From fb853e34c8f6ee3164e05931b795aafb4b7b6a63 Mon Sep 17 00:00:00 2001 From: "Morteza H. Siboni" Date: Fri, 5 Jul 2019 09:50:49 -0400 Subject: [PATCH 1/9] initial pumi examples using pyCore --- examples/pumi/ex2.py | 204 +++++++++++++++++++++++++++ examples/pumi/ex3p.py | 319 ++++++++++++++++++++++++++++++++++++++++++ examples/pumi/ex6p.py | 193 +++++++++++++++++++++++++ 3 files changed, 716 insertions(+) create mode 100644 examples/pumi/ex2.py create mode 100644 examples/pumi/ex3p.py create mode 100644 examples/pumi/ex6p.py diff --git a/examples/pumi/ex2.py b/examples/pumi/ex2.py new file mode 100644 index 00000000..6acc54fb --- /dev/null +++ b/examples/pumi/ex2.py @@ -0,0 +1,204 @@ +''' + MFEM example 2 + + See c++ version in the MFEM library for more detail +''' +import sys, getopt +import pyCore + + +# from mfem import path +import mfem.par as mfem +from mfem.par import intArray +from mfem.par import named_ifgzstream +from mfem.par import Vector +# from os.path import expanduser, join +# import numpy as np +from mfem._par.pumi import PumiMesh + + +def main(argv): + model_file = '' + mesh_file = '' + boundary_file = '' + try: + opts, args = getopt.getopt(argv,"hg:m:b:",["model=","mesh=", "boundary="]) + print opts + print args + except getopt.GetoptError: + print 'ex2.py -g -m -b ' + sys.exit(3) + for opt, arg in opts: + print opt + print arg + if opt == '-h': + print 'ex2.py -g -m -b = 0.05: + mfem_mesh.SetAttribute(el, 2) + else: + mfem_mesh.SetAttribute(el, 3) + + + mfem_mesh.SetAttributes() + if mfem_mesh.attributes.Max() < 2 or mfem_mesh.bdr_attributes.Max() < 2: + sys.exit("Input mesh should have at leaset two materials and two boundary attributes!") + + print("HERE HERE") + + order = 1 + + fec = mfem.H1_FECollection(order, dim) + fespace = mfem.FiniteElementSpace(mfem_mesh, fec, dim) + + ess_tdof_list = intArray() + ess_bdr = intArray([1]+[0]*(mfem_mesh.bdr_attributes.Max()-1)) + fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list) + + f = mfem.VectorArrayCoefficient(dim) + for i in range(dim-1): f.Set(i, mfem.ConstantCoefficient(0.0)); + + pull_force = mfem.Vector([0]*mfem_mesh.bdr_attributes.Max()) + pull_force[1] = -1.0e-2 + f.Set(dim-1, mfem.PWConstCoefficient(pull_force)) + f.Set(dim-2, mfem.PWConstCoefficient(pull_force)) + + b = mfem.LinearForm(fespace) + b.AddBoundaryIntegrator(mfem.VectorBoundaryLFIntegrator(f)) + b.Assemble() + + x = mfem.GridFunction(fespace) + x.Assign(0.0) + + lamb = mfem.Vector(mfem_mesh.attributes.Max()) + lamb.Assign(1.0) + lamb[0] = lamb[1]*10; + lamb[1] = lamb[1]*100; + lambda_func = mfem.PWConstCoefficient(lamb) + + mu = mfem.Vector(mfem_mesh.attributes.Max()) + mu.Assign(1.0); + mu[0] = mu[1]*10; + mu[1] = mu[1]*100; + mu_func = mfem.PWConstCoefficient(mu) + + a = mfem.BilinearForm(fespace) + a.AddDomainIntegrator(mfem.ElasticityIntegrator(lambda_func,mu_func)) + + print('matrix...') + static_cond = False + if (static_cond): a.EnableStaticCondensation() + a.Assemble() + + A = mfem.SparseMatrix() + B = mfem.Vector() + X = mfem.Vector() + a.FormLinearSystem(ess_tdof_list, x, b, A, X, B); + print('...done')## Here, original version calls hegith, which is not + ## defined in the header...!? + print("Size of linear system: " + str(A.Size())) + + M = mfem.GSSmoother(A) + mfem.PCG(A, M, B, X, 1, 500, 1e-8, 0.0); + + a.RecoverFEMSolution(X, b, x); + + print("HERE --- ") + + if not mfem_mesh.NURBSext: + mfem_mesh.SetNodalFESpace(fespace) + + nodes = mfem_mesh.GetNodes() + nodes += x + x *= -1 + mfem_mesh.PrintToFile('displaced.mesh', 8) + x.SaveToFile('sol.gf', 8) + + + # gmi_sim stop + pyCore.gmi_sim_stop() + + # SIMX finalization + pyCore.stop_sim() + + # gmi finalization + pyCore.PCU_Comm_Free() + + +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/examples/pumi/ex3p.py b/examples/pumi/ex3p.py new file mode 100644 index 00000000..9ca6c6ac --- /dev/null +++ b/examples/pumi/ex3p.py @@ -0,0 +1,319 @@ +''' + MFEM example 3 parallel version / using pumi/simx +''' + +import sys, getopt +import pyCore + +from mfem import path +from mfem.common.arg_parser import ArgParser +import mfem.par as mfem +from mfem.par import intArray +from mfem.par import doubleArray +from mfem._par.pumi import ParPumiMesh +from mfem._par.pumi import ParMesh2ParPumiMesh +from os.path import expanduser, join +from mpi4py import MPI +import numpy as np +from numpy import sin, array, sqrt + +model_file = '' +mesh_file = '' +order = 1 +geom_order = 1 +adapt_ratio = 0.05 +static_cond = False + +freq = 1.0 +kappa = np.pi * freq + + +class E_exact(mfem.VectorPyCoefficient): + def __init__(self): + mfem.VectorPyCoefficient.__init__(self, dim) + def EvalValue(self, x): + return (sin(kappa * x[1]), + sin(kappa * x[2]), + sin(kappa * x[0])) +class f_exact(mfem.VectorPyCoefficient): + def __init__(self): + mfem.VectorPyCoefficient.__init__(self, dim) + def EvalValue(self, x): + return ((1 + kappa**2)*sin(kappa * x[1]), + (1 + kappa**2)*sin(kappa * x[2]), + (1 + kappa**2)*sin(kappa * x[0])) + +def get_field_z(pumi_mesh, field_name, field_type, template, grid): + field_z = pyCore.createFieldOn(pumi_mesh, field_name, field_type) + dim = pumi_mesh.getDimension() + count_field = pyCore.createFieldOn(pumi_mesh, "count_field", pyCore.SCALAR) + sol_field = pyCore.createFieldOn(pumi_mesh, "sol_field", pyCore.VECTOR) + + it = pumi_mesh.begin(0) + while True: + ent = pumi_mesh.iterate(it) + if not ent: + break + pyCore.setScalar(count_field, ent, 0, 0.0) + p = pyCore.Vector3(0.0, 0.0, 0.0) + pyCore.setVector(sol_field, ent, 0, p) + pumi_mesh.end(it) + + it = pumi_mesh.begin(dim) + eid = 0 + while True: + ent = pumi_mesh.iterate(it) + if not ent: + break + + vval = mfem.DenseMatrix() + pmat = mfem.DenseMatrix() + grid.GetVectorValues(eid, template, vval, pmat) + pyCore.PCU_ALWAYS_ASSERT(vval.Width() == 4) + pyCore.PCU_ALWAYS_ASSERT(vval.Height() == 3) + + for i in range(4): + current_count = pumi_mesh.getVertScalarField(count_field, ent, i, 0) + current_sol = pumi_mesh.getVertVectorField(sol_field, ent, i, 0) + pumi_mesh.setVertScalarField(count_field, ent, i, 0, current_count + 1.0) + pumi_mesh.setVertVectorField(sol_field, ent, i, 0, current_sol.x()+vval[0,i], + current_sol.y()+vval[1,i], + current_sol.z()+vval[2,i]) + eid = eid + 1 + + pumi_mesh.end(it) + + it = pumi_mesh.begin(0) + while True: + ent = pumi_mesh.iterate(it) + if not ent: + break + current_count = pyCore.getScalar(count_field, ent, 0) + current_sol = pyCore.Vector3() + pyCore.getVector(sol_field, ent, 0, current_sol) + avg_sol = pyCore.Vector3(current_sol.x() / current_count, + current_sol.y() / current_count, + current_sol.z() / current_count) + # mag = sqrt(avg_sol.x() * avg_sol.x() + + # avg_sol.y() * avg_sol.y() + + # avg_sol.z() * avg_sol.z()) + mag = avg_sol.x() + pyCore.setScalar(field_z, ent, 0, mag) + + pumi_mesh.end(it) + pumi_mesh.removeField(count_field) + pyCore.destroyField(count_field) + pumi_mesh.removeField(sol_field) + pyCore.destroyField(sol_field) + return field_z + +def limit_refine_level(pumi_mesh, sizefield, level): + it = pumi_mesh.begin(0) + while True: + ent = pumi_mesh.iterate(it) + if not ent: + break + current_size = pumi_mesh.measureSize(ent) + computed_size = pyCore.getScalar(sizefield, ent, 0) + if computed_size < current_size / 2**level: + computed_size = current_size / 2**level + pyCore.setScalar(sizefield, ent, 0, computed_size) + pumi_mesh.end(it) + + +parser = ArgParser(description='ex3p') +parser.add_argument('-m', '--mesh', + action = 'store', type = str, + help='Mesh file to use.') +parser.add_argument('-g', '--model', + action = 'store', type = str, + help='Model file to use.') +parser.add_argument('-o', '--order', + action = 'store', default = 1, type=int, + help = 'Finite Element Order') +parser.add_argument('-go', '--geom_order', + action = 'store', default = 1, type=int, + help = 'Geometric Representation Order') +parser.add_argument('-ar', '--adapt_ratio', + action = 'store', default = 0.05, type=float, + help = "adapt ratio") + +args = parser.parse_args() +mesh_file = args.mesh +model_file = args.model +order = args.order +geom_order = args.geom_order +adapt_ratio = args.adapt_ratio + +parser.print_options(args) + +print 'Model file is "', model_file +print 'Mesh file is "', mesh_file +print 'order is "', order +print 'geom_order is "', geom_order +print 'adapt_ratio is "', adapt_ratio + + +pyCore.lion_set_verbosity(1) +pyCore.PCU_Comm_Init() + +num_proc = pyCore.PCU_Comm_Peers() +myid = pyCore.PCU_Comm_Self() +verbose = (myid == 0) + + +pyCore.start_sim('simlog.txt') + +pyCore.gmi_register_mesh() +pyCore.gmi_sim_start() +pyCore.gmi_register_sim() + +pumi_mesh = pyCore.loadMdsMesh(model_file, mesh_file) +pyCore.printStats(pumi_mesh) +pumi_mesh.verify() + +pyCore.writeASCIIVtkFiles('initial', pumi_mesh); + +dim = pumi_mesh.getDimension() + +pumi_mesh.verify() + +pmesh = ParPumiMesh(pyCore.PCU_Get_Comm(), pumi_mesh) # supposed to me of type (ParMesh) +sdim = pmesh.SpaceDimension() + +fec = mfem.ND_FECollection(order, dim) +fespace = mfem.ParFiniteElementSpace(pmesh, fec) +size = fespace.GlobalTrueVSize() + +if verbose: # note that size should be evaulated on all nodes + print("Number of finite element unknowns: " + str(size)) + +ess_tdof_list = intArray(); +if pmesh.bdr_attributes.Size(): + ess_bdr = intArray(pmesh.bdr_attributes.Max()) + ess_bdr.Assign(1) + fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list); + + + +b = mfem.ParLinearForm(fespace); +f = f_exact() +dd = mfem.VectorFEDomainLFIntegrator(f); +b.AddDomainIntegrator(dd) + +x = mfem.ParGridFunction(fespace) +E = E_exact() +x.ProjectCoefficient(E); + +muinv = mfem.ConstantCoefficient(1.0) +sigma = mfem.ConstantCoefficient(1.0) +a = mfem.ParBilinearForm(fespace) +a.AddDomainIntegrator(mfem.CurlCurlIntegrator(muinv)) +a.AddDomainIntegrator(mfem.VectorFEMassIntegrator(sigma)) + +if (static_cond): a.EnableStaticCondensation() + + +ip_cnt = 0 +vert_template = mfem.IntegrationRule(4) +ip = vert_template.IntPoint(0) +ip.Set3(0.0, 0.0, 0.0) +ip = vert_template.IntPoint(1) +ip.Set3(1.0, 0.0, 0.0) +ip = vert_template.IntPoint(2) +ip.Set3(0.0, 1.0, 0.0) +ip = vert_template.IntPoint(3) +ip.Set3(0.0, 0.0, 1.0) + + +i = 0 +error = 10.0 +while error > 0.25: + if i > 10: + break + global_dofs = fespace.GlobalTrueVSize() + if verbose: + print "AMR Iteration: ", i + print "Number of Unknowns: ", global_dofs + + a.Assemble() + b.Assemble() + + ess_tdof_list = intArray(); + if pmesh.bdr_attributes.Size(): + ess_bdr = intArray(pmesh.bdr_attributes.Max()) + ess_bdr.Assign(1) + fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list); + + A = mfem.HypreParMatrix() + B = mfem.Vector() + X = mfem.Vector() + a.FormLinearSystem(ess_tdof_list, x, b, A, X, B); + + + prec_fespace = (a.SCParFESpace() if a.StaticCondensationIsEnabled() else fespace) + ams = mfem.HypreAMS(A, prec_fespace) + pcg = mfem.HyprePCG(A) + pcg.SetTol(1e-12) + pcg.SetMaxIter(500) + pcg.SetPrintLevel(2) + pcg.SetPreconditioner(ams) + pcg.Mult(B, X) + + a.RecoverFEMSolution(X, b, x); + + err = x.ComputeL2Error(E) + if verbose: # note that err should be evaulated on all nodes + print("|| E_h - E ||_{L^2} = " + str(err)) + + + + pmesh2 = ParMesh2ParPumiMesh(pmesh) + + field_z = get_field_z(pumi_mesh, "field_z", pyCore.SCALAR, vert_template, x) + + ipfield = pyCore.getGradIPField(field_z, "mfem_gradip", 2) + sizefield = pyCore.getSPRSizeField(ipfield, adapt_ratio) + + limit_refine_level(pumi_mesh, sizefield, 1) + + pyCore.writeASCIIVtkFiles('before_adapt_' + str(i), pumi_mesh); + + pumi_mesh.removeField(ipfield) + pyCore.destroyField(ipfield); + + pyCore.destroyNumbering(pumi_mesh.findNumbering("LocalVertexNumbering")); + + + adapt_input = pyCore.configure(pumi_mesh, sizefield) + adapt_input.shouldFixShape = True + adapt_input.maximumIterations = 4 + pyCore.adapt(adapt_input) + + pyCore.writeASCIIVtkFiles('after_adapt_' + str(i), pumi_mesh); + adapted_pmesh = ParPumiMesh(pyCore.PCU_Get_Comm(), pumi_mesh) + pmesh2.UpdateMesh(adapted_pmesh) + + fespace.Update() + x.Update() + x.Assign(0) + # pmesh2.FieldPUMItoMFEM(pumi_mesh, temp_field, x) + + x.ProjectCoefficient(E); + a.Update() + b.Update() + + pumi_mesh.removeField(field_z) + pyCore.destroyField(field_z); + pumi_mesh.removeField(sizefield) + pyCore.destroyField(sizefield); + i = i+1 + + + +smyid = '{:0>6d}'.format(myid) +mesh_name = "mesh."+smyid +sol_name = "ex6-sol."+smyid + +# pmesh.PrintToFile(mesh_name, 8) +# x.SaveToFile(sol_name, 8) diff --git a/examples/pumi/ex6p.py b/examples/pumi/ex6p.py new file mode 100644 index 00000000..ea00b8a3 --- /dev/null +++ b/examples/pumi/ex6p.py @@ -0,0 +1,193 @@ +''' + MFEM example 6 + This is a version of Example 1 with a simple adaptive mesh + refinement loop. + See c++ version in the MFEM library for more detail +''' + +import sys, getopt +import pyCore + +from mfem import path +from mfem.common.arg_parser import ArgParser +import mfem.par as mfem +from mfem.par import intArray +from mfem._par.pumi import ParPumiMesh +from mfem._par.pumi import ParMesh2ParPumiMesh +from os.path import expanduser, join +from mpi4py import MPI +import numpy as np + +model_file = '' +mesh_file = '' +order = 1 +geom_order = 1 +adapt_ratio = 0.05 +static_cond = False + + +parser = ArgParser(description='ex6p') +parser.add_argument('-m', '--mesh', + action = 'store', type = str, + help='Mesh file to use.') +parser.add_argument('-g', '--model', + action = 'store', type = str, + help='Model file to use.') +parser.add_argument('-o', '--order', + action = 'store', default = 1, type=int, + help = 'Finite Element Order') +parser.add_argument('-go', '--geom_order', + action = 'store', default = 1, type=int, + help = 'Geometric Representation Order') +parser.add_argument('-ar', '--adapt_ratio', + action = 'store', default = 0.05, type=float, + help = "adapt ratio") + +args = parser.parse_args() +mesh_file = args.mesh +model_file = args.model +order = args.order +geom_order = args.geom_order +adapt_ratio = args.adapt_ratio + +parser.print_options(args) + + +print 'Model file is "', model_file +print 'Mesh file is "', mesh_file +print 'order is "', order +print 'geom_order is "', geom_order +print 'adapt_ratio is "', adapt_ratio + + +pyCore.lion_set_verbosity(1) +pyCore.PCU_Comm_Init() + +pyCore.start_sim('simlog.txt') + +pyCore.gmi_register_mesh() +pyCore.gmi_sim_start() +pyCore.gmi_register_sim() + +pumi_mesh = pyCore.loadMdsMesh(model_file, mesh_file) +pyCore.printStats(pumi_mesh) +pumi_mesh.verify() + +pyCore.writeASCIIVtkFiles('initial', pumi_mesh); + +dim = pumi_mesh.getDimension() + +ref_levels = int(np.floor(np.log(100000./pumi_mesh.count(dim))/np.log(2.)/dim)) + +if ref_levels > 2: + uniform_refine = pyCore.configureUniformRefine(pumi_mesh, 1) + pyCore.adapt(uniform_refine) + +pumi_mesh.verify() + +pyCore.writeASCIIVtkFiles('after_uniform_refine', pumi_mesh); + +num_proc = pyCore.PCU_Comm_Peers() +myid = pyCore.PCU_Comm_Self() +verbose = (myid == 0) + +pmesh = ParPumiMesh(pyCore.PCU_Get_Comm(), pumi_mesh) # supposed to me of type (ParMesh) +sdim = pmesh.SpaceDimension() + + +fec = mfem.H1_FECollection(order, dim) +fespace = mfem.ParFiniteElementSpace(pmesh, fec) + +a = mfem.ParBilinearForm(fespace) +b = mfem.ParLinearForm(fespace) + +one = mfem.ConstantCoefficient(1.0) + +integ = mfem.DiffusionIntegrator(one) +a.AddDomainIntegrator(integ) +b.AddDomainIntegrator(mfem.DomainLFIntegrator(one)) + +x = mfem.ParGridFunction(fespace) +x.Assign(0) + +if static_cond: + a.EnableStaticCondensation() + + +max_iter = 3 +for i in range(max_iter): + global_dofs = fespace.GlobalTrueVSize() + if myid == 0: + print "AMR Iteration ", i + print "Number of Unknowns ", global_dofs + + a.Assemble() + b.Assemble() + + + ess_tdof_list = intArray() + if pmesh.bdr_attributes.Size() > 0: + ess_bdr = intArray(pmesh.bdr_attributes.Max()) + ess_bdr.Assign(1) + fespace.GetEssentialTrueDofs(ess_bdr, ess_tdof_list) + + A = mfem.HypreParMatrix() + B = mfem.Vector(); X = mfem.Vector() + copy_interior = 1 + a.FormLinearSystem(ess_tdof_list, x, b, A, X, B, copy_interior) + + amg = mfem.HypreBoomerAMG() + amg.SetPrintLevel(0) + pcg = mfem.CGSolver(A.GetComm()) + pcg.SetPreconditioner(amg) + pcg.SetOperator(A) + pcg.SetRelTol(1e-6) + pcg.SetMaxIter(200) + pcg.SetPrintLevel(3) + pcg.Mult(B, X) + + a.RecoverFEMSolution(X, b, x); + + tmag_field = pyCore.createFieldOn(pumi_mesh, "field_mag", pyCore.SCALAR) + temp_field = pyCore.createFieldOn(pumi_mesh, "temp_field", pyCore.SCALAR) + + pmesh2 = ParMesh2ParPumiMesh(pmesh) + pmesh2.FieldMFEMtoPUMI(pumi_mesh, x, temp_field, tmag_field) + + ipfield = pyCore.getGradIPField(tmag_field, "mfem_gradip", 2) + sizefield = pyCore.getSPRSizeField(ipfield, adapt_ratio) + + + pyCore.writeASCIIVtkFiles('before_adapt_' + str(i), pumi_mesh); + + pyCore.destroyField(ipfield); + + adapt_input = pyCore.configure(pumi_mesh, sizefield) + adapt_input.shouldFixShape = True + adapt_input.maximumIterations = 2 + pyCore.adapt(adapt_input) + + pyCore.writeASCIIVtkFiles('after_adapt_' + str(i), pumi_mesh); + adapted_pmesh = ParPumiMesh(pyCore.PCU_Get_Comm(), pumi_mesh) + pmesh2.UpdateMesh(adapted_pmesh) + + fespace.Update() + x.Update() + x.Assign(0) + pmesh2.FieldPUMItoMFEM(pumi_mesh, temp_field, x) + + a.Update() + b.Update() + + pyCore.destroyField(temp_field); + pyCore.destroyField(tmag_field); + pyCore.destroyField(sizefield); + + + +smyid = '{:0>6d}'.format(myid) +mesh_name = "mesh."+smyid +sol_name = "ex6-sol."+smyid + +pmesh.PrintToFile(mesh_name, 8) +x.SaveToFile(sol_name, 8) From 3a9bc3ae2ce9c3a75e2ffa8ee38384c399fed174 Mon Sep 17 00:00:00 2001 From: Syun'ichi Shiraiwa Date: Wed, 18 Dec 2019 07:51:30 -0500 Subject: [PATCH 2/9] enforeced to run swig wiht pumi on to generate a wrapper code --- mfem/_par/pumi.i | 8 + mfem/_par/pumi.py | 73 +- mfem/_par/pumi_wrap.cxx | 1725 +++++++++++++++++++++++++++++++++++++-- 3 files changed, 1752 insertions(+), 54 deletions(-) diff --git a/mfem/_par/pumi.i b/mfem/_par/pumi.i index 4b63438a..edd0eb18 100644 --- a/mfem/_par/pumi.i +++ b/mfem/_par/pumi.i @@ -23,6 +23,14 @@ %include "../common/mfem_config.i" +#ifndef MFEM_USE_MPI + #define MFEM_USE_MPI YES +#endif + +#ifndef MFEM_USE_PUMI + #define MFEM_USE_PUMI YES +#endif + #ifdef MFEM_USE_MPI %include mpi4py/mpi4py.i %mpi4py_typemap(Comm, MPI_Comm); diff --git a/mfem/_par/pumi.py b/mfem/_par/pumi.py index 17ba076f..2ccf3c89 100644 --- a/mfem/_par/pumi.py +++ b/mfem/_par/pumi.py @@ -191,7 +191,78 @@ def doublep_frompointer(t): import mfem._par.sets def ParMesh2ParPumiMesh(pmesh): - r"""ParMesh2ParPumiMesh(ParMesh pmesh) -> mfem::ParPumiMesh *""" + r"""ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh""" return _pumi.ParMesh2ParPumiMesh(pmesh) +class PumiMesh(mfem._par.mesh.Mesh): + r"""Proxy of C++ mfem::PumiMesh class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, apf_mesh, generate_edges=0, refine=1, fix_orientation=True): + r"""__init__(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True) -> PumiMesh""" + _pumi.PumiMesh_swiginit(self, _pumi.new_PumiMesh(apf_mesh, generate_edges, refine, fix_orientation)) + + def Load(self, *args): + r""" + Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True) + Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1) + Load(PumiMesh self, std::istream & input, int generate_edges=0) + Load(PumiMesh self, std::istream & input) + Load(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True) + """ + return _pumi.PumiMesh_Load(self, *args) + __swig_destroy__ = _pumi.delete_PumiMesh + +# Register PumiMesh in _pumi: +_pumi.PumiMesh_swigregister(PumiMesh) + +class ParPumiMesh(mfem._par.pmesh.ParMesh): + r"""Proxy of C++ mfem::ParPumiMesh class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, comm, apf_mesh): + r"""__init__(ParPumiMesh self, MPI_Comm comm, apf::Mesh2 * apf_mesh) -> ParPumiMesh""" + _pumi.ParPumiMesh_swiginit(self, _pumi.new_ParPumiMesh(comm, apf_mesh)) + + def FieldMFEMtoPUMI(self, *args): + r""" + FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, ParGridFunction Pr, apf::Field * VelField, apf::Field * PrField, apf::Field * VelMagField) + FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Pr, apf::Field * PrField, apf::Field * PrMagField) + """ + return _pumi.ParPumiMesh_FieldMFEMtoPUMI(self, *args) + + def VectorFieldMFEMtoPUMI(self, apf_mesh, Vel, VelField, VelMagField): + r"""VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)""" + return _pumi.ParPumiMesh_VectorFieldMFEMtoPUMI(self, apf_mesh, Vel, VelField, VelMagField) + + def UpdateMesh(self, AdaptedpMesh): + r"""UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)""" + return _pumi.ParPumiMesh_UpdateMesh(self, AdaptedpMesh) + + def FieldPUMItoMFEM(self, apf_mesh, ScalarField, Pr): + r"""FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)""" + return _pumi.ParPumiMesh_FieldPUMItoMFEM(self, apf_mesh, ScalarField, Pr) + __swig_destroy__ = _pumi.delete_ParPumiMesh + +# Register ParPumiMesh in _pumi: +_pumi.ParPumiMesh_swigregister(ParPumiMesh) + +class GridFunctionPumi(mfem._par.gridfunc.GridFunction): + r"""Proxy of C++ mfem::GridFunctionPumi class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, m, PumiM, v_num_loc, mesh_order): + r"""__init__(GridFunctionPumi self, Mesh m, apf::Mesh2 * PumiM, apf::Numbering * v_num_loc, int const mesh_order) -> GridFunctionPumi""" + _pumi.GridFunctionPumi_swiginit(self, _pumi.new_GridFunctionPumi(m, PumiM, v_num_loc, mesh_order)) + __swig_destroy__ = _pumi.delete_GridFunctionPumi + +# Register GridFunctionPumi in _pumi: +_pumi.GridFunctionPumi_swigregister(GridFunctionPumi) + diff --git a/mfem/_par/pumi_wrap.cxx b/mfem/_par/pumi_wrap.cxx index 0e4cd457..dac0ac30 100644 --- a/mfem/_par/pumi_wrap.cxx +++ b/mfem/_par/pumi_wrap.cxx @@ -3069,26 +3069,37 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_double swig_types[5] -#define SWIGTYPE_p_doublep swig_types[6] -#define SWIGTYPE_p_hex_t swig_types[7] -#define SWIGTYPE_p_int swig_types[8] -#define SWIGTYPE_p_intp swig_types[9] -#define SWIGTYPE_p_mfem__GridFunction swig_types[10] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[11] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[12] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[13] -#define SWIGTYPE_p_mfem__ParGridFunction swig_types[14] -#define SWIGTYPE_p_mfem__ParMesh swig_types[15] -#define SWIGTYPE_p_mfem__ParPumiMesh swig_types[16] -#define SWIGTYPE_p_pri_t swig_types[17] -#define SWIGTYPE_p_quad_t swig_types[18] -#define SWIGTYPE_p_seg_t swig_types[19] -#define SWIGTYPE_p_tet_t swig_types[20] -#define SWIGTYPE_p_tri_t swig_types[21] -static swig_type_info *swig_types[23]; -static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0}; +#define SWIGTYPE_p_apf__Field swig_types[4] +#define SWIGTYPE_p_apf__Mesh2 swig_types[5] +#define SWIGTYPE_p_apf__Numbering swig_types[6] +#define SWIGTYPE_p_char swig_types[7] +#define SWIGTYPE_p_double swig_types[8] +#define SWIGTYPE_p_doublep swig_types[9] +#define SWIGTYPE_p_hex_t swig_types[10] +#define SWIGTYPE_p_int swig_types[11] +#define SWIGTYPE_p_intp swig_types[12] +#define SWIGTYPE_p_mfem__GridFunction swig_types[13] +#define SWIGTYPE_p_mfem__GridFunctionPumi swig_types[14] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[15] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[16] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[17] +#define SWIGTYPE_p_mfem__LinearForm swig_types[18] +#define SWIGTYPE_p_mfem__Mesh swig_types[19] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[20] +#define SWIGTYPE_p_mfem__ParGridFunction swig_types[21] +#define SWIGTYPE_p_mfem__ParMesh swig_types[22] +#define SWIGTYPE_p_mfem__ParPumiMesh swig_types[23] +#define SWIGTYPE_p_mfem__PumiMesh swig_types[24] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[25] +#define SWIGTYPE_p_mfem__Vector swig_types[26] +#define SWIGTYPE_p_pri_t swig_types[27] +#define SWIGTYPE_p_quad_t swig_types[28] +#define SWIGTYPE_p_seg_t swig_types[29] +#define SWIGTYPE_p_std__istream swig_types[30] +#define SWIGTYPE_p_tet_t swig_types[31] +#define SWIGTYPE_p_tri_t swig_types[32] +static swig_type_info *swig_types[34]; +static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3466,6 +3477,39 @@ SWIGINTERN doublep *doublep_frompointer(double *t){ } +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + +SWIGINTERN int +SWIG_AsPtr_MPI_Comm (PyObject * input, MPI_Comm **p) { + if (input == Py_None) { + if (p) *p = NULL; + return SWIG_OK; + } else if (PyObject_TypeCheck(input,&PyMPIComm_Type)) { + if (p) *p = PyMPIComm_Get(input); + return SWIG_OK; + } else { + void *argp = NULL; + int res = SWIG_ConvertPtr(input,&argp,SWIGTYPE_p_MPI_Comm, 0); + if (!SWIG_IsOK(res)) return res; + if (!argp) return SWIG_ValueError; + if (p) *p = static_cast< MPI_Comm* >(argp); + return SWIG_OK; + } +} + + /* --------------------------------------------------- * C++ director class methods @@ -3794,40 +3838,1571 @@ SWIGINTERN PyObject *_wrap_ParMesh2ParPumiMesh(PyObject *SWIGUNUSEDPARM(self), P } -static PyMethodDef SwigMethods[] = { - { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, - { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, - { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, "intp_assign(intp self, int value)"}, - { "intp_value", _wrap_intp_value, METH_O, "intp_value(intp self) -> int"}, - { "intp_cast", _wrap_intp_cast, METH_O, "intp_cast(intp self) -> int *"}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, "intp_frompointer(int * t) -> intp"}, - { "intp_swigregister", intp_swigregister, METH_O, NULL}, - { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, - { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, - { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "doublep_assign(doublep self, double value)"}, - { "doublep_value", _wrap_doublep_value, METH_O, "doublep_value(doublep self) -> double"}, - { "doublep_cast", _wrap_doublep_cast, METH_O, "doublep_cast(doublep self) -> double *"}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "doublep_frompointer(double * t) -> doublep"}, - { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, - { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, - { "ParMesh2ParPumiMesh", _wrap_ParMesh2ParPumiMesh, METH_O, "ParMesh2ParPumiMesh(ParMesh pmesh) -> mfem::ParPumiMesh *"}, - { NULL, NULL, 0, NULL } -}; +SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; + int arg2 ; + int arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + mfem::PumiMesh *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); + } + arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PumiMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + { + try { + result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} -static PyMethodDef SwigMethods_proxydocs[] = { - { NULL, NULL, 0, NULL } -}; + +SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::PumiMesh *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); + } + arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ +SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::PumiMesh *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); + } + arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} -static void *_p_mfem__ParGridFunctionTo_p_mfem__GridFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::GridFunction *) ((mfem::ParGridFunction *) x)); + +SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::PumiMesh *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); + } + arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); + { + try { + result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; } -static void *_p_intpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((int *) ((intp *) x)); + + +SWIGINTERN PyObject *_wrap_new_PumiMesh(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_PumiMesh", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_PumiMesh__SWIG_3(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_PumiMesh__SWIG_2(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_PumiMesh__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_PumiMesh__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PumiMesh'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::PumiMesh::PumiMesh(apf::Mesh2 *,int,int,bool)\n" + " mfem::PumiMesh::PumiMesh(apf::Mesh2 *,int,int)\n" + " mfem::PumiMesh::PumiMesh(apf::Mesh2 *,int)\n" + " mfem::PumiMesh::PumiMesh(apf::Mesh2 *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + std::istream *arg2 = 0 ; + int arg3 ; + int arg4 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val5 ; + int ecode5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PumiMesh_Load" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + { + try { + (arg1)->Load(*arg2,arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + std::istream *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->Load(*arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + std::istream *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->Load(*arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + std::istream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + { + try { + (arg1)->Load(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + int arg3 ; + int arg4 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val5 ; + int ecode5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PumiMesh_Load" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + { + try { + (arg1)->Load(arg2,arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->Load(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->Load(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + { + try { + (arg1)->Load(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "PumiMesh_Load", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_PumiMesh_Load__SWIG_0_3(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_PumiMesh_Load__SWIG_4(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_PumiMesh_Load__SWIG_3(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_PumiMesh_Load__SWIG_0_2(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_PumiMesh_Load__SWIG_0_1(self, argc, argv); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_PumiMesh_Load__SWIG_2(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_PumiMesh_Load__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_PumiMesh_Load__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PumiMesh_Load'.\n" + " Possible C/C++ prototypes are:\n" + " Load(std::istream &,int,int,bool)\n" + " Load(std::istream &,int,int)\n" + " Load(std::istream &,int)\n" + " Load(std::istream &)\n" + " mfem::PumiMesh::Load(apf::Mesh2 *,int,int,bool)\n" + " mfem::PumiMesh::Load(apf::Mesh2 *,int,int)\n" + " mfem::PumiMesh::Load(apf::Mesh2 *,int)\n" + " mfem::PumiMesh::Load(apf::Mesh2 *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_PumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PumiMesh" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *PumiMesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__PumiMesh, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *PumiMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ParPumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + MPI_Comm arg1 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::ParPumiMesh *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ParPumiMesh", 2, 2, swig_obj)) SWIG_fail; + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParPumiMesh" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParPumiMesh" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + { + try { + result = (mfem::ParPumiMesh *)new mfem::ParPumiMesh(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParPumiMesh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldMFEMtoPUMI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + mfem::ParGridFunction *arg3 = (mfem::ParGridFunction *) 0 ; + mfem::ParGridFunction *arg4 = (mfem::ParGridFunction *) 0 ; + apf::Field *arg5 = (apf::Field *) 0 ; + apf::Field *arg6 = (apf::Field *) 0 ; + apf::Field *arg7 = (apf::Field *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "3"" of type '" "mfem::ParGridFunction *""'"); + } + arg3 = reinterpret_cast< mfem::ParGridFunction * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "4"" of type '" "mfem::ParGridFunction *""'"); + } + arg4 = reinterpret_cast< mfem::ParGridFunction * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "5"" of type '" "apf::Field *""'"); + } + arg5 = reinterpret_cast< apf::Field * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "6"" of type '" "apf::Field *""'"); + } + arg6 = reinterpret_cast< apf::Field * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "7"" of type '" "apf::Field *""'"); + } + arg7 = reinterpret_cast< apf::Field * >(argp7); + { + try { + (arg1)->FieldMFEMtoPUMI(arg2,arg3,arg4,arg5,arg6,arg7); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldMFEMtoPUMI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + mfem::ParGridFunction *arg3 = (mfem::ParGridFunction *) 0 ; + apf::Field *arg4 = (apf::Field *) 0 ; + apf::Field *arg5 = (apf::Field *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "3"" of type '" "mfem::ParGridFunction *""'"); + } + arg3 = reinterpret_cast< mfem::ParGridFunction * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "4"" of type '" "apf::Field *""'"); + } + arg4 = reinterpret_cast< apf::Field * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParPumiMesh_FieldMFEMtoPUMI" "', argument " "5"" of type '" "apf::Field *""'"); + } + arg5 = reinterpret_cast< apf::Field * >(argp5); + { + try { + (arg1)->FieldMFEMtoPUMI(arg2,arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldMFEMtoPUMI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ParPumiMesh_FieldMFEMtoPUMI", 0, 7, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParPumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_apf__Field, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_apf__Field, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ParPumiMesh_FieldMFEMtoPUMI__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParPumiMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_apf__Field, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_apf__Field, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_apf__Field, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ParPumiMesh_FieldMFEMtoPUMI__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParPumiMesh_FieldMFEMtoPUMI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParPumiMesh::FieldMFEMtoPUMI(apf::Mesh2 *,mfem::ParGridFunction *,mfem::ParGridFunction *,apf::Field *,apf::Field *,apf::Field *)\n" + " mfem::ParPumiMesh::FieldMFEMtoPUMI(apf::Mesh2 *,mfem::ParGridFunction *,apf::Field *,apf::Field *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ParPumiMesh_VectorFieldMFEMtoPUMI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + mfem::ParGridFunction *arg3 = (mfem::ParGridFunction *) 0 ; + apf::Field *arg4 = (apf::Field *) 0 ; + apf::Field *arg5 = (apf::Field *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "ParPumiMesh_VectorFieldMFEMtoPUMI", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "3"" of type '" "mfem::ParGridFunction *""'"); + } + arg3 = reinterpret_cast< mfem::ParGridFunction * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "4"" of type '" "apf::Field *""'"); + } + arg4 = reinterpret_cast< apf::Field * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "5"" of type '" "apf::Field *""'"); + } + arg5 = reinterpret_cast< apf::Field * >(argp5); + { + try { + (arg1)->VectorFieldMFEMtoPUMI(arg2,arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParPumiMesh_UpdateMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; + mfem::ParMesh *arg2 = (mfem::ParMesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "ParPumiMesh_UpdateMesh", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_UpdateMesh" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_UpdateMesh" "', argument " "2"" of type '" "mfem::ParMesh const *""'"); + } + arg2 = reinterpret_cast< mfem::ParMesh * >(argp2); + { + try { + (arg1)->UpdateMesh((mfem::ParMesh const *)arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldPUMItoMFEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + apf::Field *arg3 = (apf::Field *) 0 ; + mfem::ParGridFunction *arg4 = (mfem::ParGridFunction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "ParPumiMesh_FieldPUMItoMFEM", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_apf__Field, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "3"" of type '" "apf::Field *""'"); + } + arg3 = reinterpret_cast< apf::Field * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "4"" of type '" "mfem::ParGridFunction *""'"); + } + arg4 = reinterpret_cast< mfem::ParGridFunction * >(argp4); + { + try { + (arg1)->FieldPUMItoMFEM(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ParPumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParPumiMesh" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ParPumiMesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ParPumiMesh, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ParPumiMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GridFunctionPumi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + apf::Numbering *arg3 = (apf::Numbering *) 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[4] ; + mfem::GridFunctionPumi *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_GridFunctionPumi", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunctionPumi" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridFunctionPumi" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + } + arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_apf__Numbering, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridFunctionPumi" "', argument " "3"" of type '" "apf::Numbering *""'"); + } + arg3 = reinterpret_cast< apf::Numbering * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + result = (mfem::GridFunctionPumi *)new mfem::GridFunctionPumi(arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunctionPumi, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GridFunctionPumi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GridFunctionPumi *arg1 = (mfem::GridFunctionPumi *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunctionPumi, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridFunctionPumi" "', argument " "1"" of type '" "mfem::GridFunctionPumi *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunctionPumi * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GridFunctionPumi_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GridFunctionPumi, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GridFunctionPumi_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, + { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, "intp_assign(intp self, int value)"}, + { "intp_value", _wrap_intp_value, METH_O, "intp_value(intp self) -> int"}, + { "intp_cast", _wrap_intp_cast, METH_O, "intp_cast(intp self) -> int *"}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, "intp_frompointer(int * t) -> intp"}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, + { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "doublep_assign(doublep self, double value)"}, + { "doublep_value", _wrap_doublep_value, METH_O, "doublep_value(doublep self) -> double"}, + { "doublep_cast", _wrap_doublep_cast, METH_O, "doublep_cast(doublep self) -> double *"}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "doublep_frompointer(double * t) -> doublep"}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "ParMesh2ParPumiMesh", _wrap_ParMesh2ParPumiMesh, METH_O, "ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh"}, + { "new_PumiMesh", _wrap_new_PumiMesh, METH_VARARGS, "PumiMesh(apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "PumiMesh_Load", _wrap_PumiMesh_Load, METH_VARARGS, "\n" + "PumiMesh_Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + "PumiMesh_Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1)\n" + "PumiMesh_Load(PumiMesh self, std::istream & input, int generate_edges=0)\n" + "PumiMesh_Load(PumiMesh self, std::istream & input)\n" + "PumiMesh_Load(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + ""}, + { "delete_PumiMesh", _wrap_delete_PumiMesh, METH_O, "delete_PumiMesh(PumiMesh self)"}, + { "PumiMesh_swigregister", PumiMesh_swigregister, METH_O, NULL}, + { "PumiMesh_swiginit", PumiMesh_swiginit, METH_VARARGS, NULL}, + { "new_ParPumiMesh", _wrap_new_ParPumiMesh, METH_VARARGS, "new_ParPumiMesh(MPI_Comm comm, apf::Mesh2 * apf_mesh) -> ParPumiMesh"}, + { "ParPumiMesh_FieldMFEMtoPUMI", _wrap_ParPumiMesh_FieldMFEMtoPUMI, METH_VARARGS, "\n" + "ParPumiMesh_FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, ParGridFunction Pr, apf::Field * VelField, apf::Field * PrField, apf::Field * VelMagField)\n" + "ParPumiMesh_FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Pr, apf::Field * PrField, apf::Field * PrMagField)\n" + ""}, + { "ParPumiMesh_VectorFieldMFEMtoPUMI", _wrap_ParPumiMesh_VectorFieldMFEMtoPUMI, METH_VARARGS, "ParPumiMesh_VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)"}, + { "ParPumiMesh_UpdateMesh", _wrap_ParPumiMesh_UpdateMesh, METH_VARARGS, "ParPumiMesh_UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)"}, + { "ParPumiMesh_FieldPUMItoMFEM", _wrap_ParPumiMesh_FieldPUMItoMFEM, METH_VARARGS, "ParPumiMesh_FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)"}, + { "delete_ParPumiMesh", _wrap_delete_ParPumiMesh, METH_O, "delete_ParPumiMesh(ParPumiMesh self)"}, + { "ParPumiMesh_swigregister", ParPumiMesh_swigregister, METH_O, NULL}, + { "ParPumiMesh_swiginit", ParPumiMesh_swiginit, METH_VARARGS, NULL}, + { "new_GridFunctionPumi", _wrap_new_GridFunctionPumi, METH_VARARGS, "new_GridFunctionPumi(Mesh m, apf::Mesh2 * PumiM, apf::Numbering * v_num_loc, int const mesh_order) -> GridFunctionPumi"}, + { "delete_GridFunctionPumi", _wrap_delete_GridFunctionPumi, METH_O, "delete_GridFunctionPumi(GridFunctionPumi self)"}, + { "GridFunctionPumi_swigregister", GridFunctionPumi_swigregister, METH_O, NULL}, + { "GridFunctionPumi_swiginit", GridFunctionPumi_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_mfem__HypreParVectorTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::HypreParVector *) x)); +} +static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); +} +static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); +} +static void *_p_mfem__ParGridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) (mfem::GridFunction *) ((mfem::ParGridFunction *) x)); +} +static void *_p_mfem__GridFunctionPumiTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) (mfem::GridFunction *) ((mfem::GridFunctionPumi *) x)); +} +static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); +} +static void *_p_mfem__ParPumiMeshTo_p_mfem__ParMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ParMesh *) ((mfem::ParPumiMesh *) x)); +} +static void *_p_mfem__ParGridFunctionTo_p_mfem__GridFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GridFunction *) ((mfem::ParGridFunction *) x)); +} +static void *_p_mfem__GridFunctionPumiTo_p_mfem__GridFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GridFunction *) ((mfem::GridFunctionPumi *) x)); +} +static void *_p_intpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((int *) ((intp *) x)); +} +static void *_p_mfem__ParMeshTo_p_mfem__Mesh(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Mesh *) ((mfem::ParMesh *) x)); +} +static void *_p_mfem__PumiMeshTo_p_mfem__Mesh(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Mesh *) ((mfem::PumiMesh *) x)); +} +static void *_p_mfem__ParPumiMeshTo_p_mfem__Mesh(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Mesh *) (mfem::ParMesh *) ((mfem::ParPumiMesh *) x)); } static void *_p_doublepTo_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((double *) ((doublep *) x)); @@ -3836,6 +5411,9 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_apf__Field = {"_p_apf__Field", "apf::Field *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_apf__Mesh2 = {"_p_apf__Mesh2", "apf::Mesh2 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_apf__Numbering = {"_p_apf__Numbering", "apf::Numbering *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; @@ -3843,15 +5421,23 @@ static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__ParGridFunction = {"_p_mfem__ParGridFunction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GridFunctionPumi = {"_p_mfem__GridFunctionPumi", "mfem::GridFunctionPumi *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__IntegrationRule = {"_p_mfem__IntegrationRule", "mfem::IntegrationRule *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollection", "mfem::L2_FECollection *|mfem::DG_FECollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Mesh = {"_p_mfem__Mesh", "mfem::Mesh *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ParGridFunction = {"_p_mfem__ParGridFunction", "mfem::ParGridFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ParMesh = {"_p_mfem__ParMesh", "mfem::ParMesh *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ParPumiMesh = {"_p_mfem__ParPumiMesh", "mfem::ParPumiMesh *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__PumiMesh = {"_p_mfem__PumiMesh", "mfem::PumiMesh *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__HypreParVector = {"_p_mfem__HypreParVector", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; @@ -3860,6 +5446,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_apf__Field, + &_swigt__p_apf__Mesh2, + &_swigt__p_apf__Numbering, &_swigt__p_char, &_swigt__p_double, &_swigt__p_doublep, @@ -3867,15 +5456,23 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_int, &_swigt__p_intp, &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__GridFunctionPumi, + &_swigt__p_mfem__HypreParVector, &_swigt__p_mfem__IntegrationRule, &_swigt__p_mfem__L2_FECollection, + &_swigt__p_mfem__LinearForm, + &_swigt__p_mfem__Mesh, &_swigt__p_mfem__OperatorHandle, &_swigt__p_mfem__ParGridFunction, &_swigt__p_mfem__ParMesh, &_swigt__p_mfem__ParPumiMesh, + &_swigt__p_mfem__PumiMesh, + &_swigt__p_mfem__QuadratureFunction, + &_swigt__p_mfem__Vector, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, + &_swigt__p_std__istream, &_swigt__p_tet_t, &_swigt__p_tri_t, }; @@ -3884,22 +5481,33 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_apf__Field[] = { {&_swigt__p_apf__Field, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_apf__Mesh2[] = { {&_swigt__p_apf__Mesh2, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_apf__Numbering[] = { {&_swigt__p_apf__Numbering, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0}, {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_intp, _p_intpTo_p_int, 0, 0}, {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ParGridFunction[] = {{&_swigt__p_mfem__ParGridFunction, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0}, {&_swigt__p_mfem__ParGridFunction, _p_mfem__ParGridFunctionTo_p_mfem__GridFunction, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0}, {&_swigt__p_mfem__ParGridFunction, _p_mfem__ParGridFunctionTo_p_mfem__GridFunction, 0, 0}, {&_swigt__p_mfem__GridFunctionPumi, _p_mfem__GridFunctionPumiTo_p_mfem__GridFunction, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GridFunctionPumi[] = { {&_swigt__p_mfem__GridFunctionPumi, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Mesh[] = { {&_swigt__p_mfem__ParMesh, _p_mfem__ParMeshTo_p_mfem__Mesh, 0, 0}, {&_swigt__p_mfem__ParPumiMesh, _p_mfem__ParPumiMeshTo_p_mfem__Mesh, 0, 0}, {&_swigt__p_mfem__PumiMesh, _p_mfem__PumiMeshTo_p_mfem__Mesh, 0, 0}, {&_swigt__p_mfem__Mesh, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ParMesh[] = { {&_swigt__p_mfem__ParMesh, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ParGridFunction[] = { {&_swigt__p_mfem__ParGridFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ParMesh[] = { {&_swigt__p_mfem__ParMesh, 0, 0, 0}, {&_swigt__p_mfem__ParPumiMesh, _p_mfem__ParPumiMeshTo_p_mfem__ParMesh, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParPumiMesh[] = { {&_swigt__p_mfem__ParPumiMesh, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PumiMesh[] = { {&_swigt__p_mfem__PumiMesh, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__HypreParVector, _p_mfem__HypreParVectorTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__ParGridFunction, _p_mfem__ParGridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__GridFunctionPumi, _p_mfem__GridFunctionPumiTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -3908,6 +5516,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_apf__Field, + _swigc__p_apf__Mesh2, + _swigc__p_apf__Numbering, _swigc__p_char, _swigc__p_double, _swigc__p_doublep, @@ -3915,15 +5526,23 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_int, _swigc__p_intp, _swigc__p_mfem__GridFunction, + _swigc__p_mfem__GridFunctionPumi, + _swigc__p_mfem__HypreParVector, _swigc__p_mfem__IntegrationRule, _swigc__p_mfem__L2_FECollection, + _swigc__p_mfem__LinearForm, + _swigc__p_mfem__Mesh, _swigc__p_mfem__OperatorHandle, _swigc__p_mfem__ParGridFunction, _swigc__p_mfem__ParMesh, _swigc__p_mfem__ParPumiMesh, + _swigc__p_mfem__PumiMesh, + _swigc__p_mfem__QuadratureFunction, + _swigc__p_mfem__Vector, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, + _swigc__p_std__istream, _swigc__p_tet_t, _swigc__p_tri_t, }; From caf0d90b8ed02a15ea200138a385abd438a50499 Mon Sep 17 00:00:00 2001 From: Syun'ichi Shiraiwa Date: Sun, 26 Jan 2020 15:27:18 +0900 Subject: [PATCH 3/9] support using Python native objects in VectorConstantCoefficient/MatrixConstantCoefficient --- README | 7 +++++++ mfem/__init__.py | 2 +- mfem/_par/coefficient.i | 31 ++++++++++++++++++++++++++++- mfem/_par/coefficient.py | 31 +++++++++++++++++++++++++++++ mfem/_ser/coefficient.i | 42 ++++++++++++++++++++++++++++++++++------ mfem/_ser/coefficient.py | 31 +++++++++++++++++++++++++++++ 6 files changed, 136 insertions(+), 8 deletions(-) diff --git a/README b/README index 1815d2e5..b9d41171 100644 --- a/README +++ b/README @@ -102,6 +102,13 @@ to find more detail of the MFEM libirary. Therefore, if one overwrite Eval method, SWIG reroute the call to the Python side. + V/M ConstantCoefficeint supports natrual python object as input + MatrixConstantCoefficient([[1,2], [2,3]]) + VecotrConstantCoefficient([1,2,3]) + + Note: thie argument is first tested if it can be converted using + np.array(x, dtype=float) + 4-3) mfem::GridFunction GetNodalValues(i) will perform GetNodalValue(Vector(), i) and return numpy array of Vector() diff --git a/mfem/__init__.py b/mfem/__init__.py index 27846eba..78069335 100644 --- a/mfem/__init__.py +++ b/mfem/__init__.py @@ -20,5 +20,5 @@ def debug_print(message): print(message) -__version__ = '4.0.1' +__version__ = '4.0.2' diff --git a/mfem/_par/coefficient.i b/mfem/_par/coefficient.i index 26ea9809..10f086ea 100644 --- a/mfem/_par/coefficient.i +++ b/mfem/_par/coefficient.i @@ -57,7 +57,36 @@ import_array(); %feature("notabstract") MatrixFunctionCoefficient; %feature("notabstract") MatrixConstantCoefficient; -namespace mfem { +namespace mfem { +%pythonprepend MatrixConstantCoefficient::MatrixConstantCoefficient(const DenseMatrix &m) %{ + try: + import numpy as np + value = np.array(m, copy=False, dtype=float) + can_np_array = True + except: + can_np_array = False + + if can_np_array: + v = mfem._par.vector.Vector(np.transpose(value).flatten()) + m = mfem._par.densemat.DenseMatrix(v.GetData(), value.shape[0], value.shape[1]) + self._value = (v,m) + else: + pass +%} +%pythonprepend VectorConstantCoefficient::VectorConstantCoefficient(const Vector &v) %{ + try: + import numpy as np + value = np.array(v, copy=False, dtype=float).flatten() + can_np_array = True + except: + can_np_array = False + + if can_np_array: + v = mfem._par.vector.Vector(value) + self._value = v + else: + pass +%} %pythonprepend DeltaCoefficient::SetWeight %{ w.thisown=0 %} diff --git a/mfem/_par/coefficient.py b/mfem/_par/coefficient.py index 64027220..02f2e6ca 100644 --- a/mfem/_par/coefficient.py +++ b/mfem/_par/coefficient.py @@ -386,6 +386,21 @@ class VectorConstantCoefficient(VectorCoefficient): def __init__(self, v): r"""__init__(VectorConstantCoefficient self, Vector v) -> VectorConstantCoefficient""" + + try: + import numpy as np + value = np.array(v, copy=False, dtype=float).flatten() + can_np_array = True + except: + can_np_array = False + + if can_np_array: + v = mfem._par.vector.Vector(value) + self._value = v + else: + pass + + _coefficient.VectorConstantCoefficient_swiginit(self, _coefficient.new_VectorConstantCoefficient(v)) def Eval(self, *args): @@ -708,6 +723,22 @@ class MatrixConstantCoefficient(MatrixCoefficient): def __init__(self, m): r"""__init__(MatrixConstantCoefficient self, DenseMatrix m) -> MatrixConstantCoefficient""" + + try: + import numpy as np + value = np.array(m, copy=False, dtype=float) + can_np_array = True + except: + can_np_array = False + + if can_np_array: + v = mfem._par.vector.Vector(np.transpose(value).flatten()) + m = mfem._par.densemat.DenseMatrix(v.GetData(), value.shape[0], value.shape[1]) + self._value = (v,m) + else: + pass + + _coefficient.MatrixConstantCoefficient_swiginit(self, _coefficient.new_MatrixConstantCoefficient(m)) def Eval(self, *args): diff --git a/mfem/_ser/coefficient.i b/mfem/_ser/coefficient.i index adc54083..1212d780 100644 --- a/mfem/_ser/coefficient.i +++ b/mfem/_ser/coefficient.i @@ -49,13 +49,36 @@ import_array(); %ignore Function; //%ignore DeltaCoefficient; -%feature("notabstract") VectorFunctionCoefficient; -%feature("notabstract") VectorConstantCoefficient; -%feature("notabstract") VectorDeltaCoefficient; -%feature("notabstract") MatrixFunctionCoefficient; -%feature("notabstract") MatrixConstantCoefficient; +namespace mfem { +%pythonprepend MatrixConstantCoefficient::MatrixConstantCoefficient(const DenseMatrix &m) %{ + try: + import numpy as np + value = np.array(m, copy=False, dtype=float) + can_np_array = True + except: + can_np_array = False -namespace mfem { + if can_np_array: + v = mfem._ser.vector.Vector(np.transpose(value).flatten()) + m = mfem._ser.densemat.DenseMatrix(v.GetData(), value.shape[0], value.shape[1]) + self._value = (v,m) + else: + pass +%} +%pythonprepend VectorConstantCoefficient::VectorConstantCoefficient(const Vector &v) %{ + try: + import numpy as np + value = np.array(v, copy=False, dtype=float).flatten() + can_np_array = True + except: + can_np_array = False + + if can_np_array: + v = mfem._ser.vector.Vector(value) + self._value = v + else: + pass +%} %pythonprepend DeltaCoefficient::SetWeight %{ w.thisown=0 %} @@ -77,6 +100,13 @@ namespace mfem { } +%feature("notabstract") mfem::VectorFunctionCoefficient; +%feature("notabstract") mfem::VectorConstantCoefficient; +%feature("notabstract") mfem::VectorDeltaCoefficient; +%feature("notabstract") mfem::MatrixFunctionCoefficient; +%feature("notabstract") mfem::MatrixConstantCoefficient; + + /* %exception { try { $action } diff --git a/mfem/_ser/coefficient.py b/mfem/_ser/coefficient.py index ce87ee1d..c0b6df52 100644 --- a/mfem/_ser/coefficient.py +++ b/mfem/_ser/coefficient.py @@ -362,6 +362,21 @@ class VectorConstantCoefficient(VectorCoefficient): def __init__(self, v): r"""__init__(VectorConstantCoefficient self, Vector v) -> VectorConstantCoefficient""" + + try: + import numpy as np + value = np.array(v, copy=False, dtype=float).flatten() + can_np_array = True + except: + can_np_array = False + + if can_np_array: + v = mfem._ser.vector.Vector(value) + self._value = v + else: + pass + + _coefficient.VectorConstantCoefficient_swiginit(self, _coefficient.new_VectorConstantCoefficient(v)) def Eval(self, *args): @@ -684,6 +699,22 @@ class MatrixConstantCoefficient(MatrixCoefficient): def __init__(self, m): r"""__init__(MatrixConstantCoefficient self, DenseMatrix m) -> MatrixConstantCoefficient""" + + try: + import numpy as np + value = np.array(m, copy=False, dtype=float) + can_np_array = True + except: + can_np_array = False + + if can_np_array: + v = mfem._ser.vector.Vector(np.transpose(value).flatten()) + m = mfem._ser.densemat.DenseMatrix(v.GetData(), value.shape[0], value.shape[1]) + self._value = (v,m) + else: + pass + + _coefficient.MatrixConstantCoefficient_swiginit(self, _coefficient.new_MatrixConstantCoefficient(m)) def Eval(self, *args): From 99c03990eaed989b17d2da9a770591acb033dbf4 Mon Sep 17 00:00:00 2001 From: Syun'ichi Shiraiwa Date: Wed, 11 Mar 2020 08:04:54 -0400 Subject: [PATCH 4/9] Update README --- README | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README b/README index b9d41171..256421a0 100644 --- a/README +++ b/README @@ -1,11 +1,11 @@ ''''' PyMFEM -built on mfem 4.0 (commit SHA=4d900b0c5fd6352c92173e74678bcbeeb11c8691) +built on mfem 4.1 (commit SHA=60b2b7d4238fb72d018ee6f9f7a54bbfc7817e96) ''''' PyMFEM is a python wrapper for MFEM, ligith-weight FEM (finite element method) library developed by LLNL (http://mfem.org). -PyMFEM is tested with python = 2.7, 3.7 +PyMFEM is tested with python = 3.6, 3.7 This wrapper is meant for a rapid-prototyping of FEM program, and is built using SWIG 3.0.12 From 80ab79ed0f3b5754247629a67e34608b92db1de9 Mon Sep 17 00:00:00 2001 From: Shunichi Shiraiwa Date: Mon, 30 Mar 2020 08:57:12 -0400 Subject: [PATCH 5/9] regenerate wrapper code with SWIG4.1, vtk, restriciton, and prestction wrapper are added --- Makefile | 2 +- mfem/__init__.py | 2 +- mfem/_par/array.py | 139 +- mfem/_par/array_wrap.cxx | 697 +- mfem/_par/bilinearform.py | 240 +- mfem/_par/bilinearform_wrap.cxx | 7184 +++++--- mfem/_par/bilinearform_wrap.h | 4 +- mfem/_par/bilininteg.py | 480 +- mfem/_par/bilininteg_wrap.cxx | 16107 +++++++++++------- mfem/_par/bilininteg_wrap.h | 8 +- mfem/_par/blockmatrix.py | 23 + mfem/_par/blockmatrix_wrap.cxx | 102 +- mfem/_par/blockoperator.py | 28 + mfem/_par/blockoperator_wrap.cxx | 160 +- mfem/_par/blockvector.py | 7 + mfem/_par/blockvector_wrap.cxx | 24 + mfem/_par/coefficient.i | 4 +- mfem/_par/coefficient.py | 108 +- mfem/_par/coefficient_wrap.cxx | 422 +- mfem/_par/common_functions.py | 8 + mfem/_par/common_functions_wrap.cxx | 64 +- mfem/_par/communication.py | 40 + mfem/_par/communication_wrap.cxx | 179 +- mfem/_par/complex_operator.py | 58 + mfem/_par/complex_operator_wrap.cxx | 661 +- mfem/_par/config.py | 3 + mfem/_par/config_wrap.cxx | 25 +- mfem/_par/cpointers.py | 13 + mfem/_par/cpointers_wrap.cxx | 19 + mfem/_par/densemat.py | 234 +- mfem/_par/densemat_wrap.cxx | 2534 ++- mfem/_par/device.py | 79 + mfem/_par/device_wrap.cxx | 285 + mfem/_par/element.py | 35 +- mfem/_par/element_wrap.cxx | 157 +- mfem/_par/eltrans.py | 47 + mfem/_par/eltrans_wrap.cxx | 344 +- mfem/_par/error.py | 8 + mfem/_par/error_wrap.cxx | 8 + mfem/_par/estimators.py | 23 + mfem/_par/estimators_wrap.cxx | 399 +- mfem/_par/fe.py | 535 +- mfem/_par/fe_coll.py | 160 + mfem/_par/fe_coll_wrap.cxx | 822 +- mfem/_par/fe_wrap.cxx | 2915 +++- mfem/_par/fespace.i | 2 + mfem/_par/fespace.py | 172 +- mfem/_par/fespace_wrap.cxx | 2012 +-- mfem/_par/geom.py | 20 + mfem/_par/geom_wrap.cxx | 50 + mfem/_par/globals.py | 8 + mfem/_par/globals_wrap.cxx | 12 + mfem/_par/gridfunc.py | 106 +- mfem/_par/gridfunc_wrap.cxx | 2351 ++- mfem/_par/handle.py | 71 + mfem/_par/handle_wrap.cxx | 672 +- mfem/_par/hash.py | 10 + mfem/_par/hash_wrap.cxx | 101 + mfem/_par/hybridization.py | 16 + mfem/_par/hybridization_wrap.cxx | 256 +- mfem/_par/hypre.py | 268 +- mfem/_par/hypre_wrap.cxx | 1569 +- mfem/_par/intrules.py | 89 +- mfem/_par/intrules_wrap.cxx | 463 +- mfem/_par/io_stream.py | 7 + mfem/_par/io_stream_wrap.cxx | 14 + mfem/_par/istream_typemap.py | 3 + mfem/_par/istream_typemap_wrap.cxx | 3 + mfem/_par/linearform.py | 17 + mfem/_par/linearform_wrap.cxx | 181 +- mfem/_par/lininteg.py | 34 +- mfem/_par/lininteg_wrap.cxx | 485 +- mfem/_par/matrix.py | 19 + mfem/_par/matrix_wrap.cxx | 184 +- mfem/_par/mem_manager.py | 83 +- mfem/_par/mem_manager_wrap.cxx | 639 +- mfem/_par/mesh.i | 1 + mfem/_par/mesh.py | 260 +- mfem/_par/mesh_operators.py | 33 + mfem/_par/mesh_operators_wrap.cxx | 104 +- mfem/_par/mesh_wrap.cxx | 9019 ++++++---- mfem/_par/ncmesh.py | 87 +- mfem/_par/ncmesh_wrap.cxx | 430 +- mfem/_par/nonlinearform.i | 1 + mfem/_par/nonlinearform.py | 42 + mfem/_par/nonlinearform_wrap.cxx | 728 +- mfem/_par/nonlininteg.py | 98 + mfem/_par/nonlininteg_wrap.cxx | 1365 +- mfem/_par/nonlininteg_wrap.h | 5 +- mfem/_par/ode.i | 4 + mfem/_par/ode.py | 392 + mfem/_par/ode_wrap.cxx | 4835 +++++- mfem/_par/operators.py | 216 + mfem/_par/operators_wrap.cxx | 4356 ++++- mfem/_par/operators_wrap.h | 32 +- mfem/_par/ostream_typemap.py | 3 + mfem/_par/ostream_typemap_wrap.cxx | 3 + mfem/_par/pbilinearform.py | 35 + mfem/_par/pbilinearform_wrap.cxx | 466 +- mfem/_par/pfespace.i | 3 + mfem/_par/pfespace.py | 81 + mfem/_par/pfespace_wrap.cxx | 1391 +- mfem/_par/pgridfunc.py | 39 +- mfem/_par/pgridfunc_wrap.cxx | 748 +- mfem/_par/plinearform.py | 10 + mfem/_par/plinearform_wrap.cxx | 148 +- mfem/_par/pmesh.py | 59 +- mfem/_par/pmesh_wrap.cxx | 631 +- mfem/_par/pncmesh.py | 48 +- mfem/_par/pncmesh_wrap.cxx | 237 +- mfem/_par/pnonlinearform.py | 21 + mfem/_par/pnonlinearform_wrap.cxx | 344 +- mfem/_par/point.py | 25 +- mfem/_par/point_wrap.cxx | 151 +- mfem/_par/prestriction.i | 20 + mfem/_par/prestriction.py | 122 + mfem/_par/prestriction_wrap.cxx | 4822 ++++++ mfem/_par/prestriction_wrap.h | 18 + mfem/_par/pumi.py | 21 + mfem/_par/pumi_wrap.cxx | 133 +- mfem/_par/restriction.i | 21 + mfem/_par/restriction.py | 217 + mfem/_par/restriction_wrap.cxx | 5627 ++++++ mfem/_par/restriction_wrap.h | 18 + mfem/_par/segment.py | 26 +- mfem/_par/segment_wrap.cxx | 153 +- mfem/_par/sets.py | 14 + mfem/_par/sets_wrap.cxx | 26 + mfem/_par/setup.py | 4 +- mfem/_par/socketstream.py | 24 + mfem/_par/socketstream_wrap.cxx | 95 +- mfem/_par/solvers.py | 249 +- mfem/_par/solvers_wrap.cxx | 3697 +++- mfem/_par/sparsemat.py | 237 +- mfem/_par/sparsemat_wrap.cxx | 2096 ++- mfem/_par/sparsesmoothers.py | 6 + mfem/_par/sparsesmoothers_wrap.cxx | 80 +- mfem/_par/stable3d.py | 9 + mfem/_par/stable3d_wrap.cxx | 31 + mfem/_par/table.py | 45 + mfem/_par/table_wrap.cxx | 100 + mfem/_par/vector.py | 70 + mfem/_par/vector_wrap.cxx | 333 + mfem/_par/vertex.py | 5 + mfem/_par/vertex_wrap.cxx | 21 + mfem/_par/vtk.i | 21 + mfem/_par/vtk.py | 102 + mfem/_par/vtk_wrap.cxx | 4338 +++++ mfem/_par/vtk_wrap.h | 18 + mfem/_ser/array.py | 139 +- mfem/_ser/array_wrap.cxx | 697 +- mfem/_ser/bilinearform.py | 250 +- mfem/_ser/bilinearform_wrap.cxx | 7325 +++++--- mfem/_ser/bilinearform_wrap.h | 4 +- mfem/_ser/bilininteg.py | 480 +- mfem/_ser/bilininteg_wrap.cxx | 23668 +++++++++++++++----------- mfem/_ser/bilininteg_wrap.h | 8 +- mfem/_ser/blockmatrix.py | 23 + mfem/_ser/blockmatrix_wrap.cxx | 102 +- mfem/_ser/blockoperator.py | 27 + mfem/_ser/blockoperator_wrap.cxx | 159 +- mfem/_ser/blockvector.py | 7 + mfem/_ser/blockvector_wrap.cxx | 24 + mfem/_ser/coefficient.i | 4 +- mfem/_ser/coefficient.py | 107 +- mfem/_ser/coefficient_wrap.cxx | 404 + mfem/_ser/common_functions.py | 8 + mfem/_ser/common_functions_wrap.cxx | 34 + mfem/_ser/complex_operator.py | 58 + mfem/_ser/complex_operator_wrap.cxx | 739 +- mfem/_ser/densemat.py | 234 +- mfem/_ser/densemat_wrap.cxx | 3128 +++- mfem/_ser/device.py | 79 + mfem/_ser/device_wrap.cxx | 285 + mfem/_ser/element.py | 35 +- mfem/_ser/element_wrap.cxx | 169 +- mfem/_ser/eltrans.py | 47 + mfem/_ser/eltrans_wrap.cxx | 350 +- mfem/_ser/error.py | 8 + mfem/_ser/error_wrap.cxx | 8 + mfem/_ser/estimators.py | 19 + mfem/_ser/estimators_wrap.cxx | 387 +- mfem/_ser/fe.py | 535 +- mfem/_ser/fe_coll.py | 174 +- mfem/_ser/fe_coll_wrap.cxx | 877 +- mfem/_ser/fe_wrap.cxx | 3021 +++- mfem/_ser/fespace.i | 2 + mfem/_ser/fespace.py | 172 +- mfem/_ser/fespace_wrap.cxx | 1962 +-- mfem/_ser/geom.py | 20 + mfem/_ser/geom_wrap.cxx | 50 + mfem/_ser/globals.py | 8 + mfem/_ser/globals_wrap.cxx | 12 + mfem/_ser/gridfunc.py | 116 +- mfem/_ser/gridfunc_wrap.cxx | 2328 ++- mfem/_ser/handle.py | 69 + mfem/_ser/handle_wrap.cxx | 672 +- mfem/_ser/hash.py | 10 + mfem/_ser/hash_wrap.cxx | 101 + mfem/_ser/hybridization.py | 14 + mfem/_ser/hybridization_wrap.cxx | 249 +- mfem/_ser/intrules.py | 89 +- mfem/_ser/intrules_wrap.cxx | 463 +- mfem/_ser/io_stream.py | 7 + mfem/_ser/io_stream_wrap.cxx | 14 + mfem/_ser/istream_typemap.py | 3 + mfem/_ser/istream_typemap_wrap.cxx | 3 + mfem/_ser/linearform.i | 1 + mfem/_ser/linearform.py | 83 +- mfem/_ser/linearform_wrap.cxx | 723 +- mfem/_ser/lininteg.py | 34 +- mfem/_ser/lininteg_wrap.cxx | 491 +- mfem/_ser/matrix.py | 19 + mfem/_ser/matrix_wrap.cxx | 190 +- mfem/_ser/mem_manager.py | 83 +- mfem/_ser/mem_manager_wrap.cxx | 639 +- mfem/_ser/mesh.i | 1 + mfem/_ser/mesh.py | 274 +- mfem/_ser/mesh_operators.py | 37 +- mfem/_ser/mesh_operators_wrap.cxx | 104 +- mfem/_ser/mesh_wrap.cxx | 9378 ++++++---- mfem/_ser/ncmesh.py | 101 +- mfem/_ser/ncmesh_wrap.cxx | 499 +- mfem/_ser/nonlinearform.i | 1 + mfem/_ser/nonlinearform.py | 42 + mfem/_ser/nonlinearform_wrap.cxx | 534 +- mfem/_ser/nonlininteg.py | 98 + mfem/_ser/nonlininteg_wrap.cxx | 1872 +- mfem/_ser/nonlininteg_wrap.h | 5 +- mfem/_ser/ode.i | 5 + mfem/_ser/ode.py | 392 + mfem/_ser/ode_wrap.cxx | 5109 +++++- mfem/_ser/operators.py | 216 + mfem/_ser/operators_wrap.cxx | 4908 +++++- mfem/_ser/operators_wrap.h | 32 +- mfem/_ser/ostream_typemap.py | 3 + mfem/_ser/ostream_typemap_wrap.cxx | 3 + mfem/_ser/point.py | 25 +- mfem/_ser/point_wrap.cxx | 163 +- mfem/_ser/restriction.i | 21 + mfem/_ser/restriction.py | 216 + mfem/_ser/restriction_wrap.cxx | 5754 +++++++ mfem/_ser/restriction_wrap.h | 18 + mfem/_ser/segment.py | 26 +- mfem/_ser/segment_wrap.cxx | 165 +- mfem/_ser/sets.py | 14 + mfem/_ser/sets_wrap.cxx | 26 + mfem/_ser/setup.py | 4 +- mfem/_ser/socketstream.py | 28 +- mfem/_ser/socketstream_wrap.cxx | 97 +- mfem/_ser/solvers.py | 249 +- mfem/_ser/solvers_wrap.cxx | 10909 +++++++----- mfem/_ser/sparsemat.py | 237 +- mfem/_ser/sparsemat_wrap.cxx | 2300 ++- mfem/_ser/sparsesmoothers.py | 6 + mfem/_ser/sparsesmoothers_wrap.cxx | 80 +- mfem/_ser/stable3d.py | 9 + mfem/_ser/stable3d_wrap.cxx | 31 + mfem/_ser/table.py | 45 + mfem/_ser/table_wrap.cxx | 100 + mfem/_ser/vector.py | 70 + mfem/_ser/vector_wrap.cxx | 334 + mfem/_ser/vertex.py | 5 + mfem/_ser/vertex_wrap.cxx | 21 + mfem/_ser/vtk.i | 21 + mfem/_ser/vtk.py | 102 + mfem/_ser/vtk_wrap.cxx | 4356 +++++ mfem/_ser/vtk_wrap.h | 18 + 268 files changed, 152155 insertions(+), 43742 deletions(-) create mode 100644 mfem/_par/prestriction.i create mode 100644 mfem/_par/prestriction.py create mode 100644 mfem/_par/prestriction_wrap.cxx create mode 100644 mfem/_par/prestriction_wrap.h create mode 100644 mfem/_par/restriction.i create mode 100644 mfem/_par/restriction.py create mode 100644 mfem/_par/restriction_wrap.cxx create mode 100644 mfem/_par/restriction_wrap.h create mode 100644 mfem/_par/vtk.i create mode 100644 mfem/_par/vtk.py create mode 100644 mfem/_par/vtk_wrap.cxx create mode 100644 mfem/_par/vtk_wrap.h create mode 100644 mfem/_ser/restriction.i create mode 100644 mfem/_ser/restriction.py create mode 100644 mfem/_ser/restriction_wrap.cxx create mode 100644 mfem/_ser/restriction_wrap.h create mode 100644 mfem/_ser/vtk.i create mode 100644 mfem/_ser/vtk.py create mode 100644 mfem/_ser/vtk_wrap.cxx create mode 100644 mfem/_ser/vtk_wrap.h diff --git a/Makefile b/Makefile index 21e76ea5..1783bd43 100644 --- a/Makefile +++ b/Makefile @@ -17,7 +17,7 @@ WHOLE_ARCHIVE = --whole_archive NO_WHOLE_ARCHIVE = --no-whole-archive SWIG=$(shell which swig) -SWIGFLAG = -Wall -c++ -python +SWIGFLAG = -Wall -c++ -python -fastproxy -olddefs # # MFEM path: diff --git a/mfem/__init__.py b/mfem/__init__.py index 78069335..3e929b6c 100644 --- a/mfem/__init__.py +++ b/mfem/__init__.py @@ -20,5 +20,5 @@ def debug_print(message): print(message) -__version__ = '4.0.2' +__version__ = '4.1.0' diff --git a/mfem/_par/array.py b/mfem/_par/array.py index eaa630d1..ce9d3d34 100644 --- a/mfem/_par/array.py +++ b/mfem/_par/array.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _array.SWIG_PyInstanceMethod_New +_swig_new_static_method = _array.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -70,7 +73,9 @@ class intArray(object): def __init__(self, *args): r""" - __init__(intArray self, int asize=0) -> intArray + __init__(intArray self) -> intArray + __init__(intArray self, mfem::MemoryType mt) -> intArray + __init__(intArray self, int asize) -> intArray __init__(intArray self, int * _data) -> intArray __init__(intArray self, intArray src) -> intArray """ @@ -89,6 +94,7 @@ def GetData(self, *args): GetData(intArray self) -> int const * """ return _array.intArray_GetData(self, *args) + GetData = _swig_new_instance_method(_array.intArray_GetData) def GetMemory(self, *args): r""" @@ -96,30 +102,37 @@ def GetMemory(self, *args): GetMemory(intArray self) -> mfem::Memory< int > const & """ return _array.intArray_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_array.intArray_GetMemory) def UseDevice(self): r"""UseDevice(intArray self) -> bool""" return _array.intArray_UseDevice(self) + UseDevice = _swig_new_instance_method(_array.intArray_UseDevice) def OwnsData(self): r"""OwnsData(intArray self) -> bool""" return _array.intArray_OwnsData(self) + OwnsData = _swig_new_instance_method(_array.intArray_OwnsData) def StealData(self, p): r"""StealData(intArray self, int ** p)""" return _array.intArray_StealData(self, p) + StealData = _swig_new_instance_method(_array.intArray_StealData) def LoseData(self): r"""LoseData(intArray self)""" return _array.intArray_LoseData(self) + LoseData = _swig_new_instance_method(_array.intArray_LoseData) def MakeDataOwner(self): r"""MakeDataOwner(intArray self)""" return _array.intArray_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_array.intArray_MakeDataOwner) def Size(self): r"""Size(intArray self) -> int""" return _array.intArray_Size(self) + Size = _swig_new_instance_method(_array.intArray_Size) def SetSize(self, *args): r""" @@ -128,14 +141,17 @@ def SetSize(self, *args): SetSize(intArray self, int nsize, mfem::MemoryType mt) """ return _array.intArray_SetSize(self, *args) + SetSize = _swig_new_instance_method(_array.intArray_SetSize) def Capacity(self): r"""Capacity(intArray self) -> int""" return _array.intArray_Capacity(self) + Capacity = _swig_new_instance_method(_array.intArray_Capacity) def Reserve(self, capacity): r"""Reserve(intArray self, int capacity)""" return _array.intArray_Reserve(self, capacity) + Reserve = _swig_new_instance_method(_array.intArray_Reserve) def Append(self, *args): r""" @@ -144,10 +160,12 @@ def Append(self, *args): Append(intArray self, intArray els) -> int """ return _array.intArray_Append(self, *args) + Append = _swig_new_instance_method(_array.intArray_Append) def Prepend(self, el): r"""Prepend(intArray self, int const & el) -> int""" return _array.intArray_Prepend(self, el) + Prepend = _swig_new_instance_method(_array.intArray_Prepend) def Last(self, *args): r""" @@ -155,34 +173,42 @@ def Last(self, *args): Last(intArray self) -> int const & """ return _array.intArray_Last(self, *args) + Last = _swig_new_instance_method(_array.intArray_Last) def Union(self, el): r"""Union(intArray self, int const & el) -> int""" return _array.intArray_Union(self, el) + Union = _swig_new_instance_method(_array.intArray_Union) def Find(self, el): r"""Find(intArray self, int const & el) -> int""" return _array.intArray_Find(self, el) + Find = _swig_new_instance_method(_array.intArray_Find) def FindSorted(self, el): r"""FindSorted(intArray self, int const & el) -> int""" return _array.intArray_FindSorted(self, el) + FindSorted = _swig_new_instance_method(_array.intArray_FindSorted) def DeleteLast(self): r"""DeleteLast(intArray self)""" return _array.intArray_DeleteLast(self) + DeleteLast = _swig_new_instance_method(_array.intArray_DeleteLast) def DeleteFirst(self, el): r"""DeleteFirst(intArray self, int const & el)""" return _array.intArray_DeleteFirst(self, el) + DeleteFirst = _swig_new_instance_method(_array.intArray_DeleteFirst) def DeleteAll(self): r"""DeleteAll(intArray self)""" return _array.intArray_DeleteAll(self) + DeleteAll = _swig_new_instance_method(_array.intArray_DeleteAll) def Copy(self, copy): r"""Copy(intArray self, intArray copy)""" return _array.intArray_Copy(self, copy) + Copy = _swig_new_instance_method(_array.intArray_Copy) def MakeRef(self, *args): r""" @@ -190,10 +216,12 @@ def MakeRef(self, *args): MakeRef(intArray self, intArray master) """ return _array.intArray_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_array.intArray_MakeRef) def GetSubArray(self, offset, sa_size, sa): r"""GetSubArray(intArray self, int offset, int sa_size, intArray sa)""" return _array.intArray_GetSubArray(self, offset, sa_size, sa) + GetSubArray = _swig_new_instance_method(_array.intArray_GetSubArray) def Load(self, *args): r""" @@ -201,78 +229,103 @@ def Load(self, *args): Load(intArray self, int new_size, std::istream & _in) """ return _array.intArray_Load(self, *args) + Load = _swig_new_instance_method(_array.intArray_Load) def Max(self): r"""Max(intArray self) -> int""" return _array.intArray_Max(self) + Max = _swig_new_instance_method(_array.intArray_Max) def Min(self): r"""Min(intArray self) -> int""" return _array.intArray_Min(self) + Min = _swig_new_instance_method(_array.intArray_Min) def Sort(self): r"""Sort(intArray self)""" return _array.intArray_Sort(self) + Sort = _swig_new_instance_method(_array.intArray_Sort) def Unique(self): r"""Unique(intArray self)""" return _array.intArray_Unique(self) + Unique = _swig_new_instance_method(_array.intArray_Unique) def IsSorted(self): r"""IsSorted(intArray self) -> int""" return _array.intArray_IsSorted(self) + IsSorted = _swig_new_instance_method(_array.intArray_IsSorted) def PartialSum(self): r"""PartialSum(intArray self)""" return _array.intArray_PartialSum(self) + PartialSum = _swig_new_instance_method(_array.intArray_PartialSum) def Sum(self): r"""Sum(intArray self) -> int""" return _array.intArray_Sum(self) + Sum = _swig_new_instance_method(_array.intArray_Sum) - def begin(self): - r"""begin(intArray self) -> int *""" - return _array.intArray_begin(self) + def begin(self, *args): + r""" + begin(intArray self) -> int + begin(intArray self) -> int const * + """ + return _array.intArray_begin(self, *args) + begin = _swig_new_instance_method(_array.intArray_begin) - def end(self): - r"""end(intArray self) -> int *""" - return _array.intArray_end(self) + def end(self, *args): + r""" + end(intArray self) -> int + end(intArray self) -> int const * + """ + return _array.intArray_end(self, *args) + end = _swig_new_instance_method(_array.intArray_end) def MemoryUsage(self): r"""MemoryUsage(intArray self) -> long""" return _array.intArray_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_array.intArray_MemoryUsage) def Read(self, on_dev=True): r"""Read(intArray self, bool on_dev=True) -> int const""" return _array.intArray_Read(self, on_dev) + Read = _swig_new_instance_method(_array.intArray_Read) def HostRead(self): r"""HostRead(intArray self) -> int const *""" return _array.intArray_HostRead(self) + HostRead = _swig_new_instance_method(_array.intArray_HostRead) def Write(self, on_dev=True): r"""Write(intArray self, bool on_dev=True) -> int""" return _array.intArray_Write(self, on_dev) + Write = _swig_new_instance_method(_array.intArray_Write) def HostWrite(self): r"""HostWrite(intArray self) -> int *""" return _array.intArray_HostWrite(self) + HostWrite = _swig_new_instance_method(_array.intArray_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(intArray self, bool on_dev=True) -> int""" return _array.intArray_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_array.intArray_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(intArray self) -> int *""" return _array.intArray_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_array.intArray_HostReadWrite) def __setitem__(self, i, v): r"""__setitem__(intArray self, int i, int const v)""" return _array.intArray___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_array.intArray___setitem__) def __getitem__(self, i): r"""__getitem__(intArray self, int const i) -> int const &""" return _array.intArray___getitem__(self, i) + __getitem__ = _swig_new_instance_method(_array.intArray___getitem__) def Assign(self, *args): r""" @@ -280,6 +333,7 @@ def Assign(self, *args): Assign(intArray self, int const & a) """ return _array.intArray_Assign(self, *args) + Assign = _swig_new_instance_method(_array.intArray_Assign) def ToList(self): return [self[i] for i in range(self.Size())] @@ -292,6 +346,7 @@ def Print(self, *args): Print(intArray self, char const * file, int precision=8) """ return _array.intArray_Print(self, *args) + Print = _swig_new_instance_method(_array.intArray_Print) def Save(self, *args): r""" @@ -300,6 +355,7 @@ def Save(self, *args): Save(intArray self) """ return _array.intArray_Save(self, *args) + Save = _swig_new_instance_method(_array.intArray_Save) # Register intArray in _array: _array.intArray_swigregister(intArray) @@ -312,7 +368,9 @@ class doubleArray(object): def __init__(self, *args): r""" - __init__(doubleArray self, int asize=0) -> doubleArray + __init__(doubleArray self) -> doubleArray + __init__(doubleArray self, mfem::MemoryType mt) -> doubleArray + __init__(doubleArray self, int asize) -> doubleArray __init__(doubleArray self, double * _data) -> doubleArray __init__(doubleArray self, doubleArray src) -> doubleArray """ @@ -331,6 +389,7 @@ def GetData(self, *args): GetData(doubleArray self) -> double const * """ return _array.doubleArray_GetData(self, *args) + GetData = _swig_new_instance_method(_array.doubleArray_GetData) def GetMemory(self, *args): r""" @@ -338,30 +397,37 @@ def GetMemory(self, *args): GetMemory(doubleArray self) -> mfem::Memory< double > const & """ return _array.doubleArray_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_array.doubleArray_GetMemory) def UseDevice(self): r"""UseDevice(doubleArray self) -> bool""" return _array.doubleArray_UseDevice(self) + UseDevice = _swig_new_instance_method(_array.doubleArray_UseDevice) def OwnsData(self): r"""OwnsData(doubleArray self) -> bool""" return _array.doubleArray_OwnsData(self) + OwnsData = _swig_new_instance_method(_array.doubleArray_OwnsData) def StealData(self, p): r"""StealData(doubleArray self, double ** p)""" return _array.doubleArray_StealData(self, p) + StealData = _swig_new_instance_method(_array.doubleArray_StealData) def LoseData(self): r"""LoseData(doubleArray self)""" return _array.doubleArray_LoseData(self) + LoseData = _swig_new_instance_method(_array.doubleArray_LoseData) def MakeDataOwner(self): r"""MakeDataOwner(doubleArray self)""" return _array.doubleArray_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_array.doubleArray_MakeDataOwner) def Size(self): r"""Size(doubleArray self) -> int""" return _array.doubleArray_Size(self) + Size = _swig_new_instance_method(_array.doubleArray_Size) def SetSize(self, *args): r""" @@ -370,14 +436,17 @@ def SetSize(self, *args): SetSize(doubleArray self, int nsize, mfem::MemoryType mt) """ return _array.doubleArray_SetSize(self, *args) + SetSize = _swig_new_instance_method(_array.doubleArray_SetSize) def Capacity(self): r"""Capacity(doubleArray self) -> int""" return _array.doubleArray_Capacity(self) + Capacity = _swig_new_instance_method(_array.doubleArray_Capacity) def Reserve(self, capacity): r"""Reserve(doubleArray self, int capacity)""" return _array.doubleArray_Reserve(self, capacity) + Reserve = _swig_new_instance_method(_array.doubleArray_Reserve) def Append(self, *args): r""" @@ -386,10 +455,12 @@ def Append(self, *args): Append(doubleArray self, doubleArray els) -> int """ return _array.doubleArray_Append(self, *args) + Append = _swig_new_instance_method(_array.doubleArray_Append) def Prepend(self, el): r"""Prepend(doubleArray self, double const & el) -> int""" return _array.doubleArray_Prepend(self, el) + Prepend = _swig_new_instance_method(_array.doubleArray_Prepend) def Last(self, *args): r""" @@ -397,34 +468,42 @@ def Last(self, *args): Last(doubleArray self) -> double const & """ return _array.doubleArray_Last(self, *args) + Last = _swig_new_instance_method(_array.doubleArray_Last) def Union(self, el): r"""Union(doubleArray self, double const & el) -> int""" return _array.doubleArray_Union(self, el) + Union = _swig_new_instance_method(_array.doubleArray_Union) def Find(self, el): r"""Find(doubleArray self, double const & el) -> int""" return _array.doubleArray_Find(self, el) + Find = _swig_new_instance_method(_array.doubleArray_Find) def FindSorted(self, el): r"""FindSorted(doubleArray self, double const & el) -> int""" return _array.doubleArray_FindSorted(self, el) + FindSorted = _swig_new_instance_method(_array.doubleArray_FindSorted) def DeleteLast(self): r"""DeleteLast(doubleArray self)""" return _array.doubleArray_DeleteLast(self) + DeleteLast = _swig_new_instance_method(_array.doubleArray_DeleteLast) def DeleteFirst(self, el): r"""DeleteFirst(doubleArray self, double const & el)""" return _array.doubleArray_DeleteFirst(self, el) + DeleteFirst = _swig_new_instance_method(_array.doubleArray_DeleteFirst) def DeleteAll(self): r"""DeleteAll(doubleArray self)""" return _array.doubleArray_DeleteAll(self) + DeleteAll = _swig_new_instance_method(_array.doubleArray_DeleteAll) def Copy(self, copy): r"""Copy(doubleArray self, doubleArray copy)""" return _array.doubleArray_Copy(self, copy) + Copy = _swig_new_instance_method(_array.doubleArray_Copy) def MakeRef(self, *args): r""" @@ -432,10 +511,12 @@ def MakeRef(self, *args): MakeRef(doubleArray self, doubleArray master) """ return _array.doubleArray_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_array.doubleArray_MakeRef) def GetSubArray(self, offset, sa_size, sa): r"""GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)""" return _array.doubleArray_GetSubArray(self, offset, sa_size, sa) + GetSubArray = _swig_new_instance_method(_array.doubleArray_GetSubArray) def Load(self, *args): r""" @@ -443,78 +524,103 @@ def Load(self, *args): Load(doubleArray self, int new_size, std::istream & _in) """ return _array.doubleArray_Load(self, *args) + Load = _swig_new_instance_method(_array.doubleArray_Load) def Max(self): r"""Max(doubleArray self) -> double""" return _array.doubleArray_Max(self) + Max = _swig_new_instance_method(_array.doubleArray_Max) def Min(self): r"""Min(doubleArray self) -> double""" return _array.doubleArray_Min(self) + Min = _swig_new_instance_method(_array.doubleArray_Min) def Sort(self): r"""Sort(doubleArray self)""" return _array.doubleArray_Sort(self) + Sort = _swig_new_instance_method(_array.doubleArray_Sort) def Unique(self): r"""Unique(doubleArray self)""" return _array.doubleArray_Unique(self) + Unique = _swig_new_instance_method(_array.doubleArray_Unique) def IsSorted(self): r"""IsSorted(doubleArray self) -> int""" return _array.doubleArray_IsSorted(self) + IsSorted = _swig_new_instance_method(_array.doubleArray_IsSorted) def PartialSum(self): r"""PartialSum(doubleArray self)""" return _array.doubleArray_PartialSum(self) + PartialSum = _swig_new_instance_method(_array.doubleArray_PartialSum) def Sum(self): r"""Sum(doubleArray self) -> double""" return _array.doubleArray_Sum(self) + Sum = _swig_new_instance_method(_array.doubleArray_Sum) - def begin(self): - r"""begin(doubleArray self) -> double *""" - return _array.doubleArray_begin(self) + def begin(self, *args): + r""" + begin(doubleArray self) -> double + begin(doubleArray self) -> double const * + """ + return _array.doubleArray_begin(self, *args) + begin = _swig_new_instance_method(_array.doubleArray_begin) - def end(self): - r"""end(doubleArray self) -> double *""" - return _array.doubleArray_end(self) + def end(self, *args): + r""" + end(doubleArray self) -> double + end(doubleArray self) -> double const * + """ + return _array.doubleArray_end(self, *args) + end = _swig_new_instance_method(_array.doubleArray_end) def MemoryUsage(self): r"""MemoryUsage(doubleArray self) -> long""" return _array.doubleArray_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_array.doubleArray_MemoryUsage) def Read(self, on_dev=True): r"""Read(doubleArray self, bool on_dev=True) -> double const""" return _array.doubleArray_Read(self, on_dev) + Read = _swig_new_instance_method(_array.doubleArray_Read) def HostRead(self): r"""HostRead(doubleArray self) -> double const *""" return _array.doubleArray_HostRead(self) + HostRead = _swig_new_instance_method(_array.doubleArray_HostRead) def Write(self, on_dev=True): r"""Write(doubleArray self, bool on_dev=True) -> double""" return _array.doubleArray_Write(self, on_dev) + Write = _swig_new_instance_method(_array.doubleArray_Write) def HostWrite(self): r"""HostWrite(doubleArray self) -> double *""" return _array.doubleArray_HostWrite(self) + HostWrite = _swig_new_instance_method(_array.doubleArray_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(doubleArray self, bool on_dev=True) -> double""" return _array.doubleArray_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_array.doubleArray_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(doubleArray self) -> double *""" return _array.doubleArray_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_array.doubleArray_HostReadWrite) def __setitem__(self, i, v): r"""__setitem__(doubleArray self, int i, double const v)""" return _array.doubleArray___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_array.doubleArray___setitem__) def __getitem__(self, i): r"""__getitem__(doubleArray self, int const i) -> double const &""" return _array.doubleArray___getitem__(self, i) + __getitem__ = _swig_new_instance_method(_array.doubleArray___getitem__) def Assign(self, *args): r""" @@ -522,6 +628,7 @@ def Assign(self, *args): Assign(doubleArray self, double const & a) """ return _array.doubleArray_Assign(self, *args) + Assign = _swig_new_instance_method(_array.doubleArray_Assign) def ToList(self): return [self[i] for i in range(self.Size())] @@ -534,6 +641,7 @@ def Print(self, *args): Print(doubleArray self, char const * file, int precision=8) """ return _array.doubleArray_Print(self, *args) + Print = _swig_new_instance_method(_array.doubleArray_Print) def Save(self, *args): r""" @@ -542,6 +650,7 @@ def Save(self, *args): Save(doubleArray self) """ return _array.doubleArray_Save(self, *args) + Save = _swig_new_instance_method(_array.doubleArray_Save) # Register doubleArray in _array: _array.doubleArray_swigregister(doubleArray) @@ -554,6 +663,7 @@ def doubleSwap(*args): doubleSwap(double & a, double & b) """ return _array.doubleSwap(*args) +doubleSwap = _array.doubleSwap def intSwap(*args): r""" @@ -562,5 +672,6 @@ def intSwap(*args): intSwap(int & a, int & b) """ return _array.intSwap(*args) +intSwap = _array.intSwap diff --git a/mfem/_par/array_wrap.cxx b/mfem/_par/array_wrap.cxx index 54e381c3..7075632c 100644 --- a/mfem/_par/array_wrap.cxx +++ b/mfem/_par/array_wrap.cxx @@ -3166,9 +3166,37 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_4(mfem::Array< double > *sel #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - int arg1 ; + mfem::Array< int > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::Array< int > *)new mfem::Array< int >(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; mfem::Array< int > *result = 0 ; @@ -3176,9 +3204,9 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "mfem::MemoryType""'"); } - arg1 = static_cast< int >(val1); + arg1 = static_cast< mfem::MemoryType >(val1); { try { result = (mfem::Array< int > *)new mfem::Array< int >(arg1); @@ -3202,14 +3230,22 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; mfem::Array< int > *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); { try { - result = (mfem::Array< int > *)new mfem::Array< int >(); + result = (mfem::Array< int > *)new mfem::Array< int >(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3230,7 +3266,7 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; int arg2 ; @@ -3281,7 +3317,7 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; @@ -3329,14 +3365,24 @@ SWIGINTERN PyObject *_wrap_new_intArray(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_intArray", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_intArray__SWIG_1(self, argc, argv); + return _wrap_new_intArray__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_intArray__SWIG_3(self, argc, argv); + return _wrap_new_intArray__SWIG_4(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_intArray__SWIG_2(self, argc, argv); } } if (argc == 1) { @@ -3346,7 +3392,7 @@ SWIGINTERN PyObject *_wrap_new_intArray(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_intArray__SWIG_0(self, argc, argv); + return _wrap_new_intArray__SWIG_1(self, argc, argv); } } if (argc == 1) { @@ -3356,17 +3402,18 @@ SWIGINTERN PyObject *_wrap_new_intArray(PyObject *self, PyObject *args) { } if (_v) { if (argc <= 1) { - return _wrap_new_intArray__SWIG_2(self, argc, argv); + return _wrap_new_intArray__SWIG_3(self, argc, argv); } - return _wrap_new_intArray__SWIG_2(self, argc, argv); + return _wrap_new_intArray__SWIG_3(self, argc, argv); } } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_intArray'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Array(int)\n" " mfem::Array< int >::Array()\n" + " mfem::Array< int >::Array(mfem::MemoryType)\n" + " mfem::Array< int >::Array(int)\n" " mfem::Array< int >::Array(int *,int)\n" " mfem::Array< int >::Array(mfem::Array< int > const &)\n"); return 0; @@ -5885,16 +5932,14 @@ SWIGINTERN PyObject *_wrap_intArray_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_intArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_begin" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -5923,16 +5968,14 @@ SWIGINTERN PyObject *_wrap_intArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_intArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_end" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -5961,6 +6004,150 @@ SWIGINTERN PyObject *_wrap_intArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject } +SWIGINTERN PyObject *_wrap_intArray_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_begin" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + { + try { + result = (int *)((mfem::Array< int > const *)arg1)->begin(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intArray_begin(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_begin", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_begin__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_begin__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_begin'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< int >::begin()\n" + " mfem::Array< int >::begin() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_intArray_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_end" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + { + try { + result = (int *)((mfem::Array< int > const *)arg1)->end(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intArray_end(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_end", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_end__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_end__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_end'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< int >::end()\n" + " mfem::Array< int >::end() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_intArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -7167,9 +7354,37 @@ SWIGINTERN PyObject *intArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - int arg1 ; + mfem::Array< double > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::Array< double > *)new mfem::Array< double >(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; mfem::Array< double > *result = 0 ; @@ -7177,9 +7392,9 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "mfem::MemoryType""'"); } - arg1 = static_cast< int >(val1); + arg1 = static_cast< mfem::MemoryType >(val1); { try { result = (mfem::Array< double > *)new mfem::Array< double >(arg1); @@ -7203,14 +7418,22 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; mfem::Array< double > *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); { try { - result = (mfem::Array< double > *)new mfem::Array< double >(); + result = (mfem::Array< double > *)new mfem::Array< double >(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7231,7 +7454,7 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -7282,7 +7505,7 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = 0 ; void *argp1 = 0 ; @@ -7330,14 +7553,14 @@ SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_doubleArray", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_doubleArray__SWIG_1(self, argc, argv); + return _wrap_new_doubleArray__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_doubleArray__SWIG_3(self, argc, argv); + return _wrap_new_doubleArray__SWIG_4(self, argc, argv); } } if (argc == 1) { @@ -7347,7 +7570,17 @@ SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_doubleArray__SWIG_0(self, argc, argv); + return _wrap_new_doubleArray__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_doubleArray__SWIG_1(self, argc, argv); } } if (argc == 1) { @@ -7357,17 +7590,18 @@ SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *self, PyObject *args) { } if (_v) { if (argc <= 1) { - return _wrap_new_doubleArray__SWIG_2(self, argc, argv); + return _wrap_new_doubleArray__SWIG_3(self, argc, argv); } - return _wrap_new_doubleArray__SWIG_2(self, argc, argv); + return _wrap_new_doubleArray__SWIG_3(self, argc, argv); } } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_doubleArray'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::Array(int)\n" " mfem::Array< double >::Array()\n" + " mfem::Array< double >::Array(mfem::MemoryType)\n" + " mfem::Array< double >::Array(int)\n" " mfem::Array< double >::Array(double *,int)\n" " mfem::Array< double >::Array(mfem::Array< double > const &)\n"); return 0; @@ -9886,16 +10120,14 @@ SWIGINTERN PyObject *_wrap_doubleArray_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_doubleArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_begin" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -9924,16 +10156,14 @@ SWIGINTERN PyObject *_wrap_doubleArray_begin(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_doubleArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_end" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -9962,6 +10192,150 @@ SWIGINTERN PyObject *_wrap_doubleArray_end(PyObject *SWIGUNUSEDPARM(self), PyObj } +SWIGINTERN PyObject *_wrap_doubleArray_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_begin" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + { + try { + result = (double *)((mfem::Array< double > const *)arg1)->begin(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doubleArray_begin(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_begin", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_begin__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_begin__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_begin'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< double >::begin()\n" + " mfem::Array< double >::begin() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_doubleArray_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_end" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + { + try { + result = (double *)((mfem::Array< double > const *)arg1)->end(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doubleArray_end(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_end", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_end__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_end__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_end'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< double >::end()\n" + " mfem::Array< double >::end() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_doubleArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; @@ -11586,8 +11960,11 @@ SWIGINTERN PyObject *_wrap_intSwap(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intArray", _wrap_new_intArray, METH_VARARGS, "\n" - "intArray(int asize=0)\n" + "intArray()\n" + "intArray(mfem::MemoryType mt)\n" + "intArray(int asize)\n" "intArray(int * _data)\n" "new_intArray(intArray src) -> intArray\n" ""}, @@ -11646,8 +12023,14 @@ static PyMethodDef SwigMethods[] = { { "intArray_IsSorted", _wrap_intArray_IsSorted, METH_O, "intArray_IsSorted(intArray self) -> int"}, { "intArray_PartialSum", _wrap_intArray_PartialSum, METH_O, "intArray_PartialSum(intArray self)"}, { "intArray_Sum", _wrap_intArray_Sum, METH_O, "intArray_Sum(intArray self) -> int"}, - { "intArray_begin", _wrap_intArray_begin, METH_O, "intArray_begin(intArray self) -> int *"}, - { "intArray_end", _wrap_intArray_end, METH_O, "intArray_end(intArray self) -> int *"}, + { "intArray_begin", _wrap_intArray_begin, METH_VARARGS, "\n" + "intArray_begin(intArray self) -> int\n" + "intArray_begin(intArray self) -> int const *\n" + ""}, + { "intArray_end", _wrap_intArray_end, METH_VARARGS, "\n" + "intArray_end(intArray self) -> int\n" + "intArray_end(intArray self) -> int const *\n" + ""}, { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "intArray_MemoryUsage(intArray self) -> long"}, { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "intArray_Read(intArray self, bool on_dev=True) -> int const"}, { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "intArray_HostRead(intArray self) -> int const *"}, @@ -11674,7 +12057,9 @@ static PyMethodDef SwigMethods[] = { { "intArray_swigregister", intArray_swigregister, METH_O, NULL}, { "intArray_swiginit", intArray_swiginit, METH_VARARGS, NULL}, { "new_doubleArray", _wrap_new_doubleArray, METH_VARARGS, "\n" - "doubleArray(int asize=0)\n" + "doubleArray()\n" + "doubleArray(mfem::MemoryType mt)\n" + "doubleArray(int asize)\n" "doubleArray(double * _data)\n" "new_doubleArray(doubleArray src) -> doubleArray\n" ""}, @@ -11733,8 +12118,14 @@ static PyMethodDef SwigMethods[] = { { "doubleArray_IsSorted", _wrap_doubleArray_IsSorted, METH_O, "doubleArray_IsSorted(doubleArray self) -> int"}, { "doubleArray_PartialSum", _wrap_doubleArray_PartialSum, METH_O, "doubleArray_PartialSum(doubleArray self)"}, { "doubleArray_Sum", _wrap_doubleArray_Sum, METH_O, "doubleArray_Sum(doubleArray self) -> double"}, - { "doubleArray_begin", _wrap_doubleArray_begin, METH_O, "doubleArray_begin(doubleArray self) -> double *"}, - { "doubleArray_end", _wrap_doubleArray_end, METH_O, "doubleArray_end(doubleArray self) -> double *"}, + { "doubleArray_begin", _wrap_doubleArray_begin, METH_VARARGS, "\n" + "doubleArray_begin(doubleArray self) -> double\n" + "doubleArray_begin(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_end", _wrap_doubleArray_end, METH_VARARGS, "\n" + "doubleArray_end(doubleArray self) -> double\n" + "doubleArray_end(doubleArray self) -> double const *\n" + ""}, { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "doubleArray_MemoryUsage(doubleArray self) -> long"}, { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "doubleArray_Read(doubleArray self, bool on_dev=True) -> double const"}, { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "doubleArray_HostRead(doubleArray self) -> double const *"}, @@ -11774,6 +12165,208 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intArray", _wrap_new_intArray, METH_VARARGS, "\n" + "intArray()\n" + "intArray(mfem::MemoryType mt)\n" + "intArray(int asize)\n" + "intArray(int * _data)\n" + "new_intArray(intArray src) -> intArray\n" + ""}, + { "delete_intArray", _wrap_delete_intArray, METH_O, "delete_intArray(intArray self)"}, + { "intArray_GetData", _wrap_intArray_GetData, METH_VARARGS, "\n" + "GetData(intArray self) -> int\n" + "GetData(intArray self) -> int const *\n" + ""}, + { "intArray_GetMemory", _wrap_intArray_GetMemory, METH_VARARGS, "\n" + "GetMemory(intArray self) -> mfem::Memory< int >\n" + "GetMemory(intArray self) -> mfem::Memory< int > const &\n" + ""}, + { "intArray_UseDevice", _wrap_intArray_UseDevice, METH_O, "UseDevice(intArray self) -> bool"}, + { "intArray_OwnsData", _wrap_intArray_OwnsData, METH_O, "OwnsData(intArray self) -> bool"}, + { "intArray_StealData", _wrap_intArray_StealData, METH_VARARGS, "StealData(intArray self, int ** p)"}, + { "intArray_LoseData", _wrap_intArray_LoseData, METH_O, "LoseData(intArray self)"}, + { "intArray_MakeDataOwner", _wrap_intArray_MakeDataOwner, METH_O, "MakeDataOwner(intArray self)"}, + { "intArray_Size", _wrap_intArray_Size, METH_O, "Size(intArray self) -> int"}, + { "intArray_SetSize", _wrap_intArray_SetSize, METH_VARARGS, "\n" + "SetSize(intArray self, int nsize)\n" + "SetSize(intArray self, int nsize, int const & initval)\n" + "SetSize(intArray self, int nsize, mfem::MemoryType mt)\n" + ""}, + { "intArray_Capacity", _wrap_intArray_Capacity, METH_O, "Capacity(intArray self) -> int"}, + { "intArray_Reserve", _wrap_intArray_Reserve, METH_VARARGS, "Reserve(intArray self, int capacity)"}, + { "intArray_Append", _wrap_intArray_Append, METH_VARARGS, "\n" + "Append(intArray self, int const & el) -> int\n" + "Append(intArray self, int const * els, int nels) -> int\n" + "Append(intArray self, intArray els) -> int\n" + ""}, + { "intArray_Prepend", _wrap_intArray_Prepend, METH_VARARGS, "Prepend(intArray self, int const & el) -> int"}, + { "intArray_Last", _wrap_intArray_Last, METH_VARARGS, "\n" + "Last(intArray self) -> int\n" + "Last(intArray self) -> int const &\n" + ""}, + { "intArray_Union", _wrap_intArray_Union, METH_VARARGS, "Union(intArray self, int const & el) -> int"}, + { "intArray_Find", _wrap_intArray_Find, METH_VARARGS, "Find(intArray self, int const & el) -> int"}, + { "intArray_FindSorted", _wrap_intArray_FindSorted, METH_VARARGS, "FindSorted(intArray self, int const & el) -> int"}, + { "intArray_DeleteLast", _wrap_intArray_DeleteLast, METH_O, "DeleteLast(intArray self)"}, + { "intArray_DeleteFirst", _wrap_intArray_DeleteFirst, METH_VARARGS, "DeleteFirst(intArray self, int const & el)"}, + { "intArray_DeleteAll", _wrap_intArray_DeleteAll, METH_O, "DeleteAll(intArray self)"}, + { "intArray_Copy", _wrap_intArray_Copy, METH_VARARGS, "Copy(intArray self, intArray copy)"}, + { "intArray_MakeRef", _wrap_intArray_MakeRef, METH_VARARGS, "\n" + "MakeRef(intArray self, int * arg2, int arg3)\n" + "MakeRef(intArray self, intArray master)\n" + ""}, + { "intArray_GetSubArray", _wrap_intArray_GetSubArray, METH_VARARGS, "GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, + { "intArray_Load", _wrap_intArray_Load, METH_VARARGS, "\n" + "Load(intArray self, std::istream & _in, int fmt=0)\n" + "Load(intArray self, int new_size, std::istream & _in)\n" + ""}, + { "intArray_Max", _wrap_intArray_Max, METH_O, "Max(intArray self) -> int"}, + { "intArray_Min", _wrap_intArray_Min, METH_O, "Min(intArray self) -> int"}, + { "intArray_Sort", _wrap_intArray_Sort, METH_O, "Sort(intArray self)"}, + { "intArray_Unique", _wrap_intArray_Unique, METH_O, "Unique(intArray self)"}, + { "intArray_IsSorted", _wrap_intArray_IsSorted, METH_O, "IsSorted(intArray self) -> int"}, + { "intArray_PartialSum", _wrap_intArray_PartialSum, METH_O, "PartialSum(intArray self)"}, + { "intArray_Sum", _wrap_intArray_Sum, METH_O, "Sum(intArray self) -> int"}, + { "intArray_begin", _wrap_intArray_begin, METH_VARARGS, "\n" + "begin(intArray self) -> int\n" + "begin(intArray self) -> int const *\n" + ""}, + { "intArray_end", _wrap_intArray_end, METH_VARARGS, "\n" + "end(intArray self) -> int\n" + "end(intArray self) -> int const *\n" + ""}, + { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "MemoryUsage(intArray self) -> long"}, + { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "Read(intArray self, bool on_dev=True) -> int const"}, + { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "HostRead(intArray self) -> int const *"}, + { "intArray_Write", _wrap_intArray_Write, METH_VARARGS, "Write(intArray self, bool on_dev=True) -> int"}, + { "intArray_HostWrite", _wrap_intArray_HostWrite, METH_O, "HostWrite(intArray self) -> int *"}, + { "intArray_ReadWrite", _wrap_intArray_ReadWrite, METH_VARARGS, "ReadWrite(intArray self, bool on_dev=True) -> int"}, + { "intArray_HostReadWrite", _wrap_intArray_HostReadWrite, METH_O, "HostReadWrite(intArray self) -> int *"}, + { "intArray___setitem__", _wrap_intArray___setitem__, METH_VARARGS, "__setitem__(intArray self, int i, int const v)"}, + { "intArray___getitem__", _wrap_intArray___getitem__, METH_VARARGS, "__getitem__(intArray self, int const i) -> int const &"}, + { "intArray_Assign", _wrap_intArray_Assign, METH_VARARGS, "\n" + "Assign(intArray self, int const * arg2)\n" + "Assign(intArray self, int const & a)\n" + ""}, + { "intArray_FakeToList", _wrap_intArray_FakeToList, METH_O, "FakeToList(intArray self)"}, + { "intArray_Print", _wrap_intArray_Print, METH_VARARGS, "\n" + "Print(intArray self, std::ostream & out=mfem::out, int width=4)\n" + "Print(intArray self, char const * file, int precision=8)\n" + ""}, + { "intArray_Save", _wrap_intArray_Save, METH_VARARGS, "\n" + "Save(intArray self, std::ostream & out, int fmt=0)\n" + "Save(intArray self, char const * file, int precision=8)\n" + "Save(intArray self)\n" + ""}, + { "intArray_swigregister", intArray_swigregister, METH_O, NULL}, + { "intArray_swiginit", intArray_swiginit, METH_VARARGS, NULL}, + { "new_doubleArray", _wrap_new_doubleArray, METH_VARARGS, "\n" + "doubleArray()\n" + "doubleArray(mfem::MemoryType mt)\n" + "doubleArray(int asize)\n" + "doubleArray(double * _data)\n" + "new_doubleArray(doubleArray src) -> doubleArray\n" + ""}, + { "delete_doubleArray", _wrap_delete_doubleArray, METH_O, "delete_doubleArray(doubleArray self)"}, + { "doubleArray_GetData", _wrap_doubleArray_GetData, METH_VARARGS, "\n" + "GetData(doubleArray self) -> double\n" + "GetData(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_GetMemory", _wrap_doubleArray_GetMemory, METH_VARARGS, "\n" + "GetMemory(doubleArray self) -> mfem::Memory< double >\n" + "GetMemory(doubleArray self) -> mfem::Memory< double > const &\n" + ""}, + { "doubleArray_UseDevice", _wrap_doubleArray_UseDevice, METH_O, "UseDevice(doubleArray self) -> bool"}, + { "doubleArray_OwnsData", _wrap_doubleArray_OwnsData, METH_O, "OwnsData(doubleArray self) -> bool"}, + { "doubleArray_StealData", _wrap_doubleArray_StealData, METH_VARARGS, "StealData(doubleArray self, double ** p)"}, + { "doubleArray_LoseData", _wrap_doubleArray_LoseData, METH_O, "LoseData(doubleArray self)"}, + { "doubleArray_MakeDataOwner", _wrap_doubleArray_MakeDataOwner, METH_O, "MakeDataOwner(doubleArray self)"}, + { "doubleArray_Size", _wrap_doubleArray_Size, METH_O, "Size(doubleArray self) -> int"}, + { "doubleArray_SetSize", _wrap_doubleArray_SetSize, METH_VARARGS, "\n" + "SetSize(doubleArray self, int nsize)\n" + "SetSize(doubleArray self, int nsize, double const & initval)\n" + "SetSize(doubleArray self, int nsize, mfem::MemoryType mt)\n" + ""}, + { "doubleArray_Capacity", _wrap_doubleArray_Capacity, METH_O, "Capacity(doubleArray self) -> int"}, + { "doubleArray_Reserve", _wrap_doubleArray_Reserve, METH_VARARGS, "Reserve(doubleArray self, int capacity)"}, + { "doubleArray_Append", _wrap_doubleArray_Append, METH_VARARGS, "\n" + "Append(doubleArray self, double const & el) -> int\n" + "Append(doubleArray self, double const * els, int nels) -> int\n" + "Append(doubleArray self, doubleArray els) -> int\n" + ""}, + { "doubleArray_Prepend", _wrap_doubleArray_Prepend, METH_VARARGS, "Prepend(doubleArray self, double const & el) -> int"}, + { "doubleArray_Last", _wrap_doubleArray_Last, METH_VARARGS, "\n" + "Last(doubleArray self) -> double\n" + "Last(doubleArray self) -> double const &\n" + ""}, + { "doubleArray_Union", _wrap_doubleArray_Union, METH_VARARGS, "Union(doubleArray self, double const & el) -> int"}, + { "doubleArray_Find", _wrap_doubleArray_Find, METH_VARARGS, "Find(doubleArray self, double const & el) -> int"}, + { "doubleArray_FindSorted", _wrap_doubleArray_FindSorted, METH_VARARGS, "FindSorted(doubleArray self, double const & el) -> int"}, + { "doubleArray_DeleteLast", _wrap_doubleArray_DeleteLast, METH_O, "DeleteLast(doubleArray self)"}, + { "doubleArray_DeleteFirst", _wrap_doubleArray_DeleteFirst, METH_VARARGS, "DeleteFirst(doubleArray self, double const & el)"}, + { "doubleArray_DeleteAll", _wrap_doubleArray_DeleteAll, METH_O, "DeleteAll(doubleArray self)"}, + { "doubleArray_Copy", _wrap_doubleArray_Copy, METH_VARARGS, "Copy(doubleArray self, doubleArray copy)"}, + { "doubleArray_MakeRef", _wrap_doubleArray_MakeRef, METH_VARARGS, "\n" + "MakeRef(doubleArray self, double * arg2, int arg3)\n" + "MakeRef(doubleArray self, doubleArray master)\n" + ""}, + { "doubleArray_GetSubArray", _wrap_doubleArray_GetSubArray, METH_VARARGS, "GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, + { "doubleArray_Load", _wrap_doubleArray_Load, METH_VARARGS, "\n" + "Load(doubleArray self, std::istream & _in, int fmt=0)\n" + "Load(doubleArray self, int new_size, std::istream & _in)\n" + ""}, + { "doubleArray_Max", _wrap_doubleArray_Max, METH_O, "Max(doubleArray self) -> double"}, + { "doubleArray_Min", _wrap_doubleArray_Min, METH_O, "Min(doubleArray self) -> double"}, + { "doubleArray_Sort", _wrap_doubleArray_Sort, METH_O, "Sort(doubleArray self)"}, + { "doubleArray_Unique", _wrap_doubleArray_Unique, METH_O, "Unique(doubleArray self)"}, + { "doubleArray_IsSorted", _wrap_doubleArray_IsSorted, METH_O, "IsSorted(doubleArray self) -> int"}, + { "doubleArray_PartialSum", _wrap_doubleArray_PartialSum, METH_O, "PartialSum(doubleArray self)"}, + { "doubleArray_Sum", _wrap_doubleArray_Sum, METH_O, "Sum(doubleArray self) -> double"}, + { "doubleArray_begin", _wrap_doubleArray_begin, METH_VARARGS, "\n" + "begin(doubleArray self) -> double\n" + "begin(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_end", _wrap_doubleArray_end, METH_VARARGS, "\n" + "end(doubleArray self) -> double\n" + "end(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "MemoryUsage(doubleArray self) -> long"}, + { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "Read(doubleArray self, bool on_dev=True) -> double const"}, + { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "HostRead(doubleArray self) -> double const *"}, + { "doubleArray_Write", _wrap_doubleArray_Write, METH_VARARGS, "Write(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_HostWrite", _wrap_doubleArray_HostWrite, METH_O, "HostWrite(doubleArray self) -> double *"}, + { "doubleArray_ReadWrite", _wrap_doubleArray_ReadWrite, METH_VARARGS, "ReadWrite(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_HostReadWrite", _wrap_doubleArray_HostReadWrite, METH_O, "HostReadWrite(doubleArray self) -> double *"}, + { "doubleArray___setitem__", _wrap_doubleArray___setitem__, METH_VARARGS, "__setitem__(doubleArray self, int i, double const v)"}, + { "doubleArray___getitem__", _wrap_doubleArray___getitem__, METH_VARARGS, "__getitem__(doubleArray self, int const i) -> double const &"}, + { "doubleArray_Assign", _wrap_doubleArray_Assign, METH_VARARGS, "\n" + "Assign(doubleArray self, double const * arg2)\n" + "Assign(doubleArray self, double const & a)\n" + ""}, + { "doubleArray_FakeToList", _wrap_doubleArray_FakeToList, METH_O, "FakeToList(doubleArray self)"}, + { "doubleArray_Print", _wrap_doubleArray_Print, METH_VARARGS, "\n" + "Print(doubleArray self, std::ostream & out=mfem::out, int width=4)\n" + "Print(doubleArray self, char const * file, int precision=8)\n" + ""}, + { "doubleArray_Save", _wrap_doubleArray_Save, METH_VARARGS, "\n" + "Save(doubleArray self, std::ostream & out, int fmt=0)\n" + "Save(doubleArray self, char const * file, int precision=8)\n" + "Save(doubleArray self)\n" + ""}, + { "doubleArray_swigregister", doubleArray_swigregister, METH_O, NULL}, + { "doubleArray_swiginit", doubleArray_swiginit, METH_VARARGS, NULL}, + { "doubleSwap", _wrap_doubleSwap, METH_VARARGS, "\n" + "doubleSwap(doubleArray arg1, doubleArray arg2)\n" + "doubleSwap(mfem::Array2D< double > & arg1, mfem::Array2D< double > & arg2)\n" + "doubleSwap(double & a, double & b)\n" + ""}, + { "intSwap", _wrap_intSwap, METH_VARARGS, "\n" + "intSwap(intArray arg1, intArray arg2)\n" + "intSwap(mfem::Array2D< int > & arg1, mfem::Array2D< int > & arg2)\n" + "intSwap(int & a, int & b)\n" + ""}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/bilinearform.py b/mfem/_par/bilinearform.py index d2c66715..27c0f042 100644 --- a/mfem/_par/bilinearform.py +++ b/mfem/_par/bilinearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _bilinearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _bilinearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -78,6 +81,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -89,6 +93,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction AssemblyLevel_FULL = _bilinearform.AssemblyLevel_FULL AssemblyLevel_ELEMENT = _bilinearform.AssemblyLevel_ELEMENT @@ -118,22 +123,32 @@ def __init__(self, *args): def Size(self): r"""Size(BilinearForm self) -> int""" return _bilinearform.BilinearForm_Size(self) + Size = _swig_new_instance_method(_bilinearform.BilinearForm_Size) def SetAssemblyLevel(self, assembly_level): r"""SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)""" return _bilinearform.BilinearForm_SetAssemblyLevel(self, assembly_level) + SetAssemblyLevel = _swig_new_instance_method(_bilinearform.BilinearForm_SetAssemblyLevel) + + def GetAssemblyLevel(self): + r"""GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel""" + return _bilinearform.BilinearForm_GetAssemblyLevel(self) + GetAssemblyLevel = _swig_new_instance_method(_bilinearform.BilinearForm_GetAssemblyLevel) def EnableStaticCondensation(self): r"""EnableStaticCondensation(BilinearForm self)""" return _bilinearform.BilinearForm_EnableStaticCondensation(self) + EnableStaticCondensation = _swig_new_instance_method(_bilinearform.BilinearForm_EnableStaticCondensation) def StaticCondensationIsEnabled(self): r"""StaticCondensationIsEnabled(BilinearForm self) -> bool""" return _bilinearform.BilinearForm_StaticCondensationIsEnabled(self) + StaticCondensationIsEnabled = _swig_new_instance_method(_bilinearform.BilinearForm_StaticCondensationIsEnabled) def SCFESpace(self): r"""SCFESpace(BilinearForm self) -> FiniteElementSpace""" return _bilinearform.BilinearForm_SCFESpace(self) + SCFESpace = _swig_new_instance_method(_bilinearform.BilinearForm_SCFESpace) def EnableHybridization(self, constr_space, constr_integ, ess_tdof_list): r"""EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)""" @@ -150,6 +165,7 @@ def EnableHybridization(self, constr_space, constr_integ, ess_tdof_list): def UsePrecomputedSparsity(self, ps=1): r"""UsePrecomputedSparsity(BilinearForm self, int ps=1)""" return _bilinearform.BilinearForm_UsePrecomputedSparsity(self, ps) + UsePrecomputedSparsity = _swig_new_instance_method(_bilinearform.BilinearForm_UsePrecomputedSparsity) def UseSparsity(self, *args): r""" @@ -157,38 +173,47 @@ def UseSparsity(self, *args): UseSparsity(BilinearForm self, SparseMatrix A) """ return _bilinearform.BilinearForm_UseSparsity(self, *args) + UseSparsity = _swig_new_instance_method(_bilinearform.BilinearForm_UseSparsity) def AllocateMatrix(self): r"""AllocateMatrix(BilinearForm self)""" return _bilinearform.BilinearForm_AllocateMatrix(self) + AllocateMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_AllocateMatrix) def GetDBFI(self): r"""GetDBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetDBFI(self) + GetDBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetDBFI) def GetBBFI(self): r"""GetBBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetBBFI(self) + GetBBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetBBFI) def GetBBFI_Marker(self): r"""GetBBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" return _bilinearform.BilinearForm_GetBBFI_Marker(self) + GetBBFI_Marker = _swig_new_instance_method(_bilinearform.BilinearForm_GetBBFI_Marker) def GetFBFI(self): r"""GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetFBFI(self) + GetFBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetFBFI) def GetBFBFI(self): r"""GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetBFBFI(self) + GetBFBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetBFBFI) def GetBFBFI_Marker(self): r"""GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" return _bilinearform.BilinearForm_GetBFBFI_Marker(self) + GetBFBFI_Marker = _swig_new_instance_method(_bilinearform.BilinearForm_GetBFBFI_Marker) def __call__(self, i, j): r"""__call__(BilinearForm self, int i, int j) -> double const &""" return _bilinearform.BilinearForm___call__(self, i, j) + __call__ = _swig_new_instance_method(_bilinearform.BilinearForm___call__) def Elem(self, *args): r""" @@ -196,46 +221,57 @@ def Elem(self, *args): Elem(BilinearForm self, int i, int j) -> double const & """ return _bilinearform.BilinearForm_Elem(self, *args) + Elem = _swig_new_instance_method(_bilinearform.BilinearForm_Elem) def Mult(self, x, y): r"""Mult(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_bilinearform.BilinearForm_Mult) def FullMult(self, x, y): r"""FullMult(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_FullMult(self, x, y) + FullMult = _swig_new_instance_method(_bilinearform.BilinearForm_FullMult) def AddMult(self, x, y, a=1.0): r"""AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)""" return _bilinearform.BilinearForm_AddMult(self, x, y, a) + AddMult = _swig_new_instance_method(_bilinearform.BilinearForm_AddMult) def FullAddMult(self, x, y): r"""FullAddMult(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_FullAddMult(self, x, y) + FullAddMult = _swig_new_instance_method(_bilinearform.BilinearForm_FullAddMult) def AddMultTranspose(self, x, y, a=1.0): r"""AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)""" return _bilinearform.BilinearForm_AddMultTranspose(self, x, y, a) + AddMultTranspose = _swig_new_instance_method(_bilinearform.BilinearForm_AddMultTranspose) def FullAddMultTranspose(self, x, y): r"""FullAddMultTranspose(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_FullAddMultTranspose(self, x, y) + FullAddMultTranspose = _swig_new_instance_method(_bilinearform.BilinearForm_FullAddMultTranspose) def MultTranspose(self, x, y): r"""MultTranspose(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_bilinearform.BilinearForm_MultTranspose) def InnerProduct(self, x, y): r"""InnerProduct(BilinearForm self, Vector x, Vector y) -> double""" return _bilinearform.BilinearForm_InnerProduct(self, x, y) + InnerProduct = _swig_new_instance_method(_bilinearform.BilinearForm_InnerProduct) def Inverse(self): r"""Inverse(BilinearForm self) -> MatrixInverse""" return _bilinearform.BilinearForm_Inverse(self) + Inverse = _swig_new_instance_method(_bilinearform.BilinearForm_Inverse) def Finalize(self, skip_zeros=1): r"""Finalize(BilinearForm self, int skip_zeros=1)""" return _bilinearform.BilinearForm_Finalize(self, skip_zeros) + Finalize = _swig_new_instance_method(_bilinearform.BilinearForm_Finalize) def SpMat(self, *args): r""" @@ -255,6 +291,7 @@ def SpMat(self, *args): def LoseMat(self): r"""LoseMat(BilinearForm self) -> SparseMatrix""" return _bilinearform.BilinearForm_LoseMat(self) + LoseMat = _swig_new_instance_method(_bilinearform.BilinearForm_LoseMat) def SpMatElim(self, *args): r""" @@ -262,6 +299,7 @@ def SpMatElim(self, *args): SpMatElim(BilinearForm self) -> SparseMatrix """ return _bilinearform.BilinearForm_SpMatElim(self, *args) + SpMatElim = _swig_new_instance_method(_bilinearform.BilinearForm_SpMatElim) def AddDomainIntegrator(self, bfi): r"""AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)""" @@ -318,38 +356,73 @@ def AddBdrFaceIntegrator(self, *args): def Assemble(self, skip_zeros=1): r"""Assemble(BilinearForm self, int skip_zeros=1)""" return _bilinearform.BilinearForm_Assemble(self, skip_zeros) + Assemble = _swig_new_instance_method(_bilinearform.BilinearForm_Assemble) + + def AssembleDiagonal(self, diag): + r"""AssembleDiagonal(BilinearForm self, Vector diag)""" + return _bilinearform.BilinearForm_AssembleDiagonal(self, diag) + AssembleDiagonal = _swig_new_instance_method(_bilinearform.BilinearForm_AssembleDiagonal) def GetProlongation(self): r"""GetProlongation(BilinearForm self) -> Operator""" return _bilinearform.BilinearForm_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_bilinearform.BilinearForm_GetProlongation) def GetRestriction(self): r"""GetRestriction(BilinearForm self) -> Operator""" return _bilinearform.BilinearForm_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_bilinearform.BilinearForm_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(BilinearForm self) -> Operator""" + return _bilinearform.BilinearForm_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_bilinearform.BilinearForm_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(BilinearForm self) -> Operator""" + return _bilinearform.BilinearForm_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_bilinearform.BilinearForm_GetOutputRestriction) def RecoverFEMSolution(self, X, b, x): r"""RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)""" return _bilinearform.BilinearForm_RecoverFEMSolution(self, X, b, x) + RecoverFEMSolution = _swig_new_instance_method(_bilinearform.BilinearForm_RecoverFEMSolution) def ComputeElementMatrices(self): r"""ComputeElementMatrices(BilinearForm self)""" return _bilinearform.BilinearForm_ComputeElementMatrices(self) + ComputeElementMatrices = _swig_new_instance_method(_bilinearform.BilinearForm_ComputeElementMatrices) def FreeElementMatrices(self): r"""FreeElementMatrices(BilinearForm self)""" return _bilinearform.BilinearForm_FreeElementMatrices(self) + FreeElementMatrices = _swig_new_instance_method(_bilinearform.BilinearForm_FreeElementMatrices) def ComputeElementMatrix(self, i, elmat): r"""ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)""" return _bilinearform.BilinearForm_ComputeElementMatrix(self, i, elmat) + ComputeElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_ComputeElementMatrix) + + def ComputeBdrElementMatrix(self, i, elmat): + r"""ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)""" + return _bilinearform.BilinearForm_ComputeBdrElementMatrix(self, i, elmat) + ComputeBdrElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_ComputeBdrElementMatrix) - def AssembleElementMatrix(self, i, elmat, vdofs, skip_zeros=1): - r"""AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)""" - return _bilinearform.BilinearForm_AssembleElementMatrix(self, i, elmat, vdofs, skip_zeros) + def AssembleElementMatrix(self, *args): + r""" + AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1) + """ + return _bilinearform.BilinearForm_AssembleElementMatrix(self, *args) + AssembleElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_AssembleElementMatrix) - def AssembleBdrElementMatrix(self, i, elmat, vdofs, skip_zeros=1): - r"""AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)""" - return _bilinearform.BilinearForm_AssembleBdrElementMatrix(self, i, elmat, vdofs, skip_zeros) + def AssembleBdrElementMatrix(self, *args): + r""" + AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1) + """ + return _bilinearform.BilinearForm_AssembleBdrElementMatrix(self, *args) + AssembleBdrElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_AssembleBdrElementMatrix) def EliminateEssentialBC(self, *args): r""" @@ -357,10 +430,12 @@ def EliminateEssentialBC(self, *args): EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _bilinearform.BilinearForm_EliminateEssentialBC(self, *args) + EliminateEssentialBC = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBC) def EliminateEssentialBCDiag(self, bdr_attr_is_ess, value): r"""EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)""" return _bilinearform.BilinearForm_EliminateEssentialBCDiag(self, bdr_attr_is_ess, value) + EliminateEssentialBCDiag = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBCDiag) def EliminateVDofs(self, *args): r""" @@ -368,6 +443,7 @@ def EliminateVDofs(self, *args): EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _bilinearform.BilinearForm_EliminateVDofs(self, *args) + EliminateVDofs = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateVDofs) def EliminateEssentialBCFromDofs(self, *args): r""" @@ -375,26 +451,32 @@ def EliminateEssentialBCFromDofs(self, *args): EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _bilinearform.BilinearForm_EliminateEssentialBCFromDofs(self, *args) + EliminateEssentialBCFromDofs = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBCFromDofs) def EliminateEssentialBCFromDofsDiag(self, ess_dofs, value): r"""EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)""" return _bilinearform.BilinearForm_EliminateEssentialBCFromDofsDiag(self, ess_dofs, value) + EliminateEssentialBCFromDofsDiag = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBCFromDofsDiag) def EliminateVDofsInRHS(self, vdofs, x, b): r"""EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)""" return _bilinearform.BilinearForm_EliminateVDofsInRHS(self, vdofs, x, b) + EliminateVDofsInRHS = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateVDofsInRHS) def FullInnerProduct(self, x, y): r"""FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double""" return _bilinearform.BilinearForm_FullInnerProduct(self, x, y) + FullInnerProduct = _swig_new_instance_method(_bilinearform.BilinearForm_FullInnerProduct) def Update(self, nfes=None): r"""Update(BilinearForm self, FiniteElementSpace nfes=None)""" return _bilinearform.BilinearForm_Update(self, nfes) + Update = _swig_new_instance_method(_bilinearform.BilinearForm_Update) def GetFES(self): r"""GetFES(BilinearForm self) -> FiniteElementSpace""" return _bilinearform.BilinearForm_GetFES(self) + GetFES = _swig_new_instance_method(_bilinearform.BilinearForm_GetFES) def FESpace(self, *args): r""" @@ -402,10 +484,17 @@ def FESpace(self, *args): FESpace(BilinearForm self) -> FiniteElementSpace """ return _bilinearform.BilinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_bilinearform.BilinearForm_FESpace) def SetDiagonalPolicy(self, policy): r"""SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)""" return _bilinearform.BilinearForm_SetDiagonalPolicy(self, policy) + SetDiagonalPolicy = _swig_new_instance_method(_bilinearform.BilinearForm_SetDiagonalPolicy) + + def UseExternalIntegrators(self): + r"""UseExternalIntegrators(BilinearForm self)""" + return _bilinearform.BilinearForm_UseExternalIntegrators(self) + UseExternalIntegrators = _swig_new_instance_method(_bilinearform.BilinearForm_UseExternalIntegrators) __swig_destroy__ = _bilinearform.delete_BilinearForm def FormLinearSystem(self, *args): @@ -415,6 +504,7 @@ def FormLinearSystem(self, *args): FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, HypreParMatrix A, Vector X, Vector B, int copy_interior=0) """ return _bilinearform.BilinearForm_FormLinearSystem(self, *args) + FormLinearSystem = _swig_new_instance_method(_bilinearform.BilinearForm_FormLinearSystem) def FormSystemMatrix(self, *args): r""" @@ -423,6 +513,7 @@ def FormSystemMatrix(self, *args): FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, HypreParMatrix A) """ return _bilinearform.BilinearForm_FormSystemMatrix(self, *args) + FormSystemMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_FormSystemMatrix) def __disown__(self): self.this.disown() _bilinearform.disown_BilinearForm(self) @@ -450,34 +541,42 @@ def Elem(self, *args): Elem(MixedBilinearForm self, int i, int j) -> double const & """ return _bilinearform.MixedBilinearForm_Elem(self, *args) + Elem = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Elem) def Mult(self, x, y): r"""Mult(MixedBilinearForm self, Vector x, Vector y)""" return _bilinearform.MixedBilinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Mult) def AddMult(self, x, y, a=1.0): r"""AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)""" return _bilinearform.MixedBilinearForm_AddMult(self, x, y, a) - - def AddMultTranspose(self, x, y, a=1.0): - r"""AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)""" - return _bilinearform.MixedBilinearForm_AddMultTranspose(self, x, y, a) + AddMult = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(MixedBilinearForm self, Vector x, Vector y)""" return _bilinearform.MixedBilinearForm_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_bilinearform.MixedBilinearForm_MultTranspose) + + def AddMultTranspose(self, x, y, a=1.0): + r"""AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)""" + return _bilinearform.MixedBilinearForm_AddMultTranspose(self, x, y, a) + AddMultTranspose = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AddMultTranspose) def Inverse(self): r"""Inverse(MixedBilinearForm self) -> MatrixInverse""" return _bilinearform.MixedBilinearForm_Inverse(self) + Inverse = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Inverse) def Finalize(self, skip_zeros=1): r"""Finalize(MixedBilinearForm self, int skip_zeros=1)""" return _bilinearform.MixedBilinearForm_Finalize(self, skip_zeros) + Finalize = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Finalize) def GetBlocks(self, blocks): r"""GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)""" return _bilinearform.MixedBilinearForm_GetBlocks(self, blocks) + GetBlocks = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBlocks) def SpMat(self, *args): r""" @@ -497,6 +596,7 @@ def SpMat(self, *args): def LoseMat(self): r"""LoseMat(MixedBilinearForm self) -> SparseMatrix""" return _bilinearform.MixedBilinearForm_LoseMat(self) + LoseMat = _swig_new_instance_method(_bilinearform.MixedBilinearForm_LoseMat) def AddDomainIntegrator(self, bfi): r"""AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)""" @@ -509,15 +609,18 @@ def AddDomainIntegrator(self, bfi): return _bilinearform.MixedBilinearForm_AddDomainIntegrator(self, bfi) - def AddBoundaryIntegrator(self, bfi): - r"""AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)""" + def AddBoundaryIntegrator(self, *args): + r""" + AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi) + AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker) + """ if not hasattr(self, "_integrators"): self._integrators = [] self._integrators.append(bfi) bfi.thisown=0 - return _bilinearform.MixedBilinearForm_AddBoundaryIntegrator(self, bfi) + return _bilinearform.MixedBilinearForm_AddBoundaryIntegrator(self, *args) def AddTraceFaceIntegrator(self, bfi): @@ -531,41 +634,150 @@ def AddTraceFaceIntegrator(self, bfi): return _bilinearform.MixedBilinearForm_AddTraceFaceIntegrator(self, bfi) + def AddBdrTraceFaceIntegrator(self, *args): + r""" + AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi) + AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker) + """ + return _bilinearform.MixedBilinearForm_AddBdrTraceFaceIntegrator(self, *args) + AddBdrTraceFaceIntegrator = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AddBdrTraceFaceIntegrator) + def GetDBFI(self): r"""GetDBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.MixedBilinearForm_GetDBFI(self) + GetDBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetDBFI) def GetBBFI(self): r"""GetBBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.MixedBilinearForm_GetBBFI(self) + GetBBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBBFI) + + def GetBBFI_Marker(self): + r"""GetBBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" + return _bilinearform.MixedBilinearForm_GetBBFI_Marker(self) + GetBBFI_Marker = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBBFI_Marker) def GetTFBFI(self): r"""GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.MixedBilinearForm_GetTFBFI(self) + GetTFBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetTFBFI) + + def GetBTFBFI(self): + r"""GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" + return _bilinearform.MixedBilinearForm_GetBTFBFI(self) + GetBTFBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBTFBFI) + + def GetBTFBFI_Marker(self): + r"""GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" + return _bilinearform.MixedBilinearForm_GetBTFBFI_Marker(self) + GetBTFBFI_Marker = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBTFBFI_Marker) + + def SetAssemblyLevel(self, assembly_level): + r"""SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)""" + return _bilinearform.MixedBilinearForm_SetAssemblyLevel(self, assembly_level) + SetAssemblyLevel = _swig_new_instance_method(_bilinearform.MixedBilinearForm_SetAssemblyLevel) def Assemble(self, skip_zeros=1): r"""Assemble(MixedBilinearForm self, int skip_zeros=1)""" return _bilinearform.MixedBilinearForm_Assemble(self, skip_zeros) + Assemble = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Assemble) + + def GetProlongation(self): + r"""GetProlongation(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetProlongation) + + def GetRestriction(self): + r"""GetRestriction(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetOutputRestriction) def ConformingAssemble(self): r"""ConformingAssemble(MixedBilinearForm self)""" return _bilinearform.MixedBilinearForm_ConformingAssemble(self) + ConformingAssemble = _swig_new_instance_method(_bilinearform.MixedBilinearForm_ConformingAssemble) + + def ComputeElementMatrix(self, i, elmat): + r"""ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)""" + return _bilinearform.MixedBilinearForm_ComputeElementMatrix(self, i, elmat) + ComputeElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_ComputeElementMatrix) + + def ComputeBdrElementMatrix(self, i, elmat): + r"""ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)""" + return _bilinearform.MixedBilinearForm_ComputeBdrElementMatrix(self, i, elmat) + ComputeBdrElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_ComputeBdrElementMatrix) + + def AssembleElementMatrix(self, *args): + r""" + AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1) + """ + return _bilinearform.MixedBilinearForm_AssembleElementMatrix(self, *args) + AssembleElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AssembleElementMatrix) + + def AssembleBdrElementMatrix(self, *args): + r""" + AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1) + """ + return _bilinearform.MixedBilinearForm_AssembleBdrElementMatrix(self, *args) + AssembleBdrElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AssembleBdrElementMatrix) def EliminateTrialDofs(self, bdr_attr_is_ess, sol, rhs): r"""EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)""" return _bilinearform.MixedBilinearForm_EliminateTrialDofs(self, bdr_attr_is_ess, sol, rhs) + EliminateTrialDofs = _swig_new_instance_method(_bilinearform.MixedBilinearForm_EliminateTrialDofs) def EliminateEssentialBCFromTrialDofs(self, marked_vdofs, sol, rhs): r"""EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)""" return _bilinearform.MixedBilinearForm_EliminateEssentialBCFromTrialDofs(self, marked_vdofs, sol, rhs) + EliminateEssentialBCFromTrialDofs = _swig_new_instance_method(_bilinearform.MixedBilinearForm_EliminateEssentialBCFromTrialDofs) def EliminateTestDofs(self, bdr_attr_is_ess): r"""EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)""" return _bilinearform.MixedBilinearForm_EliminateTestDofs(self, bdr_attr_is_ess) + EliminateTestDofs = _swig_new_instance_method(_bilinearform.MixedBilinearForm_EliminateTestDofs) + + def FormRectangularSystemMatrix(self, trial_tdof_list, test_tdof_list, A): + r"""FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)""" + return _bilinearform.MixedBilinearForm_FormRectangularSystemMatrix(self, trial_tdof_list, test_tdof_list, A) + FormRectangularSystemMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_FormRectangularSystemMatrix) + + def FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B): + r"""FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)""" + return _bilinearform.MixedBilinearForm_FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B) + FormRectangularLinearSystem = _swig_new_instance_method(_bilinearform.MixedBilinearForm_FormRectangularLinearSystem) def Update(self): r"""Update(MixedBilinearForm self)""" return _bilinearform.MixedBilinearForm_Update(self) + Update = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Update) + + def TrialFESpace(self, *args): + r""" + TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace + TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace + """ + return _bilinearform.MixedBilinearForm_TrialFESpace(self, *args) + TrialFESpace = _swig_new_instance_method(_bilinearform.MixedBilinearForm_TrialFESpace) + + def TestFESpace(self, *args): + r""" + TestFESpace(MixedBilinearForm self) -> FiniteElementSpace + TestFESpace(MixedBilinearForm self) -> FiniteElementSpace + """ + return _bilinearform.MixedBilinearForm_TestFESpace(self, *args) + TestFESpace = _swig_new_instance_method(_bilinearform.MixedBilinearForm_TestFESpace) __swig_destroy__ = _bilinearform.delete_MixedBilinearForm # Register MixedBilinearForm in _bilinearform: @@ -606,10 +818,12 @@ def AddTraceFaceInterpolator(self, di): def GetDI(self): r"""GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.DiscreteLinearOperator_GetDI(self) + GetDI = _swig_new_instance_method(_bilinearform.DiscreteLinearOperator_GetDI) def Assemble(self, skip_zeros=1): r"""Assemble(DiscreteLinearOperator self, int skip_zeros=1)""" return _bilinearform.DiscreteLinearOperator_Assemble(self, skip_zeros) + Assemble = _swig_new_instance_method(_bilinearform.DiscreteLinearOperator_Assemble) __swig_destroy__ = _bilinearform.delete_DiscreteLinearOperator # Register DiscreteLinearOperator in _bilinearform: diff --git a/mfem/_par/bilinearform_wrap.cxx b/mfem/_par/bilinearform_wrap.cxx index 07c7726a..f16ff660 100644 --- a/mfem/_par/bilinearform_wrap.cxx +++ b/mfem/_par/bilinearform_wrap.cxx @@ -3067,141 +3067,149 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_double swig_types[3] -#define SWIGTYPE_p_hex_t swig_types[4] -#define SWIGTYPE_p_int swig_types[5] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] -#define SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[9] -#define SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t swig_types[10] -#define SWIGTYPE_p_mfem__BilinearForm swig_types[11] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[12] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[14] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[17] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[18] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[20] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[21] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[22] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[23] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[24] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[25] -#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[26] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[27] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[28] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[29] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[30] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[31] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[32] -#define SWIGTYPE_p_mfem__GridFunction swig_types[33] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__HypreADS swig_types[35] -#define SWIGTYPE_p_mfem__HypreAMS swig_types[36] -#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[37] -#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[38] -#define SWIGTYPE_p_mfem__HypreEuclid swig_types[39] -#define SWIGTYPE_p_mfem__HypreGMRES swig_types[40] -#define SWIGTYPE_p_mfem__HypreIdentity swig_types[41] -#define SWIGTYPE_p_mfem__HyprePCG swig_types[42] -#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[43] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[44] -#define SWIGTYPE_p_mfem__HypreParaSails swig_types[45] -#define SWIGTYPE_p_mfem__HypreSmoother swig_types[46] -#define SWIGTYPE_p_mfem__HypreSolver swig_types[47] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[48] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[49] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[50] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[51] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[52] -#define SWIGTYPE_p_mfem__LinearForm swig_types[53] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__Matrix swig_types[56] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[57] -#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[58] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[59] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[60] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[61] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[62] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[63] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[66] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[67] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[74] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[75] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[76] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[77] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[78] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[79] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[80] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[82] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[83] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[86] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[90] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[93] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[94] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[95] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[96] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[97] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[98] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[99] -#define SWIGTYPE_p_mfem__Operator swig_types[100] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[101] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[102] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[103] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[104] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[105] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[106] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[107] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[108] -#define SWIGTYPE_p_mfem__Solver swig_types[109] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[110] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[111] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[112] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[113] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[114] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[115] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[116] -#define SWIGTYPE_p_mfem__Vector swig_types[117] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[118] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[119] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[120] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[121] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[122] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[123] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[124] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[125] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[126] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[127] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[128] -#define SWIGTYPE_p_pri_t swig_types[129] -#define SWIGTYPE_p_quad_t swig_types[130] -#define SWIGTYPE_p_seg_t swig_types[131] -#define SWIGTYPE_p_std__ostream swig_types[132] -#define SWIGTYPE_p_tet_t swig_types[133] -#define SWIGTYPE_p_tri_t swig_types[134] -static swig_type_info *swig_types[136]; -static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_double swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[7] +#define SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[10] +#define SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t swig_types[11] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[12] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[13] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[15] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[18] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[19] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[21] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[22] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[23] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[24] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[25] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[26] +#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[27] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[28] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[29] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[30] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[31] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[32] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[34] +#define SWIGTYPE_p_mfem__GridFunction swig_types[35] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[36] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[37] +#define SWIGTYPE_p_mfem__HypreADS swig_types[38] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[39] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[40] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[41] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[42] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[43] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[44] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[45] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[46] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[47] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[48] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[49] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[50] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[51] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[52] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[53] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[55] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[56] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[57] +#define SWIGTYPE_p_mfem__LinearForm swig_types[58] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[60] +#define SWIGTYPE_p_mfem__Matrix swig_types[61] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[62] +#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[63] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[64] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[65] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[66] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[69] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[70] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[76] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[77] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[78] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[79] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[80] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[81] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[84] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[85] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[91] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[93] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[95] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[96] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[97] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[98] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[99] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[100] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[101] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[102] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[103] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[104] +#define SWIGTYPE_p_mfem__Operator swig_types[105] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[106] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[107] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[108] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[109] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[110] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[111] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[112] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[113] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[114] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[115] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[116] +#define SWIGTYPE_p_mfem__Solver swig_types[117] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[118] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[119] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[120] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[121] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[122] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[123] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[124] +#define SWIGTYPE_p_mfem__Vector swig_types[125] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[126] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[127] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[128] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[129] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[130] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[131] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[132] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[133] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[134] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[135] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[136] +#define SWIGTYPE_p_pri_t swig_types[137] +#define SWIGTYPE_p_quad_t swig_types[138] +#define SWIGTYPE_p_seg_t swig_types[139] +#define SWIGTYPE_p_std__ostream swig_types[140] +#define SWIGTYPE_p_tet_t swig_types[141] +#define SWIGTYPE_p_tri_t swig_types[142] +static swig_type_info *swig_types[144]; +static swig_module_info swig_module = {swig_types, 143, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3725,6 +3733,80 @@ mfem::Operator const *SwigDirector_BilinearForm::GetRestriction() const { } +mfem::Operator const *SwigDirector_BilinearForm::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_BilinearForm::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_BilinearForm::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -3736,7 +3818,7 @@ void SwigDirector_BilinearForm::RecoverFEMSolution(mfem::Vector const &X, mfem:: Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -3772,7 +3854,7 @@ double &SwigDirector_BilinearForm::Elem(int i, int j) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "Elem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3812,7 +3894,7 @@ double const &SwigDirector_BilinearForm::Elem(int i, int j) const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 10; const char *const swig_method_name = "Elem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3850,7 +3932,7 @@ mfem::MatrixInverse *SwigDirector_BilinearForm::Inverse() const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 11; const char *const swig_method_name = "Inverse"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject args = PyTuple_New(0); @@ -3884,7 +3966,7 @@ void SwigDirector_BilinearForm::Finalize(int skip_zeros) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 12; const char *const swig_method_name = "Finalize"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -3912,7 +3994,7 @@ void SwigDirector_BilinearForm::Print(std::ostream &out, int width_) const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 11; + const size_t swig_method_index = 13; const char *const swig_method_name = "Print"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3942,7 +4024,7 @@ void SwigDirector_BilinearForm::AddMult(mfem::Vector const &x, mfem::Vector &y, Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 14; + const size_t swig_method_index = 16; const char *const swig_method_name = "AddMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -3972,7 +4054,7 @@ void SwigDirector_BilinearForm::AddMultTranspose(mfem::Vector const &x, mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 16; + const size_t swig_method_index = 18; const char *const swig_method_name = "AddMultTranspose"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4010,7 +4092,7 @@ void SwigDirector_BilinearForm::FormLinearSystem(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 19; + const size_t swig_method_index = 21; const char *const swig_method_name = "FormLinearSystem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL); @@ -4038,7 +4120,7 @@ void SwigDirector_BilinearForm::FormSystemMatrix(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 21; + const size_t swig_method_index = 23; const char *const swig_method_name = "FormSystemMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -4064,7 +4146,7 @@ void SwigDirector_BilinearForm::Update(mfem::FiniteElementSpace *nfes) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 22; + const size_t swig_method_index = 24; const char *const swig_method_name = "Update"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4391,6 +4473,36 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPAR } +SWIGINTERN PyObject *_wrap_BilinearForm_GetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::AssemblyLevel result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetAssemblyLevel" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + try { + result = (mfem::AssemblyLevel)(arg1)->GetAssemblyLevel(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_BilinearForm_EnableStaticCondensation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -6768,6 +6880,45 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Assemble(PyObject *self, PyObject *args) } +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleDiagonal", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleDiagonal" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + ((mfem::BilinearForm const *)arg1)->AssembleDiagonal(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_BilinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -6858,6 +7009,96 @@ SWIGINTERN PyObject *_wrap_BilinearForm_GetRestriction(PyObject *SWIGUNUSEDPARM( } +SWIGINTERN PyObject *_wrap_BilinearForm_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetOutputProlongation" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::GetOutputProlongation(); + } else { + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->GetOutputProlongation(); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetOutputRestriction" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::GetOutputRestriction(); + } else { + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->GetOutputRestriction(); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -7313,24 +7554,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - int arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -7339,31 +7577,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject * }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); + (arg1)->ComputeBdrElementMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7376,18 +7600,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); @@ -7409,17 +7631,15 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7432,91 +7652,52 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleElementMatrix", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); - } - } - } - } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; @@ -7533,7 +7714,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -7544,18 +7725,18 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { @@ -7566,7 +7747,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7579,7 +7760,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; @@ -7595,7 +7776,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObjec if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -7606,23 +7787,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObjec } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7635,14 +7816,37 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleBdrElementMatrix", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleElementMatrix", 0, 5, argv))) SWIG_fail; --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } if (argc == 4) { int _v; void *vptr = 0; @@ -7665,7 +7869,40 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); } } } @@ -7702,7 +7939,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, } } if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); } } } @@ -7711,70 +7948,56 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleBdrElementMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int val5 ; - int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7787,54 +8010,39 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7847,40 +8055,57 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7893,32 +8118,50 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7931,42 +8174,61 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBC", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleBdrElementMatrix", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_3(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + } } } } - if (argc == 3) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); + } } } } @@ -7977,17 +8239,28 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); } } } @@ -7999,22 +8272,32 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); } } } @@ -8023,64 +8306,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBC'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleBdrElementMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCDiag", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - (arg1)->EliminateEssentialBCDiag((mfem::Array< int > const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8101,41 +8337,41 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8148,7 +8384,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8166,36 +8402,36 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNU if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8208,7 +8444,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8223,25 +8459,25 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8254,7 +8490,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8266,20 +8502,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNU if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8292,13 +8528,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofs", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBC", 0, 5, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -8309,7 +8545,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_3(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_3(self, argc, argv); } } } @@ -8327,7 +8563,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_2(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_2(self, argc, argv); } } } @@ -8348,7 +8584,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); } } } @@ -8375,7 +8611,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_0(self, argc, argv); } } } @@ -8384,17 +8620,64 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateVDofs'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBC'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCDiag", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + (arg1)->EliminateEssentialBCDiag((mfem::Array< int > const &)*arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8415,41 +8698,41 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8462,7 +8745,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8480,36 +8763,36 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyO if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8522,7 +8805,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8537,25 +8820,25 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyO if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8568,7 +8851,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8580,20 +8863,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyO if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8606,13 +8889,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofs", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofs", 0, 5, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -8623,7 +8906,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_3(self, argc, argv); } } } @@ -8641,7 +8924,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_2(self, argc, argv); } } } @@ -8662,7 +8945,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); } } } @@ -8689,7 +8972,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_0(self, argc, argv); } } } @@ -8698,51 +8981,72 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBCFromDofs'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateVDofs'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - double arg3 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Matrix::DiagonalPolicy arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofsDiag", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "3"" of type '" "double""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } - arg3 = static_cast< double >(val3); + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateEssentialBCFromDofsDiag((mfem::Array< int > const &)*arg2,arg3); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8755,7 +9059,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8769,41 +9073,40 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofsInRHS", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateVDofsInRHS((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8816,135 +9119,82 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Matrix::DiagonalPolicy arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - double result; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullInnerProduct", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullInnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - result = (double)((mfem::BilinearForm const *)arg1)->FullInnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - Swig::Director *director = 0; - bool upcall = false; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Update(arg2); - } else { - (arg1)->Update(arg2); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Update(); - } else { - (arg1)->Update(); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2); } - } catch (Swig::DirectorException&) { - SWIG_fail; + catch (Swig::DirectorException &e) { + SWIG_fail; + } } resultobj = SWIG_Py_Void(); return resultobj; @@ -8953,222 +9203,143 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Update", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofs", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_Update__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(self, argc, argv); + } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_Update__SWIG_0(self, argc, argv); + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(self, argc, argv); + } } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Update'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Update(mfem::FiniteElementSpace *)\n" - " mfem::BilinearForm::Update()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_GetFES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElementSpace *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetFES" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)(arg1)->GetFES(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)(arg1)->FESpace(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)((mfem::BilinearForm const *)arg1)->FESpace(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FESpace(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FESpace", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 1) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_FESpace__SWIG_0(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); + } + } + } } } - if (argc == 1) { + if (argc == 5) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_FESpace__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(self, argc, argv); + } + } + } + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FESpace'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBCFromDofs'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::FESpace()\n" - " mfem::BilinearForm::FESpace() const\n"); + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Matrix::DiagonalPolicy arg2 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetDiagonalPolicy", 2, 2, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofsDiag", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "2"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg2 = static_cast< mfem::Matrix::DiagonalPolicy >(val2); - { - try { - (arg1)->SetDiagonalPolicy(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - delete arg1; + (arg1)->EliminateEssentialBCFromDofsDiag((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9181,16 +9352,12 @@ SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::SparseMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9199,76 +9366,41 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofsInRHS", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + (arg1)->EliminateVDofsInRHS((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9281,140 +9413,96 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::SparseMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + PyObject *swig_obj[3] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullInnerProduct", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullInnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + result = (double)((mfem::BilinearForm const *)arg1)->FullInnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::SparseMatrix *arg3 = 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + Swig::Director *director = 0; + bool upcall = false; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); - { - try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormSystemMatrix< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearForm::Update(arg2); + } else { + (arg1)->Update(arg2); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + } catch (Swig::DirectorException&) { + SWIG_fail; } resultobj = SWIG_Py_Void(); return resultobj; @@ -9423,98 +9511,37 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_2(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::HypreParMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; + Swig::Director *director = 0; + bool upcall = false; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::HypreParMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearForm::Update(); + } else { + (arg1)->Update(); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + } catch (Swig::DirectorException&) { + SWIG_fail; } resultobj = SWIG_Py_Void(); return resultobj; @@ -9523,384 +9550,2234 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_6(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::HypreParMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; +SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Update", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_Update__SWIG_1(self, argc, argv); + } } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_Update__SWIG_0(self, argc, argv); + } + } } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Update'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::Update(mfem::FiniteElementSpace *)\n" + " mfem::BilinearForm::Update()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_GetFES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::FiniteElementSpace *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetFES" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg5 = reinterpret_cast< mfem::HypreParMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + try { + result = (mfem::FiniteElementSpace *)(arg1)->GetFES(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::FiniteElementSpace *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + try { + result = (mfem::FiniteElementSpace *)(arg1)->FESpace(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::FiniteElementSpace *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + result = (mfem::FiniteElementSpace *)((mfem::BilinearForm const *)arg1)->FESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_FESpace(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[9] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FESpace", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_5(self, argc, argv); - } - } - } - } - } - } + return _wrap_BilinearForm_FESpace__SWIG_0(self, argc, argv); } } - if (argc == 7) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_7(self, argc, argv); - } - } - } - } - } - } + return _wrap_BilinearForm_FESpace__SWIG_1(self, argc, argv); } } - if (argc == 8) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FESpace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::FESpace()\n" + " mfem::BilinearForm::FESpace() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Matrix::DiagonalPolicy arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetDiagonalPolicy", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "2"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg2 = static_cast< mfem::Matrix::DiagonalPolicy >(val2); + { + try { + (arg1)->SetDiagonalPolicy(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_UseExternalIntegrators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_UseExternalIntegrators" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + try { + (arg1)->UseExternalIntegrators(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::SparseMatrix *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + int arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::SparseMatrix *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::SparseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormSystemMatrix< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::HypreParMatrix *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + int arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::HypreParMatrix * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::HypreParMatrix *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::HypreParMatrix * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; + --argc; + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_5(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_7(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_6(self, argc, argv); + } + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); + } + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormLinearSystem'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &,int)\n" + " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &)\n" + " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n" + " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &)\n" + " mfem::BilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &,int)\n" + " mfem::BilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::HypreParMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::HypreParMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::HypreParMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::HypreParMatrix * >(argp3); + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormSystemMatrix< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormSystemMatrix", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormSystemMatrix__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormSystemMatrix__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormSystemMatrix__SWIG_3(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormSystemMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::FormSystemMatrix(mfem::Array< int > const &,mfem::OperatorHandle &)\n" + " mfem::BilinearForm::FormSystemMatrix< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::SparseMatrix &)\n" + " mfem::BilinearForm::FormSystemMatrix< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::HypreParMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *BilinearForm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BilinearForm, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BilinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::MixedBilinearForm *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::MixedBilinearForm *arg3 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + mfem::MixedBilinearForm *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MixedBilinearForm" "', argument " "3"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg3 = reinterpret_cast< mfem::MixedBilinearForm * >(argp3); + { + try { + result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MixedBilinearForm(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedBilinearForm", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedBilinearForm__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedBilinearForm__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedBilinearForm'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *)\n" + " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *,mfem::MixedBilinearForm *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (double *) &(arg1)->Elem(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (double *) &((mfem::MixedBilinearForm const *)arg1)->Elem(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_double(static_cast< double >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Elem", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + return _wrap_MixedBilinearForm_Elem__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_Elem__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Elem'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::Elem(int,int)\n" + " mfem::MixedBilinearForm::Elem(int,int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Mult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMult", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AddMult__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + return _wrap_MixedBilinearForm_AddMult__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMult'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" + " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); - } - } - } - } + } + if (_v) { + return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); } } } } } - if (argc == 8) { + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMultTranspose'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" + " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MatrixInverse *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Inverse" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::MatrixInverse *)((mfem::MixedBilinearForm const *)arg1)->Inverse(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + (arg1)->Finalize(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + (arg1)->Finalize(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Finalize", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_6(self, argc, argv); - } - } - } - } - } + return _wrap_MixedBilinearForm_Finalize__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_MixedBilinearForm_Finalize__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Finalize'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::Finalize(int)\n" + " mfem::MixedBilinearForm::Finalize()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_GetBlocks", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + } + arg2 = reinterpret_cast< mfem::Array2D< mfem::SparseMatrix * > * >(argp2); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->GetBlocks(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &((mfem::MixedBilinearForm const *)arg1)->SpMat(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &(arg1)->SpMat(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SpMat", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_SpMat__SWIG_1(self, argc, argv); } } - if (argc == 8) { + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); - } - } - } - } - } - } - } + return _wrap_MixedBilinearForm_SpMat__SWIG_0(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormLinearSystem'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_SpMat'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &)\n"); + " mfem::MixedBilinearForm::SpMat() const\n" + " mfem::MixedBilinearForm::SpMat()\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_LoseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::HypreParMatrix *arg3 = 0 ; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::SparseMatrix *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_LoseMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::SparseMatrix *)(arg1)->LoseMat(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + { + try { + (arg1)->AddDomainIntegrator(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + { + try { + (arg1)->AddBoundaryIntegrator(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9909,30 +11786,27 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_3(PyObject *SWIGU int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::HypreParMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::HypreParMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::HypreParMatrix * >(argp3); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormSystemMatrix< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3); + (arg1)->AddBoundaryIntegrator(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9945,98 +11819,86 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_3(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormSystemMatrix", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddBoundaryIntegrator", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormSystemMatrix__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormSystemMatrix__SWIG_2(self, argc, argv); - } + return _wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_0(self, argc, argv); } } } if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_FormSystemMatrix__SWIG_3(self, argc, argv); + return _wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormSystemMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddBoundaryIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::FormSystemMatrix(mfem::Array< int > const &,mfem::OperatorHandle &)\n" - " mfem::BilinearForm::FormSystemMatrix< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::SparseMatrix &)\n" - " mfem::BilinearForm::FormSystemMatrix< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::HypreParMatrix &)\n"); + " mfem::MixedBilinearForm::AddBoundaryIntegrator(mfem::BilinearFormIntegrator *)\n" + " mfem::MixedBilinearForm::AddBoundaryIntegrator(mfem::BilinearFormIntegrator *,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddTraceFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); { - Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); - if (director) director->swig_disown(); + try { + (arg1)->AddTraceFaceIntegrator(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -10044,403 +11906,342 @@ SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *BilinearForm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BilinearForm, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BilinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::MixedBilinearForm *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); { try { - result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2); + (arg1)->AddBdrTraceFaceIntegrator(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - mfem::MixedBilinearForm *arg3 = (mfem::MixedBilinearForm *) 0 ; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - mfem::MixedBilinearForm *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MixedBilinearForm" "', argument " "3"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::MixedBilinearForm * >(argp3); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2,arg3); + (arg1)->AddBdrTraceFaceIntegrator(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedBilinearForm(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedBilinearForm", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddBdrTraceFaceIntegrator", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedBilinearForm__SWIG_0(self, argc, argv); + return _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_0(self, argc, argv); } } } if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedBilinearForm__SWIG_1(self, argc, argv); + return _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedBilinearForm'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddBdrTraceFaceIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *)\n" - " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *,mfem::MixedBilinearForm *)\n"); + " mfem::MixedBilinearForm::AddBdrTraceFaceIntegrator(mfem::BilinearFormIntegrator *)\n" + " mfem::MixedBilinearForm::AddBdrTraceFaceIntegrator(mfem::BilinearFormIntegrator *,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetDBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetDBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (double *) &(arg1)->Elem(arg2,arg3); + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetDBFI(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetBBFI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBBFI_Marker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::Array< int > * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBBFI_Marker" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - result = (double *) &((mfem::MixedBilinearForm const *)arg1)->Elem(arg2,arg3); + result = (mfem::Array< mfem::Array< int > * > *)(arg1)->GetBBFI_Marker(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(*result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetTFBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Elem", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Elem__SWIG_0(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetTFBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Elem__SWIG_1(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetTFBFI(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Elem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Elem(int,int)\n" - " mfem::MixedBilinearForm::Elem(int,int) const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBTFBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Mult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBTFBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetBTFBFI(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBTFBFI_Marker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::Array< int > * > *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBTFBFI_Marker" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + try { + result = (mfem::Array< mfem::Array< int > * > *)(arg1)->GetBTFBFI_Marker(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::AssemblyLevel arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); } - arg4 = static_cast< double >(val4); + arg2 = static_cast< mfem::AssemblyLevel >(val2); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); + (arg1)->SetAssemblyLevel(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10453,43 +12254,55 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + try { + (arg1)->Assemble(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); + (arg1)->Assemble(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10502,323 +12315,216 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMult", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Assemble", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 3) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_1(self, argc, argv); - } - } + return _wrap_MixedBilinearForm_Assemble__SWIG_1(self, argc, argv); } } - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_0(self, argc, argv); - } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_MixedBilinearForm_Assemble__SWIG_0(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMult'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Assemble'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); + " mfem::MixedBilinearForm::Assemble(int)\n" + " mfem::MixedBilinearForm::Assemble()\n"); return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetProlongation" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetProlongation(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetRestriction" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetRestriction(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetOutputProlongation" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetOutputProlongation(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetOutputRestriction" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetOutputRestriction(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MatrixInverse *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Inverse" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ConformingAssemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - result = (mfem::MatrixInverse *)((mfem::MixedBilinearForm const *)arg1)->Inverse(); + (arg1)->ConformingAssemble(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeElementMatrix", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { @@ -10827,9 +12533,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUS }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->Finalize(arg2); + (arg1)->ComputeElementMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10842,21 +12556,40 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->Finalize(); + (arg1)->ComputeBdrElementMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10869,79 +12602,91 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Finalize", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_1(self, argc, argv); - } + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_0(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Finalize(int)\n" - " mfem::MixedBilinearForm::Finalize()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_GetBlocks", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - arg2 = reinterpret_cast< mfem::Array2D< mfem::SparseMatrix * > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->GetBlocks(*arg2); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10954,152 +12699,384 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::SparseMatrix *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } { try { - result = (mfem::SparseMatrix *) &((mfem::MixedBilinearForm const *)arg1)->SpMat(); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::SparseMatrix *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); { try { - result = (mfem::SparseMatrix *) &(arg1)->SpMat(); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SpMat", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleElementMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MixedBilinearForm_SpMat__SWIG_1(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } } } - if (argc == 1) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MixedBilinearForm_SpMat__SWIG_0(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); + } + } + } + } + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_SpMat'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleElementMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::SpMat() const\n" - " mfem::MixedBilinearForm::SpMat()\n"); + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_LoseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::SparseMatrix *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_LoseMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - result = (mfem::SparseMatrix *)(arg1)->LoseMat(); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->AddDomainIntegrator(arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11112,30 +13089,68 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddBoundaryIntegrator", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); { try { - (arg1)->AddBoundaryIntegrator(arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11148,154 +13163,435 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *SWI } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddTraceFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); { try { - (arg1)->AddTraceFaceIntegrator(arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - return resultobj; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleBdrElementMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleBdrElementMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetDBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTrialDofs", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetDBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetDBFI(); + (arg1)->EliminateTrialDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetBBFI(); + (arg1)->EliminateEssentialBCFromTrialDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetTFBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTestDofs", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetTFBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetTFBFI(); + (arg1)->EliminateTestDofs((mfem::Array< int > const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::OperatorHandle *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularSystemMatrix", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); + } + arg4 = reinterpret_cast< mfem::OperatorHandle * >(argp4); { try { - (arg1)->Assemble(arg2); + (arg1)->FormRectangularSystemMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11308,21 +13604,99 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::OperatorHandle *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); + } + arg6 = reinterpret_cast< mfem::OperatorHandle * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); { try { - (arg1)->Assemble(); + (arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11335,53 +13709,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Assemble(int)\n" - " mfem::MixedBilinearForm::Assemble()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; void *argp1 = 0 ; @@ -11392,12 +13720,12 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUN swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ConformingAssemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Update" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->ConformingAssemble(); + (arg1)->Update(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11410,196 +13738,190 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TrialFESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::FiniteElementSpace *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTrialDofs", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TrialFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateTrialDofs(*arg2,(mfem::Vector const &)*arg3,*arg4); + result = (mfem::FiniteElementSpace *)(arg1)->TrialFESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TrialFESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::FiniteElementSpace *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TrialFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateEssentialBCFromTrialDofs(*arg2,(mfem::Vector const &)*arg3,*arg4); + result = (mfem::FiniteElementSpace *)((mfem::MixedBilinearForm const *)arg1)->TrialFESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TrialFESpace(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_TrialFESpace", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TrialFESpace__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TrialFESpace__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_TrialFESpace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::TrialFESpace()\n" + " mfem::MixedBilinearForm::TrialFESpace() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TestFESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::FiniteElementSpace *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTestDofs", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TestFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateTestDofs(*arg2); + result = (mfem::FiniteElementSpace *)(arg1)->TestFESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TestFESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::FiniteElementSpace *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Update" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TestFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->Update(); + result = (mfem::FiniteElementSpace *)((mfem::MixedBilinearForm const *)arg1)->TestFESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TestFESpace(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_TestFESpace", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TestFESpace__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TestFESpace__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_TestFESpace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::TestFESpace()\n" + " mfem::MixedBilinearForm::TestFESpace() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_delete_MixedBilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; @@ -11928,6 +14250,7 @@ SWIGINTERN PyObject *DiscreteLinearOperator_swiginit(PyObject *SWIGUNUSEDPARM(se static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_BilinearForm", _wrap_new_BilinearForm, METH_VARARGS, "\n" "BilinearForm()\n" "BilinearForm(FiniteElementSpace f)\n" @@ -11935,6 +14258,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "BilinearForm_Size(BilinearForm self) -> int"}, { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "BilinearForm_SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "BilinearForm_GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "BilinearForm_EnableStaticCondensation(BilinearForm self)"}, { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "BilinearForm_StaticCondensationIsEnabled(BilinearForm self) -> bool"}, { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "BilinearForm_SCFESpace(BilinearForm self) -> FiniteElementSpace"}, @@ -11986,14 +14310,24 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "BilinearForm_Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "BilinearForm_AssembleDiagonal(BilinearForm self, Vector diag)"}, { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "BilinearForm_GetProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "BilinearForm_GetRestriction(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "BilinearForm_GetOutputProlongation(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "BilinearForm_GetOutputRestriction(BilinearForm self) -> Operator"}, { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "BilinearForm_RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "BilinearForm_ComputeElementMatrices(BilinearForm self)"}, { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "BilinearForm_FreeElementMatrices(BilinearForm self)"}, { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "BilinearForm_ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, - { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)"}, - { "BilinearForm_AssembleBdrElementMatrix", _wrap_BilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "BilinearForm_AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)"}, + { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "BilinearForm_ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, + { "BilinearForm_AssembleBdrElementMatrix", _wrap_BilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "BilinearForm_AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "BilinearForm_AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, { "BilinearForm_EliminateEssentialBC", _wrap_BilinearForm_EliminateEssentialBC, METH_VARARGS, "\n" "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" @@ -12017,16 +14351,216 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_FESpace(BilinearForm self) -> FiniteElementSpace\n" ""}, { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "BilinearForm_SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "BilinearForm_UseExternalIntegrators(BilinearForm self)"}, + { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, + { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" + "BilinearForm_FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B, int copy_interior=0)\n" + "BilinearForm_FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, SparseMatrix A, Vector X, Vector B, int copy_interior=0)\n" + "BilinearForm_FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, HypreParMatrix A, Vector X, Vector B, int copy_interior=0)\n" + ""}, + { "BilinearForm_FormSystemMatrix", _wrap_BilinearForm_FormSystemMatrix, METH_VARARGS, "\n" + "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, OperatorHandle A)\n" + "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" + "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, HypreParMatrix A)\n" + ""}, + { "disown_BilinearForm", _wrap_disown_BilinearForm, METH_O, NULL}, + { "BilinearForm_swigregister", BilinearForm_swigregister, METH_O, NULL}, + { "BilinearForm_swiginit", BilinearForm_swiginit, METH_VARARGS, NULL}, + { "new_MixedBilinearForm", _wrap_new_MixedBilinearForm, METH_VARARGS, "\n" + "MixedBilinearForm(FiniteElementSpace tr_fes, FiniteElementSpace te_fes)\n" + "new_MixedBilinearForm(FiniteElementSpace tr_fes, FiniteElementSpace te_fes, MixedBilinearForm mbf) -> MixedBilinearForm\n" + ""}, + { "MixedBilinearForm_Elem", _wrap_MixedBilinearForm_Elem, METH_VARARGS, "\n" + "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double\n" + "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double const &\n" + ""}, + { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "MixedBilinearForm_Mult(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "MixedBilinearForm_AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MixedBilinearForm_MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "MixedBilinearForm_Inverse(MixedBilinearForm self) -> MatrixInverse"}, + { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "MixedBilinearForm_Finalize(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "MixedBilinearForm_GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "MixedBilinearForm_SpMat", _wrap_MixedBilinearForm_SpMat, METH_VARARGS, "\n" + "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" + "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" + ""}, + { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "MixedBilinearForm_LoseMat(MixedBilinearForm self) -> SparseMatrix"}, + { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "MixedBilinearForm_AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "MixedBilinearForm_AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" + "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "MixedBilinearForm_GetDBFI", _wrap_MixedBilinearForm_GetDBFI, METH_O, "MixedBilinearForm_GetDBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBBFI", _wrap_MixedBilinearForm_GetBBFI, METH_O, "MixedBilinearForm_GetBBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBBFI_Marker", _wrap_MixedBilinearForm_GetBBFI_Marker, METH_O, "MixedBilinearForm_GetBBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "MixedBilinearForm_GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "MixedBilinearForm_GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "MixedBilinearForm_GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "MixedBilinearForm_SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "MixedBilinearForm_Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "MixedBilinearForm_GetProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "MixedBilinearForm_GetRestriction(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "MixedBilinearForm_GetOutputProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "MixedBilinearForm_GetOutputRestriction(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "MixedBilinearForm_ConformingAssemble(MixedBilinearForm self)"}, + { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, + { "MixedBilinearForm_AssembleBdrElementMatrix", _wrap_MixedBilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, + { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "MixedBilinearForm_EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "MixedBilinearForm_FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "MixedBilinearForm_FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "MixedBilinearForm_Update(MixedBilinearForm self)"}, + { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" + "MixedBilinearForm_TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "MixedBilinearForm_TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + ""}, + { "MixedBilinearForm_TestFESpace", _wrap_MixedBilinearForm_TestFESpace, METH_VARARGS, "\n" + "MixedBilinearForm_TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "MixedBilinearForm_TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + ""}, + { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, + { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, + { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, + { "new_DiscreteLinearOperator", _wrap_new_DiscreteLinearOperator, METH_VARARGS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, + { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "DiscreteLinearOperator_GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "DiscreteLinearOperator_Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, + { "delete_DiscreteLinearOperator", _wrap_delete_DiscreteLinearOperator, METH_O, "delete_DiscreteLinearOperator(DiscreteLinearOperator self)"}, + { "DiscreteLinearOperator_swigregister", DiscreteLinearOperator_swigregister, METH_O, NULL}, + { "DiscreteLinearOperator_swiginit", DiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_BilinearForm", _wrap_new_BilinearForm, METH_VARARGS, "\n" + "BilinearForm()\n" + "BilinearForm(FiniteElementSpace f)\n" + "BilinearForm(FiniteElementSpace f, BilinearForm bf, int ps=0)\n" + ""}, + { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "Size(BilinearForm self) -> int"}, + { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, + { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "EnableStaticCondensation(BilinearForm self)"}, + { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "StaticCondensationIsEnabled(BilinearForm self) -> bool"}, + { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "SCFESpace(BilinearForm self) -> FiniteElementSpace"}, + { "BilinearForm_EnableHybridization", _wrap_BilinearForm_EnableHybridization, METH_VARARGS, "EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, + { "BilinearForm_UsePrecomputedSparsity", _wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS, "UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, + { "BilinearForm_UseSparsity", _wrap_BilinearForm_UseSparsity, METH_VARARGS, "\n" + "UseSparsity(BilinearForm self, int * I, int * J, bool isSorted)\n" + "UseSparsity(BilinearForm self, SparseMatrix A)\n" + ""}, + { "BilinearForm_AllocateMatrix", _wrap_BilinearForm_AllocateMatrix, METH_O, "AllocateMatrix(BilinearForm self)"}, + { "BilinearForm_GetDBFI", _wrap_BilinearForm_GetDBFI, METH_O, "GetDBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBBFI", _wrap_BilinearForm_GetBBFI, METH_O, "GetBBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBBFI_Marker", _wrap_BilinearForm_GetBBFI_Marker, METH_O, "GetBBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "BilinearForm_GetFBFI", _wrap_BilinearForm_GetFBFI, METH_O, "GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBFBFI", _wrap_BilinearForm_GetBFBFI, METH_O, "GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBFBFI_Marker", _wrap_BilinearForm_GetBFBFI_Marker, METH_O, "GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "BilinearForm___call__", _wrap_BilinearForm___call__, METH_VARARGS, "__call__(BilinearForm self, int i, int j) -> double const &"}, + { "BilinearForm_Elem", _wrap_BilinearForm_Elem, METH_VARARGS, "\n" + "Elem(BilinearForm self, int i, int j) -> double\n" + "Elem(BilinearForm self, int i, int j) -> double const &\n" + ""}, + { "BilinearForm_Mult", _wrap_BilinearForm_Mult, METH_VARARGS, "Mult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_FullMult", _wrap_BilinearForm_FullMult, METH_VARARGS, "FullMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMult", _wrap_BilinearForm_AddMult, METH_VARARGS, "AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMult", _wrap_BilinearForm_FullAddMult, METH_VARARGS, "FullAddMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMultTranspose", _wrap_BilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMultTranspose", _wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS, "FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_MultTranspose", _wrap_BilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_InnerProduct", _wrap_BilinearForm_InnerProduct, METH_VARARGS, "InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Inverse", _wrap_BilinearForm_Inverse, METH_O, "Inverse(BilinearForm self) -> MatrixInverse"}, + { "BilinearForm_Finalize", _wrap_BilinearForm_Finalize, METH_VARARGS, "Finalize(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_SpMat", _wrap_BilinearForm_SpMat, METH_VARARGS, "\n" + "SpMat(BilinearForm self) -> SparseMatrix\n" + "SpMat(BilinearForm self) -> SparseMatrix\n" + ""}, + { "BilinearForm_LoseMat", _wrap_BilinearForm_LoseMat, METH_O, "LoseMat(BilinearForm self) -> SparseMatrix"}, + { "BilinearForm_SpMatElim", _wrap_BilinearForm_SpMatElim, METH_VARARGS, "\n" + "SpMatElim(BilinearForm self) -> SparseMatrix\n" + "SpMatElim(BilinearForm self) -> SparseMatrix\n" + ""}, + { "BilinearForm_AddDomainIntegrator", _wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddBoundaryIntegrator", _wrap_BilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "BilinearForm_AddInteriorFaceIntegrator", _wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddBdrFaceIntegrator", _wrap_BilinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "AssembleDiagonal(BilinearForm self, Vector diag)"}, + { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "GetProlongation(BilinearForm self) -> Operator"}, + { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "GetRestriction(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(BilinearForm self) -> Operator"}, + { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, + { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "ComputeElementMatrices(BilinearForm self)"}, + { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "FreeElementMatrices(BilinearForm self)"}, + { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, + { "BilinearForm_AssembleBdrElementMatrix", _wrap_BilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, + { "BilinearForm_EliminateEssentialBC", _wrap_BilinearForm_EliminateEssentialBC, METH_VARARGS, "\n" + "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "BilinearForm_EliminateEssentialBCDiag", _wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS, "EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, + { "BilinearForm_EliminateVDofs", _wrap_BilinearForm_EliminateVDofs, METH_VARARGS, "\n" + "EliminateVDofs(BilinearForm self, intArray vdofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "BilinearForm_EliminateEssentialBCFromDofs", _wrap_BilinearForm_EliminateEssentialBCFromDofs, METH_VARARGS, "\n" + "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "BilinearForm_EliminateEssentialBCFromDofsDiag", _wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS, "EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, + { "BilinearForm_EliminateVDofsInRHS", _wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS, "EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, + { "BilinearForm_FullInnerProduct", _wrap_BilinearForm_FullInnerProduct, METH_VARARGS, "FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Update", _wrap_BilinearForm_Update, METH_VARARGS, "Update(BilinearForm self, FiniteElementSpace nfes=None)"}, + { "BilinearForm_GetFES", _wrap_BilinearForm_GetFES, METH_O, "GetFES(BilinearForm self) -> FiniteElementSpace"}, + { "BilinearForm_FESpace", _wrap_BilinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(BilinearForm self) -> FiniteElementSpace\n" + "FESpace(BilinearForm self) -> FiniteElementSpace\n" + ""}, + { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "UseExternalIntegrators(BilinearForm self)"}, { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" - "BilinearForm_FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B, int copy_interior=0)\n" - "BilinearForm_FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, SparseMatrix A, Vector X, Vector B, int copy_interior=0)\n" - "BilinearForm_FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, HypreParMatrix A, Vector X, Vector B, int copy_interior=0)\n" + "FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B, int copy_interior=0)\n" + "FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, SparseMatrix A, Vector X, Vector B, int copy_interior=0)\n" + "FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, HypreParMatrix A, Vector X, Vector B, int copy_interior=0)\n" ""}, { "BilinearForm_FormSystemMatrix", _wrap_BilinearForm_FormSystemMatrix, METH_VARARGS, "\n" - "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, OperatorHandle A)\n" - "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" - "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, HypreParMatrix A)\n" + "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, OperatorHandle A)\n" + "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" + "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, HypreParMatrix A)\n" ""}, { "disown_BilinearForm", _wrap_disown_BilinearForm, METH_O, NULL}, { "BilinearForm_swigregister", BilinearForm_swigregister, METH_O, NULL}, @@ -12036,51 +14570,82 @@ static PyMethodDef SwigMethods[] = { "new_MixedBilinearForm(FiniteElementSpace tr_fes, FiniteElementSpace te_fes, MixedBilinearForm mbf) -> MixedBilinearForm\n" ""}, { "MixedBilinearForm_Elem", _wrap_MixedBilinearForm_Elem, METH_VARARGS, "\n" - "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double\n" - "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double const &\n" + "Elem(MixedBilinearForm self, int i, int j) -> double\n" + "Elem(MixedBilinearForm self, int i, int j) -> double const &\n" ""}, - { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "MixedBilinearForm_Mult(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "MixedBilinearForm_AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MixedBilinearForm_MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "MixedBilinearForm_Inverse(MixedBilinearForm self) -> MatrixInverse"}, - { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "MixedBilinearForm_Finalize(MixedBilinearForm self, int skip_zeros=1)"}, - { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "MixedBilinearForm_GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "Mult(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "Inverse(MixedBilinearForm self) -> MatrixInverse"}, + { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "Finalize(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, { "MixedBilinearForm_SpMat", _wrap_MixedBilinearForm_SpMat, METH_VARARGS, "\n" - "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" - "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" + "SpMat(MixedBilinearForm self) -> SparseMatrix\n" + "SpMat(MixedBilinearForm self) -> SparseMatrix\n" + ""}, + { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "LoseMat(MixedBilinearForm self) -> SparseMatrix"}, + { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" + "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "MixedBilinearForm_GetDBFI", _wrap_MixedBilinearForm_GetDBFI, METH_O, "GetDBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBBFI", _wrap_MixedBilinearForm_GetBBFI, METH_O, "GetBBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBBFI_Marker", _wrap_MixedBilinearForm_GetBBFI_Marker, METH_O, "GetBBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "GetProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "GetRestriction(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "ConformingAssemble(MixedBilinearForm self)"}, + { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, + { "MixedBilinearForm_AssembleBdrElementMatrix", _wrap_MixedBilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, + { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "Update(MixedBilinearForm self)"}, + { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" + "TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + ""}, + { "MixedBilinearForm_TestFESpace", _wrap_MixedBilinearForm_TestFESpace, METH_VARARGS, "\n" + "TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" ""}, - { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "MixedBilinearForm_LoseMat(MixedBilinearForm self) -> SparseMatrix"}, - { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "MixedBilinearForm_AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, - { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, - { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "MixedBilinearForm_AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, - { "MixedBilinearForm_GetDBFI", _wrap_MixedBilinearForm_GetDBFI, METH_O, "MixedBilinearForm_GetDBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "MixedBilinearForm_GetBBFI", _wrap_MixedBilinearForm_GetBBFI, METH_O, "MixedBilinearForm_GetBBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "MixedBilinearForm_GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "MixedBilinearForm_Assemble(MixedBilinearForm self, int skip_zeros=1)"}, - { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "MixedBilinearForm_ConformingAssemble(MixedBilinearForm self)"}, - { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "MixedBilinearForm_EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, - { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "MixedBilinearForm_Update(MixedBilinearForm self)"}, { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, { "new_DiscreteLinearOperator", _wrap_new_DiscreteLinearOperator, METH_VARARGS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, - { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, - { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, - { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "DiscreteLinearOperator_GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "DiscreteLinearOperator_Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, + { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, { "delete_DiscreteLinearOperator", _wrap_delete_DiscreteLinearOperator, METH_O, "delete_DiscreteLinearOperator(DiscreteLinearOperator self)"}, { "DiscreteLinearOperator_swigregister", DiscreteLinearOperator_swigregister, METH_O, NULL}, { "DiscreteLinearOperator_swiginit", DiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; -static PyMethodDef SwigMethods_proxydocs[] = { - { NULL, NULL, 0, NULL } -}; - /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ @@ -12150,6 +14715,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -12279,9 +14847,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -12306,6 +14871,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -12315,102 +14883,120 @@ static void *_p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormInteg static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__MixedBilinearForm(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } -static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); } -static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } -static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); +static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +} +static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +} +static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); +} +static void *_p_mfem__MixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::MixedBilinearForm *) x)); +} +static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); } static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); } -static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } -static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +} +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +} +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); } static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } -static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); } -static void *_p_mfem__MixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::MixedBilinearForm *) x)); +static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); } -static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +} +static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); } static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); } -static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); -} -static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); -} -static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); -} -static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); } static void *_p_mfem__HypreSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSmoother *) x)); } -static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); -} static void *_p_mfem__GradientInterpolatorTo_p_mfem__DiscreteInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::DiscreteInterpolator *) ((mfem::GradientInterpolator *) x)); } @@ -12476,6 +15062,7 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -12486,7 +15073,6 @@ static swig_type_info _swigt__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t = {"_p_mfem_ static swig_type_info _swigt__p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t = {"_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t", "mfem::Array< mfem::BilinearFormIntegrator * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearForm = {"_p_mfem__BilinearForm", "mfem::BilinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -12497,6 +15083,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -12518,6 +15105,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -12550,8 +15138,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -12559,6 +15146,7 @@ static swig_type_info _swigt__p_mfem__DivergenceInterpolator = {"_p_mfem__Diverg static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mfem::DenseMatrix *", 0, 0, (void*)0, 0}; @@ -12575,27 +15163,33 @@ static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedBilinearForm = {"_p_mfem__MixedBilinearForm", "mfem::MixedBilinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreSmoother = {"_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; @@ -12613,6 +15207,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_hex_t, @@ -12643,9 +15238,11 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GroupConvectionIntegrator, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__HypreADS, &_swigt__p_mfem__HypreAMS, &_swigt__p_mfem__HypreBoomerAMG, @@ -12663,6 +15260,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__IntegrationRule, &_swigt__p_mfem__InverseIntegrator, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2_FECollection, &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__LumpedIntegrator, @@ -12718,8 +15317,11 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__ScalarProductInterpolator, &_swigt__p_mfem__ScalarVectorProductInterpolator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__SumIntegrator, @@ -12750,6 +15352,7 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -12759,7 +15362,6 @@ static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__Arra static swig_cast_info _swigc__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BilinearForm[] = { {&_swigt__p_mfem__BilinearForm, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12770,6 +15372,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12791,6 +15394,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12823,8 +15427,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12832,9 +15435,10 @@ static swig_cast_info _swigc__p_mfem__DivergenceInterpolator[] = {{&_swigt__p_mf static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__CurlInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = { {&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteLinearOperator[] = { {&_swigt__p_mfem__DiscreteLinearOperator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12848,29 +15452,35 @@ static swig_cast_info _swigc__p_mfem__Matrix[] = { {&_swigt__p_mfem__DiscreteLi static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__MatrixInverse, 0, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__MatrixInverse, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedBilinearForm[] = { {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__MixedBilinearForm, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; @@ -12887,6 +15497,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_hex_t, @@ -12917,9 +15528,11 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GroupConvectionIntegrator, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__HypreADS, _swigc__p_mfem__HypreAMS, _swigc__p_mfem__HypreBoomerAMG, @@ -12937,6 +15550,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__IntegrationRule, _swigc__p_mfem__InverseIntegrator, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2_FECollection, _swigc__p_mfem__LinearForm, _swigc__p_mfem__LumpedIntegrator, @@ -12992,8 +15607,11 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__ScalarProductInterpolator, _swigc__p_mfem__ScalarVectorProductInterpolator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__SumIntegrator, diff --git a/mfem/_par/bilinearform_wrap.h b/mfem/_par/bilinearform_wrap.h index 28fb831a..84555a81 100644 --- a/mfem/_par/bilinearform_wrap.h +++ b/mfem/_par/bilinearform_wrap.h @@ -27,6 +27,8 @@ class SwigDirector_BilinearForm : public mfem::BilinearForm, public Swig::Direct virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_BilinearForm(); virtual double &Elem(int i, int j); @@ -69,7 +71,7 @@ class SwigDirector_BilinearForm : public mfem::BilinearForm, public Swig::Direct return method; } private: - mutable swig::SwigVar_PyObject vtable[24]; + mutable swig::SwigVar_PyObject vtable[26]; #endif }; diff --git a/mfem/_par/bilininteg.py b/mfem/_par/bilininteg.py index 7df87401..ad7cc13c 100644 --- a/mfem/_par/bilininteg.py +++ b/mfem/_par/bilininteg.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _bilininteg.SWIG_PyInstanceMethod_New +_swig_new_static_method = _bilininteg.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -79,6 +82,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.fespace import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -87,6 +91,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.linearform class BilinearFormIntegrator(object): r"""Proxy of C++ mfem::BilinearFormIntegrator class.""" @@ -102,25 +107,49 @@ def __init__(self, ir=None): _self = self _bilininteg.BilinearFormIntegrator_swiginit(self, _bilininteg.new_BilinearFormIntegrator(_self, ir)) - def AssemblePA(self, fes): - r"""AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)""" - return _bilininteg.BilinearFormIntegrator_AssemblePA(self, fes) + def AssemblePA(self, *args): + r""" + AssemblePA(BilinearFormIntegrator self) + AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes) + AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _bilininteg.BilinearFormIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssemblePA) + + def AssemblePAInteriorFaces(self, fes): + r"""AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.BilinearFormIntegrator_AssemblePAInteriorFaces(self, fes) + AssemblePAInteriorFaces = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssemblePAInteriorFaces) + + def AssemblePABoundaryFaces(self, fes): + r"""AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.BilinearFormIntegrator_AssemblePABoundaryFaces(self, fes) + AssemblePABoundaryFaces = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssemblePABoundaryFaces) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)""" + return _bilininteg.BilinearFormIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleDiagonalPA) def AddMultPA(self, x, y): r"""AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)""" return _bilininteg.BilinearFormIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AddMultPA) def AddMultTransposePA(self, x, y): r"""AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)""" return _bilininteg.BilinearFormIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AddMultTransposePA) def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementMatrix2) def AssembleFaceMatrix(self, *args): r""" @@ -128,26 +157,32 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.BilinearFormIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleFaceMatrix) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _bilininteg.BilinearFormIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementVector) def AssembleElementGrad(self, el, Tr, elfun, elmat): r"""AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementGrad) def AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat): r"""AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat) + AssembleFaceGrad = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleFaceGrad) - def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=1): - r"""ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)""" + def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=True): + r"""ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)""" return _bilininteg.BilinearFormIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.BilinearFormIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_ComputeFluxEnergy) __swig_destroy__ = _bilininteg.delete_BilinearFormIntegrator def __disown__(self): self.this.disown() @@ -174,10 +209,12 @@ def __init__(self, _bfi, _own_bfi=1): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.TransposeIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.TransposeIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssembleElementMatrix2) def AssembleFaceMatrix(self, *args): r""" @@ -186,6 +223,35 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.TransposeIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssembleFaceMatrix) + + def AssemblePA(self, *args): + r""" + AssemblePA(TransposeIntegrator self) + AssemblePA(TransposeIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.TransposeIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssemblePA) + + def AssemblePAInteriorFaces(self, fes): + r"""AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.TransposeIntegrator_AssemblePAInteriorFaces(self, fes) + AssemblePAInteriorFaces = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssemblePAInteriorFaces) + + def AssemblePABoundaryFaces(self, fes): + r"""AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.TransposeIntegrator_AssemblePABoundaryFaces(self, fes) + AssemblePABoundaryFaces = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssemblePABoundaryFaces) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)""" + return _bilininteg.TransposeIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AddMultTransposePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(TransposeIntegrator self, Vector x, Vector y)""" + return _bilininteg.TransposeIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AddMultPA) __swig_destroy__ = _bilininteg.delete_TransposeIntegrator # Register TransposeIntegrator in _bilininteg: @@ -204,6 +270,7 @@ def __init__(self, _bfi, _own_bfi=1): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.LumpedIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.LumpedIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_LumpedIntegrator # Register LumpedIntegrator in _bilininteg: @@ -226,6 +293,7 @@ def __init__(self, integ, own_integ=1): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.InverseIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.InverseIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_InverseIntegrator # Register InverseIntegrator in _bilininteg: @@ -253,6 +321,7 @@ def AddIntegrator(self, integ): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.SumIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.SumIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_SumIntegrator # Register SumIntegrator in _bilininteg: @@ -270,10 +339,12 @@ def __init__(self, *args, **kwargs): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedScalarIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MixedScalarIntegrator_AssembleElementMatrix2) def AssembleElementMatrix(self, fe, Trans, elmat): r"""AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedScalarIntegrator_AssembleElementMatrix(self, fe, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.MixedScalarIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_MixedScalarIntegrator # Register MixedScalarIntegrator in _bilininteg: @@ -291,10 +362,12 @@ def __init__(self, *args, **kwargs): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedVectorIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MixedVectorIntegrator_AssembleElementMatrix2) def AssembleElementMatrix(self, fe, Trans, elmat): r"""AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedVectorIntegrator_AssembleElementMatrix(self, fe, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.MixedVectorIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_MixedVectorIntegrator # Register MixedVectorIntegrator in _bilininteg: @@ -312,6 +385,7 @@ def __init__(self, *args, **kwargs): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedScalarVectorIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MixedScalarVectorIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_MixedScalarVectorIntegrator # Register MixedScalarVectorIntegrator in _bilininteg: @@ -515,10 +589,12 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedDotProductIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedDotProductIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *""" return _bilininteg.MixedDotProductIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedDotProductIntegrator_FiniteElementTypeFailureMessage) __swig_destroy__ = _bilininteg.delete_MixedDotProductIntegrator # Register MixedDotProductIntegrator in _bilininteg: @@ -542,14 +618,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedWeakGradDotIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *""" return _bilininteg.MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedWeakGradDotIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedWeakGradDotIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedWeakGradDotIntegrator # Register MixedWeakGradDotIntegrator in _bilininteg: @@ -568,14 +647,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *""" return _bilininteg.MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedWeakDivCrossIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedWeakDivCrossIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedWeakDivCrossIntegrator # Register MixedWeakDivCrossIntegrator in _bilininteg: @@ -599,22 +681,27 @@ def __init__(self, *args): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedGradGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *""" return _bilininteg.MixedGradGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_FiniteElementTypeFailureMessage) def GetIntegrationOrder(self, trial_fe, test_fe, Trans): r"""GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int""" return _bilininteg.MixedGradGradIntegrator_GetIntegrationOrder(self, trial_fe, test_fe, Trans) + GetIntegrationOrder = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_GetIntegrationOrder) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedGradGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedGradGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedGradGradIntegrator # Register MixedGradGradIntegrator in _bilininteg: @@ -633,18 +720,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *""" return _bilininteg.MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossGradGradIntegrator # Register MixedCrossGradGradIntegrator in _bilininteg: @@ -668,18 +759,22 @@ def __init__(self, *args): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCurlCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *""" return _bilininteg.MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCurlCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCurlCurlIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCurlCurlIntegrator # Register MixedCurlCurlIntegrator in _bilininteg: @@ -698,18 +793,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *""" return _bilininteg.MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlCurlIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossCurlCurlIntegrator # Register MixedCrossCurlCurlIntegrator in _bilininteg: @@ -728,18 +827,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *""" return _bilininteg.MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossCurlGradIntegrator # Register MixedCrossCurlGradIntegrator in _bilininteg: @@ -758,18 +861,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *""" return _bilininteg.MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradCurlIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossGradCurlIntegrator # Register MixedCrossGradCurlIntegrator in _bilininteg: @@ -788,14 +895,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *""" return _bilininteg.MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedWeakCurlCrossIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedWeakCurlCrossIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedWeakCurlCrossIntegrator # Register MixedWeakCurlCrossIntegrator in _bilininteg: @@ -814,14 +924,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *""" return _bilininteg.MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedScalarWeakCurlCrossIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedScalarWeakCurlCrossIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedScalarWeakCurlCrossIntegrator # Register MixedScalarWeakCurlCrossIntegrator in _bilininteg: @@ -840,18 +953,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *""" return _bilininteg.MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossGradIntegrator # Register MixedCrossGradIntegrator in _bilininteg: @@ -870,14 +987,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *""" return _bilininteg.MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlIntegrator_CalcTrialShape) __swig_destroy__ = _bilininteg.delete_MixedCrossCurlIntegrator # Register MixedCrossCurlIntegrator in _bilininteg: @@ -896,14 +1016,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *""" return _bilininteg.MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedScalarCrossCurlIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedScalarCrossCurlIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedScalarCrossCurlIntegrator # Register MixedScalarCrossCurlIntegrator in _bilininteg: @@ -922,14 +1045,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *""" return _bilininteg.MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedScalarCrossGradIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedScalarCrossGradIntegrator_CalcVShape) __swig_destroy__ = _bilininteg.delete_MixedScalarCrossGradIntegrator # Register MixedScalarCrossGradIntegrator in _bilininteg: @@ -948,10 +1074,12 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *""" return _bilininteg.MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage) __swig_destroy__ = _bilininteg.delete_MixedScalarCrossProductIntegrator # Register MixedScalarCrossProductIntegrator in _bilininteg: @@ -970,14 +1098,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *""" return _bilininteg.MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedScalarWeakCrossProductIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedScalarWeakCrossProductIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedScalarWeakCrossProductIntegrator # Register MixedScalarWeakCrossProductIntegrator in _bilininteg: @@ -996,14 +1127,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *""" return _bilininteg.MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedDirectionalDerivativeIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedDirectionalDerivativeIntegrator_CalcVShape) __swig_destroy__ = _bilininteg.delete_MixedDirectionalDerivativeIntegrator # Register MixedDirectionalDerivativeIntegrator in _bilininteg: @@ -1022,18 +1156,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedGradDivIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *""" return _bilininteg.MixedGradDivIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedGradDivIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_CalcVShape) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedGradDivIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedGradDivIntegrator # Register MixedGradDivIntegrator in _bilininteg: @@ -1052,18 +1190,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedDivGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *""" return _bilininteg.MixedDivGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedDivGradIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_CalcVShape) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedDivGradIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedDivGradIntegrator # Register MixedDivGradIntegrator in _bilininteg: @@ -1082,14 +1224,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *""" return _bilininteg.MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedScalarWeakDivergenceIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedScalarWeakDivergenceIntegrator_CalcVShape) __swig_destroy__ = _bilininteg.delete_MixedScalarWeakDivergenceIntegrator # Register MixedScalarWeakDivergenceIntegrator in _bilininteg: @@ -1181,6 +1326,58 @@ def __init__(self, *args): # Register MixedVectorWeakDivergenceIntegrator in _bilininteg: _bilininteg.MixedVectorWeakDivergenceIntegrator_swigregister(MixedVectorWeakDivergenceIntegrator) +class GradientIntegrator(BilinearFormIntegrator): + r"""Proxy of C++ mfem::GradientIntegrator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(GradientIntegrator self) -> GradientIntegrator + __init__(GradientIntegrator self, Coefficient _q) -> GradientIntegrator + __init__(GradientIntegrator self, Coefficient q) -> GradientIntegrator + """ + _bilininteg.GradientIntegrator_swiginit(self, _bilininteg.new_GradientIntegrator(*args)) + + def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): + r"""AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" + return _bilininteg.GradientIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.GradientIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(GradientIntegrator self) + AssemblePA(GradientIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _bilininteg.GradientIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.GradientIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(GradientIntegrator self, Vector x, Vector y)""" + return _bilininteg.GradientIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.GradientIntegrator_AddMultPA) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)""" + return _bilininteg.GradientIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.GradientIntegrator_AddMultTransposePA) + + @staticmethod + def GetRule(trial_fe, test_fe, Trans): + r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.GradientIntegrator_GetRule(trial_fe, test_fe, Trans) + GetRule = _swig_new_static_method(_bilininteg.GradientIntegrator_GetRule) + __swig_destroy__ = _bilininteg.delete_GradientIntegrator + +# Register GradientIntegrator in _bilininteg: +_bilininteg.GradientIntegrator_swigregister(GradientIntegrator) + +def GradientIntegrator_GetRule(trial_fe, test_fe, Trans): + r"""GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.GradientIntegrator_GetRule(trial_fe, test_fe, Trans) +GradientIntegrator_GetRule = _bilininteg.GradientIntegrator_GetRule + class DiffusionIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::DiffusionIntegrator class.""" @@ -1199,40 +1396,61 @@ def __init__(self, *args): + __swig_destroy__ = _bilininteg.delete_DiffusionIntegrator def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DiffusionIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DiffusionIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleElementMatrix2) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _bilininteg.DiffusionIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleElementVector) - def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=1): - r"""ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)""" + def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=True): + r"""ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)""" return _bilininteg.DiffusionIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.DiffusionIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_ComputeFluxEnergy) - def AssemblePA(self, arg2): - r"""AssemblePA(DiffusionIntegrator self, FiniteElementSpace arg2)""" - return _bilininteg.DiffusionIntegrator_AssemblePA(self, arg2) + def AssemblePA(self, *args): + r""" + AssemblePA(DiffusionIntegrator self) + AssemblePA(DiffusionIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.DiffusionIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)""" + return _bilininteg.DiffusionIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleDiagonalPA) def AddMultPA(self, arg2, arg3): r"""AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)""" return _bilininteg.DiffusionIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AddMultPA) @staticmethod def GetRule(trial_fe, test_fe): r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule""" return _bilininteg.DiffusionIntegrator_GetRule(trial_fe, test_fe) - __swig_destroy__ = _bilininteg.delete_DiffusionIntegrator + GetRule = _swig_new_static_method(_bilininteg.DiffusionIntegrator_GetRule) + + def SetupPA(self, fes, force=False): + r"""SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)""" + return _bilininteg.DiffusionIntegrator_SetupPA(self, fes, force) + SetupPA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_SetupPA) # Register DiffusionIntegrator in _bilininteg: _bilininteg.DiffusionIntegrator_swigregister(DiffusionIntegrator) @@ -1240,6 +1458,7 @@ def GetRule(trial_fe, test_fe): def DiffusionIntegrator_GetRule(trial_fe, test_fe): r"""DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule""" return _bilininteg.DiffusionIntegrator_GetRule(trial_fe, test_fe) +DiffusionIntegrator_GetRule = _bilininteg.DiffusionIntegrator_GetRule class MassIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::MassIntegrator class.""" @@ -1258,28 +1477,46 @@ def __init__(self, *args): + __swig_destroy__ = _bilininteg.delete_MassIntegrator def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MassIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.MassIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MassIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MassIntegrator_AssembleElementMatrix2) - def AssemblePA(self, arg2): - r"""AssemblePA(MassIntegrator self, FiniteElementSpace arg2)""" - return _bilininteg.MassIntegrator_AssemblePA(self, arg2) + def AssemblePA(self, *args): + r""" + AssemblePA(MassIntegrator self) + AssemblePA(MassIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.MassIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.MassIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(MassIntegrator self, Vector diag)""" + return _bilininteg.MassIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.MassIntegrator_AssembleDiagonalPA) def AddMultPA(self, arg2, arg3): r"""AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)""" return _bilininteg.MassIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.MassIntegrator_AddMultPA) @staticmethod def GetRule(trial_fe, test_fe, Trans): r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" return _bilininteg.MassIntegrator_GetRule(trial_fe, test_fe, Trans) - __swig_destroy__ = _bilininteg.delete_MassIntegrator + GetRule = _swig_new_static_method(_bilininteg.MassIntegrator_GetRule) + + def SetupPA(self, fes, force=False): + r"""SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)""" + return _bilininteg.MassIntegrator_SetupPA(self, fes, force) + SetupPA = _swig_new_instance_method(_bilininteg.MassIntegrator_SetupPA) # Register MassIntegrator in _bilininteg: _bilininteg.MassIntegrator_swigregister(MassIntegrator) @@ -1287,6 +1524,7 @@ def GetRule(trial_fe, test_fe, Trans): def MassIntegrator_GetRule(trial_fe, test_fe, Trans): r"""MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" return _bilininteg.MassIntegrator_GetRule(trial_fe, test_fe, Trans) +MassIntegrator_GetRule = _bilininteg.MassIntegrator_GetRule class BoundaryMassIntegrator(MassIntegrator): r"""Proxy of C++ mfem::BoundaryMassIntegrator class.""" @@ -1305,6 +1543,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.BoundaryMassIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.BoundaryMassIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_BoundaryMassIntegrator # Register BoundaryMassIntegrator in _bilininteg: @@ -1323,11 +1562,42 @@ def __init__(self, q, a=1.0): def AssembleElementMatrix(self, arg2, arg3, arg4): r"""AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)""" return _bilininteg.ConvectionIntegrator_AssembleElementMatrix(self, arg2, arg3, arg4) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.ConvectionIntegrator_AssembleElementMatrix) + + def AssemblePA(self, *args): + r""" + AssemblePA(ConvectionIntegrator self) + AssemblePA(ConvectionIntegrator self, FiniteElementSpace arg2) + """ + return _bilininteg.ConvectionIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.ConvectionIntegrator_AssemblePA) + + def AddMultPA(self, arg2, arg3): + r"""AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)""" + return _bilininteg.ConvectionIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.ConvectionIntegrator_AddMultPA) + + @staticmethod + def GetRule(*args): + r""" + GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule + GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule + """ + return _bilininteg.ConvectionIntegrator_GetRule(*args) + GetRule = _swig_new_static_method(_bilininteg.ConvectionIntegrator_GetRule) __swig_destroy__ = _bilininteg.delete_ConvectionIntegrator # Register ConvectionIntegrator in _bilininteg: _bilininteg.ConvectionIntegrator_swigregister(ConvectionIntegrator) +def ConvectionIntegrator_GetRule(*args): + r""" + ConvectionIntegrator_GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule + ConvectionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule + """ + return _bilininteg.ConvectionIntegrator_GetRule(*args) +ConvectionIntegrator_GetRule = _bilininteg.ConvectionIntegrator_GetRule + class GroupConvectionIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::GroupConvectionIntegrator class.""" @@ -1341,6 +1611,7 @@ def __init__(self, q, a=1.0): def AssembleElementMatrix(self, arg2, arg3, arg4): r"""AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)""" return _bilininteg.GroupConvectionIntegrator_AssembleElementMatrix(self, arg2, arg3, arg4) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.GroupConvectionIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_GroupConvectionIntegrator # Register GroupConvectionIntegrator in _bilininteg: @@ -1365,18 +1636,40 @@ def __init__(self, *args): def GetVDim(self): r"""GetVDim(VectorMassIntegrator self) -> int""" return _bilininteg.VectorMassIntegrator_GetVDim(self) + GetVDim = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_GetVDim) def SetVDim(self, vdim): r"""SetVDim(VectorMassIntegrator self, int vdim)""" return _bilininteg.VectorMassIntegrator_SetVDim(self, vdim) + SetVDim = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_SetVDim) def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorMassIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorMassIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorMassIntegrator self) + AssemblePA(VectorMassIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.VectorMassIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)""" + return _bilininteg.VectorMassIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssembleDiagonalPA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorMassIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorMassIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AddMultPA) __swig_destroy__ = _bilininteg.delete_VectorMassIntegrator # Register VectorMassIntegrator in _bilininteg: @@ -1398,10 +1691,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorFEDivergenceIntegrator # Register VectorFEDivergenceIntegrator in _bilininteg: @@ -1423,10 +1718,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorFEWeakDivergenceIntegrator # Register VectorFEWeakDivergenceIntegrator in _bilininteg: @@ -1448,10 +1745,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFECurlIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFECurlIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFECurlIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFECurlIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorFECurlIntegrator # Register VectorFECurlIntegrator in _bilininteg: @@ -1470,10 +1769,12 @@ def __init__(self, q, i): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DerivativeIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.DerivativeIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DerivativeIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.DerivativeIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_DerivativeIntegrator # Register DerivativeIntegrator in _bilininteg: @@ -1501,14 +1802,35 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.CurlCurlIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AssembleElementMatrix) def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef): - r"""ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef)""" + r"""ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)""" return _bilininteg.CurlCurlIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.CurlCurlIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_ComputeFluxEnergy) + + def AssemblePA(self, *args): + r""" + AssemblePA(CurlCurlIntegrator self) + AssemblePA(CurlCurlIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.CurlCurlIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)""" + return _bilininteg.CurlCurlIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AddMultPA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)""" + return _bilininteg.CurlCurlIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AssembleDiagonalPA) __swig_destroy__ = _bilininteg.delete_CurlCurlIntegrator # Register CurlCurlIntegrator in _bilininteg: @@ -1530,10 +1852,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorCurlCurlIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorCurlCurlIntegrator_AssembleElementMatrix) def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double""" return _bilininteg.VectorCurlCurlIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_bilininteg.VectorCurlCurlIntegrator_GetElementEnergy) __swig_destroy__ = _bilininteg.delete_VectorCurlCurlIntegrator # Register VectorCurlCurlIntegrator in _bilininteg: @@ -1565,10 +1889,30 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEMassIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEMassIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorFEMassIntegrator self) + AssemblePA(VectorFEMassIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.VectorFEMassIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorFEMassIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AddMultPA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)""" + return _bilininteg.VectorFEMassIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssembleDiagonalPA) __swig_destroy__ = _bilininteg.delete_VectorFEMassIntegrator # Register VectorFEMassIntegrator in _bilininteg: @@ -1591,11 +1935,41 @@ def __init__(self, *args): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorDivergenceIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorDivergenceIntegrator self) + AssemblePA(VectorDivergenceIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _bilininteg.VectorDivergenceIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorDivergenceIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AddMultPA) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorDivergenceIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AddMultTransposePA) + + @staticmethod + def GetRule(trial_fe, test_fe, Trans): + r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.VectorDivergenceIntegrator_GetRule(trial_fe, test_fe, Trans) + GetRule = _swig_new_static_method(_bilininteg.VectorDivergenceIntegrator_GetRule) __swig_destroy__ = _bilininteg.delete_VectorDivergenceIntegrator # Register VectorDivergenceIntegrator in _bilininteg: _bilininteg.VectorDivergenceIntegrator_swigregister(VectorDivergenceIntegrator) +def VectorDivergenceIntegrator_GetRule(trial_fe, test_fe, Trans): + r"""VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.VectorDivergenceIntegrator_GetRule(trial_fe, test_fe, Trans) +VectorDivergenceIntegrator_GetRule = _bilininteg.VectorDivergenceIntegrator_GetRule + class DivDivIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::DivDivIntegrator class.""" @@ -1612,6 +1986,7 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DivDivIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.DivDivIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_DivDivIntegrator # Register DivDivIntegrator in _bilininteg: @@ -1633,10 +2008,30 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorDiffusionIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssembleElementMatrix) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _bilininteg.VectorDiffusionIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssembleElementVector) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorDiffusionIntegrator self) + AssemblePA(VectorDiffusionIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.VectorDiffusionIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)""" + return _bilininteg.VectorDiffusionIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssembleDiagonalPA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorDiffusionIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AddMultPA) __swig_destroy__ = _bilininteg.delete_VectorDiffusionIntegrator # Register VectorDiffusionIntegrator in _bilininteg: @@ -1658,14 +2053,17 @@ def __init__(self, *args): def AssembleElementMatrix(self, arg2, arg3, arg4): r"""AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)""" return _bilininteg.ElasticityIntegrator_AssembleElementMatrix(self, arg2, arg3, arg4) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.ElasticityIntegrator_AssembleElementMatrix) - def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=1): - r"""ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)""" + def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=True): + r"""ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)""" return _bilininteg.ElasticityIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.ElasticityIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.ElasticityIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.ElasticityIntegrator_ComputeFluxEnergy) __swig_destroy__ = _bilininteg.delete_ElasticityIntegrator # Register ElasticityIntegrator in _bilininteg: @@ -1691,11 +2089,43 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.DGTraceIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AssembleFaceMatrix) + + def AssemblePAInteriorFaces(self, fes): + r"""AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.DGTraceIntegrator_AssemblePAInteriorFaces(self, fes) + AssemblePAInteriorFaces = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AssemblePAInteriorFaces) + + def AssemblePABoundaryFaces(self, fes): + r"""AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.DGTraceIntegrator_AssemblePABoundaryFaces(self, fes) + AssemblePABoundaryFaces = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AssemblePABoundaryFaces) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)""" + return _bilininteg.DGTraceIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AddMultTransposePA) + + def AddMultPA(self, arg2, arg3): + r"""AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)""" + return _bilininteg.DGTraceIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AddMultPA) + + @staticmethod + def GetRule(geom, order, T): + r"""GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule""" + return _bilininteg.DGTraceIntegrator_GetRule(geom, order, T) + GetRule = _swig_new_static_method(_bilininteg.DGTraceIntegrator_GetRule) __swig_destroy__ = _bilininteg.delete_DGTraceIntegrator # Register DGTraceIntegrator in _bilininteg: _bilininteg.DGTraceIntegrator_swigregister(DGTraceIntegrator) +def DGTraceIntegrator_GetRule(geom, order, T): + r"""DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule""" + return _bilininteg.DGTraceIntegrator_GetRule(geom, order, T) +DGTraceIntegrator_GetRule = _bilininteg.DGTraceIntegrator_GetRule + class DGDiffusionIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::DGDiffusionIntegrator class.""" @@ -1717,6 +2147,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.DGDiffusionIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.DGDiffusionIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_DGDiffusionIntegrator # Register DGDiffusionIntegrator in _bilininteg: @@ -1742,6 +2173,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.DGElasticityIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.DGElasticityIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_DGElasticityIntegrator # Register DGElasticityIntegrator in _bilininteg: @@ -1764,6 +2196,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.TraceJumpIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.TraceJumpIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_TraceJumpIntegrator # Register TraceJumpIntegrator in _bilininteg: @@ -1786,6 +2219,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.NormalTraceJumpIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.NormalTraceJumpIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_NormalTraceJumpIntegrator # Register NormalTraceJumpIntegrator in _bilininteg: @@ -1814,6 +2248,7 @@ class GradientInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, h1_fe, nd_fe, Trans, elmat): r"""AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.GradientInterpolator_AssembleElementMatrix2(self, h1_fe, nd_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.GradientInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(GradientInterpolator self) -> GradientInterpolator""" @@ -1832,6 +2267,7 @@ class IdentityInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.IdentityInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.IdentityInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(IdentityInterpolator self) -> IdentityInterpolator""" @@ -1850,6 +2286,7 @@ class CurlInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.CurlInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.CurlInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(CurlInterpolator self) -> CurlInterpolator""" @@ -1868,6 +2305,7 @@ class DivergenceInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DivergenceInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.DivergenceInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(DivergenceInterpolator self) -> DivergenceInterpolator""" @@ -1886,6 +2324,7 @@ class NormalInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.NormalInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.NormalInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(NormalInterpolator self) -> NormalInterpolator""" @@ -1908,6 +2347,7 @@ def __init__(self, sc): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.ScalarProductInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.ScalarProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_ScalarProductInterpolator # Register ScalarProductInterpolator in _bilininteg: @@ -1926,6 +2366,7 @@ def __init__(self, sc): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.ScalarVectorProductInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.ScalarVectorProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_ScalarVectorProductInterpolator # Register ScalarVectorProductInterpolator in _bilininteg: @@ -1944,6 +2385,7 @@ def __init__(self, vc): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorScalarProductInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorScalarProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorScalarProductInterpolator # Register VectorScalarProductInterpolator in _bilininteg: @@ -1962,6 +2404,7 @@ def __init__(self, vc): def AssembleElementMatrix2(self, nd_fe, rt_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorCrossProductInterpolator_AssembleElementMatrix2(self, nd_fe, rt_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorCrossProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorCrossProductInterpolator # Register VectorCrossProductInterpolator in _bilininteg: @@ -1980,6 +2423,7 @@ def __init__(self, vc): def AssembleElementMatrix2(self, rt_fe, l2_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorInnerProductInterpolator_AssembleElementMatrix2(self, rt_fe, l2_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorInnerProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorInnerProductInterpolator # Register VectorInnerProductInterpolator in _bilininteg: diff --git a/mfem/_par/bilininteg_wrap.cxx b/mfem/_par/bilininteg_wrap.cxx index cd695970..77b9181f 100644 --- a/mfem/_par/bilininteg_wrap.cxx +++ b/mfem/_par/bilininteg_wrap.cxx @@ -3067,248 +3067,252 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[5] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[6] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[7] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[8] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[12] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__Coefficient swig_types[14] -#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[15] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[17] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[18] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[22] -#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[23] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[24] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[25] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[26] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[27] -#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[28] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[29] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[31] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[32] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[33] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[35] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[36] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[38] -#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[39] -#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[40] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[41] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[42] -#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[43] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[44] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[45] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[46] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[47] -#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[48] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[49] -#define SWIGTYPE_p_mfem__GridFunction swig_types[50] -#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[51] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[53] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[54] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[55] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[56] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[57] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[58] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[59] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[60] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[61] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[62] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[63] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[64] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[65] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[66] -#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[67] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[68] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[69] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[71] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[72] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[73] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[74] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[75] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[76] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[77] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[78] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[79] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[80] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[81] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[82] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[83] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[84] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[85] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__LinearForm swig_types[91] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[93] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[94] -#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[95] -#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[96] -#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[97] -#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[98] -#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[99] -#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[100] -#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[101] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[102] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[103] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[104] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[105] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[106] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[107] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[108] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[109] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[110] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[111] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[112] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[113] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[114] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[115] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[116] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[117] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[118] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[119] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[120] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[121] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[122] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[123] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[124] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[125] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[126] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[127] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[128] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[129] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[130] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[131] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[132] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[133] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[134] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[135] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[136] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[137] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[138] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[139] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[140] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[141] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[142] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[143] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[144] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[145] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[146] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[147] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[148] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[149] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[150] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[151] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[152] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[153] -#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[154] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[155] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[156] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[157] -#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[158] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[159] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[160] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[161] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[162] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[163] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[164] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[165] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[166] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[167] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[168] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[169] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[170] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[171] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[172] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[173] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[174] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[175] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[176] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[177] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[178] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[179] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[180] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[181] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[182] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[183] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[184] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[185] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[186] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[187] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[188] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[189] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[190] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[191] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[192] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[193] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[194] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[195] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[196] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[197] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[198] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[199] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[200] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[201] -#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[202] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[203] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[204] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[205] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[206] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[207] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[208] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[209] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[210] -#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[211] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[212] -#define SWIGTYPE_p_mfem__Vector swig_types[213] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[214] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[215] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[216] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[217] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[218] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[219] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[220] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[221] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[222] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[223] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[224] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[225] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[226] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[227] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[228] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[229] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[230] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[231] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[232] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[233] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[234] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[235] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[236] -#define SWIGTYPE_p_pri_t swig_types[237] -#define SWIGTYPE_p_quad_t swig_types[238] -#define SWIGTYPE_p_seg_t swig_types[239] -#define SWIGTYPE_p_tet_t swig_types[240] -#define SWIGTYPE_p_tri_t swig_types[241] -static swig_type_info *swig_types[243]; -static swig_module_info swig_module = {swig_types, 242, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[6] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[7] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[8] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[9] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[13] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__Coefficient swig_types[15] +#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[16] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[18] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[19] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[23] +#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[24] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[25] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[26] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[27] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[28] +#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[29] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[30] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[32] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[34] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[36] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[37] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[39] +#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[40] +#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[41] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[42] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[43] +#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[44] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[45] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[46] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[47] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[48] +#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[49] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[50] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[51] +#define SWIGTYPE_p_mfem__GridFunction swig_types[52] +#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[53] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[55] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[56] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[57] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[58] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[59] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[60] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[61] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[63] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[64] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[65] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[66] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[67] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[68] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[69] +#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[70] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[71] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[72] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[74] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[75] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[76] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[77] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[78] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[79] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[80] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[81] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[82] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[83] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[84] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[85] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[86] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[87] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[88] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__LinearForm swig_types[94] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[95] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[96] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[97] +#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[98] +#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[99] +#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[100] +#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[101] +#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[102] +#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[103] +#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[104] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[105] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[106] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[107] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[108] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[109] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[110] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[111] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[112] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[113] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[114] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[115] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[116] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[117] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[118] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[119] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[120] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[121] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[122] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[123] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[124] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[125] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[126] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[127] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[128] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[129] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[130] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[131] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[132] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[133] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[134] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[135] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[136] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[137] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[138] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[139] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[140] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[141] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[142] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[143] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[144] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[145] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[146] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[147] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[148] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[149] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[150] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[151] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[152] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[153] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[154] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[155] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[156] +#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[157] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[158] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[159] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[160] +#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[161] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[162] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[163] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[164] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[165] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[166] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[167] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[168] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[169] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[170] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[171] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[172] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[173] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[174] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[175] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[176] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[177] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[178] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[179] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[180] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[181] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[182] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[183] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[184] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[185] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[186] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[187] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[188] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[189] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[190] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[191] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[192] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[193] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[194] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[195] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[196] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[197] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[198] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[199] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[200] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[201] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[202] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[203] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[204] +#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[205] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[206] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[207] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[208] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[209] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[210] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[211] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[212] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[213] +#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[214] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[215] +#define SWIGTYPE_p_mfem__Vector swig_types[216] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[217] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[218] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[219] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[220] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[221] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[222] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[223] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[224] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[225] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[226] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[227] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[228] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[229] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[230] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[231] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[232] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[233] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[234] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[235] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[236] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[237] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[238] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[239] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[240] +#define SWIGTYPE_p_pri_t swig_types[241] +#define SWIGTYPE_p_quad_t swig_types[242] +#define SWIGTYPE_p_seg_t swig_types[243] +#define SWIGTYPE_p_tet_t swig_types[244] +#define SWIGTYPE_p_tri_t swig_types[245] +static swig_type_info *swig_types[247]; +static swig_module_info swig_module = {swig_types, 246, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3419,13 +3423,6 @@ namespace swig { #include "numpy/arrayobject.h" -SWIGINTERNINLINE PyObject* - SWIG_From_int (int value) -{ - return PyInt_FromLong((long) value); -} - - SWIGINTERN int SWIG_AsVal_double (PyObject *obj, double *val) { @@ -3472,7 +3469,97 @@ SWIG_AsVal_double (PyObject *obj, double *val) } - #define SWIG_From_double PyFloat_FromDouble +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} SWIGINTERNINLINE PyObject* @@ -3482,6 +3569,9 @@ SWIGINTERNINLINE PyObject* } + #define SWIG_From_double PyFloat_FromDouble + + SWIGINTERN swig_type_info* SWIG_pchar_descriptor(void) { @@ -3527,6 +3617,39 @@ SWIG_FromCharPtr(const char *cptr) } +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + /* --------------------------------------------------- * C++ director class methods @@ -3567,6 +3690,112 @@ void SwigDirector_BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace co } +void SwigDirector_BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&trial_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&test_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 1; + const char *const swig_method_name = "AssemblePA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_BilinearFormIntegrator::AssemblePAInteriorFaces(mfem::FiniteElementSpace const &fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 2; + const char *const swig_method_name = "AssemblePAInteriorFaces"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePAInteriorFaces"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_BilinearFormIntegrator::AssemblePABoundaryFaces(mfem::FiniteElementSpace const &fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 3; + const char *const swig_method_name = "AssemblePABoundaryFaces"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePABoundaryFaces"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_BilinearFormIntegrator::AssembleDiagonalPA(mfem::Vector &diag) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&diag), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 4; + const char *const swig_method_name = "AssembleDiagonalPA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssembleDiagonalPA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + void SwigDirector_BilinearFormIntegrator::AddMultPA(mfem::Vector const &x, mfem::Vector &y) const { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); @@ -3576,7 +3805,7 @@ void SwigDirector_BilinearFormIntegrator::AddMultPA(mfem::Vector const &x, mfem: Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 1; + const size_t swig_method_index = 5; const char *const swig_method_name = "AddMultPA"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3604,7 +3833,7 @@ void SwigDirector_BilinearFormIntegrator::AddMultTransposePA(mfem::Vector const Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 2; + const size_t swig_method_index = 6; const char *const swig_method_name = "AddMultTransposePA"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3634,7 +3863,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementMatrix(mfem::FiniteElem Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 3; + const size_t swig_method_index = 7; const char *const swig_method_name = "AssembleElementMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -3666,7 +3895,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementMatrix2(mfem::FiniteEle Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 4; + const size_t swig_method_index = 8; const char *const swig_method_name = "AssembleElementMatrix2"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3698,7 +3927,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 5; + const size_t swig_method_index = 9; const char *const swig_method_name = "AssembleFaceMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3732,7 +3961,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 10; const char *const swig_method_name = "AssembleFaceMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); @@ -3764,7 +3993,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementVector(mfem::FiniteElem Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 11; const char *const swig_method_name = "AssembleElementVector"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3796,7 +4025,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementGrad(mfem::FiniteElemen Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 12; const char *const swig_method_name = "AssembleElementGrad"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3830,7 +4059,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceGrad(mfem::FiniteElement c Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 13; const char *const swig_method_name = "AssembleFaceGrad"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); @@ -3849,7 +4078,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceGrad(mfem::FiniteElement c } -void SwigDirector_BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, int with_coef) { +void SwigDirector_BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, bool with_coef) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&el), SWIGTYPE_p_mfem__FiniteElement, 0 ); swig::SwigVar_PyObject obj1; @@ -3861,12 +4090,12 @@ void SwigDirector_BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement swig::SwigVar_PyObject obj4; obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&flux), SWIGTYPE_p_mfem__Vector, 0 ); swig::SwigVar_PyObject obj5; - obj5 = SWIG_From_int(static_cast< int >(with_coef)); + obj5 = SWIG_From_bool(static_cast< bool >(with_coef)); if (!swig_get_self()) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 14; const char *const swig_method_name = "ComputeElementFlux"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL); @@ -3900,7 +4129,7 @@ double SwigDirector_BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElemen Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 12; + const size_t swig_method_index = 16; const char *const swig_method_name = "ComputeFluxEnergy"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -4033,7 +4262,7 @@ SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -4041,11 +4270,10 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePA", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); @@ -4084,52 +4312,51 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - ((mfem::BilinearFormIntegrator const *)arg1)->mfem::BilinearFormIntegrator::AddMultPA((mfem::Vector const &)*arg2,*arg3); + (arg1)->mfem::BilinearFormIntegrator::AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } else { - ((mfem::BilinearFormIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } } catch (Swig::DirectorException &e) { @@ -4146,33 +4373,297 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - Swig::Director *director = 0; - bool upcall = false; +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearFormIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearFormIntegrator_AssemblePA__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearFormIntegrator::AssemblePA()\n" + " mfem::BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n" + " mfem::BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearFormIntegrator::AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); + } else { + (arg1)->AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearFormIntegrator::AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); + } else { + (arg1)->AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearFormIntegrator::AssembleDiagonalPA(*arg2); + } else { + (arg1)->AssembleDiagonalPA(*arg2); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + ((mfem::BilinearFormIntegrator const *)arg1)->mfem::BilinearFormIntegrator::AddMultPA((mfem::Vector const &)*arg2,*arg3); + } else { + ((mfem::BilinearFormIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); @@ -4889,7 +5380,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO mfem::Vector *arg4 = 0 ; mfem::FiniteElement *arg5 = 0 ; mfem::Vector *arg6 = 0 ; - int arg7 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4902,6 +5393,8 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; Swig::Director *director = 0; bool upcall = false; @@ -4951,12 +5444,11 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { @@ -5141,12 +5633,8 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *s _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); } if (_v) { return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); @@ -5162,7 +5650,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *s fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeElementFlux'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,int)\n" + " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); return 0; } @@ -6027,17 +6515,264 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix(PyObject *self } -SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TransposeIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransposeIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::TransposeIntegrator::AssemblePA()\n" + " mfem::TransposeIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::TransposeIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::TransposeIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeIntegrator" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); @@ -14497,134 +15232,132 @@ SWIGINTERN PyObject *MixedVectorWeakDivergenceIntegrator_swiginit(PyObject *SWIG return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *result = 0 ; + mfem::GradientIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(); + result = (mfem::GradientIntegrator *)new mfem::GradientIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DiffusionIntegrator *result = 0 ; + mfem::GradientIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); + result = (mfem::GradientIntegrator *)new mfem::GradientIntegrator(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DiffusionIntegrator *result = 0 ; + mfem::GradientIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); + result = (mfem::GradientIntegrator *)new mfem::GradientIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiffusionIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GradientIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_DiffusionIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_GradientIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_DiffusionIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_GradientIntegrator__SWIG_1(self, argc, argv); } } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_DiffusionIntegrator__SWIG_2(self, argc, argv); + return _wrap_new_GradientIntegrator__SWIG_2(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiffusionIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GradientIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::DiffusionIntegrator()\n" - " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::Coefficient &)\n" - " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::GradientIntegrator::GradientIntegrator()\n" + " mfem::GradientIntegrator::GradientIntegrator(mfem::Coefficient *)\n" + " mfem::GradientIntegrator::GradientIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -14633,41 +15366,51 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14680,66 +15423,43 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14752,66 +15472,79 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GradientIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GradientIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GradientIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GradientIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GradientIntegrator::AssemblePA()\n" + " mfem::GradientIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + ((mfem::GradientIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14824,83 +15557,44 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - int arg7 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + ((mfem::GradientIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14913,187 +15607,257 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObje } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + { + try { + result = (mfem::IntegrationRule *) &mfem::GradientIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GradientIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GradientIntegrator" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GradientIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GradientIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GradientIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::DiffusionIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::DiffusionIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MatrixCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::DiffusionIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + { + try { + result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiffusionIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 6) { + if (argc == 0) { + return _wrap_new_DiffusionIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } + return _wrap_new_DiffusionIntegrator__SWIG_1(self, argc, argv); } } - if (argc == 7) { + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } + return _wrap_new_DiffusionIntegrator__SWIG_2(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeElementFlux'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiffusionIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,int)\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); + " mfem::DiffusionIntegrator::DiffusionIntegrator()\n" + " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::Coefficient &)\n" + " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::MatrixCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_DiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -15102,66 +15866,60 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + PyObject *swig_obj[4] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -15170,149 +15928,123 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - double result; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssemblePA", 2, 2, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15325,44 +16057,84 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); { try { - ((mfem::DiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15375,311 +16147,471 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::FiniteElement *arg1 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; - mfem::IntegrationRule *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_DiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; + --argc; + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeElementFlux'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" + " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - delete arg1; + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *DiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::MassIntegrator *result = 0 ; +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(); + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); + } + } + } + } + } + } + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeFluxEnergy'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" + " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::MassIntegrator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::MassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MassIntegrator", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MassIntegrator__SWIG_3(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MassIntegrator__SWIG_2(self, argc, argv); + return _wrap_DiffusionIntegrator_AssemblePA__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MassIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MassIntegrator::MassIntegrator(mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator()\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &)\n"); + " mfem::DiffusionIntegrator::AssemblePA()\n" + " mfem::DiffusionIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleDiagonalPA(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15692,66 +16624,44 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + ((mfem::DiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15764,83 +16674,83 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; + mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssemblePA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); { try { - (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + bool val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::MassIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); { try { - ((mfem::MassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15853,475 +16763,292 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::FiniteElement *arg1 = 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::IntegrationRule *) &mfem::MassIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassIntegrator" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_SetupPA__SWIG_1(self, argc, argv); + } + } } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - { - try { - delete arg1; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DiffusionIntegrator_SetupPA__SWIG_0(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_SetupPA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" + " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); + return 0; } -SWIGINTERN PyObject *MassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MassIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::BoundaryMassIntegrator *result = 0 ; + mfem::MassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); { try { - result = (mfem::BoundaryMassIntegrator *)new mfem::BoundaryMassIntegrator(*arg1); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + mfem::MassIntegrator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + mfem::MassIntegrator *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + mfem::MassIntegrator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BoundaryMassIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MassIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 0) { + return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); + } + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } + return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); } } - if (argc == 5) { + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } + return _wrap_new_MassIntegrator__SWIG_3(self, argc, argv); } } - if (argc == 6) { + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } + return _wrap_new_MassIntegrator__SWIG_2(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoundaryMassIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MassIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::BoundaryMassIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::MassIntegrator::MassIntegrator(mfem::IntegrationRule const *)\n" + " mfem::MassIntegrator::MassIntegrator()\n" + " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" + " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassIntegrator" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); { try { delete arg1; @@ -16337,135 +17064,74 @@ SWIGINTERN PyObject *_wrap_delete_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *BoundaryMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BoundaryMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::ConvectionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::ConvectionIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvectionIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvectionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -16474,41 +17140,51 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16521,23 +17197,32 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_delete_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - delete arg1; + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16550,207 +17235,214 @@ SWIGINTERN PyObject *_wrap_delete_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *ConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MassIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MassIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MassIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MassIntegrator::AssemblePA()\n" + " mfem::MassIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; } -SWIGINTERN PyObject *ConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::GroupConvectionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); + (arg1)->AssembleDiagonalPA(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::GroupConvectionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::MassIntegrator const *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1); + ((mfem::MassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GroupConvectionIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GroupConvectionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; + mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GroupConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::IntegrationRule *) &mfem::MassIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_GroupConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MassIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); { try { - delete arg1; + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16763,541 +17455,624 @@ SWIGINTERN PyObject *_wrap_delete_GroupConvectionIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *GroupConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *GroupConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *result = 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MassIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MassIntegrator_SetupPA__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MassIntegrator_SetupPA__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MassIntegrator_SetupPA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" + " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *MassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; + PyObject *swig_obj[1] ; + mfem::BoundaryMassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); + result = (mfem::BoundaryMassIntegrator *)new mfem::BoundaryMassIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - int arg2 ; + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorMassIntegrator", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BoundaryMassIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_VectorMassIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_5(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_7(self, argc, argv); - } - } - if (argc == 2) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } } } } - if (argc == 2) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } } } - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_6(self, argc, argv); - } } } - if (argc == 2) { + if (argc == 6) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorMassIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoundaryMassIntegrator_AssembleFaceMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator()\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &)\n"); + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::BoundaryMassIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_GetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int result; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_GetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); { try { - result = (int)((mfem::VectorMassIntegrator const *)arg1)->GetVDim(); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BoundaryMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BoundaryMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; - int arg2 ; + mfem::VectorCoefficient *arg1 = 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + double val2 ; + int ecode2 = 0 ; + mfem::ConvectionIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_SetVDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_SetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - (arg1)->SetVDim(arg2); + result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::ConvectionIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvectionIntegrator", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ConvectionIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ConvectionIntegrator__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvectionIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &,double)\n" + " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -17306,51 +18081,41 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17363,23 +18128,32 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_delete_VectorMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - delete arg1; + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17392,245 +18166,244 @@ SWIGINTERN PyObject *_wrap_delete_VectorMassIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *VectorMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ConvectionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ConvectionIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConvectionIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ConvectionIntegrator::AssemblePA()\n" + " mfem::ConvectionIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; } -SWIGINTERN PyObject *VectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *result = 0 ; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::ConvectionIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(); + ((mfem::ConvectionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_GetRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEDivergenceIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); { try { - result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(*arg1); + result = (mfem::IntegrationRule *) &mfem::ConvectionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_GetRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + mfem::IntegrationRule *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEDivergenceIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_VectorFEDivergenceIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEDivergenceIntegrator__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEDivergenceIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator()\n" - " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::IntegrationRule *) &mfem::ConvectionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_GetRule(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_GetRule", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ConvectionIntegrator_GetRule__SWIG_0(self, argc, argv); + } + } } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ConvectionIntegrator_GetRule__SWIG_1(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConvectionIntegrator_GetRule'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ConvectionIntegrator::GetRule(mfem::FiniteElement const &,mfem::ElementTransformation &)\n" + " mfem::ConvectionIntegrator::GetRule(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::ElementTransformation &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_delete_VectorFEDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); { try { delete arg1; @@ -17646,101 +18419,132 @@ SWIGINTERN PyObject *_wrap_delete_VectorFEDivergenceIntegrator(PyObject *SWIGUNU } -SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::GroupConvectionIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(); + result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; + mfem::GroupConvectionIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(*arg1); + result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEWeakDivergenceIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GroupConvectionIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(self, argc, argv); - } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_GroupConvectionIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_GroupConvectionIntegrator__SWIG_0(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEWeakDivergenceIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GroupConvectionIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator()\n" - " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator(mfem::Coefficient &)\n"); + " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &,double)\n" + " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; + mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -17754,34 +18558,34 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); + if (!SWIG_Python_UnpackTuple(args, "GroupConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -17799,92 +18603,20 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri } -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_VectorFEWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_GroupConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; + mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); { try { delete arg1; @@ -17900,289 +18632,231 @@ SWIGINTERN PyObject *_wrap_delete_VectorFEWeakDivergenceIntegrator(PyObject *SWI } -SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GroupConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GroupConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *result = 0 ; + mfem::VectorMassIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFECurlIntegrator *result = 0 ; + mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(*arg1); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorMassIntegrator *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFECurlIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_VectorFECurlIntegrator__SWIG_0(self, argc, argv); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFECurlIntegrator__SWIG_1(self, argc, argv); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFECurlIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator()\n" - " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator(mfem::Coefficient &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_VectorFECurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - delete arg1; + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *VectorFECurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorFECurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::DerivativeIntegrator *result = 0 ; + mfem::VectorMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DerivativeIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -18191,317 +18865,243 @@ SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(sel } { try { - result = (mfem::DerivativeIntegrator *)new mfem::DerivativeIntegrator(*arg1,arg2); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorMassIntegrator", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorMassIntegrator__SWIG_0(self, argc, argv); } - arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_5(self, argc, argv); + } } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_7(self, argc, argv); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); + } + } } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); + } + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_6(self, argc, argv); + } + } } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorMassIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator()\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,int)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &,int)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_delete_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_GetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + int result; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_GetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *DerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); { try { - result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(); + result = (int)((mfem::VectorMassIntegrator const *)arg1)->GetVDim(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::CurlCurlIntegrator *result = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_SetVDim", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_SetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); { - try { - result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::CurlCurlIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); + (arg1)->SetVDim(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_CurlCurlIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_CurlCurlIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_CurlCurlIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_CurlCurlIntegrator__SWIG_2(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CurlCurlIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CurlCurlIntegrator::CurlCurlIntegrator()\n" - " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::Coefficient &)\n" - " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::MatrixCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -18515,34 +19115,34 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -18560,15 +19160,13 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - int arg7 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -18579,65 +19177,49 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject *swig_obj[7] ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeElementFlux", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18650,219 +19232,178 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorMassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMassIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorMassIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorMassIntegrator::AssemblePA()\n" + " mfem::VectorMassIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->AssembleDiagonalPA(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; + PyObject *swig_obj[3] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + ((mfem::VectorMassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_CurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); { try { delete arg1; @@ -18878,78 +19419,78 @@ SWIGINTERN PyObject *_wrap_delete_CurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *CurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *CurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *result = 0 ; + mfem::VectorFEDivergenceIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(); + result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorCurlCurlIntegrator *result = 0 ; + mfem::VectorFEDivergenceIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(*arg1); + result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorCurlCurlIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEDivergenceIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_VectorCurlCurlIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_VectorFEDivergenceIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -18957,22 +19498,22 @@ SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorCurlCurlIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_VectorFEDivergenceIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorCurlCurlIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEDivergenceIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator()\n" - " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator(mfem::Coefficient &)\n"); + " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator()\n" + " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; + mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -18986,34 +19527,34 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -19031,12 +19572,13 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; + mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -19045,68 +19587,77 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; - double result; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (double)(arg1)->GetElementEnergy((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_VectorCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorFEDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; + mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); { try { delete arg1; @@ -19122,233 +19673,332 @@ SWIGINTERN PyObject *_wrap_delete_VectorCurlCurlIntegrator(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *VectorCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(); + result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); + result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEWeakDivergenceIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEWeakDivergenceIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator()\n" + " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator(mfem::Coefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = (mfem::VectorCoefficient *) 0 ; + mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient *""'"); + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_VectorFEWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::VectorFECurlIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); + result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::VectorFECurlIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); + result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEMassIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFECurlIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_VectorFEMassIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_1(self, argc, argv); - } + return _wrap_new_VectorFECurlIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -19356,63 +20006,22 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_3(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_4(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_5(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_6(self, argc, argv); + return _wrap_new_VectorFECurlIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEMassIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFECurlIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator()\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient *)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient &)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient *)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient &)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient *)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator()\n" + " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -19426,34 +20035,34 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -19471,9 +20080,9 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; mfem::ElementTransformation *arg4 = 0 ; @@ -19490,42 +20099,42 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec int res5 = 0 ; PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { @@ -19543,20 +20152,20 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec } -SWIGINTERN PyObject *_wrap_delete_VectorFEMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorFECurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); { try { delete arg1; @@ -19572,139 +20181,120 @@ SWIGINTERN PyObject *_wrap_delete_VectorFEMassIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *VectorFEMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFECurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorFEMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFECurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorDivergenceIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg1 = 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorDivergenceIntegrator *result = 0 ; + PyObject *swig_obj[2] ; + mfem::DerivativeIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "new_DerivativeIntegrator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(arg1); + result = (mfem::DerivativeIntegrator *)new mfem::DerivativeIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorDivergenceIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(*arg1); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDivergenceIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_VectorDivergenceIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorDivergenceIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorDivergenceIntegrator__SWIG_2(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDivergenceIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator()\n" - " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient *)\n" - " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; mfem::ElementTransformation *arg4 = 0 ; @@ -19721,42 +20311,42 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO int res5 = 0 ; PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { @@ -19774,20 +20364,20 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO } -SWIGINTERN PyObject *_wrap_delete_VectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); { try { delete arg1; @@ -19803,78 +20393,109 @@ SWIGINTERN PyObject *_wrap_delete_VectorDivergenceIntegrator(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *VectorDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::DivDivIntegrator *result = 0 ; + mfem::CurlCurlIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(); + result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DivDivIntegrator *result = 0 ; + mfem::CurlCurlIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(*arg1); + result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MatrixCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::CurlCurlIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + { + try { + result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DivDivIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_CurlCurlIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_DivDivIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_CurlCurlIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -19882,22 +20503,32 @@ SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_DivDivIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_CurlCurlIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CurlCurlIntegrator__SWIG_2(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DivDivIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CurlCurlIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DivDivIntegrator::DivDivIntegrator()\n" - " mfem::DivDivIntegrator::DivDivIntegrator(mfem::Coefficient &)\n"); + " mfem::CurlCurlIntegrator::CurlCurlIntegrator()\n" + " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::Coefficient &)\n" + " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::MatrixCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -19911,34 +20542,34 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "DivDivIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -19956,133 +20587,15 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_delete_DivDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivDivIntegrator" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *DivDivIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DivDivIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorDiffusionIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - try { - result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDiffusionIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_VectorDiffusionIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorDiffusionIntegrator__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDiffusionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator()\n" - " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -20091,41 +20604,68 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject *swig_obj[7] ; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeElementFlux", 7, 7, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20138,13 +20678,13 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -20155,292 +20695,214 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + double result; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_VectorDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::ElasticityIntegrator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - try { - result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::ElasticityIntegrator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ElasticityIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,arg2,arg3); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ElasticityIntegrator", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ElasticityIntegrator__SWIG_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); + } + } } } } - if (argc == 3) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ElasticityIntegrator__SWIG_1(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); + } + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ElasticityIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_ComputeFluxEnergy'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &)\n" - " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,double,double)\n"); + " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" + " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20453,83 +20915,75 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - int arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CurlCurlIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::CurlCurlIntegrator::AssemblePA()\n" + " mfem::CurlCurlIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + ((mfem::CurlCurlIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20542,187 +20996,172 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + (arg1)->AssembleDiagonalPA(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorCurlCurlIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorCurlCurlIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorCurlCurlIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 6) { + if (argc == 0) { + return _wrap_new_VectorCurlCurlIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } + return _wrap_new_VectorCurlCurlIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeElementFlux'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorCurlCurlIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,int)\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); + " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator()\n" + " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -20731,63 +21170,56 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + PyObject *swig_obj[4] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; @@ -20799,41 +21231,42 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject *swig_obj[4] ; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (double)(arg1)->GetElementEnergy((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20846,89 +21279,20 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); { try { delete arg1; @@ -20944,532 +21308,343 @@ SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *ElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DGTraceIntegrator *result = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,arg2,arg3); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - double val4 ; - int ecode4 = 0 ; - mfem::DGTraceIntegrator *result = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGTraceIntegrator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,*arg2,arg3,arg4); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGTraceIntegrator", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DGTraceIntegrator__SWIG_0(self, argc, argv); - } - } - } + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DGTraceIntegrator__SWIG_1(self, argc, argv); - } - } - } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGTraceIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::VectorCoefficient &,double,double)\n" - " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::Coefficient &,mfem::VectorCoefficient &,double,double)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorCoefficient *arg1 = (mfem::VectorCoefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + { + try { + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MatrixCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEMassIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 0) { + return _wrap_new_VectorFEMassIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } + return _wrap_new_VectorFEMassIntegrator__SWIG_1(self, argc, argv); } } - if (argc == 5) { + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } + return _wrap_new_VectorFEMassIntegrator__SWIG_2(self, argc, argv); } } - if (argc == 6) { + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } - } + return _wrap_new_VectorFEMassIntegrator__SWIG_3(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEMassIntegrator__SWIG_4(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEMassIntegrator__SWIG_5(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEMassIntegrator__SWIG_6(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGTraceIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEMassIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::DGTraceIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator()\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient *)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient &)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient *)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient &)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient *)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_DGTraceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -21482,283 +21657,224 @@ SWIGINTERN PyObject *_wrap_delete_DGTraceIntegrator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *DGTraceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DGTraceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - double arg1 ; - double arg2 ; - double val1 ; - int ecode1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::DGDiffusionIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DGDiffusionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DGDiffusionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssemblePA(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGDiffusionIntegrator", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DGDiffusionIntegrator__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DGDiffusionIntegrator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DGDiffusionIntegrator__SWIG_2(self, argc, argv); - } + return _wrap_VectorFEMassIntegrator_AssemblePA__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGDiffusionIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorFEMassIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(double const,double const)\n" - " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::Coefficient &,double const,double const)\n" - " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::MatrixCoefficient &,double const,double const)\n"); + " mfem::VectorFEMassIntegrator::AssemblePA()\n" + " mfem::VectorFEMassIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::VectorFEMassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleDiagonalPA(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -21771,94 +21887,171 @@ SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(Py } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_VectorFEMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorFEMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorFEMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorDivergenceIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorDivergenceIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorDivergenceIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDivergenceIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorDivergenceIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorDivergenceIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorDivergenceIntegrator__SWIG_2(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDivergenceIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator()\n" + " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient *)\n" + " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -21870,48 +22063,49 @@ SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -21924,127 +22118,128 @@ SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(PyOb } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssemblePA(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DGDiffusionIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { + if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } + return _wrap_VectorDivergenceIntegrator_AssemblePA__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGDiffusionIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorDivergenceIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::DGDiffusionIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::VectorDivergenceIntegrator::AssemblePA()\n" + " mfem::VectorDivergenceIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_DGDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - delete arg1; + ((mfem::VectorDivergenceIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22057,178 +22252,237 @@ SWIGINTERN PyObject *_wrap_delete_DGDiffusionIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *DGDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DGDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - double arg1 ; - double arg2 ; - double val1 ; - int ecode1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::DGElasticityIntegrator *result = 0 ; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(arg1,arg2); + ((mfem::VectorDivergenceIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - double val4 ; - int ecode4 = 0 ; - mfem::DGElasticityIntegrator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGElasticityIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGElasticityIntegrator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(*arg1,*arg2,arg3,arg4); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + { + try { + result = (mfem::IntegrationRule *) &mfem::VectorDivergenceIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::DivDivIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::DivDivIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGElasticityIntegrator", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DivDivIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DGElasticityIntegrator__SWIG_0(self, argc, argv); - } - } + if (argc == 0) { + return _wrap_new_DivDivIntegrator__SWIG_0(self, argc, argv); } - if (argc == 4) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DGElasticityIntegrator__SWIG_1(self, argc, argv); - } - } - } + return _wrap_new_DivDivIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGElasticityIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DivDivIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DGElasticityIntegrator::DGElasticityIntegrator(double,double)\n" - " mfem::DGElasticityIntegrator::DGElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &,double,double)\n"); + " mfem::DivDivIntegrator::DivDivIntegrator()\n" + " mfem::DivDivIntegrator::DivDivIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; + mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -22237,50 +22491,41 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DivDivIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22293,76 +22538,176 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(P } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_DivDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivDivIntegrator" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *DivDivIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DivDivIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorDiffusionIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorDiffusionIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDiffusionIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorDiffusionIntegrator__SWIG_0(self, argc, argv); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorDiffusionIntegrator__SWIG_1(self, argc, argv); + } } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDiffusionIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator()\n" + " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator(mfem::Coefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22375,13 +22720,13 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(P } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -22392,48 +22737,49 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22446,229 +22792,152 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(PyO } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssemblePA(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DGElasticityIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } + return _wrap_VectorDiffusionIntegrator_AssemblePA__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGElasticityIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorDiffusionIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::DGElasticityIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::VectorDiffusionIntegrator::AssemblePA()\n" + " mfem::VectorDiffusionIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_DGElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *DGElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DGElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_TraceJumpIntegrator", 0, 0, 0)) SWIG_fail; + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::TraceJumpIntegrator *)new mfem::TraceJumpIntegrator(); + (arg1)->AssembleDiagonalPA(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + ((mfem::VectorDiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22681,76 +22950,23 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyOb } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_VectorDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22763,213 +22979,208 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyOb } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *VectorDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::Coefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + mfem::ElasticityIntegrator *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + { + try { + result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::ElasticityIntegrator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ElasticityIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "TraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ElasticityIntegrator", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } + return _wrap_new_ElasticityIntegrator__SWIG_0(self, argc, argv); } } } - if (argc == 6) { + if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + { + int res = SWIG_AsVal_double(argv[1], NULL); _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + { + int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } + } + if (_v) { + return _wrap_new_ElasticityIntegrator__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TraceJumpIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ElasticityIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::TraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &)\n" + " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,double,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TraceJumpIntegrator" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22982,116 +23193,15 @@ SWIGINTERN PyObject *_wrap_delete_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *TraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_NormalTraceJumpIntegrator", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::NormalTraceJumpIntegrator *)new mfem::NormalTraceJumpIntegrator(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -23104,56 +23214,63 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_ int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23166,14 +23283,14 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_ } -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -23188,54 +23305,54 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1( int res6 = 0 ; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23248,96 +23365,77 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1( } -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "NormalTraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 6) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); + } } } } } } } - if (argc == 6) { + if (argc == 7) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); + } } } } @@ -23347,89 +23445,227 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix(PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NormalTraceJumpIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeElementFlux'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::NormalTraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" + " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalTraceJumpIntegrator" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - delete arg1; + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *NormalTraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *NormalTraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DiscreteInterpolator *result = 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if (!SWIG_Python_UnpackTuple(args, "new_DiscreteInterpolator", 0, 0, 0)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::DiscreteInterpolator *)new mfem::DiscreteInterpolator(); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeFluxEnergy'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" + " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiscreteInterpolator *arg1 = (mfem::DiscreteInterpolator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteInterpolator" "', argument " "1"" of type '" "mfem::DiscreteInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DiscreteInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); { try { delete arg1; @@ -23445,155 +23681,193 @@ SWIGINTERN PyObject *_wrap_delete_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *DiscreteInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *DiscreteInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::DGTraceIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GradientInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GradientInterpolator *result = 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + double arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + double val4 ; + int ecode4 = 0 ; + mfem::DGTraceIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_GradientInterpolator", 0, 0, 0)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGTraceIntegrator" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); { try { - result = (mfem::GradientInterpolator *)new mfem::GradientInterpolator(); + result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; +SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GradientInterpolator" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGTraceIntegrator", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_DGTraceIntegrator__SWIG_0(self, argc, argv); + } + } + } } - arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); - { - try { - delete arg1; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_DGTraceIntegrator__SWIG_1(self, argc, argv); + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; -} - - -SWIGINTERN PyObject *GradientInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GradientInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGTraceIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::VectorCoefficient &,double,double)\n" + " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::Coefficient &,mfem::VectorCoefficient &,double,double)\n"); + return 0; } -SWIGINTERN PyObject *GradientInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -23605,49 +23879,48 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "IdentityInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23660,73 +23933,14 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_new_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::IdentityInterpolator *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_IdentityInterpolator", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::IdentityInterpolator *)new mfem::IdentityInterpolator(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentityInterpolator" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *IdentityInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *IdentityInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -23737,98 +23951,58 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CurlInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CurlInterpolator *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_CurlInterpolator", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::CurlInterpolator *)new mfem::CurlInterpolator(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlInterpolator" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } - arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - delete arg1; + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23841,23 +24015,12 @@ SWIGINTERN PyObject *_wrap_delete_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *CurlInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *CurlInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -23869,49 +24032,48 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "DivergenceInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23924,43 +24086,137 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec } -SWIGINTERN PyObject *_wrap_new_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::DivergenceInterpolator *result = 0 ; +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "new_DivergenceInterpolator", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::DivergenceInterpolator *)new mfem::DivergenceInterpolator(); + if (!(argc = SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGTraceIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::DGTraceIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivergenceInterpolator" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - delete arg1; + (arg1)->AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23973,77 +24229,133 @@ SWIGINTERN PyObject *_wrap_delete_DivergenceInterpolator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *DivergenceInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *DivergenceInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "NormalInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::DGTraceIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + ((mfem::DGTraceIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24056,40 +24368,67 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S } -SWIGINTERN PyObject *_wrap_new_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NormalInterpolator *result = 0 ; + mfem::Geometry::Type arg1 ; + int arg2 ; + mfem::FaceElementTransformations *arg3 = 0 ; + int val1 ; + int ecode1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_NormalInterpolator", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DGTraceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::Geometry::Type""'"); + } + arg1 = static_cast< mfem::Geometry::Type >(val1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg3 = reinterpret_cast< mfem::FaceElementTransformations * >(argp3); { try { - result = (mfem::NormalInterpolator *)new mfem::NormalInterpolator(); + result = (mfem::IntegrationRule *) &mfem::DGTraceIntegrator::GetRule(arg1,arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_DGTraceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalInterpolator" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); { try { delete arg1; @@ -24105,56 +24444,230 @@ SWIGINTERN PyObject *_wrap_delete_NormalInterpolator(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *NormalInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGTraceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalInterpolator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *NormalInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGTraceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::DGDiffusionIntegrator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; + void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::ScalarProductInterpolator *result = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::DGDiffusionIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::ScalarProductInterpolator *)new mfem::ScalarProductInterpolator(*arg1); + result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::DGDiffusionIntegrator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGDiffusionIntegrator", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_DGDiffusionIntegrator__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_DGDiffusionIntegrator__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_DGDiffusionIntegrator__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGDiffusionIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(double const,double const)\n" + " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::Coefficient &,double const,double const)\n" + " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::MatrixCoefficient &,double const,double const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24166,49 +24679,48 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "ScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24221,85 +24733,94 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb } -SWIGINTERN PyObject *_wrap_delete_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::ScalarVectorProductInterpolator *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::ScalarVectorProductInterpolator *)new mfem::ScalarVectorProductInterpolator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24311,49 +24832,48 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "ScalarVectorProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24366,20 +24886,124 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix } -SWIGINTERN PyObject *_wrap_delete_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DGDiffusionIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGDiffusionIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::DGDiffusionIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_DGDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); { try { delete arg1; @@ -24395,201 +25019,177 @@ SWIGINTERN PyObject *_wrap_delete_ScalarVectorProductInterpolator(PyObject *SWIG } -SWIGINTERN PyObject *ScalarVectorProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ScalarVectorProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::VectorScalarProductInterpolator *result = 0 ; + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::DGElasticityIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mfem::VectorScalarProductInterpolator *)new mfem::VectorScalarProductInterpolator(*arg1); + result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::Coefficient *arg2 = 0 ; + double arg3 ; + double arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + double val3 ; + int ecode3 = 0 ; + double val4 ; + int ecode4 = 0 ; + mfem::DGElasticityIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGElasticityIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGElasticityIntegrator" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(*arg1,*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; +SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); - { - try { - delete arg1; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGElasticityIntegrator", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_DGElasticityIntegrator__SWIG_0(self, argc, argv); + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::VectorCrossProductInterpolator *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - try { - result = (mfem::VectorCrossProductInterpolator *)new mfem::VectorCrossProductInterpolator(*arg1); + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_DGElasticityIntegrator__SWIG_1(self, argc, argv); + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGElasticityIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DGElasticityIntegrator::DGElasticityIntegrator(double,double)\n" + " mfem::DGElasticityIntegrator::DGElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &,double,double)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24601,49 +25201,48 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorCrossProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24656,85 +25255,94 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 } -SWIGINTERN PyObject *_wrap_delete_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorCrossProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorCrossProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::VectorInnerProductInterpolator *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::VectorInnerProductInterpolator *)new mfem::VectorInnerProductInterpolator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24746,49 +25354,48 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorInnerProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24801,20 +25408,124 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 } -SWIGINTERN PyObject *_wrap_delete_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DGElasticityIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGElasticityIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::DGElasticityIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_DGElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); { try { delete arg1; @@ -24830,74 +25541,3034 @@ SWIGINTERN PyObject *_wrap_delete_VectorInnerProductInterpolator(PyObject *SWIGU } -SWIGINTERN PyObject *VectorInnerProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorInnerProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -static PyMethodDef SwigMethods[] = { +SWIGINTERN PyObject *_wrap_new_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TraceJumpIntegrator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_TraceJumpIntegrator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::TraceJumpIntegrator *)new mfem::TraceJumpIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "TraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TraceJumpIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::TraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TraceJumpIntegrator" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_NormalTraceJumpIntegrator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::NormalTraceJumpIntegrator *)new mfem::NormalTraceJumpIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "NormalTraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NormalTraceJumpIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::NormalTraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalTraceJumpIntegrator" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *NormalTraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NormalTraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DiscreteInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_DiscreteInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::DiscreteInterpolator *)new mfem::DiscreteInterpolator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DiscreteInterpolator *arg1 = (mfem::DiscreteInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteInterpolator" "', argument " "1"" of type '" "mfem::DiscreteInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::DiscreteInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *DiscreteInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DiscreteInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "GradientInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GradientInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_GradientInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::GradientInterpolator *)new mfem::GradientInterpolator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GradientInterpolator" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GradientInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GradientInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GradientInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "IdentityInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_IdentityInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::IdentityInterpolator *)new mfem::IdentityInterpolator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentityInterpolator" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IdentityInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *IdentityInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "CurlInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_CurlInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::CurlInterpolator *)new mfem::CurlInterpolator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlInterpolator" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CurlInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CurlInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "DivergenceInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DivergenceInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_DivergenceInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::DivergenceInterpolator *)new mfem::DivergenceInterpolator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivergenceInterpolator" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *DivergenceInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DivergenceInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "NormalInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_NormalInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::NormalInterpolator *)new mfem::NormalInterpolator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalInterpolator" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *NormalInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NormalInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::ScalarProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::ScalarProductInterpolator *)new mfem::ScalarProductInterpolator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "ScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::ScalarVectorProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::ScalarVectorProductInterpolator *)new mfem::ScalarVectorProductInterpolator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "ScalarVectorProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScalarVectorProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ScalarVectorProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::VectorScalarProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + try { + result = (mfem::VectorScalarProductInterpolator *)new mfem::VectorScalarProductInterpolator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::VectorCrossProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + try { + result = (mfem::VectorCrossProductInterpolator *)new mfem::VectorCrossProductInterpolator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorCrossProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorCrossProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorCrossProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::VectorInnerProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + try { + result = (mfem::VectorInnerProductInterpolator *)new mfem::VectorInnerProductInterpolator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorInnerProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorInnerProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorInnerProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, + { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(BilinearFormIntegrator self)\n" + "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" + "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "BilinearFormIntegrator_AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, + { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, + { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, + { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, + { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "TransposeIntegrator_AssemblePA", _wrap_TransposeIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "TransposeIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "TransposeIntegrator_AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "TransposeIntegrator_AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "TransposeIntegrator_AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "TransposeIntegrator_AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, + { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, + { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, + { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, + { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, + { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, + { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, + { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, + { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, + { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, + { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, + { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, + { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, + { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, + { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, + { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, + { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, + { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" + "MixedScalarMassIntegrator()\n" + "new_MixedScalarMassIntegrator(Coefficient q) -> MixedScalarMassIntegrator\n" + ""}, + { "delete_MixedScalarMassIntegrator", _wrap_delete_MixedScalarMassIntegrator, METH_O, "delete_MixedScalarMassIntegrator(MixedScalarMassIntegrator self)"}, + { "MixedScalarMassIntegrator_swigregister", MixedScalarMassIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarMassIntegrator_swiginit", MixedScalarMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorProductIntegrator", _wrap_new_MixedVectorProductIntegrator, METH_O, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, + { "delete_MixedVectorProductIntegrator", _wrap_delete_MixedVectorProductIntegrator, METH_O, "delete_MixedVectorProductIntegrator(MixedVectorProductIntegrator self)"}, + { "MixedVectorProductIntegrator_swigregister", MixedVectorProductIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorProductIntegrator_swiginit", MixedVectorProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarDerivativeIntegrator", _wrap_new_MixedScalarDerivativeIntegrator, METH_VARARGS, "\n" + "MixedScalarDerivativeIntegrator()\n" + "new_MixedScalarDerivativeIntegrator(Coefficient q) -> MixedScalarDerivativeIntegrator\n" + ""}, + { "delete_MixedScalarDerivativeIntegrator", _wrap_delete_MixedScalarDerivativeIntegrator, METH_O, "delete_MixedScalarDerivativeIntegrator(MixedScalarDerivativeIntegrator self)"}, + { "MixedScalarDerivativeIntegrator_swigregister", MixedScalarDerivativeIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarDerivativeIntegrator_swiginit", MixedScalarDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakDerivativeIntegrator", _wrap_new_MixedScalarWeakDerivativeIntegrator, METH_VARARGS, "\n" + "MixedScalarWeakDerivativeIntegrator()\n" + "new_MixedScalarWeakDerivativeIntegrator(Coefficient q) -> MixedScalarWeakDerivativeIntegrator\n" + ""}, + { "delete_MixedScalarWeakDerivativeIntegrator", _wrap_delete_MixedScalarWeakDerivativeIntegrator, METH_O, "delete_MixedScalarWeakDerivativeIntegrator(MixedScalarWeakDerivativeIntegrator self)"}, + { "MixedScalarWeakDerivativeIntegrator_swigregister", MixedScalarWeakDerivativeIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakDerivativeIntegrator_swiginit", MixedScalarWeakDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarDivergenceIntegrator", _wrap_new_MixedScalarDivergenceIntegrator, METH_VARARGS, "\n" + "MixedScalarDivergenceIntegrator()\n" + "new_MixedScalarDivergenceIntegrator(Coefficient q) -> MixedScalarDivergenceIntegrator\n" + ""}, + { "delete_MixedScalarDivergenceIntegrator", _wrap_delete_MixedScalarDivergenceIntegrator, METH_O, "delete_MixedScalarDivergenceIntegrator(MixedScalarDivergenceIntegrator self)"}, + { "MixedScalarDivergenceIntegrator_swigregister", MixedScalarDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarDivergenceIntegrator_swiginit", MixedScalarDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorDivergenceIntegrator", _wrap_new_MixedVectorDivergenceIntegrator, METH_O, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, + { "delete_MixedVectorDivergenceIntegrator", _wrap_delete_MixedVectorDivergenceIntegrator, METH_O, "delete_MixedVectorDivergenceIntegrator(MixedVectorDivergenceIntegrator self)"}, + { "MixedVectorDivergenceIntegrator_swigregister", MixedVectorDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorDivergenceIntegrator_swiginit", MixedVectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakGradientIntegrator", _wrap_new_MixedScalarWeakGradientIntegrator, METH_VARARGS, "\n" + "MixedScalarWeakGradientIntegrator()\n" + "new_MixedScalarWeakGradientIntegrator(Coefficient q) -> MixedScalarWeakGradientIntegrator\n" + ""}, + { "delete_MixedScalarWeakGradientIntegrator", _wrap_delete_MixedScalarWeakGradientIntegrator, METH_O, "delete_MixedScalarWeakGradientIntegrator(MixedScalarWeakGradientIntegrator self)"}, + { "MixedScalarWeakGradientIntegrator_swigregister", MixedScalarWeakGradientIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakGradientIntegrator_swiginit", MixedScalarWeakGradientIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCurlIntegrator", _wrap_new_MixedScalarCurlIntegrator, METH_VARARGS, "\n" + "MixedScalarCurlIntegrator()\n" + "new_MixedScalarCurlIntegrator(Coefficient q) -> MixedScalarCurlIntegrator\n" + ""}, + { "delete_MixedScalarCurlIntegrator", _wrap_delete_MixedScalarCurlIntegrator, METH_O, "delete_MixedScalarCurlIntegrator(MixedScalarCurlIntegrator self)"}, + { "MixedScalarCurlIntegrator_swigregister", MixedScalarCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCurlIntegrator_swiginit", MixedScalarCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakCurlIntegrator", _wrap_new_MixedScalarWeakCurlIntegrator, METH_VARARGS, "\n" + "MixedScalarWeakCurlIntegrator()\n" + "new_MixedScalarWeakCurlIntegrator(Coefficient q) -> MixedScalarWeakCurlIntegrator\n" + ""}, + { "delete_MixedScalarWeakCurlIntegrator", _wrap_delete_MixedScalarWeakCurlIntegrator, METH_O, "delete_MixedScalarWeakCurlIntegrator(MixedScalarWeakCurlIntegrator self)"}, + { "MixedScalarWeakCurlIntegrator_swigregister", MixedScalarWeakCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakCurlIntegrator_swiginit", MixedScalarWeakCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorMassIntegrator", _wrap_new_MixedVectorMassIntegrator, METH_VARARGS, "\n" + "MixedVectorMassIntegrator()\n" + "MixedVectorMassIntegrator(Coefficient q)\n" + "MixedVectorMassIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorMassIntegrator(MatrixCoefficient mq) -> MixedVectorMassIntegrator\n" + ""}, + { "delete_MixedVectorMassIntegrator", _wrap_delete_MixedVectorMassIntegrator, METH_O, "delete_MixedVectorMassIntegrator(MixedVectorMassIntegrator self)"}, + { "MixedVectorMassIntegrator_swigregister", MixedVectorMassIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorMassIntegrator_swiginit", MixedVectorMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossProductIntegrator", _wrap_new_MixedCrossProductIntegrator, METH_O, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, + { "delete_MixedCrossProductIntegrator", _wrap_delete_MixedCrossProductIntegrator, METH_O, "delete_MixedCrossProductIntegrator(MixedCrossProductIntegrator self)"}, + { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDotProductIntegrator_FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, + { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, + { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, + { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, + { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, + { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, + { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, + { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, + { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedGradGradIntegrator", _wrap_new_MixedGradGradIntegrator, METH_VARARGS, "\n" + "MixedGradGradIntegrator()\n" + "MixedGradGradIntegrator(Coefficient q)\n" + "MixedGradGradIntegrator(VectorCoefficient dq)\n" + "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" + ""}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradGradIntegrator_FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, + { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, + { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, + { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCurlCurlIntegrator", _wrap_new_MixedCurlCurlIntegrator, METH_VARARGS, "\n" + "MixedCurlCurlIntegrator()\n" + "MixedCurlCurlIntegrator(Coefficient q)\n" + "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" + "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" + ""}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, + { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, + { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, + { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, + { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, + { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, + { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, + { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, + { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, + { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, + { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, + { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, + { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, + { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, + { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, + { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, + { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, + { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradDivIntegrator_FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, + { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, + { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, + { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDivGradIntegrator_FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, + { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, + { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, + { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, + { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorGradientIntegrator", _wrap_new_MixedVectorGradientIntegrator, METH_VARARGS, "\n" + "MixedVectorGradientIntegrator()\n" + "MixedVectorGradientIntegrator(Coefficient q)\n" + "MixedVectorGradientIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorGradientIntegrator(MatrixCoefficient mq) -> MixedVectorGradientIntegrator\n" + ""}, + { "delete_MixedVectorGradientIntegrator", _wrap_delete_MixedVectorGradientIntegrator, METH_O, "delete_MixedVectorGradientIntegrator(MixedVectorGradientIntegrator self)"}, + { "MixedVectorGradientIntegrator_swigregister", MixedVectorGradientIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorGradientIntegrator_swiginit", MixedVectorGradientIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorCurlIntegrator", _wrap_new_MixedVectorCurlIntegrator, METH_VARARGS, "\n" + "MixedVectorCurlIntegrator()\n" + "MixedVectorCurlIntegrator(Coefficient q)\n" + "MixedVectorCurlIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorCurlIntegrator(MatrixCoefficient mq) -> MixedVectorCurlIntegrator\n" + ""}, + { "delete_MixedVectorCurlIntegrator", _wrap_delete_MixedVectorCurlIntegrator, METH_O, "delete_MixedVectorCurlIntegrator(MixedVectorCurlIntegrator self)"}, + { "MixedVectorCurlIntegrator_swigregister", MixedVectorCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorCurlIntegrator_swiginit", MixedVectorCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorWeakCurlIntegrator", _wrap_new_MixedVectorWeakCurlIntegrator, METH_VARARGS, "\n" + "MixedVectorWeakCurlIntegrator()\n" + "MixedVectorWeakCurlIntegrator(Coefficient q)\n" + "MixedVectorWeakCurlIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorWeakCurlIntegrator(MatrixCoefficient mq) -> MixedVectorWeakCurlIntegrator\n" + ""}, + { "delete_MixedVectorWeakCurlIntegrator", _wrap_delete_MixedVectorWeakCurlIntegrator, METH_O, "delete_MixedVectorWeakCurlIntegrator(MixedVectorWeakCurlIntegrator self)"}, + { "MixedVectorWeakCurlIntegrator_swigregister", MixedVectorWeakCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorWeakCurlIntegrator_swiginit", MixedVectorWeakCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorWeakDivergenceIntegrator", _wrap_new_MixedVectorWeakDivergenceIntegrator, METH_VARARGS, "\n" + "MixedVectorWeakDivergenceIntegrator()\n" + "MixedVectorWeakDivergenceIntegrator(Coefficient q)\n" + "MixedVectorWeakDivergenceIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorWeakDivergenceIntegrator(MatrixCoefficient mq) -> MixedVectorWeakDivergenceIntegrator\n" + ""}, + { "delete_MixedVectorWeakDivergenceIntegrator", _wrap_delete_MixedVectorWeakDivergenceIntegrator, METH_O, "delete_MixedVectorWeakDivergenceIntegrator(MixedVectorWeakDivergenceIntegrator self)"}, + { "MixedVectorWeakDivergenceIntegrator_swigregister", MixedVectorWeakDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorWeakDivergenceIntegrator_swiginit", MixedVectorWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_GradientIntegrator", _wrap_new_GradientIntegrator, METH_VARARGS, "\n" + "GradientIntegrator()\n" + "GradientIntegrator(Coefficient _q)\n" + "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" + ""}, + { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "GradientIntegrator_AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "GradientIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "GradientIntegrator_AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "GradientIntegrator_AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, + { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, + { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DiffusionIntegrator", _wrap_new_DiffusionIntegrator, METH_VARARGS, "\n" + "DiffusionIntegrator()\n" + "DiffusionIntegrator(Coefficient q)\n" + "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" + ""}, + { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, + { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "DiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "DiffusionIntegrator_AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "DiffusionIntegrator_SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, + { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" + "MassIntegrator(IntegrationRule ir=None)\n" + "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" + ""}, + { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, + { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "MassIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "MassIntegrator_AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "MassIntegrator_SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, + { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, + { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, + { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, + { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, + { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "ConvectionIntegrator_AssemblePA(FiniteElementSpace arg1)\n" + ""}, + { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "ConvectionIntegrator_AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" + "ConvectionIntegrator_GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" + "ConvectionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" + ""}, + { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, + { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, + { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, + { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, + { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorMassIntegrator", _wrap_new_VectorMassIntegrator, METH_VARARGS, "\n" + "VectorMassIntegrator()\n" + "VectorMassIntegrator(Coefficient q, int qo=0)\n" + "VectorMassIntegrator(Coefficient q, IntegrationRule ir)\n" + "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" + "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" + ""}, + { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "VectorMassIntegrator_GetVDim(VectorMassIntegrator self) -> int"}, + { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorMassIntegrator_AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "VectorMassIntegrator_AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, + { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, + { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, + { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEDivergenceIntegrator", _wrap_new_VectorFEDivergenceIntegrator, METH_VARARGS, "\n" + "VectorFEDivergenceIntegrator()\n" + "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" + ""}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, + { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, + { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEWeakDivergenceIntegrator", _wrap_new_VectorFEWeakDivergenceIntegrator, METH_VARARGS, "\n" + "VectorFEWeakDivergenceIntegrator()\n" + "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" + ""}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, + { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, + { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFECurlIntegrator", _wrap_new_VectorFECurlIntegrator, METH_VARARGS, "\n" + "VectorFECurlIntegrator()\n" + "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" + ""}, + { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, + { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, + { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, + { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, + { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, + { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_CurlCurlIntegrator", _wrap_new_CurlCurlIntegrator, METH_VARARGS, "\n" + "CurlCurlIntegrator()\n" + "CurlCurlIntegrator(Coefficient q)\n" + "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" + ""}, + { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "CurlCurlIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "CurlCurlIntegrator_AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "CurlCurlIntegrator_AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, + { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, + { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, + { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorCurlCurlIntegrator", _wrap_new_VectorCurlCurlIntegrator, METH_VARARGS, "\n" + "VectorCurlCurlIntegrator()\n" + "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" + ""}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, + { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, + { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEMassIntegrator", _wrap_new_VectorFEMassIntegrator, METH_VARARGS, "\n" + "VectorFEMassIntegrator()\n" + "VectorFEMassIntegrator(Coefficient _q)\n" + "VectorFEMassIntegrator(Coefficient q)\n" + "VectorFEMassIntegrator(VectorCoefficient _vq)\n" + "VectorFEMassIntegrator(VectorCoefficient vq)\n" + "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" + "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" + ""}, + { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorFEMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "VectorFEMassIntegrator_AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorFEMassIntegrator_AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, + { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, + { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, + { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorDivergenceIntegrator", _wrap_new_VectorDivergenceIntegrator, METH_VARARGS, "\n" + "VectorDivergenceIntegrator()\n" + "VectorDivergenceIntegrator(Coefficient _q)\n" + "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" + ""}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorDivergenceIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, + { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, + { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DivDivIntegrator", _wrap_new_DivDivIntegrator, METH_VARARGS, "\n" + "DivDivIntegrator()\n" + "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" + ""}, + { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, + { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, + { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorDiffusionIntegrator", _wrap_new_VectorDiffusionIntegrator, METH_VARARGS, "\n" + "VectorDiffusionIntegrator()\n" + "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" + ""}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorDiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorDiffusionIntegrator_AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "VectorDiffusionIntegrator_AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, + { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, + { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, + { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_ElasticityIntegrator", _wrap_new_ElasticityIntegrator, METH_VARARGS, "\n" + "ElasticityIntegrator(Coefficient l, Coefficient m)\n" + "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" + ""}, + { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, + { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, + { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGTraceIntegrator", _wrap_new_DGTraceIntegrator, METH_VARARGS, "\n" + "DGTraceIntegrator(VectorCoefficient _u, double a, double b)\n" + "new_DGTraceIntegrator(Coefficient _rho, VectorCoefficient _u, double a, double b) -> DGTraceIntegrator\n" + ""}, + { "DGTraceIntegrator_AssembleFaceMatrix", _wrap_DGTraceIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "DGTraceIntegrator_AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "DGTraceIntegrator_AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, + { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, + { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, + { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGDiffusionIntegrator", _wrap_new_DGDiffusionIntegrator, METH_VARARGS, "\n" + "DGDiffusionIntegrator(double const s, double const k)\n" + "DGDiffusionIntegrator(Coefficient q, double const s, double const k)\n" + "new_DGDiffusionIntegrator(MatrixCoefficient q, double const s, double const k) -> DGDiffusionIntegrator\n" + ""}, + { "DGDiffusionIntegrator_AssembleFaceMatrix", _wrap_DGDiffusionIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_DGDiffusionIntegrator", _wrap_delete_DGDiffusionIntegrator, METH_O, "delete_DGDiffusionIntegrator(DGDiffusionIntegrator self)"}, + { "DGDiffusionIntegrator_swigregister", DGDiffusionIntegrator_swigregister, METH_O, NULL}, + { "DGDiffusionIntegrator_swiginit", DGDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGElasticityIntegrator", _wrap_new_DGElasticityIntegrator, METH_VARARGS, "\n" + "DGElasticityIntegrator(double alpha_, double kappa_)\n" + "new_DGElasticityIntegrator(Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityIntegrator\n" + ""}, + { "DGElasticityIntegrator_AssembleFaceMatrix", _wrap_DGElasticityIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_DGElasticityIntegrator", _wrap_delete_DGElasticityIntegrator, METH_O, "delete_DGElasticityIntegrator(DGElasticityIntegrator self)"}, + { "DGElasticityIntegrator_swigregister", DGElasticityIntegrator_swigregister, METH_O, NULL}, + { "DGElasticityIntegrator_swiginit", DGElasticityIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_TraceJumpIntegrator", _wrap_new_TraceJumpIntegrator, METH_NOARGS, "new_TraceJumpIntegrator() -> TraceJumpIntegrator"}, + { "TraceJumpIntegrator_AssembleFaceMatrix", _wrap_TraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_TraceJumpIntegrator", _wrap_delete_TraceJumpIntegrator, METH_O, "delete_TraceJumpIntegrator(TraceJumpIntegrator self)"}, + { "TraceJumpIntegrator_swigregister", TraceJumpIntegrator_swigregister, METH_O, NULL}, + { "TraceJumpIntegrator_swiginit", TraceJumpIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_NormalTraceJumpIntegrator", _wrap_new_NormalTraceJumpIntegrator, METH_NOARGS, "new_NormalTraceJumpIntegrator() -> NormalTraceJumpIntegrator"}, + { "NormalTraceJumpIntegrator_AssembleFaceMatrix", _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_NormalTraceJumpIntegrator", _wrap_delete_NormalTraceJumpIntegrator, METH_O, "delete_NormalTraceJumpIntegrator(NormalTraceJumpIntegrator self)"}, + { "NormalTraceJumpIntegrator_swigregister", NormalTraceJumpIntegrator_swigregister, METH_O, NULL}, + { "NormalTraceJumpIntegrator_swiginit", NormalTraceJumpIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DiscreteInterpolator", _wrap_new_DiscreteInterpolator, METH_NOARGS, "new_DiscreteInterpolator() -> DiscreteInterpolator"}, + { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, + { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, + { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, + { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, + { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, + { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, + { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, + { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, + { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, + { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, + { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, + { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, + { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, + { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, + { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, + { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, + { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, + { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, + { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, + { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, + { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, + { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, + { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, + { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, + { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, + { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, + { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, + { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, + { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, + { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, + { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, + { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, + { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, - { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(BilinearFormIntegrator self)\n" + "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" + "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)"}, - { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "TransposeIntegrator_AssemblePA", _wrap_TransposeIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" ""}, + { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, - { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, - { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, - { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, - { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, - { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, - { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" @@ -24971,22 +28642,22 @@ static PyMethodDef SwigMethods[] = { { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, - { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDotProductIntegrator_FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, - { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, - { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, + { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, - { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, - { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, @@ -24996,19 +28667,19 @@ static PyMethodDef SwigMethods[] = { "MixedGradGradIntegrator(VectorCoefficient dq)\n" "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" ""}, - { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradGradIntegrator_FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, - { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, - { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, - { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, - { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25018,120 +28689,120 @@ static PyMethodDef SwigMethods[] = { "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" ""}, - { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, - { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, - { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, - { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, - { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, - { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, - { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, - { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, - { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, - { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, - { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, + { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, - { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, - { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, - { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, - { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, - { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, - { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, - { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, - { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, - { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, - { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, - { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradDivIntegrator_FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, - { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, + { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, - { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDivGradIntegrator_FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, - { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, + { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, - { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, - { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25171,50 +28842,85 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedVectorWeakDivergenceIntegrator", _wrap_delete_MixedVectorWeakDivergenceIntegrator, METH_O, "delete_MixedVectorWeakDivergenceIntegrator(MixedVectorWeakDivergenceIntegrator self)"}, { "MixedVectorWeakDivergenceIntegrator_swigregister", MixedVectorWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedVectorWeakDivergenceIntegrator_swiginit", MixedVectorWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_GradientIntegrator", _wrap_new_GradientIntegrator, METH_VARARGS, "\n" + "GradientIntegrator()\n" + "GradientIntegrator(Coefficient _q)\n" + "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" + ""}, + { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, + { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, + { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, { "new_DiffusionIntegrator", _wrap_new_DiffusionIntegrator, METH_VARARGS, "\n" "DiffusionIntegrator()\n" "DiffusionIntegrator(Coefficient q)\n" "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" ""}, - { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)"}, - { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, - { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "DiffusionIntegrator_AssemblePA(DiffusionIntegrator self, FiniteElementSpace arg2)"}, - { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, - { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, + { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" "MassIntegrator(IntegrationRule ir=None)\n" "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" ""}, - { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "MassIntegrator_AssemblePA(MassIntegrator self, FiniteElementSpace arg2)"}, - { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, - { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, + { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace arg1)\n" + ""}, + { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" + "GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" + "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" + ""}, { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25225,10 +28931,16 @@ static PyMethodDef SwigMethods[] = { "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" ""}, - { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "VectorMassIntegrator_GetVDim(VectorMassIntegrator self) -> int"}, - { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, - { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "GetVDim(VectorMassIntegrator self) -> int"}, + { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25236,8 +28948,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEDivergenceIntegrator()\n" "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" ""}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25245,8 +28957,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEWeakDivergenceIntegrator()\n" "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" ""}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25254,14 +28966,14 @@ static PyMethodDef SwigMethods[] = { "VectorFECurlIntegrator()\n" "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" ""}, - { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, - { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25270,9 +28982,15 @@ static PyMethodDef SwigMethods[] = { "CurlCurlIntegrator(Coefficient q)\n" "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" ""}, - { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef)"}, - { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25280,8 +28998,8 @@ static PyMethodDef SwigMethods[] = { "VectorCurlCurlIntegrator()\n" "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" ""}, - { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25294,8 +29012,14 @@ static PyMethodDef SwigMethods[] = { "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" ""}, - { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25304,7 +29028,14 @@ static PyMethodDef SwigMethods[] = { "VectorDivergenceIntegrator(Coefficient _q)\n" "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" ""}, - { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25312,7 +29043,7 @@ static PyMethodDef SwigMethods[] = { "DivDivIntegrator()\n" "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" ""}, - { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25320,8 +29051,14 @@ static PyMethodDef SwigMethods[] = { "VectorDiffusionIntegrator()\n" "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" ""}, - { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25329,9 +29066,9 @@ static PyMethodDef SwigMethods[] = { "ElasticityIntegrator(Coefficient l, Coefficient m)\n" "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" ""}, - { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, - { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)"}, - { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25340,10 +29077,15 @@ static PyMethodDef SwigMethods[] = { "new_DGTraceIntegrator(Coefficient _rho, VectorCoefficient _u, double a, double b) -> DGTraceIntegrator\n" ""}, { "DGTraceIntegrator_AssembleFaceMatrix", _wrap_DGTraceIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -25353,9 +29095,9 @@ static PyMethodDef SwigMethods[] = { "new_DGDiffusionIntegrator(MatrixCoefficient q, double const s, double const k) -> DGDiffusionIntegrator\n" ""}, { "DGDiffusionIntegrator_AssembleFaceMatrix", _wrap_DGDiffusionIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_DGDiffusionIntegrator", _wrap_delete_DGDiffusionIntegrator, METH_O, "delete_DGDiffusionIntegrator(DGDiffusionIntegrator self)"}, { "DGDiffusionIntegrator_swigregister", DGDiffusionIntegrator_swigregister, METH_O, NULL}, @@ -25365,27 +29107,27 @@ static PyMethodDef SwigMethods[] = { "new_DGElasticityIntegrator(Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityIntegrator\n" ""}, { "DGElasticityIntegrator_AssembleFaceMatrix", _wrap_DGElasticityIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_DGElasticityIntegrator", _wrap_delete_DGElasticityIntegrator, METH_O, "delete_DGElasticityIntegrator(DGElasticityIntegrator self)"}, { "DGElasticityIntegrator_swigregister", DGElasticityIntegrator_swigregister, METH_O, NULL}, { "DGElasticityIntegrator_swiginit", DGElasticityIntegrator_swiginit, METH_VARARGS, NULL}, { "new_TraceJumpIntegrator", _wrap_new_TraceJumpIntegrator, METH_NOARGS, "new_TraceJumpIntegrator() -> TraceJumpIntegrator"}, { "TraceJumpIntegrator_AssembleFaceMatrix", _wrap_TraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_TraceJumpIntegrator", _wrap_delete_TraceJumpIntegrator, METH_O, "delete_TraceJumpIntegrator(TraceJumpIntegrator self)"}, { "TraceJumpIntegrator_swigregister", TraceJumpIntegrator_swigregister, METH_O, NULL}, { "TraceJumpIntegrator_swiginit", TraceJumpIntegrator_swiginit, METH_VARARGS, NULL}, { "new_NormalTraceJumpIntegrator", _wrap_new_NormalTraceJumpIntegrator, METH_NOARGS, "new_NormalTraceJumpIntegrator() -> NormalTraceJumpIntegrator"}, { "NormalTraceJumpIntegrator_AssembleFaceMatrix", _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_NormalTraceJumpIntegrator", _wrap_delete_NormalTraceJumpIntegrator, METH_O, "delete_NormalTraceJumpIntegrator(NormalTraceJumpIntegrator self)"}, { "NormalTraceJumpIntegrator_swigregister", NormalTraceJumpIntegrator_swigregister, METH_O, NULL}, @@ -25394,63 +29136,59 @@ static PyMethodDef SwigMethods[] = { { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, - { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, - { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, - { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, - { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, - { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, - { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, - { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, - { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, - { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, - { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; -static PyMethodDef SwigMethods_proxydocs[] = { - { NULL, NULL, 0, NULL } -}; - /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ @@ -25769,6 +29507,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -25898,9 +29639,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -25925,6 +29663,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -25961,12 +29702,6 @@ static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__DiscreteInterpola static void *_p_mfem__VectorInnerProductInterpolatorTo_p_mfem__DiscreteInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::DiscreteInterpolator *) ((mfem::VectorInnerProductInterpolator *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -26000,6 +29735,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -26015,6 +29753,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -26183,6 +29924,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -26226,10 +29973,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -26254,6 +30001,7 @@ static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement(void *x, int } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -26308,13 +30056,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -26326,6 +30072,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -26367,6 +30115,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -26391,6 +30141,7 @@ static swig_type_info _swigt__p_mfem__NURBS1DFiniteElement = {"_p_mfem__NURBS1DF static swig_type_info _swigt__p_mfem__NURBS2DFiniteElement = {"_p_mfem__NURBS2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS3DFiniteElement = {"_p_mfem__NURBS3DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", "mfem::GradientIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", "mfem::GradientInterpolator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GroupConvectionIntegrator = {"_p_mfem__GroupConvectionIntegrator", "mfem::GroupConvectionIntegrator *", 0, 0, (void*)0, 0}; @@ -26498,6 +30249,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -26545,6 +30297,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__GaussLinear2DFiniteElement, &_swigt__p_mfem__GaussQuad2DFiniteElement, &_swigt__p_mfem__GradientGridFunctionCoefficient, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GridFunctionCoefficient, @@ -26555,6 +30308,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -26733,6 +30487,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorRotProductCoefficient, &_swigt__p_mfem__VectorScalarProductInterpolator, &_swigt__p_mfem__VectorSumCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -26742,10 +30497,11 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = { {&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyCoefficientBase[] = {{&_swigt__p_mfem__PyCoefficientBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DeterminantCoefficient[] = {{&_swigt__p_mfem__DeterminantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; @@ -26795,13 +30551,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -26813,6 +30567,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -26854,6 +30610,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -26877,8 +30635,9 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = { {&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = { {&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GroupConvectionIntegrator[] = { {&_swigt__p_mfem__GroupConvectionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -26986,6 +30745,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -27033,6 +30793,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__GaussLinear2DFiniteElement, _swigc__p_mfem__GaussQuad2DFiniteElement, _swigc__p_mfem__GradientGridFunctionCoefficient, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GridFunctionCoefficient, @@ -27043,6 +30804,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -27221,6 +30983,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorRotProductCoefficient, _swigc__p_mfem__VectorScalarProductInterpolator, _swigc__p_mfem__VectorSumCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_par/bilininteg_wrap.h b/mfem/_par/bilininteg_wrap.h index 1ab9d76a..3361ff37 100644 --- a/mfem/_par/bilininteg_wrap.h +++ b/mfem/_par/bilininteg_wrap.h @@ -20,6 +20,10 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, public: SwigDirector_BilinearFormIntegrator(PyObject *self, mfem::IntegrationRule const *ir = NULL); virtual void AssemblePA(mfem::FiniteElementSpace const &fes); + virtual void AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes); + virtual void AssemblePAInteriorFaces(mfem::FiniteElementSpace const &fes); + virtual void AssemblePABoundaryFaces(mfem::FiniteElementSpace const &fes); + virtual void AssembleDiagonalPA(mfem::Vector &diag); virtual void AddMultPA(mfem::Vector const &x, mfem::Vector &y) const; virtual void AddMultTransposePA(mfem::Vector const &x, mfem::Vector &y) const; virtual void AssembleElementMatrix(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::DenseMatrix &elmat); @@ -29,7 +33,7 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, virtual void AssembleElementVector(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun, mfem::Vector &elvect); virtual void AssembleElementGrad(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); virtual void AssembleFaceGrad(mfem::FiniteElement const &el1, mfem::FiniteElement const &el2, mfem::FaceElementTransformations &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); - virtual void ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, int with_coef = 1); + virtual void ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, bool with_coef = true); virtual double ComputeFluxEnergy(mfem::FiniteElement const &fluxelem, mfem::ElementTransformation &Trans, mfem::Vector &flux, mfem::Vector *d_energy = NULL); virtual ~SwigDirector_BilinearFormIntegrator(); @@ -62,7 +66,7 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, return method; } private: - mutable swig::SwigVar_PyObject vtable[14]; + mutable swig::SwigVar_PyObject vtable[18]; #endif }; diff --git a/mfem/_par/blockmatrix.py b/mfem/_par/blockmatrix.py index aa7771a4..5b468b8b 100644 --- a/mfem/_par/blockmatrix.py +++ b/mfem/_par/blockmatrix.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _blockmatrix.SWIG_PyInstanceMethod_New +_swig_new_static_method = _blockmatrix.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -110,10 +113,12 @@ def SetBlock(self, i, j, mat): def NumRowBlocks(self): r"""NumRowBlocks(BlockMatrix self) -> int""" return _blockmatrix.BlockMatrix_NumRowBlocks(self) + NumRowBlocks = _swig_new_instance_method(_blockmatrix.BlockMatrix_NumRowBlocks) def NumColBlocks(self): r"""NumColBlocks(BlockMatrix self) -> int""" return _blockmatrix.BlockMatrix_NumColBlocks(self) + NumColBlocks = _swig_new_instance_method(_blockmatrix.BlockMatrix_NumColBlocks) def GetBlock(self, *args): r""" @@ -121,10 +126,12 @@ def GetBlock(self, *args): GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix """ return _blockmatrix.BlockMatrix_GetBlock(self, *args) + GetBlock = _swig_new_instance_method(_blockmatrix.BlockMatrix_GetBlock) def IsZeroBlock(self, i, j): r"""IsZeroBlock(BlockMatrix self, int i, int j) -> int""" return _blockmatrix.BlockMatrix_IsZeroBlock(self, i, j) + IsZeroBlock = _swig_new_instance_method(_blockmatrix.BlockMatrix_IsZeroBlock) def RowOffsets(self, *args): r""" @@ -132,6 +139,7 @@ def RowOffsets(self, *args): RowOffsets(BlockMatrix self) -> intArray """ return _blockmatrix.BlockMatrix_RowOffsets(self, *args) + RowOffsets = _swig_new_instance_method(_blockmatrix.BlockMatrix_RowOffsets) def ColOffsets(self, *args): r""" @@ -139,10 +147,12 @@ def ColOffsets(self, *args): ColOffsets(BlockMatrix self) -> intArray """ return _blockmatrix.BlockMatrix_ColOffsets(self, *args) + ColOffsets = _swig_new_instance_method(_blockmatrix.BlockMatrix_ColOffsets) def RowSize(self, i): r"""RowSize(BlockMatrix self, int const i) -> int""" return _blockmatrix.BlockMatrix_RowSize(self, i) + RowSize = _swig_new_instance_method(_blockmatrix.BlockMatrix_RowSize) def EliminateRowCol(self, *args): r""" @@ -150,6 +160,7 @@ def EliminateRowCol(self, *args): EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs) """ return _blockmatrix.BlockMatrix_EliminateRowCol(self, *args) + EliminateRowCol = _swig_new_instance_method(_blockmatrix.BlockMatrix_EliminateRowCol) def Finalize(self, *args): r""" @@ -157,10 +168,12 @@ def Finalize(self, *args): Finalize(BlockMatrix self, int skip_zeros, bool fix_empty_rows) """ return _blockmatrix.BlockMatrix_Finalize(self, *args) + Finalize = _swig_new_instance_method(_blockmatrix.BlockMatrix_Finalize) def CreateMonolithic(self): r"""CreateMonolithic(BlockMatrix self) -> SparseMatrix""" return _blockmatrix.BlockMatrix_CreateMonolithic(self) + CreateMonolithic = _swig_new_instance_method(_blockmatrix.BlockMatrix_CreateMonolithic) def Elem(self, *args): r""" @@ -168,38 +181,47 @@ def Elem(self, *args): Elem(BlockMatrix self, int i, int j) -> double const & """ return _blockmatrix.BlockMatrix_Elem(self, *args) + Elem = _swig_new_instance_method(_blockmatrix.BlockMatrix_Elem) def Inverse(self): r"""Inverse(BlockMatrix self) -> MatrixInverse""" return _blockmatrix.BlockMatrix_Inverse(self) + Inverse = _swig_new_instance_method(_blockmatrix.BlockMatrix_Inverse) def NumNonZeroElems(self): r"""NumNonZeroElems(BlockMatrix self) -> int""" return _blockmatrix.BlockMatrix_NumNonZeroElems(self) + NumNonZeroElems = _swig_new_instance_method(_blockmatrix.BlockMatrix_NumNonZeroElems) def GetRow(self, row, cols, srow): r"""GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int""" return _blockmatrix.BlockMatrix_GetRow(self, row, cols, srow) + GetRow = _swig_new_instance_method(_blockmatrix.BlockMatrix_GetRow) def EliminateZeroRows(self, threshold=1e-12): r"""EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)""" return _blockmatrix.BlockMatrix_EliminateZeroRows(self, threshold) + EliminateZeroRows = _swig_new_instance_method(_blockmatrix.BlockMatrix_EliminateZeroRows) def Mult(self, x, y): r"""Mult(BlockMatrix self, Vector x, Vector y)""" return _blockmatrix.BlockMatrix_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockmatrix.BlockMatrix_Mult) def AddMult(self, x, y, val=1.): r"""AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)""" return _blockmatrix.BlockMatrix_AddMult(self, x, y, val) + AddMult = _swig_new_instance_method(_blockmatrix.BlockMatrix_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(BlockMatrix self, Vector x, Vector y)""" return _blockmatrix.BlockMatrix_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockmatrix.BlockMatrix_MultTranspose) def AddMultTranspose(self, x, y, val=1.): r"""AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)""" return _blockmatrix.BlockMatrix_AddMultTranspose(self, x, y, val) + AddMultTranspose = _swig_new_instance_method(_blockmatrix.BlockMatrix_AddMultTranspose) __swig_destroy__ = _blockmatrix.delete_BlockMatrix owns_blocks = property(_blockmatrix.BlockMatrix_owns_blocks_get, _blockmatrix.BlockMatrix_owns_blocks_set, doc=r"""owns_blocks : int""") @@ -209,6 +231,7 @@ def PrintMatlab(self, *args): PrintMatlab(BlockMatrix self, char const * file, int precision=8) """ return _blockmatrix.BlockMatrix_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_blockmatrix.BlockMatrix_PrintMatlab) # Register BlockMatrix in _blockmatrix: _blockmatrix.BlockMatrix_swigregister(BlockMatrix) diff --git a/mfem/_par/blockmatrix_wrap.cxx b/mfem/_par/blockmatrix_wrap.cxx index f50a3bdf..cc6158b6 100644 --- a/mfem/_par/blockmatrix_wrap.cxx +++ b/mfem/_par/blockmatrix_wrap.cxx @@ -3082,14 +3082,17 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[14] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[15] #define SWIGTYPE_p_mfem__RAPOperator swig_types[16] -#define SWIGTYPE_p_mfem__Solver swig_types[17] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[18] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[19] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[20] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[21] -#define SWIGTYPE_p_mfem__Vector swig_types[22] -static swig_type_info *swig_types[24]; -static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[17] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[18] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[19] +#define SWIGTYPE_p_mfem__Solver swig_types[20] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[21] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[22] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[23] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[24] +#define SWIGTYPE_p_mfem__Vector swig_types[25] +static swig_type_info *swig_types[27]; +static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5939,6 +5942,7 @@ SWIGINTERN PyObject *BlockMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_BlockMatrix", _wrap_new_BlockMatrix, METH_VARARGS, "\n" "BlockMatrix(intArray offsets)\n" "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" @@ -5994,6 +5998,59 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_BlockMatrix", _wrap_new_BlockMatrix, METH_VARARGS, "\n" + "BlockMatrix(intArray offsets)\n" + "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" + ""}, + { "BlockMatrix_SetBlock", _wrap_BlockMatrix_SetBlock, METH_VARARGS, "SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, + { "BlockMatrix_NumRowBlocks", _wrap_BlockMatrix_NumRowBlocks, METH_O, "NumRowBlocks(BlockMatrix self) -> int"}, + { "BlockMatrix_NumColBlocks", _wrap_BlockMatrix_NumColBlocks, METH_O, "NumColBlocks(BlockMatrix self) -> int"}, + { "BlockMatrix_GetBlock", _wrap_BlockMatrix_GetBlock, METH_VARARGS, "\n" + "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" + "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" + ""}, + { "BlockMatrix_IsZeroBlock", _wrap_BlockMatrix_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, + { "BlockMatrix_RowOffsets", _wrap_BlockMatrix_RowOffsets, METH_VARARGS, "\n" + "RowOffsets(BlockMatrix self) -> intArray\n" + "RowOffsets(BlockMatrix self) -> intArray\n" + ""}, + { "BlockMatrix_ColOffsets", _wrap_BlockMatrix_ColOffsets, METH_VARARGS, "\n" + "ColOffsets(BlockMatrix self) -> intArray\n" + "ColOffsets(BlockMatrix self) -> intArray\n" + ""}, + { "BlockMatrix_RowSize", _wrap_BlockMatrix_RowSize, METH_VARARGS, "RowSize(BlockMatrix self, int const i) -> int"}, + { "BlockMatrix_EliminateRowCol", _wrap_BlockMatrix_EliminateRowCol, METH_VARARGS, "\n" + "EliminateRowCol(BlockMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs)\n" + ""}, + { "BlockMatrix_Finalize", _wrap_BlockMatrix_Finalize, METH_VARARGS, "\n" + "Finalize(BlockMatrix self, int skip_zeros=1)\n" + "Finalize(BlockMatrix self, int skip_zeros, bool fix_empty_rows)\n" + ""}, + { "BlockMatrix_CreateMonolithic", _wrap_BlockMatrix_CreateMonolithic, METH_O, "CreateMonolithic(BlockMatrix self) -> SparseMatrix"}, + { "BlockMatrix_Elem", _wrap_BlockMatrix_Elem, METH_VARARGS, "\n" + "Elem(BlockMatrix self, int i, int j) -> double\n" + "Elem(BlockMatrix self, int i, int j) -> double const &\n" + ""}, + { "BlockMatrix_Inverse", _wrap_BlockMatrix_Inverse, METH_O, "Inverse(BlockMatrix self) -> MatrixInverse"}, + { "BlockMatrix_NumNonZeroElems", _wrap_BlockMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(BlockMatrix self) -> int"}, + { "BlockMatrix_GetRow", _wrap_BlockMatrix_GetRow, METH_VARARGS, "GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "BlockMatrix_EliminateZeroRows", _wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, + { "BlockMatrix_Mult", _wrap_BlockMatrix_Mult, METH_VARARGS, "Mult(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMult", _wrap_BlockMatrix_AddMult, METH_VARARGS, "AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_MultTranspose", _wrap_BlockMatrix_MultTranspose, METH_VARARGS, "MultTranspose(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMultTranspose", _wrap_BlockMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "delete_BlockMatrix", _wrap_delete_BlockMatrix, METH_O, "delete_BlockMatrix(BlockMatrix self)"}, + { "BlockMatrix_owns_blocks_set", _wrap_BlockMatrix_owns_blocks_set, METH_VARARGS, "BlockMatrix_owns_blocks_set(BlockMatrix self, int owns_blocks)"}, + { "BlockMatrix_owns_blocks_get", _wrap_BlockMatrix_owns_blocks_get, METH_O, "BlockMatrix_owns_blocks_get(BlockMatrix self) -> int"}, + { "BlockMatrix_PrintMatlab", _wrap_BlockMatrix_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(BlockMatrix self, std::ostream & os=mfem::out)\n" + "PrintMatlab(BlockMatrix self, char const * file, int precision=8)\n" + ""}, + { "BlockMatrix_swigregister", BlockMatrix_swigregister, METH_O, NULL}, + { "BlockMatrix_swiginit", BlockMatrix_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6036,12 +6093,12 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } @@ -6051,6 +6108,9 @@ static void *_p_mfem__BlockMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPAR static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -6066,9 +6126,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -6086,12 +6152,15 @@ static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Op static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -6114,6 +6183,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -6135,14 +6207,17 @@ static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__Mat static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockMatrix, _p_mfem__BlockMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockMatrix, _p_mfem__BlockMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -6164,6 +6239,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_par/blockoperator.py b/mfem/_par/blockoperator.py index 51df2153..ba917d2d 100644 --- a/mfem/_par/blockoperator.py +++ b/mfem/_par/blockoperator.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _blockoperator.SWIG_PyInstanceMethod_New +_swig_new_static_method = _blockoperator.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -71,14 +74,17 @@ class _SwigNonDynamicMeta(type): def Opr2BlockOpr(op): r"""Opr2BlockOpr(Operator op) -> BlockOperator""" return _blockoperator.Opr2BlockOpr(op) +Opr2BlockOpr = _blockoperator.Opr2BlockOpr def Opr2SparseMat(op): r"""Opr2SparseMat(Operator op) -> mfem::SparseMatrix *""" return _blockoperator.Opr2SparseMat(op) +Opr2SparseMat = _blockoperator.Opr2SparseMat def Opr2HypreParMat(op): r"""Opr2HypreParMat(Operator op) -> mfem::HypreParMatrix *""" return _blockoperator.Opr2HypreParMat(op) +Opr2HypreParMat = _blockoperator.Opr2HypreParMat class BlockOperator(mfem._par.operators.Operator): r"""Proxy of C++ mfem::BlockOperator class.""" @@ -131,42 +137,52 @@ def SetBlock(self, iRow, iCol, op, c=1.0): def NumRowBlocks(self): r"""NumRowBlocks(BlockOperator self) -> int""" return _blockoperator.BlockOperator_NumRowBlocks(self) + NumRowBlocks = _swig_new_instance_method(_blockoperator.BlockOperator_NumRowBlocks) def NumColBlocks(self): r"""NumColBlocks(BlockOperator self) -> int""" return _blockoperator.BlockOperator_NumColBlocks(self) + NumColBlocks = _swig_new_instance_method(_blockoperator.BlockOperator_NumColBlocks) def IsZeroBlock(self, i, j): r"""IsZeroBlock(BlockOperator self, int i, int j) -> int""" return _blockoperator.BlockOperator_IsZeroBlock(self, i, j) + IsZeroBlock = _swig_new_instance_method(_blockoperator.BlockOperator_IsZeroBlock) def GetBlock(self, i, j): r"""GetBlock(BlockOperator self, int i, int j) -> Operator""" return _blockoperator.BlockOperator_GetBlock(self, i, j) + GetBlock = _swig_new_instance_method(_blockoperator.BlockOperator_GetBlock) def GetBlockCoef(self, i, j): r"""GetBlockCoef(BlockOperator self, int i, int j) -> double""" return _blockoperator.BlockOperator_GetBlockCoef(self, i, j) + GetBlockCoef = _swig_new_instance_method(_blockoperator.BlockOperator_GetBlockCoef) def SetBlockCoef(self, i, j, c): r"""SetBlockCoef(BlockOperator self, int i, int j, double c)""" return _blockoperator.BlockOperator_SetBlockCoef(self, i, j, c) + SetBlockCoef = _swig_new_instance_method(_blockoperator.BlockOperator_SetBlockCoef) def RowOffsets(self): r"""RowOffsets(BlockOperator self) -> intArray""" return _blockoperator.BlockOperator_RowOffsets(self) + RowOffsets = _swig_new_instance_method(_blockoperator.BlockOperator_RowOffsets) def ColOffsets(self): r"""ColOffsets(BlockOperator self) -> intArray""" return _blockoperator.BlockOperator_ColOffsets(self) + ColOffsets = _swig_new_instance_method(_blockoperator.BlockOperator_ColOffsets) def Mult(self, x, y): r"""Mult(BlockOperator self, Vector x, Vector y)""" return _blockoperator.BlockOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockoperator.BlockOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(BlockOperator self, Vector x, Vector y)""" return _blockoperator.BlockOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockoperator.BlockOperator_MultTranspose) __swig_destroy__ = _blockoperator.delete_BlockOperator owns_blocks = property(_blockoperator.BlockOperator_owns_blocks_get, _blockoperator.BlockOperator_owns_blocks_set, doc=r"""owns_blocks : int""") @@ -203,26 +219,32 @@ def SetDiagonalBlock(self, iblock, op): def SetOperator(self, op): r"""SetOperator(BlockDiagonalPreconditioner self, Operator op)""" return _blockoperator.BlockDiagonalPreconditioner_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_SetOperator) def NumBlocks(self): r"""NumBlocks(BlockDiagonalPreconditioner self) -> int""" return _blockoperator.BlockDiagonalPreconditioner_NumBlocks(self) + NumBlocks = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_NumBlocks) def GetDiagonalBlock(self, iblock): r"""GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator""" return _blockoperator.BlockDiagonalPreconditioner_GetDiagonalBlock(self, iblock) + GetDiagonalBlock = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_GetDiagonalBlock) def Offsets(self): r"""Offsets(BlockDiagonalPreconditioner self) -> intArray""" return _blockoperator.BlockDiagonalPreconditioner_Offsets(self) + Offsets = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_Offsets) def Mult(self, x, y): r"""Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockDiagonalPreconditioner_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_Mult) def MultTranspose(self, x, y): r"""MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockDiagonalPreconditioner_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_MultTranspose) __swig_destroy__ = _blockoperator.delete_BlockDiagonalPreconditioner owns_blocks = property(_blockoperator.BlockDiagonalPreconditioner_owns_blocks_get, _blockoperator.BlockDiagonalPreconditioner_owns_blocks_set, doc=r"""owns_blocks : int""") @@ -277,26 +299,32 @@ def SetBlock(self, iRow, iCol, op): def SetOperator(self, op): r"""SetOperator(BlockLowerTriangularPreconditioner self, Operator op)""" return _blockoperator.BlockLowerTriangularPreconditioner_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_SetOperator) def NumBlocks(self): r"""NumBlocks(BlockLowerTriangularPreconditioner self) -> int""" return _blockoperator.BlockLowerTriangularPreconditioner_NumBlocks(self) + NumBlocks = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_NumBlocks) def GetBlock(self, iblock, jblock): r"""GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator""" return _blockoperator.BlockLowerTriangularPreconditioner_GetBlock(self, iblock, jblock) + GetBlock = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_GetBlock) def Offsets(self): r"""Offsets(BlockLowerTriangularPreconditioner self) -> intArray""" return _blockoperator.BlockLowerTriangularPreconditioner_Offsets(self) + Offsets = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_Offsets) def Mult(self, x, y): r"""Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockLowerTriangularPreconditioner_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_Mult) def MultTranspose(self, x, y): r"""MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockLowerTriangularPreconditioner_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_MultTranspose) __swig_destroy__ = _blockoperator.delete_BlockLowerTriangularPreconditioner owns_blocks = property(_blockoperator.BlockLowerTriangularPreconditioner_owns_blocks_get, _blockoperator.BlockLowerTriangularPreconditioner_owns_blocks_set, doc=r"""owns_blocks : int""") diff --git a/mfem/_par/blockoperator_wrap.cxx b/mfem/_par/blockoperator_wrap.cxx index 7307834e..3e9c7101 100644 --- a/mfem/_par/blockoperator_wrap.cxx +++ b/mfem/_par/blockoperator_wrap.cxx @@ -3076,14 +3076,17 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[11] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[12] #define SWIGTYPE_p_mfem__RAPOperator swig_types[13] -#define SWIGTYPE_p_mfem__Solver swig_types[14] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[15] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[16] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[17] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[18] -#define SWIGTYPE_p_mfem__Vector swig_types[19] -static swig_type_info *swig_types[21]; -static swig_module_info swig_module = {swig_types, 20, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[14] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[15] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[16] +#define SWIGTYPE_p_mfem__Solver swig_types[17] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[18] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[19] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[20] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[21] +#define SWIGTYPE_p_mfem__Vector swig_types[22] +static swig_type_info *swig_types[24]; +static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5384,6 +5387,7 @@ SWIGINTERN PyObject *BlockLowerTriangularPreconditioner_swiginit(PyObject *SWIGU static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, { "Opr2HypreParMat", _wrap_Opr2HypreParMat, METH_O, "Opr2HypreParMat(Operator op) -> mfem::HypreParMatrix *"}, @@ -5439,6 +5443,59 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, + { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, + { "Opr2HypreParMat", _wrap_Opr2HypreParMat, METH_O, "Opr2HypreParMat(Operator op) -> mfem::HypreParMatrix *"}, + { "new_BlockOperator", _wrap_new_BlockOperator, METH_VARARGS, "\n" + "BlockOperator(intArray offsets)\n" + "new_BlockOperator(intArray row_offsets, intArray col_offsets) -> BlockOperator\n" + ""}, + { "BlockOperator_SetDiagonalBlock", _wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, + { "BlockOperator_SetBlock", _wrap_BlockOperator_SetBlock, METH_VARARGS, "SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, + { "BlockOperator_NumRowBlocks", _wrap_BlockOperator_NumRowBlocks, METH_O, "NumRowBlocks(BlockOperator self) -> int"}, + { "BlockOperator_NumColBlocks", _wrap_BlockOperator_NumColBlocks, METH_O, "NumColBlocks(BlockOperator self) -> int"}, + { "BlockOperator_IsZeroBlock", _wrap_BlockOperator_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockOperator self, int i, int j) -> int"}, + { "BlockOperator_GetBlock", _wrap_BlockOperator_GetBlock, METH_VARARGS, "GetBlock(BlockOperator self, int i, int j) -> Operator"}, + { "BlockOperator_GetBlockCoef", _wrap_BlockOperator_GetBlockCoef, METH_VARARGS, "GetBlockCoef(BlockOperator self, int i, int j) -> double"}, + { "BlockOperator_SetBlockCoef", _wrap_BlockOperator_SetBlockCoef, METH_VARARGS, "SetBlockCoef(BlockOperator self, int i, int j, double c)"}, + { "BlockOperator_RowOffsets", _wrap_BlockOperator_RowOffsets, METH_O, "RowOffsets(BlockOperator self) -> intArray"}, + { "BlockOperator_ColOffsets", _wrap_BlockOperator_ColOffsets, METH_O, "ColOffsets(BlockOperator self) -> intArray"}, + { "BlockOperator_Mult", _wrap_BlockOperator_Mult, METH_VARARGS, "Mult(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_MultTranspose", _wrap_BlockOperator_MultTranspose, METH_VARARGS, "MultTranspose(BlockOperator self, Vector x, Vector y)"}, + { "delete_BlockOperator", _wrap_delete_BlockOperator, METH_O, "delete_BlockOperator(BlockOperator self)"}, + { "BlockOperator_owns_blocks_set", _wrap_BlockOperator_owns_blocks_set, METH_VARARGS, "BlockOperator_owns_blocks_set(BlockOperator self, int owns_blocks)"}, + { "BlockOperator_owns_blocks_get", _wrap_BlockOperator_owns_blocks_get, METH_O, "BlockOperator_owns_blocks_get(BlockOperator self) -> int"}, + { "BlockOperator_swigregister", BlockOperator_swigregister, METH_O, NULL}, + { "BlockOperator_swiginit", BlockOperator_swiginit, METH_VARARGS, NULL}, + { "new_BlockDiagonalPreconditioner", _wrap_new_BlockDiagonalPreconditioner, METH_O, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, + { "BlockDiagonalPreconditioner_SetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, + { "BlockDiagonalPreconditioner_SetOperator", _wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, + { "BlockDiagonalPreconditioner_NumBlocks", _wrap_BlockDiagonalPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockDiagonalPreconditioner self) -> int"}, + { "BlockDiagonalPreconditioner_GetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS, "GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, + { "BlockDiagonalPreconditioner_Offsets", _wrap_BlockDiagonalPreconditioner_Offsets, METH_O, "Offsets(BlockDiagonalPreconditioner self) -> intArray"}, + { "BlockDiagonalPreconditioner_Mult", _wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS, "Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_MultTranspose", _wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "delete_BlockDiagonalPreconditioner", _wrap_delete_BlockDiagonalPreconditioner, METH_O, "delete_BlockDiagonalPreconditioner(BlockDiagonalPreconditioner self)"}, + { "BlockDiagonalPreconditioner_owns_blocks_set", _wrap_BlockDiagonalPreconditioner_owns_blocks_set, METH_VARARGS, "BlockDiagonalPreconditioner_owns_blocks_set(BlockDiagonalPreconditioner self, int owns_blocks)"}, + { "BlockDiagonalPreconditioner_owns_blocks_get", _wrap_BlockDiagonalPreconditioner_owns_blocks_get, METH_O, "BlockDiagonalPreconditioner_owns_blocks_get(BlockDiagonalPreconditioner self) -> int"}, + { "BlockDiagonalPreconditioner_swigregister", BlockDiagonalPreconditioner_swigregister, METH_O, NULL}, + { "BlockDiagonalPreconditioner_swiginit", BlockDiagonalPreconditioner_swiginit, METH_VARARGS, NULL}, + { "new_BlockLowerTriangularPreconditioner", _wrap_new_BlockLowerTriangularPreconditioner, METH_O, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, + { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", _wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetBlock", _wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS, "SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetOperator", _wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, + { "BlockLowerTriangularPreconditioner_NumBlocks", _wrap_BlockLowerTriangularPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockLowerTriangularPreconditioner self) -> int"}, + { "BlockLowerTriangularPreconditioner_GetBlock", _wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS, "GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, + { "BlockLowerTriangularPreconditioner_Offsets", _wrap_BlockLowerTriangularPreconditioner_Offsets, METH_O, "Offsets(BlockLowerTriangularPreconditioner self) -> intArray"}, + { "BlockLowerTriangularPreconditioner_Mult", _wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS, "Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_MultTranspose", _wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "delete_BlockLowerTriangularPreconditioner", _wrap_delete_BlockLowerTriangularPreconditioner, METH_O, "delete_BlockLowerTriangularPreconditioner(BlockLowerTriangularPreconditioner self)"}, + { "BlockLowerTriangularPreconditioner_owns_blocks_set", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_set, METH_VARARGS, "BlockLowerTriangularPreconditioner_owns_blocks_set(BlockLowerTriangularPreconditioner self, int owns_blocks)"}, + { "BlockLowerTriangularPreconditioner_owns_blocks_get", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_get, METH_O, "BlockLowerTriangularPreconditioner_owns_blocks_get(BlockLowerTriangularPreconditioner self) -> int"}, + { "BlockLowerTriangularPreconditioner_swigregister", BlockLowerTriangularPreconditioner_swigregister, METH_O, NULL}, + { "BlockLowerTriangularPreconditioner_swiginit", BlockLowerTriangularPreconditioner_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5451,6 +5508,12 @@ static void *_p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Solver(void *x, int static void *_p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) ((mfem::BlockLowerTriangularPreconditioner *) x)); } +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } @@ -5460,35 +5523,38 @@ static void *_p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator(void *x, in static void *_p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::BlockLowerTriangularPreconditioner *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__BlockOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::BlockOperator *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); } static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__BlockOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::BlockOperator *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; @@ -5498,15 +5564,18 @@ static swig_type_info _swigt__p_mfem__BlockLowerTriangularPreconditioner = {"_p_ static swig_type_info _swigt__p_mfem__BlockOperator = {"_p_mfem__BlockOperator", "mfem::BlockOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HypreParMatrix = {"_p_mfem__HypreParMatrix", "mfem::HypreParMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -5526,6 +5595,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -5541,16 +5613,19 @@ static swig_cast_info _swigc__p_mfem__BlockDiagonalPreconditioner[] = { {&_swig static swig_cast_info _swigc__p_mfem__BlockLowerTriangularPreconditioner[] = { {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockOperator[] = { {&_swigt__p_mfem__BlockOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParMatrix[] = { {&_swigt__p_mfem__HypreParMatrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockOperator, _p_mfem__BlockOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockOperator, _p_mfem__BlockOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -5570,6 +5645,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_par/blockvector.py b/mfem/_par/blockvector.py index f95a8504..0f6512d5 100644 --- a/mfem/_par/blockvector.py +++ b/mfem/_par/blockvector.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _blockvector.SWIG_PyInstanceMethod_New +_swig_new_static_method = _blockvector.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,14 +90,17 @@ def GetBlock(self, *args): GetBlock(BlockVector self, int i) -> Vector """ return _blockvector.BlockVector_GetBlock(self, *args) + GetBlock = _swig_new_instance_method(_blockvector.BlockVector_GetBlock) def GetBlockView(self, i, blockView): r"""GetBlockView(BlockVector self, int i, Vector blockView)""" return _blockvector.BlockVector_GetBlockView(self, i, blockView) + GetBlockView = _swig_new_instance_method(_blockvector.BlockVector_GetBlockView) def BlockSize(self, i): r"""BlockSize(BlockVector self, int i) -> int""" return _blockvector.BlockVector_BlockSize(self, i) + BlockSize = _swig_new_instance_method(_blockvector.BlockVector_BlockSize) def Update(self, *args): r""" @@ -103,6 +109,7 @@ def Update(self, *args): Update(BlockVector self, intArray bOffsets, mfem::MemoryType mt) """ return _blockvector.BlockVector_Update(self, *args) + Update = _swig_new_instance_method(_blockvector.BlockVector_Update) # Register BlockVector in _blockvector: _blockvector.BlockVector_swigregister(BlockVector) diff --git a/mfem/_par/blockvector_wrap.cxx b/mfem/_par/blockvector_wrap.cxx index 07bd3a06..93b93065 100644 --- a/mfem/_par/blockvector_wrap.cxx +++ b/mfem/_par/blockvector_wrap.cxx @@ -3715,6 +3715,7 @@ SWIGINTERN PyObject *BlockVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_BlockVector", _wrap_new_BlockVector, METH_VARARGS, "\n" "BlockVector()\n" "BlockVector(intArray bOffsets)\n" @@ -3740,6 +3741,29 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_BlockVector", _wrap_new_BlockVector, METH_VARARGS, "\n" + "BlockVector()\n" + "BlockVector(intArray bOffsets)\n" + "BlockVector(intArray bOffsets, mfem::MemoryType mt)\n" + "BlockVector(BlockVector block)\n" + "new_BlockVector(double * data, intArray bOffsets) -> BlockVector\n" + ""}, + { "delete_BlockVector", _wrap_delete_BlockVector, METH_O, "delete_BlockVector(BlockVector self)"}, + { "BlockVector_GetBlock", _wrap_BlockVector_GetBlock, METH_VARARGS, "\n" + "GetBlock(BlockVector self, int i) -> Vector\n" + "GetBlock(BlockVector self, int i) -> Vector\n" + ""}, + { "BlockVector_GetBlockView", _wrap_BlockVector_GetBlockView, METH_VARARGS, "GetBlockView(BlockVector self, int i, Vector blockView)"}, + { "BlockVector_BlockSize", _wrap_BlockVector_BlockSize, METH_VARARGS, "BlockSize(BlockVector self, int i) -> int"}, + { "BlockVector_Update", _wrap_BlockVector_Update, METH_VARARGS, "\n" + "Update(BlockVector self, double * data, intArray bOffsets)\n" + "Update(BlockVector self, intArray bOffsets)\n" + "Update(BlockVector self, intArray bOffsets, mfem::MemoryType mt)\n" + ""}, + { "BlockVector_swigregister", BlockVector_swigregister, METH_O, NULL}, + { "BlockVector_swiginit", BlockVector_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/coefficient.i b/mfem/_par/coefficient.i index 10f086ea..3c4ecb40 100644 --- a/mfem/_par/coefficient.i +++ b/mfem/_par/coefficient.i @@ -309,7 +309,7 @@ class MatrixPyCoefficient(MatrixPyCoefficientBase): K.Assign(k) def EvalValue(self, x): - return np.array([[0,0,0], [0,0,0] [0,0,0]]) + return np.array([[0,0,0], [0,0,0], [0,0,0]]) class MatrixPyCoefficientT(MatrixPyCoefficientBase): def __init__(self, dim): @@ -320,7 +320,7 @@ class MatrixPyCoefficientT(MatrixPyCoefficientBase): K.Assign(k) def EvalValue(self, x, t): - return np.array([[0.0,0.0,0.0], [0.0,0.0,0.0] [0.0,0.0,0.0]]) + return np.array([[0.0,0.0,0.0], [0.0,0.0,0.0], [0.0,0.0,0.0]]) %} diff --git a/mfem/_par/coefficient.py b/mfem/_par/coefficient.py index 02f2e6ca..89ed14d3 100644 --- a/mfem/_par/coefficient.py +++ b/mfem/_par/coefficient.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _coefficient.SWIG_PyInstanceMethod_New +_swig_new_static_method = _coefficient.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -110,10 +113,12 @@ def __init__(self, *args, **kwargs): def SetTime(self, t): r"""SetTime(Coefficient self, double t)""" return _coefficient.Coefficient_SetTime(self, t) + SetTime = _swig_new_instance_method(_coefficient.Coefficient_SetTime) def GetTime(self): r"""GetTime(Coefficient self) -> double""" return _coefficient.Coefficient_GetTime(self) + GetTime = _swig_new_instance_method(_coefficient.Coefficient_GetTime) def Eval(self, *args): r""" @@ -121,6 +126,7 @@ def Eval(self, *args): Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip, double t) -> double """ return _coefficient.Coefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.Coefficient_Eval) __swig_destroy__ = _coefficient.delete_Coefficient # Register Coefficient in _coefficient: @@ -140,6 +146,7 @@ def __init__(self, c=1.0): def Eval(self, T, ip): r"""Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.ConstantCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.ConstantCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ConstantCoefficient # Register ConstantCoefficient in _coefficient: @@ -161,18 +168,22 @@ def __init__(self, *args): def UpdateConstants(self, c): r"""UpdateConstants(PWConstCoefficient self, Vector c)""" return _coefficient.PWConstCoefficient_UpdateConstants(self, c) + UpdateConstants = _swig_new_instance_method(_coefficient.PWConstCoefficient_UpdateConstants) def __call__(self, i): r"""__call__(PWConstCoefficient self, int i) -> double &""" return _coefficient.PWConstCoefficient___call__(self, i) + __call__ = _swig_new_instance_method(_coefficient.PWConstCoefficient___call__) def GetNConst(self): r"""GetNConst(PWConstCoefficient self) -> int""" return _coefficient.PWConstCoefficient_GetNConst(self) + GetNConst = _swig_new_instance_method(_coefficient.PWConstCoefficient_GetNConst) def Eval(self, T, ip): r"""Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.PWConstCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.PWConstCoefficient_Eval) __swig_destroy__ = _coefficient.delete_PWConstCoefficient # Register PWConstCoefficient in _coefficient: @@ -196,6 +207,7 @@ def __init__(self, *args): def Eval(self, T, ip): r"""Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.FunctionCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.FunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_FunctionCoefficient # Register FunctionCoefficient in _coefficient: @@ -217,14 +229,17 @@ def __init__(self, *args): def SetGridFunction(self, gf): r"""SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.GridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.GridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_GetGridFunction) def Eval(self, T, ip): r"""Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.GridFunctionCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_GridFunctionCoefficient # Register GridFunctionCoefficient in _coefficient: @@ -246,6 +261,7 @@ def __init__(self, *args): def Eval(self, T, ip): r"""Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.TransformedCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.TransformedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_TransformedCoefficient # Register TransformedCoefficient in _coefficient: @@ -269,18 +285,22 @@ def __init__(self, *args): def SetDeltaCenter(self, center): r"""SetDeltaCenter(DeltaCoefficient self, Vector center)""" return _coefficient.DeltaCoefficient_SetDeltaCenter(self, center) + SetDeltaCenter = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetDeltaCenter) def SetScale(self, _s): r"""SetScale(DeltaCoefficient self, double _s)""" return _coefficient.DeltaCoefficient_SetScale(self, _s) + SetScale = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetScale) def SetFunction(self, f): r"""SetFunction(DeltaCoefficient self, double (*)(double) f)""" return _coefficient.DeltaCoefficient_SetFunction(self, f) + SetFunction = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetFunction) def SetTol(self, _tol): r"""SetTol(DeltaCoefficient self, double _tol)""" return _coefficient.DeltaCoefficient_SetTol(self, _tol) + SetTol = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetTol) def SetWeight(self, w): r"""SetWeight(DeltaCoefficient self, Coefficient w)""" @@ -294,30 +314,37 @@ def SetWeight(self, w): def Center(self): r"""Center(DeltaCoefficient self) -> double const *""" return _coefficient.DeltaCoefficient_Center(self) + Center = _swig_new_instance_method(_coefficient.DeltaCoefficient_Center) def Scale(self): r"""Scale(DeltaCoefficient self) -> double""" return _coefficient.DeltaCoefficient_Scale(self) + Scale = _swig_new_instance_method(_coefficient.DeltaCoefficient_Scale) def Tol(self): r"""Tol(DeltaCoefficient self) -> double""" return _coefficient.DeltaCoefficient_Tol(self) + Tol = _swig_new_instance_method(_coefficient.DeltaCoefficient_Tol) def Weight(self): r"""Weight(DeltaCoefficient self) -> Coefficient""" return _coefficient.DeltaCoefficient_Weight(self) + Weight = _swig_new_instance_method(_coefficient.DeltaCoefficient_Weight) def GetDeltaCenter(self, center): r"""GetDeltaCenter(DeltaCoefficient self, Vector center)""" return _coefficient.DeltaCoefficient_GetDeltaCenter(self, center) + GetDeltaCenter = _swig_new_instance_method(_coefficient.DeltaCoefficient_GetDeltaCenter) def EvalDelta(self, T, ip): r"""EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DeltaCoefficient_EvalDelta(self, T, ip) + EvalDelta = _swig_new_instance_method(_coefficient.DeltaCoefficient_EvalDelta) def Eval(self, T, ip): r"""Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DeltaCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.DeltaCoefficient_Eval) __swig_destroy__ = _coefficient.delete_DeltaCoefficient # Register DeltaCoefficient in _coefficient: @@ -341,6 +368,7 @@ def __init__(self, _c, attr): def Eval(self, T, ip): r"""Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.RestrictedCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.RestrictedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_RestrictedCoefficient # Register RestrictedCoefficient in _coefficient: @@ -358,14 +386,17 @@ def __init__(self, *args, **kwargs): def SetTime(self, t): r"""SetTime(VectorCoefficient self, double t)""" return _coefficient.VectorCoefficient_SetTime(self, t) + SetTime = _swig_new_instance_method(_coefficient.VectorCoefficient_SetTime) def GetTime(self): r"""GetTime(VectorCoefficient self) -> double""" return _coefficient.VectorCoefficient_GetTime(self) + GetTime = _swig_new_instance_method(_coefficient.VectorCoefficient_GetTime) def GetVDim(self): r"""GetVDim(VectorCoefficient self) -> int""" return _coefficient.VectorCoefficient_GetVDim(self) + GetVDim = _swig_new_instance_method(_coefficient.VectorCoefficient_GetVDim) def Eval(self, *args): r""" @@ -373,6 +404,7 @@ def Eval(self, *args): Eval(VectorCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorCoefficient # Register VectorCoefficient in _coefficient: @@ -410,6 +442,12 @@ def Eval(self, *args): Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorConstantCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorConstantCoefficient_Eval) + + def GetVec(self): + r"""GetVec(VectorConstantCoefficient self) -> Vector""" + return _coefficient.VectorConstantCoefficient_GetVec(self) + GetVec = _swig_new_instance_method(_coefficient.VectorConstantCoefficient_GetVec) __swig_destroy__ = _coefficient.delete_VectorConstantCoefficient # Register VectorConstantCoefficient in _coefficient: @@ -435,6 +473,7 @@ def Eval(self, *args): Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorFunctionCoefficient # Register VectorFunctionCoefficient in _coefficient: @@ -453,10 +492,12 @@ def __init__(self, dim): def GetCoeff(self, i): r"""GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient""" return _coefficient.VectorArrayCoefficient_GetCoeff(self, i) + GetCoeff = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_GetCoeff) def GetCoeffs(self): r"""GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **""" return _coefficient.VectorArrayCoefficient_GetCoeffs(self) + GetCoeffs = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_GetCoeffs) def Set(self, i, c, own=True): r"""Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)""" @@ -475,6 +516,7 @@ def Eval(self, *args): Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorArrayCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorArrayCoefficient # Register VectorArrayCoefficient in _coefficient: @@ -496,10 +538,12 @@ def __init__(self, *args): def SetGridFunction(self, gf): r"""SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.VectorGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.VectorGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_GetGridFunction) def Eval(self, *args): r""" @@ -507,6 +551,7 @@ def Eval(self, *args): Eval(VectorGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorGridFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorGridFunctionCoefficient # Register VectorGridFunctionCoefficient in _coefficient: @@ -525,10 +570,12 @@ def __init__(self, gf): def SetGridFunction(self, gf): r"""SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.GradientGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.GradientGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_GetGridFunction) def Eval(self, *args): r""" @@ -536,6 +583,7 @@ def Eval(self, *args): Eval(GradientGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.GradientGridFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_GradientGridFunctionCoefficient # Register GradientGridFunctionCoefficient in _coefficient: @@ -553,10 +601,12 @@ def __init__(self, *args, **kwargs): def SetGridFunction(self, gf): r"""SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.CurlGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.CurlGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_GetGridFunction) def Eval(self, *args): r""" @@ -565,6 +615,7 @@ def Eval(self, *args): Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.CurlGridFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_CurlGridFunctionCoefficient # Register CurlGridFunctionCoefficient in _coefficient: @@ -583,14 +634,17 @@ def __init__(self, gf): def SetGridFunction(self, gf): r"""SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.DivergenceGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.DivergenceGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_GetGridFunction) def Eval(self, T, ip): r"""Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DivergenceGridFunctionCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_DivergenceGridFunctionCoefficient # Register DivergenceGridFunctionCoefficient in _coefficient: @@ -615,30 +669,37 @@ def __init__(self, *args): def SetDeltaCoefficient(self, _d): r"""SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)""" return _coefficient.VectorDeltaCoefficient_SetDeltaCoefficient(self, _d) + SetDeltaCoefficient = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDeltaCoefficient) def GetDeltaCoefficient(self): r"""GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient""" return _coefficient.VectorDeltaCoefficient_GetDeltaCoefficient(self) + GetDeltaCoefficient = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_GetDeltaCoefficient) def SetScale(self, s): r"""SetScale(VectorDeltaCoefficient self, double s)""" return _coefficient.VectorDeltaCoefficient_SetScale(self, s) + SetScale = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetScale) def SetDirection(self, _d): r"""SetDirection(VectorDeltaCoefficient self, Vector _d)""" return _coefficient.VectorDeltaCoefficient_SetDirection(self, _d) + SetDirection = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDirection) def SetDeltaCenter(self, center): r"""SetDeltaCenter(VectorDeltaCoefficient self, Vector center)""" return _coefficient.VectorDeltaCoefficient_SetDeltaCenter(self, center) + SetDeltaCenter = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDeltaCenter) def GetDeltaCenter(self, center): r"""GetDeltaCenter(VectorDeltaCoefficient self, Vector center)""" return _coefficient.VectorDeltaCoefficient_GetDeltaCenter(self, center) + GetDeltaCenter = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_GetDeltaCenter) def EvalDelta(self, V, T, ip): r"""EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.VectorDeltaCoefficient_EvalDelta(self, V, T, ip) + EvalDelta = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_EvalDelta) def Eval(self, *args): r""" @@ -647,6 +708,7 @@ def Eval(self, *args): Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorDeltaCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorDeltaCoefficient # Register VectorDeltaCoefficient in _coefficient: @@ -673,6 +735,7 @@ def Eval(self, *args): Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorRestrictedCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorRestrictedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorRestrictedCoefficient # Register VectorRestrictedCoefficient in _coefficient: @@ -690,26 +753,32 @@ def __init__(self, *args, **kwargs): def SetTime(self, t): r"""SetTime(MatrixCoefficient self, double t)""" return _coefficient.MatrixCoefficient_SetTime(self, t) + SetTime = _swig_new_instance_method(_coefficient.MatrixCoefficient_SetTime) def GetTime(self): r"""GetTime(MatrixCoefficient self) -> double""" return _coefficient.MatrixCoefficient_GetTime(self) + GetTime = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetTime) def GetHeight(self): r"""GetHeight(MatrixCoefficient self) -> int""" return _coefficient.MatrixCoefficient_GetHeight(self) + GetHeight = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetHeight) def GetWidth(self): r"""GetWidth(MatrixCoefficient self) -> int""" return _coefficient.MatrixCoefficient_GetWidth(self) + GetWidth = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetWidth) def GetVDim(self): r"""GetVDim(MatrixCoefficient self) -> int""" return _coefficient.MatrixCoefficient_GetVDim(self) + GetVDim = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetVDim) def Eval(self, K, T, ip): r"""Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixCoefficient_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixCoefficient # Register MatrixCoefficient in _coefficient: @@ -747,6 +816,7 @@ def Eval(self, *args): Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.MatrixConstantCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.MatrixConstantCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixConstantCoefficient # Register MatrixConstantCoefficient in _coefficient: @@ -769,6 +839,7 @@ def __init__(self, *args): def Eval(self, K, T, ip): r"""Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixFunctionCoefficient_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixFunctionCoefficient # Register MatrixFunctionCoefficient in _coefficient: @@ -787,6 +858,7 @@ def __init__(self, dim): def GetCoeff(self, i, j): r"""GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient""" return _coefficient.MatrixArrayCoefficient_GetCoeff(self, i, j) + GetCoeff = _swig_new_instance_method(_coefficient.MatrixArrayCoefficient_GetCoeff) def Set(self, i, j, c, own=True): r"""Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)""" @@ -803,6 +875,7 @@ def Eval(self, *args): Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.MatrixArrayCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.MatrixArrayCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixArrayCoefficient # Register MatrixArrayCoefficient in _coefficient: @@ -826,6 +899,7 @@ def __init__(self, mc, attr): def Eval(self, K, T, ip): r"""Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixRestrictedCoefficient_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixRestrictedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixRestrictedCoefficient # Register MatrixRestrictedCoefficient in _coefficient: @@ -844,6 +918,7 @@ def __init__(self, A, B, _alpha=1.0, _beta=1.0): def Eval(self, T, ip): r"""Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.SumCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.SumCoefficient_Eval) __swig_destroy__ = _coefficient.delete_SumCoefficient # Register SumCoefficient in _coefficient: @@ -862,6 +937,7 @@ def __init__(self, A, B): def Eval(self, T, ip): r"""Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.ProductCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.ProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ProductCoefficient # Register ProductCoefficient in _coefficient: @@ -880,6 +956,7 @@ def __init__(self, A, _p): def Eval(self, T, ip): r"""Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.PowerCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.PowerCoefficient_Eval) __swig_destroy__ = _coefficient.delete_PowerCoefficient # Register PowerCoefficient in _coefficient: @@ -898,6 +975,7 @@ def __init__(self, A, B): def Eval(self, T, ip): r"""Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.InnerProductCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.InnerProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_InnerProductCoefficient # Register InnerProductCoefficient in _coefficient: @@ -916,6 +994,7 @@ def __init__(self, A, B): def Eval(self, T, ip): r"""Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.VectorRotProductCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.VectorRotProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorRotProductCoefficient # Register VectorRotProductCoefficient in _coefficient: @@ -934,6 +1013,7 @@ def __init__(self, A): def Eval(self, T, ip): r"""Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DeterminantCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.DeterminantCoefficient_Eval) __swig_destroy__ = _coefficient.delete_DeterminantCoefficient # Register DeterminantCoefficient in _coefficient: @@ -955,6 +1035,7 @@ def Eval(self, *args): Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorSumCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorSumCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorSumCoefficient # Register VectorSumCoefficient in _coefficient: @@ -976,6 +1057,7 @@ def Eval(self, *args): Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.ScalarVectorProductCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ScalarVectorProductCoefficient # Register ScalarVectorProductCoefficient in _coefficient: @@ -997,6 +1079,7 @@ def Eval(self, *args): Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorCrossProductCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorCrossProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorCrossProductCoefficient # Register VectorCrossProductCoefficient in _coefficient: @@ -1018,6 +1101,7 @@ def Eval(self, *args): Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.MatVecCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.MatVecCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatVecCoefficient # Register MatVecCoefficient in _coefficient: @@ -1036,6 +1120,7 @@ def __init__(self, d): def Eval(self, M, T, ip): r"""Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.IdentityMatrixCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.IdentityMatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_IdentityMatrixCoefficient # Register IdentityMatrixCoefficient in _coefficient: @@ -1054,6 +1139,7 @@ def __init__(self, A, B, _alpha=1.0, _beta=1.0): def Eval(self, M, T, ip): r"""Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixSumCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixSumCoefficient # Register MatrixSumCoefficient in _coefficient: @@ -1072,6 +1158,7 @@ def __init__(self, A, B): def Eval(self, M, T, ip): r"""Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.ScalarMatrixProductCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ScalarMatrixProductCoefficient # Register ScalarMatrixProductCoefficient in _coefficient: @@ -1090,6 +1177,7 @@ def __init__(self, A): def Eval(self, M, T, ip): r"""Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.TransposeMatrixCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.TransposeMatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_TransposeMatrixCoefficient # Register TransposeMatrixCoefficient in _coefficient: @@ -1108,6 +1196,7 @@ def __init__(self, A): def Eval(self, M, T, ip): r"""Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.InverseMatrixCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.InverseMatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_InverseMatrixCoefficient # Register InverseMatrixCoefficient in _coefficient: @@ -1126,6 +1215,7 @@ def __init__(self, A, B): def Eval(self, M, T, ip): r"""Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.OuterProductCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.OuterProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_OuterProductCoefficient # Register OuterProductCoefficient in _coefficient: @@ -1138,6 +1228,7 @@ def ComputeLpNorm(*args): ComputeLpNorm(double p, VectorCoefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double """ return _coefficient.ComputeLpNorm(*args) +ComputeLpNorm = _coefficient.ComputeLpNorm def ComputeGlobalLpNorm(*args): r""" @@ -1145,18 +1236,22 @@ def ComputeGlobalLpNorm(*args): ComputeGlobalLpNorm(double p, VectorCoefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double """ return _coefficient.ComputeGlobalLpNorm(*args) +ComputeGlobalLpNorm = _coefficient.ComputeGlobalLpNorm def fake_func(x): r"""fake_func(Vector x) -> double""" return _coefficient.fake_func(x) +fake_func = _coefficient.fake_func def fake_func_vec(x, Ht): r"""fake_func_vec(Vector x, Vector Ht)""" return _coefficient.fake_func_vec(x, Ht) +fake_func_vec = _coefficient.fake_func_vec def fake_func_mat(x, Kt): r"""fake_func_mat(Vector x, DenseMatrix Kt)""" return _coefficient.fake_func_mat(x, Kt) +fake_func_mat = _coefficient.fake_func_mat class PyCoefficientBase(FunctionCoefficient): r"""Proxy of C++ mfem::PyCoefficientBase class.""" @@ -1174,14 +1269,17 @@ def __init__(self, tdep): def Eval(self, T, ip): r"""Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.PyCoefficientBase_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.PyCoefficientBase_Eval) def _EvalPy(self, arg0): r"""_EvalPy(PyCoefficientBase self, Vector arg0) -> double""" return _coefficient.PyCoefficientBase__EvalPy(self, arg0) + _EvalPy = _swig_new_instance_method(_coefficient.PyCoefficientBase__EvalPy) def _EvalPyT(self, arg0, arg1): r"""_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double""" return _coefficient.PyCoefficientBase__EvalPyT(self, arg0, arg1) + _EvalPyT = _swig_new_instance_method(_coefficient.PyCoefficientBase__EvalPyT) __swig_destroy__ = _coefficient.delete_PyCoefficientBase def __disown__(self): self.this.disown() @@ -1211,14 +1309,17 @@ def Eval(self, *args): Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorPyCoefficientBase_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase_Eval) def _EvalPy(self, arg0, arg1): r"""_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)""" return _coefficient.VectorPyCoefficientBase__EvalPy(self, arg0, arg1) + _EvalPy = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase__EvalPy) def _EvalPyT(self, arg0, arg1, arg2): r"""_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)""" return _coefficient.VectorPyCoefficientBase__EvalPyT(self, arg0, arg1, arg2) + _EvalPyT = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase__EvalPyT) __swig_destroy__ = _coefficient.delete_VectorPyCoefficientBase def __disown__(self): self.this.disown() @@ -1245,14 +1346,17 @@ def __init__(self, dim, tdep): def Eval(self, K, T, ip): r"""Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixPyCoefficientBase_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase_Eval) def _EvalPy(self, arg0, arg1): r"""_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)""" return _coefficient.MatrixPyCoefficientBase__EvalPy(self, arg0, arg1) + _EvalPy = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase__EvalPy) def _EvalPyT(self, arg0, arg1, arg2): r"""_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)""" return _coefficient.MatrixPyCoefficientBase__EvalPyT(self, arg0, arg1, arg2) + _EvalPyT = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase__EvalPyT) __swig_destroy__ = _coefficient.delete_MatrixPyCoefficientBase def __disown__(self): self.this.disown() @@ -1318,7 +1422,7 @@ def _EvalPy(self, x, K): K.Assign(k) def EvalValue(self, x): - return np.array([[0,0,0], [0,0,0] [0,0,0]]) + return np.array([[0,0,0], [0,0,0], [0,0,0]]) class MatrixPyCoefficientT(MatrixPyCoefficientBase): def __init__(self, dim): @@ -1329,7 +1433,7 @@ def _EvalPyT(self, x, t, K): K.Assign(k) def EvalValue(self, x, t): - return np.array([[0.0,0.0,0.0], [0.0,0.0,0.0] [0.0,0.0,0.0]]) + return np.array([[0.0,0.0,0.0], [0.0,0.0,0.0], [0.0,0.0,0.0]]) diff --git a/mfem/_par/coefficient_wrap.cxx b/mfem/_par/coefficient_wrap.cxx index be954e5a..90433d8a 100644 --- a/mfem/_par/coefficient_wrap.cxx +++ b/mfem/_par/coefficient_wrap.cxx @@ -7287,6 +7287,41 @@ SWIGINTERN PyObject *_wrap_VectorConstantCoefficient_Eval(PyObject *self, PyObje } +SWIGINTERN PyObject *_wrap_VectorConstantCoefficient_GetVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConstantCoefficient *arg1 = (mfem::VectorConstantCoefficient *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConstantCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConstantCoefficient_GetVec" "', argument " "1"" of type '" "mfem::VectorConstantCoefficient *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConstantCoefficient * >(argp1); + { + try { + result = (mfem::Vector *) &(arg1)->GetVec(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_VectorConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorConstantCoefficient *arg1 = (mfem::VectorConstantCoefficient *) 0 ; @@ -18397,6 +18432,7 @@ SWIGINTERN PyObject *MatrixPyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(s static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "Coefficient_SetTime(Coefficient self, double t)"}, { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "Coefficient_GetTime(Coefficient self) -> double"}, { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" @@ -18492,6 +18528,7 @@ static PyMethodDef SwigMethods[] = { "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" ""}, + { "VectorConstantCoefficient_GetVec", _wrap_VectorConstantCoefficient_GetVec, METH_O, "VectorConstantCoefficient_GetVec(VectorConstantCoefficient self) -> Vector"}, { "delete_VectorConstantCoefficient", _wrap_delete_VectorConstantCoefficient, METH_O, "delete_VectorConstantCoefficient(VectorConstantCoefficient self)"}, { "VectorConstantCoefficient_swigregister", VectorConstantCoefficient_swigregister, METH_O, NULL}, { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18763,6 +18800,371 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "SetTime(Coefficient self, double t)"}, + { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "GetTime(Coefficient self) -> double"}, + { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" + "Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip) -> double\n" + "Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip, double t) -> double\n" + ""}, + { "delete_Coefficient", _wrap_delete_Coefficient, METH_O, "delete_Coefficient(Coefficient self)"}, + { "Coefficient_swigregister", Coefficient_swigregister, METH_O, NULL}, + { "ConstantCoefficient_constant_set", _wrap_ConstantCoefficient_constant_set, METH_VARARGS, "ConstantCoefficient_constant_set(ConstantCoefficient self, double constant)"}, + { "ConstantCoefficient_constant_get", _wrap_ConstantCoefficient_constant_get, METH_O, "ConstantCoefficient_constant_get(ConstantCoefficient self) -> double"}, + { "new_ConstantCoefficient", _wrap_new_ConstantCoefficient, METH_VARARGS, "ConstantCoefficient(double c=1.0)"}, + { "ConstantCoefficient_Eval", _wrap_ConstantCoefficient_Eval, METH_VARARGS, "Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_ConstantCoefficient", _wrap_delete_ConstantCoefficient, METH_O, "delete_ConstantCoefficient(ConstantCoefficient self)"}, + { "ConstantCoefficient_swigregister", ConstantCoefficient_swigregister, METH_O, NULL}, + { "ConstantCoefficient_swiginit", ConstantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_PWConstCoefficient", _wrap_new_PWConstCoefficient, METH_VARARGS, "\n" + "PWConstCoefficient(int NumOfSubD=0)\n" + "new_PWConstCoefficient(Vector c) -> PWConstCoefficient\n" + ""}, + { "PWConstCoefficient_UpdateConstants", _wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS, "UpdateConstants(PWConstCoefficient self, Vector c)"}, + { "PWConstCoefficient___call__", _wrap_PWConstCoefficient___call__, METH_VARARGS, "__call__(PWConstCoefficient self, int i) -> double &"}, + { "PWConstCoefficient_GetNConst", _wrap_PWConstCoefficient_GetNConst, METH_O, "GetNConst(PWConstCoefficient self) -> int"}, + { "PWConstCoefficient_Eval", _wrap_PWConstCoefficient_Eval, METH_VARARGS, "Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_PWConstCoefficient", _wrap_delete_PWConstCoefficient, METH_O, "delete_PWConstCoefficient(PWConstCoefficient self)"}, + { "PWConstCoefficient_swigregister", PWConstCoefficient_swigregister, METH_O, NULL}, + { "PWConstCoefficient_swiginit", PWConstCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_FunctionCoefficient", _wrap_new_FunctionCoefficient, METH_VARARGS, "\n" + "FunctionCoefficient(double (*)(mfem::Vector const &) f)\n" + "FunctionCoefficient(double (*)(mfem::Vector const &,double) tdf)\n" + "FunctionCoefficient(double (*)(mfem::Vector &) f)\n" + "new_FunctionCoefficient(double (*)(mfem::Vector &,double) tdf) -> FunctionCoefficient\n" + ""}, + { "FunctionCoefficient_Eval", _wrap_FunctionCoefficient_Eval, METH_VARARGS, "Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_FunctionCoefficient", _wrap_delete_FunctionCoefficient, METH_O, "delete_FunctionCoefficient(FunctionCoefficient self)"}, + { "FunctionCoefficient_swigregister", FunctionCoefficient_swigregister, METH_O, NULL}, + { "FunctionCoefficient_swiginit", FunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_GridFunctionCoefficient", _wrap_new_GridFunctionCoefficient, METH_VARARGS, "\n" + "GridFunctionCoefficient()\n" + "GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1)\n" + ""}, + { "GridFunctionCoefficient_SetGridFunction", _wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GridFunctionCoefficient_GetGridFunction", _wrap_GridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "GridFunctionCoefficient_Eval", _wrap_GridFunctionCoefficient_Eval, METH_VARARGS, "Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_GridFunctionCoefficient", _wrap_delete_GridFunctionCoefficient, METH_O, "delete_GridFunctionCoefficient(GridFunctionCoefficient self)"}, + { "GridFunctionCoefficient_swigregister", GridFunctionCoefficient_swigregister, METH_O, NULL}, + { "GridFunctionCoefficient_swiginit", GridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_TransformedCoefficient", _wrap_new_TransformedCoefficient, METH_VARARGS, "\n" + "TransformedCoefficient(Coefficient q, double (*)(double) F)\n" + "new_TransformedCoefficient(Coefficient q1, Coefficient q2, double (*)(double,double) F) -> TransformedCoefficient\n" + ""}, + { "TransformedCoefficient_Eval", _wrap_TransformedCoefficient_Eval, METH_VARARGS, "Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_TransformedCoefficient", _wrap_delete_TransformedCoefficient, METH_O, "delete_TransformedCoefficient(TransformedCoefficient self)"}, + { "TransformedCoefficient_swigregister", TransformedCoefficient_swigregister, METH_O, NULL}, + { "TransformedCoefficient_swiginit", TransformedCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_DeltaCoefficient", _wrap_new_DeltaCoefficient, METH_VARARGS, "\n" + "DeltaCoefficient()\n" + "DeltaCoefficient(double x, double s)\n" + "DeltaCoefficient(double x, double y, double s)\n" + "new_DeltaCoefficient(double x, double y, double z, double s) -> DeltaCoefficient\n" + ""}, + { "DeltaCoefficient_SetDeltaCenter", _wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_SetScale", _wrap_DeltaCoefficient_SetScale, METH_VARARGS, "SetScale(DeltaCoefficient self, double _s)"}, + { "DeltaCoefficient_SetFunction", _wrap_DeltaCoefficient_SetFunction, METH_VARARGS, "SetFunction(DeltaCoefficient self, double (*)(double) f)"}, + { "DeltaCoefficient_SetTol", _wrap_DeltaCoefficient_SetTol, METH_VARARGS, "SetTol(DeltaCoefficient self, double _tol)"}, + { "DeltaCoefficient_SetWeight", _wrap_DeltaCoefficient_SetWeight, METH_VARARGS, "SetWeight(DeltaCoefficient self, Coefficient w)"}, + { "DeltaCoefficient_Center", _wrap_DeltaCoefficient_Center, METH_O, "Center(DeltaCoefficient self) -> double const *"}, + { "DeltaCoefficient_Scale", _wrap_DeltaCoefficient_Scale, METH_O, "Scale(DeltaCoefficient self) -> double"}, + { "DeltaCoefficient_Tol", _wrap_DeltaCoefficient_Tol, METH_O, "Tol(DeltaCoefficient self) -> double"}, + { "DeltaCoefficient_Weight", _wrap_DeltaCoefficient_Weight, METH_O, "Weight(DeltaCoefficient self) -> Coefficient"}, + { "DeltaCoefficient_GetDeltaCenter", _wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_EvalDelta", _wrap_DeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_Eval", _wrap_DeltaCoefficient_Eval, METH_VARARGS, "Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_DeltaCoefficient", _wrap_delete_DeltaCoefficient, METH_O, "delete_DeltaCoefficient(DeltaCoefficient self)"}, + { "DeltaCoefficient_swigregister", DeltaCoefficient_swigregister, METH_O, NULL}, + { "DeltaCoefficient_swiginit", DeltaCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_RestrictedCoefficient", _wrap_new_RestrictedCoefficient, METH_VARARGS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, + { "RestrictedCoefficient_Eval", _wrap_RestrictedCoefficient_Eval, METH_VARARGS, "Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_RestrictedCoefficient", _wrap_delete_RestrictedCoefficient, METH_O, "delete_RestrictedCoefficient(RestrictedCoefficient self)"}, + { "RestrictedCoefficient_swigregister", RestrictedCoefficient_swigregister, METH_O, NULL}, + { "RestrictedCoefficient_swiginit", RestrictedCoefficient_swiginit, METH_VARARGS, NULL}, + { "VectorCoefficient_SetTime", _wrap_VectorCoefficient_SetTime, METH_VARARGS, "SetTime(VectorCoefficient self, double t)"}, + { "VectorCoefficient_GetTime", _wrap_VectorCoefficient_GetTime, METH_O, "GetTime(VectorCoefficient self) -> double"}, + { "VectorCoefficient_GetVDim", _wrap_VectorCoefficient_GetVDim, METH_O, "GetVDim(VectorCoefficient self) -> int"}, + { "VectorCoefficient_Eval", _wrap_VectorCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorCoefficient", _wrap_delete_VectorCoefficient, METH_O, "delete_VectorCoefficient(VectorCoefficient self)"}, + { "VectorCoefficient_swigregister", VectorCoefficient_swigregister, METH_O, NULL}, + { "new_VectorConstantCoefficient", _wrap_new_VectorConstantCoefficient, METH_O, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, + { "VectorConstantCoefficient_Eval", _wrap_VectorConstantCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "VectorConstantCoefficient_GetVec", _wrap_VectorConstantCoefficient_GetVec, METH_O, "GetVec(VectorConstantCoefficient self) -> Vector"}, + { "delete_VectorConstantCoefficient", _wrap_delete_VectorConstantCoefficient, METH_O, "delete_VectorConstantCoefficient(VectorConstantCoefficient self)"}, + { "VectorConstantCoefficient_swigregister", VectorConstantCoefficient_swigregister, METH_O, NULL}, + { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorFunctionCoefficient", _wrap_new_VectorFunctionCoefficient, METH_VARARGS, "\n" + "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::Vector &) F, Coefficient q=None)\n" + "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None)\n" + ""}, + { "VectorFunctionCoefficient_Eval", _wrap_VectorFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_VectorFunctionCoefficient", _wrap_delete_VectorFunctionCoefficient, METH_O, "delete_VectorFunctionCoefficient(VectorFunctionCoefficient self)"}, + { "VectorFunctionCoefficient_swigregister", VectorFunctionCoefficient_swigregister, METH_O, NULL}, + { "VectorFunctionCoefficient_swiginit", VectorFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorArrayCoefficient", _wrap_new_VectorArrayCoefficient, METH_O, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, + { "VectorArrayCoefficient_GetCoeff", _wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, + { "VectorArrayCoefficient_GetCoeffs", _wrap_VectorArrayCoefficient_GetCoeffs, METH_O, "GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **"}, + { "VectorArrayCoefficient_Set", _wrap_VectorArrayCoefficient_Set, METH_VARARGS, "Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, + { "VectorArrayCoefficient_Eval", _wrap_VectorArrayCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorArrayCoefficient self, int i, ElementTransformation T, IntegrationPoint ip) -> double\n" + "Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorArrayCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_VectorArrayCoefficient", _wrap_delete_VectorArrayCoefficient, METH_O, "delete_VectorArrayCoefficient(VectorArrayCoefficient self)"}, + { "VectorArrayCoefficient_swigregister", VectorArrayCoefficient_swigregister, METH_O, NULL}, + { "VectorArrayCoefficient_swiginit", VectorArrayCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorGridFunctionCoefficient", _wrap_new_VectorGridFunctionCoefficient, METH_VARARGS, "\n" + "VectorGridFunctionCoefficient()\n" + "new_VectorGridFunctionCoefficient(mfem::GridFunction * gf) -> VectorGridFunctionCoefficient\n" + ""}, + { "VectorGridFunctionCoefficient_SetGridFunction", _wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "VectorGridFunctionCoefficient_GetGridFunction", _wrap_VectorGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "VectorGridFunctionCoefficient_Eval", _wrap_VectorGridFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorGridFunctionCoefficient", _wrap_delete_VectorGridFunctionCoefficient, METH_O, "delete_VectorGridFunctionCoefficient(VectorGridFunctionCoefficient self)"}, + { "VectorGridFunctionCoefficient_swigregister", VectorGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "VectorGridFunctionCoefficient_swiginit", VectorGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_GradientGridFunctionCoefficient", _wrap_new_GradientGridFunctionCoefficient, METH_O, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, + { "GradientGridFunctionCoefficient_SetGridFunction", _wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GradientGridFunctionCoefficient_GetGridFunction", _wrap_GradientGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "GradientGridFunctionCoefficient_Eval", _wrap_GradientGridFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(GradientGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(GradientGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_GradientGridFunctionCoefficient", _wrap_delete_GradientGridFunctionCoefficient, METH_O, "delete_GradientGridFunctionCoefficient(GradientGridFunctionCoefficient self)"}, + { "GradientGridFunctionCoefficient_swigregister", GradientGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "GradientGridFunctionCoefficient_swiginit", GradientGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "CurlGridFunctionCoefficient_SetGridFunction", _wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "CurlGridFunctionCoefficient_GetGridFunction", _wrap_CurlGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "CurlGridFunctionCoefficient_Eval", _wrap_CurlGridFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(CurlGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_CurlGridFunctionCoefficient", _wrap_delete_CurlGridFunctionCoefficient, METH_O, "delete_CurlGridFunctionCoefficient(CurlGridFunctionCoefficient self)"}, + { "CurlGridFunctionCoefficient_swigregister", CurlGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "new_DivergenceGridFunctionCoefficient", _wrap_new_DivergenceGridFunctionCoefficient, METH_O, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, + { "DivergenceGridFunctionCoefficient_SetGridFunction", _wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "DivergenceGridFunctionCoefficient_GetGridFunction", _wrap_DivergenceGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "DivergenceGridFunctionCoefficient_Eval", _wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS, "Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_DivergenceGridFunctionCoefficient", _wrap_delete_DivergenceGridFunctionCoefficient, METH_O, "delete_DivergenceGridFunctionCoefficient(DivergenceGridFunctionCoefficient self)"}, + { "DivergenceGridFunctionCoefficient_swigregister", DivergenceGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "DivergenceGridFunctionCoefficient_swiginit", DivergenceGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorDeltaCoefficient", _wrap_new_VectorDeltaCoefficient, METH_VARARGS, "\n" + "VectorDeltaCoefficient(int _vdim)\n" + "VectorDeltaCoefficient(Vector _dir)\n" + "VectorDeltaCoefficient(Vector _dir, double x, double s)\n" + "VectorDeltaCoefficient(Vector _dir, double x, double y, double s)\n" + "new_VectorDeltaCoefficient(Vector _dir, double x, double y, double z, double s) -> VectorDeltaCoefficient\n" + ""}, + { "VectorDeltaCoefficient_SetDeltaCoefficient", _wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS, "SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, + { "VectorDeltaCoefficient_GetDeltaCoefficient", _wrap_VectorDeltaCoefficient_GetDeltaCoefficient, METH_O, "GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient"}, + { "VectorDeltaCoefficient_SetScale", _wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS, "SetScale(VectorDeltaCoefficient self, double s)"}, + { "VectorDeltaCoefficient_SetDirection", _wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS, "SetDirection(VectorDeltaCoefficient self, Vector _d)"}, + { "VectorDeltaCoefficient_SetDeltaCenter", _wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_GetDeltaCenter", _wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_EvalDelta", _wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, + { "VectorDeltaCoefficient_Eval", _wrap_VectorDeltaCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorDeltaCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_VectorDeltaCoefficient", _wrap_delete_VectorDeltaCoefficient, METH_O, "delete_VectorDeltaCoefficient(VectorDeltaCoefficient self)"}, + { "VectorDeltaCoefficient_swigregister", VectorDeltaCoefficient_swigregister, METH_O, NULL}, + { "VectorDeltaCoefficient_swiginit", VectorDeltaCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorRestrictedCoefficient", _wrap_new_VectorRestrictedCoefficient, METH_VARARGS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, + { "VectorRestrictedCoefficient_Eval", _wrap_VectorRestrictedCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorRestrictedCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorRestrictedCoefficient", _wrap_delete_VectorRestrictedCoefficient, METH_O, "delete_VectorRestrictedCoefficient(VectorRestrictedCoefficient self)"}, + { "VectorRestrictedCoefficient_swigregister", VectorRestrictedCoefficient_swigregister, METH_O, NULL}, + { "VectorRestrictedCoefficient_swiginit", VectorRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, + { "MatrixCoefficient_SetTime", _wrap_MatrixCoefficient_SetTime, METH_VARARGS, "SetTime(MatrixCoefficient self, double t)"}, + { "MatrixCoefficient_GetTime", _wrap_MatrixCoefficient_GetTime, METH_O, "GetTime(MatrixCoefficient self) -> double"}, + { "MatrixCoefficient_GetHeight", _wrap_MatrixCoefficient_GetHeight, METH_O, "GetHeight(MatrixCoefficient self) -> int"}, + { "MatrixCoefficient_GetWidth", _wrap_MatrixCoefficient_GetWidth, METH_O, "GetWidth(MatrixCoefficient self) -> int"}, + { "MatrixCoefficient_GetVDim", _wrap_MatrixCoefficient_GetVDim, METH_O, "GetVDim(MatrixCoefficient self) -> int"}, + { "MatrixCoefficient_Eval", _wrap_MatrixCoefficient_Eval, METH_VARARGS, "Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixCoefficient", _wrap_delete_MatrixCoefficient, METH_O, "delete_MatrixCoefficient(MatrixCoefficient self)"}, + { "MatrixCoefficient_swigregister", MatrixCoefficient_swigregister, METH_O, NULL}, + { "new_MatrixConstantCoefficient", _wrap_new_MatrixConstantCoefficient, METH_O, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, + { "MatrixConstantCoefficient_Eval", _wrap_MatrixConstantCoefficient_Eval, METH_VARARGS, "\n" + "Eval(MatrixConstantCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_MatrixConstantCoefficient", _wrap_delete_MatrixConstantCoefficient, METH_O, "delete_MatrixConstantCoefficient(MatrixConstantCoefficient self)"}, + { "MatrixConstantCoefficient_swigregister", MatrixConstantCoefficient_swigregister, METH_O, NULL}, + { "MatrixConstantCoefficient_swiginit", MatrixConstantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixFunctionCoefficient", _wrap_new_MatrixFunctionCoefficient, METH_VARARGS, "\n" + "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::DenseMatrix &) F, Coefficient q=None)\n" + "MatrixFunctionCoefficient(DenseMatrix m, Coefficient q)\n" + "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None)\n" + ""}, + { "MatrixFunctionCoefficient_Eval", _wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS, "Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixFunctionCoefficient", _wrap_delete_MatrixFunctionCoefficient, METH_O, "delete_MatrixFunctionCoefficient(MatrixFunctionCoefficient self)"}, + { "MatrixFunctionCoefficient_swigregister", MatrixFunctionCoefficient_swigregister, METH_O, NULL}, + { "MatrixFunctionCoefficient_swiginit", MatrixFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixArrayCoefficient", _wrap_new_MatrixArrayCoefficient, METH_O, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, + { "MatrixArrayCoefficient_GetCoeff", _wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, + { "MatrixArrayCoefficient_Set", _wrap_MatrixArrayCoefficient_Set, METH_VARARGS, "Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, + { "MatrixArrayCoefficient_Eval", _wrap_MatrixArrayCoefficient_Eval, METH_VARARGS, "\n" + "Eval(MatrixArrayCoefficient self, int i, int j, ElementTransformation T, IntegrationPoint ip) -> double\n" + "Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_MatrixArrayCoefficient", _wrap_delete_MatrixArrayCoefficient, METH_O, "delete_MatrixArrayCoefficient(MatrixArrayCoefficient self)"}, + { "MatrixArrayCoefficient_swigregister", MatrixArrayCoefficient_swigregister, METH_O, NULL}, + { "MatrixArrayCoefficient_swiginit", MatrixArrayCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixRestrictedCoefficient", _wrap_new_MatrixRestrictedCoefficient, METH_VARARGS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, + { "MatrixRestrictedCoefficient_Eval", _wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS, "Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixRestrictedCoefficient", _wrap_delete_MatrixRestrictedCoefficient, METH_O, "delete_MatrixRestrictedCoefficient(MatrixRestrictedCoefficient self)"}, + { "MatrixRestrictedCoefficient_swigregister", MatrixRestrictedCoefficient_swigregister, METH_O, NULL}, + { "MatrixRestrictedCoefficient_swiginit", MatrixRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_SumCoefficient", _wrap_new_SumCoefficient, METH_VARARGS, "SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "SumCoefficient_Eval", _wrap_SumCoefficient_Eval, METH_VARARGS, "Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_SumCoefficient", _wrap_delete_SumCoefficient, METH_O, "delete_SumCoefficient(SumCoefficient self)"}, + { "SumCoefficient_swigregister", SumCoefficient_swigregister, METH_O, NULL}, + { "SumCoefficient_swiginit", SumCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_ProductCoefficient", _wrap_new_ProductCoefficient, METH_VARARGS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, + { "ProductCoefficient_Eval", _wrap_ProductCoefficient_Eval, METH_VARARGS, "Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_ProductCoefficient", _wrap_delete_ProductCoefficient, METH_O, "delete_ProductCoefficient(ProductCoefficient self)"}, + { "ProductCoefficient_swigregister", ProductCoefficient_swigregister, METH_O, NULL}, + { "ProductCoefficient_swiginit", ProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_PowerCoefficient", _wrap_new_PowerCoefficient, METH_VARARGS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, + { "PowerCoefficient_Eval", _wrap_PowerCoefficient_Eval, METH_VARARGS, "Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_PowerCoefficient", _wrap_delete_PowerCoefficient, METH_O, "delete_PowerCoefficient(PowerCoefficient self)"}, + { "PowerCoefficient_swigregister", PowerCoefficient_swigregister, METH_O, NULL}, + { "PowerCoefficient_swiginit", PowerCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_InnerProductCoefficient", _wrap_new_InnerProductCoefficient, METH_VARARGS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, + { "InnerProductCoefficient_Eval", _wrap_InnerProductCoefficient_Eval, METH_VARARGS, "Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_InnerProductCoefficient", _wrap_delete_InnerProductCoefficient, METH_O, "delete_InnerProductCoefficient(InnerProductCoefficient self)"}, + { "InnerProductCoefficient_swigregister", InnerProductCoefficient_swigregister, METH_O, NULL}, + { "InnerProductCoefficient_swiginit", InnerProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorRotProductCoefficient", _wrap_new_VectorRotProductCoefficient, METH_VARARGS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, + { "VectorRotProductCoefficient_Eval", _wrap_VectorRotProductCoefficient_Eval, METH_VARARGS, "Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_VectorRotProductCoefficient", _wrap_delete_VectorRotProductCoefficient, METH_O, "delete_VectorRotProductCoefficient(VectorRotProductCoefficient self)"}, + { "VectorRotProductCoefficient_swigregister", VectorRotProductCoefficient_swigregister, METH_O, NULL}, + { "VectorRotProductCoefficient_swiginit", VectorRotProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_DeterminantCoefficient", _wrap_new_DeterminantCoefficient, METH_O, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, + { "DeterminantCoefficient_Eval", _wrap_DeterminantCoefficient_Eval, METH_VARARGS, "Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_DeterminantCoefficient", _wrap_delete_DeterminantCoefficient, METH_O, "delete_DeterminantCoefficient(DeterminantCoefficient self)"}, + { "DeterminantCoefficient_swigregister", DeterminantCoefficient_swigregister, METH_O, NULL}, + { "DeterminantCoefficient_swiginit", DeterminantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorSumCoefficient", _wrap_new_VectorSumCoefficient, METH_VARARGS, "VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "VectorSumCoefficient_Eval", _wrap_VectorSumCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorSumCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorSumCoefficient", _wrap_delete_VectorSumCoefficient, METH_O, "delete_VectorSumCoefficient(VectorSumCoefficient self)"}, + { "VectorSumCoefficient_swigregister", VectorSumCoefficient_swigregister, METH_O, NULL}, + { "VectorSumCoefficient_swiginit", VectorSumCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_ScalarVectorProductCoefficient", _wrap_new_ScalarVectorProductCoefficient, METH_VARARGS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, + { "ScalarVectorProductCoefficient_Eval", _wrap_ScalarVectorProductCoefficient_Eval, METH_VARARGS, "\n" + "Eval(ScalarVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_ScalarVectorProductCoefficient", _wrap_delete_ScalarVectorProductCoefficient, METH_O, "delete_ScalarVectorProductCoefficient(ScalarVectorProductCoefficient self)"}, + { "ScalarVectorProductCoefficient_swigregister", ScalarVectorProductCoefficient_swigregister, METH_O, NULL}, + { "ScalarVectorProductCoefficient_swiginit", ScalarVectorProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorCrossProductCoefficient", _wrap_new_VectorCrossProductCoefficient, METH_VARARGS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, + { "VectorCrossProductCoefficient_Eval", _wrap_VectorCrossProductCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorCrossProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorCrossProductCoefficient", _wrap_delete_VectorCrossProductCoefficient, METH_O, "delete_VectorCrossProductCoefficient(VectorCrossProductCoefficient self)"}, + { "VectorCrossProductCoefficient_swigregister", VectorCrossProductCoefficient_swigregister, METH_O, NULL}, + { "VectorCrossProductCoefficient_swiginit", VectorCrossProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatVecCoefficient", _wrap_new_MatVecCoefficient, METH_VARARGS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, + { "MatVecCoefficient_Eval", _wrap_MatVecCoefficient_Eval, METH_VARARGS, "\n" + "Eval(MatVecCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_MatVecCoefficient", _wrap_delete_MatVecCoefficient, METH_O, "delete_MatVecCoefficient(MatVecCoefficient self)"}, + { "MatVecCoefficient_swigregister", MatVecCoefficient_swigregister, METH_O, NULL}, + { "MatVecCoefficient_swiginit", MatVecCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_IdentityMatrixCoefficient", _wrap_new_IdentityMatrixCoefficient, METH_O, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, + { "IdentityMatrixCoefficient_Eval", _wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS, "Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_IdentityMatrixCoefficient", _wrap_delete_IdentityMatrixCoefficient, METH_O, "delete_IdentityMatrixCoefficient(IdentityMatrixCoefficient self)"}, + { "IdentityMatrixCoefficient_swigregister", IdentityMatrixCoefficient_swigregister, METH_O, NULL}, + { "IdentityMatrixCoefficient_swiginit", IdentityMatrixCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixSumCoefficient", _wrap_new_MatrixSumCoefficient, METH_VARARGS, "MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "MatrixSumCoefficient_Eval", _wrap_MatrixSumCoefficient_Eval, METH_VARARGS, "Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixSumCoefficient", _wrap_delete_MatrixSumCoefficient, METH_O, "delete_MatrixSumCoefficient(MatrixSumCoefficient self)"}, + { "MatrixSumCoefficient_swigregister", MatrixSumCoefficient_swigregister, METH_O, NULL}, + { "MatrixSumCoefficient_swiginit", MatrixSumCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_ScalarMatrixProductCoefficient", _wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, + { "ScalarMatrixProductCoefficient_Eval", _wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS, "Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_ScalarMatrixProductCoefficient", _wrap_delete_ScalarMatrixProductCoefficient, METH_O, "delete_ScalarMatrixProductCoefficient(ScalarMatrixProductCoefficient self)"}, + { "ScalarMatrixProductCoefficient_swigregister", ScalarMatrixProductCoefficient_swigregister, METH_O, NULL}, + { "ScalarMatrixProductCoefficient_swiginit", ScalarMatrixProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_TransposeMatrixCoefficient", _wrap_new_TransposeMatrixCoefficient, METH_O, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, + { "TransposeMatrixCoefficient_Eval", _wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS, "Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_TransposeMatrixCoefficient", _wrap_delete_TransposeMatrixCoefficient, METH_O, "delete_TransposeMatrixCoefficient(TransposeMatrixCoefficient self)"}, + { "TransposeMatrixCoefficient_swigregister", TransposeMatrixCoefficient_swigregister, METH_O, NULL}, + { "TransposeMatrixCoefficient_swiginit", TransposeMatrixCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_InverseMatrixCoefficient", _wrap_new_InverseMatrixCoefficient, METH_O, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, + { "InverseMatrixCoefficient_Eval", _wrap_InverseMatrixCoefficient_Eval, METH_VARARGS, "Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_InverseMatrixCoefficient", _wrap_delete_InverseMatrixCoefficient, METH_O, "delete_InverseMatrixCoefficient(InverseMatrixCoefficient self)"}, + { "InverseMatrixCoefficient_swigregister", InverseMatrixCoefficient_swigregister, METH_O, NULL}, + { "InverseMatrixCoefficient_swiginit", InverseMatrixCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_OuterProductCoefficient", _wrap_new_OuterProductCoefficient, METH_VARARGS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, + { "OuterProductCoefficient_Eval", _wrap_OuterProductCoefficient_Eval, METH_VARARGS, "Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_OuterProductCoefficient", _wrap_delete_OuterProductCoefficient, METH_O, "delete_OuterProductCoefficient(OuterProductCoefficient self)"}, + { "OuterProductCoefficient_swigregister", OuterProductCoefficient_swigregister, METH_O, NULL}, + { "OuterProductCoefficient_swiginit", OuterProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "ComputeLpNorm", _wrap_ComputeLpNorm, METH_VARARGS, "\n" + "ComputeLpNorm(double p, Coefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" + "ComputeLpNorm(double p, VectorCoefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" + ""}, + { "ComputeGlobalLpNorm", _wrap_ComputeGlobalLpNorm, METH_VARARGS, "\n" + "ComputeGlobalLpNorm(double p, Coefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double\n" + "ComputeGlobalLpNorm(double p, VectorCoefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double\n" + ""}, + { "fake_func", _wrap_fake_func, METH_O, "fake_func(Vector x) -> double"}, + { "fake_func_vec", _wrap_fake_func_vec, METH_VARARGS, "fake_func_vec(Vector x, Vector Ht)"}, + { "fake_func_mat", _wrap_fake_func_mat, METH_VARARGS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, + { "new_PyCoefficientBase", _wrap_new_PyCoefficientBase, METH_VARARGS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, + { "PyCoefficientBase_Eval", _wrap_PyCoefficientBase_Eval, METH_VARARGS, "Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PyCoefficientBase__EvalPy", _wrap_PyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, + { "PyCoefficientBase__EvalPyT", _wrap_PyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, + { "delete_PyCoefficientBase", _wrap_delete_PyCoefficientBase, METH_O, "delete_PyCoefficientBase(PyCoefficientBase self)"}, + { "disown_PyCoefficientBase", _wrap_disown_PyCoefficientBase, METH_O, NULL}, + { "PyCoefficientBase_swigregister", PyCoefficientBase_swigregister, METH_O, NULL}, + { "PyCoefficientBase_swiginit", PyCoefficientBase_swiginit, METH_VARARGS, NULL}, + { "new_VectorPyCoefficientBase", _wrap_new_VectorPyCoefficientBase, METH_VARARGS, "VectorPyCoefficientBase(int dim, int tdep, Coefficient q=None)"}, + { "VectorPyCoefficientBase_Eval", _wrap_VectorPyCoefficientBase_Eval, METH_VARARGS, "\n" + "Eval(VectorPyCoefficientBase self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "VectorPyCoefficientBase__EvalPy", _wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, + { "VectorPyCoefficientBase__EvalPyT", _wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, + { "delete_VectorPyCoefficientBase", _wrap_delete_VectorPyCoefficientBase, METH_O, "delete_VectorPyCoefficientBase(VectorPyCoefficientBase self)"}, + { "disown_VectorPyCoefficientBase", _wrap_disown_VectorPyCoefficientBase, METH_O, NULL}, + { "VectorPyCoefficientBase_swigregister", VectorPyCoefficientBase_swigregister, METH_O, NULL}, + { "VectorPyCoefficientBase_swiginit", VectorPyCoefficientBase_swiginit, METH_VARARGS, NULL}, + { "new_MatrixPyCoefficientBase", _wrap_new_MatrixPyCoefficientBase, METH_VARARGS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, + { "MatrixPyCoefficientBase_Eval", _wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS, "Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixPyCoefficientBase__EvalPy", _wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, + { "MatrixPyCoefficientBase__EvalPyT", _wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, + { "delete_MatrixPyCoefficientBase", _wrap_delete_MatrixPyCoefficientBase, METH_O, "delete_MatrixPyCoefficientBase(MatrixPyCoefficientBase self)"}, + { "disown_MatrixPyCoefficientBase", _wrap_disown_MatrixPyCoefficientBase, METH_O, NULL}, + { "MatrixPyCoefficientBase_swigregister", MatrixPyCoefficientBase_swigregister, METH_O, NULL}, + { "MatrixPyCoefficientBase_swiginit", MatrixPyCoefficientBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -20002,18 +20404,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); import_array(); diff --git a/mfem/_par/common_functions.py b/mfem/_par/common_functions.py index 37ee4ddc..bb6396f3 100644 --- a/mfem/_par/common_functions.py +++ b/mfem/_par/common_functions.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _common_functions.SWIG_PyInstanceMethod_New +_swig_new_static_method = _common_functions.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -86,6 +89,7 @@ def Transpose(*args): Transpose(mfem::SparseMatrix const & A) -> mfem::SparseMatrix * """ return _common_functions.Transpose(*args) +Transpose = _common_functions.Transpose def Mult(*args): r""" @@ -97,6 +101,7 @@ def Mult(*args): Mult(mfem::SparseMatrix const & A, mfem::DenseMatrix & B) -> mfem::DenseMatrix * """ return _common_functions.Mult(*args) +Mult = _common_functions.Mult def InnerProduct(*args): r""" @@ -106,6 +111,7 @@ def InnerProduct(*args): InnerProduct(mfem::HypreParVector * x, mfem::HypreParVector * y) -> double """ return _common_functions.InnerProduct(*args) +InnerProduct = _common_functions.InnerProduct def Add(*args): r""" @@ -119,6 +125,7 @@ def Add(*args): Add(double alpha, mfem::HypreParMatrix const & A, double beta, mfem::HypreParMatrix const & B) -> mfem::HypreParMatrix * """ return _common_functions.Add(*args) +Add = _common_functions.Add def RAP(*args): r""" @@ -130,5 +137,6 @@ def RAP(*args): RAP(mfem::HypreParMatrix const * Rt, mfem::HypreParMatrix const * A, mfem::HypreParMatrix const * P) -> mfem::HypreParMatrix * """ return _common_functions.RAP(*args) +RAP = _common_functions.RAP diff --git a/mfem/_par/common_functions_wrap.cxx b/mfem/_par/common_functions_wrap.cxx index e243c530..695e596c 100644 --- a/mfem/_par/common_functions_wrap.cxx +++ b/mfem/_par/common_functions_wrap.cxx @@ -5429,6 +5429,7 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Transpose", _wrap_Transpose, METH_VARARGS, "\n" "Transpose(mfem::Table const & A, mfem::Table & At, int _ncols_A=-1)\n" "Transpose(mfem::Table const & A) -> mfem::Table\n" @@ -5472,6 +5473,47 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Transpose", _wrap_Transpose, METH_VARARGS, "\n" + "Transpose(mfem::Table const & A, mfem::Table & At, int _ncols_A=-1)\n" + "Transpose(mfem::Table const & A) -> mfem::Table\n" + "Transpose(intArray A, mfem::Table & At, int _ncols_A=-1)\n" + "Transpose(mfem::BlockMatrix const & A) -> mfem::BlockMatrix\n" + "Transpose(mfem::SparseMatrix const & A) -> mfem::SparseMatrix *\n" + ""}, + { "Mult", _wrap_Mult, METH_VARARGS, "\n" + "Mult(mfem::Table const & A, mfem::Table const & B, mfem::Table & C)\n" + "Mult(mfem::Table const & A, mfem::Table const & B) -> mfem::Table\n" + "Mult(mfem::BlockMatrix const & A, mfem::BlockMatrix const & B) -> mfem::BlockMatrix\n" + "Mult(mfem::DenseMatrix const & b, mfem::DenseMatrix const & c, mfem::DenseMatrix & a)\n" + "Mult(mfem::SparseMatrix const & A, mfem::SparseMatrix const & B, mfem::SparseMatrix * OAB=None) -> mfem::SparseMatrix\n" + "Mult(mfem::SparseMatrix const & A, mfem::DenseMatrix & B) -> mfem::DenseMatrix *\n" + ""}, + { "InnerProduct", _wrap_InnerProduct, METH_VARARGS, "\n" + "InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double\n" + "InnerProduct(MPI_Comm comm, mfem::Vector const & x, mfem::Vector const & y) -> double\n" + "InnerProduct(mfem::HypreParVector & x, mfem::HypreParVector & y) -> double\n" + "InnerProduct(mfem::HypreParVector * x, mfem::HypreParVector * y) -> double\n" + ""}, + { "Add", _wrap_Add, METH_VARARGS, "\n" + "Add(mfem::DenseMatrix const & A, mfem::DenseMatrix const & B, double alpha, mfem::DenseMatrix & C)\n" + "Add(double alpha, double const * A, double beta, double const * B, mfem::DenseMatrix & C)\n" + "Add(double alpha, mfem::DenseMatrix const & A, double beta, mfem::DenseMatrix const & B, mfem::DenseMatrix & C)\n" + "Add(mfem::SparseMatrix const & A, mfem::SparseMatrix const & B) -> mfem::SparseMatrix\n" + "Add(double a, mfem::SparseMatrix const & A, double b, mfem::SparseMatrix const & B) -> mfem::SparseMatrix\n" + "Add(mfem::Array< mfem::SparseMatrix * > & Ai) -> mfem::SparseMatrix\n" + "Add(mfem::SparseMatrix const & A, double alpha, mfem::DenseMatrix & B)\n" + "Add(double alpha, mfem::HypreParMatrix const & A, double beta, mfem::HypreParMatrix const & B) -> mfem::HypreParMatrix *\n" + ""}, + { "RAP", _wrap_RAP, METH_VARARGS, "\n" + "RAP(mfem::SparseMatrix const & A, mfem::DenseMatrix & P) -> mfem::DenseMatrix\n" + "RAP(mfem::DenseMatrix & A, mfem::SparseMatrix const & P) -> mfem::DenseMatrix\n" + "RAP(mfem::SparseMatrix const & A, mfem::SparseMatrix const & R, mfem::SparseMatrix * ORAP=None) -> mfem::SparseMatrix\n" + "RAP(mfem::SparseMatrix const & Rt, mfem::SparseMatrix const & A, mfem::SparseMatrix const & P) -> mfem::SparseMatrix\n" + "RAP(mfem::HypreParMatrix const * A, mfem::HypreParMatrix const * P) -> mfem::HypreParMatrix\n" + "RAP(mfem::HypreParMatrix const * Rt, mfem::HypreParMatrix const * A, mfem::HypreParMatrix const * P) -> mfem::HypreParMatrix *\n" + ""}, { NULL, NULL, 0, NULL } }; @@ -6342,19 +6384,19 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_GIT_STRING",SWIG_FromCharPtr("tags/v4.0-0-g4d900b0c5fd6352c92173e74678bcbeeb11c8691")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_GIT_STRING",SWIG_FromCharPtr("tags/v4.1-0-g8dbbcfc25629ac7612fe31afd5b511752ff0e69b")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/communication.py b/mfem/_par/communication.py index 1eac4276..b3d863e5 100644 --- a/mfem/_par/communication.py +++ b/mfem/_par/communication.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _communication.SWIG_PyInstanceMethod_New +_swig_new_static_method = _communication.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -106,14 +109,17 @@ def __init__(self, *args): def WorldRank(self): r"""WorldRank(MPI_Session self) -> int""" return _communication.MPI_Session_WorldRank(self) + WorldRank = _swig_new_instance_method(_communication.MPI_Session_WorldRank) def WorldSize(self): r"""WorldSize(MPI_Session self) -> int""" return _communication.MPI_Session_WorldSize(self) + WorldSize = _swig_new_instance_method(_communication.MPI_Session_WorldSize) def Root(self): r"""Root(MPI_Session self) -> bool""" return _communication.MPI_Session_Root(self) + Root = _swig_new_instance_method(_communication.MPI_Session_Root) # Register MPI_Session in _communication: _communication.MPI_Session_swigregister(MPI_Session) @@ -135,66 +141,82 @@ def __init__(self, *args): def SetComm(self, comm): r"""SetComm(GroupTopology self, MPI_Comm comm)""" return _communication.GroupTopology_SetComm(self, comm) + SetComm = _swig_new_instance_method(_communication.GroupTopology_SetComm) def GetComm(self): r"""GetComm(GroupTopology self) -> MPI_Comm""" return _communication.GroupTopology_GetComm(self) + GetComm = _swig_new_instance_method(_communication.GroupTopology_GetComm) def MyRank(self): r"""MyRank(GroupTopology self) -> int""" return _communication.GroupTopology_MyRank(self) + MyRank = _swig_new_instance_method(_communication.GroupTopology_MyRank) def NRanks(self): r"""NRanks(GroupTopology self) -> int""" return _communication.GroupTopology_NRanks(self) + NRanks = _swig_new_instance_method(_communication.GroupTopology_NRanks) def Create(self, groups, mpitag): r"""Create(GroupTopology self, ListOfIntegerSets groups, int mpitag)""" return _communication.GroupTopology_Create(self, groups, mpitag) + Create = _swig_new_instance_method(_communication.GroupTopology_Create) def NGroups(self): r"""NGroups(GroupTopology self) -> int""" return _communication.GroupTopology_NGroups(self) + NGroups = _swig_new_instance_method(_communication.GroupTopology_NGroups) def GetNumNeighbors(self): r"""GetNumNeighbors(GroupTopology self) -> int""" return _communication.GroupTopology_GetNumNeighbors(self) + GetNumNeighbors = _swig_new_instance_method(_communication.GroupTopology_GetNumNeighbors) def GetNeighborRank(self, i): r"""GetNeighborRank(GroupTopology self, int i) -> int""" return _communication.GroupTopology_GetNeighborRank(self, i) + GetNeighborRank = _swig_new_instance_method(_communication.GroupTopology_GetNeighborRank) def IAmMaster(self, g): r"""IAmMaster(GroupTopology self, int g) -> bool""" return _communication.GroupTopology_IAmMaster(self, g) + IAmMaster = _swig_new_instance_method(_communication.GroupTopology_IAmMaster) def GetGroupMaster(self, g): r"""GetGroupMaster(GroupTopology self, int g) -> int""" return _communication.GroupTopology_GetGroupMaster(self, g) + GetGroupMaster = _swig_new_instance_method(_communication.GroupTopology_GetGroupMaster) def GetGroupMasterRank(self, g): r"""GetGroupMasterRank(GroupTopology self, int g) -> int""" return _communication.GroupTopology_GetGroupMasterRank(self, g) + GetGroupMasterRank = _swig_new_instance_method(_communication.GroupTopology_GetGroupMasterRank) def GetGroupMasterGroup(self, g): r"""GetGroupMasterGroup(GroupTopology self, int g) -> int""" return _communication.GroupTopology_GetGroupMasterGroup(self, g) + GetGroupMasterGroup = _swig_new_instance_method(_communication.GroupTopology_GetGroupMasterGroup) def GetGroupSize(self, g): r"""GetGroupSize(GroupTopology self, int g) -> int""" return _communication.GroupTopology_GetGroupSize(self, g) + GetGroupSize = _swig_new_instance_method(_communication.GroupTopology_GetGroupSize) def GetGroup(self, g): r"""GetGroup(GroupTopology self, int g) -> int const *""" return _communication.GroupTopology_GetGroup(self, g) + GetGroup = _swig_new_instance_method(_communication.GroupTopology_GetGroup) def Load(self, _in): r"""Load(GroupTopology self, std::istream & _in)""" return _communication.GroupTopology_Load(self, _in) + Load = _swig_new_instance_method(_communication.GroupTopology_Load) def Copy(self, copy): r"""Copy(GroupTopology self, GroupTopology copy)""" return _communication.GroupTopology_Copy(self, copy) + Copy = _swig_new_instance_method(_communication.GroupTopology_Copy) __swig_destroy__ = _communication.delete_GroupTopology def Save(self, *args): @@ -203,6 +225,7 @@ def Save(self, *args): Save(GroupTopology self, char const * file, int precision=8) """ return _communication.GroupTopology_Save(self, *args) + Save = _swig_new_instance_method(_communication.GroupTopology_Save) # Register GroupTopology in _communication: _communication.GroupTopology_swigregister(GroupTopology) @@ -224,6 +247,7 @@ def __init__(self, *args): def Create(self, ldof_group): r"""Create(GroupCommunicator self, intArray ldof_group)""" return _communication.GroupCommunicator_Create(self, ldof_group) + Create = _swig_new_instance_method(_communication.GroupCommunicator_Create) def GroupLDofTable(self, *args): r""" @@ -231,14 +255,17 @@ def GroupLDofTable(self, *args): GroupLDofTable(GroupCommunicator self) -> Table """ return _communication.GroupCommunicator_GroupLDofTable(self, *args) + GroupLDofTable = _swig_new_instance_method(_communication.GroupCommunicator_GroupLDofTable) def Finalize(self): r"""Finalize(GroupCommunicator self)""" return _communication.GroupCommunicator_Finalize(self) + Finalize = _swig_new_instance_method(_communication.GroupCommunicator_Finalize) def SetLTDofTable(self, ldof_ltdof): r"""SetLTDofTable(GroupCommunicator self, intArray ldof_ltdof)""" return _communication.GroupCommunicator_SetLTDofTable(self, ldof_ltdof) + SetLTDofTable = _swig_new_instance_method(_communication.GroupCommunicator_SetLTDofTable) def GetGroupTopology(self, *args): r""" @@ -246,6 +273,17 @@ def GetGroupTopology(self, *args): GetGroupTopology(GroupCommunicator self) -> GroupTopology """ return _communication.GroupCommunicator_GetGroupTopology(self, *args) + GetGroupTopology = _swig_new_instance_method(_communication.GroupCommunicator_GetGroupTopology) + + def GetNeighborLTDofTable(self, nbr_ltdof): + r"""GetNeighborLTDofTable(GroupCommunicator self, Table nbr_ltdof)""" + return _communication.GroupCommunicator_GetNeighborLTDofTable(self, nbr_ltdof) + GetNeighborLTDofTable = _swig_new_instance_method(_communication.GroupCommunicator_GetNeighborLTDofTable) + + def GetNeighborLDofTable(self, nbr_ldof): + r"""GetNeighborLDofTable(GroupCommunicator self, Table nbr_ldof)""" + return _communication.GroupCommunicator_GetNeighborLDofTable(self, nbr_ldof) + GetNeighborLDofTable = _swig_new_instance_method(_communication.GroupCommunicator_GetNeighborLDofTable) __swig_destroy__ = _communication.delete_GroupCommunicator def PrintInfo(self, *args): @@ -254,6 +292,7 @@ def PrintInfo(self, *args): PrintInfo(GroupCommunicator self, char const * file, int precision=8) """ return _communication.GroupCommunicator_PrintInfo(self, *args) + PrintInfo = _swig_new_instance_method(_communication.GroupCommunicator_PrintInfo) # Register GroupCommunicator in _communication: _communication.GroupCommunicator_swigregister(GroupCommunicator) @@ -262,5 +301,6 @@ def PrintInfo(self, *args): def ReorderRanksZCurve(comm): r"""ReorderRanksZCurve(MPI_Comm comm) -> MPI_Comm""" return _communication.ReorderRanksZCurve(comm) +ReorderRanksZCurve = _communication.ReorderRanksZCurve diff --git a/mfem/_par/communication_wrap.cxx b/mfem/_par/communication_wrap.cxx index 6286851d..510d1eea 100644 --- a/mfem/_par/communication_wrap.cxx +++ b/mfem/_par/communication_wrap.cxx @@ -5030,6 +5030,100 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_GetGroupTopology(PyObject *self, Py } +SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLTDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; + mfem::Table *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GroupCommunicator_GetNeighborLTDofTable", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_GetNeighborLTDofTable" "', argument " "1"" of type '" "mfem::GroupCommunicator const *""'"); + } + arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_GetNeighborLTDofTable" "', argument " "2"" of type '" "mfem::Table &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupCommunicator_GetNeighborLTDofTable" "', argument " "2"" of type '" "mfem::Table &""'"); + } + arg2 = reinterpret_cast< mfem::Table * >(argp2); + { + try { + ((mfem::GroupCommunicator const *)arg1)->GetNeighborLTDofTable(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; + mfem::Table *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GroupCommunicator_GetNeighborLDofTable", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_GetNeighborLDofTable" "', argument " "1"" of type '" "mfem::GroupCommunicator const *""'"); + } + arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_GetNeighborLDofTable" "', argument " "2"" of type '" "mfem::Table &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupCommunicator_GetNeighborLDofTable" "', argument " "2"" of type '" "mfem::Table &""'"); + } + arg2 = reinterpret_cast< mfem::Table * >(argp2); + { + try { + ((mfem::GroupCommunicator const *)arg1)->GetNeighborLDofTable(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; @@ -5402,6 +5496,7 @@ SWIGINTERN PyObject *_wrap_ReorderRanksZCurve(PyObject *SWIGUNUSEDPARM(self), Py static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_MPI_Session", _wrap_new_MPI_Session, METH_VARARGS, "\n" "MPI_Session()\n" "new_MPI_Session(int & argc, char **& argv) -> MPI_Session\n" @@ -5452,6 +5547,8 @@ static PyMethodDef SwigMethods[] = { "GroupCommunicator_GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" "GroupCommunicator_GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" ""}, + { "GroupCommunicator_GetNeighborLTDofTable", _wrap_GroupCommunicator_GetNeighborLTDofTable, METH_VARARGS, "GroupCommunicator_GetNeighborLTDofTable(GroupCommunicator self, Table nbr_ltdof)"}, + { "GroupCommunicator_GetNeighborLDofTable", _wrap_GroupCommunicator_GetNeighborLDofTable, METH_VARARGS, "GroupCommunicator_GetNeighborLDofTable(GroupCommunicator self, Table nbr_ldof)"}, { "delete_GroupCommunicator", _wrap_delete_GroupCommunicator, METH_O, "delete_GroupCommunicator(GroupCommunicator self)"}, { "GroupCommunicator_PrintInfo", _wrap_GroupCommunicator_PrintInfo, METH_VARARGS, "\n" "GroupCommunicator_PrintInfo(GroupCommunicator self, std::ostream & out=mfem::out)\n" @@ -5464,6 +5561,68 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_MPI_Session", _wrap_new_MPI_Session, METH_VARARGS, "\n" + "MPI_Session()\n" + "new_MPI_Session(int & argc, char **& argv) -> MPI_Session\n" + ""}, + { "delete_MPI_Session", _wrap_delete_MPI_Session, METH_O, "delete_MPI_Session(MPI_Session self)"}, + { "MPI_Session_WorldRank", _wrap_MPI_Session_WorldRank, METH_O, "WorldRank(MPI_Session self) -> int"}, + { "MPI_Session_WorldSize", _wrap_MPI_Session_WorldSize, METH_O, "WorldSize(MPI_Session self) -> int"}, + { "MPI_Session_Root", _wrap_MPI_Session_Root, METH_O, "Root(MPI_Session self) -> bool"}, + { "MPI_Session_swigregister", MPI_Session_swigregister, METH_O, NULL}, + { "MPI_Session_swiginit", MPI_Session_swiginit, METH_VARARGS, NULL}, + { "new_GroupTopology", _wrap_new_GroupTopology, METH_VARARGS, "\n" + "GroupTopology()\n" + "GroupTopology(MPI_Comm comm)\n" + "new_GroupTopology(GroupTopology gt) -> GroupTopology\n" + ""}, + { "GroupTopology_SetComm", _wrap_GroupTopology_SetComm, METH_VARARGS, "SetComm(GroupTopology self, MPI_Comm comm)"}, + { "GroupTopology_GetComm", _wrap_GroupTopology_GetComm, METH_O, "GetComm(GroupTopology self) -> MPI_Comm"}, + { "GroupTopology_MyRank", _wrap_GroupTopology_MyRank, METH_O, "MyRank(GroupTopology self) -> int"}, + { "GroupTopology_NRanks", _wrap_GroupTopology_NRanks, METH_O, "NRanks(GroupTopology self) -> int"}, + { "GroupTopology_Create", _wrap_GroupTopology_Create, METH_VARARGS, "Create(GroupTopology self, ListOfIntegerSets groups, int mpitag)"}, + { "GroupTopology_NGroups", _wrap_GroupTopology_NGroups, METH_O, "NGroups(GroupTopology self) -> int"}, + { "GroupTopology_GetNumNeighbors", _wrap_GroupTopology_GetNumNeighbors, METH_O, "GetNumNeighbors(GroupTopology self) -> int"}, + { "GroupTopology_GetNeighborRank", _wrap_GroupTopology_GetNeighborRank, METH_VARARGS, "GetNeighborRank(GroupTopology self, int i) -> int"}, + { "GroupTopology_IAmMaster", _wrap_GroupTopology_IAmMaster, METH_VARARGS, "IAmMaster(GroupTopology self, int g) -> bool"}, + { "GroupTopology_GetGroupMaster", _wrap_GroupTopology_GetGroupMaster, METH_VARARGS, "GetGroupMaster(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupMasterRank", _wrap_GroupTopology_GetGroupMasterRank, METH_VARARGS, "GetGroupMasterRank(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupMasterGroup", _wrap_GroupTopology_GetGroupMasterGroup, METH_VARARGS, "GetGroupMasterGroup(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupSize", _wrap_GroupTopology_GetGroupSize, METH_VARARGS, "GetGroupSize(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroup", _wrap_GroupTopology_GetGroup, METH_VARARGS, "GetGroup(GroupTopology self, int g) -> int const *"}, + { "GroupTopology_Load", _wrap_GroupTopology_Load, METH_VARARGS, "Load(GroupTopology self, std::istream & _in)"}, + { "GroupTopology_Copy", _wrap_GroupTopology_Copy, METH_VARARGS, "Copy(GroupTopology self, GroupTopology copy)"}, + { "delete_GroupTopology", _wrap_delete_GroupTopology, METH_O, "delete_GroupTopology(GroupTopology self)"}, + { "GroupTopology_Save", _wrap_GroupTopology_Save, METH_VARARGS, "\n" + "Save(GroupTopology self, std::ostream & out)\n" + "Save(GroupTopology self, char const * file, int precision=8)\n" + ""}, + { "GroupTopology_swigregister", GroupTopology_swigregister, METH_O, NULL}, + { "GroupTopology_swiginit", GroupTopology_swiginit, METH_VARARGS, NULL}, + { "new_GroupCommunicator", _wrap_new_GroupCommunicator, METH_VARARGS, "GroupCommunicator(GroupTopology gt, mfem::GroupCommunicator::Mode m=byNeighbor)"}, + { "GroupCommunicator_Create", _wrap_GroupCommunicator_Create, METH_VARARGS, "Create(GroupCommunicator self, intArray ldof_group)"}, + { "GroupCommunicator_GroupLDofTable", _wrap_GroupCommunicator_GroupLDofTable, METH_VARARGS, "\n" + "GroupLDofTable(GroupCommunicator self) -> Table\n" + "GroupLDofTable(GroupCommunicator self) -> Table\n" + ""}, + { "GroupCommunicator_Finalize", _wrap_GroupCommunicator_Finalize, METH_O, "Finalize(GroupCommunicator self)"}, + { "GroupCommunicator_SetLTDofTable", _wrap_GroupCommunicator_SetLTDofTable, METH_VARARGS, "SetLTDofTable(GroupCommunicator self, intArray ldof_ltdof)"}, + { "GroupCommunicator_GetGroupTopology", _wrap_GroupCommunicator_GetGroupTopology, METH_VARARGS, "\n" + "GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" + "GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" + ""}, + { "GroupCommunicator_GetNeighborLTDofTable", _wrap_GroupCommunicator_GetNeighborLTDofTable, METH_VARARGS, "GetNeighborLTDofTable(GroupCommunicator self, Table nbr_ltdof)"}, + { "GroupCommunicator_GetNeighborLDofTable", _wrap_GroupCommunicator_GetNeighborLDofTable, METH_VARARGS, "GetNeighborLDofTable(GroupCommunicator self, Table nbr_ldof)"}, + { "delete_GroupCommunicator", _wrap_delete_GroupCommunicator, METH_O, "delete_GroupCommunicator(GroupCommunicator self)"}, + { "GroupCommunicator_PrintInfo", _wrap_GroupCommunicator_PrintInfo, METH_VARARGS, "\n" + "PrintInfo(GroupCommunicator self, std::ostream & out=mfem::out)\n" + "PrintInfo(GroupCommunicator self, char const * file, int precision=8)\n" + ""}, + { "GroupCommunicator_swigregister", GroupCommunicator_swigregister, METH_O, NULL}, + { "GroupCommunicator_swiginit", GroupCommunicator_swiginit, METH_VARARGS, NULL}, + { "ReorderRanksZCurve", _wrap_ReorderRanksZCurve, METH_O, "ReorderRanksZCurve(MPI_Comm comm) -> MPI_Comm"}, { NULL, NULL, 0, NULL } }; @@ -6260,18 +6419,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); import_array(); diff --git a/mfem/_par/complex_operator.py b/mfem/_par/complex_operator.py index b3d4c1cd..0ce08304 100644 --- a/mfem/_par/complex_operator.py +++ b/mfem/_par/complex_operator.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _complex_operator.SWIG_PyInstanceMethod_New +_swig_new_static_method = _complex_operator.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -81,13 +84,46 @@ class ComplexOperator(mfem._par.operators.Operator): __swig_destroy__ = _complex_operator.delete_ComplexOperator + def hasRealPart(self): + r"""hasRealPart(ComplexOperator self) -> bool""" + return _complex_operator.ComplexOperator_hasRealPart(self) + hasRealPart = _swig_new_instance_method(_complex_operator.ComplexOperator_hasRealPart) + + def hasImagPart(self): + r"""hasImagPart(ComplexOperator self) -> bool""" + return _complex_operator.ComplexOperator_hasImagPart(self) + hasImagPart = _swig_new_instance_method(_complex_operator.ComplexOperator_hasImagPart) + + def real(self, *args): + r""" + real(ComplexOperator self) -> Operator + real(ComplexOperator self) -> Operator + """ + return _complex_operator.ComplexOperator_real(self, *args) + real = _swig_new_instance_method(_complex_operator.ComplexOperator_real) + + def imag(self, *args): + r""" + imag(ComplexOperator self) -> Operator + imag(ComplexOperator self) -> Operator + """ + return _complex_operator.ComplexOperator_imag(self, *args) + imag = _swig_new_instance_method(_complex_operator.ComplexOperator_imag) + def Mult(self, x, y): r"""Mult(ComplexOperator self, Vector x, Vector y)""" return _complex_operator.ComplexOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_complex_operator.ComplexOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(ComplexOperator self, Vector x, Vector y)""" return _complex_operator.ComplexOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_complex_operator.ComplexOperator_MultTranspose) + + def GetType(self): + r"""GetType(ComplexOperator self) -> mfem::Operator::Type""" + return _complex_operator.ComplexOperator_GetType(self) + GetType = _swig_new_instance_method(_complex_operator.ComplexOperator_GetType) def __init__(self, Op_Real, Op_Imag, ownReal=False, ownImag=False, hermitan=True): r"""__init__(ComplexOperator self, Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True) -> ComplexOperator""" @@ -116,9 +152,31 @@ def __init__(self, *args): r"""__init__(ComplexSparseMatrix self, SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix""" _complex_operator.ComplexSparseMatrix_swiginit(self, _complex_operator.new_ComplexSparseMatrix(*args)) + def real(self, *args): + r""" + real(ComplexSparseMatrix self) -> SparseMatrix + real(ComplexSparseMatrix self) -> SparseMatrix + """ + return _complex_operator.ComplexSparseMatrix_real(self, *args) + real = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_real) + + def imag(self, *args): + r""" + imag(ComplexSparseMatrix self) -> SparseMatrix + imag(ComplexSparseMatrix self) -> SparseMatrix + """ + return _complex_operator.ComplexSparseMatrix_imag(self, *args) + imag = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_imag) + def GetSystemMatrix(self): r"""GetSystemMatrix(ComplexSparseMatrix self) -> SparseMatrix""" return _complex_operator.ComplexSparseMatrix_GetSystemMatrix(self) + GetSystemMatrix = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_GetSystemMatrix) + + def GetType(self): + r"""GetType(ComplexSparseMatrix self) -> mfem::Operator::Type""" + return _complex_operator.ComplexSparseMatrix_GetType(self) + GetType = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_GetType) __swig_destroy__ = _complex_operator.delete_ComplexSparseMatrix # Register ComplexSparseMatrix in _complex_operator: diff --git a/mfem/_par/complex_operator_wrap.cxx b/mfem/_par/complex_operator_wrap.cxx index f8502d07..41a6c784 100644 --- a/mfem/_par/complex_operator_wrap.cxx +++ b/mfem/_par/complex_operator_wrap.cxx @@ -3081,14 +3081,17 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[13] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[14] #define SWIGTYPE_p_mfem__RAPOperator swig_types[15] -#define SWIGTYPE_p_mfem__Solver swig_types[16] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[17] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[18] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[19] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[20] -#define SWIGTYPE_p_mfem__Vector swig_types[21] -static swig_type_info *swig_types[23]; -static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[16] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[17] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[18] +#define SWIGTYPE_p_mfem__Solver swig_types[19] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[20] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[21] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[22] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[23] +#define SWIGTYPE_p_mfem__Vector swig_types[24] +static swig_type_info *swig_types[26]; +static swig_module_info swig_module = {swig_types, 25, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3204,6 +3207,13 @@ SWIGINTERNINLINE PyObject* } +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + SWIGINTERN int SWIG_AsVal_double (PyObject *obj, double *val) { @@ -3422,6 +3432,280 @@ SWIGINTERN PyObject *_wrap_delete_ComplexOperator(PyObject *SWIGUNUSEDPARM(self) } +SWIGINTERN PyObject *_wrap_ComplexOperator_hasRealPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_hasRealPart" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (bool)((mfem::ComplexOperator const *)arg1)->hasRealPart(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_hasImagPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_hasImagPart" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (bool)((mfem::ComplexOperator const *)arg1)->hasImagPart(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_real__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_real" "', argument " "1"" of type '" "mfem::ComplexOperator *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &(arg1)->real(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_imag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_imag" "', argument " "1"" of type '" "mfem::ComplexOperator *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &(arg1)->imag(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_real__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_real" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &((mfem::ComplexOperator const *)arg1)->real(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_real(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexOperator_real", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_real__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_real__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexOperator_real'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexOperator::real()\n" + " mfem::ComplexOperator::real() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_imag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_imag" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &((mfem::ComplexOperator const *)arg1)->imag(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_imag(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexOperator_imag", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_imag__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_imag__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexOperator_imag'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexOperator::imag()\n" + " mfem::ComplexOperator::imag() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; @@ -3532,6 +3816,41 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPAR } +SWIGINTERN PyObject *_wrap_ComplexOperator_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator::Type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_GetType" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator::Type)((mfem::ComplexOperator const *)arg1)->GetType(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; @@ -4065,6 +4384,210 @@ SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix(PyObject *self, PyObject *arg } +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_real" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &(arg1)->real(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_imag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_imag" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &(arg1)->imag(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_real" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &((mfem::ComplexSparseMatrix const *)arg1)->real(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexSparseMatrix_real", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_real__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_real__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexSparseMatrix_real'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexSparseMatrix::real()\n" + " mfem::ComplexSparseMatrix::real() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_imag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_imag" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &((mfem::ComplexSparseMatrix const *)arg1)->imag(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_imag(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexSparseMatrix_imag", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_imag__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_imag__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexSparseMatrix_imag'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexSparseMatrix::imag()\n" + " mfem::ComplexSparseMatrix::imag() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_GetSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; @@ -4100,6 +4623,41 @@ SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_GetSystemMatrix(PyObject *SWIGUNU } +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator::Type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_GetType" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::Operator::Type)((mfem::ComplexSparseMatrix const *)arg1)->GetType(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_ComplexSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; @@ -4147,14 +4705,35 @@ SWIGINTERN PyObject *ComplexSparseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self) static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "delete_ComplexOperator", _wrap_delete_ComplexOperator, METH_O, "delete_ComplexOperator(ComplexOperator self)"}, + { "ComplexOperator_hasRealPart", _wrap_ComplexOperator_hasRealPart, METH_O, "ComplexOperator_hasRealPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_hasImagPart", _wrap_ComplexOperator_hasImagPart, METH_O, "ComplexOperator_hasImagPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_real", _wrap_ComplexOperator_real, METH_VARARGS, "\n" + "ComplexOperator_real(ComplexOperator self) -> Operator\n" + "ComplexOperator_real(ComplexOperator self) -> Operator\n" + ""}, + { "ComplexOperator_imag", _wrap_ComplexOperator_imag, METH_VARARGS, "\n" + "ComplexOperator_imag(ComplexOperator self) -> Operator\n" + "ComplexOperator_imag(ComplexOperator self) -> Operator\n" + ""}, { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "ComplexOperator_Mult(ComplexOperator self, Vector x, Vector y)"}, { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "ComplexOperator_MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "ComplexOperator_GetType(ComplexOperator self) -> mfem::Operator::Type"}, { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" + "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" + "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, + { "ComplexSparseMatrix_imag", _wrap_ComplexSparseMatrix_imag, METH_VARARGS, "\n" + "ComplexSparseMatrix_imag(ComplexSparseMatrix self) -> SparseMatrix\n" + "ComplexSparseMatrix_imag(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, { "ComplexSparseMatrix_GetSystemMatrix", _wrap_ComplexSparseMatrix_GetSystemMatrix, METH_O, "ComplexSparseMatrix_GetSystemMatrix(ComplexSparseMatrix self) -> SparseMatrix"}, + { "ComplexSparseMatrix_GetType", _wrap_ComplexSparseMatrix_GetType, METH_O, "ComplexSparseMatrix_GetType(ComplexSparseMatrix self) -> mfem::Operator::Type"}, { "delete_ComplexSparseMatrix", _wrap_delete_ComplexSparseMatrix, METH_O, "delete_ComplexSparseMatrix(ComplexSparseMatrix self)"}, { "ComplexSparseMatrix_swigregister", ComplexSparseMatrix_swigregister, METH_O, NULL}, { "ComplexSparseMatrix_swiginit", ComplexSparseMatrix_swiginit, METH_VARARGS, NULL}, @@ -4162,6 +4741,39 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "delete_ComplexOperator", _wrap_delete_ComplexOperator, METH_O, "delete_ComplexOperator(ComplexOperator self)"}, + { "ComplexOperator_hasRealPart", _wrap_ComplexOperator_hasRealPart, METH_O, "hasRealPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_hasImagPart", _wrap_ComplexOperator_hasImagPart, METH_O, "hasImagPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_real", _wrap_ComplexOperator_real, METH_VARARGS, "\n" + "real(ComplexOperator self) -> Operator\n" + "real(ComplexOperator self) -> Operator\n" + ""}, + { "ComplexOperator_imag", _wrap_ComplexOperator_imag, METH_VARARGS, "\n" + "imag(ComplexOperator self) -> Operator\n" + "imag(ComplexOperator self) -> Operator\n" + ""}, + { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "Mult(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "GetType(ComplexOperator self) -> mfem::Operator::Type"}, + { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, + { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, + { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, + { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" + "real(ComplexSparseMatrix self) -> SparseMatrix\n" + "real(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, + { "ComplexSparseMatrix_imag", _wrap_ComplexSparseMatrix_imag, METH_VARARGS, "\n" + "imag(ComplexSparseMatrix self) -> SparseMatrix\n" + "imag(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, + { "ComplexSparseMatrix_GetSystemMatrix", _wrap_ComplexSparseMatrix_GetSystemMatrix, METH_O, "GetSystemMatrix(ComplexSparseMatrix self) -> SparseMatrix"}, + { "ComplexSparseMatrix_GetType", _wrap_ComplexSparseMatrix_GetType, METH_O, "GetType(ComplexSparseMatrix self) -> mfem::Operator::Type"}, + { "delete_ComplexSparseMatrix", _wrap_delete_ComplexSparseMatrix, METH_O, "delete_ComplexSparseMatrix(ComplexSparseMatrix self)"}, + { "ComplexSparseMatrix_swigregister", ComplexSparseMatrix_swigregister, METH_O, NULL}, + { "ComplexSparseMatrix_swiginit", ComplexSparseMatrix_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4183,12 +4795,12 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } @@ -4198,6 +4810,9 @@ static void *_p_mfem__ComplexSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGU static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -4213,9 +4828,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -4235,15 +4856,18 @@ static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -4265,6 +4889,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -4282,17 +4909,20 @@ static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOp static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexSparseMatrix, _p_mfem__ComplexSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexOperator, _p_mfem__ComplexOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexSparseMatrix, _p_mfem__ComplexSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexOperator, _p_mfem__ComplexOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -4313,6 +4943,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_par/config.py b/mfem/_par/config.py index 9241940c..9afbe84d 100644 --- a/mfem/_par/config.py +++ b/mfem/_par/config.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _config.SWIG_PyInstanceMethod_New +_swig_new_static_method = _config.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() diff --git a/mfem/_par/config_wrap.cxx b/mfem/_par/config_wrap.cxx index c21f087c..481b34ed 100644 --- a/mfem/_par/config_wrap.cxx +++ b/mfem/_par/config_wrap.cxx @@ -2822,10 +2822,13 @@ extern "C" { #endif static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; @@ -3571,19 +3574,19 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_GIT_STRING",SWIG_FromCharPtr("tags/v4.0-0-g4d900b0c5fd6352c92173e74678bcbeeb11c8691")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_GIT_STRING",SWIG_FromCharPtr("tags/v4.1-0-g8dbbcfc25629ac7612fe31afd5b511752ff0e69b")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/cpointers.py b/mfem/_par/cpointers.py index 7ffe9c59..3d47a6de 100644 --- a/mfem/_par/cpointers.py +++ b/mfem/_par/cpointers.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _cpointers.SWIG_PyInstanceMethod_New +_swig_new_static_method = _cpointers.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -71,22 +74,27 @@ def __init__(self): def assign(self, value): return _cpointers.intp_assign(self, value) + assign = _swig_new_instance_method(_cpointers.intp_assign) def value(self): return _cpointers.intp_value(self) + value = _swig_new_instance_method(_cpointers.intp_value) def cast(self): return _cpointers.intp_cast(self) + cast = _swig_new_instance_method(_cpointers.intp_cast) @staticmethod def frompointer(t): return _cpointers.intp_frompointer(t) + frompointer = _swig_new_static_method(_cpointers.intp_frompointer) # Register intp in _cpointers: _cpointers.intp_swigregister(intp) def intp_frompointer(t): return _cpointers.intp_frompointer(t) +intp_frompointer = _cpointers.intp_frompointer class doublep(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -98,22 +106,27 @@ def __init__(self): def assign(self, value): return _cpointers.doublep_assign(self, value) + assign = _swig_new_instance_method(_cpointers.doublep_assign) def value(self): return _cpointers.doublep_value(self) + value = _swig_new_instance_method(_cpointers.doublep_value) def cast(self): return _cpointers.doublep_cast(self) + cast = _swig_new_instance_method(_cpointers.doublep_cast) @staticmethod def frompointer(t): return _cpointers.doublep_frompointer(t) + frompointer = _swig_new_static_method(_cpointers.doublep_frompointer) # Register doublep in _cpointers: _cpointers.doublep_swigregister(doublep) def doublep_frompointer(t): return _cpointers.doublep_frompointer(t) +doublep_frompointer = _cpointers.doublep_frompointer diff --git a/mfem/_par/cpointers_wrap.cxx b/mfem/_par/cpointers_wrap.cxx index 343586e0..b6b48895 100644 --- a/mfem/_par/cpointers_wrap.cxx +++ b/mfem/_par/cpointers_wrap.cxx @@ -3262,6 +3262,7 @@ SWIGINTERN PyObject *doublep_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, @@ -3282,6 +3283,24 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, + { "delete_intp", _wrap_delete_intp, METH_O, NULL}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_value", _wrap_intp_value, METH_O, NULL}, + { "intp_cast", _wrap_intp_cast, METH_O, NULL}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, + { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_value", _wrap_doublep_value, METH_O, NULL}, + { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/densemat.py b/mfem/_par/densemat.py index 069365f6..6088db53 100644 --- a/mfem/_par/densemat.py +++ b/mfem/_par/densemat.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _densemat.SWIG_PyInstanceMethod_New +_swig_new_static_method = _densemat.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -88,22 +91,27 @@ def __init__(self, *args): def UseExternalData(self, d, h, w): r"""UseExternalData(DenseMatrix self, double * d, int h, int w)""" return _densemat.DenseMatrix_UseExternalData(self, d, h, w) + UseExternalData = _swig_new_instance_method(_densemat.DenseMatrix_UseExternalData) def Reset(self, d, h, w): r"""Reset(DenseMatrix self, double * d, int h, int w)""" return _densemat.DenseMatrix_Reset(self, d, h, w) + Reset = _swig_new_instance_method(_densemat.DenseMatrix_Reset) def ClearExternalData(self): r"""ClearExternalData(DenseMatrix self)""" return _densemat.DenseMatrix_ClearExternalData(self) + ClearExternalData = _swig_new_instance_method(_densemat.DenseMatrix_ClearExternalData) def Clear(self): r"""Clear(DenseMatrix self)""" return _densemat.DenseMatrix_Clear(self) + Clear = _swig_new_instance_method(_densemat.DenseMatrix_Clear) def Size(self): r"""Size(DenseMatrix self) -> int""" return _densemat.DenseMatrix_Size(self) + Size = _swig_new_instance_method(_densemat.DenseMatrix_Size) def SetSize(self, *args): r""" @@ -111,18 +119,30 @@ def SetSize(self, *args): SetSize(DenseMatrix self, int h, int w) """ return _densemat.DenseMatrix_SetSize(self, *args) + SetSize = _swig_new_instance_method(_densemat.DenseMatrix_SetSize) def Data(self): r"""Data(DenseMatrix self) -> double *""" return _densemat.DenseMatrix_Data(self) + Data = _swig_new_instance_method(_densemat.DenseMatrix_Data) def GetData(self): r"""GetData(DenseMatrix self) -> double *""" return _densemat.DenseMatrix_GetData(self) + GetData = _swig_new_instance_method(_densemat.DenseMatrix_GetData) + + def GetMemory(self, *args): + r""" + GetMemory(DenseMatrix self) -> mfem::Memory< double > + GetMemory(DenseMatrix self) -> mfem::Memory< double > const & + """ + return _densemat.DenseMatrix_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_densemat.DenseMatrix_GetMemory) def OwnsData(self): r"""OwnsData(DenseMatrix self) -> bool""" return _densemat.DenseMatrix_OwnsData(self) + OwnsData = _swig_new_instance_method(_densemat.DenseMatrix_OwnsData) def __call__(self, *args): r""" @@ -130,14 +150,17 @@ def __call__(self, *args): __call__(DenseMatrix self, int i, int j) -> double const & """ return _densemat.DenseMatrix___call__(self, *args) + __call__ = _swig_new_instance_method(_densemat.DenseMatrix___call__) def __mul__(self, m): r"""__mul__(DenseMatrix self, DenseMatrix m) -> double""" return _densemat.DenseMatrix___mul__(self, m) + __mul__ = _swig_new_instance_method(_densemat.DenseMatrix___mul__) def Trace(self): r"""Trace(DenseMatrix self) -> double""" return _densemat.DenseMatrix_Trace(self) + Trace = _swig_new_instance_method(_densemat.DenseMatrix_Trace) def Elem(self, *args): r""" @@ -145,6 +168,7 @@ def Elem(self, *args): Elem(DenseMatrix self, int i, int j) -> double const & """ return _densemat.DenseMatrix_Elem(self, *args) + Elem = _swig_new_instance_method(_densemat.DenseMatrix_Elem) def Mult(self, *args): r""" @@ -152,6 +176,7 @@ def Mult(self, *args): Mult(DenseMatrix self, Vector x, Vector y) """ return _densemat.DenseMatrix_Mult(self, *args) + Mult = _swig_new_instance_method(_densemat.DenseMatrix_Mult) def MultTranspose(self, *args): r""" @@ -159,46 +184,57 @@ def MultTranspose(self, *args): MultTranspose(DenseMatrix self, Vector x, Vector y) """ return _densemat.DenseMatrix_MultTranspose(self, *args) + MultTranspose = _swig_new_instance_method(_densemat.DenseMatrix_MultTranspose) def AddMult(self, x, y): r"""AddMult(DenseMatrix self, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMult(self, x, y) + AddMult = _swig_new_instance_method(_densemat.DenseMatrix_AddMult) def AddMultTranspose(self, x, y): r"""AddMultTranspose(DenseMatrix self, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMultTranspose(self, x, y) + AddMultTranspose = _swig_new_instance_method(_densemat.DenseMatrix_AddMultTranspose) def AddMult_a(self, a, x, y): r"""AddMult_a(DenseMatrix self, double a, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMult_a(self, a, x, y) + AddMult_a = _swig_new_instance_method(_densemat.DenseMatrix_AddMult_a) def AddMultTranspose_a(self, a, x, y): r"""AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMultTranspose_a(self, a, x, y) + AddMultTranspose_a = _swig_new_instance_method(_densemat.DenseMatrix_AddMultTranspose_a) def LeftScaling(self, s): r"""LeftScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_LeftScaling(self, s) + LeftScaling = _swig_new_instance_method(_densemat.DenseMatrix_LeftScaling) def InvLeftScaling(self, s): r"""InvLeftScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_InvLeftScaling(self, s) + InvLeftScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvLeftScaling) def RightScaling(self, s): r"""RightScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_RightScaling(self, s) + RightScaling = _swig_new_instance_method(_densemat.DenseMatrix_RightScaling) def InvRightScaling(self, s): r"""InvRightScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_InvRightScaling(self, s) + InvRightScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvRightScaling) def SymmetricScaling(self, s): r"""SymmetricScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_SymmetricScaling(self, s) + SymmetricScaling = _swig_new_instance_method(_densemat.DenseMatrix_SymmetricScaling) def InvSymmetricScaling(self, s): r"""InvSymmetricScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_InvSymmetricScaling(self, s) + InvSymmetricScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvSymmetricScaling) def InnerProduct(self, *args): r""" @@ -206,26 +242,32 @@ def InnerProduct(self, *args): InnerProduct(DenseMatrix self, Vector x, Vector y) -> double """ return _densemat.DenseMatrix_InnerProduct(self, *args) + InnerProduct = _swig_new_instance_method(_densemat.DenseMatrix_InnerProduct) def Inverse(self): r"""Inverse(DenseMatrix self) -> MatrixInverse""" return _densemat.DenseMatrix_Inverse(self) + Inverse = _swig_new_instance_method(_densemat.DenseMatrix_Inverse) def Invert(self): r"""Invert(DenseMatrix self)""" return _densemat.DenseMatrix_Invert(self) + Invert = _swig_new_instance_method(_densemat.DenseMatrix_Invert) def SquareRootInverse(self): r"""SquareRootInverse(DenseMatrix self)""" return _densemat.DenseMatrix_SquareRootInverse(self) + SquareRootInverse = _swig_new_instance_method(_densemat.DenseMatrix_SquareRootInverse) def Det(self): r"""Det(DenseMatrix self) -> double""" return _densemat.DenseMatrix_Det(self) + Det = _swig_new_instance_method(_densemat.DenseMatrix_Det) def Weight(self): r"""Weight(DenseMatrix self) -> double""" return _densemat.DenseMatrix_Weight(self) + Weight = _swig_new_instance_method(_densemat.DenseMatrix_Weight) def Set(self, *args): r""" @@ -233,10 +275,12 @@ def Set(self, *args): Set(DenseMatrix self, double alpha, DenseMatrix A) """ return _densemat.DenseMatrix_Set(self, *args) + Set = _swig_new_instance_method(_densemat.DenseMatrix_Set) def Add(self, c, A): r"""Add(DenseMatrix self, double const c, DenseMatrix A)""" return _densemat.DenseMatrix_Add(self, c, A) + Add = _swig_new_instance_method(_densemat.DenseMatrix_Add) def __iadd__(self, v): ret = _densmat.DenseMatrix___iadd__(self, v) @@ -265,22 +309,27 @@ def __imul__(self, v): def Neg(self): r"""Neg(DenseMatrix self)""" return _densemat.DenseMatrix_Neg(self) + Neg = _swig_new_instance_method(_densemat.DenseMatrix_Neg) def Norm2(self, v): r"""Norm2(DenseMatrix self, double * v)""" return _densemat.DenseMatrix_Norm2(self, v) + Norm2 = _swig_new_instance_method(_densemat.DenseMatrix_Norm2) def MaxMaxNorm(self): r"""MaxMaxNorm(DenseMatrix self) -> double""" return _densemat.DenseMatrix_MaxMaxNorm(self) + MaxMaxNorm = _swig_new_instance_method(_densemat.DenseMatrix_MaxMaxNorm) def FNorm(self): r"""FNorm(DenseMatrix self) -> double""" return _densemat.DenseMatrix_FNorm(self) + FNorm = _swig_new_instance_method(_densemat.DenseMatrix_FNorm) def FNorm2(self): r"""FNorm2(DenseMatrix self) -> double""" return _densemat.DenseMatrix_FNorm2(self) + FNorm2 = _swig_new_instance_method(_densemat.DenseMatrix_FNorm2) def Eigenvalues(self, *args): r""" @@ -290,6 +339,7 @@ def Eigenvalues(self, *args): Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect) """ return _densemat.DenseMatrix_Eigenvalues(self, *args) + Eigenvalues = _swig_new_instance_method(_densemat.DenseMatrix_Eigenvalues) def Eigensystem(self, *args): r""" @@ -297,26 +347,32 @@ def Eigensystem(self, *args): Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect) """ return _densemat.DenseMatrix_Eigensystem(self, *args) + Eigensystem = _swig_new_instance_method(_densemat.DenseMatrix_Eigensystem) def SingularValues(self, sv): r"""SingularValues(DenseMatrix self, Vector sv)""" return _densemat.DenseMatrix_SingularValues(self, sv) + SingularValues = _swig_new_instance_method(_densemat.DenseMatrix_SingularValues) def Rank(self, tol): r"""Rank(DenseMatrix self, double tol) -> int""" return _densemat.DenseMatrix_Rank(self, tol) + Rank = _swig_new_instance_method(_densemat.DenseMatrix_Rank) def CalcSingularvalue(self, i): r"""CalcSingularvalue(DenseMatrix self, int const i) -> double""" return _densemat.DenseMatrix_CalcSingularvalue(self, i) + CalcSingularvalue = _swig_new_instance_method(_densemat.DenseMatrix_CalcSingularvalue) def CalcEigenvalues(self, _lambda, vec): r"""CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)""" return _densemat.DenseMatrix_CalcEigenvalues(self, _lambda, vec) + CalcEigenvalues = _swig_new_instance_method(_densemat.DenseMatrix_CalcEigenvalues) def GetRow(self, r, row): r"""GetRow(DenseMatrix self, int r, Vector row)""" return _densemat.DenseMatrix_GetRow(self, r, row) + GetRow = _swig_new_instance_method(_densemat.DenseMatrix_GetRow) def GetColumn(self, *args): r""" @@ -325,36 +381,45 @@ def GetColumn(self, *args): GetColumn(DenseMatrix self, int col) -> double const * """ return _densemat.DenseMatrix_GetColumn(self, *args) + GetColumn = _swig_new_instance_method(_densemat.DenseMatrix_GetColumn) def GetColumnReference(self, c, col): r"""GetColumnReference(DenseMatrix self, int c, Vector col)""" return _densemat.DenseMatrix_GetColumnReference(self, c, col) + GetColumnReference = _swig_new_instance_method(_densemat.DenseMatrix_GetColumnReference) def SetRow(self, *args): r""" + SetRow(DenseMatrix self, int r, double const * row) SetRow(DenseMatrix self, int r, Vector row) SetRow(DenseMatrix self, int row, double value) """ return _densemat.DenseMatrix_SetRow(self, *args) + SetRow = _swig_new_instance_method(_densemat.DenseMatrix_SetRow) def SetCol(self, *args): r""" + SetCol(DenseMatrix self, int c, double const * col) SetCol(DenseMatrix self, int c, Vector col) SetCol(DenseMatrix self, int col, double value) """ return _densemat.DenseMatrix_SetCol(self, *args) + SetCol = _swig_new_instance_method(_densemat.DenseMatrix_SetCol) def GetDiag(self, d): r"""GetDiag(DenseMatrix self, Vector d)""" return _densemat.DenseMatrix_GetDiag(self, d) + GetDiag = _swig_new_instance_method(_densemat.DenseMatrix_GetDiag) def Getl1Diag(self, l): r"""Getl1Diag(DenseMatrix self, Vector l)""" return _densemat.DenseMatrix_Getl1Diag(self, l) + Getl1Diag = _swig_new_instance_method(_densemat.DenseMatrix_Getl1Diag) def GetRowSums(self, l): r"""GetRowSums(DenseMatrix self, Vector l)""" return _densemat.DenseMatrix_GetRowSums(self, l) + GetRowSums = _swig_new_instance_method(_densemat.DenseMatrix_GetRowSums) def Diag(self, *args): r""" @@ -362,6 +427,7 @@ def Diag(self, *args): Diag(DenseMatrix self, double * diag, int n) """ return _densemat.DenseMatrix_Diag(self, *args) + Diag = _swig_new_instance_method(_densemat.DenseMatrix_Diag) def Transpose(self, *args): r""" @@ -369,34 +435,42 @@ def Transpose(self, *args): Transpose(DenseMatrix self, DenseMatrix A) """ return _densemat.DenseMatrix_Transpose(self, *args) + Transpose = _swig_new_instance_method(_densemat.DenseMatrix_Transpose) def Symmetrize(self): r"""Symmetrize(DenseMatrix self)""" return _densemat.DenseMatrix_Symmetrize(self) + Symmetrize = _swig_new_instance_method(_densemat.DenseMatrix_Symmetrize) def Lump(self): r"""Lump(DenseMatrix self)""" return _densemat.DenseMatrix_Lump(self) + Lump = _swig_new_instance_method(_densemat.DenseMatrix_Lump) def GradToCurl(self, curl): r"""GradToCurl(DenseMatrix self, DenseMatrix curl)""" return _densemat.DenseMatrix_GradToCurl(self, curl) + GradToCurl = _swig_new_instance_method(_densemat.DenseMatrix_GradToCurl) def GradToDiv(self, div): r"""GradToDiv(DenseMatrix self, Vector div)""" return _densemat.DenseMatrix_GradToDiv(self, div) + GradToDiv = _swig_new_instance_method(_densemat.DenseMatrix_GradToDiv) def CopyRows(self, A, row1, row2): r"""CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)""" return _densemat.DenseMatrix_CopyRows(self, A, row1, row2) + CopyRows = _swig_new_instance_method(_densemat.DenseMatrix_CopyRows) def CopyCols(self, A, col1, col2): r"""CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)""" return _densemat.DenseMatrix_CopyCols(self, A, col1, col2) + CopyCols = _swig_new_instance_method(_densemat.DenseMatrix_CopyCols) def CopyMNt(self, A, row_offset, col_offset): r"""CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)""" return _densemat.DenseMatrix_CopyMNt(self, A, row_offset, col_offset) + CopyMNt = _swig_new_instance_method(_densemat.DenseMatrix_CopyMNt) def CopyMN(self, *args): r""" @@ -405,6 +479,7 @@ def CopyMN(self, *args): CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco, int row_offset, int col_offset) """ return _densemat.DenseMatrix_CopyMN(self, *args) + CopyMN = _swig_new_instance_method(_densemat.DenseMatrix_CopyMN) def CopyMNDiag(self, *args): r""" @@ -412,10 +487,12 @@ def CopyMNDiag(self, *args): CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset) """ return _densemat.DenseMatrix_CopyMNDiag(self, *args) + CopyMNDiag = _swig_new_instance_method(_densemat.DenseMatrix_CopyMNDiag) def CopyExceptMN(self, A, m, n): r"""CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)""" return _densemat.DenseMatrix_CopyExceptMN(self, A, m, n) + CopyExceptMN = _swig_new_instance_method(_densemat.DenseMatrix_CopyExceptMN) def AddMatrix(self, *args): r""" @@ -423,34 +500,72 @@ def AddMatrix(self, *args): AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co) """ return _densemat.DenseMatrix_AddMatrix(self, *args) + AddMatrix = _swig_new_instance_method(_densemat.DenseMatrix_AddMatrix) def AddToVector(self, offset, v): r"""AddToVector(DenseMatrix self, int offset, Vector v)""" return _densemat.DenseMatrix_AddToVector(self, offset, v) + AddToVector = _swig_new_instance_method(_densemat.DenseMatrix_AddToVector) def GetFromVector(self, offset, v): r"""GetFromVector(DenseMatrix self, int offset, Vector v)""" return _densemat.DenseMatrix_GetFromVector(self, offset, v) + GetFromVector = _swig_new_instance_method(_densemat.DenseMatrix_GetFromVector) def AdjustDofDirection(self, dofs): r"""AdjustDofDirection(DenseMatrix self, intArray dofs)""" return _densemat.DenseMatrix_AdjustDofDirection(self, dofs) + AdjustDofDirection = _swig_new_instance_method(_densemat.DenseMatrix_AdjustDofDirection) def Threshold(self, eps): r"""Threshold(DenseMatrix self, double eps)""" return _densemat.DenseMatrix_Threshold(self, eps) + Threshold = _swig_new_instance_method(_densemat.DenseMatrix_Threshold) def CheckFinite(self): r"""CheckFinite(DenseMatrix self) -> int""" return _densemat.DenseMatrix_CheckFinite(self) + CheckFinite = _swig_new_instance_method(_densemat.DenseMatrix_CheckFinite) def TestInversion(self): r"""TestInversion(DenseMatrix self)""" return _densemat.DenseMatrix_TestInversion(self) + TestInversion = _swig_new_instance_method(_densemat.DenseMatrix_TestInversion) def MemoryUsage(self): r"""MemoryUsage(DenseMatrix self) -> long""" return _densemat.DenseMatrix_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_densemat.DenseMatrix_MemoryUsage) + + def Read(self, on_dev=True): + r"""Read(DenseMatrix self, bool on_dev=True) -> double const""" + return _densemat.DenseMatrix_Read(self, on_dev) + Read = _swig_new_instance_method(_densemat.DenseMatrix_Read) + + def HostRead(self): + r"""HostRead(DenseMatrix self) -> double const *""" + return _densemat.DenseMatrix_HostRead(self) + HostRead = _swig_new_instance_method(_densemat.DenseMatrix_HostRead) + + def Write(self, on_dev=True): + r"""Write(DenseMatrix self, bool on_dev=True) -> double""" + return _densemat.DenseMatrix_Write(self, on_dev) + Write = _swig_new_instance_method(_densemat.DenseMatrix_Write) + + def HostWrite(self): + r"""HostWrite(DenseMatrix self) -> double *""" + return _densemat.DenseMatrix_HostWrite(self) + HostWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostWrite) + + def ReadWrite(self, on_dev=True): + r"""ReadWrite(DenseMatrix self, bool on_dev=True) -> double""" + return _densemat.DenseMatrix_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_ReadWrite) + + def HostReadWrite(self): + r"""HostReadWrite(DenseMatrix self) -> double *""" + return _densemat.DenseMatrix_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostReadWrite) __swig_destroy__ = _densemat.delete_DenseMatrix def Assign(self, *args): @@ -496,6 +611,7 @@ def __setitem__(self, *args): def GetDataArray(self): r"""GetDataArray(DenseMatrix self) -> PyObject *""" return _densemat.DenseMatrix_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_densemat.DenseMatrix_GetDataArray) def Print(self, *args): r""" @@ -503,6 +619,7 @@ def Print(self, *args): Print(DenseMatrix self, char const * file, int precision=8) """ return _densemat.DenseMatrix_Print(self, *args) + Print = _swig_new_instance_method(_densemat.DenseMatrix_Print) def PrintT(self, *args): r""" @@ -510,6 +627,7 @@ def PrintT(self, *args): PrintT(DenseMatrix self, char const * file, int precision=8) """ return _densemat.DenseMatrix_PrintT(self, *args) + PrintT = _swig_new_instance_method(_densemat.DenseMatrix_PrintT) def PrintMatlab(self, *args): r""" @@ -517,102 +635,136 @@ def PrintMatlab(self, *args): PrintMatlab(DenseMatrix self, char const * file, int precision=8) """ return _densemat.DenseMatrix_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_densemat.DenseMatrix_PrintMatlab) # Register DenseMatrix in _densemat: _densemat.DenseMatrix_swigregister(DenseMatrix) +def LinearSolve(A, X, TOL=1.e-9): + r"""LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool""" + return _densemat.LinearSolve(A, X, TOL) +LinearSolve = _densemat.LinearSolve + def AddMult(b, c, a): r"""AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)""" return _densemat.AddMult(b, c, a) +AddMult = _densemat.AddMult + +def AddMult_a(alpha, b, c, a): + r"""AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)""" + return _densemat.AddMult_a(alpha, b, c, a) +AddMult_a = _densemat.AddMult_a def CalcAdjugate(a, adja): r"""CalcAdjugate(DenseMatrix a, DenseMatrix adja)""" return _densemat.CalcAdjugate(a, adja) +CalcAdjugate = _densemat.CalcAdjugate def CalcAdjugateTranspose(a, adjat): r"""CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)""" return _densemat.CalcAdjugateTranspose(a, adjat) +CalcAdjugateTranspose = _densemat.CalcAdjugateTranspose def CalcInverse(a, inva): r"""CalcInverse(DenseMatrix a, DenseMatrix inva)""" return _densemat.CalcInverse(a, inva) +CalcInverse = _densemat.CalcInverse def CalcInverseTranspose(a, inva): r"""CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)""" return _densemat.CalcInverseTranspose(a, inva) +CalcInverseTranspose = _densemat.CalcInverseTranspose def CalcOrtho(J, n): r"""CalcOrtho(DenseMatrix J, Vector n)""" return _densemat.CalcOrtho(J, n) +CalcOrtho = _densemat.CalcOrtho def MultAAt(a, aat): r"""MultAAt(DenseMatrix a, DenseMatrix aat)""" return _densemat.MultAAt(a, aat) +MultAAt = _densemat.MultAAt def MultADAt(A, D, ADAt): r"""MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)""" return _densemat.MultADAt(A, D, ADAt) +MultADAt = _densemat.MultADAt def AddMultADAt(A, D, ADAt): r"""AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)""" return _densemat.AddMultADAt(A, D, ADAt) +AddMultADAt = _densemat.AddMultADAt def MultABt(A, B, ABt): r"""MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)""" return _densemat.MultABt(A, B, ABt) +MultABt = _densemat.MultABt def MultADBt(A, D, B, ADBt): r"""MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)""" return _densemat.MultADBt(A, D, B, ADBt) +MultADBt = _densemat.MultADBt def AddMultABt(A, B, ABt): r"""AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)""" return _densemat.AddMultABt(A, B, ABt) +AddMultABt = _densemat.AddMultABt def AddMultADBt(A, D, B, ADBt): r"""AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)""" return _densemat.AddMultADBt(A, D, B, ADBt) +AddMultADBt = _densemat.AddMultADBt def AddMult_a_ABt(a, A, B, ABt): r"""AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)""" return _densemat.AddMult_a_ABt(a, A, B, ABt) +AddMult_a_ABt = _densemat.AddMult_a_ABt def MultAtB(A, B, AtB): r"""MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)""" return _densemat.MultAtB(A, B, AtB) +MultAtB = _densemat.MultAtB def AddMult_a_AAt(a, A, AAt): r"""AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)""" return _densemat.AddMult_a_AAt(a, A, AAt) +AddMult_a_AAt = _densemat.AddMult_a_AAt def Mult_a_AAt(a, A, AAt): r"""Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)""" return _densemat.Mult_a_AAt(a, A, AAt) +Mult_a_AAt = _densemat.Mult_a_AAt def MultVVt(v, vvt): r"""MultVVt(Vector v, DenseMatrix vvt)""" return _densemat.MultVVt(v, vvt) +MultVVt = _densemat.MultVVt def MultVWt(v, w, VWt): r"""MultVWt(Vector v, Vector w, DenseMatrix VWt)""" return _densemat.MultVWt(v, w, VWt) +MultVWt = _densemat.MultVWt def AddMultVWt(v, w, VWt): r"""AddMultVWt(Vector v, Vector w, DenseMatrix VWt)""" return _densemat.AddMultVWt(v, w, VWt) +AddMultVWt = _densemat.AddMultVWt def AddMultVVt(v, VWt): r"""AddMultVVt(Vector v, DenseMatrix VWt)""" return _densemat.AddMultVVt(v, VWt) +AddMultVVt = _densemat.AddMultVVt def AddMult_a_VWt(a, v, w, VWt): r"""AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)""" return _densemat.AddMult_a_VWt(a, v, w, VWt) +AddMult_a_VWt = _densemat.AddMult_a_VWt def AddMult_a_VVt(a, v, VVt): r"""AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)""" return _densemat.AddMult_a_VVt(a, v, VVt) +AddMult_a_VVt = _densemat.AddMult_a_VVt class LUFactors(object): r"""Proxy of C++ mfem::LUFactors class.""" @@ -630,50 +782,66 @@ def __init__(self, *args): """ _densemat.LUFactors_swiginit(self, _densemat.new_LUFactors(*args)) - def Factor(self, m): - r"""Factor(LUFactors self, int m)""" - return _densemat.LUFactors_Factor(self, m) + def Factor(self, m, TOL=0.0): + r"""Factor(LUFactors self, int m, double TOL=0.0) -> bool""" + return _densemat.LUFactors_Factor(self, m, TOL) + Factor = _swig_new_instance_method(_densemat.LUFactors_Factor) def Det(self, m): r"""Det(LUFactors self, int m) -> double""" return _densemat.LUFactors_Det(self, m) + Det = _swig_new_instance_method(_densemat.LUFactors_Det) def Mult(self, m, n, X): r"""Mult(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_Mult(self, m, n, X) + Mult = _swig_new_instance_method(_densemat.LUFactors_Mult) def LSolve(self, m, n, X): r"""LSolve(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_LSolve(self, m, n, X) + LSolve = _swig_new_instance_method(_densemat.LUFactors_LSolve) def USolve(self, m, n, X): r"""USolve(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_USolve(self, m, n, X) + USolve = _swig_new_instance_method(_densemat.LUFactors_USolve) def Solve(self, m, n, X): r"""Solve(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_Solve(self, m, n, X) + Solve = _swig_new_instance_method(_densemat.LUFactors_Solve) + + def RightSolve(self, m, n, X): + r"""RightSolve(LUFactors self, int m, int n, double * X)""" + return _densemat.LUFactors_RightSolve(self, m, n, X) + RightSolve = _swig_new_instance_method(_densemat.LUFactors_RightSolve) def GetInverseMatrix(self, m, X): r"""GetInverseMatrix(LUFactors self, int m, double * X)""" return _densemat.LUFactors_GetInverseMatrix(self, m, X) + GetInverseMatrix = _swig_new_instance_method(_densemat.LUFactors_GetInverseMatrix) @staticmethod def SubMult(m, n, r, A21, X1, X2): r"""SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)""" return _densemat.LUFactors_SubMult(m, n, r, A21, X1, X2) + SubMult = _swig_new_static_method(_densemat.LUFactors_SubMult) def BlockFactor(self, m, n, A12, A21, A22): r"""BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)""" return _densemat.LUFactors_BlockFactor(self, m, n, A12, A21, A22) + BlockFactor = _swig_new_instance_method(_densemat.LUFactors_BlockFactor) def BlockForwSolve(self, m, n, r, L21, B1, B2): r"""BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)""" return _densemat.LUFactors_BlockForwSolve(self, m, n, r, L21, B1, B2) + BlockForwSolve = _swig_new_instance_method(_densemat.LUFactors_BlockForwSolve) def BlockBackSolve(self, m, n, r, U12, X2, Y1): r"""BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)""" return _densemat.LUFactors_BlockBackSolve(self, m, n, r, U12, X2, Y1) + BlockBackSolve = _swig_new_instance_method(_densemat.LUFactors_BlockBackSolve) __swig_destroy__ = _densemat.delete_LUFactors # Register LUFactors in _densemat: @@ -682,6 +850,7 @@ def BlockBackSolve(self, m, n, r, U12, X2, Y1): def LUFactors_SubMult(m, n, r, A21, X1, X2): r"""LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)""" return _densemat.LUFactors_SubMult(m, n, r, A21, X1, X2) +LUFactors_SubMult = _densemat.LUFactors_SubMult class DenseMatrixInverse(mfem._par.matrix.MatrixInverse): r"""Proxy of C++ mfem::DenseMatrixInverse class.""" @@ -700,6 +869,7 @@ def __init__(self, *args): def Size(self): r"""Size(DenseMatrixInverse self) -> int""" return _densemat.DenseMatrixInverse_Size(self) + Size = _swig_new_instance_method(_densemat.DenseMatrixInverse_Size) def Factor(self, *args): r""" @@ -707,10 +877,12 @@ def Factor(self, *args): Factor(DenseMatrixInverse self, DenseMatrix mat) """ return _densemat.DenseMatrixInverse_Factor(self, *args) + Factor = _swig_new_instance_method(_densemat.DenseMatrixInverse_Factor) def SetOperator(self, op): r"""SetOperator(DenseMatrixInverse self, Operator op)""" return _densemat.DenseMatrixInverse_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_densemat.DenseMatrixInverse_SetOperator) def Mult(self, *args): r""" @@ -719,18 +891,22 @@ def Mult(self, *args): Mult(DenseMatrixInverse self, DenseMatrix X) """ return _densemat.DenseMatrixInverse_Mult(self, *args) + Mult = _swig_new_instance_method(_densemat.DenseMatrixInverse_Mult) def GetInverseMatrix(self, Ainv): r"""GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)""" return _densemat.DenseMatrixInverse_GetInverseMatrix(self, Ainv) + GetInverseMatrix = _swig_new_instance_method(_densemat.DenseMatrixInverse_GetInverseMatrix) def Det(self): r"""Det(DenseMatrixInverse self) -> double""" return _densemat.DenseMatrixInverse_Det(self) + Det = _swig_new_instance_method(_densemat.DenseMatrixInverse_Det) def TestInversion(self): r"""TestInversion(DenseMatrixInverse self)""" return _densemat.DenseMatrixInverse_TestInversion(self) + TestInversion = _swig_new_instance_method(_densemat.DenseMatrixInverse_TestInversion) __swig_destroy__ = _densemat.delete_DenseMatrixInverse # Register DenseMatrixInverse in _densemat: @@ -752,22 +928,27 @@ def __init__(self, *args): def Eval(self): r"""Eval(DenseMatrixEigensystem self)""" return _densemat.DenseMatrixEigensystem_Eval(self) + Eval = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eval) def Eigenvalues(self): r"""Eigenvalues(DenseMatrixEigensystem self) -> Vector""" return _densemat.DenseMatrixEigensystem_Eigenvalues(self) + Eigenvalues = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvalues) def Eigenvectors(self): r"""Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix""" return _densemat.DenseMatrixEigensystem_Eigenvectors(self) + Eigenvectors = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvectors) def Eigenvalue(self, i): r"""Eigenvalue(DenseMatrixEigensystem self, int i) -> double""" return _densemat.DenseMatrixEigensystem_Eigenvalue(self, i) + Eigenvalue = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvalue) def Eigenvector(self, i): r"""Eigenvector(DenseMatrixEigensystem self, int i) -> Vector""" return _densemat.DenseMatrixEigensystem_Eigenvector(self, i) + Eigenvector = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvector) __swig_destroy__ = _densemat.delete_DenseMatrixEigensystem # Register DenseMatrixEigensystem in _densemat: @@ -789,14 +970,17 @@ def __init__(self, *args): def Eval(self, M): r"""Eval(DenseMatrixSVD self, DenseMatrix M)""" return _densemat.DenseMatrixSVD_Eval(self, M) + Eval = _swig_new_instance_method(_densemat.DenseMatrixSVD_Eval) def Singularvalues(self): r"""Singularvalues(DenseMatrixSVD self) -> Vector""" return _densemat.DenseMatrixSVD_Singularvalues(self) + Singularvalues = _swig_new_instance_method(_densemat.DenseMatrixSVD_Singularvalues) def Singularvalue(self, i): r"""Singularvalue(DenseMatrixSVD self, int i) -> double""" return _densemat.DenseMatrixSVD_Singularvalue(self, i) + Singularvalue = _swig_new_instance_method(_densemat.DenseMatrixSVD_Singularvalue) __swig_destroy__ = _densemat.delete_DenseMatrixSVD # Register DenseMatrixSVD in _densemat: @@ -819,26 +1003,32 @@ def __init__(self, *args): def SizeI(self): r"""SizeI(DenseTensor self) -> int""" return _densemat.DenseTensor_SizeI(self) + SizeI = _swig_new_instance_method(_densemat.DenseTensor_SizeI) def SizeJ(self): r"""SizeJ(DenseTensor self) -> int""" return _densemat.DenseTensor_SizeJ(self) + SizeJ = _swig_new_instance_method(_densemat.DenseTensor_SizeJ) def SizeK(self): r"""SizeK(DenseTensor self) -> int""" return _densemat.DenseTensor_SizeK(self) + SizeK = _swig_new_instance_method(_densemat.DenseTensor_SizeK) def TotalSize(self): r"""TotalSize(DenseTensor self) -> int""" return _densemat.DenseTensor_TotalSize(self) + TotalSize = _swig_new_instance_method(_densemat.DenseTensor_TotalSize) def SetSize(self, i, j, k): r"""SetSize(DenseTensor self, int i, int j, int k)""" return _densemat.DenseTensor_SetSize(self, i, j, k) + SetSize = _swig_new_instance_method(_densemat.DenseTensor_SetSize) def UseExternalData(self, ext_data, i, j, k): r"""UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)""" return _densemat.DenseTensor_UseExternalData(self, ext_data, i, j, k) + UseExternalData = _swig_new_instance_method(_densemat.DenseTensor_UseExternalData) def __call__(self, *args): r""" @@ -848,10 +1038,12 @@ def __call__(self, *args): __call__(DenseTensor self, int i, int j, int k) -> double const & """ return _densemat.DenseTensor___call__(self, *args) + __call__ = _swig_new_instance_method(_densemat.DenseTensor___call__) def GetData(self, k): r"""GetData(DenseTensor self, int k) -> double *""" return _densemat.DenseTensor_GetData(self, k) + GetData = _swig_new_instance_method(_densemat.DenseTensor_GetData) def Data(self, *args): r""" @@ -859,6 +1051,7 @@ def Data(self, *args): Data(DenseTensor self) -> double const * """ return _densemat.DenseTensor_Data(self, *args) + Data = _swig_new_instance_method(_densemat.DenseTensor_Data) def GetMemory(self, *args): r""" @@ -866,18 +1059,52 @@ def GetMemory(self, *args): GetMemory(DenseTensor self) -> mfem::Memory< double > const & """ return _densemat.DenseTensor_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_densemat.DenseTensor_GetMemory) def AddMult(self, elem_dof, x, y): r"""AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)""" return _densemat.DenseTensor_AddMult(self, elem_dof, x, y) + AddMult = _swig_new_instance_method(_densemat.DenseTensor_AddMult) def Clear(self): r"""Clear(DenseTensor self)""" return _densemat.DenseTensor_Clear(self) + Clear = _swig_new_instance_method(_densemat.DenseTensor_Clear) def MemoryUsage(self): r"""MemoryUsage(DenseTensor self) -> long""" return _densemat.DenseTensor_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_densemat.DenseTensor_MemoryUsage) + + def Read(self, on_dev=True): + r"""Read(DenseTensor self, bool on_dev=True) -> double const""" + return _densemat.DenseTensor_Read(self, on_dev) + Read = _swig_new_instance_method(_densemat.DenseTensor_Read) + + def HostRead(self): + r"""HostRead(DenseTensor self) -> double const *""" + return _densemat.DenseTensor_HostRead(self) + HostRead = _swig_new_instance_method(_densemat.DenseTensor_HostRead) + + def Write(self, on_dev=True): + r"""Write(DenseTensor self, bool on_dev=True) -> double""" + return _densemat.DenseTensor_Write(self, on_dev) + Write = _swig_new_instance_method(_densemat.DenseTensor_Write) + + def HostWrite(self): + r"""HostWrite(DenseTensor self) -> double *""" + return _densemat.DenseTensor_HostWrite(self) + HostWrite = _swig_new_instance_method(_densemat.DenseTensor_HostWrite) + + def ReadWrite(self, on_dev=True): + r"""ReadWrite(DenseTensor self, bool on_dev=True) -> double""" + return _densemat.DenseTensor_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_densemat.DenseTensor_ReadWrite) + + def HostReadWrite(self): + r"""HostReadWrite(DenseTensor self) -> double *""" + return _densemat.DenseTensor_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_densemat.DenseTensor_HostReadWrite) __swig_destroy__ = _densemat.delete_DenseTensor def Assign(self, c): @@ -916,6 +1143,7 @@ def __setitem__(self, *args): def GetDataArray(self): r"""GetDataArray(DenseTensor self) -> PyObject *""" return _densemat.DenseTensor_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_densemat.DenseTensor_GetDataArray) # Register DenseTensor in _densemat: _densemat.DenseTensor_swigregister(DenseTensor) diff --git a/mfem/_par/densemat_wrap.cxx b/mfem/_par/densemat_wrap.cxx index aa7287d4..9d85a596 100644 --- a/mfem/_par/densemat_wrap.cxx +++ b/mfem/_par/densemat_wrap.cxx @@ -3087,15 +3087,18 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[19] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[20] #define SWIGTYPE_p_mfem__RAPOperator swig_types[21] -#define SWIGTYPE_p_mfem__Solver swig_types[22] -#define SWIGTYPE_p_mfem__Table swig_types[23] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[24] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[25] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[26] -#define SWIGTYPE_p_mfem__Vector swig_types[27] -#define SWIGTYPE_p_void swig_types[28] -static swig_type_info *swig_types[30]; -static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[22] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[23] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[24] +#define SWIGTYPE_p_mfem__Solver swig_types[25] +#define SWIGTYPE_p_mfem__Table swig_types[26] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[27] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[28] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[29] +#define SWIGTYPE_p_mfem__Vector swig_types[30] +#define SWIGTYPE_p_void swig_types[31] +static swig_type_info *swig_types[33]; +static swig_module_info swig_module = {swig_types, 32, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3525,6 +3528,20 @@ SWIGINTERNINLINE PyObject* #define SWIG_From_long PyInt_FromLong + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + SWIGINTERN void mfem_DenseMatrix_Assign__SWIG_0(mfem::DenseMatrix *self,double const v){ (* self) = v; } @@ -4409,6 +4426,108 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetData(PyObject *SWIGUNUSEDPARM(self), P } +SWIGINTERN PyObject *_wrap_DenseMatrix_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetMemory" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &(arg1)->GetMemory(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetMemory" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &((mfem::DenseMatrix const *)arg1)->GetMemory(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_GetMemory(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_GetMemory", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_GetMemory__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_GetMemory__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_GetMemory'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::GetMemory()\n" + " mfem::DenseMatrix::GetMemory() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_DenseMatrix_OwnsData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; @@ -7598,6 +7717,53 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SetRow" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_SetRow" "', argument " "3"" of type '" "double const *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + { + try { + (arg1)->SetRow(arg2,(double const *)arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -7648,6 +7814,53 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SetCol" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_SetCol" "', argument " "3"" of type '" "double const *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + { + try { + (arg1)->SetCol(arg2,(double const *)arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -7697,7 +7910,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -7767,7 +7980,8 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_DenseMatrix_SetRow__SWIG_0(self, argc, argv); @@ -7775,6 +7989,29 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { } } } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_SetRow__SWIG_1(self, argc, argv); + } + } + } + } if (argc == 3) { int _v; void *vptr = 0; @@ -7795,7 +8032,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DenseMatrix_SetRow__SWIG_1(self, argc, argv); + return _wrap_DenseMatrix_SetRow__SWIG_2(self, argc, argv); } } } @@ -7804,13 +8041,14 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_SetRow'.\n" " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::SetRow(int,double const *)\n" " mfem::DenseMatrix::SetRow(int,mfem::Vector const &)\n" " mfem::DenseMatrix::SetRow(int,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -7880,7 +8118,8 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_DenseMatrix_SetCol__SWIG_0(self, argc, argv); @@ -7888,6 +8127,29 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { } } } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_SetCol__SWIG_1(self, argc, argv); + } + } + } + } if (argc == 3) { int _v; void *vptr = 0; @@ -7908,7 +8170,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DenseMatrix_SetCol__SWIG_1(self, argc, argv); + return _wrap_DenseMatrix_SetCol__SWIG_2(self, argc, argv); } } } @@ -7917,6 +8179,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_SetCol'.\n" " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::SetCol(int,double const *)\n" " mfem::DenseMatrix::SetCol(int,mfem::Vector const &)\n" " mfem::DenseMatrix::SetCol(int,double)\n"); return 0; @@ -10253,23 +10516,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_delete_DenseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DenseMatrix" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - delete arg1; + result = (double *)((mfem::DenseMatrix const *)arg1)->Read(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10280,36 +10550,29 @@ SWIGINTERN PyObject *_wrap_delete_DenseMatrix(PyObject *SWIGUNUSEDPARM(self), Py // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); { try { - mfem_DenseMatrix_Assign__SWIG_0(arg1,arg2); + result = (double *)((mfem::DenseMatrix const *)arg1)->Read(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10320,39 +10583,114 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Read", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_Read__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseMatrix_Read__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Read'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::Read(bool) const\n" + " mfem::DenseMatrix::Read() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostRead" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + { + try { + result = (double *)((mfem::DenseMatrix const *)arg1)->HostRead(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - mfem_DenseMatrix_Assign__SWIG_1(arg1,(mfem::DenseMatrix const &)*arg2); + result = (double *)(arg1)->Write(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10363,30 +10701,29 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - PyObject *arg2 = (PyObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - arg2 = swig_obj[1]; { try { - mfem_DenseMatrix_Assign__SWIG_2(arg1,arg2); + result = (double *)(arg1)->Write(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10397,32 +10734,28 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Assign", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Write", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Assign__SWIG_1(self, argc, argv); - } + return _wrap_DenseMatrix_Write__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -10432,68 +10765,42 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_double(argv[1], NULL); + int res = SWIG_AsVal_bool(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DenseMatrix_Assign__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - _v = (argv[1] != 0); - if (_v) { - return _wrap_DenseMatrix_Assign__SWIG_2(self, argc, argv); + return _wrap_DenseMatrix_Write__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Assign'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Write'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::Assign(double const)\n" - " mfem::DenseMatrix::Assign(mfem::DenseMatrix const &)\n" - " mfem::DenseMatrix::Assign(PyObject *)\n"); + " mfem::DenseMatrix::Write(bool)\n" + " mfem::DenseMatrix::Write()\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; - double result; + PyObject *swig_obj[1] ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___getitem__", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___getitem__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (double)mfem_DenseMatrix___getitem__((mfem::DenseMatrix const *)arg1,arg2,arg3); + result = (double *)(arg1)->HostWrite(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10504,51 +10811,37 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - int arg2 ; - int arg3 ; - double arg4 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - PyObject *swig_obj[4] ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___setitem__", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___setitem__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DenseMatrix___setitem__" "', argument " "4"" of type '" "double""'"); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_ReadWrite" "', argument " "2"" of type '" "bool""'"); } - arg4 = static_cast< double >(val4); + arg2 = static_cast< bool >(val2); { try { - mfem_DenseMatrix___setitem__(arg1,arg2,arg3,arg4); + result = (double *)(arg1)->ReadWrite(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10559,31 +10852,29 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - PyObject *result = 0 ; + double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetDataArray" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { try { - result = (PyObject *)mfem_DenseMatrix_GetDataArray((mfem::DenseMatrix const *)arg1); + result = (double *)(arg1)->ReadWrite(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10594,31 +10885,456 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(sel // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = result; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_ReadWrite", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_ReadWrite__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseMatrix_ReadWrite__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_ReadWrite'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::ReadWrite(bool)\n" + " mfem::DenseMatrix::ReadWrite()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + { + try { + result = (double *)(arg1)->HostReadWrite(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_DenseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DenseMatrix" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + mfem_DenseMatrix_Assign__SWIG_0(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + { + try { + mfem_DenseMatrix_Assign__SWIG_1(arg1,(mfem::DenseMatrix const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + PyObject *arg2 = (PyObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + arg2 = swig_obj[1]; + { + try { + mfem_DenseMatrix_Assign__SWIG_2(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Assign", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_Assign__SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseMatrix_Assign__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (argv[1] != 0); + if (_v) { + return _wrap_DenseMatrix_Assign__SWIG_2(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Assign'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::Assign(double const)\n" + " mfem::DenseMatrix::Assign(mfem::DenseMatrix const &)\n" + " mfem::DenseMatrix::Assign(PyObject *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[3] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___getitem__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___getitem__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (double)mfem_DenseMatrix___getitem__((mfem::DenseMatrix const *)arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + int arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___setitem__", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___setitem__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DenseMatrix___setitem__" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + mfem_DenseMatrix___setitem__(arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetDataArray" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + result = (PyObject *)mfem_DenseMatrix_GetDataArray((mfem::DenseMatrix const *)arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } @@ -11148,66 +11864,214 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_DenseMatrix_PrintMatlab__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_DenseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintMatlab'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::PrintMatlab(std::ostream &) const\n" + " mfem::DenseMatrix::PrintMatlab() const\n" + " mfem::DenseMatrix::PrintMatlab(char const *,int)\n" + " mfem::DenseMatrix::PrintMatlab(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *DenseMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DenseMatrix, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DenseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = 0 ; + double *arg2 = (double *) 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearSolve" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + result = (bool)mfem::LinearSolve(*arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = 0 ; + double *arg2 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (bool)mfem::LinearSolve(*arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LinearSolve(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "LinearSolve", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_0(self, argc, argv); + return _wrap_LinearSolve__SWIG_1(self, argc, argv); } } } if (argc == 3) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_LinearSolve__SWIG_0(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintMatlab'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearSolve'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::DenseMatrix::PrintMatlab() const\n" - " mfem::DenseMatrix::PrintMatlab(char const *,int)\n" - " mfem::DenseMatrix::PrintMatlab(char const *)\n"); + " mfem::LinearSolve(mfem::DenseMatrix &,double *,double)\n" + " mfem::LinearSolve(mfem::DenseMatrix &,double *)\n"); return 0; } -SWIGINTERN PyObject *DenseMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DenseMatrix, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DenseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; @@ -11266,6 +12130,72 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } +SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double arg1 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + double val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "AddMult_a", 4, 4, swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + mfem::AddMult_a(arg1,(mfem::DenseMatrix const &)*arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; @@ -12688,15 +13618,18 @@ SWIGINTERN PyObject *_wrap_new_LUFactors(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + double val3 ; + int ecode3 = 0 ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Factor", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); @@ -12708,9 +13641,14 @@ SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyOb }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LUFactors_Factor" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - (arg1)->Factor(arg2); + result = (bool)(arg1)->Factor(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12721,13 +13659,115 @@ SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyOb // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); + } + arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (bool)(arg1)->Factor(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } +SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "LUFactors_Factor", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_LUFactors_Factor__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LUFactors_Factor__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LUFactors_Factor'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::LUFactors::Factor(int,double)\n" + " mfem::LUFactors::Factor(int)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; @@ -12836,10 +13876,65 @@ SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyOb int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_LSolve", 4, 4, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "LUFactors_LSolve", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_LSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); + } + arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_LSolve" "', argument " "4"" of type '" "double *""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + { + try { + ((mfem::LUFactors const *)arg1)->LSolve(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; + int arg2 ; + int arg3 ; + double *arg4 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "LUFactors_USolve", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_LSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_USolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { @@ -12856,12 +13951,12 @@ SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyOb } res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_LSolve" "', argument " "4"" of type '" "double *""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_USolve" "', argument " "4"" of type '" "double *""'"); } arg4 = reinterpret_cast< double * >(argp4); { try { - ((mfem::LUFactors const *)arg1)->LSolve(arg2,arg3,arg4); + ((mfem::LUFactors const *)arg1)->USolve(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12879,7 +13974,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -12891,10 +13986,10 @@ SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyOb int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_USolve", 4, 4, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "LUFactors_Solve", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_USolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Solve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { @@ -12911,12 +14006,12 @@ SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyOb } res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_USolve" "', argument " "4"" of type '" "double *""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_Solve" "', argument " "4"" of type '" "double *""'"); } arg4 = reinterpret_cast< double * >(argp4); { try { - ((mfem::LUFactors const *)arg1)->USolve(arg2,arg3,arg4); + ((mfem::LUFactors const *)arg1)->Solve(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12934,7 +14029,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -12946,10 +14041,10 @@ SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObj int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Solve", 4, 4, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "LUFactors_RightSolve", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Solve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_RightSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { @@ -12966,12 +14061,12 @@ SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObj } res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_Solve" "', argument " "4"" of type '" "double *""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_RightSolve" "', argument " "4"" of type '" "double *""'"); } arg4 = reinterpret_cast< double * >(argp4); { try { - ((mfem::LUFactors const *)arg1)->Solve(arg2,arg3,arg4); + ((mfem::LUFactors const *)arg1)->RightSolve(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15454,40 +16549,344 @@ SWIGINTERN PyObject *_wrap_DenseTensor___call__(PyObject *self, PyObject *args) } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor___call__'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor___call__'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::operator ()(int)\n" + " mfem::DenseTensor::operator ()(int) const\n" + " mfem::DenseTensor::operator ()(int,int,int)\n" + " mfem::DenseTensor::operator ()(int,int,int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + double *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "DenseTensor_GetData", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (double *)(arg1)->GetData(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (double *)(arg1)->Data(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (double *)((mfem::DenseTensor const *)arg1)->Data(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_Data(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Data", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_Data__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_Data__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Data'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::Data()\n" + " mfem::DenseTensor::Data() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (mfem::Memory< double > *) &(arg1)->GetMemory(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (mfem::Memory< double > *) &((mfem::DenseTensor const *)arg1)->GetMemory(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_GetMemory", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_GetMemory__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_GetMemory__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_GetMemory'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::operator ()(int)\n" - " mfem::DenseTensor::operator ()(int) const\n" - " mfem::DenseTensor::operator ()(int,int,int)\n" - " mfem::DenseTensor::operator ()(int,int,int) const\n"); + " mfem::DenseTensor::GetMemory()\n" + " mfem::DenseTensor::GetMemory() const\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - int arg2 ; + mfem::Table *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - double *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_GetData", 2, 2, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DenseTensor_AddMult", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_AddMult" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + arg2 = reinterpret_cast< mfem::Table * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + ((mfem::DenseTensor const *)arg1)->AddMult((mfem::Table const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Clear" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)(arg1)->GetData(arg2); + (arg1)->Clear(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15498,29 +16897,72 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), P // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + long result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_MemoryUsage" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (long)((mfem::DenseTensor const *)arg1)->MemoryUsage(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_long(static_cast< long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - result = (double *)(arg1)->Data(); + result = (double *)((mfem::DenseTensor const *)arg1)->Read(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15538,7 +16980,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; @@ -15548,12 +16990,12 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(sel if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)((mfem::DenseTensor const *)arg1)->Data(); + result = (double *)((mfem::DenseTensor const *)arg1)->Read(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15571,13 +17013,13 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseTensor_Data(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_Read(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Data", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Read", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) { int _v; @@ -15585,44 +17027,52 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_Data__SWIG_0(self, argc, argv); + return _wrap_DenseTensor_Read__SWIG_1(self, argc, argv); } } - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_Data__SWIG_1(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseTensor_Read__SWIG_0(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Data'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Read'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::Data()\n" - " mfem::DenseTensor::Data() const\n"); + " mfem::DenseTensor::Read(bool) const\n" + " mfem::DenseTensor::Read() const\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< double > *result = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_HostRead" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (mfem::Memory< double > *) &(arg1)->GetMemory(); + result = (double *)((mfem::DenseTensor const *)arg1)->HostRead(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15633,29 +17083,70 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPAR // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< double > *result = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)(arg1)->Write(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (mfem::Memory< double > *) &((mfem::DenseTensor const *)arg1)->GetMemory(); + result = (double *)(arg1)->Write(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15666,20 +17157,20 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPAR // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_Write(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_GetMemory", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Write", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) { int _v; @@ -15687,77 +17178,93 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_GetMemory__SWIG_0(self, argc, argv); + return _wrap_DenseTensor_Write__SWIG_1(self, argc, argv); } } - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_GetMemory__SWIG_1(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseTensor_Write__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Write'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::Write(bool)\n" + " mfem::DenseTensor::Write()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_HostWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (double *)(arg1)->HostWrite(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_GetMemory'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::GetMemory()\n" - " mfem::DenseTensor::GetMemory() const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - mfem::Table *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_AddMult", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_AddMult" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - ((mfem::DenseTensor const *)arg1)->AddMult((mfem::Table const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + result = (double *)(arg1)->ReadWrite(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15768,30 +17275,29 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Clear" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - (arg1)->Clear(); + result = (double *)(arg1)->ReadWrite(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15802,31 +17308,73 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Clear(PyObject *SWIGUNUSEDPARM(self), PyO // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_ReadWrite", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_ReadWrite__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseTensor_ReadWrite__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_ReadWrite'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::ReadWrite(bool)\n" + " mfem::DenseTensor::ReadWrite()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - long result; + double *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_MemoryUsage" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_HostReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (long)((mfem::DenseTensor const *)arg1)->MemoryUsage(); + result = (double *)(arg1)->HostReadWrite(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15837,7 +17385,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_long(static_cast< long >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; @@ -16199,6 +17747,7 @@ SWIGINTERN PyObject *DenseTensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_DenseMatrix", _wrap_new_DenseMatrix, METH_VARARGS, "\n" "DenseMatrix()\n" "DenseMatrix(DenseMatrix arg1)\n" @@ -16218,6 +17767,10 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_Data", _wrap_DenseMatrix_Data, METH_O, "DenseMatrix_Data(DenseMatrix self) -> double *"}, { "DenseMatrix_GetData", _wrap_DenseMatrix_GetData, METH_O, "DenseMatrix_GetData(DenseMatrix self) -> double *"}, + { "DenseMatrix_GetMemory", _wrap_DenseMatrix_GetMemory, METH_VARARGS, "\n" + "DenseMatrix_GetMemory(DenseMatrix self) -> mfem::Memory< double >\n" + "DenseMatrix_GetMemory(DenseMatrix self) -> mfem::Memory< double > const &\n" + ""}, { "DenseMatrix_OwnsData", _wrap_DenseMatrix_OwnsData, METH_O, "DenseMatrix_OwnsData(DenseMatrix self) -> bool"}, { "DenseMatrix___call__", _wrap_DenseMatrix___call__, METH_VARARGS, "\n" "DenseMatrix___call__(DenseMatrix self, int i, int j) -> double\n" @@ -16294,10 +17847,12 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "DenseMatrix_GetColumnReference(DenseMatrix self, int c, Vector col)"}, { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" + "DenseMatrix_SetRow(DenseMatrix self, int r, double const * row)\n" "DenseMatrix_SetRow(DenseMatrix self, int r, Vector row)\n" "DenseMatrix_SetRow(DenseMatrix self, int row, double value)\n" ""}, { "DenseMatrix_SetCol", _wrap_DenseMatrix_SetCol, METH_VARARGS, "\n" + "DenseMatrix_SetCol(DenseMatrix self, int c, double const * col)\n" "DenseMatrix_SetCol(DenseMatrix self, int c, Vector col)\n" "DenseMatrix_SetCol(DenseMatrix self, int col, double value)\n" ""}, @@ -16340,6 +17895,12 @@ static PyMethodDef SwigMethods[] = { { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "DenseMatrix_CheckFinite(DenseMatrix self) -> int"}, { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "DenseMatrix_TestInversion(DenseMatrix self)"}, { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "DenseMatrix_MemoryUsage(DenseMatrix self) -> long"}, + { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "DenseMatrix_Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "DenseMatrix_HostRead(DenseMatrix self) -> double const *"}, + { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "DenseMatrix_Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "DenseMatrix_HostWrite(DenseMatrix self) -> double *"}, + { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "DenseMatrix_ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "DenseMatrix_HostReadWrite(DenseMatrix self) -> double *"}, { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" "DenseMatrix_Assign(DenseMatrix self, double const v)\n" @@ -16363,7 +17924,9 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, + { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, @@ -16394,12 +17957,13 @@ static PyMethodDef SwigMethods[] = { "LUFactors()\n" "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" ""}, - { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "LUFactors_Factor(LUFactors self, int m)"}, + { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "LUFactors_Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "LUFactors_Det(LUFactors self, int m) -> double"}, { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "LUFactors_Mult(LUFactors self, int m, int n, double * X)"}, { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LUFactors_LSolve(LUFactors self, int m, int n, double * X)"}, { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "LUFactors_USolve(LUFactors self, int m, int n, double * X)"}, { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "LUFactors_Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "LUFactors_RightSolve(LUFactors self, int m, int n, double * X)"}, { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "LUFactors_GetInverseMatrix(LUFactors self, int m, double * X)"}, { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "LUFactors_BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, @@ -16481,6 +18045,12 @@ static PyMethodDef SwigMethods[] = { { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "DenseTensor_AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "DenseTensor_Clear(DenseTensor self)"}, { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "DenseTensor_MemoryUsage(DenseTensor self) -> long"}, + { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "DenseTensor_Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "DenseTensor_HostRead(DenseTensor self) -> double const *"}, + { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "DenseTensor_Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "DenseTensor_HostWrite(DenseTensor self) -> double *"}, + { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "DenseTensor_ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "DenseTensor_HostReadWrite(DenseTensor self) -> double *"}, { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "DenseTensor_Assign(DenseTensor self, double const c)"}, { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" @@ -16495,6 +18065,321 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_DenseMatrix", _wrap_new_DenseMatrix, METH_VARARGS, "\n" + "DenseMatrix()\n" + "DenseMatrix(DenseMatrix arg1)\n" + "DenseMatrix(int s)\n" + "DenseMatrix(int m, int n)\n" + "DenseMatrix(DenseMatrix mat, char ch)\n" + "new_DenseMatrix(double * d, int h, int w) -> DenseMatrix\n" + ""}, + { "DenseMatrix_UseExternalData", _wrap_DenseMatrix_UseExternalData, METH_VARARGS, "UseExternalData(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_Reset", _wrap_DenseMatrix_Reset, METH_VARARGS, "Reset(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_ClearExternalData", _wrap_DenseMatrix_ClearExternalData, METH_O, "ClearExternalData(DenseMatrix self)"}, + { "DenseMatrix_Clear", _wrap_DenseMatrix_Clear, METH_O, "Clear(DenseMatrix self)"}, + { "DenseMatrix_Size", _wrap_DenseMatrix_Size, METH_O, "Size(DenseMatrix self) -> int"}, + { "DenseMatrix_SetSize", _wrap_DenseMatrix_SetSize, METH_VARARGS, "\n" + "SetSize(DenseMatrix self, int s)\n" + "SetSize(DenseMatrix self, int h, int w)\n" + ""}, + { "DenseMatrix_Data", _wrap_DenseMatrix_Data, METH_O, "Data(DenseMatrix self) -> double *"}, + { "DenseMatrix_GetData", _wrap_DenseMatrix_GetData, METH_O, "GetData(DenseMatrix self) -> double *"}, + { "DenseMatrix_GetMemory", _wrap_DenseMatrix_GetMemory, METH_VARARGS, "\n" + "GetMemory(DenseMatrix self) -> mfem::Memory< double >\n" + "GetMemory(DenseMatrix self) -> mfem::Memory< double > const &\n" + ""}, + { "DenseMatrix_OwnsData", _wrap_DenseMatrix_OwnsData, METH_O, "OwnsData(DenseMatrix self) -> bool"}, + { "DenseMatrix___call__", _wrap_DenseMatrix___call__, METH_VARARGS, "\n" + "__call__(DenseMatrix self, int i, int j) -> double\n" + "__call__(DenseMatrix self, int i, int j) -> double const &\n" + ""}, + { "DenseMatrix___mul__", _wrap_DenseMatrix___mul__, METH_VARARGS, "__mul__(DenseMatrix self, DenseMatrix m) -> double"}, + { "DenseMatrix_Trace", _wrap_DenseMatrix_Trace, METH_O, "Trace(DenseMatrix self) -> double"}, + { "DenseMatrix_Elem", _wrap_DenseMatrix_Elem, METH_VARARGS, "\n" + "Elem(DenseMatrix self, int i, int j) -> double\n" + "Elem(DenseMatrix self, int i, int j) -> double const &\n" + ""}, + { "DenseMatrix_Mult", _wrap_DenseMatrix_Mult, METH_VARARGS, "\n" + "Mult(DenseMatrix self, double const * x, double * y)\n" + "Mult(DenseMatrix self, Vector x, Vector y)\n" + ""}, + { "DenseMatrix_MultTranspose", _wrap_DenseMatrix_MultTranspose, METH_VARARGS, "\n" + "MultTranspose(DenseMatrix self, double const * x, double * y)\n" + "MultTranspose(DenseMatrix self, Vector x, Vector y)\n" + ""}, + { "DenseMatrix_AddMult", _wrap_DenseMatrix_AddMult, METH_VARARGS, "AddMult(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose", _wrap_DenseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMult_a", _wrap_DenseMatrix_AddMult_a, METH_VARARGS, "AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose_a", _wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS, "AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_LeftScaling", _wrap_DenseMatrix_LeftScaling, METH_VARARGS, "LeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvLeftScaling", _wrap_DenseMatrix_InvLeftScaling, METH_VARARGS, "InvLeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_RightScaling", _wrap_DenseMatrix_RightScaling, METH_VARARGS, "RightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvRightScaling", _wrap_DenseMatrix_InvRightScaling, METH_VARARGS, "InvRightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_SymmetricScaling", _wrap_DenseMatrix_SymmetricScaling, METH_VARARGS, "SymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvSymmetricScaling", _wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS, "InvSymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InnerProduct", _wrap_DenseMatrix_InnerProduct, METH_VARARGS, "\n" + "InnerProduct(DenseMatrix self, double const * x, double const * y) -> double\n" + "InnerProduct(DenseMatrix self, Vector x, Vector y) -> double\n" + ""}, + { "DenseMatrix_Inverse", _wrap_DenseMatrix_Inverse, METH_O, "Inverse(DenseMatrix self) -> MatrixInverse"}, + { "DenseMatrix_Invert", _wrap_DenseMatrix_Invert, METH_O, "Invert(DenseMatrix self)"}, + { "DenseMatrix_SquareRootInverse", _wrap_DenseMatrix_SquareRootInverse, METH_O, "SquareRootInverse(DenseMatrix self)"}, + { "DenseMatrix_Det", _wrap_DenseMatrix_Det, METH_O, "Det(DenseMatrix self) -> double"}, + { "DenseMatrix_Weight", _wrap_DenseMatrix_Weight, METH_O, "Weight(DenseMatrix self) -> double"}, + { "DenseMatrix_Set", _wrap_DenseMatrix_Set, METH_VARARGS, "\n" + "Set(DenseMatrix self, double alpha, double const * A)\n" + "Set(DenseMatrix self, double alpha, DenseMatrix A)\n" + ""}, + { "DenseMatrix_Add", _wrap_DenseMatrix_Add, METH_VARARGS, "Add(DenseMatrix self, double const c, DenseMatrix A)"}, + { "DenseMatrix___iadd__", _wrap_DenseMatrix___iadd__, METH_VARARGS, "\n" + "__iadd__(DenseMatrix self, double const * m) -> DenseMatrix\n" + "__iadd__(DenseMatrix self, DenseMatrix m) -> DenseMatrix\n" + ""}, + { "DenseMatrix___isub__", _wrap_DenseMatrix___isub__, METH_VARARGS, "__isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, + { "DenseMatrix___imul__", _wrap_DenseMatrix___imul__, METH_VARARGS, "__imul__(DenseMatrix self, double c) -> DenseMatrix"}, + { "DenseMatrix_Neg", _wrap_DenseMatrix_Neg, METH_O, "Neg(DenseMatrix self)"}, + { "DenseMatrix_Norm2", _wrap_DenseMatrix_Norm2, METH_VARARGS, "Norm2(DenseMatrix self, double * v)"}, + { "DenseMatrix_MaxMaxNorm", _wrap_DenseMatrix_MaxMaxNorm, METH_O, "MaxMaxNorm(DenseMatrix self) -> double"}, + { "DenseMatrix_FNorm", _wrap_DenseMatrix_FNorm, METH_O, "FNorm(DenseMatrix self) -> double"}, + { "DenseMatrix_FNorm2", _wrap_DenseMatrix_FNorm2, METH_O, "FNorm2(DenseMatrix self) -> double"}, + { "DenseMatrix_Eigenvalues", _wrap_DenseMatrix_Eigenvalues, METH_VARARGS, "\n" + "Eigenvalues(DenseMatrix self, Vector ev)\n" + "Eigenvalues(DenseMatrix self, Vector ev, DenseMatrix evect)\n" + "Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev)\n" + "Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" + ""}, + { "DenseMatrix_Eigensystem", _wrap_DenseMatrix_Eigensystem, METH_VARARGS, "\n" + "Eigensystem(DenseMatrix self, Vector ev, DenseMatrix evect)\n" + "Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" + ""}, + { "DenseMatrix_SingularValues", _wrap_DenseMatrix_SingularValues, METH_VARARGS, "SingularValues(DenseMatrix self, Vector sv)"}, + { "DenseMatrix_Rank", _wrap_DenseMatrix_Rank, METH_VARARGS, "Rank(DenseMatrix self, double tol) -> int"}, + { "DenseMatrix_CalcSingularvalue", _wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS, "CalcSingularvalue(DenseMatrix self, int const i) -> double"}, + { "DenseMatrix_CalcEigenvalues", _wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS, "CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, + { "DenseMatrix_GetRow", _wrap_DenseMatrix_GetRow, METH_VARARGS, "GetRow(DenseMatrix self, int r, Vector row)"}, + { "DenseMatrix_GetColumn", _wrap_DenseMatrix_GetColumn, METH_VARARGS, "\n" + "GetColumn(DenseMatrix self, int c, Vector col)\n" + "GetColumn(DenseMatrix self, int col) -> double\n" + "GetColumn(DenseMatrix self, int col) -> double const *\n" + ""}, + { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "GetColumnReference(DenseMatrix self, int c, Vector col)"}, + { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" + "SetRow(DenseMatrix self, int r, double const * row)\n" + "SetRow(DenseMatrix self, int r, Vector row)\n" + "SetRow(DenseMatrix self, int row, double value)\n" + ""}, + { "DenseMatrix_SetCol", _wrap_DenseMatrix_SetCol, METH_VARARGS, "\n" + "SetCol(DenseMatrix self, int c, double const * col)\n" + "SetCol(DenseMatrix self, int c, Vector col)\n" + "SetCol(DenseMatrix self, int col, double value)\n" + ""}, + { "DenseMatrix_GetDiag", _wrap_DenseMatrix_GetDiag, METH_VARARGS, "GetDiag(DenseMatrix self, Vector d)"}, + { "DenseMatrix_Getl1Diag", _wrap_DenseMatrix_Getl1Diag, METH_VARARGS, "Getl1Diag(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetRowSums", _wrap_DenseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(DenseMatrix self, Vector l)"}, + { "DenseMatrix_Diag", _wrap_DenseMatrix_Diag, METH_VARARGS, "\n" + "Diag(DenseMatrix self, double c, int n)\n" + "Diag(DenseMatrix self, double * diag, int n)\n" + ""}, + { "DenseMatrix_Transpose", _wrap_DenseMatrix_Transpose, METH_VARARGS, "\n" + "Transpose(DenseMatrix self)\n" + "Transpose(DenseMatrix self, DenseMatrix A)\n" + ""}, + { "DenseMatrix_Symmetrize", _wrap_DenseMatrix_Symmetrize, METH_O, "Symmetrize(DenseMatrix self)"}, + { "DenseMatrix_Lump", _wrap_DenseMatrix_Lump, METH_O, "Lump(DenseMatrix self)"}, + { "DenseMatrix_GradToCurl", _wrap_DenseMatrix_GradToCurl, METH_VARARGS, "GradToCurl(DenseMatrix self, DenseMatrix curl)"}, + { "DenseMatrix_GradToDiv", _wrap_DenseMatrix_GradToDiv, METH_VARARGS, "GradToDiv(DenseMatrix self, Vector div)"}, + { "DenseMatrix_CopyRows", _wrap_DenseMatrix_CopyRows, METH_VARARGS, "CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, + { "DenseMatrix_CopyCols", _wrap_DenseMatrix_CopyCols, METH_VARARGS, "CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, + { "DenseMatrix_CopyMNt", _wrap_DenseMatrix_CopyMNt, METH_VARARGS, "CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, + { "DenseMatrix_CopyMN", _wrap_DenseMatrix_CopyMN, METH_VARARGS, "\n" + "CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco)\n" + "CopyMN(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)\n" + "CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco, int row_offset, int col_offset)\n" + ""}, + { "DenseMatrix_CopyMNDiag", _wrap_DenseMatrix_CopyMNDiag, METH_VARARGS, "\n" + "CopyMNDiag(DenseMatrix self, double c, int n, int row_offset, int col_offset)\n" + "CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset)\n" + ""}, + { "DenseMatrix_CopyExceptMN", _wrap_DenseMatrix_CopyExceptMN, METH_VARARGS, "CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, + { "DenseMatrix_AddMatrix", _wrap_DenseMatrix_AddMatrix, METH_VARARGS, "\n" + "AddMatrix(DenseMatrix self, DenseMatrix A, int ro, int co)\n" + "AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co)\n" + ""}, + { "DenseMatrix_AddToVector", _wrap_DenseMatrix_AddToVector, METH_VARARGS, "AddToVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_GetFromVector", _wrap_DenseMatrix_GetFromVector, METH_VARARGS, "GetFromVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_AdjustDofDirection", _wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS, "AdjustDofDirection(DenseMatrix self, intArray dofs)"}, + { "DenseMatrix_Threshold", _wrap_DenseMatrix_Threshold, METH_VARARGS, "Threshold(DenseMatrix self, double eps)"}, + { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "CheckFinite(DenseMatrix self) -> int"}, + { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "TestInversion(DenseMatrix self)"}, + { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "MemoryUsage(DenseMatrix self) -> long"}, + { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "HostRead(DenseMatrix self) -> double const *"}, + { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "HostWrite(DenseMatrix self) -> double *"}, + { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "HostReadWrite(DenseMatrix self) -> double *"}, + { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, + { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" + "Assign(DenseMatrix self, double const v)\n" + "Assign(DenseMatrix self, DenseMatrix m)\n" + "Assign(DenseMatrix self, PyObject * numpymat)\n" + ""}, + { "DenseMatrix___getitem__", _wrap_DenseMatrix___getitem__, METH_VARARGS, "__getitem__(DenseMatrix self, int const i, int const j) -> double const"}, + { "DenseMatrix___setitem__", _wrap_DenseMatrix___setitem__, METH_VARARGS, "__setitem__(DenseMatrix self, int i, int j, double const v)"}, + { "DenseMatrix_GetDataArray", _wrap_DenseMatrix_GetDataArray, METH_O, "GetDataArray(DenseMatrix self) -> PyObject *"}, + { "DenseMatrix_Print", _wrap_DenseMatrix_Print, METH_VARARGS, "\n" + "Print(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" + "Print(DenseMatrix self, char const * file, int precision=8)\n" + ""}, + { "DenseMatrix_PrintT", _wrap_DenseMatrix_PrintT, METH_VARARGS, "\n" + "PrintT(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" + "PrintT(DenseMatrix self, char const * file, int precision=8)\n" + ""}, + { "DenseMatrix_PrintMatlab", _wrap_DenseMatrix_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(DenseMatrix self, std::ostream & out=mfem::out)\n" + "PrintMatlab(DenseMatrix self, char const * file, int precision=8)\n" + ""}, + { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, + { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, + { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, + { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, + { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, + { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, + { "CalcInverseTranspose", _wrap_CalcInverseTranspose, METH_VARARGS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, + { "CalcOrtho", _wrap_CalcOrtho, METH_VARARGS, "CalcOrtho(DenseMatrix J, Vector n)"}, + { "MultAAt", _wrap_MultAAt, METH_VARARGS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, + { "MultADAt", _wrap_MultADAt, METH_VARARGS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "AddMultADAt", _wrap_AddMultADAt, METH_VARARGS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "MultABt", _wrap_MultABt, METH_VARARGS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultADBt", _wrap_MultADBt, METH_VARARGS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMultABt", _wrap_AddMultABt, METH_VARARGS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "AddMultADBt", _wrap_AddMultADBt, METH_VARARGS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMult_a_ABt", _wrap_AddMult_a_ABt, METH_VARARGS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultAtB", _wrap_MultAtB, METH_VARARGS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, + { "AddMult_a_AAt", _wrap_AddMult_a_AAt, METH_VARARGS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "Mult_a_AAt", _wrap_Mult_a_AAt, METH_VARARGS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "MultVVt", _wrap_MultVVt, METH_VARARGS, "MultVVt(Vector v, DenseMatrix vvt)"}, + { "MultVWt", _wrap_MultVWt, METH_VARARGS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVWt", _wrap_AddMultVWt, METH_VARARGS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVVt", _wrap_AddMultVVt, METH_VARARGS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, + { "AddMult_a_VWt", _wrap_AddMult_a_VWt, METH_VARARGS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMult_a_VVt", _wrap_AddMult_a_VVt, METH_VARARGS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, + { "LUFactors_data_set", _wrap_LUFactors_data_set, METH_VARARGS, "LUFactors_data_set(LUFactors self, double * data)"}, + { "LUFactors_data_get", _wrap_LUFactors_data_get, METH_O, "LUFactors_data_get(LUFactors self) -> double *"}, + { "LUFactors_ipiv_set", _wrap_LUFactors_ipiv_set, METH_VARARGS, "LUFactors_ipiv_set(LUFactors self, int * ipiv)"}, + { "LUFactors_ipiv_get", _wrap_LUFactors_ipiv_get, METH_O, "LUFactors_ipiv_get(LUFactors self) -> int *"}, + { "new_LUFactors", _wrap_new_LUFactors, METH_VARARGS, "\n" + "LUFactors()\n" + "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" + ""}, + { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, + { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "Det(LUFactors self, int m) -> double"}, + { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "Mult(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "USolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "RightSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(LUFactors self, int m, double * X)"}, + { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, + { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, + { "LUFactors_BlockForwSolve", _wrap_LUFactors_BlockForwSolve, METH_VARARGS, "BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, + { "LUFactors_BlockBackSolve", _wrap_LUFactors_BlockBackSolve, METH_VARARGS, "BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, + { "delete_LUFactors", _wrap_delete_LUFactors, METH_O, "delete_LUFactors(LUFactors self)"}, + { "LUFactors_swigregister", LUFactors_swigregister, METH_O, NULL}, + { "LUFactors_swiginit", LUFactors_swiginit, METH_VARARGS, NULL}, + { "new_DenseMatrixInverse", _wrap_new_DenseMatrixInverse, METH_VARARGS, "\n" + "DenseMatrixInverse()\n" + "DenseMatrixInverse(DenseMatrix mat)\n" + "new_DenseMatrixInverse(DenseMatrix mat) -> DenseMatrixInverse\n" + ""}, + { "DenseMatrixInverse_Size", _wrap_DenseMatrixInverse_Size, METH_O, "Size(DenseMatrixInverse self) -> int"}, + { "DenseMatrixInverse_Factor", _wrap_DenseMatrixInverse_Factor, METH_VARARGS, "\n" + "Factor(DenseMatrixInverse self)\n" + "Factor(DenseMatrixInverse self, DenseMatrix mat)\n" + ""}, + { "DenseMatrixInverse_SetOperator", _wrap_DenseMatrixInverse_SetOperator, METH_VARARGS, "SetOperator(DenseMatrixInverse self, Operator op)"}, + { "DenseMatrixInverse_Mult", _wrap_DenseMatrixInverse_Mult, METH_VARARGS, "\n" + "Mult(DenseMatrixInverse self, Vector x, Vector y)\n" + "Mult(DenseMatrixInverse self, DenseMatrix B, DenseMatrix X)\n" + "Mult(DenseMatrixInverse self, DenseMatrix X)\n" + ""}, + { "DenseMatrixInverse_GetInverseMatrix", _wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, + { "DenseMatrixInverse_Det", _wrap_DenseMatrixInverse_Det, METH_O, "Det(DenseMatrixInverse self) -> double"}, + { "DenseMatrixInverse_TestInversion", _wrap_DenseMatrixInverse_TestInversion, METH_O, "TestInversion(DenseMatrixInverse self)"}, + { "delete_DenseMatrixInverse", _wrap_delete_DenseMatrixInverse, METH_O, "delete_DenseMatrixInverse(DenseMatrixInverse self)"}, + { "DenseMatrixInverse_swigregister", DenseMatrixInverse_swigregister, METH_O, NULL}, + { "DenseMatrixInverse_swiginit", DenseMatrixInverse_swiginit, METH_VARARGS, NULL}, + { "new_DenseMatrixEigensystem", _wrap_new_DenseMatrixEigensystem, METH_VARARGS, "\n" + "DenseMatrixEigensystem(DenseMatrix m)\n" + "new_DenseMatrixEigensystem(DenseMatrixEigensystem other) -> DenseMatrixEigensystem\n" + ""}, + { "DenseMatrixEigensystem_Eval", _wrap_DenseMatrixEigensystem_Eval, METH_O, "Eval(DenseMatrixEigensystem self)"}, + { "DenseMatrixEigensystem_Eigenvalues", _wrap_DenseMatrixEigensystem_Eigenvalues, METH_O, "Eigenvalues(DenseMatrixEigensystem self) -> Vector"}, + { "DenseMatrixEigensystem_Eigenvectors", _wrap_DenseMatrixEigensystem_Eigenvectors, METH_O, "Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix"}, + { "DenseMatrixEigensystem_Eigenvalue", _wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS, "Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, + { "DenseMatrixEigensystem_Eigenvector", _wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS, "Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, + { "delete_DenseMatrixEigensystem", _wrap_delete_DenseMatrixEigensystem, METH_O, "delete_DenseMatrixEigensystem(DenseMatrixEigensystem self)"}, + { "DenseMatrixEigensystem_swigregister", DenseMatrixEigensystem_swigregister, METH_O, NULL}, + { "DenseMatrixEigensystem_swiginit", DenseMatrixEigensystem_swiginit, METH_VARARGS, NULL}, + { "new_DenseMatrixSVD", _wrap_new_DenseMatrixSVD, METH_VARARGS, "\n" + "DenseMatrixSVD(DenseMatrix M)\n" + "new_DenseMatrixSVD(int h, int w) -> DenseMatrixSVD\n" + ""}, + { "DenseMatrixSVD_Eval", _wrap_DenseMatrixSVD_Eval, METH_VARARGS, "Eval(DenseMatrixSVD self, DenseMatrix M)"}, + { "DenseMatrixSVD_Singularvalues", _wrap_DenseMatrixSVD_Singularvalues, METH_O, "Singularvalues(DenseMatrixSVD self) -> Vector"}, + { "DenseMatrixSVD_Singularvalue", _wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS, "Singularvalue(DenseMatrixSVD self, int i) -> double"}, + { "delete_DenseMatrixSVD", _wrap_delete_DenseMatrixSVD, METH_O, "delete_DenseMatrixSVD(DenseMatrixSVD self)"}, + { "DenseMatrixSVD_swigregister", DenseMatrixSVD_swigregister, METH_O, NULL}, + { "DenseMatrixSVD_swiginit", DenseMatrixSVD_swiginit, METH_VARARGS, NULL}, + { "new_DenseTensor", _wrap_new_DenseTensor, METH_VARARGS, "\n" + "DenseTensor()\n" + "DenseTensor(int i, int j, int k)\n" + "new_DenseTensor(DenseTensor other) -> DenseTensor\n" + ""}, + { "DenseTensor_SizeI", _wrap_DenseTensor_SizeI, METH_O, "SizeI(DenseTensor self) -> int"}, + { "DenseTensor_SizeJ", _wrap_DenseTensor_SizeJ, METH_O, "SizeJ(DenseTensor self) -> int"}, + { "DenseTensor_SizeK", _wrap_DenseTensor_SizeK, METH_O, "SizeK(DenseTensor self) -> int"}, + { "DenseTensor_TotalSize", _wrap_DenseTensor_TotalSize, METH_O, "TotalSize(DenseTensor self) -> int"}, + { "DenseTensor_SetSize", _wrap_DenseTensor_SetSize, METH_VARARGS, "SetSize(DenseTensor self, int i, int j, int k)"}, + { "DenseTensor_UseExternalData", _wrap_DenseTensor_UseExternalData, METH_VARARGS, "UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, + { "DenseTensor___call__", _wrap_DenseTensor___call__, METH_VARARGS, "\n" + "__call__(DenseTensor self, int k) -> DenseMatrix\n" + "__call__(DenseTensor self, int k) -> DenseMatrix\n" + "__call__(DenseTensor self, int i, int j, int k) -> double\n" + "__call__(DenseTensor self, int i, int j, int k) -> double const &\n" + ""}, + { "DenseTensor_GetData", _wrap_DenseTensor_GetData, METH_VARARGS, "GetData(DenseTensor self, int k) -> double *"}, + { "DenseTensor_Data", _wrap_DenseTensor_Data, METH_VARARGS, "\n" + "Data(DenseTensor self) -> double\n" + "Data(DenseTensor self) -> double const *\n" + ""}, + { "DenseTensor_GetMemory", _wrap_DenseTensor_GetMemory, METH_VARARGS, "\n" + "GetMemory(DenseTensor self) -> mfem::Memory< double >\n" + "GetMemory(DenseTensor self) -> mfem::Memory< double > const &\n" + ""}, + { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, + { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "Clear(DenseTensor self)"}, + { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "MemoryUsage(DenseTensor self) -> long"}, + { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "HostRead(DenseTensor self) -> double const *"}, + { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "HostWrite(DenseTensor self) -> double *"}, + { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "HostReadWrite(DenseTensor self) -> double *"}, + { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, + { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "Assign(DenseTensor self, double const c)"}, + { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" + "__getitem__(DenseTensor self, int const i, int const j, int const k) -> double const\n" + "__getitem__(DenseTensor self, int const k) -> DenseMatrix\n" + ""}, + { "DenseTensor___setitem__", _wrap_DenseTensor___setitem__, METH_VARARGS, "__setitem__(DenseTensor self, int i, int j, int k, double const v)"}, + { "DenseTensor_GetDataArray", _wrap_DenseTensor_GetDataArray, METH_O, "GetDataArray(DenseTensor self) -> PyObject *"}, + { "DenseTensor_swigregister", DenseTensor_swigregister, METH_O, NULL}, + { "DenseTensor_swiginit", DenseTensor_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -16531,15 +18416,18 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -16555,9 +18443,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -16579,12 +18473,15 @@ static swig_type_info _swigt__p_mfem__MemoryT_double_t = {"_p_mfem__MemoryT_doub static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Table = {"_p_mfem__Table", "mfem::Table *", 0, 0, (void*)0, 0}; @@ -16614,6 +18511,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__Table, &_swigt__p_mfem__TimeDependentOperator, @@ -16640,14 +18540,17 @@ static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__Mat static swig_cast_info _swigc__p_mfem__MemoryT_double_t[] = { {&_swigt__p_mfem__MemoryT_double_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Table[] = { {&_swigt__p_mfem__Table, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -16676,6 +18579,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__Table, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_par/device.py b/mfem/_par/device.py index 9d1b524f..4b9d2c0b 100644 --- a/mfem/_par/device.py +++ b/mfem/_par/device.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _device.SWIG_PyInstanceMethod_New +_swig_new_static_method = _device.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -68,16 +71,22 @@ class Backend(object): CPU = _device.Backend_CPU OMP = _device.Backend_OMP CUDA = _device.Backend_CUDA + HIP = _device.Backend_HIP RAJA_CPU = _device.Backend_RAJA_CPU RAJA_OMP = _device.Backend_RAJA_OMP RAJA_CUDA = _device.Backend_RAJA_CUDA OCCA_CPU = _device.Backend_OCCA_CPU OCCA_OMP = _device.Backend_OCCA_OMP OCCA_CUDA = _device.Backend_OCCA_CUDA + CEED_CPU = _device.Backend_CEED_CPU + CEED_CUDA = _device.Backend_CEED_CUDA + DEBUG = _device.Backend_DEBUG NUM_BACKENDS = _device.Backend_NUM_BACKENDS CPU_MASK = _device.Backend_CPU_MASK CUDA_MASK = _device.Backend_CUDA_MASK + HIP_MASK = _device.Backend_HIP_MASK OMP_MASK = _device.Backend_OMP_MASK + CEED_MASK = _device.Backend_CEED_MASK DEVICE_MASK = _device.Backend_DEVICE_MASK RAJA_MASK = _device.Backend_RAJA_MASK OCCA_MASK = _device.Backend_OCCA_MASK @@ -99,61 +108,131 @@ def __init__(self, *args): def Configure(self, device, dev=0): return _device.Device_Configure(self, device, dev) + Configure = _swig_new_instance_method(_device.Device_Configure) def Print(self, *args): return _device.Device_Print(self, *args) + Print = _swig_new_instance_method(_device.Device_Print) @staticmethod def IsConfigured(): return _device.Device_IsConfigured() + IsConfigured = _swig_new_static_method(_device.Device_IsConfigured) @staticmethod def IsAvailable(): return _device.Device_IsAvailable() + IsAvailable = _swig_new_static_method(_device.Device_IsAvailable) @staticmethod def IsEnabled(): return _device.Device_IsEnabled() + IsEnabled = _swig_new_static_method(_device.Device_IsEnabled) @staticmethod def IsDisabled(): return _device.Device_IsDisabled() + IsDisabled = _swig_new_static_method(_device.Device_IsDisabled) @staticmethod def Allows(b_mask): return _device.Device_Allows(b_mask) + Allows = _swig_new_static_method(_device.Device_Allows) + + @staticmethod + def GetHostMemoryType(): + return _device.Device_GetHostMemoryType() + GetHostMemoryType = _swig_new_static_method(_device.Device_GetHostMemoryType) + + @staticmethod + def GetHostMemoryClass(): + return _device.Device_GetHostMemoryClass() + GetHostMemoryClass = _swig_new_static_method(_device.Device_GetHostMemoryClass) + + @staticmethod + def GetDeviceMemoryType(): + return _device.Device_GetDeviceMemoryType() + GetDeviceMemoryType = _swig_new_static_method(_device.Device_GetDeviceMemoryType) @staticmethod def GetMemoryType(): return _device.Device_GetMemoryType() + GetMemoryType = _swig_new_static_method(_device.Device_GetMemoryType) + + @staticmethod + def GetDeviceMemoryClass(): + return _device.Device_GetDeviceMemoryClass() + GetDeviceMemoryClass = _swig_new_static_method(_device.Device_GetDeviceMemoryClass) @staticmethod def GetMemoryClass(): return _device.Device_GetMemoryClass() + GetMemoryClass = _swig_new_static_method(_device.Device_GetMemoryClass) + + @staticmethod + def SetGPUAwareMPI(force=True): + return _device.Device_SetGPUAwareMPI(force) + SetGPUAwareMPI = _swig_new_static_method(_device.Device_SetGPUAwareMPI) + + @staticmethod + def GetGPUAwareMPI(): + return _device.Device_GetGPUAwareMPI() + GetGPUAwareMPI = _swig_new_static_method(_device.Device_GetGPUAwareMPI) # Register Device in _device: _device.Device_swigregister(Device) def Device_IsConfigured(): return _device.Device_IsConfigured() +Device_IsConfigured = _device.Device_IsConfigured def Device_IsAvailable(): return _device.Device_IsAvailable() +Device_IsAvailable = _device.Device_IsAvailable def Device_IsEnabled(): return _device.Device_IsEnabled() +Device_IsEnabled = _device.Device_IsEnabled def Device_IsDisabled(): return _device.Device_IsDisabled() +Device_IsDisabled = _device.Device_IsDisabled def Device_Allows(b_mask): return _device.Device_Allows(b_mask) +Device_Allows = _device.Device_Allows + +def Device_GetHostMemoryType(): + return _device.Device_GetHostMemoryType() +Device_GetHostMemoryType = _device.Device_GetHostMemoryType + +def Device_GetHostMemoryClass(): + return _device.Device_GetHostMemoryClass() +Device_GetHostMemoryClass = _device.Device_GetHostMemoryClass + +def Device_GetDeviceMemoryType(): + return _device.Device_GetDeviceMemoryType() +Device_GetDeviceMemoryType = _device.Device_GetDeviceMemoryType def Device_GetMemoryType(): return _device.Device_GetMemoryType() +Device_GetMemoryType = _device.Device_GetMemoryType + +def Device_GetDeviceMemoryClass(): + return _device.Device_GetDeviceMemoryClass() +Device_GetDeviceMemoryClass = _device.Device_GetDeviceMemoryClass def Device_GetMemoryClass(): return _device.Device_GetMemoryClass() +Device_GetMemoryClass = _device.Device_GetMemoryClass + +def Device_SetGPUAwareMPI(force=True): + return _device.Device_SetGPUAwareMPI(force) +Device_SetGPUAwareMPI = _device.Device_SetGPUAwareMPI + +def Device_GetGPUAwareMPI(): + return _device.Device_GetGPUAwareMPI() +Device_GetGPUAwareMPI = _device.Device_GetGPUAwareMPI diff --git a/mfem/_par/device_wrap.cxx b/mfem/_par/device_wrap.cxx index 32f3da27..8b6f5deb 100644 --- a/mfem/_par/device_wrap.cxx +++ b/mfem/_par/device_wrap.cxx @@ -2987,6 +2987,20 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) return SWIG_TypeError; } + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + #ifdef __cplusplus extern "C" { #endif @@ -3683,6 +3697,90 @@ SWIGINTERN PyObject *_wrap_Device_Allows(PyObject *SWIGUNUSEDPARM(self), PyObjec } +SWIGINTERN PyObject *_wrap_Device_GetHostMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetHostMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::Device::GetHostMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_GetHostMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryClass result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetHostMemoryClass", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryClass)mfem::Device::GetHostMemoryClass(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_GetDeviceMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetDeviceMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::Device::GetDeviceMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Device_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryType result; @@ -3711,6 +3809,34 @@ SWIGINTERN PyObject *_wrap_Device_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_Device_GetDeviceMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryClass result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetDeviceMemoryClass", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryClass)mfem::Device::GetDeviceMemoryClass(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Device_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryClass result; @@ -3739,6 +3865,127 @@ SWIGINTERN PyObject *_wrap_Device_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + bool arg1 ; + bool val1 ; + int ecode1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_SetGPUAwareMPI" "', argument " "1"" of type '" "bool""'"); + } + arg1 = static_cast< bool >(val1); + { + try { + mfem::Device::SetGPUAwareMPI(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + mfem::Device::SetGPUAwareMPI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Device_SetGPUAwareMPI", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_Device_SetGPUAwareMPI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_bool(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Device_SetGPUAwareMPI__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_SetGPUAwareMPI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Device::SetGPUAwareMPI(bool const)\n" + " mfem::Device::SetGPUAwareMPI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Device_GetGPUAwareMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetGPUAwareMPI", 0, 0, 0)) SWIG_fail; + { + try { + result = (bool)mfem::Device::GetGPUAwareMPI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *Device_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -3752,6 +3999,7 @@ SWIGINTERN PyObject *Device_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Backend", _wrap_new_Backend, METH_NOARGS, NULL}, { "delete_Backend", _wrap_delete_Backend, METH_O, NULL}, { "Backend_swigregister", Backend_swigregister, METH_O, NULL}, @@ -3765,14 +4013,45 @@ static PyMethodDef SwigMethods[] = { { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, + { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, + { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, { "Device_swigregister", Device_swigregister, METH_O, NULL}, { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Backend", _wrap_new_Backend, METH_NOARGS, NULL}, + { "delete_Backend", _wrap_delete_Backend, METH_O, NULL}, + { "Backend_swigregister", Backend_swigregister, METH_O, NULL}, + { "Backend_swiginit", Backend_swiginit, METH_VARARGS, NULL}, + { "new_Device", _wrap_new_Device, METH_VARARGS, NULL}, + { "delete_Device", _wrap_delete_Device, METH_O, NULL}, + { "Device_Configure", _wrap_Device_Configure, METH_VARARGS, NULL}, + { "Device_Print", _wrap_Device_Print, METH_VARARGS, NULL}, + { "Device_IsConfigured", _wrap_Device_IsConfigured, METH_NOARGS, NULL}, + { "Device_IsAvailable", _wrap_Device_IsAvailable, METH_NOARGS, NULL}, + { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, + { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, + { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, + { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, + { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, + { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, + { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, + { "Device_swigregister", Device_swigregister, METH_O, NULL}, + { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4540,16 +4819,22 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Backend_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::CPU))); SWIG_Python_SetConstant(d, "Backend_OMP",SWIG_From_int(static_cast< int >(mfem::Backend::OMP))); SWIG_Python_SetConstant(d, "Backend_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::CUDA))); + SWIG_Python_SetConstant(d, "Backend_HIP",SWIG_From_int(static_cast< int >(mfem::Backend::HIP))); SWIG_Python_SetConstant(d, "Backend_RAJA_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_CPU))); SWIG_Python_SetConstant(d, "Backend_RAJA_OMP",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_OMP))); SWIG_Python_SetConstant(d, "Backend_RAJA_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_CUDA))); SWIG_Python_SetConstant(d, "Backend_OCCA_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_CPU))); SWIG_Python_SetConstant(d, "Backend_OCCA_OMP",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_OMP))); SWIG_Python_SetConstant(d, "Backend_OCCA_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_CUDA))); + SWIG_Python_SetConstant(d, "Backend_CEED_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::CEED_CPU))); + SWIG_Python_SetConstant(d, "Backend_CEED_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::CEED_CUDA))); + SWIG_Python_SetConstant(d, "Backend_DEBUG",SWIG_From_int(static_cast< int >(mfem::Backend::DEBUG))); SWIG_Python_SetConstant(d, "Backend_NUM_BACKENDS",SWIG_From_int(static_cast< int >(mfem::Backend::NUM_BACKENDS))); SWIG_Python_SetConstant(d, "Backend_CPU_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::CPU_MASK))); SWIG_Python_SetConstant(d, "Backend_CUDA_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::CUDA_MASK))); + SWIG_Python_SetConstant(d, "Backend_HIP_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::HIP_MASK))); SWIG_Python_SetConstant(d, "Backend_OMP_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::OMP_MASK))); + SWIG_Python_SetConstant(d, "Backend_CEED_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::CEED_MASK))); SWIG_Python_SetConstant(d, "Backend_DEVICE_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::DEVICE_MASK))); SWIG_Python_SetConstant(d, "Backend_RAJA_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_MASK))); SWIG_Python_SetConstant(d, "Backend_OCCA_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_MASK))); diff --git a/mfem/_par/element.py b/mfem/_par/element.py index ca848412..06f176d7 100644 --- a/mfem/_par/element.py +++ b/mfem/_par/element.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _element.SWIG_PyInstanceMethod_New +_swig_new_static_method = _element.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -99,22 +102,27 @@ def __init__(self, *args, **kwargs): def GetType(self): r"""GetType(Element self) -> mfem::Element::Type""" return _element.Element_GetType(self) + GetType = _swig_new_instance_method(_element.Element_GetType) def GetGeometryType(self): r"""GetGeometryType(Element self) -> mfem::Geometry::Type""" return _element.Element_GetGeometryType(self) + GetGeometryType = _swig_new_instance_method(_element.Element_GetGeometryType) def GetAttribute(self): r"""GetAttribute(Element self) -> int""" return _element.Element_GetAttribute(self) + GetAttribute = _swig_new_instance_method(_element.Element_GetAttribute) def SetAttribute(self, attr): r"""SetAttribute(Element self, int const attr)""" return _element.Element_SetAttribute(self, attr) + SetAttribute = _swig_new_instance_method(_element.Element_SetAttribute) def SetVertices(self, ind): r"""SetVertices(Element self, int const * ind)""" return _element.Element_SetVertices(self, ind) + SetVertices = _swig_new_instance_method(_element.Element_SetVertices) def GetVertices(self, *args): r""" @@ -123,55 +131,76 @@ def GetVertices(self, *args): GetVertices(Element self) -> int const * """ return _element.Element_GetVertices(self, *args) + GetVertices = _swig_new_instance_method(_element.Element_GetVertices) def GetNVertices(self): r"""GetNVertices(Element self) -> int""" return _element.Element_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_element.Element_GetNVertices) def GetNEdges(self): r"""GetNEdges(Element self) -> int""" return _element.Element_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_element.Element_GetNEdges) def GetEdgeVertices(self, arg2): r"""GetEdgeVertices(Element self, int arg2) -> int const *""" return _element.Element_GetEdgeVertices(self, arg2) + GetEdgeVertices = _swig_new_instance_method(_element.Element_GetEdgeVertices) + + def GetNFaces(self, *args): + r""" + GetNFaces(Element self, int & nFaceVertices) -> int + GetNFaces(Element self) -> int + """ + return _element.Element_GetNFaces(self, *args) + GetNFaces = _swig_new_instance_method(_element.Element_GetNFaces) - def GetNFaces(self, nFaceVertices): - r"""GetNFaces(Element self, int & nFaceVertices) -> int""" - return _element.Element_GetNFaces(self, nFaceVertices) + def GetNFaceVertices(self, fi): + r"""GetNFaceVertices(Element self, int fi) -> int""" + return _element.Element_GetNFaceVertices(self, fi) + GetNFaceVertices = _swig_new_instance_method(_element.Element_GetNFaceVertices) def GetFaceVertices(self, fi): r"""GetFaceVertices(Element self, int fi) -> int const *""" return _element.Element_GetFaceVertices(self, fi) + GetFaceVertices = _swig_new_instance_method(_element.Element_GetFaceVertices) def MarkEdge(self, v_to_v, length): r"""MarkEdge(Element self, DSTable v_to_v, int const * length)""" return _element.Element_MarkEdge(self, v_to_v, length) + MarkEdge = _swig_new_instance_method(_element.Element_MarkEdge) def NeedRefinement(self, v_to_v): r"""NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int""" return _element.Element_NeedRefinement(self, v_to_v) + NeedRefinement = _swig_new_instance_method(_element.Element_NeedRefinement) def ResetTransform(self, tr): r"""ResetTransform(Element self, int tr)""" return _element.Element_ResetTransform(self, tr) + ResetTransform = _swig_new_instance_method(_element.Element_ResetTransform) def PushTransform(self, tr): r"""PushTransform(Element self, int tr)""" return _element.Element_PushTransform(self, tr) + PushTransform = _swig_new_instance_method(_element.Element_PushTransform) def GetTransform(self): r"""GetTransform(Element self) -> unsigned int""" return _element.Element_GetTransform(self) + GetTransform = _swig_new_instance_method(_element.Element_GetTransform) def Duplicate(self, m): r"""Duplicate(Element self, mfem::Mesh * m) -> Element""" return _element.Element_Duplicate(self, m) + Duplicate = _swig_new_instance_method(_element.Element_Duplicate) __swig_destroy__ = _element.delete_Element def GetVerticesArray(self): r"""GetVerticesArray(Element self) -> PyObject *""" return _element.Element_GetVerticesArray(self) + GetVerticesArray = _swig_new_instance_method(_element.Element_GetVerticesArray) # Register Element in _element: _element.Element_swigregister(Element) diff --git a/mfem/_par/element_wrap.cxx b/mfem/_par/element_wrap.cxx index 66c3c6d7..a1516a9d 100644 --- a/mfem/_par/element_wrap.cxx +++ b/mfem/_par/element_wrap.cxx @@ -3679,7 +3679,7 @@ SWIGINTERN PyObject *_wrap_Element_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetNFaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int *arg2 = 0 ; @@ -3687,10 +3687,9 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; int result; - if (!SWIG_Python_UnpackTuple(args, "Element_GetNFaces", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaces" "', argument " "1"" of type '" "mfem::Element const *""'"); @@ -3724,6 +3723,121 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO } +SWIGINTERN PyObject *_wrap_Element_GetNFaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Element *arg1 = (mfem::Element *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaces" "', argument " "1"" of type '" "mfem::Element const *""'"); + } + arg1 = reinterpret_cast< mfem::Element * >(argp1); + { + try { + result = (int)((mfem::Element const *)arg1)->GetNFaces(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Element_GetNFaces", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Element, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Element_GetNFaces__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Element, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Element_GetNFaces__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Element_GetNFaces'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Element::GetNFaces(int &) const\n" + " mfem::Element::GetNFaces() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Element *arg1 = (mfem::Element *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Element_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); + } + arg1 = reinterpret_cast< mfem::Element * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::Element const *)arg1)->GetNFaceVertices(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; @@ -4097,6 +4211,7 @@ SWIGINTERN PyObject *Element_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Element_GetType", _wrap_Element_GetType, METH_O, "Element_GetType(Element self) -> mfem::Element::Type"}, { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "Element_GetGeometryType(Element self) -> mfem::Geometry::Type"}, { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "Element_GetAttribute(Element self) -> int"}, @@ -4110,7 +4225,11 @@ static PyMethodDef SwigMethods[] = { { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "Element_GetNVertices(Element self) -> int"}, { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "Element_GetNEdges(Element self) -> int"}, { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "Element_GetEdgeVertices(Element self, int arg2) -> int const *"}, - { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "Element_GetNFaces(Element self, int & nFaceVertices) -> int"}, + { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" + "Element_GetNFaces(Element self, int & nFaceVertices) -> int\n" + "Element_GetNFaces(Element self) -> int\n" + ""}, + { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "Element_GetNFaceVertices(Element self, int fi) -> int"}, { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "Element_GetFaceVertices(Element self, int fi) -> int const *"}, { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "Element_MarkEdge(Element self, DSTable v_to_v, int const * length)"}, { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "Element_NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, @@ -4125,6 +4244,36 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Element_GetType", _wrap_Element_GetType, METH_O, "GetType(Element self) -> mfem::Element::Type"}, + { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "GetGeometryType(Element self) -> mfem::Geometry::Type"}, + { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "GetAttribute(Element self) -> int"}, + { "Element_SetAttribute", _wrap_Element_SetAttribute, METH_VARARGS, "SetAttribute(Element self, int const attr)"}, + { "Element_SetVertices", _wrap_Element_SetVertices, METH_VARARGS, "SetVertices(Element self, int const * ind)"}, + { "Element_GetVertices", _wrap_Element_GetVertices, METH_VARARGS, "\n" + "GetVertices(Element self, intArray v)\n" + "GetVertices(Element self) -> int\n" + "GetVertices(Element self) -> int const *\n" + ""}, + { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "GetNVertices(Element self) -> int"}, + { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "GetNEdges(Element self) -> int"}, + { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Element self, int arg2) -> int const *"}, + { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" + "GetNFaces(Element self, int & nFaceVertices) -> int\n" + "GetNFaces(Element self) -> int\n" + ""}, + { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Element self, int fi) -> int"}, + { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Element self, int fi) -> int const *"}, + { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "MarkEdge(Element self, DSTable v_to_v, int const * length)"}, + { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, + { "Element_ResetTransform", _wrap_Element_ResetTransform, METH_VARARGS, "ResetTransform(Element self, int tr)"}, + { "Element_PushTransform", _wrap_Element_PushTransform, METH_VARARGS, "PushTransform(Element self, int tr)"}, + { "Element_GetTransform", _wrap_Element_GetTransform, METH_O, "GetTransform(Element self) -> unsigned int"}, + { "Element_Duplicate", _wrap_Element_Duplicate, METH_VARARGS, "Duplicate(Element self, mfem::Mesh * m) -> Element"}, + { "delete_Element", _wrap_delete_Element, METH_O, "delete_Element(Element self)"}, + { "Element_GetVerticesArray", _wrap_Element_GetVerticesArray, METH_O, "GetVerticesArray(Element self) -> PyObject *"}, + { "Element_swigregister", Element_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/eltrans.py b/mfem/_par/eltrans.py index 6f5a8747..49c0cc5c 100644 --- a/mfem/_par/eltrans.py +++ b/mfem/_par/eltrans.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _eltrans.SWIG_PyInstanceMethod_New +_swig_new_static_method = _eltrans.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,10 +90,12 @@ def __init__(self, *args, **kwargs): def SetIntPoint(self, ip): r"""SetIntPoint(ElementTransformation self, IntegrationPoint ip)""" return _eltrans.ElementTransformation_SetIntPoint(self, ip) + SetIntPoint = _swig_new_instance_method(_eltrans.ElementTransformation_SetIntPoint) def GetIntPoint(self): r"""GetIntPoint(ElementTransformation self) -> IntegrationPoint""" return _eltrans.ElementTransformation_GetIntPoint(self) + GetIntPoint = _swig_new_instance_method(_eltrans.ElementTransformation_GetIntPoint) def Transform(self, *args): from .vector import Vector @@ -108,50 +113,67 @@ def Transform(self, *args): def Jacobian(self): r"""Jacobian(ElementTransformation self) -> DenseMatrix""" return _eltrans.ElementTransformation_Jacobian(self) + Jacobian = _swig_new_instance_method(_eltrans.ElementTransformation_Jacobian) + + def Hessian(self): + r"""Hessian(ElementTransformation self) -> DenseMatrix""" + return _eltrans.ElementTransformation_Hessian(self) + Hessian = _swig_new_instance_method(_eltrans.ElementTransformation_Hessian) def Weight(self): r"""Weight(ElementTransformation self) -> double""" return _eltrans.ElementTransformation_Weight(self) + Weight = _swig_new_instance_method(_eltrans.ElementTransformation_Weight) def AdjugateJacobian(self): r"""AdjugateJacobian(ElementTransformation self) -> DenseMatrix""" return _eltrans.ElementTransformation_AdjugateJacobian(self) + AdjugateJacobian = _swig_new_instance_method(_eltrans.ElementTransformation_AdjugateJacobian) def InverseJacobian(self): r"""InverseJacobian(ElementTransformation self) -> DenseMatrix""" return _eltrans.ElementTransformation_InverseJacobian(self) + InverseJacobian = _swig_new_instance_method(_eltrans.ElementTransformation_InverseJacobian) def Order(self): r"""Order(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_Order(self) + Order = _swig_new_instance_method(_eltrans.ElementTransformation_Order) def OrderJ(self): r"""OrderJ(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_OrderJ(self) + OrderJ = _swig_new_instance_method(_eltrans.ElementTransformation_OrderJ) def OrderW(self): r"""OrderW(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_OrderW(self) + OrderW = _swig_new_instance_method(_eltrans.ElementTransformation_OrderW) def OrderGrad(self, fe): r"""OrderGrad(ElementTransformation self, FiniteElement fe) -> int""" return _eltrans.ElementTransformation_OrderGrad(self, fe) + OrderGrad = _swig_new_instance_method(_eltrans.ElementTransformation_OrderGrad) def GetGeometryType(self): r"""GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type""" return _eltrans.ElementTransformation_GetGeometryType(self) + GetGeometryType = _swig_new_instance_method(_eltrans.ElementTransformation_GetGeometryType) def GetDimension(self): r"""GetDimension(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_GetDimension(self) + GetDimension = _swig_new_instance_method(_eltrans.ElementTransformation_GetDimension) def GetSpaceDim(self): r"""GetSpaceDim(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_GetSpaceDim(self) + GetSpaceDim = _swig_new_instance_method(_eltrans.ElementTransformation_GetSpaceDim) def TransformBack(self, pt, ip): r"""TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int""" return _eltrans.ElementTransformation_TransformBack(self, pt, ip) + TransformBack = _swig_new_instance_method(_eltrans.ElementTransformation_TransformBack) __swig_destroy__ = _eltrans.delete_ElementTransformation # Register ElementTransformation in _eltrans: @@ -191,58 +213,72 @@ def __init__(self, Trans=None): def SetTransformation(self, Trans): r"""SetTransformation(InverseElementTransformation self, ElementTransformation Trans)""" return _eltrans.InverseElementTransformation_SetTransformation(self, Trans) + SetTransformation = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetTransformation) def SetInitialGuessType(self, itype): r"""SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)""" return _eltrans.InverseElementTransformation_SetInitialGuessType(self, itype) + SetInitialGuessType = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitialGuessType) def SetInitialGuess(self, init_ip): r"""SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)""" return _eltrans.InverseElementTransformation_SetInitialGuess(self, init_ip) + SetInitialGuess = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitialGuess) def SetInitGuessPointsType(self, q_type): r"""SetInitGuessPointsType(InverseElementTransformation self, int q_type)""" return _eltrans.InverseElementTransformation_SetInitGuessPointsType(self, q_type) + SetInitGuessPointsType = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitGuessPointsType) def SetInitGuessRelOrder(self, order): r"""SetInitGuessRelOrder(InverseElementTransformation self, int order)""" return _eltrans.InverseElementTransformation_SetInitGuessRelOrder(self, order) + SetInitGuessRelOrder = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitGuessRelOrder) def SetSolverType(self, stype): r"""SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)""" return _eltrans.InverseElementTransformation_SetSolverType(self, stype) + SetSolverType = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetSolverType) def SetMaxIter(self, max_it): r"""SetMaxIter(InverseElementTransformation self, int max_it)""" return _eltrans.InverseElementTransformation_SetMaxIter(self, max_it) + SetMaxIter = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetMaxIter) def SetReferenceTol(self, ref_sp_tol): r"""SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)""" return _eltrans.InverseElementTransformation_SetReferenceTol(self, ref_sp_tol) + SetReferenceTol = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetReferenceTol) def SetPhysicalRelTol(self, phys_rel_tol): r"""SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)""" return _eltrans.InverseElementTransformation_SetPhysicalRelTol(self, phys_rel_tol) + SetPhysicalRelTol = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetPhysicalRelTol) def SetElementTol(self, el_tol): r"""SetElementTol(InverseElementTransformation self, double el_tol)""" return _eltrans.InverseElementTransformation_SetElementTol(self, el_tol) + SetElementTol = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetElementTol) def SetPrintLevel(self, pr_level): r"""SetPrintLevel(InverseElementTransformation self, int pr_level)""" return _eltrans.InverseElementTransformation_SetPrintLevel(self, pr_level) + SetPrintLevel = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetPrintLevel) def FindClosestPhysPoint(self, pt, ir): r"""FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int""" return _eltrans.InverseElementTransformation_FindClosestPhysPoint(self, pt, ir) + FindClosestPhysPoint = _swig_new_instance_method(_eltrans.InverseElementTransformation_FindClosestPhysPoint) def FindClosestRefPoint(self, pt, ir): r"""FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int""" return _eltrans.InverseElementTransformation_FindClosestRefPoint(self, pt, ir) + FindClosestRefPoint = _swig_new_instance_method(_eltrans.InverseElementTransformation_FindClosestRefPoint) def Transform(self, pt, ip): r"""Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int""" return _eltrans.InverseElementTransformation_Transform(self, pt, ip) + Transform = _swig_new_instance_method(_eltrans.InverseElementTransformation_Transform) # Register InverseElementTransformation in _eltrans: _eltrans.InverseElementTransformation_swigregister(InverseElementTransformation) @@ -256,22 +292,27 @@ class IsoparametricTransformation(ElementTransformation): def SetFE(self, FE): r"""SetFE(IsoparametricTransformation self, FiniteElement FE)""" return _eltrans.IsoparametricTransformation_SetFE(self, FE) + SetFE = _swig_new_instance_method(_eltrans.IsoparametricTransformation_SetFE) def GetFE(self): r"""GetFE(IsoparametricTransformation self) -> FiniteElement""" return _eltrans.IsoparametricTransformation_GetFE(self) + GetFE = _swig_new_instance_method(_eltrans.IsoparametricTransformation_GetFE) def GetPointMat(self): r"""GetPointMat(IsoparametricTransformation self) -> DenseMatrix""" return _eltrans.IsoparametricTransformation_GetPointMat(self) + GetPointMat = _swig_new_instance_method(_eltrans.IsoparametricTransformation_GetPointMat) def FinalizeTransformation(self): r"""FinalizeTransformation(IsoparametricTransformation self)""" return _eltrans.IsoparametricTransformation_FinalizeTransformation(self) + FinalizeTransformation = _swig_new_instance_method(_eltrans.IsoparametricTransformation_FinalizeTransformation) def SetIdentityTransformation(self, GeomType): r"""SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)""" return _eltrans.IsoparametricTransformation_SetIdentityTransformation(self, GeomType) + SetIdentityTransformation = _swig_new_instance_method(_eltrans.IsoparametricTransformation_SetIdentityTransformation) def Transform(self, *args): from .vector import Vector @@ -289,22 +330,27 @@ def Transform(self, *args): def Order(self): r"""Order(IsoparametricTransformation self) -> int""" return _eltrans.IsoparametricTransformation_Order(self) + Order = _swig_new_instance_method(_eltrans.IsoparametricTransformation_Order) def OrderJ(self): r"""OrderJ(IsoparametricTransformation self) -> int""" return _eltrans.IsoparametricTransformation_OrderJ(self) + OrderJ = _swig_new_instance_method(_eltrans.IsoparametricTransformation_OrderJ) def OrderW(self): r"""OrderW(IsoparametricTransformation self) -> int""" return _eltrans.IsoparametricTransformation_OrderW(self) + OrderW = _swig_new_instance_method(_eltrans.IsoparametricTransformation_OrderW) def OrderGrad(self, fe): r"""OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int""" return _eltrans.IsoparametricTransformation_OrderGrad(self, fe) + OrderGrad = _swig_new_instance_method(_eltrans.IsoparametricTransformation_OrderGrad) def TransformBack(self, v, ip): r"""TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int""" return _eltrans.IsoparametricTransformation_TransformBack(self, v, ip) + TransformBack = _swig_new_instance_method(_eltrans.IsoparametricTransformation_TransformBack) __swig_destroy__ = _eltrans.delete_IsoparametricTransformation def __init__(self): @@ -327,6 +373,7 @@ def Transform(self, *args): Transform(IntegrationPointTransformation self, IntegrationRule arg2, IntegrationRule arg3) """ return _eltrans.IntegrationPointTransformation_Transform(self, *args) + Transform = _swig_new_instance_method(_eltrans.IntegrationPointTransformation_Transform) def __init__(self): r"""__init__(IntegrationPointTransformation self) -> IntegrationPointTransformation""" diff --git a/mfem/_par/eltrans_wrap.cxx b/mfem/_par/eltrans_wrap.cxx index f64eeb14..d30a1b34 100644 --- a/mfem/_par/eltrans_wrap.cxx +++ b/mfem/_par/eltrans_wrap.cxx @@ -3090,89 +3090,91 @@ namespace Swig { #define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[25] #define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[26] #define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[27] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[28] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[29] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[30] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[31] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[32] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[33] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[34] -#define SWIGTYPE_p_mfem__IntegrationPointTransformation swig_types[35] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[36] -#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[37] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[38] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[39] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[40] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[41] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[42] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[43] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[44] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[45] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[46] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[47] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[48] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[49] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[50] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[51] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[52] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[53] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[54] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[55] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[56] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[57] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[58] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[59] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[60] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[61] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[62] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[63] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[64] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[65] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[66] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[67] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[68] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[69] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[70] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[76] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[77] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[78] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[79] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[80] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[81] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[82] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[83] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[95] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[96] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[97] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[98] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__Vector swig_types[107] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[108] -static swig_type_info *swig_types[110]; -static swig_module_info swig_module = {swig_types, 109, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[28] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[29] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[30] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[31] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[32] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[33] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[34] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[35] +#define SWIGTYPE_p_mfem__IntegrationPointTransformation swig_types[36] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[37] +#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[38] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[39] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[40] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[41] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[42] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[43] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[44] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[45] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[46] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[47] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[48] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[49] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[50] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[51] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[52] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[53] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[54] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[55] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[56] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[57] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[58] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[59] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[60] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[61] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[62] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[63] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[64] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[65] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[66] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[67] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[70] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[71] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[72] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[73] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[74] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[75] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[79] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[80] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[81] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[82] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[83] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[84] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[85] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[86] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[96] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[97] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[98] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[99] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[106] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__Vector swig_types[108] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[110] +static swig_type_info *swig_types[112]; +static swig_module_info swig_module = {swig_types, 111, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3901,6 +3903,41 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_Jacobian(PyObject *SWIGUNUSEDPA } +SWIGINTERN PyObject *_wrap_ElementTransformation_Hessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::DenseMatrix *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_Hessian" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); + } + arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); + { + try { + result = (mfem::DenseMatrix *) &(arg1)->Hessian(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_ElementTransformation_Weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; @@ -6572,6 +6609,7 @@ SWIGINTERN PyObject *FaceElementTransformations_swiginit(PyObject *SWIGUNUSEDPAR static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "ElementTransformation_Attribute_set", _wrap_ElementTransformation_Attribute_set, METH_VARARGS, "ElementTransformation_Attribute_set(ElementTransformation self, int Attribute)"}, { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, @@ -6584,6 +6622,7 @@ static PyMethodDef SwigMethods[] = { "ElementTransformation_Transform(ElementTransformation self, DenseMatrix matrix, DenseMatrix result)\n" ""}, { "ElementTransformation_Jacobian", _wrap_ElementTransformation_Jacobian, METH_O, "ElementTransformation_Jacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Hessian", _wrap_ElementTransformation_Hessian, METH_O, "ElementTransformation_Hessian(ElementTransformation self) -> DenseMatrix"}, { "ElementTransformation_Weight", _wrap_ElementTransformation_Weight, METH_O, "ElementTransformation_Weight(ElementTransformation self) -> double"}, { "ElementTransformation_AdjugateJacobian", _wrap_ElementTransformation_AdjugateJacobian, METH_O, "ElementTransformation_AdjugateJacobian(ElementTransformation self) -> DenseMatrix"}, { "ElementTransformation_InverseJacobian", _wrap_ElementTransformation_InverseJacobian, METH_O, "ElementTransformation_InverseJacobian(ElementTransformation self) -> DenseMatrix"}, @@ -6668,6 +6707,101 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "ElementTransformation_Attribute_set", _wrap_ElementTransformation_Attribute_set, METH_VARARGS, "ElementTransformation_Attribute_set(ElementTransformation self, int Attribute)"}, + { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, + { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, + { "ElementTransformation_ElementNo_get", _wrap_ElementTransformation_ElementNo_get, METH_O, "ElementTransformation_ElementNo_get(ElementTransformation self) -> int"}, + { "ElementTransformation_SetIntPoint", _wrap_ElementTransformation_SetIntPoint, METH_VARARGS, "SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, + { "ElementTransformation_GetIntPoint", _wrap_ElementTransformation_GetIntPoint, METH_O, "GetIntPoint(ElementTransformation self) -> IntegrationPoint"}, + { "ElementTransformation_Transform", _wrap_ElementTransformation_Transform, METH_VARARGS, "\n" + "Transform(ElementTransformation self, IntegrationPoint arg2, Vector arg3)\n" + "Transform(ElementTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" + "Transform(ElementTransformation self, DenseMatrix matrix, DenseMatrix result)\n" + ""}, + { "ElementTransformation_Jacobian", _wrap_ElementTransformation_Jacobian, METH_O, "Jacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Hessian", _wrap_ElementTransformation_Hessian, METH_O, "Hessian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Weight", _wrap_ElementTransformation_Weight, METH_O, "Weight(ElementTransformation self) -> double"}, + { "ElementTransformation_AdjugateJacobian", _wrap_ElementTransformation_AdjugateJacobian, METH_O, "AdjugateJacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_InverseJacobian", _wrap_ElementTransformation_InverseJacobian, METH_O, "InverseJacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Order", _wrap_ElementTransformation_Order, METH_O, "Order(ElementTransformation self) -> int"}, + { "ElementTransformation_OrderJ", _wrap_ElementTransformation_OrderJ, METH_O, "OrderJ(ElementTransformation self) -> int"}, + { "ElementTransformation_OrderW", _wrap_ElementTransformation_OrderW, METH_O, "OrderW(ElementTransformation self) -> int"}, + { "ElementTransformation_OrderGrad", _wrap_ElementTransformation_OrderGrad, METH_VARARGS, "OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, + { "ElementTransformation_GetGeometryType", _wrap_ElementTransformation_GetGeometryType, METH_O, "GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type"}, + { "ElementTransformation_GetDimension", _wrap_ElementTransformation_GetDimension, METH_O, "GetDimension(ElementTransformation self) -> int"}, + { "ElementTransformation_GetSpaceDim", _wrap_ElementTransformation_GetSpaceDim, METH_O, "GetSpaceDim(ElementTransformation self) -> int"}, + { "ElementTransformation_TransformBack", _wrap_ElementTransformation_TransformBack, METH_VARARGS, "TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "delete_ElementTransformation", _wrap_delete_ElementTransformation, METH_O, "delete_ElementTransformation(ElementTransformation self)"}, + { "ElementTransformation_swigregister", ElementTransformation_swigregister, METH_O, NULL}, + { "new_InverseElementTransformation", _wrap_new_InverseElementTransformation, METH_VARARGS, "InverseElementTransformation(ElementTransformation Trans=None)"}, + { "delete_InverseElementTransformation", _wrap_delete_InverseElementTransformation, METH_O, "delete_InverseElementTransformation(InverseElementTransformation self)"}, + { "InverseElementTransformation_SetTransformation", _wrap_InverseElementTransformation_SetTransformation, METH_VARARGS, "SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, + { "InverseElementTransformation_SetInitialGuessType", _wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS, "SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, + { "InverseElementTransformation_SetInitialGuess", _wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS, "SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, + { "InverseElementTransformation_SetInitGuessPointsType", _wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS, "SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, + { "InverseElementTransformation_SetInitGuessRelOrder", _wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS, "SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, + { "InverseElementTransformation_SetSolverType", _wrap_InverseElementTransformation_SetSolverType, METH_VARARGS, "SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, + { "InverseElementTransformation_SetMaxIter", _wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS, "SetMaxIter(InverseElementTransformation self, int max_it)"}, + { "InverseElementTransformation_SetReferenceTol", _wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS, "SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, + { "InverseElementTransformation_SetPhysicalRelTol", _wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS, "SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, + { "InverseElementTransformation_SetElementTol", _wrap_InverseElementTransformation_SetElementTol, METH_VARARGS, "SetElementTol(InverseElementTransformation self, double el_tol)"}, + { "InverseElementTransformation_SetPrintLevel", _wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS, "SetPrintLevel(InverseElementTransformation self, int pr_level)"}, + { "InverseElementTransformation_FindClosestPhysPoint", _wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS, "FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_FindClosestRefPoint", _wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS, "FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_Transform", _wrap_InverseElementTransformation_Transform, METH_VARARGS, "Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "InverseElementTransformation_swigregister", InverseElementTransformation_swigregister, METH_O, NULL}, + { "InverseElementTransformation_swiginit", InverseElementTransformation_swiginit, METH_VARARGS, NULL}, + { "IsoparametricTransformation_SetFE", _wrap_IsoparametricTransformation_SetFE, METH_VARARGS, "SetFE(IsoparametricTransformation self, FiniteElement FE)"}, + { "IsoparametricTransformation_GetFE", _wrap_IsoparametricTransformation_GetFE, METH_O, "GetFE(IsoparametricTransformation self) -> FiniteElement"}, + { "IsoparametricTransformation_GetPointMat", _wrap_IsoparametricTransformation_GetPointMat, METH_O, "GetPointMat(IsoparametricTransformation self) -> DenseMatrix"}, + { "IsoparametricTransformation_FinalizeTransformation", _wrap_IsoparametricTransformation_FinalizeTransformation, METH_O, "FinalizeTransformation(IsoparametricTransformation self)"}, + { "IsoparametricTransformation_SetIdentityTransformation", _wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS, "SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, + { "IsoparametricTransformation_Transform", _wrap_IsoparametricTransformation_Transform, METH_VARARGS, "\n" + "Transform(IsoparametricTransformation self, IntegrationPoint arg2, Vector arg3)\n" + "Transform(IsoparametricTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" + "Transform(IsoparametricTransformation self, DenseMatrix matrix, DenseMatrix result)\n" + ""}, + { "IsoparametricTransformation_Order", _wrap_IsoparametricTransformation_Order, METH_O, "Order(IsoparametricTransformation self) -> int"}, + { "IsoparametricTransformation_OrderJ", _wrap_IsoparametricTransformation_OrderJ, METH_O, "OrderJ(IsoparametricTransformation self) -> int"}, + { "IsoparametricTransformation_OrderW", _wrap_IsoparametricTransformation_OrderW, METH_O, "OrderW(IsoparametricTransformation self) -> int"}, + { "IsoparametricTransformation_OrderGrad", _wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS, "OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, + { "IsoparametricTransformation_TransformBack", _wrap_IsoparametricTransformation_TransformBack, METH_VARARGS, "TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, + { "delete_IsoparametricTransformation", _wrap_delete_IsoparametricTransformation, METH_O, "delete_IsoparametricTransformation(IsoparametricTransformation self)"}, + { "new_IsoparametricTransformation", _wrap_new_IsoparametricTransformation, METH_NOARGS, "new_IsoparametricTransformation() -> IsoparametricTransformation"}, + { "IsoparametricTransformation_swigregister", IsoparametricTransformation_swigregister, METH_O, NULL}, + { "IsoparametricTransformation_swiginit", IsoparametricTransformation_swiginit, METH_VARARGS, NULL}, + { "IntegrationPointTransformation_Transf_set", _wrap_IntegrationPointTransformation_Transf_set, METH_VARARGS, "IntegrationPointTransformation_Transf_set(IntegrationPointTransformation self, IsoparametricTransformation Transf)"}, + { "IntegrationPointTransformation_Transf_get", _wrap_IntegrationPointTransformation_Transf_get, METH_O, "IntegrationPointTransformation_Transf_get(IntegrationPointTransformation self) -> IsoparametricTransformation"}, + { "IntegrationPointTransformation_Transform", _wrap_IntegrationPointTransformation_Transform, METH_VARARGS, "\n" + "Transform(IntegrationPointTransformation self, IntegrationPoint arg2, IntegrationPoint arg3)\n" + "Transform(IntegrationPointTransformation self, IntegrationRule arg2, IntegrationRule arg3)\n" + ""}, + { "new_IntegrationPointTransformation", _wrap_new_IntegrationPointTransformation, METH_NOARGS, "new_IntegrationPointTransformation() -> IntegrationPointTransformation"}, + { "delete_IntegrationPointTransformation", _wrap_delete_IntegrationPointTransformation, METH_O, "delete_IntegrationPointTransformation(IntegrationPointTransformation self)"}, + { "IntegrationPointTransformation_swigregister", IntegrationPointTransformation_swigregister, METH_O, NULL}, + { "IntegrationPointTransformation_swiginit", IntegrationPointTransformation_swiginit, METH_VARARGS, NULL}, + { "FaceElementTransformations_Elem1No_set", _wrap_FaceElementTransformations_Elem1No_set, METH_VARARGS, "FaceElementTransformations_Elem1No_set(FaceElementTransformations self, int Elem1No)"}, + { "FaceElementTransformations_Elem1No_get", _wrap_FaceElementTransformations_Elem1No_get, METH_O, "FaceElementTransformations_Elem1No_get(FaceElementTransformations self) -> int"}, + { "FaceElementTransformations_Elem2No_set", _wrap_FaceElementTransformations_Elem2No_set, METH_VARARGS, "FaceElementTransformations_Elem2No_set(FaceElementTransformations self, int Elem2No)"}, + { "FaceElementTransformations_Elem2No_get", _wrap_FaceElementTransformations_Elem2No_get, METH_O, "FaceElementTransformations_Elem2No_get(FaceElementTransformations self) -> int"}, + { "FaceElementTransformations_FaceGeom_set", _wrap_FaceElementTransformations_FaceGeom_set, METH_VARARGS, "FaceElementTransformations_FaceGeom_set(FaceElementTransformations self, int FaceGeom)"}, + { "FaceElementTransformations_FaceGeom_get", _wrap_FaceElementTransformations_FaceGeom_get, METH_O, "FaceElementTransformations_FaceGeom_get(FaceElementTransformations self) -> int"}, + { "FaceElementTransformations_Elem1_set", _wrap_FaceElementTransformations_Elem1_set, METH_VARARGS, "FaceElementTransformations_Elem1_set(FaceElementTransformations self, ElementTransformation Elem1)"}, + { "FaceElementTransformations_Elem1_get", _wrap_FaceElementTransformations_Elem1_get, METH_O, "FaceElementTransformations_Elem1_get(FaceElementTransformations self) -> ElementTransformation"}, + { "FaceElementTransformations_Elem2_set", _wrap_FaceElementTransformations_Elem2_set, METH_VARARGS, "FaceElementTransformations_Elem2_set(FaceElementTransformations self, ElementTransformation Elem2)"}, + { "FaceElementTransformations_Elem2_get", _wrap_FaceElementTransformations_Elem2_get, METH_O, "FaceElementTransformations_Elem2_get(FaceElementTransformations self) -> ElementTransformation"}, + { "FaceElementTransformations_Face_set", _wrap_FaceElementTransformations_Face_set, METH_VARARGS, "FaceElementTransformations_Face_set(FaceElementTransformations self, ElementTransformation Face)"}, + { "FaceElementTransformations_Face_get", _wrap_FaceElementTransformations_Face_get, METH_O, "FaceElementTransformations_Face_get(FaceElementTransformations self) -> ElementTransformation"}, + { "FaceElementTransformations_Loc1_set", _wrap_FaceElementTransformations_Loc1_set, METH_VARARGS, "FaceElementTransformations_Loc1_set(FaceElementTransformations self, IntegrationPointTransformation Loc1)"}, + { "FaceElementTransformations_Loc1_get", _wrap_FaceElementTransformations_Loc1_get, METH_O, "FaceElementTransformations_Loc1_get(FaceElementTransformations self) -> IntegrationPointTransformation"}, + { "FaceElementTransformations_Loc2_set", _wrap_FaceElementTransformations_Loc2_set, METH_VARARGS, "FaceElementTransformations_Loc2_set(FaceElementTransformations self, IntegrationPointTransformation Loc2)"}, + { "FaceElementTransformations_Loc2_get", _wrap_FaceElementTransformations_Loc2_get, METH_O, "FaceElementTransformations_Loc2_get(FaceElementTransformations self) -> IntegrationPointTransformation"}, + { "new_FaceElementTransformations", _wrap_new_FaceElementTransformations, METH_NOARGS, "new_FaceElementTransformations() -> FaceElementTransformations"}, + { "delete_FaceElementTransformations", _wrap_delete_FaceElementTransformations, METH_O, "delete_FaceElementTransformations(FaceElementTransformations self)"}, + { "FaceElementTransformations_swigregister", FaceElementTransformations_swigregister, METH_O, NULL}, + { "FaceElementTransformations_swiginit", FaceElementTransformations_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6677,12 +6811,6 @@ static PyMethodDef SwigMethods_proxydocs[] = { static void *_p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ElementTransformation *) ((mfem::IsoparametricTransformation *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -6716,6 +6844,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -6731,6 +6862,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -6899,6 +7033,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -6942,10 +7082,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -6989,13 +7129,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -7007,6 +7145,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -7048,6 +7188,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -7107,6 +7249,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -7188,6 +7331,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__Vector, &_swigt__p_mfem__VectorFiniteElement, + &_swigt__p_mfem__VectorTensorFiniteElement, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; @@ -7210,13 +7354,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7228,6 +7370,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7269,6 +7413,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7292,7 +7438,7 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationPoint[] = { {&_swigt__p_mfem__IntegrationPoint, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationPointTransformation[] = { {&_swigt__p_mfem__IntegrationPointTransformation, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; @@ -7329,6 +7475,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -7410,6 +7557,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__Vector, _swigc__p_mfem__VectorFiniteElement, + _swigc__p_mfem__VectorTensorFiniteElement, }; diff --git a/mfem/_par/error.py b/mfem/_par/error.py index d5b808b4..ff321cad 100644 --- a/mfem/_par/error.py +++ b/mfem/_par/error.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _error.SWIG_PyInstanceMethod_New +_swig_new_static_method = _error.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -66,17 +69,22 @@ class _SwigNonDynamicMeta(type): def set_error_action(action): return _error.set_error_action(action) +set_error_action = _error.set_error_action def get_error_action(): return _error.get_error_action() +get_error_action = _error.get_error_action def mfem_backtrace(mode=0, depth=-1): return _error.mfem_backtrace(mode, depth) +mfem_backtrace = _error.mfem_backtrace def mfem_error(msg=None): return _error.mfem_error(msg) +mfem_error = _error.mfem_error def mfem_warning(msg=None): return _error.mfem_warning(msg) +mfem_warning = _error.mfem_warning diff --git a/mfem/_par/error_wrap.cxx b/mfem/_par/error_wrap.cxx index 5ac4579d..6245645f 100644 --- a/mfem/_par/error_wrap.cxx +++ b/mfem/_par/error_wrap.cxx @@ -3463,6 +3463,7 @@ SWIGINTERN PyObject *_wrap_mfem_warning(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "set_error_action", _wrap_set_error_action, METH_O, NULL}, { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, @@ -3472,6 +3473,13 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "set_error_action", _wrap_set_error_action, METH_O, NULL}, + { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, + { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, + { "mfem_error", _wrap_mfem_error, METH_VARARGS, NULL}, + { "mfem_warning", _wrap_mfem_warning, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/estimators.py b/mfem/_par/estimators.py index 2eb8e243..2988250a 100644 --- a/mfem/_par/estimators.py +++ b/mfem/_par/estimators.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _estimators.SWIG_PyInstanceMethod_New +_swig_new_static_method = _estimators.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -90,6 +93,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -101,6 +105,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilinearform class AbstractErrorEstimator(object): r"""Proxy of C++ mfem::AbstractErrorEstimator class.""" @@ -128,10 +133,12 @@ def __init__(self, *args, **kwargs): def GetLocalErrors(self): r"""GetLocalErrors(ErrorEstimator self) -> Vector""" return _estimators.ErrorEstimator_GetLocalErrors(self) + GetLocalErrors = _swig_new_instance_method(_estimators.ErrorEstimator_GetLocalErrors) def Reset(self): r"""Reset(ErrorEstimator self)""" return _estimators.ErrorEstimator_Reset(self) + Reset = _swig_new_instance_method(_estimators.ErrorEstimator_Reset) __swig_destroy__ = _estimators.delete_ErrorEstimator # Register ErrorEstimator in _estimators: @@ -149,6 +156,7 @@ def __init__(self, *args, **kwargs): def GetAnisotropicFlags(self): r"""GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray""" return _estimators.AnisotropicErrorEstimator_GetAnisotropicFlags(self) + GetAnisotropicFlags = _swig_new_instance_method(_estimators.AnisotropicErrorEstimator_GetAnisotropicFlags) __swig_destroy__ = _estimators.delete_AnisotropicErrorEstimator # Register AnisotropicErrorEstimator in _estimators: @@ -160,29 +168,40 @@ class ZienkiewiczZhuEstimator(AnisotropicErrorEstimator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr + def SetWithCoeff(self, w_coeff=True): + r"""SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)""" + return _estimators.ZienkiewiczZhuEstimator_SetWithCoeff(self, w_coeff) + SetWithCoeff = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_SetWithCoeff) + def SetAnisotropic(self, aniso=True): r"""SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)""" return _estimators.ZienkiewiczZhuEstimator_SetAnisotropic(self, aniso) + SetAnisotropic = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_SetAnisotropic) def SetFluxAveraging(self, fa): r"""SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)""" return _estimators.ZienkiewiczZhuEstimator_SetFluxAveraging(self, fa) + SetFluxAveraging = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_SetFluxAveraging) def GetTotalError(self): r"""GetTotalError(ZienkiewiczZhuEstimator self) -> double""" return _estimators.ZienkiewiczZhuEstimator_GetTotalError(self) + GetTotalError = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_GetTotalError) def GetLocalErrors(self): r"""GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector""" return _estimators.ZienkiewiczZhuEstimator_GetLocalErrors(self) + GetLocalErrors = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_GetLocalErrors) def GetAnisotropicFlags(self): r"""GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray""" return _estimators.ZienkiewiczZhuEstimator_GetAnisotropicFlags(self) + GetAnisotropicFlags = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_GetAnisotropicFlags) def Reset(self): r"""Reset(ZienkiewiczZhuEstimator self)""" return _estimators.ZienkiewiczZhuEstimator_Reset(self) + Reset = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_Reset) __swig_destroy__ = _estimators.delete_ZienkiewiczZhuEstimator def __init__(self, integ, sol, flux_fes, own_flux_fes=False): @@ -205,18 +224,22 @@ class L2ZienkiewiczZhuEstimator(ErrorEstimator): def SetLocalErrorNormP(self, p): r"""SetLocalErrorNormP(L2ZienkiewiczZhuEstimator self, int p)""" return _estimators.L2ZienkiewiczZhuEstimator_SetLocalErrorNormP(self, p) + SetLocalErrorNormP = _swig_new_instance_method(_estimators.L2ZienkiewiczZhuEstimator_SetLocalErrorNormP) def GetTotalError(self): r"""GetTotalError(L2ZienkiewiczZhuEstimator self) -> double""" return _estimators.L2ZienkiewiczZhuEstimator_GetTotalError(self) + GetTotalError = _swig_new_instance_method(_estimators.L2ZienkiewiczZhuEstimator_GetTotalError) def GetLocalErrors(self): r"""GetLocalErrors(L2ZienkiewiczZhuEstimator self) -> Vector""" return _estimators.L2ZienkiewiczZhuEstimator_GetLocalErrors(self) + GetLocalErrors = _swig_new_instance_method(_estimators.L2ZienkiewiczZhuEstimator_GetLocalErrors) def Reset(self): r"""Reset(L2ZienkiewiczZhuEstimator self)""" return _estimators.L2ZienkiewiczZhuEstimator_Reset(self) + Reset = _swig_new_instance_method(_estimators.L2ZienkiewiczZhuEstimator_Reset) __swig_destroy__ = _estimators.delete_L2ZienkiewiczZhuEstimator def __init__(self, integ, sol, flux_fes, smooth_flux_fes, own_flux_fes=False): diff --git a/mfem/_par/estimators_wrap.cxx b/mfem/_par/estimators_wrap.cxx index f4a86a7e..22011871 100644 --- a/mfem/_par/estimators_wrap.cxx +++ b/mfem/_par/estimators_wrap.cxx @@ -3067,110 +3067,112 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__AbstractErrorEstimator swig_types[5] -#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[8] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[10] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[11] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[12] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[17] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[18] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[20] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[21] -#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[22] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[23] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[24] -#define SWIGTYPE_p_mfem__GridFunction swig_types[25] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[26] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[27] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[28] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[29] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__L2ZienkiewiczZhuEstimator swig_types[31] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[32] -#define SWIGTYPE_p_mfem__LinearForm swig_types[33] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[35] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[36] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[38] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[39] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[40] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[41] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[42] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[43] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[44] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[45] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[46] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[47] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[48] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[49] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[50] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[51] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[53] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[57] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[58] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[59] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[60] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[61] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[62] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[63] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[66] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[67] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[74] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[75] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[76] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[77] -#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[78] -#define SWIGTYPE_p_mfem__ParGridFunction swig_types[79] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[80] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[81] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[82] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[83] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__Vector swig_types[86] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[87] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[90] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[93] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[94] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[95] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[96] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[97] -#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[98] -#define SWIGTYPE_p_pri_t swig_types[99] -#define SWIGTYPE_p_quad_t swig_types[100] -#define SWIGTYPE_p_seg_t swig_types[101] -#define SWIGTYPE_p_tet_t swig_types[102] -#define SWIGTYPE_p_tri_t swig_types[103] -static swig_type_info *swig_types[105]; -static swig_module_info swig_module = {swig_types, 104, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__AbstractErrorEstimator swig_types[6] +#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[9] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[10] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[11] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[12] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[13] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[18] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[19] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[21] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[22] +#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[23] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[24] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[25] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[26] +#define SWIGTYPE_p_mfem__GridFunction swig_types[27] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[28] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[29] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[30] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[31] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__L2ZienkiewiczZhuEstimator swig_types[33] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[34] +#define SWIGTYPE_p_mfem__LinearForm swig_types[35] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[36] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[37] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[39] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[40] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[41] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[42] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[43] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[44] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[45] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[46] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[47] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[48] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[49] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[50] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[51] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[52] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[53] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[56] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[57] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[60] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[61] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[62] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[63] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[64] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[65] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[66] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[69] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[70] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[76] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[77] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[78] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[79] +#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[80] +#define SWIGTYPE_p_mfem__ParGridFunction swig_types[81] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[82] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[83] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[84] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[85] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__Vector swig_types[88] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[89] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[91] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[93] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[95] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[96] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[97] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[98] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[99] +#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[100] +#define SWIGTYPE_p_pri_t swig_types[101] +#define SWIGTYPE_p_quad_t swig_types[102] +#define SWIGTYPE_p_seg_t swig_types[103] +#define SWIGTYPE_p_tet_t swig_types[104] +#define SWIGTYPE_p_tri_t swig_types[105] +static swig_type_info *swig_types[107]; +static swig_module_info swig_module = {swig_types, 106, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3723,6 +3725,110 @@ SWIGINTERN PyObject *AnisotropicErrorEstimator_swigregister(PyObject *SWIGUNUSED return SWIG_Py_Void(); } +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); + } + arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + (arg1)->SetWithCoeff(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); + } + arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); + { + try { + (arg1)->SetWithCoeff(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetWithCoeff", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZienkiewiczZhuEstimator_SetWithCoeff'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ZienkiewiczZhuEstimator::SetWithCoeff(bool)\n" + " mfem::ZienkiewiczZhuEstimator::SetWithCoeff()\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; @@ -4553,6 +4659,7 @@ SWIGINTERN PyObject *L2ZienkiewiczZhuEstimator_swiginit(PyObject *SWIGUNUSEDPARM static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "delete_AbstractErrorEstimator", _wrap_delete_AbstractErrorEstimator, METH_O, "delete_AbstractErrorEstimator(AbstractErrorEstimator self)"}, { "new_AbstractErrorEstimator", _wrap_new_AbstractErrorEstimator, METH_NOARGS, "new_AbstractErrorEstimator() -> AbstractErrorEstimator"}, { "AbstractErrorEstimator_swigregister", AbstractErrorEstimator_swigregister, METH_O, NULL}, @@ -4564,6 +4671,7 @@ static PyMethodDef SwigMethods[] = { { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "AnisotropicErrorEstimator_GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "ZienkiewiczZhuEstimator_SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "ZienkiewiczZhuEstimator_SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "ZienkiewiczZhuEstimator_SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "ZienkiewiczZhuEstimator_GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, @@ -4586,6 +4694,38 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "delete_AbstractErrorEstimator", _wrap_delete_AbstractErrorEstimator, METH_O, "delete_AbstractErrorEstimator(AbstractErrorEstimator self)"}, + { "new_AbstractErrorEstimator", _wrap_new_AbstractErrorEstimator, METH_NOARGS, "new_AbstractErrorEstimator() -> AbstractErrorEstimator"}, + { "AbstractErrorEstimator_swigregister", AbstractErrorEstimator_swigregister, METH_O, NULL}, + { "AbstractErrorEstimator_swiginit", AbstractErrorEstimator_swiginit, METH_VARARGS, NULL}, + { "ErrorEstimator_GetLocalErrors", _wrap_ErrorEstimator_GetLocalErrors, METH_O, "GetLocalErrors(ErrorEstimator self) -> Vector"}, + { "ErrorEstimator_Reset", _wrap_ErrorEstimator_Reset, METH_O, "Reset(ErrorEstimator self)"}, + { "delete_ErrorEstimator", _wrap_delete_ErrorEstimator, METH_O, "delete_ErrorEstimator(ErrorEstimator self)"}, + { "ErrorEstimator_swigregister", ErrorEstimator_swigregister, METH_O, NULL}, + { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, + { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, + { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, + { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, + { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, + { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, + { "ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector"}, + { "ZienkiewiczZhuEstimator_GetAnisotropicFlags", _wrap_ZienkiewiczZhuEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray"}, + { "ZienkiewiczZhuEstimator_Reset", _wrap_ZienkiewiczZhuEstimator_Reset, METH_O, "Reset(ZienkiewiczZhuEstimator self)"}, + { "delete_ZienkiewiczZhuEstimator", _wrap_delete_ZienkiewiczZhuEstimator, METH_O, "delete_ZienkiewiczZhuEstimator(ZienkiewiczZhuEstimator self)"}, + { "new_ZienkiewiczZhuEstimator", _wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS, "ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False)"}, + { "ZienkiewiczZhuEstimator_swigregister", ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, + { "ZienkiewiczZhuEstimator_swiginit", ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, + { "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP", _wrap_L2ZienkiewiczZhuEstimator_SetLocalErrorNormP, METH_VARARGS, "SetLocalErrorNormP(L2ZienkiewiczZhuEstimator self, int p)"}, + { "L2ZienkiewiczZhuEstimator_GetTotalError", _wrap_L2ZienkiewiczZhuEstimator_GetTotalError, METH_O, "GetTotalError(L2ZienkiewiczZhuEstimator self) -> double"}, + { "L2ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_L2ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "GetLocalErrors(L2ZienkiewiczZhuEstimator self) -> Vector"}, + { "L2ZienkiewiczZhuEstimator_Reset", _wrap_L2ZienkiewiczZhuEstimator_Reset, METH_O, "Reset(L2ZienkiewiczZhuEstimator self)"}, + { "delete_L2ZienkiewiczZhuEstimator", _wrap_delete_L2ZienkiewiczZhuEstimator, METH_O, "delete_L2ZienkiewiczZhuEstimator(L2ZienkiewiczZhuEstimator self)"}, + { "new_L2ZienkiewiczZhuEstimator", _wrap_new_L2ZienkiewiczZhuEstimator, METH_VARARGS, "L2ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, mfem::ParGridFunction & sol, mfem::ParFiniteElementSpace * flux_fes, mfem::ParFiniteElementSpace * smooth_flux_fes, bool own_flux_fes=False)"}, + { "L2ZienkiewiczZhuEstimator_swigregister", L2ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, + { "L2ZienkiewiczZhuEstimator_swiginit", L2ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4670,6 +4810,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -4799,9 +4942,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -4826,6 +4966,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -4858,6 +5001,7 @@ static void *_p_mfem__L2ZienkiewiczZhuEstimatorTo_p_mfem__AbstractErrorEstimator } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -4865,7 +5009,6 @@ static swig_type_info _swigt__p_mfem__AbstractErrorEstimator = {"_p_mfem__Abstra static swig_type_info _swigt__p_mfem__AnisotropicErrorEstimator = {"_p_mfem__AnisotropicErrorEstimator", "mfem::AnisotropicErrorEstimator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -4876,6 +5019,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -4897,6 +5041,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -4929,8 +5074,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -4939,6 +5083,7 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ErrorEstimator = {"_p_mfem__ErrorEstimator", "mfem::ErrorEstimator *", 0, 0, (void*)0, 0}; @@ -4964,6 +5109,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -4986,6 +5132,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__ErrorEstimator, &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GroupConvectionIntegrator, @@ -5070,13 +5217,13 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractErrorEstimator[] = { {&_swigt__p_mfem__AbstractErrorEstimator, 0, 0, 0}, {&_swigt__p_mfem__ErrorEstimator, _p_mfem__ErrorEstimatorTo_p_mfem__AbstractErrorEstimator, 0, 0}, {&_swigt__p_mfem__AnisotropicErrorEstimator, _p_mfem__AnisotropicErrorEstimatorTo_p_mfem__AbstractErrorEstimator, 0, 0}, {&_swigt__p_mfem__ZienkiewiczZhuEstimator, _p_mfem__ZienkiewiczZhuEstimatorTo_p_mfem__AbstractErrorEstimator, 0, 0}, {&_swigt__p_mfem__L2ZienkiewiczZhuEstimator, _p_mfem__L2ZienkiewiczZhuEstimatorTo_p_mfem__AbstractErrorEstimator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AnisotropicErrorEstimator[] = { {&_swigt__p_mfem__AnisotropicErrorEstimator, 0, 0, 0}, {&_swigt__p_mfem__ZienkiewiczZhuEstimator, _p_mfem__ZienkiewiczZhuEstimatorTo_p_mfem__AnisotropicErrorEstimator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -5087,6 +5234,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -5108,6 +5256,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -5140,8 +5289,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -5150,9 +5298,10 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ErrorEstimator[] = { {&_swigt__p_mfem__ErrorEstimator, 0, 0, 0}, {&_swigt__p_mfem__AnisotropicErrorEstimator, _p_mfem__AnisotropicErrorEstimatorTo_p_mfem__ErrorEstimator, 0, 0}, {&_swigt__p_mfem__ZienkiewiczZhuEstimator, _p_mfem__ZienkiewiczZhuEstimatorTo_p_mfem__ErrorEstimator, 0, 0}, {&_swigt__p_mfem__L2ZienkiewiczZhuEstimator, _p_mfem__L2ZienkiewiczZhuEstimatorTo_p_mfem__ErrorEstimator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -5176,6 +5325,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -5198,6 +5348,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__ErrorEstimator, _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GroupConvectionIntegrator, @@ -6007,18 +6158,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/fe.py b/mfem/_par/fe.py index 25a81bc7..f1aca2c4 100644 --- a/mfem/_par/fe.py +++ b/mfem/_par/fe.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _fe.SWIG_PyInstanceMethod_New +_swig_new_static_method = _fe.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -91,6 +94,8 @@ class BasisType(object): OpenHalfUniform = _fe.BasisType_OpenHalfUniform + Serendipity = _fe.BasisType_Serendipity + NumBasisTypes = _fe.BasisType_NumBasisTypes @@ -98,36 +103,43 @@ class BasisType(object): def Check(b_type): r"""Check(int b_type) -> int""" return _fe.BasisType_Check(b_type) + Check = _swig_new_static_method(_fe.BasisType_Check) @staticmethod def CheckNodal(b_type): r"""CheckNodal(int b_type) -> int""" return _fe.BasisType_CheckNodal(b_type) + CheckNodal = _swig_new_static_method(_fe.BasisType_CheckNodal) @staticmethod def GetQuadrature1D(b_type): r"""GetQuadrature1D(int b_type) -> int""" return _fe.BasisType_GetQuadrature1D(b_type) + GetQuadrature1D = _swig_new_static_method(_fe.BasisType_GetQuadrature1D) @staticmethod def GetNodalBasis(qpt_type): r"""GetNodalBasis(int qpt_type) -> int""" return _fe.BasisType_GetNodalBasis(qpt_type) + GetNodalBasis = _swig_new_static_method(_fe.BasisType_GetNodalBasis) @staticmethod def Name(b_type): r"""Name(int b_type) -> char const *""" return _fe.BasisType_Name(b_type) + Name = _swig_new_static_method(_fe.BasisType_Name) @staticmethod def GetChar(b_type): r"""GetChar(int b_type) -> char""" return _fe.BasisType_GetChar(b_type) + GetChar = _swig_new_static_method(_fe.BasisType_GetChar) @staticmethod def GetType(b_ident): r"""GetType(char b_ident) -> int""" return _fe.BasisType_GetType(b_ident) + GetType = _swig_new_static_method(_fe.BasisType_GetType) def __init__(self): r"""__init__(BasisType self) -> BasisType""" @@ -140,30 +152,37 @@ def __init__(self): def BasisType_Check(b_type): r"""BasisType_Check(int b_type) -> int""" return _fe.BasisType_Check(b_type) +BasisType_Check = _fe.BasisType_Check def BasisType_CheckNodal(b_type): r"""BasisType_CheckNodal(int b_type) -> int""" return _fe.BasisType_CheckNodal(b_type) +BasisType_CheckNodal = _fe.BasisType_CheckNodal def BasisType_GetQuadrature1D(b_type): r"""BasisType_GetQuadrature1D(int b_type) -> int""" return _fe.BasisType_GetQuadrature1D(b_type) +BasisType_GetQuadrature1D = _fe.BasisType_GetQuadrature1D def BasisType_GetNodalBasis(qpt_type): r"""BasisType_GetNodalBasis(int qpt_type) -> int""" return _fe.BasisType_GetNodalBasis(qpt_type) +BasisType_GetNodalBasis = _fe.BasisType_GetNodalBasis def BasisType_Name(b_type): r"""BasisType_Name(int b_type) -> char const *""" return _fe.BasisType_Name(b_type) +BasisType_Name = _fe.BasisType_Name def BasisType_GetChar(b_type): r"""BasisType_GetChar(int b_type) -> char""" return _fe.BasisType_GetChar(b_type) +BasisType_GetChar = _fe.BasisType_GetChar def BasisType_GetType(b_ident): r"""BasisType_GetType(char b_ident) -> int""" return _fe.BasisType_GetType(b_ident) +BasisType_GetType = _fe.BasisType_GetType class DofToQuad(object): r"""Proxy of C++ mfem::DofToQuad class.""" @@ -243,70 +262,87 @@ def __init__(self, *args, **kwargs): def GetDim(self): r"""GetDim(FiniteElement self) -> int""" return _fe.FiniteElement_GetDim(self) + GetDim = _swig_new_instance_method(_fe.FiniteElement_GetDim) def GetGeomType(self): r"""GetGeomType(FiniteElement self) -> mfem::Geometry::Type""" return _fe.FiniteElement_GetGeomType(self) + GetGeomType = _swig_new_instance_method(_fe.FiniteElement_GetGeomType) def GetDof(self): r"""GetDof(FiniteElement self) -> int""" return _fe.FiniteElement_GetDof(self) + GetDof = _swig_new_instance_method(_fe.FiniteElement_GetDof) def GetOrder(self): r"""GetOrder(FiniteElement self) -> int""" return _fe.FiniteElement_GetOrder(self) + GetOrder = _swig_new_instance_method(_fe.FiniteElement_GetOrder) def HasAnisotropicOrders(self): r"""HasAnisotropicOrders(FiniteElement self) -> bool""" return _fe.FiniteElement_HasAnisotropicOrders(self) + HasAnisotropicOrders = _swig_new_instance_method(_fe.FiniteElement_HasAnisotropicOrders) def GetAnisotropicOrders(self): r"""GetAnisotropicOrders(FiniteElement self) -> int const *""" return _fe.FiniteElement_GetAnisotropicOrders(self) + GetAnisotropicOrders = _swig_new_instance_method(_fe.FiniteElement_GetAnisotropicOrders) def Space(self): r"""Space(FiniteElement self) -> int""" return _fe.FiniteElement_Space(self) + Space = _swig_new_instance_method(_fe.FiniteElement_Space) def GetRangeType(self): r"""GetRangeType(FiniteElement self) -> int""" return _fe.FiniteElement_GetRangeType(self) + GetRangeType = _swig_new_instance_method(_fe.FiniteElement_GetRangeType) def GetDerivRangeType(self): r"""GetDerivRangeType(FiniteElement self) -> int""" return _fe.FiniteElement_GetDerivRangeType(self) + GetDerivRangeType = _swig_new_instance_method(_fe.FiniteElement_GetDerivRangeType) def GetMapType(self): r"""GetMapType(FiniteElement self) -> int""" return _fe.FiniteElement_GetMapType(self) + GetMapType = _swig_new_instance_method(_fe.FiniteElement_GetMapType) def GetDerivType(self): r"""GetDerivType(FiniteElement self) -> int""" return _fe.FiniteElement_GetDerivType(self) + GetDerivType = _swig_new_instance_method(_fe.FiniteElement_GetDerivType) def GetDerivMapType(self): r"""GetDerivMapType(FiniteElement self) -> int""" return _fe.FiniteElement_GetDerivMapType(self) + GetDerivMapType = _swig_new_instance_method(_fe.FiniteElement_GetDerivMapType) def CalcShape(self, ip, shape): r"""CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.FiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.FiniteElement_CalcShape) def CalcPhysShape(self, Trans, shape): r"""CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)""" return _fe.FiniteElement_CalcPhysShape(self, Trans, shape) + CalcPhysShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.FiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.FiniteElement_CalcDShape) def CalcPhysDShape(self, Trans, dshape): r"""CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)""" return _fe.FiniteElement_CalcPhysDShape(self, Trans, dshape) + CalcPhysDShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysDShape) def GetNodes(self): r"""GetNodes(FiniteElement self) -> IntegrationRule""" return _fe.FiniteElement_GetNodes(self) + GetNodes = _swig_new_instance_method(_fe.FiniteElement_GetNodes) def CalcVShape(self, *args): r""" @@ -314,54 +350,82 @@ def CalcVShape(self, *args): CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.FiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.FiniteElement_CalcVShape) def CalcPhysVShape(self, Trans, shape): r"""CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)""" return _fe.FiniteElement_CalcPhysVShape(self, Trans, shape) + CalcPhysVShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.FiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.FiniteElement_CalcDivShape) def CalcPhysDivShape(self, Trans, divshape): r"""CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)""" return _fe.FiniteElement_CalcPhysDivShape(self, Trans, divshape) + CalcPhysDivShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysDivShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.FiniteElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.FiniteElement_CalcCurlShape) def CalcPhysCurlShape(self, Trans, curl_shape): r"""CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)""" return _fe.FiniteElement_CalcPhysCurlShape(self, Trans, curl_shape) + CalcPhysCurlShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysCurlShape) def GetFaceDofs(self, face, dofs, ndofs): r"""GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)""" return _fe.FiniteElement_GetFaceDofs(self, face, dofs, ndofs) + GetFaceDofs = _swig_new_instance_method(_fe.FiniteElement_GetFaceDofs) - def CalcHessian(self, ip, h): - r"""CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix h)""" - return _fe.FiniteElement_CalcHessian(self, ip, h) + def CalcHessian(self, ip, Hessian): + r"""CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)""" + return _fe.FiniteElement_CalcHessian(self, ip, Hessian) + CalcHessian = _swig_new_instance_method(_fe.FiniteElement_CalcHessian) + + def CalcPhysHessian(self, Trans, Hessian): + r"""CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)""" + return _fe.FiniteElement_CalcPhysHessian(self, Trans, Hessian) + CalcPhysHessian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysHessian) + + def CalcPhysLaplacian(self, Trans, Laplacian): + r"""CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)""" + return _fe.FiniteElement_CalcPhysLaplacian(self, Trans, Laplacian) + CalcPhysLaplacian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysLaplacian) + + def CalcPhysLinLaplacian(self, Trans, Laplacian): + r"""CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)""" + return _fe.FiniteElement_CalcPhysLinLaplacian(self, Trans, Laplacian) + CalcPhysLinLaplacian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysLinLaplacian) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.FiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.FiniteElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.FiniteElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.FiniteElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.FiniteElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.FiniteElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.FiniteElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.FiniteElement_ProjectMatrixCoefficient) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(FiniteElement self, int vertex, Vector dofs)""" return _fe.FiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.FiniteElement_ProjectDelta) def Project(self, *args): r""" @@ -370,48 +434,58 @@ def Project(self, *args): Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.FiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.FiniteElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.FiniteElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.FiniteElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.FiniteElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.FiniteElement_ProjectCurl) def ProjectDiv(self, fe, Trans, div): r"""ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)""" return _fe.FiniteElement_ProjectDiv(self, fe, Trans, div) + ProjectDiv = _swig_new_instance_method(_fe.FiniteElement_ProjectDiv) def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.FiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.FiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_FiniteElement @staticmethod def IsClosedType(b_type): r"""IsClosedType(int b_type) -> bool""" return _fe.FiniteElement_IsClosedType(b_type) + IsClosedType = _swig_new_static_method(_fe.FiniteElement_IsClosedType) @staticmethod def IsOpenType(b_type): r"""IsOpenType(int b_type) -> bool""" return _fe.FiniteElement_IsOpenType(b_type) + IsOpenType = _swig_new_static_method(_fe.FiniteElement_IsOpenType) @staticmethod def VerifyClosed(b_type): r"""VerifyClosed(int b_type) -> int""" return _fe.FiniteElement_VerifyClosed(b_type) + VerifyClosed = _swig_new_static_method(_fe.FiniteElement_VerifyClosed) @staticmethod def VerifyOpen(b_type): r"""VerifyOpen(int b_type) -> int""" return _fe.FiniteElement_VerifyOpen(b_type) + VerifyOpen = _swig_new_static_method(_fe.FiniteElement_VerifyOpen) @staticmethod def VerifyNodal(b_type): r"""VerifyNodal(int b_type) -> int""" return _fe.FiniteElement_VerifyNodal(b_type) + VerifyNodal = _swig_new_static_method(_fe.FiniteElement_VerifyNodal) # Register FiniteElement in _fe: _fe.FiniteElement_swigregister(FiniteElement) @@ -419,22 +493,27 @@ def VerifyNodal(b_type): def FiniteElement_IsClosedType(b_type): r"""FiniteElement_IsClosedType(int b_type) -> bool""" return _fe.FiniteElement_IsClosedType(b_type) +FiniteElement_IsClosedType = _fe.FiniteElement_IsClosedType def FiniteElement_IsOpenType(b_type): r"""FiniteElement_IsOpenType(int b_type) -> bool""" return _fe.FiniteElement_IsOpenType(b_type) +FiniteElement_IsOpenType = _fe.FiniteElement_IsOpenType def FiniteElement_VerifyClosed(b_type): r"""FiniteElement_VerifyClosed(int b_type) -> int""" return _fe.FiniteElement_VerifyClosed(b_type) +FiniteElement_VerifyClosed = _fe.FiniteElement_VerifyClosed def FiniteElement_VerifyOpen(b_type): r"""FiniteElement_VerifyOpen(int b_type) -> int""" return _fe.FiniteElement_VerifyOpen(b_type) +FiniteElement_VerifyOpen = _fe.FiniteElement_VerifyOpen def FiniteElement_VerifyNodal(b_type): r"""FiniteElement_VerifyNodal(int b_type) -> int""" return _fe.FiniteElement_VerifyNodal(b_type) +FiniteElement_VerifyNodal = _fe.FiniteElement_VerifyNodal class ScalarFiniteElement(FiniteElement): r"""Proxy of C++ mfem::ScalarFiniteElement class.""" @@ -448,18 +527,22 @@ def __init__(self, *args, **kwargs): def SetMapType(self, M): r"""SetMapType(ScalarFiniteElement self, int M)""" return _fe.ScalarFiniteElement_SetMapType(self, M) + SetMapType = _swig_new_instance_method(_fe.ScalarFiniteElement_SetMapType) def NodalLocalInterpolation(self, Trans, I, fine_fe): r"""NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)""" return _fe.ScalarFiniteElement_NodalLocalInterpolation(self, Trans, I, fine_fe) + NodalLocalInterpolation = _swig_new_instance_method(_fe.ScalarFiniteElement_NodalLocalInterpolation) def ScalarLocalInterpolation(self, Trans, I, fine_fe): r"""ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)""" return _fe.ScalarFiniteElement_ScalarLocalInterpolation(self, Trans, I, fine_fe) + ScalarLocalInterpolation = _swig_new_instance_method(_fe.ScalarFiniteElement_ScalarLocalInterpolation) def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.ScalarFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.ScalarFiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_ScalarFiniteElement # Register ScalarFiniteElement in _fe: @@ -477,18 +560,22 @@ def __init__(self, *args, **kwargs): def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.NodalFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.NodalFiniteElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.NodalFiniteElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.NodalFiniteElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.NodalFiniteElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.NodalFiniteElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.NodalFiniteElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -497,14 +584,17 @@ def Project(self, *args): Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.NodalFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.NodalFiniteElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.NodalFiniteElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectGrad) def ProjectDiv(self, fe, Trans, div): r"""ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)""" return _fe.NodalFiniteElement_ProjectDiv(self, fe, Trans, div) + ProjectDiv = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectDiv) __swig_destroy__ = _fe.delete_NodalFiniteElement # Register NodalFiniteElement in _fe: @@ -522,10 +612,12 @@ def __init__(self, *args, **kwargs): def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.PositiveFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.PositiveFiniteElement_GetLocalInterpolation) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.PositiveFiniteElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.PositiveFiniteElement_GetTransferMatrix) def Project(self, *args): r""" @@ -537,6 +629,7 @@ def Project(self, *args): Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.PositiveFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.PositiveFiniteElement_Project) __swig_destroy__ = _fe.delete_PositiveFiniteElement # Register PositiveFiniteElement in _fe: @@ -569,10 +662,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.PointFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.PointFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.PointFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.PointFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_PointFiniteElement # Register PointFiniteElement in _fe: @@ -591,10 +686,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Linear1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Linear1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Linear1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Linear1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Linear1DFiniteElement # Register Linear1DFiniteElement in _fe: @@ -613,14 +710,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Linear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Linear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Linear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Linear2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.Linear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.Linear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_Linear2DFiniteElement # Register Linear2DFiniteElement in _fe: @@ -639,18 +739,22 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.BiLinear2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcHessian) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.BiLinear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_BiLinear2DFiniteElement # Register BiLinear2DFiniteElement in _fe: @@ -669,14 +773,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.GaussLinear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_GaussLinear2DFiniteElement # Register GaussLinear2DFiniteElement in _fe: @@ -695,14 +802,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussBiLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussBiLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.GaussBiLinear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_GaussBiLinear2DFiniteElement # Register GaussBiLinear2DFiniteElement in _fe: @@ -721,14 +831,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P1OnQuadFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P1OnQuadFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)""" return _fe.P1OnQuadFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P1OnQuadFiniteElement # Register P1OnQuadFiniteElement in _fe: @@ -747,10 +860,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Quad1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Quad1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Quad1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Quad1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Quad1DFiniteElement # Register Quad1DFiniteElement in _fe: @@ -769,10 +884,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.QuadPos1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.QuadPos1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.QuadPos1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.QuadPos1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_QuadPos1DFiniteElement # Register QuadPos1DFiniteElement in _fe: @@ -791,18 +908,22 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Quad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Quad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.Quad2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcHessian) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)""" return _fe.Quad2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.Quad2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_Quad2DFiniteElement # Register Quad2DFiniteElement in _fe: @@ -821,10 +942,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussQuad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussQuad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussQuad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussQuad2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_GaussQuad2DFiniteElement # Register GaussQuad2DFiniteElement in _fe: @@ -843,14 +966,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiQuad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiQuad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)""" return _fe.BiQuad2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_BiQuad2DFiniteElement # Register BiQuad2DFiniteElement in _fe: @@ -869,14 +995,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiQuadPos2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiQuadPos2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_CalcDShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.BiQuadPos2DFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -887,10 +1016,12 @@ def Project(self, *args): Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.BiQuadPos2DFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_Project) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)""" return _fe.BiQuadPos2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_BiQuadPos2DFiniteElement # Register BiQuadPos2DFiniteElement in _fe: @@ -909,10 +1040,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussBiQuad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussBiQuad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussBiQuad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussBiQuad2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_GaussBiQuad2DFiniteElement # Register GaussBiQuad2DFiniteElement in _fe: @@ -931,14 +1064,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiCubic2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiCubic2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.BiCubic2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_BiCubic2DFiniteElement # Register BiCubic2DFiniteElement in _fe: @@ -957,10 +1093,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Cubic1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Cubic1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Cubic1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Cubic1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Cubic1DFiniteElement # Register Cubic1DFiniteElement in _fe: @@ -979,14 +1117,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Cubic2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Cubic2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.Cubic2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_Cubic2DFiniteElement # Register Cubic2DFiniteElement in _fe: @@ -1005,10 +1146,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Cubic3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Cubic3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Cubic3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Cubic3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Cubic3DFiniteElement # Register Cubic3DFiniteElement in _fe: @@ -1027,14 +1170,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0TriangleFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0TriangleFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0TriangleFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0TriangleFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)""" return _fe.P0TriangleFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0TriangleFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0TriangleFiniteElement # Register P0TriangleFiniteElement in _fe: @@ -1053,14 +1199,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0QuadFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0QuadFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0QuadFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0QuadFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)""" return _fe.P0QuadFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0QuadFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0QuadFiniteElement # Register P0QuadFiniteElement in _fe: @@ -1079,18 +1228,22 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Linear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Linear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Linear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Linear3DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)""" return _fe.Linear3DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.Linear3DFiniteElement_ProjectDelta) def GetFaceDofs(self, face, dofs, ndofs): r"""GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)""" return _fe.Linear3DFiniteElement_GetFaceDofs(self, face, dofs, ndofs) + GetFaceDofs = _swig_new_instance_method(_fe.Linear3DFiniteElement_GetFaceDofs) __swig_destroy__ = _fe.delete_Linear3DFiniteElement # Register Linear3DFiniteElement in _fe: @@ -1109,10 +1262,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Quadratic3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Quadratic3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Quadratic3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Quadratic3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Quadratic3DFiniteElement # Register Quadratic3DFiniteElement in _fe: @@ -1131,14 +1286,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.TriLinear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.TriLinear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)""" return _fe.TriLinear3DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_TriLinear3DFiniteElement # Register TriLinear3DFiniteElement in _fe: @@ -1157,14 +1315,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.CrouzeixRaviartFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.CrouzeixRaviartFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)""" return _fe.CrouzeixRaviartFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_CrouzeixRaviartFiniteElement # Register CrouzeixRaviartFiniteElement in _fe: @@ -1183,10 +1344,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.CrouzeixRaviartQuadFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.CrouzeixRaviartQuadFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.CrouzeixRaviartQuadFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.CrouzeixRaviartQuadFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_CrouzeixRaviartQuadFiniteElement # Register CrouzeixRaviartQuadFiniteElement in _fe: @@ -1205,10 +1368,12 @@ def __init__(self, Ord=0): def CalcShape(self, ip, shape): r"""CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0SegmentFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0SegmentFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0SegmentFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0SegmentFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P0SegmentFiniteElement # Register P0SegmentFiniteElement in _fe: @@ -1230,14 +1395,17 @@ def CalcVShape(self, *args): CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0TriangleFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0TriangleFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0TriangleFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1247,6 +1415,7 @@ def Project(self, *args): Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0TriangleFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0TriangleFiniteElement # Register RT0TriangleFiniteElement in _fe: @@ -1268,14 +1437,17 @@ def CalcVShape(self, *args): CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0QuadFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0QuadFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0QuadFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0QuadFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0QuadFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0QuadFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1285,6 +1457,7 @@ def Project(self, *args): Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0QuadFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0QuadFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0QuadFiniteElement # Register RT0QuadFiniteElement in _fe: @@ -1306,14 +1479,17 @@ def CalcVShape(self, *args): CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT1TriangleFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT1TriangleFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT1TriangleFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1323,6 +1499,7 @@ def Project(self, *args): Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT1TriangleFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_Project) __swig_destroy__ = _fe.delete_RT1TriangleFiniteElement # Register RT1TriangleFiniteElement in _fe: @@ -1344,14 +1521,17 @@ def CalcVShape(self, *args): CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT1QuadFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT1QuadFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT1QuadFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT1QuadFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT1QuadFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT1QuadFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1361,6 +1541,7 @@ def Project(self, *args): Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT1QuadFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT1QuadFiniteElement_Project) __swig_destroy__ = _fe.delete_RT1QuadFiniteElement # Register RT1QuadFiniteElement in _fe: @@ -1382,10 +1563,12 @@ def CalcVShape(self, *args): CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT2TriangleFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT2TriangleFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT2TriangleFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT2TriangleFiniteElement_CalcDivShape) __swig_destroy__ = _fe.delete_RT2TriangleFiniteElement # Register RT2TriangleFiniteElement in _fe: @@ -1407,14 +1590,17 @@ def CalcVShape(self, *args): CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT2QuadFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT2QuadFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT2QuadFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT2QuadFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT2QuadFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT2QuadFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1424,6 +1610,7 @@ def Project(self, *args): Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT2QuadFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT2QuadFiniteElement_Project) __swig_destroy__ = _fe.delete_RT2QuadFiniteElement # Register RT2QuadFiniteElement in _fe: @@ -1442,10 +1629,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P1SegmentFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P1SegmentFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P1SegmentFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P1SegmentFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P1SegmentFiniteElement # Register P1SegmentFiniteElement in _fe: @@ -1464,10 +1653,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P2SegmentFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P2SegmentFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P2SegmentFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P2SegmentFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P2SegmentFiniteElement # Register P2SegmentFiniteElement in _fe: @@ -1486,10 +1677,12 @@ def __init__(self, degree): def CalcShape(self, ip, shape): r"""CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Lagrange1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Lagrange1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Lagrange1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Lagrange1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Lagrange1DFiniteElement # Register Lagrange1DFiniteElement in _fe: @@ -1508,10 +1701,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P1TetNonConfFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P1TetNonConfFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P1TetNonConfFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P1TetNonConfFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P1TetNonConfFiniteElement # Register P1TetNonConfFiniteElement in _fe: @@ -1530,14 +1725,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0TetFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0TetFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0TetFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0TetFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)""" return _fe.P0TetFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0TetFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0TetFiniteElement # Register P0TetFiniteElement in _fe: @@ -1556,14 +1754,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0HexFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0HexFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0HexFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0HexFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)""" return _fe.P0HexFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0HexFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0HexFiniteElement # Register P0HexFiniteElement in _fe: @@ -1582,10 +1783,12 @@ def __init__(self, degree): def CalcShape(self, ip, shape): r"""CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.LagrangeHexFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.LagrangeHexFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.LagrangeHexFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.LagrangeHexFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_LagrangeHexFiniteElement # Register LagrangeHexFiniteElement in _fe: @@ -1604,10 +1807,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedLinear1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedLinear1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedLinear1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedLinear1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedLinear1DFiniteElement # Register RefinedLinear1DFiniteElement in _fe: @@ -1626,10 +1831,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedLinear2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedLinear2DFiniteElement # Register RefinedLinear2DFiniteElement in _fe: @@ -1648,10 +1855,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedLinear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedLinear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedLinear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedLinear3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedLinear3DFiniteElement # Register RefinedLinear3DFiniteElement in _fe: @@ -1670,10 +1879,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedBiLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedBiLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedBiLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedBiLinear2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedBiLinear2DFiniteElement # Register RefinedBiLinear2DFiniteElement in _fe: @@ -1692,10 +1903,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedTriLinear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedTriLinear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedTriLinear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedTriLinear3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedTriLinear3DFiniteElement # Register RefinedTriLinear3DFiniteElement in _fe: @@ -1717,14 +1930,17 @@ def CalcVShape(self, *args): CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.Nedelec1HexFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.Nedelec1HexFiniteElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.Nedelec1HexFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1734,6 +1950,7 @@ def Project(self, *args): Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.Nedelec1HexFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_Project) __swig_destroy__ = _fe.delete_Nedelec1HexFiniteElement # Register Nedelec1HexFiniteElement in _fe: @@ -1755,14 +1972,17 @@ def CalcVShape(self, *args): CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.Nedelec1TetFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.Nedelec1TetFiniteElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.Nedelec1TetFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1772,6 +1992,7 @@ def Project(self, *args): Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.Nedelec1TetFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_Project) __swig_destroy__ = _fe.delete_Nedelec1TetFiniteElement # Register Nedelec1TetFiniteElement in _fe: @@ -1793,14 +2014,17 @@ def CalcVShape(self, *args): CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0HexFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0HexFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0HexFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0HexFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0HexFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0HexFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1810,6 +2034,7 @@ def Project(self, *args): Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0HexFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0HexFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0HexFiniteElement # Register RT0HexFiniteElement in _fe: @@ -1831,14 +2056,17 @@ def CalcVShape(self, *args): CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT1HexFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT1HexFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT1HexFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT1HexFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT1HexFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT1HexFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1848,6 +2076,7 @@ def Project(self, *args): Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT1HexFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT1HexFiniteElement_Project) __swig_destroy__ = _fe.delete_RT1HexFiniteElement # Register RT1HexFiniteElement in _fe: @@ -1869,14 +2098,17 @@ def CalcVShape(self, *args): CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0TetFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0TetFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0TetFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0TetFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0TetFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0TetFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1886,6 +2118,7 @@ def Project(self, *args): Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0TetFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0TetFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0TetFiniteElement # Register RT0TetFiniteElement in _fe: @@ -1904,10 +2137,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RotTriLinearHexFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RotTriLinearHexFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RotTriLinearHexFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RotTriLinearHexFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RotTriLinearHexFiniteElement # Register RotTriLinearHexFiniteElement in _fe: @@ -1935,22 +2170,27 @@ def __init__(self): def Binom(p): r"""Binom(int const p) -> int const *""" return _fe.Poly_1D_Binom(p) + Binom = _swig_new_static_method(_fe.Poly_1D_Binom) def GetPoints(self, p, btype): r"""GetPoints(Poly_1D self, int const p, int const btype) -> double const *""" return _fe.Poly_1D_GetPoints(self, p, btype) + GetPoints = _swig_new_instance_method(_fe.Poly_1D_GetPoints) def OpenPoints(self, *args): r"""OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const""" return _fe.Poly_1D_OpenPoints(self, *args) + OpenPoints = _swig_new_instance_method(_fe.Poly_1D_OpenPoints) def ClosedPoints(self, *args): r"""ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const""" return _fe.Poly_1D_ClosedPoints(self, *args) + ClosedPoints = _swig_new_instance_method(_fe.Poly_1D_ClosedPoints) def GetBasis(self, p, btype): r"""GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &""" return _fe.Poly_1D_GetBasis(self, p, btype) + GetBasis = _swig_new_instance_method(_fe.Poly_1D_GetBasis) @staticmethod def CalcBasis(*args): @@ -1960,16 +2200,19 @@ def CalcBasis(*args): CalcBasis(int const p, double const x, double * u, double * d, double * dd) """ return _fe.Poly_1D_CalcBasis(*args) + CalcBasis = _swig_new_static_method(_fe.Poly_1D_CalcBasis) @staticmethod def CalcDelta(p, x): r"""CalcDelta(int const p, double const x) -> double""" return _fe.Poly_1D_CalcDelta(p, x) + CalcDelta = _swig_new_static_method(_fe.Poly_1D_CalcDelta) @staticmethod def ChebyshevPoints(p, x): r"""ChebyshevPoints(int const p, double * x)""" return _fe.Poly_1D_ChebyshevPoints(p, x) + ChebyshevPoints = _swig_new_static_method(_fe.Poly_1D_ChebyshevPoints) @staticmethod def CalcBinomTerms(*args): @@ -1978,11 +2221,13 @@ def CalcBinomTerms(*args): CalcBinomTerms(int const p, double const x, double const y, double * u, double * d) """ return _fe.Poly_1D_CalcBinomTerms(*args) + CalcBinomTerms = _swig_new_static_method(_fe.Poly_1D_CalcBinomTerms) @staticmethod def CalcDBinomTerms(p, x, y, d): r"""CalcDBinomTerms(int const p, double const x, double const y, double * d)""" return _fe.Poly_1D_CalcDBinomTerms(p, x, y, d) + CalcDBinomTerms = _swig_new_static_method(_fe.Poly_1D_CalcDBinomTerms) @staticmethod def CalcBernstein(*args): @@ -1991,6 +2236,16 @@ def CalcBernstein(*args): CalcBernstein(int const p, double const x, double * u, double * d) """ return _fe.Poly_1D_CalcBernstein(*args) + CalcBernstein = _swig_new_static_method(_fe.Poly_1D_CalcBernstein) + + @staticmethod + def CalcLegendre(*args): + r""" + CalcLegendre(int const p, double const x, double * u) + CalcLegendre(int const p, double const x, double * u, double * d) + """ + return _fe.Poly_1D_CalcLegendre(*args) + CalcLegendre = _swig_new_static_method(_fe.Poly_1D_CalcLegendre) __swig_destroy__ = _fe.delete_Poly_1D # Register Poly_1D in _fe: @@ -1999,6 +2254,7 @@ def CalcBernstein(*args): def Poly_1D_Binom(p): r"""Poly_1D_Binom(int const p) -> int const *""" return _fe.Poly_1D_Binom(p) +Poly_1D_Binom = _fe.Poly_1D_Binom def Poly_1D_CalcBasis(*args): r""" @@ -2007,14 +2263,17 @@ def Poly_1D_CalcBasis(*args): Poly_1D_CalcBasis(int const p, double const x, double * u, double * d, double * dd) """ return _fe.Poly_1D_CalcBasis(*args) +Poly_1D_CalcBasis = _fe.Poly_1D_CalcBasis def Poly_1D_CalcDelta(p, x): r"""Poly_1D_CalcDelta(int const p, double const x) -> double""" return _fe.Poly_1D_CalcDelta(p, x) +Poly_1D_CalcDelta = _fe.Poly_1D_CalcDelta def Poly_1D_ChebyshevPoints(p, x): r"""Poly_1D_ChebyshevPoints(int const p, double * x)""" return _fe.Poly_1D_ChebyshevPoints(p, x) +Poly_1D_ChebyshevPoints = _fe.Poly_1D_ChebyshevPoints def Poly_1D_CalcBinomTerms(*args): r""" @@ -2022,10 +2281,12 @@ def Poly_1D_CalcBinomTerms(*args): Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u, double * d) """ return _fe.Poly_1D_CalcBinomTerms(*args) +Poly_1D_CalcBinomTerms = _fe.Poly_1D_CalcBinomTerms def Poly_1D_CalcDBinomTerms(p, x, y, d): r"""Poly_1D_CalcDBinomTerms(int const p, double const x, double const y, double * d)""" return _fe.Poly_1D_CalcDBinomTerms(p, x, y, d) +Poly_1D_CalcDBinomTerms = _fe.Poly_1D_CalcDBinomTerms def Poly_1D_CalcBernstein(*args): r""" @@ -2033,6 +2294,15 @@ def Poly_1D_CalcBernstein(*args): Poly_1D_CalcBernstein(int const p, double const x, double * u, double * d) """ return _fe.Poly_1D_CalcBernstein(*args) +Poly_1D_CalcBernstein = _fe.Poly_1D_CalcBernstein + +def Poly_1D_CalcLegendre(*args): + r""" + Poly_1D_CalcLegendre(int const p, double const x, double * u) + Poly_1D_CalcLegendre(int const p, double const x, double * u, double * d) + """ + return _fe.Poly_1D_CalcLegendre(*args) +Poly_1D_CalcLegendre = _fe.Poly_1D_CalcLegendre class TensorBasisElement(object): r"""Proxy of C++ mfem::TensorBasisElement class.""" @@ -2043,6 +2313,8 @@ class TensorBasisElement(object): H1_DOF_MAP = _fe.TensorBasisElement_H1_DOF_MAP + Sr_DOF_MAP = _fe.TensorBasisElement_Sr_DOF_MAP + def __init__(self, dims, p, btype, dmtype): r"""__init__(TensorBasisElement self, int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement""" @@ -2051,24 +2323,29 @@ def __init__(self, dims, p, btype, dmtype): def GetBasisType(self): r"""GetBasisType(TensorBasisElement self) -> int""" return _fe.TensorBasisElement_GetBasisType(self) + GetBasisType = _swig_new_instance_method(_fe.TensorBasisElement_GetBasisType) def GetBasis1D(self): r"""GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &""" return _fe.TensorBasisElement_GetBasis1D(self) + GetBasis1D = _swig_new_instance_method(_fe.TensorBasisElement_GetBasis1D) def GetDofMap(self): r"""GetDofMap(TensorBasisElement self) -> intArray""" return _fe.TensorBasisElement_GetDofMap(self) + GetDofMap = _swig_new_instance_method(_fe.TensorBasisElement_GetDofMap) @staticmethod def GetTensorProductGeometry(dim): r"""GetTensorProductGeometry(int dim) -> mfem::Geometry::Type""" return _fe.TensorBasisElement_GetTensorProductGeometry(dim) + GetTensorProductGeometry = _swig_new_static_method(_fe.TensorBasisElement_GetTensorProductGeometry) @staticmethod def Pow(base, dim): r"""Pow(int base, int dim) -> int""" return _fe.TensorBasisElement_Pow(base, dim) + Pow = _swig_new_static_method(_fe.TensorBasisElement_Pow) __swig_destroy__ = _fe.delete_TensorBasisElement # Register TensorBasisElement in _fe: @@ -2077,10 +2354,12 @@ def Pow(base, dim): def TensorBasisElement_GetTensorProductGeometry(dim): r"""TensorBasisElement_GetTensorProductGeometry(int dim) -> mfem::Geometry::Type""" return _fe.TensorBasisElement_GetTensorProductGeometry(dim) +TensorBasisElement_GetTensorProductGeometry = _fe.TensorBasisElement_GetTensorProductGeometry def TensorBasisElement_Pow(base, dim): r"""TensorBasisElement_Pow(int base, int dim) -> int""" return _fe.TensorBasisElement_Pow(base, dim) +TensorBasisElement_Pow = _fe.TensorBasisElement_Pow class NodalTensorFiniteElement(NodalFiniteElement, TensorBasisElement): r"""Proxy of C++ mfem::NodalTensorFiniteElement class.""" @@ -2094,6 +2373,7 @@ def __init__(self, *args, **kwargs): def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.NodalTensorFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.NodalTensorFiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_NodalTensorFiniteElement # Register NodalTensorFiniteElement in _fe: @@ -2111,11 +2391,41 @@ def __init__(self, *args, **kwargs): def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.PositiveTensorFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.PositiveTensorFiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_PositiveTensorFiniteElement # Register PositiveTensorFiniteElement in _fe: _fe.PositiveTensorFiniteElement_swigregister(PositiveTensorFiniteElement) +class VectorTensorFiniteElement(VectorFiniteElement, TensorBasisElement): + r"""Proxy of C++ mfem::VectorTensorFiniteElement class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, dims, d, p, cbtype, obtype, M, dmtype): + r"""__init__(VectorTensorFiniteElement self, int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement""" + _fe.VectorTensorFiniteElement_swiginit(self, _fe.new_VectorTensorFiniteElement(dims, d, p, cbtype, obtype, M, dmtype)) + + def GetDofToQuad(self, ir, mode): + r"""GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" + return _fe.VectorTensorFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetDofToQuad) + + def GetDofToQuadOpen(self, ir, mode): + r"""GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" + return _fe.VectorTensorFiniteElement_GetDofToQuadOpen(self, ir, mode) + GetDofToQuadOpen = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetDofToQuadOpen) + + def GetTensorDofToQuad(self, ir, mode, closed): + r"""GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad""" + return _fe.VectorTensorFiniteElement_GetTensorDofToQuad(self, ir, mode, closed) + GetTensorDofToQuad = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetTensorDofToQuad) + __swig_destroy__ = _fe.delete_VectorTensorFiniteElement + +# Register VectorTensorFiniteElement in _fe: +_fe.VectorTensorFiniteElement_swigregister(VectorTensorFiniteElement) + class H1_SegmentElement(NodalTensorFiniteElement): r"""Proxy of C++ mfem::H1_SegmentElement class.""" @@ -2129,14 +2439,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)""" return _fe.H1_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1_SegmentElement # Register H1_SegmentElement in _fe: @@ -2155,14 +2468,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.H1_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1_QuadrilateralElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1_QuadrilateralElement # Register H1_QuadrilateralElement in _fe: @@ -2181,14 +2497,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)""" return _fe.H1_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1_HexahedronElement # Register H1_HexahedronElement in _fe: @@ -2207,14 +2526,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)""" return _fe.H1Pos_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1Pos_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1Pos_SegmentElement # Register H1Pos_SegmentElement in _fe: @@ -2233,19 +2555,60 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.H1Pos_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1Pos_QuadrilateralElement # Register H1Pos_QuadrilateralElement in _fe: _fe.H1Pos_QuadrilateralElement_swigregister(H1Pos_QuadrilateralElement) +class H1Ser_QuadrilateralElement(ScalarFiniteElement): + r"""Proxy of C++ mfem::H1Ser_QuadrilateralElement class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, p): + r"""__init__(H1Ser_QuadrilateralElement self, int const p) -> H1Ser_QuadrilateralElement""" + _fe.H1Ser_QuadrilateralElement_swiginit(self, _fe.new_H1Ser_QuadrilateralElement(p)) + + def CalcShape(self, ip, shape): + r"""CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" + return _fe.H1Ser_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_CalcShape) + + def CalcDShape(self, ip, dshape): + r"""CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" + return _fe.H1Ser_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_CalcDShape) + + def GetLocalInterpolation(self, Trans, I): + r"""GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" + return _fe.H1Ser_QuadrilateralElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_GetLocalInterpolation) + + def Project(self, *args): + r""" + Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs) + Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) + Project(H1Ser_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) + """ + return _fe.H1Ser_QuadrilateralElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_Project) + __swig_destroy__ = _fe.delete_H1Ser_QuadrilateralElement + +# Register H1Ser_QuadrilateralElement in _fe: +_fe.H1Ser_QuadrilateralElement_swigregister(H1Ser_QuadrilateralElement) + class H1Pos_HexahedronElement(PositiveTensorFiniteElement): r"""Proxy of C++ mfem::H1Pos_HexahedronElement class.""" @@ -2259,14 +2622,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)""" return _fe.H1Pos_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1Pos_HexahedronElement # Register H1Pos_HexahedronElement in _fe: @@ -2285,14 +2651,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_TriangleElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_TriangleElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_TriangleElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_TriangleElement_CalcDShape) def CalcHessian(self, ip, ddshape): r"""CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)""" return _fe.H1_TriangleElement_CalcHessian(self, ip, ddshape) + CalcHessian = _swig_new_instance_method(_fe.H1_TriangleElement_CalcHessian) __swig_destroy__ = _fe.delete_H1_TriangleElement # Register H1_TriangleElement in _fe: @@ -2311,14 +2680,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_TetrahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_TetrahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcDShape) def CalcHessian(self, ip, ddshape): r"""CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)""" return _fe.H1_TetrahedronElement_CalcHessian(self, ip, ddshape) + CalcHessian = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcHessian) __swig_destroy__ = _fe.delete_H1_TetrahedronElement # Register H1_TetrahedronElement in _fe: @@ -2340,6 +2712,7 @@ def CalcShape(self, *args): CalcShape(H1Pos_TriangleElement self, IntegrationPoint ip, Vector shape) """ return _fe.H1Pos_TriangleElement_CalcShape(self, *args) + CalcShape = _swig_new_instance_method(_fe.H1Pos_TriangleElement_CalcShape) def CalcDShape(self, *args): r""" @@ -2347,6 +2720,7 @@ def CalcDShape(self, *args): CalcDShape(H1Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape) """ return _fe.H1Pos_TriangleElement_CalcDShape(self, *args) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_TriangleElement_CalcDShape) __swig_destroy__ = _fe.delete_H1Pos_TriangleElement # Register H1Pos_TriangleElement in _fe: @@ -2368,6 +2742,7 @@ def CalcShape(self, *args): CalcShape(H1Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape) """ return _fe.H1Pos_TetrahedronElement_CalcShape(self, *args) + CalcShape = _swig_new_instance_method(_fe.H1Pos_TetrahedronElement_CalcShape) def CalcDShape(self, *args): r""" @@ -2375,6 +2750,7 @@ def CalcDShape(self, *args): CalcDShape(H1Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape) """ return _fe.H1Pos_TetrahedronElement_CalcDShape(self, *args) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_TetrahedronElement_CalcDShape) __swig_destroy__ = _fe.delete_H1Pos_TetrahedronElement # Register H1Pos_TetrahedronElement in _fe: @@ -2393,10 +2769,12 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_H1_WedgeElement # Register H1_WedgeElement in _fe: @@ -2457,10 +2835,12 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_H1Pos_WedgeElement # Register H1Pos_WedgeElement in _fe: @@ -2479,14 +2859,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)""" return _fe.L2_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2_SegmentElement # Register L2_SegmentElement in _fe: @@ -2505,14 +2888,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)""" return _fe.L2Pos_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_SegmentElement # Register L2Pos_SegmentElement in _fe: @@ -2531,18 +2917,22 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.L2_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_QuadrilateralElement_ProjectDelta) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.L2_QuadrilateralElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.L2_QuadrilateralElement_ProjectCurl) __swig_destroy__ = _fe.delete_L2_QuadrilateralElement # Register L2_QuadrilateralElement in _fe: @@ -2561,14 +2951,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.L2Pos_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_QuadrilateralElement # Register L2Pos_QuadrilateralElement in _fe: @@ -2587,14 +2980,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)""" return _fe.L2_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2_HexahedronElement # Register L2_HexahedronElement in _fe: @@ -2613,14 +3009,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)""" return _fe.L2Pos_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_HexahedronElement # Register L2Pos_HexahedronElement in _fe: @@ -2639,18 +3038,22 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_TriangleElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_TriangleElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_TriangleElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_TriangleElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)""" return _fe.L2_TriangleElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_TriangleElement_ProjectDelta) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.L2_TriangleElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.L2_TriangleElement_ProjectCurl) __swig_destroy__ = _fe.delete_L2_TriangleElement # Register L2_TriangleElement in _fe: @@ -2669,14 +3072,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_TriangleElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_TriangleElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_TriangleElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_TriangleElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)""" return _fe.L2Pos_TriangleElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_TriangleElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_TriangleElement # Register L2Pos_TriangleElement in _fe: @@ -2695,14 +3101,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_TetrahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_TetrahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_TetrahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_TetrahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)""" return _fe.L2_TetrahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_TetrahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2_TetrahedronElement # Register L2_TetrahedronElement in _fe: @@ -2721,14 +3130,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_TetrahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_TetrahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)""" return _fe.L2Pos_TetrahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_TetrahedronElement # Register L2Pos_TetrahedronElement in _fe: @@ -2747,10 +3159,12 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_L2_WedgeElement # Register L2_WedgeElement in _fe: @@ -2783,10 +3197,12 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_L2Pos_WedgeElement # Register L2Pos_WedgeElement in _fe: @@ -2808,26 +3224,32 @@ def CalcVShape(self, *args): CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_QuadrilateralElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_QuadrilateralElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_QuadrilateralElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_QuadrilateralElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_QuadrilateralElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_QuadrilateralElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_QuadrilateralElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_QuadrilateralElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -2838,14 +3260,17 @@ def Project(self, *args): Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_QuadrilateralElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_QuadrilateralElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.RT_QuadrilateralElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_QuadrilateralElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_QuadrilateralElement # Register RT_QuadrilateralElement in _fe: @@ -2867,26 +3292,32 @@ def CalcVShape(self, *args): CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_HexahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_HexahedronElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_HexahedronElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_HexahedronElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_HexahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_HexahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_HexahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_HexahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_HexahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_HexahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_HexahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_HexahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -2897,10 +3328,12 @@ def Project(self, *args): Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_HexahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_HexahedronElement_Project) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_HexahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_HexahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_HexahedronElement # Register RT_HexahedronElement in _fe: @@ -2922,26 +3355,32 @@ def CalcVShape(self, *args): CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_TriangleElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_TriangleElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_TriangleElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_TriangleElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TriangleElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_TriangleElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_TriangleElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_TriangleElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TriangleElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_TriangleElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_TriangleElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -2952,14 +3391,17 @@ def Project(self, *args): Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_TriangleElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_TriangleElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.RT_TriangleElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_TriangleElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_TriangleElement # Register RT_TriangleElement in _fe: @@ -2981,26 +3423,32 @@ def CalcVShape(self, *args): CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_TetrahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_TetrahedronElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_TetrahedronElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_TetrahedronElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TetrahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_TetrahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TetrahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_TetrahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_TetrahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3011,16 +3459,18 @@ def Project(self, *args): Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_TetrahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_TetrahedronElement_Project) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_TetrahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_TetrahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_TetrahedronElement # Register RT_TetrahedronElement in _fe: _fe.RT_TetrahedronElement_swigregister(RT_TetrahedronElement) -class ND_HexahedronElement(VectorFiniteElement): +class ND_HexahedronElement(VectorTensorFiniteElement): r"""Proxy of C++ mfem::ND_HexahedronElement class.""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -3036,26 +3486,32 @@ def CalcVShape(self, *args): CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_HexahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_HexahedronElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_HexahedronElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_HexahedronElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_HexahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_HexahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_HexahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_HexahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_HexahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_HexahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_HexahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3066,20 +3522,23 @@ def Project(self, *args): Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_HexahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_HexahedronElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_HexahedronElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.ND_HexahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_ND_HexahedronElement # Register ND_HexahedronElement in _fe: _fe.ND_HexahedronElement_swigregister(ND_HexahedronElement) -class ND_QuadrilateralElement(VectorFiniteElement): +class ND_QuadrilateralElement(VectorTensorFiniteElement): r"""Proxy of C++ mfem::ND_QuadrilateralElement class.""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -3095,26 +3554,32 @@ def CalcVShape(self, *args): CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_QuadrilateralElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_QuadrilateralElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_QuadrilateralElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_QuadrilateralElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_QuadrilateralElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_QuadrilateralElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_QuadrilateralElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_QuadrilateralElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_QuadrilateralElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3125,10 +3590,12 @@ def Project(self, *args): Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_QuadrilateralElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_QuadrilateralElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_QuadrilateralElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_QuadrilateralElement_ProjectGrad) __swig_destroy__ = _fe.delete_ND_QuadrilateralElement # Register ND_QuadrilateralElement in _fe: @@ -3150,26 +3617,32 @@ def CalcVShape(self, *args): CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_TetrahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_TetrahedronElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_TetrahedronElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_TetrahedronElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TetrahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_TetrahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TetrahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_TetrahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3180,14 +3653,17 @@ def Project(self, *args): Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_TetrahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_TetrahedronElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_TetrahedronElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.ND_TetrahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_ND_TetrahedronElement # Register ND_TetrahedronElement in _fe: @@ -3209,26 +3685,32 @@ def CalcVShape(self, *args): CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_TriangleElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_TriangleElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_TriangleElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_TriangleElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TriangleElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_TriangleElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_TriangleElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_TriangleElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TriangleElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_TriangleElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_TriangleElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_TriangleElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3239,10 +3721,12 @@ def Project(self, *args): Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_TriangleElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_TriangleElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_TriangleElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_TriangleElement_ProjectGrad) __swig_destroy__ = _fe.delete_ND_TriangleElement # Register ND_TriangleElement in _fe: @@ -3261,6 +3745,7 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.ND_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.ND_SegmentElement_CalcShape) def CalcVShape(self, *args): r""" @@ -3268,22 +3753,27 @@ def CalcVShape(self, *args): CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_SegmentElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_SegmentElement_CalcVShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_SegmentElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_SegmentElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_SegmentElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_SegmentElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_SegmentElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_SegmentElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_SegmentElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_SegmentElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3294,10 +3784,12 @@ def Project(self, *args): Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_SegmentElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_SegmentElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_SegmentElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_SegmentElement_ProjectGrad) __swig_destroy__ = _fe.delete_ND_SegmentElement # Register ND_SegmentElement in _fe: @@ -3315,38 +3807,47 @@ def __init__(self, *args, **kwargs): def Reset(self): r"""Reset(NURBSFiniteElement self)""" return _fe.NURBSFiniteElement_Reset(self) + Reset = _swig_new_instance_method(_fe.NURBSFiniteElement_Reset) def SetIJK(self, IJK): r"""SetIJK(NURBSFiniteElement self, int const * IJK)""" return _fe.NURBSFiniteElement_SetIJK(self, IJK) + SetIJK = _swig_new_instance_method(_fe.NURBSFiniteElement_SetIJK) def GetPatch(self): r"""GetPatch(NURBSFiniteElement self) -> int""" return _fe.NURBSFiniteElement_GetPatch(self) + GetPatch = _swig_new_instance_method(_fe.NURBSFiniteElement_GetPatch) def SetPatch(self, p): r"""SetPatch(NURBSFiniteElement self, int p)""" return _fe.NURBSFiniteElement_SetPatch(self, p) + SetPatch = _swig_new_instance_method(_fe.NURBSFiniteElement_SetPatch) def GetElement(self): r"""GetElement(NURBSFiniteElement self) -> int""" return _fe.NURBSFiniteElement_GetElement(self) + GetElement = _swig_new_instance_method(_fe.NURBSFiniteElement_GetElement) def SetElement(self, e): r"""SetElement(NURBSFiniteElement self, int e)""" return _fe.NURBSFiniteElement_SetElement(self, e) + SetElement = _swig_new_instance_method(_fe.NURBSFiniteElement_SetElement) def KnotVectors(self): r"""KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &""" return _fe.NURBSFiniteElement_KnotVectors(self) + KnotVectors = _swig_new_instance_method(_fe.NURBSFiniteElement_KnotVectors) def Weights(self): r"""Weights(NURBSFiniteElement self) -> Vector""" return _fe.NURBSFiniteElement_Weights(self) + Weights = _swig_new_instance_method(_fe.NURBSFiniteElement_Weights) def SetOrder(self): r"""SetOrder(NURBSFiniteElement self)""" return _fe.NURBSFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBSFiniteElement_SetOrder) __swig_destroy__ = _fe.delete_NURBSFiniteElement # Register NURBSFiniteElement in _fe: @@ -3365,14 +3866,22 @@ def __init__(self, p): def SetOrder(self): r"""SetOrder(NURBS1DFiniteElement self)""" return _fe.NURBS1DFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBS1DFiniteElement_SetOrder) def CalcShape(self, ip, shape): r"""CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.NURBS1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.NURBS1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcDShape) + + def CalcHessian(self, ip, hessian): + r"""CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)""" + return _fe.NURBS1DFiniteElement_CalcHessian(self, ip, hessian) + CalcHessian = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_NURBS1DFiniteElement # Register NURBS1DFiniteElement in _fe: @@ -3394,14 +3903,22 @@ def __init__(self, *args): def SetOrder(self): r"""SetOrder(NURBS2DFiniteElement self)""" return _fe.NURBS2DFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBS2DFiniteElement_SetOrder) def CalcShape(self, ip, shape): r"""CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.NURBS2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.NURBS2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcDShape) + + def CalcHessian(self, ip, hessian): + r"""CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)""" + return _fe.NURBS2DFiniteElement_CalcHessian(self, ip, hessian) + CalcHessian = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_NURBS2DFiniteElement # Register NURBS2DFiniteElement in _fe: @@ -3423,14 +3940,22 @@ def __init__(self, *args): def SetOrder(self): r"""SetOrder(NURBS3DFiniteElement self)""" return _fe.NURBS3DFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBS3DFiniteElement_SetOrder) def CalcShape(self, ip, shape): r"""CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.NURBS3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.NURBS3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcDShape) + + def CalcHessian(self, ip, hessian): + r"""CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)""" + return _fe.NURBS3DFiniteElement_CalcHessian(self, ip, hessian) + CalcHessian = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_NURBS3DFiniteElement # Register NURBS3DFiniteElement in _fe: diff --git a/mfem/_par/fe_coll.py b/mfem/_par/fe_coll.py index 5d573a09..e4f67e72 100644 --- a/mfem/_par/fe_coll.py +++ b/mfem/_par/fe_coll.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _fe_coll.SWIG_PyInstanceMethod_New +_swig_new_static_method = _fe_coll.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -70,6 +73,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.mem_manager import mfem._par.operators import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.densemat import mfem._par.geom @@ -86,6 +90,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform class FiniteElementCollection(object): @@ -100,40 +105,49 @@ def __init__(self, *args, **kwargs): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.FiniteElementCollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.FiniteElementCollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.FiniteElementCollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.FiniteElementCollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.FiniteElementCollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.FiniteElementCollection_DofOrderForOrientation) def Name(self): r"""Name(FiniteElementCollection self) -> char const *""" return _fe_coll.FiniteElementCollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.FiniteElementCollection_Name) def HasFaceDofs(self, GeomType): r"""HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.FiniteElementCollection_HasFaceDofs(self, GeomType) + HasFaceDofs = _swig_new_instance_method(_fe_coll.FiniteElementCollection_HasFaceDofs) def TraceFiniteElementForGeometry(self, GeomType): r"""TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.FiniteElementCollection_TraceFiniteElementForGeometry(self, GeomType) + TraceFiniteElementForGeometry = _swig_new_instance_method(_fe_coll.FiniteElementCollection_TraceFiniteElementForGeometry) def GetTraceCollection(self): r"""GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection""" return _fe_coll.FiniteElementCollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.FiniteElementCollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_FiniteElementCollection @staticmethod def New(name): r"""New(char const * name) -> FiniteElementCollection""" return _fe_coll.FiniteElementCollection_New(name) + New = _swig_new_static_method(_fe_coll.FiniteElementCollection_New) def SubDofOrder(self, Geom, SDim, Info, dofs): r"""SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)""" return _fe_coll.FiniteElementCollection_SubDofOrder(self, Geom, SDim, Info, dofs) + SubDofOrder = _swig_new_instance_method(_fe_coll.FiniteElementCollection_SubDofOrder) # Register FiniteElementCollection in _fe_coll: _fe_coll.FiniteElementCollection_swigregister(FiniteElementCollection) @@ -141,6 +155,7 @@ def SubDofOrder(self, Geom, SDim, Info, dofs): def FiniteElementCollection_New(name): r"""FiniteElementCollection_New(char const * name) -> FiniteElementCollection""" return _fe_coll.FiniteElementCollection_New(name) +FiniteElementCollection_New = _fe_coll.FiniteElementCollection_New class H1_FECollection(FiniteElementCollection): r"""Proxy of C++ mfem::H1_FECollection class.""" @@ -155,30 +170,37 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.H1_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.H1_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.H1_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.H1_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.H1_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.H1_FECollection_DofOrderForOrientation) def Name(self): r"""Name(H1_FECollection self) -> char const *""" return _fe_coll.H1_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.H1_FECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(H1_FECollection self) -> FiniteElementCollection""" return _fe_coll.H1_FECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.H1_FECollection_GetTraceCollection) def GetBasisType(self): r"""GetBasisType(H1_FECollection self) -> int""" return _fe_coll.H1_FECollection_GetBasisType(self) + GetBasisType = _swig_new_instance_method(_fe_coll.H1_FECollection_GetBasisType) def GetDofMap(self, GeomType): r"""GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *""" return _fe_coll.H1_FECollection_GetDofMap(self, GeomType) + GetDofMap = _swig_new_instance_method(_fe_coll.H1_FECollection_GetDofMap) __swig_destroy__ = _fe_coll.delete_H1_FECollection # Register H1_FECollection in _fe_coll: @@ -198,6 +220,20 @@ def __init__(self, p, dim=3): # Register H1Pos_FECollection in _fe_coll: _fe_coll.H1Pos_FECollection_swigregister(H1Pos_FECollection) +class H1Ser_FECollection(H1_FECollection): + r"""Proxy of C++ mfem::H1Ser_FECollection class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, p, dim=2): + r"""__init__(H1Ser_FECollection self, int const p, int const dim=2) -> H1Ser_FECollection""" + _fe_coll.H1Ser_FECollection_swiginit(self, _fe_coll.new_H1Ser_FECollection(p, dim)) + __swig_destroy__ = _fe_coll.delete_H1Ser_FECollection + +# Register H1Ser_FECollection in _fe_coll: +_fe_coll.H1Ser_FECollection_swigregister(H1Ser_FECollection) + class H1_Trace_FECollection(H1_FECollection): r"""Proxy of C++ mfem::H1_Trace_FECollection class.""" @@ -225,26 +261,32 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.L2_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.L2_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.L2_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.L2_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.L2_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.L2_FECollection_DofOrderForOrientation) def Name(self): r"""Name(L2_FECollection self) -> char const *""" return _fe_coll.L2_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.L2_FECollection_Name) def TraceFiniteElementForGeometry(self, GeomType): r"""TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.L2_FECollection_TraceFiniteElementForGeometry(self, GeomType) + TraceFiniteElementForGeometry = _swig_new_instance_method(_fe_coll.L2_FECollection_TraceFiniteElementForGeometry) def GetBasisType(self): r"""GetBasisType(L2_FECollection self) -> int""" return _fe_coll.L2_FECollection_GetBasisType(self) + GetBasisType = _swig_new_instance_method(_fe_coll.L2_FECollection_GetBasisType) __swig_destroy__ = _fe_coll.delete_L2_FECollection # Register L2_FECollection in _fe_coll: @@ -263,22 +305,27 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT_FECollection_DofOrderForOrientation) def Name(self): r"""Name(RT_FECollection self) -> char const *""" return _fe_coll.RT_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT_FECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(RT_FECollection self) -> FiniteElementCollection""" return _fe_coll.RT_FECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.RT_FECollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_RT_FECollection # Register RT_FECollection in _fe_coll: @@ -325,22 +372,27 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.ND_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.ND_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.ND_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.ND_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.ND_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.ND_FECollection_DofOrderForOrientation) def Name(self): r"""Name(ND_FECollection self) -> char const *""" return _fe_coll.ND_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.ND_FECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(ND_FECollection self) -> FiniteElementCollection""" return _fe_coll.ND_FECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.ND_FECollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_ND_FECollection # Register ND_FECollection in _fe_coll: @@ -375,34 +427,42 @@ def __init__(self, *args): def Reset(self): r"""Reset(NURBSFECollection self)""" return _fe_coll.NURBSFECollection_Reset(self) + Reset = _swig_new_instance_method(_fe_coll.NURBSFECollection_Reset) def GetOrder(self): r"""GetOrder(NURBSFECollection self) -> int""" return _fe_coll.NURBSFECollection_GetOrder(self) + GetOrder = _swig_new_instance_method(_fe_coll.NURBSFECollection_GetOrder) def SetOrder(self, Order): r"""SetOrder(NURBSFECollection self, int Order)""" return _fe_coll.NURBSFECollection_SetOrder(self, Order) + SetOrder = _swig_new_instance_method(_fe_coll.NURBSFECollection_SetOrder) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.NURBSFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.NURBSFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.NURBSFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.NURBSFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.NURBSFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.NURBSFECollection_DofOrderForOrientation) def Name(self): r"""Name(NURBSFECollection self) -> char const *""" return _fe_coll.NURBSFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.NURBSFECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection""" return _fe_coll.NURBSFECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.NURBSFECollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_NURBSFECollection # Register NURBSFECollection in _fe_coll: @@ -421,18 +481,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearFECollection self) -> char const *""" return _fe_coll.LinearFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearFECollection # Register LinearFECollection in _fe_coll: @@ -451,18 +515,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticFECollection self) -> char const *""" return _fe_coll.QuadraticFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticFECollection # Register QuadraticFECollection in _fe_coll: @@ -481,18 +549,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticPosFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticPosFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticPosFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticPosFECollection self) -> char const *""" return _fe_coll.QuadraticPosFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticPosFECollection # Register QuadraticPosFECollection in _fe_coll: @@ -511,18 +583,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.CubicFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.CubicFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.CubicFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.CubicFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.CubicFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.CubicFECollection_DofOrderForOrientation) def Name(self): r"""Name(CubicFECollection self) -> char const *""" return _fe_coll.CubicFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.CubicFECollection_Name) __swig_destroy__ = _fe_coll.delete_CubicFECollection # Register CubicFECollection in _fe_coll: @@ -541,18 +617,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.CrouzeixRaviartFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.CrouzeixRaviartFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.CrouzeixRaviartFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_DofOrderForOrientation) def Name(self): r"""Name(CrouzeixRaviartFECollection self) -> char const *""" return _fe_coll.CrouzeixRaviartFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_Name) __swig_destroy__ = _fe_coll.delete_CrouzeixRaviartFECollection # Register CrouzeixRaviartFECollection in _fe_coll: @@ -571,18 +651,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearNonConf3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearNonConf3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearNonConf3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearNonConf3DFECollection self) -> char const *""" return _fe_coll.LinearNonConf3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearNonConf3DFECollection # Register LinearNonConf3DFECollection in _fe_coll: @@ -601,18 +685,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT0_2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT0_2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT0_2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT0_2DFECollection self) -> char const *""" return _fe_coll.RT0_2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT0_2DFECollection # Register RT0_2DFECollection in _fe_coll: @@ -631,18 +719,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT1_2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT1_2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT1_2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT1_2DFECollection self) -> char const *""" return _fe_coll.RT1_2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT1_2DFECollection # Register RT1_2DFECollection in _fe_coll: @@ -661,18 +753,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT2_2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT2_2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT2_2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT2_2DFECollection self) -> char const *""" return _fe_coll.RT2_2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT2_2DFECollection # Register RT2_2DFECollection in _fe_coll: @@ -691,18 +787,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.Const2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.Const2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.Const2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.Const2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.Const2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.Const2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(Const2DFECollection self) -> char const *""" return _fe_coll.Const2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.Const2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_Const2DFECollection # Register Const2DFECollection in _fe_coll: @@ -721,18 +821,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearDiscont2DFECollection self) -> char const *""" return _fe_coll.LinearDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearDiscont2DFECollection # Register LinearDiscont2DFECollection in _fe_coll: @@ -751,18 +855,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.GaussLinearDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.GaussLinearDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.GaussLinearDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(GaussLinearDiscont2DFECollection self) -> char const *""" return _fe_coll.GaussLinearDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_GaussLinearDiscont2DFECollection # Register GaussLinearDiscont2DFECollection in _fe_coll: @@ -781,18 +889,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.P1OnQuadFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.P1OnQuadFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.P1OnQuadFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_DofOrderForOrientation) def Name(self): r"""Name(P1OnQuadFECollection self) -> char const *""" return _fe_coll.P1OnQuadFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_Name) __swig_destroy__ = _fe_coll.delete_P1OnQuadFECollection # Register P1OnQuadFECollection in _fe_coll: @@ -811,18 +923,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticDiscont2DFECollection self) -> char const *""" return _fe_coll.QuadraticDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticDiscont2DFECollection # Register QuadraticDiscont2DFECollection in _fe_coll: @@ -841,18 +957,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticPosDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticPosDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticPosDiscont2DFECollection self) -> char const *""" return _fe_coll.QuadraticPosDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticPosDiscont2DFECollection # Register QuadraticPosDiscont2DFECollection in _fe_coll: @@ -871,18 +991,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.GaussQuadraticDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(GaussQuadraticDiscont2DFECollection self) -> char const *""" return _fe_coll.GaussQuadraticDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_GaussQuadraticDiscont2DFECollection # Register GaussQuadraticDiscont2DFECollection in _fe_coll: @@ -901,18 +1025,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.CubicDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.CubicDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.CubicDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(CubicDiscont2DFECollection self) -> char const *""" return _fe_coll.CubicDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_CubicDiscont2DFECollection # Register CubicDiscont2DFECollection in _fe_coll: @@ -931,18 +1059,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.Const3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.Const3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.Const3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.Const3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.Const3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.Const3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(Const3DFECollection self) -> char const *""" return _fe_coll.Const3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.Const3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_Const3DFECollection # Register Const3DFECollection in _fe_coll: @@ -961,18 +1093,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearDiscont3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearDiscont3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearDiscont3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearDiscont3DFECollection self) -> char const *""" return _fe_coll.LinearDiscont3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearDiscont3DFECollection # Register LinearDiscont3DFECollection in _fe_coll: @@ -991,18 +1127,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticDiscont3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticDiscont3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticDiscont3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticDiscont3DFECollection self) -> char const *""" return _fe_coll.QuadraticDiscont3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticDiscont3DFECollection # Register QuadraticDiscont3DFECollection in _fe_coll: @@ -1021,18 +1161,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RefinedLinearFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RefinedLinearFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RefinedLinearFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_DofOrderForOrientation) def Name(self): r"""Name(RefinedLinearFECollection self) -> char const *""" return _fe_coll.RefinedLinearFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_Name) __swig_destroy__ = _fe_coll.delete_RefinedLinearFECollection # Register RefinedLinearFECollection in _fe_coll: @@ -1051,18 +1195,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.ND1_3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.ND1_3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.ND1_3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(ND1_3DFECollection self) -> char const *""" return _fe_coll.ND1_3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_ND1_3DFECollection # Register ND1_3DFECollection in _fe_coll: @@ -1081,18 +1229,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT0_3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT0_3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT0_3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT0_3DFECollection self) -> char const *""" return _fe_coll.RT0_3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT0_3DFECollection # Register RT0_3DFECollection in _fe_coll: @@ -1111,18 +1263,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT1_3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT1_3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT1_3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT1_3DFECollection self) -> char const *""" return _fe_coll.RT1_3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT1_3DFECollection # Register RT1_3DFECollection in _fe_coll: @@ -1141,18 +1297,22 @@ def __init__(self, fe_name): def FiniteElementForGeometry(self, _GeomType): r"""FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement""" return _fe_coll.Local_FECollection_FiniteElementForGeometry(self, _GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.Local_FECollection_FiniteElementForGeometry) def DofForGeometry(self, _GeomType): r"""DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int""" return _fe_coll.Local_FECollection_DofForGeometry(self, _GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.Local_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.Local_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.Local_FECollection_DofOrderForOrientation) def Name(self): r"""Name(Local_FECollection self) -> char const *""" return _fe_coll.Local_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.Local_FECollection_Name) __swig_destroy__ = _fe_coll.delete_Local_FECollection # Register Local_FECollection in _fe_coll: diff --git a/mfem/_par/fe_coll_wrap.cxx b/mfem/_par/fe_coll_wrap.cxx index 69d79ff8..ee34e984 100644 --- a/mfem/_par/fe_coll_wrap.cxx +++ b/mfem/_par/fe_coll_wrap.cxx @@ -3064,154 +3064,158 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[5] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[6] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[7] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[8] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[12] -#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[13] -#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[14] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[15] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[16] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[17] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[18] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[21] -#define SWIGTYPE_p_mfem__CubicFECollection swig_types[22] -#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[23] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[24] -#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[25] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[26] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[27] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[28] -#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[29] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[30] -#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[31] -#define SWIGTYPE_p_mfem__GridFunction swig_types[32] -#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[33] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[34] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[35] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[36] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[37] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[38] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[39] -#define SWIGTYPE_p_mfem__H1_FECollection swig_types[40] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[41] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[42] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[43] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[44] -#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[45] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[46] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[47] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[48] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[49] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[50] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[51] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[52] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[53] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[54] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[55] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[56] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[57] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[58] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[59] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[60] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[61] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[62] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[63] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[64] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[65] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[66] -#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[67] -#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[68] -#define SWIGTYPE_p_mfem__LinearFECollection swig_types[69] -#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[70] -#define SWIGTYPE_p_mfem__Local_FECollection swig_types[71] -#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[72] -#define SWIGTYPE_p_mfem__ND_FECollection swig_types[73] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[74] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[75] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[76] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[77] -#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[78] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[79] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[80] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[81] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[82] -#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[83] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[89] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[96] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[108] -#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[109] -#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[110] -#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[111] -#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[112] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[114] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[117] -#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[118] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[119] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[122] -#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[123] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[124] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[125] -#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[126] -#define SWIGTYPE_p_mfem__RT_FECollection swig_types[127] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[128] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[129] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[130] -#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[131] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[132] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[133] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[134] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[135] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[136] -#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[137] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[138] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[139] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[140] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[141] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[142] -#define SWIGTYPE_p_pri_t swig_types[143] -#define SWIGTYPE_p_quad_t swig_types[144] -#define SWIGTYPE_p_seg_t swig_types[145] -#define SWIGTYPE_p_tet_t swig_types[146] -#define SWIGTYPE_p_tri_t swig_types[147] -static swig_type_info *swig_types[149]; -static swig_module_info swig_module = {swig_types, 148, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[7] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[8] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[9] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[13] +#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[14] +#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[15] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[16] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[17] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[18] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[19] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[22] +#define SWIGTYPE_p_mfem__CubicFECollection swig_types[23] +#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[24] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[25] +#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[26] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[27] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[28] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[29] +#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[30] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[31] +#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[32] +#define SWIGTYPE_p_mfem__GridFunction swig_types[33] +#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[34] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[35] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[36] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[37] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[38] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[39] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[40] +#define SWIGTYPE_p_mfem__H1Ser_FECollection swig_types[41] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[42] +#define SWIGTYPE_p_mfem__H1_FECollection swig_types[43] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[44] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[45] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[46] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[47] +#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[48] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[49] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[50] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[51] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[52] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[53] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[54] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[55] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[56] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[57] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[58] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[59] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[60] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[61] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[63] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[64] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[65] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[66] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[67] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[70] +#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[71] +#define SWIGTYPE_p_mfem__LinearFECollection swig_types[72] +#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[73] +#define SWIGTYPE_p_mfem__Local_FECollection swig_types[74] +#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[75] +#define SWIGTYPE_p_mfem__ND_FECollection swig_types[76] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[77] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[78] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[79] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[80] +#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[81] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[82] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[83] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[84] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[85] +#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[86] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[92] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[99] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[106] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[110] +#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[111] +#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[112] +#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[113] +#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[114] +#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[115] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[117] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[118] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[120] +#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[121] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[125] +#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[126] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[127] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[128] +#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[129] +#define SWIGTYPE_p_mfem__RT_FECollection swig_types[130] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[131] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[132] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[133] +#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[134] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[135] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[136] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[137] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[138] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[139] +#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[140] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[141] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[142] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[143] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[144] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[145] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[146] +#define SWIGTYPE_p_pri_t swig_types[147] +#define SWIGTYPE_p_quad_t swig_types[148] +#define SWIGTYPE_p_seg_t swig_types[149] +#define SWIGTYPE_p_tet_t swig_types[150] +#define SWIGTYPE_p_tri_t swig_types[151] +static swig_type_info *swig_types[153]; +static swig_module_info swig_module = {swig_types, 152, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4671,6 +4675,163 @@ SWIGINTERN PyObject *H1Pos_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + mfem::H1Ser_FECollection *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::H1Ser_FECollection *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1Ser_FECollection", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_H1Ser_FECollection__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_H1Ser_FECollection__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1Ser_FECollection'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::H1Ser_FECollection::H1Ser_FECollection(int const,int const)\n" + " mfem::H1Ser_FECollection::H1Ser_FECollection(int const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Ser_FECollection *arg1 = (mfem::H1Ser_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Ser_FECollection" "', argument " "1"" of type '" "mfem::H1Ser_FECollection *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_FECollection * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *H1Ser_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1Ser_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; @@ -12746,6 +12907,7 @@ SWIGINTERN PyObject *Local_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "FiniteElementCollection_FiniteElementForGeometry", _wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementCollection_FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "FiniteElementCollection_DofForGeometry", _wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS, "FiniteElementCollection_DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, { "FiniteElementCollection_DofOrderForOrientation", _wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS, "FiniteElementCollection_DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, @@ -12772,6 +12934,10 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, + { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, + { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, @@ -13032,15 +13198,300 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "FiniteElementCollection_FiniteElementForGeometry", _wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_DofForGeometry", _wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS, "DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_DofOrderForOrientation", _wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "FiniteElementCollection_Name", _wrap_FiniteElementCollection_Name, METH_O, "Name(FiniteElementCollection self) -> char const *"}, + { "FiniteElementCollection_HasFaceDofs", _wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS, "HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_TraceFiniteElementForGeometry", _wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_GetTraceCollection", _wrap_FiniteElementCollection_GetTraceCollection, METH_O, "GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection"}, + { "delete_FiniteElementCollection", _wrap_delete_FiniteElementCollection, METH_O, "delete_FiniteElementCollection(FiniteElementCollection self)"}, + { "FiniteElementCollection_New", _wrap_FiniteElementCollection_New, METH_O, "New(char const * name) -> FiniteElementCollection"}, + { "FiniteElementCollection_SubDofOrder", _wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS, "SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, + { "FiniteElementCollection_swigregister", FiniteElementCollection_swigregister, METH_O, NULL}, + { "new_H1_FECollection", _wrap_new_H1_FECollection, METH_VARARGS, "H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto)"}, + { "H1_FECollection_FiniteElementForGeometry", _wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "H1_FECollection_DofForGeometry", _wrap_H1_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "H1_FECollection_DofOrderForOrientation", _wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "H1_FECollection_Name", _wrap_H1_FECollection_Name, METH_O, "Name(H1_FECollection self) -> char const *"}, + { "H1_FECollection_GetTraceCollection", _wrap_H1_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(H1_FECollection self) -> FiniteElementCollection"}, + { "H1_FECollection_GetBasisType", _wrap_H1_FECollection_GetBasisType, METH_O, "GetBasisType(H1_FECollection self) -> int"}, + { "H1_FECollection_GetDofMap", _wrap_H1_FECollection_GetDofMap, METH_VARARGS, "GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, + { "delete_H1_FECollection", _wrap_delete_H1_FECollection, METH_O, "delete_H1_FECollection(H1_FECollection self)"}, + { "H1_FECollection_swigregister", H1_FECollection_swigregister, METH_O, NULL}, + { "H1_FECollection_swiginit", H1_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_FECollection", _wrap_new_H1Pos_FECollection, METH_VARARGS, "H1Pos_FECollection(int const p, int const dim=3)"}, + { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, + { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, + { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, + { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, + { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, + { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, + { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, + { "H1_Trace_FECollection_swiginit", H1_Trace_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_L2_FECollection", _wrap_new_L2_FECollection, METH_VARARGS, "L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE)"}, + { "L2_FECollection_FiniteElementForGeometry", _wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_DofForGeometry", _wrap_L2_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "L2_FECollection_DofOrderForOrientation", _wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "L2_FECollection_Name", _wrap_L2_FECollection_Name, METH_O, "Name(L2_FECollection self) -> char const *"}, + { "L2_FECollection_TraceFiniteElementForGeometry", _wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_GetBasisType", _wrap_L2_FECollection_GetBasisType, METH_O, "GetBasisType(L2_FECollection self) -> int"}, + { "delete_L2_FECollection", _wrap_delete_L2_FECollection, METH_O, "delete_L2_FECollection(L2_FECollection self)"}, + { "L2_FECollection_swigregister", L2_FECollection_swigregister, METH_O, NULL}, + { "L2_FECollection_swiginit", L2_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, "RT_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "RT_FECollection_FiniteElementForGeometry", _wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT_FECollection_DofForGeometry", _wrap_RT_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT_FECollection_DofOrderForOrientation", _wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT_FECollection_Name", _wrap_RT_FECollection_Name, METH_O, "Name(RT_FECollection self) -> char const *"}, + { "RT_FECollection_GetTraceCollection", _wrap_RT_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(RT_FECollection self) -> FiniteElementCollection"}, + { "delete_RT_FECollection", _wrap_delete_RT_FECollection, METH_O, "delete_RT_FECollection(RT_FECollection self)"}, + { "RT_FECollection_swigregister", RT_FECollection_swigregister, METH_O, NULL}, + { "RT_FECollection_swiginit", RT_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT_Trace_FECollection", _wrap_new_RT_Trace_FECollection, METH_VARARGS, "RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre)"}, + { "delete_RT_Trace_FECollection", _wrap_delete_RT_Trace_FECollection, METH_O, "delete_RT_Trace_FECollection(RT_Trace_FECollection self)"}, + { "RT_Trace_FECollection_swigregister", RT_Trace_FECollection_swigregister, METH_O, NULL}, + { "RT_Trace_FECollection_swiginit", RT_Trace_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_DG_Interface_FECollection", _wrap_new_DG_Interface_FECollection, METH_VARARGS, "DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre)"}, + { "delete_DG_Interface_FECollection", _wrap_delete_DG_Interface_FECollection, METH_O, "delete_DG_Interface_FECollection(DG_Interface_FECollection self)"}, + { "DG_Interface_FECollection_swigregister", DG_Interface_FECollection_swigregister, METH_O, NULL}, + { "DG_Interface_FECollection_swiginit", DG_Interface_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_ND_FECollection", _wrap_new_ND_FECollection, METH_VARARGS, "ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "ND_FECollection_FiniteElementForGeometry", _wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND_FECollection_DofForGeometry", _wrap_ND_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND_FECollection_DofOrderForOrientation", _wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND_FECollection_Name", _wrap_ND_FECollection_Name, METH_O, "Name(ND_FECollection self) -> char const *"}, + { "ND_FECollection_GetTraceCollection", _wrap_ND_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(ND_FECollection self) -> FiniteElementCollection"}, + { "delete_ND_FECollection", _wrap_delete_ND_FECollection, METH_O, "delete_ND_FECollection(ND_FECollection self)"}, + { "ND_FECollection_swigregister", ND_FECollection_swigregister, METH_O, NULL}, + { "ND_FECollection_swiginit", ND_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_ND_Trace_FECollection", _wrap_new_ND_Trace_FECollection, METH_VARARGS, "ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "delete_ND_Trace_FECollection", _wrap_delete_ND_Trace_FECollection, METH_O, "delete_ND_Trace_FECollection(ND_Trace_FECollection self)"}, + { "ND_Trace_FECollection_swigregister", ND_Trace_FECollection_swigregister, METH_O, NULL}, + { "ND_Trace_FECollection_swiginit", ND_Trace_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_NURBSFECollection", _wrap_new_NURBSFECollection, METH_VARARGS, "NURBSFECollection(int Order=VariableOrder)"}, + { "NURBSFECollection_Reset", _wrap_NURBSFECollection_Reset, METH_O, "Reset(NURBSFECollection self)"}, + { "NURBSFECollection_GetOrder", _wrap_NURBSFECollection_GetOrder, METH_O, "GetOrder(NURBSFECollection self) -> int"}, + { "NURBSFECollection_SetOrder", _wrap_NURBSFECollection_SetOrder, METH_VARARGS, "SetOrder(NURBSFECollection self, int Order)"}, + { "NURBSFECollection_FiniteElementForGeometry", _wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "NURBSFECollection_DofForGeometry", _wrap_NURBSFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "NURBSFECollection_DofOrderForOrientation", _wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "NURBSFECollection_Name", _wrap_NURBSFECollection_Name, METH_O, "Name(NURBSFECollection self) -> char const *"}, + { "NURBSFECollection_GetTraceCollection", _wrap_NURBSFECollection_GetTraceCollection, METH_O, "GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection"}, + { "delete_NURBSFECollection", _wrap_delete_NURBSFECollection, METH_O, "delete_NURBSFECollection(NURBSFECollection self)"}, + { "NURBSFECollection_swigregister", NURBSFECollection_swigregister, METH_O, NULL}, + { "NURBSFECollection_swiginit", NURBSFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearFECollection", _wrap_new_LinearFECollection, METH_NOARGS, "new_LinearFECollection() -> LinearFECollection"}, + { "LinearFECollection_FiniteElementForGeometry", _wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearFECollection_DofForGeometry", _wrap_LinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearFECollection_DofOrderForOrientation", _wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearFECollection_Name", _wrap_LinearFECollection_Name, METH_O, "Name(LinearFECollection self) -> char const *"}, + { "delete_LinearFECollection", _wrap_delete_LinearFECollection, METH_O, "delete_LinearFECollection(LinearFECollection self)"}, + { "LinearFECollection_swigregister", LinearFECollection_swigregister, METH_O, NULL}, + { "LinearFECollection_swiginit", LinearFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticFECollection", _wrap_new_QuadraticFECollection, METH_NOARGS, "new_QuadraticFECollection() -> QuadraticFECollection"}, + { "QuadraticFECollection_FiniteElementForGeometry", _wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticFECollection_DofForGeometry", _wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticFECollection_DofOrderForOrientation", _wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticFECollection_Name", _wrap_QuadraticFECollection_Name, METH_O, "Name(QuadraticFECollection self) -> char const *"}, + { "delete_QuadraticFECollection", _wrap_delete_QuadraticFECollection, METH_O, "delete_QuadraticFECollection(QuadraticFECollection self)"}, + { "QuadraticFECollection_swigregister", QuadraticFECollection_swigregister, METH_O, NULL}, + { "QuadraticFECollection_swiginit", QuadraticFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticPosFECollection", _wrap_new_QuadraticPosFECollection, METH_NOARGS, "new_QuadraticPosFECollection() -> QuadraticPosFECollection"}, + { "QuadraticPosFECollection_FiniteElementForGeometry", _wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosFECollection_DofForGeometry", _wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosFECollection_DofOrderForOrientation", _wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosFECollection_Name", _wrap_QuadraticPosFECollection_Name, METH_O, "Name(QuadraticPosFECollection self) -> char const *"}, + { "delete_QuadraticPosFECollection", _wrap_delete_QuadraticPosFECollection, METH_O, "delete_QuadraticPosFECollection(QuadraticPosFECollection self)"}, + { "QuadraticPosFECollection_swigregister", QuadraticPosFECollection_swigregister, METH_O, NULL}, + { "QuadraticPosFECollection_swiginit", QuadraticPosFECollection_swiginit, METH_VARARGS, NULL}, + { "new_CubicFECollection", _wrap_new_CubicFECollection, METH_NOARGS, "new_CubicFECollection() -> CubicFECollection"}, + { "CubicFECollection_FiniteElementForGeometry", _wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicFECollection_DofForGeometry", _wrap_CubicFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicFECollection_DofOrderForOrientation", _wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicFECollection_Name", _wrap_CubicFECollection_Name, METH_O, "Name(CubicFECollection self) -> char const *"}, + { "delete_CubicFECollection", _wrap_delete_CubicFECollection, METH_O, "delete_CubicFECollection(CubicFECollection self)"}, + { "CubicFECollection_swigregister", CubicFECollection_swigregister, METH_O, NULL}, + { "CubicFECollection_swiginit", CubicFECollection_swiginit, METH_VARARGS, NULL}, + { "new_CrouzeixRaviartFECollection", _wrap_new_CrouzeixRaviartFECollection, METH_NOARGS, "new_CrouzeixRaviartFECollection() -> CrouzeixRaviartFECollection"}, + { "CrouzeixRaviartFECollection_FiniteElementForGeometry", _wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CrouzeixRaviartFECollection_DofForGeometry", _wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CrouzeixRaviartFECollection_DofOrderForOrientation", _wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CrouzeixRaviartFECollection_Name", _wrap_CrouzeixRaviartFECollection_Name, METH_O, "Name(CrouzeixRaviartFECollection self) -> char const *"}, + { "delete_CrouzeixRaviartFECollection", _wrap_delete_CrouzeixRaviartFECollection, METH_O, "delete_CrouzeixRaviartFECollection(CrouzeixRaviartFECollection self)"}, + { "CrouzeixRaviartFECollection_swigregister", CrouzeixRaviartFECollection_swigregister, METH_O, NULL}, + { "CrouzeixRaviartFECollection_swiginit", CrouzeixRaviartFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearNonConf3DFECollection", _wrap_new_LinearNonConf3DFECollection, METH_NOARGS, "new_LinearNonConf3DFECollection() -> LinearNonConf3DFECollection"}, + { "LinearNonConf3DFECollection_FiniteElementForGeometry", _wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearNonConf3DFECollection_DofForGeometry", _wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearNonConf3DFECollection_DofOrderForOrientation", _wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearNonConf3DFECollection_Name", _wrap_LinearNonConf3DFECollection_Name, METH_O, "Name(LinearNonConf3DFECollection self) -> char const *"}, + { "delete_LinearNonConf3DFECollection", _wrap_delete_LinearNonConf3DFECollection, METH_O, "delete_LinearNonConf3DFECollection(LinearNonConf3DFECollection self)"}, + { "LinearNonConf3DFECollection_swigregister", LinearNonConf3DFECollection_swigregister, METH_O, NULL}, + { "LinearNonConf3DFECollection_swiginit", LinearNonConf3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT0_2DFECollection", _wrap_new_RT0_2DFECollection, METH_NOARGS, "new_RT0_2DFECollection() -> RT0_2DFECollection"}, + { "RT0_2DFECollection_FiniteElementForGeometry", _wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_2DFECollection_DofForGeometry", _wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_2DFECollection_DofOrderForOrientation", _wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_2DFECollection_Name", _wrap_RT0_2DFECollection_Name, METH_O, "Name(RT0_2DFECollection self) -> char const *"}, + { "delete_RT0_2DFECollection", _wrap_delete_RT0_2DFECollection, METH_O, "delete_RT0_2DFECollection(RT0_2DFECollection self)"}, + { "RT0_2DFECollection_swigregister", RT0_2DFECollection_swigregister, METH_O, NULL}, + { "RT0_2DFECollection_swiginit", RT0_2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT1_2DFECollection", _wrap_new_RT1_2DFECollection, METH_NOARGS, "new_RT1_2DFECollection() -> RT1_2DFECollection"}, + { "RT1_2DFECollection_FiniteElementForGeometry", _wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_2DFECollection_DofForGeometry", _wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_2DFECollection_DofOrderForOrientation", _wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_2DFECollection_Name", _wrap_RT1_2DFECollection_Name, METH_O, "Name(RT1_2DFECollection self) -> char const *"}, + { "delete_RT1_2DFECollection", _wrap_delete_RT1_2DFECollection, METH_O, "delete_RT1_2DFECollection(RT1_2DFECollection self)"}, + { "RT1_2DFECollection_swigregister", RT1_2DFECollection_swigregister, METH_O, NULL}, + { "RT1_2DFECollection_swiginit", RT1_2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT2_2DFECollection", _wrap_new_RT2_2DFECollection, METH_NOARGS, "new_RT2_2DFECollection() -> RT2_2DFECollection"}, + { "RT2_2DFECollection_FiniteElementForGeometry", _wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT2_2DFECollection_DofForGeometry", _wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT2_2DFECollection_DofOrderForOrientation", _wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT2_2DFECollection_Name", _wrap_RT2_2DFECollection_Name, METH_O, "Name(RT2_2DFECollection self) -> char const *"}, + { "delete_RT2_2DFECollection", _wrap_delete_RT2_2DFECollection, METH_O, "delete_RT2_2DFECollection(RT2_2DFECollection self)"}, + { "RT2_2DFECollection_swigregister", RT2_2DFECollection_swigregister, METH_O, NULL}, + { "RT2_2DFECollection_swiginit", RT2_2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_Const2DFECollection", _wrap_new_Const2DFECollection, METH_NOARGS, "new_Const2DFECollection() -> Const2DFECollection"}, + { "Const2DFECollection_FiniteElementForGeometry", _wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const2DFECollection_DofForGeometry", _wrap_Const2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const2DFECollection_DofOrderForOrientation", _wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const2DFECollection_Name", _wrap_Const2DFECollection_Name, METH_O, "Name(Const2DFECollection self) -> char const *"}, + { "delete_Const2DFECollection", _wrap_delete_Const2DFECollection, METH_O, "delete_Const2DFECollection(Const2DFECollection self)"}, + { "Const2DFECollection_swigregister", Const2DFECollection_swigregister, METH_O, NULL}, + { "Const2DFECollection_swiginit", Const2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearDiscont2DFECollection", _wrap_new_LinearDiscont2DFECollection, METH_NOARGS, "new_LinearDiscont2DFECollection() -> LinearDiscont2DFECollection"}, + { "LinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont2DFECollection_DofForGeometry", _wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont2DFECollection_DofOrderForOrientation", _wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont2DFECollection_Name", _wrap_LinearDiscont2DFECollection_Name, METH_O, "Name(LinearDiscont2DFECollection self) -> char const *"}, + { "delete_LinearDiscont2DFECollection", _wrap_delete_LinearDiscont2DFECollection, METH_O, "delete_LinearDiscont2DFECollection(LinearDiscont2DFECollection self)"}, + { "LinearDiscont2DFECollection_swigregister", LinearDiscont2DFECollection_swigregister, METH_O, NULL}, + { "LinearDiscont2DFECollection_swiginit", LinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_GaussLinearDiscont2DFECollection", _wrap_new_GaussLinearDiscont2DFECollection, METH_NOARGS, "new_GaussLinearDiscont2DFECollection() -> GaussLinearDiscont2DFECollection"}, + { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussLinearDiscont2DFECollection_DofForGeometry", _wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussLinearDiscont2DFECollection_Name", _wrap_GaussLinearDiscont2DFECollection_Name, METH_O, "Name(GaussLinearDiscont2DFECollection self) -> char const *"}, + { "delete_GaussLinearDiscont2DFECollection", _wrap_delete_GaussLinearDiscont2DFECollection, METH_O, "delete_GaussLinearDiscont2DFECollection(GaussLinearDiscont2DFECollection self)"}, + { "GaussLinearDiscont2DFECollection_swigregister", GaussLinearDiscont2DFECollection_swigregister, METH_O, NULL}, + { "GaussLinearDiscont2DFECollection_swiginit", GaussLinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_P1OnQuadFECollection", _wrap_new_P1OnQuadFECollection, METH_NOARGS, "new_P1OnQuadFECollection() -> P1OnQuadFECollection"}, + { "P1OnQuadFECollection_FiniteElementForGeometry", _wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "P1OnQuadFECollection_DofForGeometry", _wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "P1OnQuadFECollection_DofOrderForOrientation", _wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "P1OnQuadFECollection_Name", _wrap_P1OnQuadFECollection_Name, METH_O, "Name(P1OnQuadFECollection self) -> char const *"}, + { "delete_P1OnQuadFECollection", _wrap_delete_P1OnQuadFECollection, METH_O, "delete_P1OnQuadFECollection(P1OnQuadFECollection self)"}, + { "P1OnQuadFECollection_swigregister", P1OnQuadFECollection_swigregister, METH_O, NULL}, + { "P1OnQuadFECollection_swiginit", P1OnQuadFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticDiscont2DFECollection", _wrap_new_QuadraticDiscont2DFECollection, METH_NOARGS, "new_QuadraticDiscont2DFECollection() -> QuadraticDiscont2DFECollection"}, + { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont2DFECollection_DofForGeometry", _wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont2DFECollection_Name", _wrap_QuadraticDiscont2DFECollection_Name, METH_O, "Name(QuadraticDiscont2DFECollection self) -> char const *"}, + { "delete_QuadraticDiscont2DFECollection", _wrap_delete_QuadraticDiscont2DFECollection, METH_O, "delete_QuadraticDiscont2DFECollection(QuadraticDiscont2DFECollection self)"}, + { "QuadraticDiscont2DFECollection_swigregister", QuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, + { "QuadraticDiscont2DFECollection_swiginit", QuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticPosDiscont2DFECollection", _wrap_new_QuadraticPosDiscont2DFECollection, METH_NOARGS, "new_QuadraticPosDiscont2DFECollection() -> QuadraticPosDiscont2DFECollection"}, + { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosDiscont2DFECollection_DofForGeometry", _wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosDiscont2DFECollection_Name", _wrap_QuadraticPosDiscont2DFECollection_Name, METH_O, "Name(QuadraticPosDiscont2DFECollection self) -> char const *"}, + { "delete_QuadraticPosDiscont2DFECollection", _wrap_delete_QuadraticPosDiscont2DFECollection, METH_O, "delete_QuadraticPosDiscont2DFECollection(QuadraticPosDiscont2DFECollection self)"}, + { "QuadraticPosDiscont2DFECollection_swigregister", QuadraticPosDiscont2DFECollection_swigregister, METH_O, NULL}, + { "QuadraticPosDiscont2DFECollection_swiginit", QuadraticPosDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_GaussQuadraticDiscont2DFECollection", _wrap_new_GaussQuadraticDiscont2DFECollection, METH_NOARGS, "new_GaussQuadraticDiscont2DFECollection() -> GaussQuadraticDiscont2DFECollection"}, + { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussQuadraticDiscont2DFECollection_DofForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussQuadraticDiscont2DFECollection_Name", _wrap_GaussQuadraticDiscont2DFECollection_Name, METH_O, "Name(GaussQuadraticDiscont2DFECollection self) -> char const *"}, + { "delete_GaussQuadraticDiscont2DFECollection", _wrap_delete_GaussQuadraticDiscont2DFECollection, METH_O, "delete_GaussQuadraticDiscont2DFECollection(GaussQuadraticDiscont2DFECollection self)"}, + { "GaussQuadraticDiscont2DFECollection_swigregister", GaussQuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, + { "GaussQuadraticDiscont2DFECollection_swiginit", GaussQuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_CubicDiscont2DFECollection", _wrap_new_CubicDiscont2DFECollection, METH_NOARGS, "new_CubicDiscont2DFECollection() -> CubicDiscont2DFECollection"}, + { "CubicDiscont2DFECollection_FiniteElementForGeometry", _wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicDiscont2DFECollection_DofForGeometry", _wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicDiscont2DFECollection_DofOrderForOrientation", _wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicDiscont2DFECollection_Name", _wrap_CubicDiscont2DFECollection_Name, METH_O, "Name(CubicDiscont2DFECollection self) -> char const *"}, + { "delete_CubicDiscont2DFECollection", _wrap_delete_CubicDiscont2DFECollection, METH_O, "delete_CubicDiscont2DFECollection(CubicDiscont2DFECollection self)"}, + { "CubicDiscont2DFECollection_swigregister", CubicDiscont2DFECollection_swigregister, METH_O, NULL}, + { "CubicDiscont2DFECollection_swiginit", CubicDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_Const3DFECollection", _wrap_new_Const3DFECollection, METH_NOARGS, "new_Const3DFECollection() -> Const3DFECollection"}, + { "Const3DFECollection_FiniteElementForGeometry", _wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const3DFECollection_DofForGeometry", _wrap_Const3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const3DFECollection_DofOrderForOrientation", _wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const3DFECollection_Name", _wrap_Const3DFECollection_Name, METH_O, "Name(Const3DFECollection self) -> char const *"}, + { "delete_Const3DFECollection", _wrap_delete_Const3DFECollection, METH_O, "delete_Const3DFECollection(Const3DFECollection self)"}, + { "Const3DFECollection_swigregister", Const3DFECollection_swigregister, METH_O, NULL}, + { "Const3DFECollection_swiginit", Const3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearDiscont3DFECollection", _wrap_new_LinearDiscont3DFECollection, METH_NOARGS, "new_LinearDiscont3DFECollection() -> LinearDiscont3DFECollection"}, + { "LinearDiscont3DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont3DFECollection_DofForGeometry", _wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont3DFECollection_DofOrderForOrientation", _wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont3DFECollection_Name", _wrap_LinearDiscont3DFECollection_Name, METH_O, "Name(LinearDiscont3DFECollection self) -> char const *"}, + { "delete_LinearDiscont3DFECollection", _wrap_delete_LinearDiscont3DFECollection, METH_O, "delete_LinearDiscont3DFECollection(LinearDiscont3DFECollection self)"}, + { "LinearDiscont3DFECollection_swigregister", LinearDiscont3DFECollection_swigregister, METH_O, NULL}, + { "LinearDiscont3DFECollection_swiginit", LinearDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticDiscont3DFECollection", _wrap_new_QuadraticDiscont3DFECollection, METH_NOARGS, "new_QuadraticDiscont3DFECollection() -> QuadraticDiscont3DFECollection"}, + { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont3DFECollection_DofForGeometry", _wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont3DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont3DFECollection_Name", _wrap_QuadraticDiscont3DFECollection_Name, METH_O, "Name(QuadraticDiscont3DFECollection self) -> char const *"}, + { "delete_QuadraticDiscont3DFECollection", _wrap_delete_QuadraticDiscont3DFECollection, METH_O, "delete_QuadraticDiscont3DFECollection(QuadraticDiscont3DFECollection self)"}, + { "QuadraticDiscont3DFECollection_swigregister", QuadraticDiscont3DFECollection_swigregister, METH_O, NULL}, + { "QuadraticDiscont3DFECollection_swiginit", QuadraticDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinearFECollection", _wrap_new_RefinedLinearFECollection, METH_NOARGS, "new_RefinedLinearFECollection() -> RefinedLinearFECollection"}, + { "RefinedLinearFECollection_FiniteElementForGeometry", _wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RefinedLinearFECollection_DofForGeometry", _wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RefinedLinearFECollection_DofOrderForOrientation", _wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RefinedLinearFECollection_Name", _wrap_RefinedLinearFECollection_Name, METH_O, "Name(RefinedLinearFECollection self) -> char const *"}, + { "delete_RefinedLinearFECollection", _wrap_delete_RefinedLinearFECollection, METH_O, "delete_RefinedLinearFECollection(RefinedLinearFECollection self)"}, + { "RefinedLinearFECollection_swigregister", RefinedLinearFECollection_swigregister, METH_O, NULL}, + { "RefinedLinearFECollection_swiginit", RefinedLinearFECollection_swiginit, METH_VARARGS, NULL}, + { "new_ND1_3DFECollection", _wrap_new_ND1_3DFECollection, METH_NOARGS, "new_ND1_3DFECollection() -> ND1_3DFECollection"}, + { "ND1_3DFECollection_FiniteElementForGeometry", _wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND1_3DFECollection_DofForGeometry", _wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND1_3DFECollection_DofOrderForOrientation", _wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND1_3DFECollection_Name", _wrap_ND1_3DFECollection_Name, METH_O, "Name(ND1_3DFECollection self) -> char const *"}, + { "delete_ND1_3DFECollection", _wrap_delete_ND1_3DFECollection, METH_O, "delete_ND1_3DFECollection(ND1_3DFECollection self)"}, + { "ND1_3DFECollection_swigregister", ND1_3DFECollection_swigregister, METH_O, NULL}, + { "ND1_3DFECollection_swiginit", ND1_3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT0_3DFECollection", _wrap_new_RT0_3DFECollection, METH_NOARGS, "new_RT0_3DFECollection() -> RT0_3DFECollection"}, + { "RT0_3DFECollection_FiniteElementForGeometry", _wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_3DFECollection_DofForGeometry", _wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_3DFECollection_DofOrderForOrientation", _wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_3DFECollection_Name", _wrap_RT0_3DFECollection_Name, METH_O, "Name(RT0_3DFECollection self) -> char const *"}, + { "delete_RT0_3DFECollection", _wrap_delete_RT0_3DFECollection, METH_O, "delete_RT0_3DFECollection(RT0_3DFECollection self)"}, + { "RT0_3DFECollection_swigregister", RT0_3DFECollection_swigregister, METH_O, NULL}, + { "RT0_3DFECollection_swiginit", RT0_3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT1_3DFECollection", _wrap_new_RT1_3DFECollection, METH_NOARGS, "new_RT1_3DFECollection() -> RT1_3DFECollection"}, + { "RT1_3DFECollection_FiniteElementForGeometry", _wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_3DFECollection_DofForGeometry", _wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_3DFECollection_DofOrderForOrientation", _wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_3DFECollection_Name", _wrap_RT1_3DFECollection_Name, METH_O, "Name(RT1_3DFECollection self) -> char const *"}, + { "delete_RT1_3DFECollection", _wrap_delete_RT1_3DFECollection, METH_O, "delete_RT1_3DFECollection(RT1_3DFECollection self)"}, + { "RT1_3DFECollection_swigregister", RT1_3DFECollection_swigregister, METH_O, NULL}, + { "RT1_3DFECollection_swiginit", RT1_3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_Local_FECollection", _wrap_new_Local_FECollection, METH_O, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, + { "Local_FECollection_FiniteElementForGeometry", _wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, + { "Local_FECollection_DofForGeometry", _wrap_Local_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, + { "Local_FECollection_DofOrderForOrientation", _wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Local_FECollection_Name", _wrap_Local_FECollection_Name, METH_O, "Name(Local_FECollection self) -> char const *"}, + { "delete_Local_FECollection", _wrap_delete_Local_FECollection, METH_O, "delete_Local_FECollection(Local_FECollection self)"}, + { "Local_FECollection_swigregister", Local_FECollection_swigregister, METH_O, NULL}, + { "Local_FECollection_swiginit", Local_FECollection_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); -} static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); } @@ -13098,12 +13549,18 @@ static void *_p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollect static void *_p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::CrouzeixRaviartFECollection *) x)); } +static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +} static void *_p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::H1_FECollection *) x)); } static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -13137,8 +13594,8 @@ static void *_p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection(vo static void *_p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::QuadraticPosFECollection *) x)); } -static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); } static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::Local_FECollection *) x)); @@ -13146,6 +13603,9 @@ static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__H1_FECollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__H1_FECollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__H1_FECollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -13158,12 +13618,6 @@ static void *_p_mfem__DG_Interface_FECollectionTo_p_mfem__RT_FECollection(void * static void *_p_mfem__ND_Trace_FECollectionTo_p_mfem__ND_FECollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ND_FECollection *) ((mfem::ND_Trace_FECollection *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -13197,6 +13651,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -13212,6 +13669,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -13380,6 +13840,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -13423,10 +13889,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -13451,6 +13917,7 @@ static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement(void *x, int } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -13477,13 +13944,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -13495,6 +13960,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -13536,6 +14003,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -13564,6 +14033,7 @@ static swig_type_info _swigt__p_mfem__GaussLinearDiscont2DFECollection = {"_p_mf static swig_type_info _swigt__p_mfem__GaussQuadraticDiscont2DFECollection = {"_p_mfem__GaussQuadraticDiscont2DFECollection", "mfem::GaussQuadraticDiscont2DFECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_FECollection = {"_p_mfem__H1Pos_FECollection", "mfem::H1Pos_FECollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_FECollection = {"_p_mfem__H1Ser_FECollection", "mfem::H1Ser_FECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_FECollection = {"_p_mfem__H1_FECollection", "mfem::H1_FECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_Trace_FECollection = {"_p_mfem__H1_Trace_FECollection", "mfem::H1_Trace_FECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__IntegrationRule = {"_p_mfem__IntegrationRule", "mfem::IntegrationRule *", 0, 0, (void*)0, 0}; @@ -13601,6 +14071,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -13639,6 +14110,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_FECollection, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_FECollection, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, @@ -13742,6 +14215,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ScalarFiniteElement, &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__VectorFiniteElement, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -13751,6 +14225,7 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -13776,13 +14251,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -13794,6 +14267,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -13835,6 +14310,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -13858,13 +14335,14 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussLinearDiscont2DFECollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussQuadraticDiscont2DFECollection[] = { {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_FECollection[] = { {&_swigt__p_mfem__H1Pos_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1_FECollection[] = { {&_swigt__p_mfem__H1_FECollection, 0, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__H1_FECollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__H1_FECollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_FECollection[] = { {&_swigt__p_mfem__H1Ser_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1_FECollection[] = { {&_swigt__p_mfem__H1_FECollection, 0, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__H1_FECollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__H1_FECollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__H1_FECollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_Trace_FECollection[] = { {&_swigt__p_mfem__H1_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -13901,6 +14379,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -13939,6 +14418,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_FECollection, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_FECollection, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, @@ -14042,6 +14523,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ScalarFiniteElement, _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__VectorFiniteElement, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_par/fe_wrap.cxx b/mfem/_par/fe_wrap.cxx index 672fb105..0f04190b 100644 --- a/mfem/_par/fe_wrap.cxx +++ b/mfem/_par/fe_wrap.cxx @@ -3101,92 +3101,94 @@ namespace Swig { #define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[33] #define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[34] #define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[35] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[36] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[37] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[38] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[39] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[40] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[41] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[42] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[43] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[44] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[45] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[46] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[47] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[48] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[49] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[50] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[51] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[52] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[53] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[54] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[55] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[56] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[57] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[58] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[59] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[60] -#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[61] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[62] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[63] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[64] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[65] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[66] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[67] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[68] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[69] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[70] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[76] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[77] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[78] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[79] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[80] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[81] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[82] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[83] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__Poly_1D swig_types[86] -#define SWIGTYPE_p_mfem__Poly_1D__Basis swig_types[87] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[103] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[104] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[105] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[106] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[109] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[110] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[111] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__TensorBasisElement swig_types[114] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__Vector swig_types[116] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[117] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[118] -#define SWIGTYPE_p_p_int swig_types[119] -static swig_type_info *swig_types[121]; -static swig_module_info swig_module = {swig_types, 120, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[36] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[37] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[38] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[39] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[40] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[41] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[42] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[43] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[44] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[45] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[46] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[47] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[49] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[50] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[51] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[52] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[53] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[54] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[55] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[56] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[57] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[58] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[59] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[60] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[61] +#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[62] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[63] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[64] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[65] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[66] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[67] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[70] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[71] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[72] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[73] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[74] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[75] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[79] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[80] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[81] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[82] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[83] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[84] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[85] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[86] +#define SWIGTYPE_p_mfem__Poly_1D swig_types[87] +#define SWIGTYPE_p_mfem__Poly_1D__Basis swig_types[88] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[99] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[104] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[105] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[106] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[107] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[110] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[111] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[112] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__TensorBasisElement swig_types[115] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__Vector swig_types[117] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[118] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[120] +#define SWIGTYPE_p_p_int swig_types[121] +static swig_type_info *swig_types[123]; +static swig_module_info swig_module = {swig_types, 122, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3668,6 +3670,20 @@ SWIGINTERNINLINE PyObject* #define SWIG_From_double PyFloat_FromDouble +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + /* --------------------------------------------------- * C++ director class methods @@ -5765,6 +5781,171 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se } +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysHessian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::FiniteElement const *)arg1)->CalcPhysHessian(*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLaplacian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::FiniteElement const *)arg1)->CalcPhysLaplacian(*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLinLaplacian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::FiniteElement const *)arg1)->CalcPhysLinLaplacian(*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; @@ -26173,6 +26354,181 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcBernstein(PyObject *self, PyObject *args) } +SWIGINTERN PyObject *_wrap_Poly_1D_CalcLegendre__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + double *arg3 = (double *) 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcLegendre" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Poly_1D_CalcLegendre" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + { + try { + mfem::Poly_1D::CalcLegendre(arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Poly_1D_CalcLegendre__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + double *arg3 = (double *) 0 ; + double *arg4 = (double *) 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcLegendre" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Poly_1D_CalcLegendre" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Poly_1D_CalcLegendre" "', argument " "4"" of type '" "double *""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + { + try { + mfem::Poly_1D::CalcLegendre(arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Poly_1D_CalcLegendre(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Poly_1D_CalcLegendre", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Poly_1D_CalcLegendre__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Poly_1D_CalcLegendre__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Poly_1D_CalcLegendre'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Poly_1D::CalcLegendre(int const,double const,double *)\n" + " mfem::Poly_1D::CalcLegendre(int const,double const,double *,double *)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_delete_Poly_1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; @@ -26685,6 +27041,294 @@ SWIGINTERN PyObject *PositiveTensorFiniteElement_swigregister(PyObject *SWIGUNUS return SWIG_Py_Void(); } +SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + mfem::TensorBasisElement::DofMapType arg7 ; + int val7 ; + int ecode7 = 0 ; + PyObject *swig_obj[7] ; + mfem::VectorTensorFiniteElement *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_VectorTensorFiniteElement", 7, 7, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VectorTensorFiniteElement" "', argument " "7"" of type '" "mfem::TensorBasisElement::DofMapType""'"); + } + arg7 = static_cast< mfem::TensorBasisElement::DofMapType >(val7); + { + try { + result = (mfem::VectorTensorFiniteElement *)new mfem::VectorTensorFiniteElement(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorTensorFiniteElement, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::DofToQuad::Mode arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::DofToQuad *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); + } + arg3 = static_cast< mfem::DofToQuad::Mode >(val3); + { + try { + result = (mfem::DofToQuad *) &((mfem::VectorTensorFiniteElement const *)arg1)->GetDofToQuad((mfem::IntegrationRule const &)*arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DofToQuad, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::DofToQuad::Mode arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::DofToQuad *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuadOpen", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); + } + arg3 = static_cast< mfem::DofToQuad::Mode >(val3); + { + try { + result = (mfem::DofToQuad *) &((mfem::VectorTensorFiniteElement const *)arg1)->GetDofToQuadOpen((mfem::IntegrationRule const &)*arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DofToQuad, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::DofToQuad::Mode arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + mfem::DofToQuad *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetTensorDofToQuad", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); + } + arg3 = static_cast< mfem::DofToQuad::Mode >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + { + try { + result = (mfem::DofToQuad *) &((mfem::VectorTensorFiniteElement const *)arg1)->GetTensorDofToQuad((mfem::IntegrationRule const &)*arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DofToQuad, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorTensorFiniteElement" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorTensorFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorTensorFiniteElement, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorTensorFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; @@ -28164,11 +28808,11 @@ SWIGINTERN PyObject *H1Pos_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; int arg1 ; PyObject *swig_obj[1] ; - mfem::H1Pos_HexahedronElement *result = 0 ; + mfem::H1Ser_QuadrilateralElement *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; @@ -28180,7 +28824,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM( } { try { - result = (mfem::H1Pos_HexahedronElement *)new mfem::H1Pos_HexahedronElement(arg1); + result = (mfem::H1Ser_QuadrilateralElement *)new mfem::H1Ser_QuadrilateralElement(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28191,16 +28835,16 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM( // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Pos_HexahedronElement, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -28211,31 +28855,31 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } - arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::H1Pos_HexahedronElement const *)arg1)->CalcShape((mfem::IntegrationPoint const &)*arg2,*arg3); + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->CalcShape((mfem::IntegrationPoint const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28253,9 +28897,9 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; @@ -28266,31 +28910,31 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } - arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::H1Pos_HexahedronElement const *)arg1)->CalcDShape((mfem::IntegrationPoint const &)*arg2,*arg3); + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->CalcDShape((mfem::IntegrationPoint const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28308,40 +28952,44 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } - arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::H1Pos_HexahedronElement const *)arg1)->ProjectDelta(arg2,*arg3); + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->GetLocalInterpolation(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28359,23 +29007,54 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_delete_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Pos_HexahedronElement" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } - arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - delete arg1; + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->Project(*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28393,39 +29072,54 @@ SWIGINTERN PyObject *_wrap_delete_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *H1Pos_HexahedronElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Pos_HexahedronElement, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *H1Pos_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::H1_TriangleElement *result = 0 ; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1,arg2); + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->Project(*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28436,28 +29130,61 @@ SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPA // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TriangleElement, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - mfem::H1_TriangleElement *result = 0 ; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1); + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->Project((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28468,65 +29195,511 @@ SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPA // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TriangleElement, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_TriangleElement", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_Project", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 4) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_H1_TriangleElement__SWIG_1(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_0(self, argc, argv); + } + } + } } } - if (argc == 2) { + if (argc == 4) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0); + _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_1(self, argc, argv); + } } } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_H1_TriangleElement__SWIG_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_2(self, argc, argv); + } + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_TriangleElement'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'H1Ser_QuadrilateralElement_Project'.\n" " Possible C/C++ prototypes are:\n" - " mfem::H1_TriangleElement::H1_TriangleElement(int const,int const)\n" - " mfem::H1_TriangleElement::H1_TriangleElement(int const)\n"); + " Project(mfem::Coefficient &,mfem::ElementTransformation &,mfem::Vector &) const\n" + " Project(mfem::VectorCoefficient &,mfem::ElementTransformation &,mfem::Vector &) const\n" + " Project(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::DenseMatrix &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Ser_QuadrilateralElement" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *H1Ser_QuadrilateralElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1Ser_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + PyObject *swig_obj[1] ; + mfem::H1Pos_HexahedronElement *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::H1Pos_HexahedronElement *)new mfem::H1Pos_HexahedronElement(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Pos_HexahedronElement, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::H1Pos_HexahedronElement const *)arg1)->CalcShape((mfem::IntegrationPoint const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::H1Pos_HexahedronElement const *)arg1)->CalcDShape((mfem::IntegrationPoint const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::H1Pos_HexahedronElement const *)arg1)->ProjectDelta(arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Pos_HexahedronElement" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement *""'"); + } + arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *H1Pos_HexahedronElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Pos_HexahedronElement, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1Pos_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + mfem::H1_TriangleElement *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TriangleElement, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::H1_TriangleElement *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TriangleElement, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_H1_TriangleElement(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_TriangleElement", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_H1_TriangleElement__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_H1_TriangleElement__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_TriangleElement'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::H1_TriangleElement::H1_TriangleElement(int const,int const)\n" + " mfem::H1_TriangleElement::H1_TriangleElement(int const)\n"); return 0; } @@ -45435,6 +46608,61 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::NURBS1DFiniteElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_NURBS1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; @@ -45751,6 +46979,61 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::NURBS2DFiniteElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_NURBS2DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; @@ -46084,6 +47367,61 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::NURBS3DFiniteElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_NURBS3DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; @@ -46131,6 +47469,7 @@ SWIGINTERN PyObject *NURBS3DFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "BasisType_Check", _wrap_BasisType_Check, METH_O, "BasisType_Check(int b_type) -> int"}, { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "BasisType_CheckNodal(int b_type) -> int"}, { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "BasisType_GetQuadrature1D(int b_type) -> int"}, @@ -46193,7 +47532,10 @@ static PyMethodDef SwigMethods[] = { { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "FiniteElement_CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "FiniteElement_CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "FiniteElement_GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, - { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "FiniteElement_CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "FiniteElement_GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "FiniteElement_GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "FiniteElement_GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, @@ -46703,6 +48045,10 @@ static PyMethodDef SwigMethods[] = { "Poly_1D_CalcBernstein(int const p, double const x, double * u)\n" "Poly_1D_CalcBernstein(int const p, double const x, double * u, double * d)\n" ""}, + { "Poly_1D_CalcLegendre", _wrap_Poly_1D_CalcLegendre, METH_VARARGS, "\n" + "Poly_1D_CalcLegendre(int const p, double const x, double * u)\n" + "Poly_1D_CalcLegendre(int const p, double const x, double * u, double * d)\n" + ""}, { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, @@ -46721,6 +48067,13 @@ static PyMethodDef SwigMethods[] = { { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "PositiveTensorFiniteElement_GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, + { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, + { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, + { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "H1_SegmentElement_CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "H1_SegmentElement_CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, @@ -46756,6 +48109,18 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "H1Ser_QuadrilateralElement_GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" + "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, + { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, @@ -47121,6 +48486,7 @@ static PyMethodDef SwigMethods[] = { { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "NURBS1DFiniteElement_SetOrder(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "NURBS1DFiniteElement_CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "NURBS1DFiniteElement_CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "NURBS1DFiniteElement_CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -47131,6 +48497,7 @@ static PyMethodDef SwigMethods[] = { { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "NURBS2DFiniteElement_SetOrder(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "NURBS2DFiniteElement_CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "NURBS2DFiniteElement_CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "NURBS2DFiniteElement_CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -47141,6 +48508,7 @@ static PyMethodDef SwigMethods[] = { { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "NURBS3DFiniteElement_SetOrder(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "NURBS3DFiniteElement_CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "NURBS3DFiniteElement_CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "NURBS3DFiniteElement_CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -47148,15 +48516,1056 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "BasisType_Check", _wrap_BasisType_Check, METH_O, "Check(int b_type) -> int"}, + { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "CheckNodal(int b_type) -> int"}, + { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "GetQuadrature1D(int b_type) -> int"}, + { "BasisType_GetNodalBasis", _wrap_BasisType_GetNodalBasis, METH_O, "GetNodalBasis(int qpt_type) -> int"}, + { "BasisType_Name", _wrap_BasisType_Name, METH_O, "Name(int b_type) -> char const *"}, + { "BasisType_GetChar", _wrap_BasisType_GetChar, METH_O, "GetChar(int b_type) -> char"}, + { "BasisType_GetType", _wrap_BasisType_GetType, METH_O, "GetType(char b_ident) -> int"}, + { "new_BasisType", _wrap_new_BasisType, METH_NOARGS, "new_BasisType() -> BasisType"}, + { "delete_BasisType", _wrap_delete_BasisType, METH_O, "delete_BasisType(BasisType self)"}, + { "BasisType_swigregister", BasisType_swigregister, METH_O, NULL}, + { "BasisType_swiginit", BasisType_swiginit, METH_VARARGS, NULL}, + { "DofToQuad_IntRule_set", _wrap_DofToQuad_IntRule_set, METH_VARARGS, "DofToQuad_IntRule_set(DofToQuad self, IntegrationRule IntRule)"}, + { "DofToQuad_IntRule_get", _wrap_DofToQuad_IntRule_get, METH_O, "DofToQuad_IntRule_get(DofToQuad self) -> IntegrationRule"}, + { "DofToQuad_mode_set", _wrap_DofToQuad_mode_set, METH_VARARGS, "DofToQuad_mode_set(DofToQuad self, mfem::DofToQuad::Mode mode)"}, + { "DofToQuad_mode_get", _wrap_DofToQuad_mode_get, METH_O, "DofToQuad_mode_get(DofToQuad self) -> mfem::DofToQuad::Mode"}, + { "DofToQuad_ndof_set", _wrap_DofToQuad_ndof_set, METH_VARARGS, "DofToQuad_ndof_set(DofToQuad self, int ndof)"}, + { "DofToQuad_ndof_get", _wrap_DofToQuad_ndof_get, METH_O, "DofToQuad_ndof_get(DofToQuad self) -> int"}, + { "DofToQuad_nqpt_set", _wrap_DofToQuad_nqpt_set, METH_VARARGS, "DofToQuad_nqpt_set(DofToQuad self, int nqpt)"}, + { "DofToQuad_nqpt_get", _wrap_DofToQuad_nqpt_get, METH_O, "DofToQuad_nqpt_get(DofToQuad self) -> int"}, + { "DofToQuad_B_set", _wrap_DofToQuad_B_set, METH_VARARGS, "DofToQuad_B_set(DofToQuad self, doubleArray B)"}, + { "DofToQuad_B_get", _wrap_DofToQuad_B_get, METH_O, "DofToQuad_B_get(DofToQuad self) -> doubleArray"}, + { "DofToQuad_Bt_set", _wrap_DofToQuad_Bt_set, METH_VARARGS, "DofToQuad_Bt_set(DofToQuad self, doubleArray Bt)"}, + { "DofToQuad_Bt_get", _wrap_DofToQuad_Bt_get, METH_O, "DofToQuad_Bt_get(DofToQuad self) -> doubleArray"}, + { "DofToQuad_G_set", _wrap_DofToQuad_G_set, METH_VARARGS, "DofToQuad_G_set(DofToQuad self, doubleArray G)"}, + { "DofToQuad_G_get", _wrap_DofToQuad_G_get, METH_O, "DofToQuad_G_get(DofToQuad self) -> doubleArray"}, + { "DofToQuad_Gt_set", _wrap_DofToQuad_Gt_set, METH_VARARGS, "DofToQuad_Gt_set(DofToQuad self, doubleArray Gt)"}, + { "DofToQuad_Gt_get", _wrap_DofToQuad_Gt_get, METH_O, "DofToQuad_Gt_get(DofToQuad self) -> doubleArray"}, + { "new_DofToQuad", _wrap_new_DofToQuad, METH_NOARGS, "new_DofToQuad() -> DofToQuad"}, + { "delete_DofToQuad", _wrap_delete_DofToQuad, METH_O, "delete_DofToQuad(DofToQuad self)"}, + { "DofToQuad_swigregister", DofToQuad_swigregister, METH_O, NULL}, + { "DofToQuad_swiginit", DofToQuad_swiginit, METH_VARARGS, NULL}, + { "new_FunctionSpace", _wrap_new_FunctionSpace, METH_NOARGS, "new_FunctionSpace() -> FunctionSpace"}, + { "delete_FunctionSpace", _wrap_delete_FunctionSpace, METH_O, "delete_FunctionSpace(FunctionSpace self)"}, + { "FunctionSpace_swigregister", FunctionSpace_swigregister, METH_O, NULL}, + { "FunctionSpace_swiginit", FunctionSpace_swiginit, METH_VARARGS, NULL}, + { "FiniteElement_GetDim", _wrap_FiniteElement_GetDim, METH_O, "GetDim(FiniteElement self) -> int"}, + { "FiniteElement_GetGeomType", _wrap_FiniteElement_GetGeomType, METH_O, "GetGeomType(FiniteElement self) -> mfem::Geometry::Type"}, + { "FiniteElement_GetDof", _wrap_FiniteElement_GetDof, METH_O, "GetDof(FiniteElement self) -> int"}, + { "FiniteElement_GetOrder", _wrap_FiniteElement_GetOrder, METH_O, "GetOrder(FiniteElement self) -> int"}, + { "FiniteElement_HasAnisotropicOrders", _wrap_FiniteElement_HasAnisotropicOrders, METH_O, "HasAnisotropicOrders(FiniteElement self) -> bool"}, + { "FiniteElement_GetAnisotropicOrders", _wrap_FiniteElement_GetAnisotropicOrders, METH_O, "GetAnisotropicOrders(FiniteElement self) -> int const *"}, + { "FiniteElement_Space", _wrap_FiniteElement_Space, METH_O, "Space(FiniteElement self) -> int"}, + { "FiniteElement_GetRangeType", _wrap_FiniteElement_GetRangeType, METH_O, "GetRangeType(FiniteElement self) -> int"}, + { "FiniteElement_GetDerivRangeType", _wrap_FiniteElement_GetDerivRangeType, METH_O, "GetDerivRangeType(FiniteElement self) -> int"}, + { "FiniteElement_GetMapType", _wrap_FiniteElement_GetMapType, METH_O, "GetMapType(FiniteElement self) -> int"}, + { "FiniteElement_GetDerivType", _wrap_FiniteElement_GetDerivType, METH_O, "GetDerivType(FiniteElement self) -> int"}, + { "FiniteElement_GetDerivMapType", _wrap_FiniteElement_GetDerivMapType, METH_O, "GetDerivMapType(FiniteElement self) -> int"}, + { "FiniteElement_CalcShape", _wrap_FiniteElement_CalcShape, METH_VARARGS, "CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "FiniteElement_CalcPhysShape", _wrap_FiniteElement_CalcPhysShape, METH_VARARGS, "CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, + { "FiniteElement_CalcDShape", _wrap_FiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "FiniteElement_CalcPhysDShape", _wrap_FiniteElement_CalcPhysDShape, METH_VARARGS, "CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, + { "FiniteElement_GetNodes", _wrap_FiniteElement_GetNodes, METH_O, "GetNodes(FiniteElement self) -> IntegrationRule"}, + { "FiniteElement_CalcVShape", _wrap_FiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(FiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "FiniteElement_CalcPhysVShape", _wrap_FiniteElement_CalcPhysVShape, METH_VARARGS, "CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, + { "FiniteElement_CalcDivShape", _wrap_FiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "FiniteElement_CalcPhysDivShape", _wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS, "CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, + { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, + { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_ProjectMatrixCoefficient", _wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "FiniteElement_ProjectDelta", _wrap_FiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, + { "FiniteElement_Project", _wrap_FiniteElement_Project, METH_VARARGS, "\n" + "Project(FiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(FiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "FiniteElement_ProjectGrad", _wrap_FiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "FiniteElement_ProjectCurl", _wrap_FiniteElement_ProjectCurl, METH_VARARGS, "ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "FiniteElement_ProjectDiv", _wrap_FiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "FiniteElement_GetDofToQuad", _wrap_FiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_FiniteElement", _wrap_delete_FiniteElement, METH_O, "delete_FiniteElement(FiniteElement self)"}, + { "FiniteElement_IsClosedType", _wrap_FiniteElement_IsClosedType, METH_O, "IsClosedType(int b_type) -> bool"}, + { "FiniteElement_IsOpenType", _wrap_FiniteElement_IsOpenType, METH_O, "IsOpenType(int b_type) -> bool"}, + { "FiniteElement_VerifyClosed", _wrap_FiniteElement_VerifyClosed, METH_O, "VerifyClosed(int b_type) -> int"}, + { "FiniteElement_VerifyOpen", _wrap_FiniteElement_VerifyOpen, METH_O, "VerifyOpen(int b_type) -> int"}, + { "FiniteElement_VerifyNodal", _wrap_FiniteElement_VerifyNodal, METH_O, "VerifyNodal(int b_type) -> int"}, + { "FiniteElement_swigregister", FiniteElement_swigregister, METH_O, NULL}, + { "ScalarFiniteElement_SetMapType", _wrap_ScalarFiniteElement_SetMapType, METH_VARARGS, "SetMapType(ScalarFiniteElement self, int M)"}, + { "ScalarFiniteElement_NodalLocalInterpolation", _wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS, "NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_ScalarLocalInterpolation", _wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS, "ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_GetDofToQuad", _wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_ScalarFiniteElement", _wrap_delete_ScalarFiniteElement, METH_O, "delete_ScalarFiniteElement(ScalarFiniteElement self)"}, + { "ScalarFiniteElement_swigregister", ScalarFiniteElement_swigregister, METH_O, NULL}, + { "NodalFiniteElement_GetLocalInterpolation", _wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_GetLocalRestriction", _wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "NodalFiniteElement_GetTransferMatrix", _wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_ProjectMatrixCoefficient", _wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "NodalFiniteElement_Project", _wrap_NodalFiniteElement_Project, METH_VARARGS, "\n" + "Project(NodalFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(NodalFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "NodalFiniteElement_ProjectGrad", _wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "NodalFiniteElement_ProjectDiv", _wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "delete_NodalFiniteElement", _wrap_delete_NodalFiniteElement, METH_O, "delete_NodalFiniteElement(NodalFiniteElement self)"}, + { "NodalFiniteElement_swigregister", NodalFiniteElement_swigregister, METH_O, NULL}, + { "PositiveFiniteElement_GetLocalInterpolation", _wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetTransferMatrix", _wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_Project", _wrap_PositiveFiniteElement_Project, METH_VARARGS, "\n" + "Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "delete_PositiveFiniteElement", _wrap_delete_PositiveFiniteElement, METH_O, "delete_PositiveFiniteElement(PositiveFiniteElement self)"}, + { "PositiveFiniteElement_swigregister", PositiveFiniteElement_swigregister, METH_O, NULL}, + { "new_VectorFiniteElement", _wrap_new_VectorFiniteElement, METH_VARARGS, "VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk)"}, + { "delete_VectorFiniteElement", _wrap_delete_VectorFiniteElement, METH_O, "delete_VectorFiniteElement(VectorFiniteElement self)"}, + { "VectorFiniteElement_swigregister", VectorFiniteElement_swigregister, METH_O, NULL}, + { "VectorFiniteElement_swiginit", VectorFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_PointFiniteElement", _wrap_new_PointFiniteElement, METH_NOARGS, "new_PointFiniteElement() -> PointFiniteElement"}, + { "PointFiniteElement_CalcShape", _wrap_PointFiniteElement_CalcShape, METH_VARARGS, "CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "PointFiniteElement_CalcDShape", _wrap_PointFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_PointFiniteElement", _wrap_delete_PointFiniteElement, METH_O, "delete_PointFiniteElement(PointFiniteElement self)"}, + { "PointFiniteElement_swigregister", PointFiniteElement_swigregister, METH_O, NULL}, + { "PointFiniteElement_swiginit", PointFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Linear1DFiniteElement", _wrap_new_Linear1DFiniteElement, METH_NOARGS, "new_Linear1DFiniteElement() -> Linear1DFiniteElement"}, + { "Linear1DFiniteElement_CalcShape", _wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear1DFiniteElement_CalcDShape", _wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Linear1DFiniteElement", _wrap_delete_Linear1DFiniteElement, METH_O, "delete_Linear1DFiniteElement(Linear1DFiniteElement self)"}, + { "Linear1DFiniteElement_swigregister", Linear1DFiniteElement_swigregister, METH_O, NULL}, + { "Linear1DFiniteElement_swiginit", Linear1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Linear2DFiniteElement", _wrap_new_Linear2DFiniteElement, METH_NOARGS, "new_Linear2DFiniteElement() -> Linear2DFiniteElement"}, + { "Linear2DFiniteElement_CalcShape", _wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear2DFiniteElement_CalcDShape", _wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear2DFiniteElement_ProjectDelta", _wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_Linear2DFiniteElement", _wrap_delete_Linear2DFiniteElement, METH_O, "delete_Linear2DFiniteElement(Linear2DFiniteElement self)"}, + { "Linear2DFiniteElement_swigregister", Linear2DFiniteElement_swigregister, METH_O, NULL}, + { "Linear2DFiniteElement_swiginit", Linear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiLinear2DFiniteElement", _wrap_new_BiLinear2DFiniteElement, METH_NOARGS, "new_BiLinear2DFiniteElement() -> BiLinear2DFiniteElement"}, + { "BiLinear2DFiniteElement_CalcShape", _wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiLinear2DFiniteElement_CalcDShape", _wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiLinear2DFiniteElement_CalcHessian", _wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiLinear2DFiniteElement_ProjectDelta", _wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_BiLinear2DFiniteElement", _wrap_delete_BiLinear2DFiniteElement, METH_O, "delete_BiLinear2DFiniteElement(BiLinear2DFiniteElement self)"}, + { "BiLinear2DFiniteElement_swigregister", BiLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "BiLinear2DFiniteElement_swiginit", BiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussLinear2DFiniteElement", _wrap_new_GaussLinear2DFiniteElement, METH_NOARGS, "new_GaussLinear2DFiniteElement() -> GaussLinear2DFiniteElement"}, + { "GaussLinear2DFiniteElement_CalcShape", _wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussLinear2DFiniteElement_CalcDShape", _wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussLinear2DFiniteElement_ProjectDelta", _wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_GaussLinear2DFiniteElement", _wrap_delete_GaussLinear2DFiniteElement, METH_O, "delete_GaussLinear2DFiniteElement(GaussLinear2DFiniteElement self)"}, + { "GaussLinear2DFiniteElement_swigregister", GaussLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussLinear2DFiniteElement_swiginit", GaussLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussBiLinear2DFiniteElement", _wrap_new_GaussBiLinear2DFiniteElement, METH_NOARGS, "new_GaussBiLinear2DFiniteElement() -> GaussBiLinear2DFiniteElement"}, + { "GaussBiLinear2DFiniteElement_CalcShape", _wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiLinear2DFiniteElement_CalcDShape", _wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiLinear2DFiniteElement_ProjectDelta", _wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_GaussBiLinear2DFiniteElement", _wrap_delete_GaussBiLinear2DFiniteElement, METH_O, "delete_GaussBiLinear2DFiniteElement(GaussBiLinear2DFiniteElement self)"}, + { "GaussBiLinear2DFiniteElement_swigregister", GaussBiLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussBiLinear2DFiniteElement_swiginit", GaussBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P1OnQuadFiniteElement", _wrap_new_P1OnQuadFiniteElement, METH_NOARGS, "new_P1OnQuadFiniteElement() -> P1OnQuadFiniteElement"}, + { "P1OnQuadFiniteElement_CalcShape", _wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1OnQuadFiniteElement_CalcDShape", _wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1OnQuadFiniteElement_ProjectDelta", _wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P1OnQuadFiniteElement", _wrap_delete_P1OnQuadFiniteElement, METH_O, "delete_P1OnQuadFiniteElement(P1OnQuadFiniteElement self)"}, + { "P1OnQuadFiniteElement_swigregister", P1OnQuadFiniteElement_swigregister, METH_O, NULL}, + { "P1OnQuadFiniteElement_swiginit", P1OnQuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Quad1DFiniteElement", _wrap_new_Quad1DFiniteElement, METH_NOARGS, "new_Quad1DFiniteElement() -> Quad1DFiniteElement"}, + { "Quad1DFiniteElement_CalcShape", _wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad1DFiniteElement_CalcDShape", _wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Quad1DFiniteElement", _wrap_delete_Quad1DFiniteElement, METH_O, "delete_Quad1DFiniteElement(Quad1DFiniteElement self)"}, + { "Quad1DFiniteElement_swigregister", Quad1DFiniteElement_swigregister, METH_O, NULL}, + { "Quad1DFiniteElement_swiginit", Quad1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_QuadPos1DFiniteElement", _wrap_new_QuadPos1DFiniteElement, METH_NOARGS, "new_QuadPos1DFiniteElement() -> QuadPos1DFiniteElement"}, + { "QuadPos1DFiniteElement_CalcShape", _wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "QuadPos1DFiniteElement_CalcDShape", _wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_QuadPos1DFiniteElement", _wrap_delete_QuadPos1DFiniteElement, METH_O, "delete_QuadPos1DFiniteElement(QuadPos1DFiniteElement self)"}, + { "QuadPos1DFiniteElement_swigregister", QuadPos1DFiniteElement_swigregister, METH_O, NULL}, + { "QuadPos1DFiniteElement_swiginit", QuadPos1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Quad2DFiniteElement", _wrap_new_Quad2DFiniteElement, METH_NOARGS, "new_Quad2DFiniteElement() -> Quad2DFiniteElement"}, + { "Quad2DFiniteElement_CalcShape", _wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad2DFiniteElement_CalcDShape", _wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad2DFiniteElement_CalcHessian", _wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Quad2DFiniteElement_ProjectDelta", _wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_Quad2DFiniteElement", _wrap_delete_Quad2DFiniteElement, METH_O, "delete_Quad2DFiniteElement(Quad2DFiniteElement self)"}, + { "Quad2DFiniteElement_swigregister", Quad2DFiniteElement_swigregister, METH_O, NULL}, + { "Quad2DFiniteElement_swiginit", Quad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussQuad2DFiniteElement", _wrap_new_GaussQuad2DFiniteElement, METH_NOARGS, "new_GaussQuad2DFiniteElement() -> GaussQuad2DFiniteElement"}, + { "GaussQuad2DFiniteElement_CalcShape", _wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussQuad2DFiniteElement_CalcDShape", _wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_GaussQuad2DFiniteElement", _wrap_delete_GaussQuad2DFiniteElement, METH_O, "delete_GaussQuad2DFiniteElement(GaussQuad2DFiniteElement self)"}, + { "GaussQuad2DFiniteElement_swigregister", GaussQuad2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussQuad2DFiniteElement_swiginit", GaussQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiQuad2DFiniteElement", _wrap_new_BiQuad2DFiniteElement, METH_NOARGS, "new_BiQuad2DFiniteElement() -> BiQuad2DFiniteElement"}, + { "BiQuad2DFiniteElement_CalcShape", _wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuad2DFiniteElement_CalcDShape", _wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuad2DFiniteElement_ProjectDelta", _wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_BiQuad2DFiniteElement", _wrap_delete_BiQuad2DFiniteElement, METH_O, "delete_BiQuad2DFiniteElement(BiQuad2DFiniteElement self)"}, + { "BiQuad2DFiniteElement_swigregister", BiQuad2DFiniteElement_swigregister, METH_O, NULL}, + { "BiQuad2DFiniteElement_swiginit", BiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiQuadPos2DFiniteElement", _wrap_new_BiQuadPos2DFiniteElement, METH_NOARGS, "new_BiQuadPos2DFiniteElement() -> BiQuadPos2DFiniteElement"}, + { "BiQuadPos2DFiniteElement_CalcShape", _wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuadPos2DFiniteElement_CalcDShape", _wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuadPos2DFiniteElement_GetLocalInterpolation", _wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "BiQuadPos2DFiniteElement_Project", _wrap_BiQuadPos2DFiniteElement_Project, METH_VARARGS, "\n" + "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(BiQuadPos2DFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "BiQuadPos2DFiniteElement_ProjectDelta", _wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_BiQuadPos2DFiniteElement", _wrap_delete_BiQuadPos2DFiniteElement, METH_O, "delete_BiQuadPos2DFiniteElement(BiQuadPos2DFiniteElement self)"}, + { "BiQuadPos2DFiniteElement_swigregister", BiQuadPos2DFiniteElement_swigregister, METH_O, NULL}, + { "BiQuadPos2DFiniteElement_swiginit", BiQuadPos2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussBiQuad2DFiniteElement", _wrap_new_GaussBiQuad2DFiniteElement, METH_NOARGS, "new_GaussBiQuad2DFiniteElement() -> GaussBiQuad2DFiniteElement"}, + { "GaussBiQuad2DFiniteElement_CalcShape", _wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiQuad2DFiniteElement_CalcDShape", _wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_GaussBiQuad2DFiniteElement", _wrap_delete_GaussBiQuad2DFiniteElement, METH_O, "delete_GaussBiQuad2DFiniteElement(GaussBiQuad2DFiniteElement self)"}, + { "GaussBiQuad2DFiniteElement_swigregister", GaussBiQuad2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussBiQuad2DFiniteElement_swiginit", GaussBiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiCubic2DFiniteElement", _wrap_new_BiCubic2DFiniteElement, METH_NOARGS, "new_BiCubic2DFiniteElement() -> BiCubic2DFiniteElement"}, + { "BiCubic2DFiniteElement_CalcShape", _wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiCubic2DFiniteElement_CalcDShape", _wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiCubic2DFiniteElement_CalcHessian", _wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "delete_BiCubic2DFiniteElement", _wrap_delete_BiCubic2DFiniteElement, METH_O, "delete_BiCubic2DFiniteElement(BiCubic2DFiniteElement self)"}, + { "BiCubic2DFiniteElement_swigregister", BiCubic2DFiniteElement_swigregister, METH_O, NULL}, + { "BiCubic2DFiniteElement_swiginit", BiCubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Cubic1DFiniteElement", _wrap_new_Cubic1DFiniteElement, METH_NOARGS, "new_Cubic1DFiniteElement() -> Cubic1DFiniteElement"}, + { "Cubic1DFiniteElement_CalcShape", _wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic1DFiniteElement_CalcDShape", _wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Cubic1DFiniteElement", _wrap_delete_Cubic1DFiniteElement, METH_O, "delete_Cubic1DFiniteElement(Cubic1DFiniteElement self)"}, + { "Cubic1DFiniteElement_swigregister", Cubic1DFiniteElement_swigregister, METH_O, NULL}, + { "Cubic1DFiniteElement_swiginit", Cubic1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Cubic2DFiniteElement", _wrap_new_Cubic2DFiniteElement, METH_NOARGS, "new_Cubic2DFiniteElement() -> Cubic2DFiniteElement"}, + { "Cubic2DFiniteElement_CalcShape", _wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic2DFiniteElement_CalcDShape", _wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic2DFiniteElement_CalcHessian", _wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "delete_Cubic2DFiniteElement", _wrap_delete_Cubic2DFiniteElement, METH_O, "delete_Cubic2DFiniteElement(Cubic2DFiniteElement self)"}, + { "Cubic2DFiniteElement_swigregister", Cubic2DFiniteElement_swigregister, METH_O, NULL}, + { "Cubic2DFiniteElement_swiginit", Cubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Cubic3DFiniteElement", _wrap_new_Cubic3DFiniteElement, METH_NOARGS, "new_Cubic3DFiniteElement() -> Cubic3DFiniteElement"}, + { "Cubic3DFiniteElement_CalcShape", _wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic3DFiniteElement_CalcDShape", _wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Cubic3DFiniteElement", _wrap_delete_Cubic3DFiniteElement, METH_O, "delete_Cubic3DFiniteElement(Cubic3DFiniteElement self)"}, + { "Cubic3DFiniteElement_swigregister", Cubic3DFiniteElement_swigregister, METH_O, NULL}, + { "Cubic3DFiniteElement_swiginit", Cubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0TriangleFiniteElement", _wrap_new_P0TriangleFiniteElement, METH_NOARGS, "new_P0TriangleFiniteElement() -> P0TriangleFiniteElement"}, + { "P0TriangleFiniteElement_CalcShape", _wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TriangleFiniteElement_CalcDShape", _wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TriangleFiniteElement_ProjectDelta", _wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0TriangleFiniteElement", _wrap_delete_P0TriangleFiniteElement, METH_O, "delete_P0TriangleFiniteElement(P0TriangleFiniteElement self)"}, + { "P0TriangleFiniteElement_swigregister", P0TriangleFiniteElement_swigregister, METH_O, NULL}, + { "P0TriangleFiniteElement_swiginit", P0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0QuadFiniteElement", _wrap_new_P0QuadFiniteElement, METH_NOARGS, "new_P0QuadFiniteElement() -> P0QuadFiniteElement"}, + { "P0QuadFiniteElement_CalcShape", _wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0QuadFiniteElement_CalcDShape", _wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0QuadFiniteElement_ProjectDelta", _wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0QuadFiniteElement", _wrap_delete_P0QuadFiniteElement, METH_O, "delete_P0QuadFiniteElement(P0QuadFiniteElement self)"}, + { "P0QuadFiniteElement_swigregister", P0QuadFiniteElement_swigregister, METH_O, NULL}, + { "P0QuadFiniteElement_swiginit", P0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Linear3DFiniteElement", _wrap_new_Linear3DFiniteElement, METH_NOARGS, "new_Linear3DFiniteElement() -> Linear3DFiniteElement"}, + { "Linear3DFiniteElement_CalcShape", _wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear3DFiniteElement_CalcDShape", _wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear3DFiniteElement_ProjectDelta", _wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear3DFiniteElement_GetFaceDofs", _wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "delete_Linear3DFiniteElement", _wrap_delete_Linear3DFiniteElement, METH_O, "delete_Linear3DFiniteElement(Linear3DFiniteElement self)"}, + { "Linear3DFiniteElement_swigregister", Linear3DFiniteElement_swigregister, METH_O, NULL}, + { "Linear3DFiniteElement_swiginit", Linear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Quadratic3DFiniteElement", _wrap_new_Quadratic3DFiniteElement, METH_NOARGS, "new_Quadratic3DFiniteElement() -> Quadratic3DFiniteElement"}, + { "Quadratic3DFiniteElement_CalcShape", _wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quadratic3DFiniteElement_CalcDShape", _wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Quadratic3DFiniteElement", _wrap_delete_Quadratic3DFiniteElement, METH_O, "delete_Quadratic3DFiniteElement(Quadratic3DFiniteElement self)"}, + { "Quadratic3DFiniteElement_swigregister", Quadratic3DFiniteElement_swigregister, METH_O, NULL}, + { "Quadratic3DFiniteElement_swiginit", Quadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_TriLinear3DFiniteElement", _wrap_new_TriLinear3DFiniteElement, METH_NOARGS, "new_TriLinear3DFiniteElement() -> TriLinear3DFiniteElement"}, + { "TriLinear3DFiniteElement_CalcShape", _wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "TriLinear3DFiniteElement_CalcDShape", _wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "TriLinear3DFiniteElement_ProjectDelta", _wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_TriLinear3DFiniteElement", _wrap_delete_TriLinear3DFiniteElement, METH_O, "delete_TriLinear3DFiniteElement(TriLinear3DFiniteElement self)"}, + { "TriLinear3DFiniteElement_swigregister", TriLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "TriLinear3DFiniteElement_swiginit", TriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_CrouzeixRaviartFiniteElement", _wrap_new_CrouzeixRaviartFiniteElement, METH_NOARGS, "new_CrouzeixRaviartFiniteElement() -> CrouzeixRaviartFiniteElement"}, + { "CrouzeixRaviartFiniteElement_CalcShape", _wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartFiniteElement_CalcDShape", _wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartFiniteElement_ProjectDelta", _wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, + { "delete_CrouzeixRaviartFiniteElement", _wrap_delete_CrouzeixRaviartFiniteElement, METH_O, "delete_CrouzeixRaviartFiniteElement(CrouzeixRaviartFiniteElement self)"}, + { "CrouzeixRaviartFiniteElement_swigregister", CrouzeixRaviartFiniteElement_swigregister, METH_O, NULL}, + { "CrouzeixRaviartFiniteElement_swiginit", CrouzeixRaviartFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_CrouzeixRaviartQuadFiniteElement", _wrap_new_CrouzeixRaviartQuadFiniteElement, METH_NOARGS, "new_CrouzeixRaviartQuadFiniteElement() -> CrouzeixRaviartQuadFiniteElement"}, + { "CrouzeixRaviartQuadFiniteElement_CalcShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcDShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_CrouzeixRaviartQuadFiniteElement", _wrap_delete_CrouzeixRaviartQuadFiniteElement, METH_O, "delete_CrouzeixRaviartQuadFiniteElement(CrouzeixRaviartQuadFiniteElement self)"}, + { "CrouzeixRaviartQuadFiniteElement_swigregister", CrouzeixRaviartQuadFiniteElement_swigregister, METH_O, NULL}, + { "CrouzeixRaviartQuadFiniteElement_swiginit", CrouzeixRaviartQuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0SegmentFiniteElement", _wrap_new_P0SegmentFiniteElement, METH_VARARGS, "P0SegmentFiniteElement(int Ord=0)"}, + { "P0SegmentFiniteElement_CalcShape", _wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0SegmentFiniteElement_CalcDShape", _wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P0SegmentFiniteElement", _wrap_delete_P0SegmentFiniteElement, METH_O, "delete_P0SegmentFiniteElement(P0SegmentFiniteElement self)"}, + { "P0SegmentFiniteElement_swigregister", P0SegmentFiniteElement_swigregister, METH_O, NULL}, + { "P0SegmentFiniteElement_swiginit", P0SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0TriangleFiniteElement", _wrap_new_RT0TriangleFiniteElement, METH_NOARGS, "new_RT0TriangleFiniteElement() -> RT0TriangleFiniteElement"}, + { "RT0TriangleFiniteElement_CalcVShape", _wrap_RT0TriangleFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0TriangleFiniteElement_CalcDivShape", _wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TriangleFiniteElement_GetLocalInterpolation", _wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TriangleFiniteElement_Project", _wrap_RT0TriangleFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TriangleFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0TriangleFiniteElement", _wrap_delete_RT0TriangleFiniteElement, METH_O, "delete_RT0TriangleFiniteElement(RT0TriangleFiniteElement self)"}, + { "RT0TriangleFiniteElement_swigregister", RT0TriangleFiniteElement_swigregister, METH_O, NULL}, + { "RT0TriangleFiniteElement_swiginit", RT0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0QuadFiniteElement", _wrap_new_RT0QuadFiniteElement, METH_NOARGS, "new_RT0QuadFiniteElement() -> RT0QuadFiniteElement"}, + { "RT0QuadFiniteElement_CalcVShape", _wrap_RT0QuadFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0QuadFiniteElement_CalcDivShape", _wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0QuadFiniteElement_GetLocalInterpolation", _wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0QuadFiniteElement_Project", _wrap_RT0QuadFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0QuadFiniteElement", _wrap_delete_RT0QuadFiniteElement, METH_O, "delete_RT0QuadFiniteElement(RT0QuadFiniteElement self)"}, + { "RT0QuadFiniteElement_swigregister", RT0QuadFiniteElement_swigregister, METH_O, NULL}, + { "RT0QuadFiniteElement_swiginit", RT0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT1TriangleFiniteElement", _wrap_new_RT1TriangleFiniteElement, METH_NOARGS, "new_RT1TriangleFiniteElement() -> RT1TriangleFiniteElement"}, + { "RT1TriangleFiniteElement_CalcVShape", _wrap_RT1TriangleFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT1TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT1TriangleFiniteElement_CalcDivShape", _wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1TriangleFiniteElement_GetLocalInterpolation", _wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1TriangleFiniteElement_Project", _wrap_RT1TriangleFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT1TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1TriangleFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT1TriangleFiniteElement", _wrap_delete_RT1TriangleFiniteElement, METH_O, "delete_RT1TriangleFiniteElement(RT1TriangleFiniteElement self)"}, + { "RT1TriangleFiniteElement_swigregister", RT1TriangleFiniteElement_swigregister, METH_O, NULL}, + { "RT1TriangleFiniteElement_swiginit", RT1TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT1QuadFiniteElement", _wrap_new_RT1QuadFiniteElement, METH_NOARGS, "new_RT1QuadFiniteElement() -> RT1QuadFiniteElement"}, + { "RT1QuadFiniteElement_CalcVShape", _wrap_RT1QuadFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT1QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT1QuadFiniteElement_CalcDivShape", _wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1QuadFiniteElement_GetLocalInterpolation", _wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1QuadFiniteElement_Project", _wrap_RT1QuadFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT1QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT1QuadFiniteElement", _wrap_delete_RT1QuadFiniteElement, METH_O, "delete_RT1QuadFiniteElement(RT1QuadFiniteElement self)"}, + { "RT1QuadFiniteElement_swigregister", RT1QuadFiniteElement_swigregister, METH_O, NULL}, + { "RT1QuadFiniteElement_swiginit", RT1QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT2TriangleFiniteElement", _wrap_new_RT2TriangleFiniteElement, METH_NOARGS, "new_RT2TriangleFiniteElement() -> RT2TriangleFiniteElement"}, + { "RT2TriangleFiniteElement_CalcVShape", _wrap_RT2TriangleFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT2TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT2TriangleFiniteElement_CalcDivShape", _wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "delete_RT2TriangleFiniteElement", _wrap_delete_RT2TriangleFiniteElement, METH_O, "delete_RT2TriangleFiniteElement(RT2TriangleFiniteElement self)"}, + { "RT2TriangleFiniteElement_swigregister", RT2TriangleFiniteElement_swigregister, METH_O, NULL}, + { "RT2TriangleFiniteElement_swiginit", RT2TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT2QuadFiniteElement", _wrap_new_RT2QuadFiniteElement, METH_NOARGS, "new_RT2QuadFiniteElement() -> RT2QuadFiniteElement"}, + { "RT2QuadFiniteElement_CalcVShape", _wrap_RT2QuadFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT2QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT2QuadFiniteElement_CalcDivShape", _wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2QuadFiniteElement_GetLocalInterpolation", _wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT2QuadFiniteElement_Project", _wrap_RT2QuadFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT2QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT2QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT2QuadFiniteElement", _wrap_delete_RT2QuadFiniteElement, METH_O, "delete_RT2QuadFiniteElement(RT2QuadFiniteElement self)"}, + { "RT2QuadFiniteElement_swigregister", RT2QuadFiniteElement_swigregister, METH_O, NULL}, + { "RT2QuadFiniteElement_swiginit", RT2QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P1SegmentFiniteElement", _wrap_new_P1SegmentFiniteElement, METH_NOARGS, "new_P1SegmentFiniteElement() -> P1SegmentFiniteElement"}, + { "P1SegmentFiniteElement_CalcShape", _wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1SegmentFiniteElement_CalcDShape", _wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P1SegmentFiniteElement", _wrap_delete_P1SegmentFiniteElement, METH_O, "delete_P1SegmentFiniteElement(P1SegmentFiniteElement self)"}, + { "P1SegmentFiniteElement_swigregister", P1SegmentFiniteElement_swigregister, METH_O, NULL}, + { "P1SegmentFiniteElement_swiginit", P1SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P2SegmentFiniteElement", _wrap_new_P2SegmentFiniteElement, METH_NOARGS, "new_P2SegmentFiniteElement() -> P2SegmentFiniteElement"}, + { "P2SegmentFiniteElement_CalcShape", _wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P2SegmentFiniteElement_CalcDShape", _wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P2SegmentFiniteElement", _wrap_delete_P2SegmentFiniteElement, METH_O, "delete_P2SegmentFiniteElement(P2SegmentFiniteElement self)"}, + { "P2SegmentFiniteElement_swigregister", P2SegmentFiniteElement_swigregister, METH_O, NULL}, + { "P2SegmentFiniteElement_swiginit", P2SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Lagrange1DFiniteElement", _wrap_new_Lagrange1DFiniteElement, METH_O, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, + { "Lagrange1DFiniteElement_CalcShape", _wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Lagrange1DFiniteElement_CalcDShape", _wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Lagrange1DFiniteElement", _wrap_delete_Lagrange1DFiniteElement, METH_O, "delete_Lagrange1DFiniteElement(Lagrange1DFiniteElement self)"}, + { "Lagrange1DFiniteElement_swigregister", Lagrange1DFiniteElement_swigregister, METH_O, NULL}, + { "Lagrange1DFiniteElement_swiginit", Lagrange1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P1TetNonConfFiniteElement", _wrap_new_P1TetNonConfFiniteElement, METH_NOARGS, "new_P1TetNonConfFiniteElement() -> P1TetNonConfFiniteElement"}, + { "P1TetNonConfFiniteElement_CalcShape", _wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1TetNonConfFiniteElement_CalcDShape", _wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P1TetNonConfFiniteElement", _wrap_delete_P1TetNonConfFiniteElement, METH_O, "delete_P1TetNonConfFiniteElement(P1TetNonConfFiniteElement self)"}, + { "P1TetNonConfFiniteElement_swigregister", P1TetNonConfFiniteElement_swigregister, METH_O, NULL}, + { "P1TetNonConfFiniteElement_swiginit", P1TetNonConfFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0TetFiniteElement", _wrap_new_P0TetFiniteElement, METH_NOARGS, "new_P0TetFiniteElement() -> P0TetFiniteElement"}, + { "P0TetFiniteElement_CalcShape", _wrap_P0TetFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TetFiniteElement_CalcDShape", _wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TetFiniteElement_ProjectDelta", _wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0TetFiniteElement", _wrap_delete_P0TetFiniteElement, METH_O, "delete_P0TetFiniteElement(P0TetFiniteElement self)"}, + { "P0TetFiniteElement_swigregister", P0TetFiniteElement_swigregister, METH_O, NULL}, + { "P0TetFiniteElement_swiginit", P0TetFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0HexFiniteElement", _wrap_new_P0HexFiniteElement, METH_NOARGS, "new_P0HexFiniteElement() -> P0HexFiniteElement"}, + { "P0HexFiniteElement_CalcShape", _wrap_P0HexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0HexFiniteElement_CalcDShape", _wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0HexFiniteElement_ProjectDelta", _wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0HexFiniteElement", _wrap_delete_P0HexFiniteElement, METH_O, "delete_P0HexFiniteElement(P0HexFiniteElement self)"}, + { "P0HexFiniteElement_swigregister", P0HexFiniteElement_swigregister, METH_O, NULL}, + { "P0HexFiniteElement_swiginit", P0HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_LagrangeHexFiniteElement", _wrap_new_LagrangeHexFiniteElement, METH_O, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, + { "LagrangeHexFiniteElement_CalcShape", _wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "LagrangeHexFiniteElement_CalcDShape", _wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_LagrangeHexFiniteElement", _wrap_delete_LagrangeHexFiniteElement, METH_O, "delete_LagrangeHexFiniteElement(LagrangeHexFiniteElement self)"}, + { "LagrangeHexFiniteElement_swigregister", LagrangeHexFiniteElement_swigregister, METH_O, NULL}, + { "LagrangeHexFiniteElement_swiginit", LagrangeHexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinear1DFiniteElement", _wrap_new_RefinedLinear1DFiniteElement, METH_NOARGS, "new_RefinedLinear1DFiniteElement() -> RefinedLinear1DFiniteElement"}, + { "RefinedLinear1DFiniteElement_CalcShape", _wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear1DFiniteElement_CalcDShape", _wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedLinear1DFiniteElement", _wrap_delete_RefinedLinear1DFiniteElement, METH_O, "delete_RefinedLinear1DFiniteElement(RefinedLinear1DFiniteElement self)"}, + { "RefinedLinear1DFiniteElement_swigregister", RefinedLinear1DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedLinear1DFiniteElement_swiginit", RefinedLinear1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinear2DFiniteElement", _wrap_new_RefinedLinear2DFiniteElement, METH_NOARGS, "new_RefinedLinear2DFiniteElement() -> RefinedLinear2DFiniteElement"}, + { "RefinedLinear2DFiniteElement_CalcShape", _wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear2DFiniteElement_CalcDShape", _wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedLinear2DFiniteElement", _wrap_delete_RefinedLinear2DFiniteElement, METH_O, "delete_RefinedLinear2DFiniteElement(RefinedLinear2DFiniteElement self)"}, + { "RefinedLinear2DFiniteElement_swigregister", RefinedLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedLinear2DFiniteElement_swiginit", RefinedLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinear3DFiniteElement", _wrap_new_RefinedLinear3DFiniteElement, METH_NOARGS, "new_RefinedLinear3DFiniteElement() -> RefinedLinear3DFiniteElement"}, + { "RefinedLinear3DFiniteElement_CalcShape", _wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear3DFiniteElement_CalcDShape", _wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedLinear3DFiniteElement", _wrap_delete_RefinedLinear3DFiniteElement, METH_O, "delete_RefinedLinear3DFiniteElement(RefinedLinear3DFiniteElement self)"}, + { "RefinedLinear3DFiniteElement_swigregister", RefinedLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedLinear3DFiniteElement_swiginit", RefinedLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedBiLinear2DFiniteElement", _wrap_new_RefinedBiLinear2DFiniteElement, METH_NOARGS, "new_RefinedBiLinear2DFiniteElement() -> RefinedBiLinear2DFiniteElement"}, + { "RefinedBiLinear2DFiniteElement_CalcShape", _wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedBiLinear2DFiniteElement_CalcDShape", _wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedBiLinear2DFiniteElement", _wrap_delete_RefinedBiLinear2DFiniteElement, METH_O, "delete_RefinedBiLinear2DFiniteElement(RefinedBiLinear2DFiniteElement self)"}, + { "RefinedBiLinear2DFiniteElement_swigregister", RefinedBiLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedBiLinear2DFiniteElement_swiginit", RefinedBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedTriLinear3DFiniteElement", _wrap_new_RefinedTriLinear3DFiniteElement, METH_NOARGS, "new_RefinedTriLinear3DFiniteElement() -> RefinedTriLinear3DFiniteElement"}, + { "RefinedTriLinear3DFiniteElement_CalcShape", _wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedTriLinear3DFiniteElement_CalcDShape", _wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedTriLinear3DFiniteElement", _wrap_delete_RefinedTriLinear3DFiniteElement, METH_O, "delete_RefinedTriLinear3DFiniteElement(RefinedTriLinear3DFiniteElement self)"}, + { "RefinedTriLinear3DFiniteElement_swigregister", RefinedTriLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedTriLinear3DFiniteElement_swiginit", RefinedTriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Nedelec1HexFiniteElement", _wrap_new_Nedelec1HexFiniteElement, METH_NOARGS, "new_Nedelec1HexFiniteElement() -> Nedelec1HexFiniteElement"}, + { "Nedelec1HexFiniteElement_CalcVShape", _wrap_Nedelec1HexFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "Nedelec1HexFiniteElement_CalcCurlShape", _wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1HexFiniteElement_GetLocalInterpolation", _wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1HexFiniteElement_Project", _wrap_Nedelec1HexFiniteElement_Project, METH_VARARGS, "\n" + "Project(Nedelec1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_Nedelec1HexFiniteElement", _wrap_delete_Nedelec1HexFiniteElement, METH_O, "delete_Nedelec1HexFiniteElement(Nedelec1HexFiniteElement self)"}, + { "Nedelec1HexFiniteElement_swigregister", Nedelec1HexFiniteElement_swigregister, METH_O, NULL}, + { "Nedelec1HexFiniteElement_swiginit", Nedelec1HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Nedelec1TetFiniteElement", _wrap_new_Nedelec1TetFiniteElement, METH_NOARGS, "new_Nedelec1TetFiniteElement() -> Nedelec1TetFiniteElement"}, + { "Nedelec1TetFiniteElement_CalcVShape", _wrap_Nedelec1TetFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "Nedelec1TetFiniteElement_CalcCurlShape", _wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1TetFiniteElement_GetLocalInterpolation", _wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1TetFiniteElement_Project", _wrap_Nedelec1TetFiniteElement_Project, METH_VARARGS, "\n" + "Project(Nedelec1TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1TetFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_Nedelec1TetFiniteElement", _wrap_delete_Nedelec1TetFiniteElement, METH_O, "delete_Nedelec1TetFiniteElement(Nedelec1TetFiniteElement self)"}, + { "Nedelec1TetFiniteElement_swigregister", Nedelec1TetFiniteElement_swigregister, METH_O, NULL}, + { "Nedelec1TetFiniteElement_swiginit", Nedelec1TetFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0HexFiniteElement", _wrap_new_RT0HexFiniteElement, METH_NOARGS, "new_RT0HexFiniteElement() -> RT0HexFiniteElement"}, + { "RT0HexFiniteElement_CalcVShape", _wrap_RT0HexFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0HexFiniteElement_CalcDivShape", _wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0HexFiniteElement_GetLocalInterpolation", _wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0HexFiniteElement_Project", _wrap_RT0HexFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0HexFiniteElement", _wrap_delete_RT0HexFiniteElement, METH_O, "delete_RT0HexFiniteElement(RT0HexFiniteElement self)"}, + { "RT0HexFiniteElement_swigregister", RT0HexFiniteElement_swigregister, METH_O, NULL}, + { "RT0HexFiniteElement_swiginit", RT0HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT1HexFiniteElement", _wrap_new_RT1HexFiniteElement, METH_NOARGS, "new_RT1HexFiniteElement() -> RT1HexFiniteElement"}, + { "RT1HexFiniteElement_CalcVShape", _wrap_RT1HexFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT1HexFiniteElement_CalcDivShape", _wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1HexFiniteElement_GetLocalInterpolation", _wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1HexFiniteElement_Project", _wrap_RT1HexFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT1HexFiniteElement", _wrap_delete_RT1HexFiniteElement, METH_O, "delete_RT1HexFiniteElement(RT1HexFiniteElement self)"}, + { "RT1HexFiniteElement_swigregister", RT1HexFiniteElement_swigregister, METH_O, NULL}, + { "RT1HexFiniteElement_swiginit", RT1HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0TetFiniteElement", _wrap_new_RT0TetFiniteElement, METH_NOARGS, "new_RT0TetFiniteElement() -> RT0TetFiniteElement"}, + { "RT0TetFiniteElement_CalcVShape", _wrap_RT0TetFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0TetFiniteElement_CalcDivShape", _wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TetFiniteElement_GetLocalInterpolation", _wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TetFiniteElement_Project", _wrap_RT0TetFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TetFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0TetFiniteElement", _wrap_delete_RT0TetFiniteElement, METH_O, "delete_RT0TetFiniteElement(RT0TetFiniteElement self)"}, + { "RT0TetFiniteElement_swigregister", RT0TetFiniteElement_swigregister, METH_O, NULL}, + { "RT0TetFiniteElement_swiginit", RT0TetFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RotTriLinearHexFiniteElement", _wrap_new_RotTriLinearHexFiniteElement, METH_NOARGS, "new_RotTriLinearHexFiniteElement() -> RotTriLinearHexFiniteElement"}, + { "RotTriLinearHexFiniteElement_CalcShape", _wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RotTriLinearHexFiniteElement_CalcDShape", _wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RotTriLinearHexFiniteElement", _wrap_delete_RotTriLinearHexFiniteElement, METH_O, "delete_RotTriLinearHexFiniteElement(RotTriLinearHexFiniteElement self)"}, + { "RotTriLinearHexFiniteElement_swigregister", RotTriLinearHexFiniteElement_swigregister, METH_O, NULL}, + { "RotTriLinearHexFiniteElement_swiginit", RotTriLinearHexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Poly_1D", _wrap_new_Poly_1D, METH_NOARGS, "new_Poly_1D() -> Poly_1D"}, + { "Poly_1D_Binom", _wrap_Poly_1D_Binom, METH_O, "Binom(int const p) -> int const *"}, + { "Poly_1D_GetPoints", _wrap_Poly_1D_GetPoints, METH_VARARGS, "GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, + { "Poly_1D_OpenPoints", _wrap_Poly_1D_OpenPoints, METH_VARARGS, "OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const"}, + { "Poly_1D_ClosedPoints", _wrap_Poly_1D_ClosedPoints, METH_VARARGS, "ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const"}, + { "Poly_1D_GetBasis", _wrap_Poly_1D_GetBasis, METH_VARARGS, "GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, + { "Poly_1D_CalcBasis", _wrap_Poly_1D_CalcBasis, METH_VARARGS, "\n" + "CalcBasis(int const p, double const x, double * u)\n" + "CalcBasis(int const p, double const x, double * u, double * d)\n" + "CalcBasis(int const p, double const x, double * u, double * d, double * dd)\n" + ""}, + { "Poly_1D_CalcDelta", _wrap_Poly_1D_CalcDelta, METH_VARARGS, "CalcDelta(int const p, double const x) -> double"}, + { "Poly_1D_ChebyshevPoints", _wrap_Poly_1D_ChebyshevPoints, METH_VARARGS, "ChebyshevPoints(int const p, double * x)"}, + { "Poly_1D_CalcBinomTerms", _wrap_Poly_1D_CalcBinomTerms, METH_VARARGS, "\n" + "CalcBinomTerms(int const p, double const x, double const y, double * u)\n" + "CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)\n" + ""}, + { "Poly_1D_CalcDBinomTerms", _wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS, "CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, + { "Poly_1D_CalcBernstein", _wrap_Poly_1D_CalcBernstein, METH_VARARGS, "\n" + "CalcBernstein(int const p, double const x, double * u)\n" + "CalcBernstein(int const p, double const x, double * u, double * d)\n" + ""}, + { "Poly_1D_CalcLegendre", _wrap_Poly_1D_CalcLegendre, METH_VARARGS, "\n" + "CalcLegendre(int const p, double const x, double * u)\n" + "CalcLegendre(int const p, double const x, double * u, double * d)\n" + ""}, + { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, + { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, + { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, + { "new_TensorBasisElement", _wrap_new_TensorBasisElement, METH_VARARGS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, + { "TensorBasisElement_GetBasisType", _wrap_TensorBasisElement_GetBasisType, METH_O, "GetBasisType(TensorBasisElement self) -> int"}, + { "TensorBasisElement_GetBasis1D", _wrap_TensorBasisElement_GetBasis1D, METH_O, "GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &"}, + { "TensorBasisElement_GetDofMap", _wrap_TensorBasisElement_GetDofMap, METH_O, "GetDofMap(TensorBasisElement self) -> intArray"}, + { "TensorBasisElement_GetTensorProductGeometry", _wrap_TensorBasisElement_GetTensorProductGeometry, METH_O, "GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, + { "TensorBasisElement_Pow", _wrap_TensorBasisElement_Pow, METH_VARARGS, "Pow(int base, int dim) -> int"}, + { "delete_TensorBasisElement", _wrap_delete_TensorBasisElement, METH_O, "delete_TensorBasisElement(TensorBasisElement self)"}, + { "TensorBasisElement_swigregister", TensorBasisElement_swigregister, METH_O, NULL}, + { "TensorBasisElement_swiginit", TensorBasisElement_swiginit, METH_VARARGS, NULL}, + { "NodalTensorFiniteElement_GetDofToQuad", _wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_NodalTensorFiniteElement", _wrap_delete_NodalTensorFiniteElement, METH_O, "delete_NodalTensorFiniteElement(NodalTensorFiniteElement self)"}, + { "NodalTensorFiniteElement_swigregister", NodalTensorFiniteElement_swigregister, METH_O, NULL}, + { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, + { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, + { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, + { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, + { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, + { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_SegmentElement_ProjectDelta", _wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_H1_SegmentElement", _wrap_delete_H1_SegmentElement, METH_O, "delete_H1_SegmentElement(H1_SegmentElement self)"}, + { "H1_SegmentElement_swigregister", H1_SegmentElement_swigregister, METH_O, NULL}, + { "H1_SegmentElement_swiginit", H1_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_QuadrilateralElement", _wrap_new_H1_QuadrilateralElement, METH_VARARGS, "H1_QuadrilateralElement(int const p, int const btype=GaussLobatto)"}, + { "H1_QuadrilateralElement_CalcShape", _wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_QuadrilateralElement_CalcDShape", _wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_QuadrilateralElement_ProjectDelta", _wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "delete_H1_QuadrilateralElement", _wrap_delete_H1_QuadrilateralElement, METH_O, "delete_H1_QuadrilateralElement(H1_QuadrilateralElement self)"}, + { "H1_QuadrilateralElement_swigregister", H1_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1_QuadrilateralElement_swiginit", H1_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_HexahedronElement", _wrap_new_H1_HexahedronElement, METH_VARARGS, "H1_HexahedronElement(int const p, int const btype=GaussLobatto)"}, + { "H1_HexahedronElement_CalcShape", _wrap_H1_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_HexahedronElement_CalcDShape", _wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_HexahedronElement_ProjectDelta", _wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_H1_HexahedronElement", _wrap_delete_H1_HexahedronElement, METH_O, "delete_H1_HexahedronElement(H1_HexahedronElement self)"}, + { "H1_HexahedronElement_swigregister", H1_HexahedronElement_swigregister, METH_O, NULL}, + { "H1_HexahedronElement_swiginit", H1_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_SegmentElement", _wrap_new_H1Pos_SegmentElement, METH_O, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, + { "H1Pos_SegmentElement_CalcShape", _wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_SegmentElement_CalcDShape", _wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_SegmentElement_ProjectDelta", _wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_H1Pos_SegmentElement", _wrap_delete_H1Pos_SegmentElement, METH_O, "delete_H1Pos_SegmentElement(H1Pos_SegmentElement self)"}, + { "H1Pos_SegmentElement_swigregister", H1Pos_SegmentElement_swigregister, METH_O, NULL}, + { "H1Pos_SegmentElement_swiginit", H1Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_QuadrilateralElement", _wrap_new_H1Pos_QuadrilateralElement, METH_O, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, + { "H1Pos_QuadrilateralElement_CalcShape", _wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_QuadrilateralElement_CalcDShape", _wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_QuadrilateralElement_ProjectDelta", _wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, + { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" + "Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(H1Ser_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, + { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, + { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_HexahedronElement_ProjectDelta", _wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_H1Pos_HexahedronElement", _wrap_delete_H1Pos_HexahedronElement, METH_O, "delete_H1Pos_HexahedronElement(H1Pos_HexahedronElement self)"}, + { "H1Pos_HexahedronElement_swigregister", H1Pos_HexahedronElement_swigregister, METH_O, NULL}, + { "H1Pos_HexahedronElement_swiginit", H1Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_TriangleElement", _wrap_new_H1_TriangleElement, METH_VARARGS, "H1_TriangleElement(int const p, int const btype=GaussLobatto)"}, + { "H1_TriangleElement_CalcShape", _wrap_H1_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TriangleElement_CalcDShape", _wrap_H1_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TriangleElement_CalcHessian", _wrap_H1_TriangleElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "delete_H1_TriangleElement", _wrap_delete_H1_TriangleElement, METH_O, "delete_H1_TriangleElement(H1_TriangleElement self)"}, + { "H1_TriangleElement_swigregister", H1_TriangleElement_swigregister, METH_O, NULL}, + { "H1_TriangleElement_swiginit", H1_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_TetrahedronElement", _wrap_new_H1_TetrahedronElement, METH_VARARGS, "H1_TetrahedronElement(int const p, int const btype=GaussLobatto)"}, + { "H1_TetrahedronElement_CalcShape", _wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TetrahedronElement_CalcDShape", _wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TetrahedronElement_CalcHessian", _wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "delete_H1_TetrahedronElement", _wrap_delete_H1_TetrahedronElement, METH_O, "delete_H1_TetrahedronElement(H1_TetrahedronElement self)"}, + { "H1_TetrahedronElement_swigregister", H1_TetrahedronElement_swigregister, METH_O, NULL}, + { "H1_TetrahedronElement_swiginit", H1_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_TriangleElement", _wrap_new_H1Pos_TriangleElement, METH_O, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, + { "H1Pos_TriangleElement_CalcShape", _wrap_H1Pos_TriangleElement_CalcShape, METH_VARARGS, "\n" + "CalcShape(int const p, double const x, double const y, double * shape)\n" + "CalcShape(IntegrationPoint ip, Vector shape)\n" + ""}, + { "H1Pos_TriangleElement_CalcDShape", _wrap_H1Pos_TriangleElement_CalcDShape, METH_VARARGS, "\n" + "CalcDShape(int const p, double const x, double const y, double * dshape_1d, double * dshape)\n" + "CalcDShape(IntegrationPoint ip, DenseMatrix dshape)\n" + ""}, + { "delete_H1Pos_TriangleElement", _wrap_delete_H1Pos_TriangleElement, METH_O, "delete_H1Pos_TriangleElement(H1Pos_TriangleElement self)"}, + { "H1Pos_TriangleElement_swigregister", H1Pos_TriangleElement_swigregister, METH_O, NULL}, + { "H1Pos_TriangleElement_swiginit", H1Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_TetrahedronElement", _wrap_new_H1Pos_TetrahedronElement, METH_O, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, + { "H1Pos_TetrahedronElement_CalcShape", _wrap_H1Pos_TetrahedronElement_CalcShape, METH_VARARGS, "\n" + "CalcShape(int const p, double const x, double const y, double const z, double * shape)\n" + "CalcShape(IntegrationPoint ip, Vector shape)\n" + ""}, + { "H1Pos_TetrahedronElement_CalcDShape", _wrap_H1Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "\n" + "CalcDShape(int const p, double const x, double const y, double const z, double * dshape_1d, double * dshape)\n" + "CalcDShape(IntegrationPoint ip, DenseMatrix dshape)\n" + ""}, + { "delete_H1Pos_TetrahedronElement", _wrap_delete_H1Pos_TetrahedronElement, METH_O, "delete_H1Pos_TetrahedronElement(H1Pos_TetrahedronElement self)"}, + { "H1Pos_TetrahedronElement_swigregister", H1Pos_TetrahedronElement_swigregister, METH_O, NULL}, + { "H1Pos_TetrahedronElement_swiginit", H1Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_WedgeElement", _wrap_new_H1_WedgeElement, METH_VARARGS, "H1_WedgeElement(int const p, int const btype=GaussLobatto)"}, + { "H1_WedgeElement_CalcShape", _wrap_H1_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_WedgeElement_CalcDShape", _wrap_H1_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_H1_WedgeElement", _wrap_delete_H1_WedgeElement, METH_O, "delete_H1_WedgeElement(H1_WedgeElement self)"}, + { "H1_WedgeElement_swigregister", H1_WedgeElement_swigregister, METH_O, NULL}, + { "H1_WedgeElement_swiginit", H1_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_BiLinear3DFiniteElement", _wrap_new_BiLinear3DFiniteElement, METH_NOARGS, "new_BiLinear3DFiniteElement() -> BiLinear3DFiniteElement"}, + { "delete_BiLinear3DFiniteElement", _wrap_delete_BiLinear3DFiniteElement, METH_O, "delete_BiLinear3DFiniteElement(BiLinear3DFiniteElement self)"}, + { "BiLinear3DFiniteElement_swigregister", BiLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "BiLinear3DFiniteElement_swiginit", BiLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiQuadratic3DFiniteElement", _wrap_new_BiQuadratic3DFiniteElement, METH_NOARGS, "new_BiQuadratic3DFiniteElement() -> BiQuadratic3DFiniteElement"}, + { "delete_BiQuadratic3DFiniteElement", _wrap_delete_BiQuadratic3DFiniteElement, METH_O, "delete_BiQuadratic3DFiniteElement(BiQuadratic3DFiniteElement self)"}, + { "BiQuadratic3DFiniteElement_swigregister", BiQuadratic3DFiniteElement_swigregister, METH_O, NULL}, + { "BiQuadratic3DFiniteElement_swiginit", BiQuadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiCubic3DFiniteElement", _wrap_new_BiCubic3DFiniteElement, METH_NOARGS, "new_BiCubic3DFiniteElement() -> BiCubic3DFiniteElement"}, + { "delete_BiCubic3DFiniteElement", _wrap_delete_BiCubic3DFiniteElement, METH_O, "delete_BiCubic3DFiniteElement(BiCubic3DFiniteElement self)"}, + { "BiCubic3DFiniteElement_swigregister", BiCubic3DFiniteElement_swigregister, METH_O, NULL}, + { "BiCubic3DFiniteElement_swiginit", BiCubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_WedgeElement", _wrap_new_H1Pos_WedgeElement, METH_O, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, + { "H1Pos_WedgeElement_CalcShape", _wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_WedgeElement_CalcDShape", _wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_H1Pos_WedgeElement", _wrap_delete_H1Pos_WedgeElement, METH_O, "delete_H1Pos_WedgeElement(H1Pos_WedgeElement self)"}, + { "H1Pos_WedgeElement_swigregister", H1Pos_WedgeElement_swigregister, METH_O, NULL}, + { "H1Pos_WedgeElement_swiginit", H1Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_SegmentElement", _wrap_new_L2_SegmentElement, METH_VARARGS, "L2_SegmentElement(int const p, int const btype=GaussLegendre)"}, + { "L2_SegmentElement_CalcShape", _wrap_L2_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_SegmentElement_CalcDShape", _wrap_L2_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_SegmentElement_ProjectDelta", _wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_L2_SegmentElement", _wrap_delete_L2_SegmentElement, METH_O, "delete_L2_SegmentElement(L2_SegmentElement self)"}, + { "L2_SegmentElement_swigregister", L2_SegmentElement_swigregister, METH_O, NULL}, + { "L2_SegmentElement_swiginit", L2_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_SegmentElement", _wrap_new_L2Pos_SegmentElement, METH_O, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, + { "L2Pos_SegmentElement_CalcShape", _wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_SegmentElement_CalcDShape", _wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_SegmentElement_ProjectDelta", _wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_SegmentElement", _wrap_delete_L2Pos_SegmentElement, METH_O, "delete_L2Pos_SegmentElement(L2Pos_SegmentElement self)"}, + { "L2Pos_SegmentElement_swigregister", L2Pos_SegmentElement_swigregister, METH_O, NULL}, + { "L2Pos_SegmentElement_swiginit", L2Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_QuadrilateralElement", _wrap_new_L2_QuadrilateralElement, METH_VARARGS, "L2_QuadrilateralElement(int const p, int const btype=GaussLegendre)"}, + { "L2_QuadrilateralElement_CalcShape", _wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_QuadrilateralElement_CalcDShape", _wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_QuadrilateralElement_ProjectDelta", _wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "L2_QuadrilateralElement_ProjectCurl", _wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_L2_QuadrilateralElement", _wrap_delete_L2_QuadrilateralElement, METH_O, "delete_L2_QuadrilateralElement(L2_QuadrilateralElement self)"}, + { "L2_QuadrilateralElement_swigregister", L2_QuadrilateralElement_swigregister, METH_O, NULL}, + { "L2_QuadrilateralElement_swiginit", L2_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_QuadrilateralElement", _wrap_new_L2Pos_QuadrilateralElement, METH_O, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, + { "L2Pos_QuadrilateralElement_CalcShape", _wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_QuadrilateralElement_CalcDShape", _wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_QuadrilateralElement_ProjectDelta", _wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_QuadrilateralElement", _wrap_delete_L2Pos_QuadrilateralElement, METH_O, "delete_L2Pos_QuadrilateralElement(L2Pos_QuadrilateralElement self)"}, + { "L2Pos_QuadrilateralElement_swigregister", L2Pos_QuadrilateralElement_swigregister, METH_O, NULL}, + { "L2Pos_QuadrilateralElement_swiginit", L2Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_HexahedronElement", _wrap_new_L2_HexahedronElement, METH_VARARGS, "L2_HexahedronElement(int const p, int const btype=GaussLegendre)"}, + { "L2_HexahedronElement_CalcShape", _wrap_L2_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_HexahedronElement_CalcDShape", _wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_HexahedronElement_ProjectDelta", _wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2_HexahedronElement", _wrap_delete_L2_HexahedronElement, METH_O, "delete_L2_HexahedronElement(L2_HexahedronElement self)"}, + { "L2_HexahedronElement_swigregister", L2_HexahedronElement_swigregister, METH_O, NULL}, + { "L2_HexahedronElement_swiginit", L2_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_HexahedronElement", _wrap_new_L2Pos_HexahedronElement, METH_O, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, + { "L2Pos_HexahedronElement_CalcShape", _wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_HexahedronElement_CalcDShape", _wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_HexahedronElement_ProjectDelta", _wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_HexahedronElement", _wrap_delete_L2Pos_HexahedronElement, METH_O, "delete_L2Pos_HexahedronElement(L2Pos_HexahedronElement self)"}, + { "L2Pos_HexahedronElement_swigregister", L2Pos_HexahedronElement_swigregister, METH_O, NULL}, + { "L2Pos_HexahedronElement_swiginit", L2Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_TriangleElement", _wrap_new_L2_TriangleElement, METH_VARARGS, "L2_TriangleElement(int const p, int const btype=GaussLegendre)"}, + { "L2_TriangleElement_CalcShape", _wrap_L2_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TriangleElement_CalcDShape", _wrap_L2_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TriangleElement_ProjectDelta", _wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, + { "L2_TriangleElement_ProjectCurl", _wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_L2_TriangleElement", _wrap_delete_L2_TriangleElement, METH_O, "delete_L2_TriangleElement(L2_TriangleElement self)"}, + { "L2_TriangleElement_swigregister", L2_TriangleElement_swigregister, METH_O, NULL}, + { "L2_TriangleElement_swiginit", L2_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_TriangleElement", _wrap_new_L2Pos_TriangleElement, METH_O, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, + { "L2Pos_TriangleElement_CalcShape", _wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TriangleElement_CalcDShape", _wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TriangleElement_ProjectDelta", _wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_TriangleElement", _wrap_delete_L2Pos_TriangleElement, METH_O, "delete_L2Pos_TriangleElement(L2Pos_TriangleElement self)"}, + { "L2Pos_TriangleElement_swigregister", L2Pos_TriangleElement_swigregister, METH_O, NULL}, + { "L2Pos_TriangleElement_swiginit", L2Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_TetrahedronElement", _wrap_new_L2_TetrahedronElement, METH_VARARGS, "L2_TetrahedronElement(int const p, int const btype=GaussLegendre)"}, + { "L2_TetrahedronElement_CalcShape", _wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TetrahedronElement_CalcDShape", _wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TetrahedronElement_ProjectDelta", _wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2_TetrahedronElement", _wrap_delete_L2_TetrahedronElement, METH_O, "delete_L2_TetrahedronElement(L2_TetrahedronElement self)"}, + { "L2_TetrahedronElement_swigregister", L2_TetrahedronElement_swigregister, METH_O, NULL}, + { "L2_TetrahedronElement_swiginit", L2_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_TetrahedronElement", _wrap_new_L2Pos_TetrahedronElement, METH_O, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, + { "L2Pos_TetrahedronElement_CalcShape", _wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TetrahedronElement_CalcDShape", _wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TetrahedronElement_ProjectDelta", _wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_TetrahedronElement", _wrap_delete_L2Pos_TetrahedronElement, METH_O, "delete_L2Pos_TetrahedronElement(L2Pos_TetrahedronElement self)"}, + { "L2Pos_TetrahedronElement_swigregister", L2Pos_TetrahedronElement_swigregister, METH_O, NULL}, + { "L2Pos_TetrahedronElement_swiginit", L2Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_WedgeElement", _wrap_new_L2_WedgeElement, METH_VARARGS, "L2_WedgeElement(int const p, int const btype=GaussLegendre)"}, + { "L2_WedgeElement_CalcShape", _wrap_L2_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_WedgeElement_CalcDShape", _wrap_L2_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_L2_WedgeElement", _wrap_delete_L2_WedgeElement, METH_O, "delete_L2_WedgeElement(L2_WedgeElement self)"}, + { "L2_WedgeElement_swigregister", L2_WedgeElement_swigregister, METH_O, NULL}, + { "L2_WedgeElement_swiginit", L2_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_P0WedgeFiniteElement", _wrap_new_P0WedgeFiniteElement, METH_NOARGS, "new_P0WedgeFiniteElement() -> P0WedgeFiniteElement"}, + { "delete_P0WedgeFiniteElement", _wrap_delete_P0WedgeFiniteElement, METH_O, "delete_P0WedgeFiniteElement(P0WedgeFiniteElement self)"}, + { "P0WedgeFiniteElement_swigregister", P0WedgeFiniteElement_swigregister, METH_O, NULL}, + { "P0WedgeFiniteElement_swiginit", P0WedgeFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_WedgeElement", _wrap_new_L2Pos_WedgeElement, METH_O, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, + { "L2Pos_WedgeElement_CalcShape", _wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_WedgeElement_CalcDShape", _wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_L2Pos_WedgeElement", _wrap_delete_L2Pos_WedgeElement, METH_O, "delete_L2Pos_WedgeElement(L2Pos_WedgeElement self)"}, + { "L2Pos_WedgeElement_swigregister", L2Pos_WedgeElement_swigregister, METH_O, NULL}, + { "L2Pos_WedgeElement_swiginit", L2Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_QuadrilateralElement", _wrap_new_RT_QuadrilateralElement, METH_VARARGS, "RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "RT_QuadrilateralElement_CalcVShape", _wrap_RT_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_QuadrilateralElement_CalcDivShape", _wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_QuadrilateralElement_GetLocalInterpolation", _wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_GetLocalRestriction", _wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_QuadrilateralElement_GetTransferMatrix", _wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_QuadrilateralElement_Project", _wrap_RT_QuadrilateralElement_Project, METH_VARARGS, "\n" + "Project(RT_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_QuadrilateralElement_ProjectGrad", _wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_QuadrilateralElement_ProjectCurl", _wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_QuadrilateralElement", _wrap_delete_RT_QuadrilateralElement, METH_O, "delete_RT_QuadrilateralElement(RT_QuadrilateralElement self)"}, + { "RT_QuadrilateralElement_swigregister", RT_QuadrilateralElement_swigregister, METH_O, NULL}, + { "RT_QuadrilateralElement_swiginit", RT_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_HexahedronElement", _wrap_new_RT_HexahedronElement, METH_VARARGS, "RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "RT_HexahedronElement_CalcVShape", _wrap_RT_HexahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_HexahedronElement_CalcDivShape", _wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_HexahedronElement_GetLocalInterpolation", _wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_GetLocalRestriction", _wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_HexahedronElement_GetTransferMatrix", _wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_ProjectMatrixCoefficient", _wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_HexahedronElement_Project", _wrap_RT_HexahedronElement_Project, METH_VARARGS, "\n" + "Project(RT_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_HexahedronElement_ProjectCurl", _wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_HexahedronElement", _wrap_delete_RT_HexahedronElement, METH_O, "delete_RT_HexahedronElement(RT_HexahedronElement self)"}, + { "RT_HexahedronElement_swigregister", RT_HexahedronElement_swigregister, METH_O, NULL}, + { "RT_HexahedronElement_swiginit", RT_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_TriangleElement", _wrap_new_RT_TriangleElement, METH_O, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, + { "RT_TriangleElement_CalcVShape", _wrap_RT_TriangleElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_TriangleElement_CalcDivShape", _wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TriangleElement_GetLocalInterpolation", _wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_GetLocalRestriction", _wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TriangleElement_GetTransferMatrix", _wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_ProjectMatrixCoefficient", _wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TriangleElement_Project", _wrap_RT_TriangleElement_Project, METH_VARARGS, "\n" + "Project(RT_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_TriangleElement_ProjectGrad", _wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_TriangleElement_ProjectCurl", _wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_TriangleElement", _wrap_delete_RT_TriangleElement, METH_O, "delete_RT_TriangleElement(RT_TriangleElement self)"}, + { "RT_TriangleElement_swigregister", RT_TriangleElement_swigregister, METH_O, NULL}, + { "RT_TriangleElement_swiginit", RT_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_TetrahedronElement", _wrap_new_RT_TetrahedronElement, METH_O, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, + { "RT_TetrahedronElement_CalcVShape", _wrap_RT_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_TetrahedronElement_CalcDivShape", _wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TetrahedronElement_GetLocalInterpolation", _wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_GetLocalRestriction", _wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TetrahedronElement_GetTransferMatrix", _wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_ProjectMatrixCoefficient", _wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TetrahedronElement_Project", _wrap_RT_TetrahedronElement_Project, METH_VARARGS, "\n" + "Project(RT_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_TetrahedronElement_ProjectCurl", _wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_TetrahedronElement", _wrap_delete_RT_TetrahedronElement, METH_O, "delete_RT_TetrahedronElement(RT_TetrahedronElement self)"}, + { "RT_TetrahedronElement_swigregister", RT_TetrahedronElement_swigregister, METH_O, NULL}, + { "RT_TetrahedronElement_swiginit", RT_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_HexahedronElement", _wrap_new_ND_HexahedronElement, METH_VARARGS, "ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "ND_HexahedronElement_CalcVShape", _wrap_ND_HexahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_HexahedronElement_CalcCurlShape", _wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_HexahedronElement_GetLocalInterpolation", _wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_GetLocalRestriction", _wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_HexahedronElement_GetTransferMatrix", _wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_ProjectMatrixCoefficient", _wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_HexahedronElement_Project", _wrap_ND_HexahedronElement_Project, METH_VARARGS, "\n" + "Project(ND_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_HexahedronElement_ProjectGrad", _wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_HexahedronElement_ProjectCurl", _wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_ND_HexahedronElement", _wrap_delete_ND_HexahedronElement, METH_O, "delete_ND_HexahedronElement(ND_HexahedronElement self)"}, + { "ND_HexahedronElement_swigregister", ND_HexahedronElement_swigregister, METH_O, NULL}, + { "ND_HexahedronElement_swiginit", ND_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_QuadrilateralElement", _wrap_new_ND_QuadrilateralElement, METH_VARARGS, "ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "ND_QuadrilateralElement_CalcVShape", _wrap_ND_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_QuadrilateralElement_CalcCurlShape", _wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_QuadrilateralElement_GetLocalInterpolation", _wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_GetLocalRestriction", _wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_QuadrilateralElement_GetTransferMatrix", _wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_QuadrilateralElement_Project", _wrap_ND_QuadrilateralElement_Project, METH_VARARGS, "\n" + "Project(ND_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_QuadrilateralElement_ProjectGrad", _wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "delete_ND_QuadrilateralElement", _wrap_delete_ND_QuadrilateralElement, METH_O, "delete_ND_QuadrilateralElement(ND_QuadrilateralElement self)"}, + { "ND_QuadrilateralElement_swigregister", ND_QuadrilateralElement_swigregister, METH_O, NULL}, + { "ND_QuadrilateralElement_swiginit", ND_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_TetrahedronElement", _wrap_new_ND_TetrahedronElement, METH_O, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, + { "ND_TetrahedronElement_CalcVShape", _wrap_ND_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_TetrahedronElement_CalcCurlShape", _wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TetrahedronElement_GetLocalInterpolation", _wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_GetLocalRestriction", _wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TetrahedronElement_GetTransferMatrix", _wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_ProjectMatrixCoefficient", _wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TetrahedronElement_Project", _wrap_ND_TetrahedronElement_Project, METH_VARARGS, "\n" + "Project(ND_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_TetrahedronElement_ProjectGrad", _wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TetrahedronElement_ProjectCurl", _wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_ND_TetrahedronElement", _wrap_delete_ND_TetrahedronElement, METH_O, "delete_ND_TetrahedronElement(ND_TetrahedronElement self)"}, + { "ND_TetrahedronElement_swigregister", ND_TetrahedronElement_swigregister, METH_O, NULL}, + { "ND_TetrahedronElement_swiginit", ND_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_TriangleElement", _wrap_new_ND_TriangleElement, METH_O, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, + { "ND_TriangleElement_CalcVShape", _wrap_ND_TriangleElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_TriangleElement_CalcCurlShape", _wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TriangleElement_GetLocalInterpolation", _wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_GetLocalRestriction", _wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TriangleElement_GetTransferMatrix", _wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_ProjectMatrixCoefficient", _wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TriangleElement_Project", _wrap_ND_TriangleElement_Project, METH_VARARGS, "\n" + "Project(ND_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_TriangleElement_ProjectGrad", _wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "delete_ND_TriangleElement", _wrap_delete_ND_TriangleElement, METH_O, "delete_ND_TriangleElement(ND_TriangleElement self)"}, + { "ND_TriangleElement_swigregister", ND_TriangleElement_swigregister, METH_O, NULL}, + { "ND_TriangleElement_swiginit", ND_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_SegmentElement", _wrap_new_ND_SegmentElement, METH_VARARGS, "ND_SegmentElement(int const p, int const ob_type=GaussLegendre)"}, + { "ND_SegmentElement_CalcShape", _wrap_ND_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "ND_SegmentElement_CalcVShape", _wrap_ND_SegmentElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_SegmentElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_SegmentElement_GetLocalInterpolation", _wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_GetLocalRestriction", _wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_SegmentElement_GetTransferMatrix", _wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_ProjectMatrixCoefficient", _wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_SegmentElement_Project", _wrap_ND_SegmentElement_Project, METH_VARARGS, "\n" + "Project(ND_SegmentElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_SegmentElement_ProjectGrad", _wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "delete_ND_SegmentElement", _wrap_delete_ND_SegmentElement, METH_O, "delete_ND_SegmentElement(ND_SegmentElement self)"}, + { "ND_SegmentElement_swigregister", ND_SegmentElement_swigregister, METH_O, NULL}, + { "ND_SegmentElement_swiginit", ND_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "NURBSFiniteElement_Reset", _wrap_NURBSFiniteElement_Reset, METH_O, "Reset(NURBSFiniteElement self)"}, + { "NURBSFiniteElement_SetIJK", _wrap_NURBSFiniteElement_SetIJK, METH_VARARGS, "SetIJK(NURBSFiniteElement self, int const * IJK)"}, + { "NURBSFiniteElement_GetPatch", _wrap_NURBSFiniteElement_GetPatch, METH_O, "GetPatch(NURBSFiniteElement self) -> int"}, + { "NURBSFiniteElement_SetPatch", _wrap_NURBSFiniteElement_SetPatch, METH_VARARGS, "SetPatch(NURBSFiniteElement self, int p)"}, + { "NURBSFiniteElement_GetElement", _wrap_NURBSFiniteElement_GetElement, METH_O, "GetElement(NURBSFiniteElement self) -> int"}, + { "NURBSFiniteElement_SetElement", _wrap_NURBSFiniteElement_SetElement, METH_VARARGS, "SetElement(NURBSFiniteElement self, int e)"}, + { "NURBSFiniteElement_KnotVectors", _wrap_NURBSFiniteElement_KnotVectors, METH_O, "KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &"}, + { "NURBSFiniteElement_Weights", _wrap_NURBSFiniteElement_Weights, METH_O, "Weights(NURBSFiniteElement self) -> Vector"}, + { "NURBSFiniteElement_SetOrder", _wrap_NURBSFiniteElement_SetOrder, METH_O, "SetOrder(NURBSFiniteElement self)"}, + { "delete_NURBSFiniteElement", _wrap_delete_NURBSFiniteElement, METH_O, "delete_NURBSFiniteElement(NURBSFiniteElement self)"}, + { "NURBSFiniteElement_swigregister", NURBSFiniteElement_swigregister, METH_O, NULL}, + { "new_NURBS1DFiniteElement", _wrap_new_NURBS1DFiniteElement, METH_O, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, + { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS1DFiniteElement self)"}, + { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, + { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, + { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_NURBS2DFiniteElement", _wrap_new_NURBS2DFiniteElement, METH_VARARGS, "\n" + "NURBS2DFiniteElement(int p)\n" + "new_NURBS2DFiniteElement(int px, int py) -> NURBS2DFiniteElement\n" + ""}, + { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS2DFiniteElement self)"}, + { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, + { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, + { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_NURBS3DFiniteElement", _wrap_new_NURBS3DFiniteElement, METH_VARARGS, "\n" + "NURBS3DFiniteElement(int p)\n" + "new_NURBS3DFiniteElement(int px, int py, int pz) -> NURBS3DFiniteElement\n" + ""}, + { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS3DFiniteElement self)"}, + { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, + { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, + { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS2DFiniteElement *) x)); -} static void *_p_mfem__NURBS1DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS1DFiniteElement *) x)); } @@ -47232,6 +49641,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__ScalarFiniteElement(void *x, static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -47376,6 +49788,9 @@ static void *_p_mfem__P0TetFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, static void *_p_mfem__P0HexFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::NodalFiniteElement *) ((mfem::P0HexFiniteElement *) x)); } +static void *_p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS2DFiniteElement *) x)); +} static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS3DFiniteElement *) x)); } @@ -47388,6 +49803,12 @@ static void *_p_mfem__NURBS2DFiniteElementTo_p_mfem__NURBSFiniteElement(void *x, static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__NURBSFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NURBSFiniteElement *) ((mfem::NURBS3DFiniteElement *) x)); } +static void *_p_mfem__ND_HexahedronElementTo_p_mfem__VectorTensorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); +} +static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorTensorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); +} static void *_p_mfem__P0WedgeFiniteElementTo_p_mfem__L2_WedgeElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::L2_WedgeElement *) ((mfem::P0WedgeFiniteElement *) x)); } @@ -47436,9 +49857,6 @@ static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__NodalTensorFiniteElement static void *_p_mfem__L2_HexahedronElementTo_p_mfem__NodalTensorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NodalTensorFiniteElement *) ((mfem::L2_HexahedronElement *) x)); } -static void *_p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::TensorBasisElement *) (mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_HexahedronElement *) x)); -} static void *_p_mfem__L2_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) (mfem::NodalTensorFiniteElement *) ((mfem::L2_HexahedronElement *) x)); } @@ -47472,14 +49890,23 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__TensorBasisElement(void static void *_p_mfem__H1_SegmentElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) (mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) ((mfem::PositiveTensorFiniteElement *) x)); } static void *_p_mfem__NodalTensorFiniteElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) ((mfem::NodalTensorFiniteElement *) x)); } -static void *_p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_TriangleElement *) x)); +static void *_p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) (mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_HexahedronElement *) x)); +} +static void *_p_mfem__ND_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); +} +static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_HexahedronElement *) x)); @@ -47487,6 +49914,9 @@ static void *_p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement(void *x static void *_p_mfem__RT_QuadrilateralElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_QuadrilateralElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__RT0TetFiniteElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT0TetFiniteElement *) x)); } @@ -47520,14 +49950,17 @@ static void *_p_mfem__RT0QuadFiniteElementTo_p_mfem__VectorFiniteElement(void *x static void *_p_mfem__RT0TriangleFiniteElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT0TriangleFiniteElement *) x)); } +static void *_p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_TriangleElement *) x)); +} static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::VectorFiniteElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::VectorFiniteElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -47745,12 +50178,6 @@ static void *_p_mfem__L2_WedgeElementTo_p_mfem__NodalFiniteElement(void *x, int static void *_p_mfem__P0WedgeFiniteElementTo_p_mfem__NodalFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NodalFiniteElement *) (mfem::L2_WedgeElement *) ((mfem::P0WedgeFiniteElement *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -47784,6 +50211,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -47799,6 +50229,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -47967,6 +50400,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -48010,10 +50449,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -48072,6 +50511,7 @@ static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_Se static swig_type_info _swigt__p_mfem__H1Pos_TetrahedronElement = {"_p_mfem__H1Pos_TetrahedronElement", "mfem::H1Pos_TetrahedronElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_TriangleElement", "mfem::H1Pos_TriangleElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", "mfem::H1Pos_WedgeElement *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", "mfem::H1Ser_QuadrilateralElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", "mfem::H1_HexahedronElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", "mfem::H1_QuadrilateralElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", "mfem::H1_SegmentElement *", 0, 0, (void*)0, 0}; @@ -48155,6 +50595,7 @@ static swig_type_info _swigt__p_mfem__TriLinear3DFiniteElement = {"_p_mfem__TriL static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__VectorCoefficient = {"_p_mfem__VectorCoefficient", "mfem::VectorCoefficient *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__VectorFiniteElement = {"_p_mfem__VectorFiniteElement", "mfem::VectorFiniteElement *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", "mfem::VectorTensorFiniteElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { @@ -48194,6 +50635,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -48277,6 +50719,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__Vector, &_swigt__p_mfem__VectorCoefficient, &_swigt__p_mfem__VectorFiniteElement, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_p_int, }; @@ -48304,7 +50747,7 @@ static swig_cast_info _swigc__p_mfem__Cubic3DFiniteElement[] = { {&_swigt__p_mf static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DofToQuad[] = { {&_swigt__p_mfem__DofToQuad, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FunctionSpace[] = { {&_swigt__p_mfem__FunctionSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussBiLinear2DFiniteElement[] = { {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussBiQuad2DFiniteElement[] = { {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -48316,6 +50759,7 @@ static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = { {&_swigt__p_mf static swig_cast_info _swigc__p_mfem__H1Pos_TetrahedronElement[] = { {&_swigt__p_mfem__H1Pos_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = { {&_swigt__p_mfem__H1Pos_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = { {&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = { {&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = { {&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = { {&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = { {&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -48393,12 +50837,13 @@ static swig_cast_info _swigc__p_mfem__RefinedLinear2DFiniteElement[] = { {&_swi static swig_cast_info _swigc__p_mfem__RefinedLinear3DFiniteElement[] = { {&_swigt__p_mfem__RefinedLinear3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RefinedTriLinear3DFiniteElement[] = { {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = { {&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ScalarFiniteElement[] = { {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TensorBasisElement[] = { {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__TensorBasisElement, 0, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScalarFiniteElement[] = { {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TensorBasisElement[] = { {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__TensorBasisElement, 0, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TriLinear3DFiniteElement[] = { {&_swigt__p_mfem__TriLinear3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCoefficient[] = { {&_swigt__p_mfem__VectorCoefficient, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorFiniteElement[] = { {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__VectorFiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorFiniteElement[] = { {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__VectorFiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = { {&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__VectorTensorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorTensorFiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_int[] = { {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { @@ -48438,6 +50883,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -48521,6 +50967,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__Vector, _swigc__p_mfem__VectorCoefficient, _swigc__p_mfem__VectorFiniteElement, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_p_int, }; @@ -49261,6 +51708,7 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "BasisType_OpenUniform",SWIG_From_int(static_cast< int >(mfem::BasisType::OpenUniform))); SWIG_Python_SetConstant(d, "BasisType_ClosedUniform",SWIG_From_int(static_cast< int >(mfem::BasisType::ClosedUniform))); SWIG_Python_SetConstant(d, "BasisType_OpenHalfUniform",SWIG_From_int(static_cast< int >(mfem::BasisType::OpenHalfUniform))); + SWIG_Python_SetConstant(d, "BasisType_Serendipity",SWIG_From_int(static_cast< int >(mfem::BasisType::Serendipity))); SWIG_Python_SetConstant(d, "BasisType_NumBasisTypes",SWIG_From_int(static_cast< int >(mfem::BasisType::NumBasisTypes))); SWIG_Python_SetConstant(d, "DofToQuad_FULL",SWIG_From_int(static_cast< int >(mfem::DofToQuad::FULL))); SWIG_Python_SetConstant(d, "DofToQuad_TENSOR",SWIG_From_int(static_cast< int >(mfem::DofToQuad::TENSOR))); @@ -49283,6 +51731,7 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Poly_1D_NumEvalTypes",SWIG_From_int(static_cast< int >(mfem::Poly_1D::NumEvalTypes))); SWIG_Python_SetConstant(d, "TensorBasisElement_L2_DOF_MAP",SWIG_From_int(static_cast< int >(mfem::TensorBasisElement::L2_DOF_MAP))); SWIG_Python_SetConstant(d, "TensorBasisElement_H1_DOF_MAP",SWIG_From_int(static_cast< int >(mfem::TensorBasisElement::H1_DOF_MAP))); + SWIG_Python_SetConstant(d, "TensorBasisElement_Sr_DOF_MAP",SWIG_From_int(static_cast< int >(mfem::TensorBasisElement::Sr_DOF_MAP))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/fespace.i b/mfem/_par/fespace.i index b077383d..11528870 100644 --- a/mfem/_par/fespace.i +++ b/mfem/_par/fespace.i @@ -16,6 +16,7 @@ #include "fem/eltrans.hpp" #include "fem/coefficient.hpp" #include "fem/intrules.hpp" +#include "fem/restriction.hpp" #include "io_stream.hpp" #include "numpy/arrayobject.h" #include "pyoperator.hpp" @@ -39,6 +40,7 @@ import_array(); %import "eltrans.i" %import "lininteg.i" %import "handle.i" +%import "restriction.i" %include "../common/typemap_macros.i" %import "../common/exception.i" diff --git a/mfem/_par/fespace.py b/mfem/_par/fespace.py index 2f10684f..03b08851 100644 --- a/mfem/_par/fespace.py +++ b/mfem/_par/fespace.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _fespace.SWIG_PyInstanceMethod_New +_swig_new_static_method = _fespace.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -77,6 +80,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -88,6 +92,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction class Ordering(object): r"""Proxy of C++ mfem::Ordering class.""" @@ -143,6 +148,7 @@ def __init__(self, *args): def GetMesh(self): r"""GetMesh(FiniteElementSpace self) -> Mesh""" return _fespace.FiniteElementSpace_GetMesh(self) + GetMesh = _swig_new_instance_method(_fespace.FiniteElementSpace_GetMesh) def GetNURBSext(self, *args): r""" @@ -150,125 +156,170 @@ def GetNURBSext(self, *args): GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension * """ return _fespace.FiniteElementSpace_GetNURBSext(self, *args) + GetNURBSext = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNURBSext) def StealNURBSext(self): r"""StealNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *""" return _fespace.FiniteElementSpace_StealNURBSext(self) + StealNURBSext = _swig_new_instance_method(_fespace.FiniteElementSpace_StealNURBSext) def Conforming(self): r"""Conforming(FiniteElementSpace self) -> bool""" return _fespace.FiniteElementSpace_Conforming(self) + Conforming = _swig_new_instance_method(_fespace.FiniteElementSpace_Conforming) def Nonconforming(self): r"""Nonconforming(FiniteElementSpace self) -> bool""" return _fespace.FiniteElementSpace_Nonconforming(self) + Nonconforming = _swig_new_instance_method(_fespace.FiniteElementSpace_Nonconforming) def GetConformingProlongation(self): r"""GetConformingProlongation(FiniteElementSpace self) -> SparseMatrix""" return _fespace.FiniteElementSpace_GetConformingProlongation(self) + GetConformingProlongation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingProlongation) def GetConformingRestriction(self): r"""GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix""" return _fespace.FiniteElementSpace_GetConformingRestriction(self) + GetConformingRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingRestriction) def GetProlongationMatrix(self): r"""GetProlongationMatrix(FiniteElementSpace self) -> Operator""" return _fespace.FiniteElementSpace_GetProlongationMatrix(self) + GetProlongationMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_GetProlongationMatrix) def GetRestrictionMatrix(self): r"""GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix""" return _fespace.FiniteElementSpace_GetRestrictionMatrix(self) + GetRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_GetRestrictionMatrix) def GetElementRestriction(self, e_ordering): r"""GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator""" return _fespace.FiniteElementSpace_GetElementRestriction(self, e_ordering) + GetElementRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementRestriction) + + def GetFaceRestriction(self, *args): + r"""GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator""" + return _fespace.FiniteElementSpace_GetFaceRestriction(self, *args) + GetFaceRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceRestriction) def GetQuadratureInterpolator(self, *args): r""" - GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> QuadratureInterpolator - GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> QuadratureInterpolator + GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const + GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const * """ return _fespace.FiniteElementSpace_GetQuadratureInterpolator(self, *args) + GetQuadratureInterpolator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetQuadratureInterpolator) + + def GetFaceQuadratureInterpolator(self, ir, type): + r"""GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *""" + return _fespace.FiniteElementSpace_GetFaceQuadratureInterpolator(self, ir, type) + GetFaceQuadratureInterpolator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceQuadratureInterpolator) def GetVDim(self): r"""GetVDim(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetVDim(self) + GetVDim = _swig_new_instance_method(_fespace.FiniteElementSpace_GetVDim) def GetOrder(self, i): r"""GetOrder(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetOrder(self, i) + GetOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetOrder) def GetFaceOrder(self, i): r"""GetFaceOrder(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetFaceOrder(self, i) + GetFaceOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceOrder) def GetNDofs(self): r"""GetNDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNDofs(self) + GetNDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNDofs) def GetVSize(self): r"""GetVSize(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetVSize(self) + GetVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetVSize) def GetTrueVSize(self): r"""GetTrueVSize(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetTrueVSize(self) + GetTrueVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTrueVSize) def GetNConformingDofs(self): r"""GetNConformingDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNConformingDofs(self) + GetNConformingDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNConformingDofs) def GetConformingVSize(self): r"""GetConformingVSize(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetConformingVSize(self) + GetConformingVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingVSize) def GetOrdering(self): r"""GetOrdering(FiniteElementSpace self) -> mfem::Ordering::Type""" return _fespace.FiniteElementSpace_GetOrdering(self) + GetOrdering = _swig_new_instance_method(_fespace.FiniteElementSpace_GetOrdering) def FEColl(self): r"""FEColl(FiniteElementSpace self) -> FiniteElementCollection""" return _fespace.FiniteElementSpace_FEColl(self) + FEColl = _swig_new_instance_method(_fespace.FiniteElementSpace_FEColl) def GetNVDofs(self): r"""GetNVDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNVDofs(self) + GetNVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNVDofs) def GetNEDofs(self): r"""GetNEDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNEDofs(self) + GetNEDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNEDofs) def GetNFDofs(self): r"""GetNFDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNFDofs(self) + GetNFDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNFDofs) def GetNV(self): r"""GetNV(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNV(self) + GetNV = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNV) def GetNE(self): r"""GetNE(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNE(self) + GetNE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNE) def GetNF(self): r"""GetNF(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNF(self) + GetNF = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNF) def GetNBE(self): r"""GetNBE(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNBE(self) + GetNBE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNBE) + + def GetNFbyType(self, type): + r"""GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int""" + return _fespace.FiniteElementSpace_GetNFbyType(self, type) + GetNFbyType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNFbyType) def GetElementType(self, i): r"""GetElementType(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetElementType(self, i) + GetElementType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementType) def GetElementVertices(self, i, vertices): r"""GetElementVertices(FiniteElementSpace self, int i, intArray vertices)""" return _fespace.FiniteElementSpace_GetElementVertices(self, i, vertices) + GetElementVertices = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementVertices) def GetBdrElementType(self, i): r"""GetBdrElementType(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetBdrElementType(self, i) + GetBdrElementType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementType) def GetElementTransformation(self, *args): r""" @@ -276,18 +327,22 @@ def GetElementTransformation(self, *args): GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr) """ return _fespace.FiniteElementSpace_GetElementTransformation(self, *args) + GetElementTransformation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementTransformation) def GetBdrElementTransformation(self, i): r"""GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation""" return _fespace.FiniteElementSpace_GetBdrElementTransformation(self, i) + GetBdrElementTransformation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementTransformation) def GetAttribute(self, i): r"""GetAttribute(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetAttribute(self, i) + GetAttribute = _swig_new_instance_method(_fespace.FiniteElementSpace_GetAttribute) def GetBdrAttribute(self, i): r"""GetBdrAttribute(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetBdrAttribute(self, i) + GetBdrAttribute = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrAttribute) def GetElementDofs(self, i): from .array import intArray @@ -340,10 +395,12 @@ def GetElementInteriorDofs(self, i): def GetFaceInteriorDofs(self, i, dofs): r"""GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)""" return _fespace.FiniteElementSpace_GetFaceInteriorDofs(self, i, dofs) + GetFaceInteriorDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceInteriorDofs) def GetNumElementInteriorDofs(self, i): r"""GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetNumElementInteriorDofs(self, i) + GetNumElementInteriorDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNumElementInteriorDofs) def GetEdgeInteriorDofs(self, i): from .array import intArray @@ -359,19 +416,23 @@ def DofsToVDofs(self, *args): DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1) """ return _fespace.FiniteElementSpace_DofsToVDofs(self, *args) + DofsToVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_DofsToVDofs) def DofToVDof(self, dof, vd, ndofs=-1): r"""DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int""" return _fespace.FiniteElementSpace_DofToVDof(self, dof, vd, ndofs) + DofToVDof = _swig_new_instance_method(_fespace.FiniteElementSpace_DofToVDof) def VDofToDof(self, vdof): r"""VDofToDof(FiniteElementSpace self, int vdof) -> int""" return _fespace.FiniteElementSpace_VDofToDof(self, vdof) + VDofToDof = _swig_new_instance_method(_fespace.FiniteElementSpace_VDofToDof) @staticmethod def AdjustVDofs(vdofs): r"""AdjustVDofs(intArray vdofs)""" return _fespace.FiniteElementSpace_AdjustVDofs(vdofs) + AdjustVDofs = _swig_new_static_method(_fespace.FiniteElementSpace_AdjustVDofs) def GetElementVDofs(self, i): from .array import intArray @@ -432,100 +493,124 @@ def GetEdgeInteriorVDofs(self, i): def RebuildElementToDofTable(self): r"""RebuildElementToDofTable(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_RebuildElementToDofTable(self) + RebuildElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_RebuildElementToDofTable) def ReorderElementToDofTable(self): r"""ReorderElementToDofTable(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_ReorderElementToDofTable(self) + ReorderElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_ReorderElementToDofTable) def BuildDofToArrays(self): r"""BuildDofToArrays(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_BuildDofToArrays(self) + BuildDofToArrays = _swig_new_instance_method(_fespace.FiniteElementSpace_BuildDofToArrays) def GetElementToDofTable(self): r"""GetElementToDofTable(FiniteElementSpace self) -> Table""" return _fespace.FiniteElementSpace_GetElementToDofTable(self) + GetElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementToDofTable) def GetBdrElementToDofTable(self): r"""GetBdrElementToDofTable(FiniteElementSpace self) -> Table""" return _fespace.FiniteElementSpace_GetBdrElementToDofTable(self) + GetBdrElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementToDofTable) def GetElementForDof(self, i): r"""GetElementForDof(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetElementForDof(self, i) + GetElementForDof = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementForDof) def GetLocalDofForDof(self, i): r"""GetLocalDofForDof(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetLocalDofForDof(self, i) + GetLocalDofForDof = _swig_new_instance_method(_fespace.FiniteElementSpace_GetLocalDofForDof) def GetFE(self, i): r"""GetFE(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetFE(self, i) + GetFE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFE) def GetBE(self, i): r"""GetBE(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetBE(self, i) + GetBE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBE) def GetFaceElement(self, i): r"""GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetFaceElement(self, i) + GetFaceElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceElement) def GetEdgeElement(self, i): r"""GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetEdgeElement(self, i) + GetEdgeElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEdgeElement) def GetTraceElement(self, i, geom_type): r"""GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement""" return _fespace.FiniteElementSpace_GetTraceElement(self, i, geom_type) + GetTraceElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTraceElement) def GetEssentialVDofs(self, bdr_attr_is_ess, ess_vdofs, component=-1): r"""GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)""" return _fespace.FiniteElementSpace_GetEssentialVDofs(self, bdr_attr_is_ess, ess_vdofs, component) + GetEssentialVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEssentialVDofs) def GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component=-1): r"""GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)""" return _fespace.FiniteElementSpace_GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component) + GetEssentialTrueDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEssentialTrueDofs) @staticmethod def MarkerToList(marker, list): r"""MarkerToList(intArray marker, intArray list)""" return _fespace.FiniteElementSpace_MarkerToList(marker, list) + MarkerToList = _swig_new_static_method(_fespace.FiniteElementSpace_MarkerToList) @staticmethod def ListToMarker(list, marker_size, marker, mark_val=-1): r"""ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)""" return _fespace.FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val) + ListToMarker = _swig_new_static_method(_fespace.FiniteElementSpace_ListToMarker) def ConvertToConformingVDofs(self, dofs, cdofs): r"""ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)""" return _fespace.FiniteElementSpace_ConvertToConformingVDofs(self, dofs, cdofs) + ConvertToConformingVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_ConvertToConformingVDofs) def ConvertFromConformingVDofs(self, cdofs, dofs): r"""ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)""" return _fespace.FiniteElementSpace_ConvertFromConformingVDofs(self, cdofs, dofs) + ConvertFromConformingVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_ConvertFromConformingVDofs) def D2C_GlobalRestrictionMatrix(self, cfes): r"""D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix""" return _fespace.FiniteElementSpace_D2C_GlobalRestrictionMatrix(self, cfes) + D2C_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_D2C_GlobalRestrictionMatrix) def D2Const_GlobalRestrictionMatrix(self, cfes): r"""D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix""" return _fespace.FiniteElementSpace_D2Const_GlobalRestrictionMatrix(self, cfes) + D2Const_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_D2Const_GlobalRestrictionMatrix) def H2L_GlobalRestrictionMatrix(self, lfes): r"""H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix""" return _fespace.FiniteElementSpace_H2L_GlobalRestrictionMatrix(self, lfes) + H2L_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_H2L_GlobalRestrictionMatrix) def GetTransferOperator(self, coarse_fes, T): r"""GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)""" return _fespace.FiniteElementSpace_GetTransferOperator(self, coarse_fes, T) + GetTransferOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTransferOperator) def GetTrueTransferOperator(self, coarse_fes, T): r"""GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)""" return _fespace.FiniteElementSpace_GetTrueTransferOperator(self, coarse_fes, T) + GetTrueTransferOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTrueTransferOperator) def Update(self, want_transform=True): r"""Update(FiniteElementSpace self, bool want_transform=True)""" return _fespace.FiniteElementSpace_Update(self, want_transform) + Update = _swig_new_instance_method(_fespace.FiniteElementSpace_Update) def GetUpdateOperator(self, *args): r""" @@ -533,26 +618,32 @@ def GetUpdateOperator(self, *args): GetUpdateOperator(FiniteElementSpace self, OperatorHandle T) """ return _fespace.FiniteElementSpace_GetUpdateOperator(self, *args) + GetUpdateOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetUpdateOperator) def SetUpdateOperatorOwner(self, own): r"""SetUpdateOperatorOwner(FiniteElementSpace self, bool own)""" return _fespace.FiniteElementSpace_SetUpdateOperatorOwner(self, own) + SetUpdateOperatorOwner = _swig_new_instance_method(_fespace.FiniteElementSpace_SetUpdateOperatorOwner) def SetUpdateOperatorType(self, tid): r"""SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)""" return _fespace.FiniteElementSpace_SetUpdateOperatorType(self, tid) + SetUpdateOperatorType = _swig_new_instance_method(_fespace.FiniteElementSpace_SetUpdateOperatorType) def UpdatesFinished(self): r"""UpdatesFinished(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_UpdatesFinished(self) + UpdatesFinished = _swig_new_instance_method(_fespace.FiniteElementSpace_UpdatesFinished) def GetSequence(self): r"""GetSequence(FiniteElementSpace self) -> long""" return _fespace.FiniteElementSpace_GetSequence(self) + GetSequence = _swig_new_instance_method(_fespace.FiniteElementSpace_GetSequence) def Load(self, m, input): r"""Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection""" return _fespace.FiniteElementSpace_Load(self, m, input) + Load = _swig_new_instance_method(_fespace.FiniteElementSpace_Load) __swig_destroy__ = _fespace.delete_FiniteElementSpace def Save(self, *args): @@ -562,6 +653,7 @@ def Save(self, *args): Save(FiniteElementSpace self) """ return _fespace.FiniteElementSpace_Save(self, *args) + Save = _swig_new_instance_method(_fespace.FiniteElementSpace_Save) # Register FiniteElementSpace in _fespace: _fespace.FiniteElementSpace_swigregister(FiniteElementSpace) @@ -569,14 +661,17 @@ def Save(self, *args): def FiniteElementSpace_AdjustVDofs(vdofs): r"""FiniteElementSpace_AdjustVDofs(intArray vdofs)""" return _fespace.FiniteElementSpace_AdjustVDofs(vdofs) +FiniteElementSpace_AdjustVDofs = _fespace.FiniteElementSpace_AdjustVDofs def FiniteElementSpace_MarkerToList(marker, list): r"""FiniteElementSpace_MarkerToList(intArray marker, intArray list)""" return _fespace.FiniteElementSpace_MarkerToList(marker, list) +FiniteElementSpace_MarkerToList = _fespace.FiniteElementSpace_MarkerToList def FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val=-1): r"""FiniteElementSpace_ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)""" return _fespace.FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val) +FiniteElementSpace_ListToMarker = _fespace.FiniteElementSpace_ListToMarker class QuadratureSpace(object): r"""Proxy of C++ mfem::QuadratureSpace class.""" @@ -595,10 +690,12 @@ def __init__(self, *args): def GetSize(self): r"""GetSize(QuadratureSpace self) -> int""" return _fespace.QuadratureSpace_GetSize(self) + GetSize = _swig_new_instance_method(_fespace.QuadratureSpace_GetSize) def GetElementIntRule(self, idx): r"""GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule""" return _fespace.QuadratureSpace_GetElementIntRule(self, idx) + GetElementIntRule = _swig_new_instance_method(_fespace.QuadratureSpace_GetElementIntRule) def Save(self, *args): r""" @@ -607,6 +704,7 @@ def Save(self, *args): Save(QuadratureSpace self) """ return _fespace.QuadratureSpace_Save(self, *args) + Save = _swig_new_instance_method(_fespace.QuadratureSpace_Save) # Register QuadratureSpace in _fespace: _fespace.QuadratureSpace_swigregister(QuadratureSpace) @@ -624,22 +722,27 @@ def __init__(self, *args, **kwargs): def SetOperatorType(self, type): r"""SetOperatorType(GridTransfer self, mfem::Operator::Type type)""" return _fespace.GridTransfer_SetOperatorType(self, type) + SetOperatorType = _swig_new_instance_method(_fespace.GridTransfer_SetOperatorType) def ForwardOperator(self): r"""ForwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_ForwardOperator(self) + ForwardOperator = _swig_new_instance_method(_fespace.GridTransfer_ForwardOperator) def BackwardOperator(self): r"""BackwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_BackwardOperator(self) + BackwardOperator = _swig_new_instance_method(_fespace.GridTransfer_BackwardOperator) def TrueForwardOperator(self): r"""TrueForwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_TrueForwardOperator(self) + TrueForwardOperator = _swig_new_instance_method(_fespace.GridTransfer_TrueForwardOperator) def TrueBackwardOperator(self): r"""TrueBackwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_TrueBackwardOperator(self) + TrueBackwardOperator = _swig_new_instance_method(_fespace.GridTransfer_TrueBackwardOperator) # Register GridTransfer in _fespace: _fespace.GridTransfer_swigregister(GridTransfer) @@ -658,14 +761,17 @@ def __init__(self, coarse_fes, fine_fes): def SetMassIntegrator(self, mass_integ_, own_mass_integ_=True): r"""SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)""" return _fespace.InterpolationGridTransfer_SetMassIntegrator(self, mass_integ_, own_mass_integ_) + SetMassIntegrator = _swig_new_instance_method(_fespace.InterpolationGridTransfer_SetMassIntegrator) def ForwardOperator(self): r"""ForwardOperator(InterpolationGridTransfer self) -> Operator""" return _fespace.InterpolationGridTransfer_ForwardOperator(self) + ForwardOperator = _swig_new_instance_method(_fespace.InterpolationGridTransfer_ForwardOperator) def BackwardOperator(self): r"""BackwardOperator(InterpolationGridTransfer self) -> Operator""" return _fespace.InterpolationGridTransfer_BackwardOperator(self) + BackwardOperator = _swig_new_instance_method(_fespace.InterpolationGridTransfer_BackwardOperator) # Register InterpolationGridTransfer in _fespace: _fespace.InterpolationGridTransfer_swigregister(InterpolationGridTransfer) @@ -683,71 +789,21 @@ def __init__(self, coarse_fes, fine_fes): def ForwardOperator(self): r"""ForwardOperator(L2ProjectionGridTransfer self) -> Operator""" return _fespace.L2ProjectionGridTransfer_ForwardOperator(self) + ForwardOperator = _swig_new_instance_method(_fespace.L2ProjectionGridTransfer_ForwardOperator) def BackwardOperator(self): r"""BackwardOperator(L2ProjectionGridTransfer self) -> Operator""" return _fespace.L2ProjectionGridTransfer_BackwardOperator(self) + BackwardOperator = _swig_new_instance_method(_fespace.L2ProjectionGridTransfer_BackwardOperator) __swig_destroy__ = _fespace.delete_L2ProjectionGridTransfer # Register L2ProjectionGridTransfer in _fespace: _fespace.L2ProjectionGridTransfer_swigregister(L2ProjectionGridTransfer) -class ElementRestriction(mfem._par.operators.Operator): - r"""Proxy of C++ mfem::ElementRestriction class.""" - - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") - __repr__ = _swig_repr - - def __init__(self, arg2, arg3): - r"""__init__(ElementRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering arg3) -> ElementRestriction""" - _fespace.ElementRestriction_swiginit(self, _fespace.new_ElementRestriction(arg2, arg3)) - - def Mult(self, x, y): - r"""Mult(ElementRestriction self, Vector x, Vector y)""" - return _fespace.ElementRestriction_Mult(self, x, y) - - def MultTranspose(self, x, y): - r"""MultTranspose(ElementRestriction self, Vector x, Vector y)""" - return _fespace.ElementRestriction_MultTranspose(self, x, y) - __swig_destroy__ = _fespace.delete_ElementRestriction - -# Register ElementRestriction in _fespace: -_fespace.ElementRestriction_swigregister(ElementRestriction) - -class QuadratureInterpolator(object): - r"""Proxy of C++ mfem::QuadratureInterpolator class.""" - - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") - __repr__ = _swig_repr - VALUES = _fespace.QuadratureInterpolator_VALUES - - DERIVATIVES = _fespace.QuadratureInterpolator_DERIVATIVES - - DETERMINANTS = _fespace.QuadratureInterpolator_DETERMINANTS - - - def __init__(self, *args): - r""" - __init__(QuadratureInterpolator self, FiniteElementSpace fes, IntegrationRule ir) -> QuadratureInterpolator - __init__(QuadratureInterpolator self, FiniteElementSpace fes, QuadratureSpace qs) -> QuadratureInterpolator - """ - _fespace.QuadratureInterpolator_swiginit(self, _fespace.new_QuadratureInterpolator(*args)) - - def DisableTensorProducts(self, disable=True): - r"""DisableTensorProducts(QuadratureInterpolator self, bool disable=True)""" - return _fespace.QuadratureInterpolator_DisableTensorProducts(self, disable) - - def Mult(self, e_vec, eval_flags, q_val, q_der, q_det): - r"""Mult(QuadratureInterpolator self, Vector e_vec, unsigned int eval_flags, Vector q_val, Vector q_der, Vector q_det)""" - return _fespace.QuadratureInterpolator_Mult(self, e_vec, eval_flags, q_val, q_der, q_det) - - def MultTranspose(self, eval_flags, q_val, q_der, e_vec): - r"""MultTranspose(QuadratureInterpolator self, unsigned int eval_flags, Vector q_val, Vector q_der, Vector e_vec)""" - return _fespace.QuadratureInterpolator_MultTranspose(self, eval_flags, q_val, q_der, e_vec) - __swig_destroy__ = _fespace.delete_QuadratureInterpolator - -# Register QuadratureInterpolator in _fespace: -_fespace.QuadratureInterpolator_swigregister(QuadratureInterpolator) +def UsesTensorBasis(fes): + r"""UsesTensorBasis(FiniteElementSpace fes) -> bool""" + return _fespace.UsesTensorBasis(fes) +UsesTensorBasis = _fespace.UsesTensorBasis diff --git a/mfem/_par/fespace_wrap.cxx b/mfem/_par/fespace_wrap.cxx index 41b1f0df..affb4168 100644 --- a/mfem/_par/fespace_wrap.cxx +++ b/mfem/_par/fespace_wrap.cxx @@ -3067,280 +3067,288 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[7] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[8] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[12] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[13] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[16] -#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[17] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[18] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[20] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[22] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[23] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[24] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[25] -#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[26] -#define SWIGTYPE_p_mfem__CubicFECollection swig_types[27] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[29] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[31] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[32] -#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[33] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[34] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[35] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[36] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[38] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[39] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[40] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[41] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[42] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[43] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[44] -#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[45] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[46] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[47] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[48] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[49] -#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[50] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[51] -#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[52] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[53] -#define SWIGTYPE_p_mfem__GridFunction swig_types[54] -#define SWIGTYPE_p_mfem__GridTransfer swig_types[55] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[57] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[59] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[60] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[62] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[63] -#define SWIGTYPE_p_mfem__H1_FECollection swig_types[64] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[65] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[66] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[67] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[68] -#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[69] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[70] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[71] -#define SWIGTYPE_p_mfem__HypreADS swig_types[72] -#define SWIGTYPE_p_mfem__HypreAMS swig_types[73] -#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[74] -#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[75] -#define SWIGTYPE_p_mfem__HypreEuclid swig_types[76] -#define SWIGTYPE_p_mfem__HypreGMRES swig_types[77] -#define SWIGTYPE_p_mfem__HypreIdentity swig_types[78] -#define SWIGTYPE_p_mfem__HyprePCG swig_types[79] -#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[80] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[81] -#define SWIGTYPE_p_mfem__HypreParaSails swig_types[82] -#define SWIGTYPE_p_mfem__HypreSmoother swig_types[83] -#define SWIGTYPE_p_mfem__HypreSolver swig_types[84] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[85] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[86] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[87] -#define SWIGTYPE_p_mfem__InterpolationGridTransfer swig_types[88] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[90] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[91] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[92] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[93] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[94] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[95] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[96] -#define SWIGTYPE_p_mfem__L2ProjectionGridTransfer swig_types[97] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[98] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[99] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[100] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[101] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[102] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[103] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[104] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[109] -#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[110] -#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[111] -#define SWIGTYPE_p_mfem__LinearFECollection swig_types[112] -#define SWIGTYPE_p_mfem__LinearForm swig_types[113] -#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[114] -#define SWIGTYPE_p_mfem__Local_FECollection swig_types[115] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[116] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[117] -#define SWIGTYPE_p_mfem__Matrix swig_types[118] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[119] -#define SWIGTYPE_p_mfem__Mesh swig_types[120] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[121] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[122] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[123] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[124] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[125] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[126] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[127] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[128] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[129] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[130] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[131] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[132] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[133] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[134] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[135] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[136] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[137] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[138] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[139] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[140] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[141] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[142] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[143] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[144] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[145] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[146] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[147] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[148] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[149] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[150] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[151] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[152] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[153] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[154] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[155] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[156] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[157] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[158] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[159] -#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[160] -#define SWIGTYPE_p_mfem__ND_FECollection swig_types[161] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[162] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[163] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[164] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[165] -#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[166] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[167] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[168] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[169] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[170] -#define SWIGTYPE_p_mfem__NURBSExtension swig_types[171] -#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[172] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[173] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[174] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[175] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[176] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[177] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[178] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[179] -#define SWIGTYPE_p_mfem__Operator swig_types[180] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[181] -#define SWIGTYPE_p_mfem__Ordering swig_types[182] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[183] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[184] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[185] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[186] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[187] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[188] -#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[189] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[190] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[191] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[192] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[193] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[194] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[195] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[196] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[197] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[198] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[199] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[200] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[201] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[202] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[203] -#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[204] -#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[205] -#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[206] -#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[207] -#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[208] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[209] -#define SWIGTYPE_p_mfem__QuadratureInterpolator swig_types[210] -#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[211] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[212] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[213] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[214] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[215] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[216] -#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[217] -#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[218] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[219] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[220] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[221] -#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[222] -#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[223] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[224] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[225] -#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[226] -#define SWIGTYPE_p_mfem__RT_FECollection swig_types[227] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[228] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[229] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[230] -#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[231] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[232] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[233] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[234] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[235] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[236] -#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[237] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[238] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[239] -#define SWIGTYPE_p_mfem__STable swig_types[240] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[241] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[242] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[243] -#define SWIGTYPE_p_mfem__Solver swig_types[244] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[245] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[246] -#define SWIGTYPE_p_mfem__Table swig_types[247] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[248] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[249] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[250] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[251] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[252] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[253] -#define SWIGTYPE_p_mfem__Vector swig_types[254] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[255] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[256] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[257] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[258] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[259] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[260] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[261] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[262] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[263] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[264] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[265] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[266] -#define SWIGTYPE_p_pri_t swig_types[267] -#define SWIGTYPE_p_quad_t swig_types[268] -#define SWIGTYPE_p_seg_t swig_types[269] -#define SWIGTYPE_p_std__istream swig_types[270] -#define SWIGTYPE_p_tet_t swig_types[271] -#define SWIGTYPE_p_tri_t swig_types[272] -#define SWIGTYPE_p_void swig_types[273] -static swig_type_info *swig_types[275]; -static swig_module_info swig_module = {swig_types, 274, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[8] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[9] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[13] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[14] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[17] +#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[18] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[19] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[21] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[24] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[25] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[26] +#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[27] +#define SWIGTYPE_p_mfem__CubicFECollection swig_types[28] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[29] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[30] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[34] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[35] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[36] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[37] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[39] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[40] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[41] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[42] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[43] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[44] +#define SWIGTYPE_p_mfem__FaceQuadratureInterpolator swig_types[45] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[46] +#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[47] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[48] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[49] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[50] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[51] +#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[52] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[53] +#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[54] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[56] +#define SWIGTYPE_p_mfem__GridFunction swig_types[57] +#define SWIGTYPE_p_mfem__GridTransfer swig_types[58] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[60] +#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[61] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[63] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[64] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[65] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[66] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[67] +#define SWIGTYPE_p_mfem__H1Ser_FECollection swig_types[68] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[69] +#define SWIGTYPE_p_mfem__H1_FECollection swig_types[70] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[71] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[72] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[73] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[74] +#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[75] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[76] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[77] +#define SWIGTYPE_p_mfem__HypreADS swig_types[78] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[79] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[80] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[81] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[82] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[83] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[84] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[85] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[86] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[87] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[88] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[89] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[90] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[91] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[92] +#define SWIGTYPE_p_mfem__InterpolationGridTransfer swig_types[93] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[95] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[96] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[97] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[98] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[99] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[100] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[101] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[102] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[103] +#define SWIGTYPE_p_mfem__L2ProjectionGridTransfer swig_types[104] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[105] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[106] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[107] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[108] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[109] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[110] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[111] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[112] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[117] +#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[118] +#define SWIGTYPE_p_mfem__LinearFECollection swig_types[119] +#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[120] +#define SWIGTYPE_p_mfem__Local_FECollection swig_types[121] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[122] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[123] +#define SWIGTYPE_p_mfem__Matrix swig_types[124] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[125] +#define SWIGTYPE_p_mfem__Mesh swig_types[126] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[127] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[128] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[129] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[130] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[131] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[132] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[133] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[134] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[135] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[136] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[137] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[138] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[139] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[140] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[141] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[142] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[143] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[144] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[145] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[146] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[147] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[148] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[149] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[150] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[151] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[152] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[153] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[154] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[155] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[156] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[157] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[158] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[159] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[160] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[161] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[162] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[163] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[164] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[165] +#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[166] +#define SWIGTYPE_p_mfem__ND_FECollection swig_types[167] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[168] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[169] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[170] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[171] +#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[172] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[173] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[174] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[175] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[176] +#define SWIGTYPE_p_mfem__NURBSExtension swig_types[177] +#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[178] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[179] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[180] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[181] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[182] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[183] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[184] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[185] +#define SWIGTYPE_p_mfem__Operator swig_types[186] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[187] +#define SWIGTYPE_p_mfem__Ordering swig_types[188] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[189] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[190] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[191] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[192] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[193] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[194] +#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[195] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[196] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[197] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[198] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[199] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[200] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[201] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[202] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[203] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[204] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[205] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[206] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[207] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[208] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[209] +#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[210] +#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[211] +#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[212] +#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[213] +#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[214] +#define SWIGTYPE_p_mfem__QuadratureInterpolator swig_types[215] +#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[216] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[217] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[218] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[219] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[220] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[221] +#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[222] +#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[223] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[224] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[225] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[226] +#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[227] +#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[228] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[229] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[230] +#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[231] +#define SWIGTYPE_p_mfem__RT_FECollection swig_types[232] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[233] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[234] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[235] +#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[236] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[237] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[238] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[239] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[240] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[241] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[242] +#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[243] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[244] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[245] +#define SWIGTYPE_p_mfem__STable swig_types[246] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[247] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[248] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[249] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[250] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[251] +#define SWIGTYPE_p_mfem__Solver swig_types[252] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[253] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[254] +#define SWIGTYPE_p_mfem__Table swig_types[255] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[256] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[257] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[258] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[259] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[260] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[261] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[262] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[263] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[264] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[265] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[266] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[267] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[268] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[269] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[270] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[271] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[272] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[273] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[274] +#define SWIGTYPE_p_pri_t swig_types[275] +#define SWIGTYPE_p_quad_t swig_types[276] +#define SWIGTYPE_p_seg_t swig_types[277] +#define SWIGTYPE_p_std__istream swig_types[278] +#define SWIGTYPE_p_tet_t swig_types[279] +#define SWIGTYPE_p_tri_t swig_types[280] +#define SWIGTYPE_p_void swig_types[281] +static swig_type_info *swig_types[283]; +static swig_module_info swig_module = {swig_types, 282, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3457,6 +3465,7 @@ namespace swig { #include "fem/eltrans.hpp" #include "fem/coefficient.hpp" #include "fem/intrules.hpp" +#include "fem/restriction.hpp" #include "io_stream.hpp" #include "numpy/arrayobject.h" #include "pyoperator.hpp" @@ -3795,70 +3804,6 @@ SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_3(mfem::QuadratureSpace *self){ self -> Save(std::cout); } -SWIGINTERN int -SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) -{ -#if PY_VERSION_HEX < 0x03000000 - if (PyInt_Check(obj)) { - long v = PyInt_AsLong(obj); - if (v >= 0) { - if (val) *val = v; - return SWIG_OK; - } else { - return SWIG_OverflowError; - } - } else -#endif - if (PyLong_Check(obj)) { - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - return SWIG_OverflowError; - } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); - } - if (!dispatch) { - double d; - int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { - if (val) *val = (unsigned long)(d); - return res; - } - } - } -#endif - return SWIG_TypeError; -} - - -SWIGINTERN int -SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) -{ - unsigned long v; - int res = SWIG_AsVal_unsigned_SS_long (obj, &v); - if (SWIG_IsOK(res)) { - if ((v > UINT_MAX)) { - return SWIG_OverflowError; - } else { - if (val) *val = static_cast< unsigned int >(v); - } - } - return res; -} - - /* --------------------------------------------------- * C++ director class methods @@ -4944,6 +4889,168 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SW } +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + mfem::L2FaceValues arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); + { + try { + result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceRestriction", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetFaceRestriction'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues) const\n" + " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType) const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -5066,6 +5173,54 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator(PyObject } +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::FaceQuadratureInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceQuadratureInterpolator", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::FaceQuadratureInterpolator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceQuadratureInterpolator((mfem::IntegrationRule const &)*arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceQuadratureInterpolator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -5588,6 +5743,43 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNBE(PyObject *SWIGUNUSEDPARM(se } +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::FaceType arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); + { + try { + result = (int)((mfem::FiniteElementSpace const *)arg1)->GetNFbyType(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -10288,607 +10480,42 @@ SWIGINTERN PyObject *L2ProjectionGridTransfer_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_UsesTensorBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; - mfem::ElementDofOrdering arg2 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::ElementRestriction *result = 0 ; + PyObject *swig_obj[1] ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "new_ElementRestriction", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsesTensorBasis" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UsesTensorBasis" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - { - try { - result = (mfem::ElementRestriction *)new mfem::ElementRestriction((mfem::FiniteElementSpace const &)*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); - } - arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::ElementRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); - } - arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::ElementRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElementRestriction" "', argument " "1"" of type '" "mfem::ElementRestriction *""'"); - } - arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ElementRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElementRestriction, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_QuadratureInterpolator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::IntegrationRule *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::QuadratureInterpolator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - result = (mfem::QuadratureInterpolator *)new mfem::QuadratureInterpolator((mfem::FiniteElementSpace const &)*arg1,(mfem::IntegrationRule const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_QuadratureInterpolator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::QuadratureSpace *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::QuadratureInterpolator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::QuadratureSpace const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::QuadratureSpace const &""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); - { - try { - result = (mfem::QuadratureInterpolator *)new mfem::QuadratureInterpolator((mfem::FiniteElementSpace const &)*arg1,(mfem::QuadratureSpace const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_QuadratureInterpolator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuadratureInterpolator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureInterpolator__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureInterpolator__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuadratureInterpolator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureInterpolator::QuadratureInterpolator(mfem::FiniteElementSpace const &,mfem::IntegrationRule const &)\n" - " mfem::QuadratureInterpolator::QuadratureInterpolator(mfem::FiniteElementSpace const &,mfem::QuadratureSpace const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_DisableTensorProducts" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureInterpolator_DisableTensorProducts" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - ((mfem::QuadratureInterpolator const *)arg1)->DisableTensorProducts(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_DisableTensorProducts" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - { - try { - ((mfem::QuadratureInterpolator const *)arg1)->DisableTensorProducts(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_DisableTensorProducts(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureInterpolator_DisableTensorProducts", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureInterpolator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureInterpolator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureInterpolator_DisableTensorProducts'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureInterpolator::DisableTensorProducts(bool) const\n" - " mfem::QuadratureInterpolator::DisableTensorProducts() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - mfem::Vector *arg2 = 0 ; - unsigned int arg3 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - unsigned int val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject *swig_obj[6] ; - - if (!SWIG_Python_UnpackTuple(args, "QuadratureInterpolator_Mult", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_Mult" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureInterpolator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuadratureInterpolator_Mult" "', argument " "3"" of type '" "unsigned int""'"); - } - arg3 = static_cast< unsigned int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuadratureInterpolator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "QuadratureInterpolator_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "QuadratureInterpolator_Mult" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - ((mfem::QuadratureInterpolator const *)arg1)->Mult((mfem::Vector const &)*arg2,arg3,*arg4,*arg5,*arg6); + result = (bool)mfem::UsesTensorBasis((mfem::FiniteElementSpace const &)*arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - unsigned int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "QuadratureInterpolator_MultTranspose", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "2"" of type '" "unsigned int""'"); - } - arg2 = static_cast< unsigned int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - ((mfem::QuadratureInterpolator const *)arg1)->MultTranspose(arg2,(mfem::Vector const &)*arg3,(mfem::Vector const &)*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_QuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::QuadratureInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *QuadratureInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *QuadratureInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Ordering", _wrap_new_Ordering, METH_NOARGS, "new_Ordering() -> Ordering"}, { "delete_Ordering", _wrap_delete_Ordering, METH_O, "delete_Ordering(Ordering self)"}, { "Ordering_swigregister", Ordering_swigregister, METH_O, NULL}, @@ -10912,10 +10539,12 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "FiniteElementSpace_GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "FiniteElementSpace_GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "FiniteElementSpace_GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "FiniteElementSpace_GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" - "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> QuadratureInterpolator\n" - "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> QuadratureInterpolator\n" + "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" + "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" ""}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "FiniteElementSpace_GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "FiniteElementSpace_GetVDim(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "FiniteElementSpace_GetOrder(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "FiniteElementSpace_GetFaceOrder(FiniteElementSpace self, int i) -> int"}, @@ -10933,6 +10562,7 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "FiniteElementSpace_GetNE(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "FiniteElementSpace_GetNF(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "FiniteElementSpace_GetNBE(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "FiniteElementSpace_GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "FiniteElementSpace_GetElementType(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "FiniteElementSpace_GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "FiniteElementSpace_GetBdrElementType(FiniteElementSpace self, int i) -> int"}, @@ -11041,26 +10671,169 @@ static PyMethodDef SwigMethods[] = { { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, - { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, - { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, - { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, - { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, - { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_QuadratureInterpolator", _wrap_new_QuadratureInterpolator, METH_VARARGS, "\n" - "QuadratureInterpolator(FiniteElementSpace fes, IntegrationRule ir)\n" - "new_QuadratureInterpolator(FiniteElementSpace fes, QuadratureSpace qs) -> QuadratureInterpolator\n" - ""}, - { "QuadratureInterpolator_DisableTensorProducts", _wrap_QuadratureInterpolator_DisableTensorProducts, METH_VARARGS, "QuadratureInterpolator_DisableTensorProducts(QuadratureInterpolator self, bool disable=True)"}, - { "QuadratureInterpolator_Mult", _wrap_QuadratureInterpolator_Mult, METH_VARARGS, "QuadratureInterpolator_Mult(QuadratureInterpolator self, Vector e_vec, unsigned int eval_flags, Vector q_val, Vector q_der, Vector q_det)"}, - { "QuadratureInterpolator_MultTranspose", _wrap_QuadratureInterpolator_MultTranspose, METH_VARARGS, "QuadratureInterpolator_MultTranspose(QuadratureInterpolator self, unsigned int eval_flags, Vector q_val, Vector q_der, Vector e_vec)"}, - { "delete_QuadratureInterpolator", _wrap_delete_QuadratureInterpolator, METH_O, "delete_QuadratureInterpolator(QuadratureInterpolator self)"}, - { "QuadratureInterpolator_swigregister", QuadratureInterpolator_swigregister, METH_O, NULL}, - { "QuadratureInterpolator_swiginit", QuadratureInterpolator_swiginit, METH_VARARGS, NULL}, + { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Ordering", _wrap_new_Ordering, METH_NOARGS, "new_Ordering() -> Ordering"}, + { "delete_Ordering", _wrap_delete_Ordering, METH_O, "delete_Ordering(Ordering self)"}, + { "Ordering_swigregister", Ordering_swigregister, METH_O, NULL}, + { "Ordering_swiginit", Ordering_swiginit, METH_VARARGS, NULL}, + { "new_FiniteElementSpace", _wrap_new_FiniteElementSpace, METH_VARARGS, "\n" + "FiniteElementSpace()\n" + "FiniteElementSpace(FiniteElementSpace orig, Mesh mesh=None, FiniteElementCollection fec=None)\n" + "FiniteElementSpace(Mesh mesh, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + "FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + ""}, + { "FiniteElementSpace_GetMesh", _wrap_FiniteElementSpace_GetMesh, METH_O, "GetMesh(FiniteElementSpace self) -> Mesh"}, + { "FiniteElementSpace_GetNURBSext", _wrap_FiniteElementSpace_GetNURBSext, METH_VARARGS, "\n" + "GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension const\n" + "GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *\n" + ""}, + { "FiniteElementSpace_StealNURBSext", _wrap_FiniteElementSpace_StealNURBSext, METH_O, "StealNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *"}, + { "FiniteElementSpace_Conforming", _wrap_FiniteElementSpace_Conforming, METH_O, "Conforming(FiniteElementSpace self) -> bool"}, + { "FiniteElementSpace_Nonconforming", _wrap_FiniteElementSpace_Nonconforming, METH_O, "Nonconforming(FiniteElementSpace self) -> bool"}, + { "FiniteElementSpace_GetConformingProlongation", _wrap_FiniteElementSpace_GetConformingProlongation, METH_O, "GetConformingProlongation(FiniteElementSpace self) -> SparseMatrix"}, + { "FiniteElementSpace_GetConformingRestriction", _wrap_FiniteElementSpace_GetConformingRestriction, METH_O, "GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix"}, + { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, + { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, + { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" + "GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" + "GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" + ""}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, + { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "GetVDim(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "GetOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "GetFaceOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetNDofs", _wrap_FiniteElementSpace_GetNDofs, METH_O, "GetNDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetVSize", _wrap_FiniteElementSpace_GetVSize, METH_O, "GetVSize(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetTrueVSize", _wrap_FiniteElementSpace_GetTrueVSize, METH_O, "GetTrueVSize(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNConformingDofs", _wrap_FiniteElementSpace_GetNConformingDofs, METH_O, "GetNConformingDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetConformingVSize", _wrap_FiniteElementSpace_GetConformingVSize, METH_O, "GetConformingVSize(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetOrdering", _wrap_FiniteElementSpace_GetOrdering, METH_O, "GetOrdering(FiniteElementSpace self) -> mfem::Ordering::Type"}, + { "FiniteElementSpace_FEColl", _wrap_FiniteElementSpace_FEColl, METH_O, "FEColl(FiniteElementSpace self) -> FiniteElementCollection"}, + { "FiniteElementSpace_GetNVDofs", _wrap_FiniteElementSpace_GetNVDofs, METH_O, "GetNVDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNEDofs", _wrap_FiniteElementSpace_GetNEDofs, METH_O, "GetNEDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNFDofs", _wrap_FiniteElementSpace_GetNFDofs, METH_O, "GetNFDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNV", _wrap_FiniteElementSpace_GetNV, METH_O, "GetNV(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "GetNE(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "GetNF(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "GetNBE(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, + { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "GetElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, + { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "GetBdrElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementTransformation", _wrap_FiniteElementSpace_GetElementTransformation, METH_VARARGS, "\n" + "GetElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation\n" + "GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr)\n" + ""}, + { "FiniteElementSpace_GetBdrElementTransformation", _wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS, "GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, + { "FiniteElementSpace_GetAttribute", _wrap_FiniteElementSpace_GetAttribute, METH_VARARGS, "GetAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetBdrAttribute", _wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementDofs", _wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS, "GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementDofs", _wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceDofs", _wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetEdgeDofs", _wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS, "GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetVertexDofs", _wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS, "GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetElementInteriorDofs", _wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS, "GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceInteriorDofs", _wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS, "GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetNumElementInteriorDofs", _wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS, "GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetEdgeInteriorDofs", _wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS, "GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_DofsToVDofs", _wrap_FiniteElementSpace_DofsToVDofs, METH_VARARGS, "\n" + "DofsToVDofs(FiniteElementSpace self, intArray dofs, int ndofs=-1)\n" + "DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)\n" + ""}, + { "FiniteElementSpace_DofToVDof", _wrap_FiniteElementSpace_DofToVDof, METH_VARARGS, "DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, + { "FiniteElementSpace_VDofToDof", _wrap_FiniteElementSpace_VDofToDof, METH_VARARGS, "VDofToDof(FiniteElementSpace self, int vdof) -> int"}, + { "FiniteElementSpace_AdjustVDofs", _wrap_FiniteElementSpace_AdjustVDofs, METH_O, "AdjustVDofs(intArray vdofs)"}, + { "FiniteElementSpace_GetElementVDofs", _wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS, "GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetBdrElementVDofs", _wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS, "GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetFaceVDofs", _wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS, "GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeVDofs", _wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS, "GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetVertexVDofs", _wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS, "GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetElementInteriorVDofs", _wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS, "GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeInteriorVDofs", _wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS, "GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_RebuildElementToDofTable", _wrap_FiniteElementSpace_RebuildElementToDofTable, METH_O, "RebuildElementToDofTable(FiniteElementSpace self)"}, + { "FiniteElementSpace_ReorderElementToDofTable", _wrap_FiniteElementSpace_ReorderElementToDofTable, METH_O, "ReorderElementToDofTable(FiniteElementSpace self)"}, + { "FiniteElementSpace_BuildDofToArrays", _wrap_FiniteElementSpace_BuildDofToArrays, METH_O, "BuildDofToArrays(FiniteElementSpace self)"}, + { "FiniteElementSpace_GetElementToDofTable", _wrap_FiniteElementSpace_GetElementToDofTable, METH_O, "GetElementToDofTable(FiniteElementSpace self) -> Table"}, + { "FiniteElementSpace_GetBdrElementToDofTable", _wrap_FiniteElementSpace_GetBdrElementToDofTable, METH_O, "GetBdrElementToDofTable(FiniteElementSpace self) -> Table"}, + { "FiniteElementSpace_GetElementForDof", _wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS, "GetElementForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetLocalDofForDof", _wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS, "GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFE", _wrap_FiniteElementSpace_GetFE, METH_VARARGS, "GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetBE", _wrap_FiniteElementSpace_GetBE, METH_VARARGS, "GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetFaceElement", _wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS, "GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetEdgeElement", _wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS, "GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetTraceElement", _wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS, "GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, + { "FiniteElementSpace_GetEssentialVDofs", _wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, + { "FiniteElementSpace_GetEssentialTrueDofs", _wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "FiniteElementSpace_MarkerToList", _wrap_FiniteElementSpace_MarkerToList, METH_VARARGS, "MarkerToList(intArray marker, intArray list)"}, + { "FiniteElementSpace_ListToMarker", _wrap_FiniteElementSpace_ListToMarker, METH_VARARGS, "ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, + { "FiniteElementSpace_ConvertToConformingVDofs", _wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS, "ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, + { "FiniteElementSpace_ConvertFromConformingVDofs", _wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS, "ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, + { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS, "D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS, "D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS, "H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, + { "FiniteElementSpace_GetTransferOperator", _wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS, "GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_GetTrueTransferOperator", _wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_Update", _wrap_FiniteElementSpace_Update, METH_VARARGS, "Update(FiniteElementSpace self, bool want_transform=True)"}, + { "FiniteElementSpace_GetUpdateOperator", _wrap_FiniteElementSpace_GetUpdateOperator, METH_VARARGS, "\n" + "GetUpdateOperator(FiniteElementSpace self) -> Operator\n" + "GetUpdateOperator(FiniteElementSpace self, OperatorHandle T)\n" + ""}, + { "FiniteElementSpace_SetUpdateOperatorOwner", _wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS, "SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, + { "FiniteElementSpace_SetUpdateOperatorType", _wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS, "SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, + { "FiniteElementSpace_UpdatesFinished", _wrap_FiniteElementSpace_UpdatesFinished, METH_O, "UpdatesFinished(FiniteElementSpace self)"}, + { "FiniteElementSpace_GetSequence", _wrap_FiniteElementSpace_GetSequence, METH_O, "GetSequence(FiniteElementSpace self) -> long"}, + { "FiniteElementSpace_Load", _wrap_FiniteElementSpace_Load, METH_VARARGS, "Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, + { "delete_FiniteElementSpace", _wrap_delete_FiniteElementSpace, METH_O, "delete_FiniteElementSpace(FiniteElementSpace self)"}, + { "FiniteElementSpace_Save", _wrap_FiniteElementSpace_Save, METH_VARARGS, "\n" + "Save(FiniteElementSpace self, std::ostream & out)\n" + "Save(FiniteElementSpace self, char const * file, int precision=8)\n" + "Save(FiniteElementSpace self)\n" + ""}, + { "FiniteElementSpace_swigregister", FiniteElementSpace_swigregister, METH_O, NULL}, + { "FiniteElementSpace_swiginit", FiniteElementSpace_swiginit, METH_VARARGS, NULL}, + { "new_QuadratureSpace", _wrap_new_QuadratureSpace, METH_VARARGS, "\n" + "QuadratureSpace(Mesh mesh_, int order_)\n" + "new_QuadratureSpace(Mesh mesh_, std::istream & _in) -> QuadratureSpace\n" + ""}, + { "delete_QuadratureSpace", _wrap_delete_QuadratureSpace, METH_O, "delete_QuadratureSpace(QuadratureSpace self)"}, + { "QuadratureSpace_GetSize", _wrap_QuadratureSpace_GetSize, METH_O, "GetSize(QuadratureSpace self) -> int"}, + { "QuadratureSpace_GetElementIntRule", _wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, + { "QuadratureSpace_Save", _wrap_QuadratureSpace_Save, METH_VARARGS, "\n" + "Save(QuadratureSpace self, std::ostream & out)\n" + "Save(QuadratureSpace self, char const * file, int precision=8)\n" + "Save(QuadratureSpace self)\n" + ""}, + { "QuadratureSpace_swigregister", QuadratureSpace_swigregister, METH_O, NULL}, + { "QuadratureSpace_swiginit", QuadratureSpace_swiginit, METH_VARARGS, NULL}, + { "delete_GridTransfer", _wrap_delete_GridTransfer, METH_O, "delete_GridTransfer(GridTransfer self)"}, + { "GridTransfer_SetOperatorType", _wrap_GridTransfer_SetOperatorType, METH_VARARGS, "SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, + { "GridTransfer_ForwardOperator", _wrap_GridTransfer_ForwardOperator, METH_O, "ForwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_BackwardOperator", _wrap_GridTransfer_BackwardOperator, METH_O, "BackwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_TrueForwardOperator", _wrap_GridTransfer_TrueForwardOperator, METH_O, "TrueForwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_TrueBackwardOperator", _wrap_GridTransfer_TrueBackwardOperator, METH_O, "TrueBackwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_swigregister", GridTransfer_swigregister, METH_O, NULL}, + { "new_InterpolationGridTransfer", _wrap_new_InterpolationGridTransfer, METH_VARARGS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, + { "delete_InterpolationGridTransfer", _wrap_delete_InterpolationGridTransfer, METH_O, "delete_InterpolationGridTransfer(InterpolationGridTransfer self)"}, + { "InterpolationGridTransfer_SetMassIntegrator", _wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS, "SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, + { "InterpolationGridTransfer_ForwardOperator", _wrap_InterpolationGridTransfer_ForwardOperator, METH_O, "ForwardOperator(InterpolationGridTransfer self) -> Operator"}, + { "InterpolationGridTransfer_BackwardOperator", _wrap_InterpolationGridTransfer_BackwardOperator, METH_O, "BackwardOperator(InterpolationGridTransfer self) -> Operator"}, + { "InterpolationGridTransfer_swigregister", InterpolationGridTransfer_swigregister, METH_O, NULL}, + { "InterpolationGridTransfer_swiginit", InterpolationGridTransfer_swiginit, METH_VARARGS, NULL}, + { "new_L2ProjectionGridTransfer", _wrap_new_L2ProjectionGridTransfer, METH_VARARGS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, + { "L2ProjectionGridTransfer_ForwardOperator", _wrap_L2ProjectionGridTransfer_ForwardOperator, METH_O, "ForwardOperator(L2ProjectionGridTransfer self) -> Operator"}, + { "L2ProjectionGridTransfer_BackwardOperator", _wrap_L2ProjectionGridTransfer_BackwardOperator, METH_O, "BackwardOperator(L2ProjectionGridTransfer self) -> Operator"}, + { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, + { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, + { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, + { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; @@ -11133,6 +10906,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -11262,9 +11038,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -11289,15 +11062,15 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } static void *_p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorInnerProductInterpolator *) x)); } -static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); -} static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); } @@ -11355,12 +11128,18 @@ static void *_p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollect static void *_p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::CrouzeixRaviartFECollection *) x)); } +static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +} static void *_p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::H1_FECollection *) x)); } static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -11394,95 +11173,113 @@ static void *_p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection(vo static void *_p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::QuadraticPosFECollection *) x)); } -static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); } static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::Local_FECollection *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } -static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); } -static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } -static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); +static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +} +static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +} +static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); } static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); } -static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } -static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +} +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +} +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); } static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } -static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); } -static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); +static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); } -static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); +static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); } -static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); +static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); } -static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); } static void *_p_mfem__HypreSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSmoother *) x)); @@ -11493,12 +11290,6 @@ static void *_p_mfem__InterpolationGridTransferTo_p_mfem__GridTransfer(void *x, static void *_p_mfem__L2ProjectionGridTransferTo_p_mfem__GridTransfer(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::GridTransfer *) ((mfem::L2ProjectionGridTransfer *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -11532,6 +11323,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -11547,6 +11341,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -11715,6 +11512,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -11758,10 +11561,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -11790,26 +11593,14 @@ static void *_p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformatio static void *_p_mfem__STableTo_p_mfem__Table(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Table *) ((mfem::STable *) x)); } -static void *_p_mfem__HypreParVectorTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::HypreParVector *) x)); -} -static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); -} -static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); -} -static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); -} static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -11820,6 +11611,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -11841,6 +11633,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -11873,8 +11666,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -11883,10 +11675,11 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", "mfem::ElementRestriction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ElementTransformation = {"_p_mfem__ElementTransformation", "mfem::ElementTransformation *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FaceQuadratureInterpolator = {"_p_mfem__FaceQuadratureInterpolator", "mfem::FaceQuadratureInterpolator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FiniteElement = {"_p_mfem__FiniteElement", "mfem::FiniteElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__P0HexFiniteElement = {"_p_mfem__P0HexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LagrangeHexFiniteElement = {"_p_mfem__LagrangeHexFiniteElement", 0, 0, 0, 0, 0}; @@ -11903,13 +11696,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -11921,6 +11712,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -11962,6 +11755,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -11986,6 +11781,7 @@ static swig_type_info _swigt__p_mfem__NURBS1DFiniteElement = {"_p_mfem__NURBS1DF static swig_type_info _swigt__p_mfem__NURBS2DFiniteElement = {"_p_mfem__NURBS2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS3DFiniteElement = {"_p_mfem__NURBS3DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementCollection = {"_p_mfem__FiniteElementCollection", "mfem::FiniteElementCollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GaussLinearDiscont2DFECollection = {"_p_mfem__GaussLinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1OnQuadFECollection = {"_p_mfem__P1OnQuadFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticDiscont2DFECollection = {"_p_mfem__QuadraticDiscont2DFECollection", 0, 0, 0, 0, 0}; @@ -11998,15 +11794,13 @@ static swig_type_info _swigt__p_mfem__QuadraticDiscont3DFECollection = {"_p_mfem static swig_type_info _swigt__p_mfem__RefinedLinearFECollection = {"_p_mfem__RefinedLinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ND1_3DFECollection = {"_p_mfem__ND1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_3DFECollection = {"_p_mfem__RT0_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Const2DFECollection = {"_p_mfem__Const2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT2_2DFECollection = {"_p_mfem__RT2_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1_2DFECollection = {"_p_mfem__RT1_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_2DFECollection = {"_p_mfem__RT0_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearNonConf3DFECollection = {"_p_mfem__LinearNonConf3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CrouzeixRaviartFECollection = {"_p_mfem__CrouzeixRaviartFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticFECollection = {"_p_mfem__QuadraticFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearFECollection = {"_p_mfem__LinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBSFECollection = {"_p_mfem__NURBSFECollection", 0, 0, 0, 0, 0}; @@ -12016,9 +11810,11 @@ static swig_type_info _swigt__p_mfem__DG_Interface_FECollection = {"_p_mfem__DG_ static swig_type_info _swigt__p_mfem__RT_Trace_FECollection = {"_p_mfem__RT_Trace_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT_FECollection = {"_p_mfem__RT_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_Trace_FECollection = {"_p_mfem__H1_Trace_FECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_FECollection = {"_p_mfem__H1Ser_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_FECollection = {"_p_mfem__H1Pos_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_FECollection = {"_p_mfem__H1_FECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Local_FECollection = {"_p_mfem__Local_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; @@ -12031,32 +11827,39 @@ static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollecti static swig_type_info _swigt__p_mfem__Mesh = {"_p_mfem__Mesh", "mfem::Mesh *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__NURBSExtension = {"_p_mfem__NURBSExtension", "mfem::NURBSExtension *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreParMatrix = {"_p_mfem__HypreParMatrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParMatrix = {"_p_mfem__HypreParMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreSmoother = {"_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Ordering = {"_p_mfem__Ordering", "mfem::Ordering *", 0, 0, (void*)0, 0}; @@ -12065,10 +11868,6 @@ static swig_type_info _swigt__p_mfem__QuadratureSpace = {"_p_mfem__QuadratureSpa static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Table = {"_p_mfem__Table", "mfem::Table *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__STable = {"_p_mfem__STable", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__HypreParVector = {"_p_mfem__HypreParVector", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; @@ -12080,6 +11879,7 @@ static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -12122,6 +11922,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__ElementTransformation, + &_swigt__p_mfem__FaceQuadratureInterpolator, &_swigt__p_mfem__FiniteElement, &_swigt__p_mfem__FiniteElementCollection, &_swigt__p_mfem__FiniteElementSpace, @@ -12131,10 +11932,12 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__GaussLinearDiscont2DFECollection, &_swigt__p_mfem__GaussQuad2DFiniteElement, &_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GridTransfer, &_swigt__p_mfem__GroupConvectionIntegrator, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__H1Pos_FECollection, &_swigt__p_mfem__H1Pos_HexahedronElement, &_swigt__p_mfem__H1Pos_QuadrilateralElement, @@ -12142,6 +11945,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_FECollection, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_FECollection, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, @@ -12159,7 +11964,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__HypreIdentity, &_swigt__p_mfem__HyprePCG, &_swigt__p_mfem__HypreParMatrix, - &_swigt__p_mfem__HypreParVector, &_swigt__p_mfem__HypreParaSails, &_swigt__p_mfem__HypreSmoother, &_swigt__p_mfem__HypreSolver, @@ -12169,6 +11973,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__InterpolationGridTransfer, &_swigt__p_mfem__InverseIntegrator, &_swigt__p_mfem__IsoparametricTransformation, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2Pos_HexahedronElement, &_swigt__p_mfem__L2Pos_QuadrilateralElement, &_swigt__p_mfem__L2Pos_SegmentElement, @@ -12191,7 +11997,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__LinearDiscont2DFECollection, &_swigt__p_mfem__LinearDiscont3DFECollection, &_swigt__p_mfem__LinearFECollection, - &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__LinearNonConf3DFECollection, &_swigt__p_mfem__Local_FECollection, &_swigt__p_mfem__LumpedIntegrator, @@ -12287,7 +12092,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__QuadraticFECollection, &_swigt__p_mfem__QuadraticPosDiscont2DFECollection, &_swigt__p_mfem__QuadraticPosFECollection, - &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__QuadratureInterpolator, &_swigt__p_mfem__QuadratureSpace, &_swigt__p_mfem__RAPOperator, @@ -12311,6 +12115,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__RT_TetrahedronElement, &_swigt__p_mfem__RT_Trace_FECollection, &_swigt__p_mfem__RT_TriangleElement, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__RefinedBiLinear2DFiniteElement, &_swigt__p_mfem__RefinedLinear1DFiniteElement, &_swigt__p_mfem__RefinedLinear2DFiniteElement, @@ -12322,6 +12127,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ScalarFiniteElement, &_swigt__p_mfem__ScalarProductInterpolator, &_swigt__p_mfem__ScalarVectorProductInterpolator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__SumIntegrator, @@ -12332,7 +12139,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__TransposeOperator, &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__TripleProductOperator, - &_swigt__p_mfem__Vector, &_swigt__p_mfem__VectorCrossProductInterpolator, &_swigt__p_mfem__VectorCurlCurlIntegrator, &_swigt__p_mfem__VectorDiffusionIntegrator, @@ -12345,6 +12151,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorInnerProductInterpolator, &_swigt__p_mfem__VectorMassIntegrator, &_swigt__p_mfem__VectorScalarProductInterpolator, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -12356,11 +12163,11 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12371,6 +12178,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12392,6 +12200,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12424,8 +12233,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12434,11 +12242,12 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ElementRestriction[] = { {&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0}, {&_swigt__p_mfem__IsoparametricTransformation, _p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FaceQuadratureInterpolator[] = { {&_swigt__p_mfem__FaceQuadratureInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0HexFiniteElement[] = {{&_swigt__p_mfem__P0HexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LagrangeHexFiniteElement[] = {{&_swigt__p_mfem__LagrangeHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RefinedLinear1DFiniteElement[] = {{&_swigt__p_mfem__RefinedLinear1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -12454,13 +12263,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -12472,6 +12279,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -12513,6 +12322,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -12536,7 +12347,8 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussLinearDiscont2DFECollection[] = {{&_swigt__p_mfem__GaussLinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1OnQuadFECollection[] = {{&_swigt__p_mfem__P1OnQuadFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticDiscont2DFECollection[] = {{&_swigt__p_mfem__QuadraticDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -12549,15 +12361,13 @@ static swig_cast_info _swigc__p_mfem__QuadraticDiscont3DFECollection[] = {{&_swi static swig_cast_info _swigc__p_mfem__RefinedLinearFECollection[] = {{&_swigt__p_mfem__RefinedLinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ND1_3DFECollection[] = {{&_swigt__p_mfem__ND1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_3DFECollection[] = {{&_swigt__p_mfem__RT0_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Const2DFECollection[] = {{&_swigt__p_mfem__Const2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT2_2DFECollection[] = {{&_swigt__p_mfem__RT2_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1_2DFECollection[] = {{&_swigt__p_mfem__RT1_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_2DFECollection[] = {{&_swigt__p_mfem__RT0_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearNonConf3DFECollection[] = {{&_swigt__p_mfem__LinearNonConf3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CrouzeixRaviartFECollection[] = {{&_swigt__p_mfem__CrouzeixRaviartFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticFECollection[] = {{&_swigt__p_mfem__QuadraticFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearFECollection[] = {{&_swigt__p_mfem__LinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBSFECollection[] = {{&_swigt__p_mfem__NURBSFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -12567,11 +12377,13 @@ static swig_cast_info _swigc__p_mfem__DG_Interface_FECollection[] = {{&_swigt__p static swig_cast_info _swigc__p_mfem__RT_Trace_FECollection[] = {{&_swigt__p_mfem__RT_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT_FECollection[] = {{&_swigt__p_mfem__RT_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_Trace_FECollection[] = {{&_swigt__p_mfem__H1_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_FECollection[] = {{&_swigt__p_mfem__H1Ser_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_FECollection[] = {{&_swigt__p_mfem__H1Pos_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_FECollection[] = {{&_swigt__p_mfem__H1_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Local_FECollection[] = {{&_swigt__p_mfem__Local_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridTransfer[] = { {&_swigt__p_mfem__GridTransfer, 0, 0, 0}, {&_swigt__p_mfem__InterpolationGridTransfer, _p_mfem__InterpolationGridTransferTo_p_mfem__GridTransfer, 0, 0}, {&_swigt__p_mfem__L2ProjectionGridTransfer, _p_mfem__L2ProjectionGridTransferTo_p_mfem__GridTransfer, 0, 0},{0, 0, 0, 0}}; @@ -12582,34 +12394,41 @@ static swig_cast_info _swigc__p_mfem__L2ProjectionGridTransfer[] = { {&_swigt__ static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Mesh[] = { {&_swigt__p_mfem__Mesh, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBSExtension[] = { {&_swigt__p_mfem__NURBSExtension, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreParMatrix[] = {{&_swigt__p_mfem__HypreParMatrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParMatrix[] = {{&_swigt__p_mfem__HypreParMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Ordering[] = { {&_swigt__p_mfem__Ordering, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadratureInterpolator[] = { {&_swigt__p_mfem__QuadratureInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -12617,10 +12436,6 @@ static swig_cast_info _swigc__p_mfem__QuadratureSpace[] = { {&_swigt__p_mfem__Q static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__STable[] = {{&_swigt__p_mfem__STable, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Table[] = { {&_swigt__p_mfem__STable, _p_mfem__STableTo_p_mfem__Table, 0, 0}, {&_swigt__p_mfem__Table, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__HypreParVector, _p_mfem__HypreParVectorTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -12632,6 +12447,7 @@ static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -12674,6 +12490,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__ElementTransformation, + _swigc__p_mfem__FaceQuadratureInterpolator, _swigc__p_mfem__FiniteElement, _swigc__p_mfem__FiniteElementCollection, _swigc__p_mfem__FiniteElementSpace, @@ -12683,10 +12500,12 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__GaussLinearDiscont2DFECollection, _swigc__p_mfem__GaussQuad2DFiniteElement, _swigc__p_mfem__GaussQuadraticDiscont2DFECollection, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GridTransfer, _swigc__p_mfem__GroupConvectionIntegrator, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__H1Pos_FECollection, _swigc__p_mfem__H1Pos_HexahedronElement, _swigc__p_mfem__H1Pos_QuadrilateralElement, @@ -12694,6 +12513,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_FECollection, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_FECollection, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, @@ -12711,7 +12532,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__HypreIdentity, _swigc__p_mfem__HyprePCG, _swigc__p_mfem__HypreParMatrix, - _swigc__p_mfem__HypreParVector, _swigc__p_mfem__HypreParaSails, _swigc__p_mfem__HypreSmoother, _swigc__p_mfem__HypreSolver, @@ -12721,6 +12541,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__InterpolationGridTransfer, _swigc__p_mfem__InverseIntegrator, _swigc__p_mfem__IsoparametricTransformation, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2Pos_HexahedronElement, _swigc__p_mfem__L2Pos_QuadrilateralElement, _swigc__p_mfem__L2Pos_SegmentElement, @@ -12743,7 +12565,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__LinearDiscont2DFECollection, _swigc__p_mfem__LinearDiscont3DFECollection, _swigc__p_mfem__LinearFECollection, - _swigc__p_mfem__LinearForm, _swigc__p_mfem__LinearNonConf3DFECollection, _swigc__p_mfem__Local_FECollection, _swigc__p_mfem__LumpedIntegrator, @@ -12839,7 +12660,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__QuadraticFECollection, _swigc__p_mfem__QuadraticPosDiscont2DFECollection, _swigc__p_mfem__QuadraticPosFECollection, - _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__QuadratureInterpolator, _swigc__p_mfem__QuadratureSpace, _swigc__p_mfem__RAPOperator, @@ -12863,6 +12683,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__RT_TetrahedronElement, _swigc__p_mfem__RT_Trace_FECollection, _swigc__p_mfem__RT_TriangleElement, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__RefinedBiLinear2DFiniteElement, _swigc__p_mfem__RefinedLinear1DFiniteElement, _swigc__p_mfem__RefinedLinear2DFiniteElement, @@ -12874,6 +12695,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ScalarFiniteElement, _swigc__p_mfem__ScalarProductInterpolator, _swigc__p_mfem__ScalarVectorProductInterpolator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__SumIntegrator, @@ -12884,7 +12707,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__TransposeOperator, _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__TripleProductOperator, - _swigc__p_mfem__Vector, _swigc__p_mfem__VectorCrossProductInterpolator, _swigc__p_mfem__VectorCurlCurlIntegrator, _swigc__p_mfem__VectorDiffusionIntegrator, @@ -12897,6 +12719,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorInnerProductInterpolator, _swigc__p_mfem__VectorMassIntegrator, _swigc__p_mfem__VectorScalarProductInterpolator, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, @@ -13640,9 +13463,6 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Ordering_byVDIM",SWIG_From_int(static_cast< int >(mfem::Ordering::byVDIM))); SWIG_Python_SetConstant(d, "ElementDofOrdering_NATIVE",SWIG_From_int(static_cast< int >(mfem::ElementDofOrdering::NATIVE))); SWIG_Python_SetConstant(d, "ElementDofOrdering_LEXICOGRAPHIC",SWIG_From_int(static_cast< int >(mfem::ElementDofOrdering::LEXICOGRAPHIC))); - SWIG_Python_SetConstant(d, "QuadratureInterpolator_VALUES",SWIG_From_int(static_cast< int >(mfem::QuadratureInterpolator::VALUES))); - SWIG_Python_SetConstant(d, "QuadratureInterpolator_DERIVATIVES",SWIG_From_int(static_cast< int >(mfem::QuadratureInterpolator::DERIVATIVES))); - SWIG_Python_SetConstant(d, "QuadratureInterpolator_DETERMINANTS",SWIG_From_int(static_cast< int >(mfem::QuadratureInterpolator::DETERMINANTS))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/geom.py b/mfem/_par/geom.py index 31e6cc1f..5f5d7215 100644 --- a/mfem/_par/geom.py +++ b/mfem/_par/geom.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _geom.SWIG_PyInstanceMethod_New +_swig_new_static_method = _geom.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -107,15 +110,18 @@ def __init__(self): def GetVertices(self, GeomType): r"""GetVertices(Geometry self, int GeomType) -> IntegrationRule""" return _geom.Geometry_GetVertices(self, GeomType) + GetVertices = _swig_new_instance_method(_geom.Geometry_GetVertices) def GetCenter(self, GeomType): r"""GetCenter(Geometry self, int GeomType) -> IntegrationPoint""" return _geom.Geometry_GetCenter(self, GeomType) + GetCenter = _swig_new_instance_method(_geom.Geometry_GetCenter) @staticmethod def GetRandomPoint(GeomType, ip): r"""GetRandomPoint(int GeomType, IntegrationPoint ip)""" return _geom.Geometry_GetRandomPoint(GeomType, ip) + GetRandomPoint = _swig_new_static_method(_geom.Geometry_GetRandomPoint) @staticmethod def CheckPoint(*args): @@ -124,6 +130,7 @@ def CheckPoint(*args): CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool """ return _geom.Geometry_CheckPoint(*args) + CheckPoint = _swig_new_static_method(_geom.Geometry_CheckPoint) @staticmethod def ProjectPoint(*args): @@ -132,26 +139,32 @@ def ProjectPoint(*args): ProjectPoint(int GeomType, IntegrationPoint ip) -> bool """ return _geom.Geometry_ProjectPoint(*args) + ProjectPoint = _swig_new_static_method(_geom.Geometry_ProjectPoint) def GetGeomToPerfGeomJac(self, GeomType): r"""GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix""" return _geom.Geometry_GetGeomToPerfGeomJac(self, GeomType) + GetGeomToPerfGeomJac = _swig_new_instance_method(_geom.Geometry_GetGeomToPerfGeomJac) def GetPerfGeomToGeomJac(self, GeomType): r"""GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix""" return _geom.Geometry_GetPerfGeomToGeomJac(self, GeomType) + GetPerfGeomToGeomJac = _swig_new_instance_method(_geom.Geometry_GetPerfGeomToGeomJac) def GetPerfPointMat(self, GeomType, pm): r"""GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)""" return _geom.Geometry_GetPerfPointMat(self, GeomType, pm) + GetPerfPointMat = _swig_new_instance_method(_geom.Geometry_GetPerfPointMat) def JacToPerfJac(self, GeomType, J, PJ): r"""JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)""" return _geom.Geometry_JacToPerfJac(self, GeomType, J, PJ) + JacToPerfJac = _swig_new_instance_method(_geom.Geometry_JacToPerfJac) def NumBdr(self, GeomType): r"""NumBdr(Geometry self, int GeomType) -> int""" return _geom.Geometry_NumBdr(self, GeomType) + NumBdr = _swig_new_instance_method(_geom.Geometry_NumBdr) # Register Geometry in _geom: _geom.Geometry_swigregister(Geometry) @@ -167,6 +180,7 @@ def NumBdr(self, GeomType): def Geometry_GetRandomPoint(GeomType, ip): r"""Geometry_GetRandomPoint(int GeomType, IntegrationPoint ip)""" return _geom.Geometry_GetRandomPoint(GeomType, ip) +Geometry_GetRandomPoint = _geom.Geometry_GetRandomPoint def Geometry_CheckPoint(*args): r""" @@ -174,6 +188,7 @@ def Geometry_CheckPoint(*args): Geometry_CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool """ return _geom.Geometry_CheckPoint(*args) +Geometry_CheckPoint = _geom.Geometry_CheckPoint def Geometry_ProjectPoint(*args): r""" @@ -181,6 +196,7 @@ def Geometry_ProjectPoint(*args): Geometry_ProjectPoint(int GeomType, IntegrationPoint ip) -> bool """ return _geom.Geometry_ProjectPoint(*args) +Geometry_ProjectPoint = _geom.Geometry_ProjectPoint class RefinedGeometry(object): r"""Proxy of C++ mfem::RefinedGeometry class.""" @@ -216,18 +232,22 @@ def __init__(self): def SetType(self, t): r"""SetType(GeometryRefiner self, int const t)""" return _geom.GeometryRefiner_SetType(self, t) + SetType = _swig_new_instance_method(_geom.GeometryRefiner_SetType) def GetType(self): r"""GetType(GeometryRefiner self) -> int""" return _geom.GeometryRefiner_GetType(self) + GetType = _swig_new_instance_method(_geom.GeometryRefiner_GetType) def Refine(self, Geom, Times, ETimes=1): r"""Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry""" return _geom.GeometryRefiner_Refine(self, Geom, Times, ETimes) + Refine = _swig_new_instance_method(_geom.GeometryRefiner_Refine) def RefineInterior(self, Geom, Times): r"""RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule""" return _geom.GeometryRefiner_RefineInterior(self, Geom, Times) + RefineInterior = _swig_new_instance_method(_geom.GeometryRefiner_RefineInterior) __swig_destroy__ = _geom.delete_GeometryRefiner # Register GeometryRefiner in _geom: diff --git a/mfem/_par/geom_wrap.cxx b/mfem/_par/geom_wrap.cxx index 4f2296ba..b8b21063 100644 --- a/mfem/_par/geom_wrap.cxx +++ b/mfem/_par/geom_wrap.cxx @@ -5230,6 +5230,7 @@ SWIGINTERN PyObject *Swig_var_GlobGeometryRefiner_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Geometry_Name_get", _wrap_Geometry_Name_get, METH_VARARGS, NULL}, { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, @@ -5281,6 +5282,55 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Geometry_Name_get", _wrap_Geometry_Name_get, METH_VARARGS, NULL}, + { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, + { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, + { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"}, + { "Geometry_GetVertices", _wrap_Geometry_GetVertices, METH_VARARGS, "GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, + { "Geometry_GetCenter", _wrap_Geometry_GetCenter, METH_VARARGS, "GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, + { "Geometry_GetRandomPoint", _wrap_Geometry_GetRandomPoint, METH_VARARGS, "GetRandomPoint(int GeomType, IntegrationPoint ip)"}, + { "Geometry_CheckPoint", _wrap_Geometry_CheckPoint, METH_VARARGS, "\n" + "CheckPoint(int GeomType, IntegrationPoint ip) -> bool\n" + "CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool\n" + ""}, + { "Geometry_ProjectPoint", _wrap_Geometry_ProjectPoint, METH_VARARGS, "\n" + "ProjectPoint(int GeomType, IntegrationPoint beg, IntegrationPoint end) -> bool\n" + "ProjectPoint(int GeomType, IntegrationPoint ip) -> bool\n" + ""}, + { "Geometry_GetGeomToPerfGeomJac", _wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS, "GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfGeomToGeomJac", _wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS, "GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfPointMat", _wrap_Geometry_GetPerfPointMat, METH_VARARGS, "GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, + { "Geometry_JacToPerfJac", _wrap_Geometry_JacToPerfJac, METH_VARARGS, "JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, + { "Geometry_NumBdr", _wrap_Geometry_NumBdr, METH_VARARGS, "NumBdr(Geometry self, int GeomType) -> int"}, + { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL}, + { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL}, + { "RefinedGeometry_Times_set", _wrap_RefinedGeometry_Times_set, METH_VARARGS, "RefinedGeometry_Times_set(RefinedGeometry self, int Times)"}, + { "RefinedGeometry_Times_get", _wrap_RefinedGeometry_Times_get, METH_O, "RefinedGeometry_Times_get(RefinedGeometry self) -> int"}, + { "RefinedGeometry_ETimes_set", _wrap_RefinedGeometry_ETimes_set, METH_VARARGS, "RefinedGeometry_ETimes_set(RefinedGeometry self, int ETimes)"}, + { "RefinedGeometry_ETimes_get", _wrap_RefinedGeometry_ETimes_get, METH_O, "RefinedGeometry_ETimes_get(RefinedGeometry self) -> int"}, + { "RefinedGeometry_RefPts_get", _wrap_RefinedGeometry_RefPts_get, METH_O, "RefinedGeometry_RefPts_get(RefinedGeometry self) -> IntegrationRule"}, + { "RefinedGeometry_RefGeoms_set", _wrap_RefinedGeometry_RefGeoms_set, METH_VARARGS, "RefinedGeometry_RefGeoms_set(RefinedGeometry self, intArray RefGeoms)"}, + { "RefinedGeometry_RefGeoms_get", _wrap_RefinedGeometry_RefGeoms_get, METH_O, "RefinedGeometry_RefGeoms_get(RefinedGeometry self) -> intArray"}, + { "RefinedGeometry_RefEdges_set", _wrap_RefinedGeometry_RefEdges_set, METH_VARARGS, "RefinedGeometry_RefEdges_set(RefinedGeometry self, intArray RefEdges)"}, + { "RefinedGeometry_RefEdges_get", _wrap_RefinedGeometry_RefEdges_get, METH_O, "RefinedGeometry_RefEdges_get(RefinedGeometry self) -> intArray"}, + { "RefinedGeometry_NumBdrEdges_set", _wrap_RefinedGeometry_NumBdrEdges_set, METH_VARARGS, "RefinedGeometry_NumBdrEdges_set(RefinedGeometry self, int NumBdrEdges)"}, + { "RefinedGeometry_NumBdrEdges_get", _wrap_RefinedGeometry_NumBdrEdges_get, METH_O, "RefinedGeometry_NumBdrEdges_get(RefinedGeometry self) -> int"}, + { "RefinedGeometry_Type_set", _wrap_RefinedGeometry_Type_set, METH_VARARGS, "RefinedGeometry_Type_set(RefinedGeometry self, int Type)"}, + { "RefinedGeometry_Type_get", _wrap_RefinedGeometry_Type_get, METH_O, "RefinedGeometry_Type_get(RefinedGeometry self) -> int"}, + { "new_RefinedGeometry", _wrap_new_RefinedGeometry, METH_VARARGS, "RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0)"}, + { "delete_RefinedGeometry", _wrap_delete_RefinedGeometry, METH_O, "delete_RefinedGeometry(RefinedGeometry self)"}, + { "RefinedGeometry_swigregister", RefinedGeometry_swigregister, METH_O, NULL}, + { "RefinedGeometry_swiginit", RefinedGeometry_swiginit, METH_VARARGS, NULL}, + { "new_GeometryRefiner", _wrap_new_GeometryRefiner, METH_NOARGS, "new_GeometryRefiner() -> GeometryRefiner"}, + { "GeometryRefiner_SetType", _wrap_GeometryRefiner_SetType, METH_VARARGS, "SetType(GeometryRefiner self, int const t)"}, + { "GeometryRefiner_GetType", _wrap_GeometryRefiner_GetType, METH_O, "GetType(GeometryRefiner self) -> int"}, + { "GeometryRefiner_Refine", _wrap_GeometryRefiner_Refine, METH_VARARGS, "Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, + { "GeometryRefiner_RefineInterior", _wrap_GeometryRefiner_RefineInterior, METH_VARARGS, "RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, + { "delete_GeometryRefiner", _wrap_delete_GeometryRefiner, METH_O, "delete_GeometryRefiner(GeometryRefiner self)"}, + { "GeometryRefiner_swigregister", GeometryRefiner_swigregister, METH_O, NULL}, + { "GeometryRefiner_swiginit", GeometryRefiner_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/globals.py b/mfem/_par/globals.py index aabb73e9..78ab457e 100644 --- a/mfem/_par/globals.py +++ b/mfem/_par/globals.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _globals.SWIG_PyInstanceMethod_New +_swig_new_static_method = _globals.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -70,15 +73,19 @@ def __init__(self, out): def SetStream(self, out): return _globals.OutStream_SetStream(self, out) + SetStream = _swig_new_instance_method(_globals.OutStream_SetStream) def Enable(self): return _globals.OutStream_Enable(self) + Enable = _swig_new_instance_method(_globals.OutStream_Enable) def Disable(self): return _globals.OutStream_Disable(self) + Disable = _swig_new_instance_method(_globals.OutStream_Disable) def IsEnabled(self): return _globals.OutStream_IsEnabled(self) + IsEnabled = _swig_new_instance_method(_globals.OutStream_IsEnabled) __swig_destroy__ = _globals.delete_OutStream # Register OutStream in _globals: @@ -87,6 +94,7 @@ def IsEnabled(self): def MakeParFilename(*args): return _globals.MakeParFilename(*args) +MakeParFilename = _globals.MakeParFilename cvar = _globals.cvar out = cvar.out diff --git a/mfem/_par/globals_wrap.cxx b/mfem/_par/globals_wrap.cxx index 8082d656..addcf9e1 100644 --- a/mfem/_par/globals_wrap.cxx +++ b/mfem/_par/globals_wrap.cxx @@ -3468,6 +3468,7 @@ SWIGINTERN PyObject *_wrap_MakeParFilename(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, @@ -3481,6 +3482,17 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, + { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, + { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, + { "OutStream_Disable", _wrap_OutStream_Disable, METH_O, NULL}, + { "OutStream_IsEnabled", _wrap_OutStream_IsEnabled, METH_O, NULL}, + { "delete_OutStream", _wrap_delete_OutStream, METH_O, NULL}, + { "OutStream_swigregister", OutStream_swigregister, METH_O, NULL}, + { "OutStream_swiginit", OutStream_swiginit, METH_VARARGS, NULL}, + { "MakeParFilename", _wrap_MakeParFilename, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/gridfunc.py b/mfem/_par/gridfunc.py index bddaf303..1a4612c8 100644 --- a/mfem/_par/gridfunc.py +++ b/mfem/_par/gridfunc.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _gridfunc.SWIG_PyInstanceMethod_New +_swig_new_static_method = _gridfunc.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -78,6 +81,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.fespace import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -86,6 +90,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform class GridFunction(mfem._par.vector.Vector): @@ -97,14 +102,17 @@ class GridFunction(mfem._par.vector.Vector): def MakeOwner(self, _fec): r"""MakeOwner(GridFunction self, FiniteElementCollection _fec)""" return _gridfunc.GridFunction_MakeOwner(self, _fec) + MakeOwner = _swig_new_instance_method(_gridfunc.GridFunction_MakeOwner) def OwnFEC(self): r"""OwnFEC(GridFunction self) -> FiniteElementCollection""" return _gridfunc.GridFunction_OwnFEC(self) + OwnFEC = _swig_new_instance_method(_gridfunc.GridFunction_OwnFEC) def VectorDim(self): r"""VectorDim(GridFunction self) -> int""" return _gridfunc.GridFunction_VectorDim(self) + VectorDim = _swig_new_instance_method(_gridfunc.GridFunction_VectorDim) def GetTrueVector(self, *args): r""" @@ -112,30 +120,37 @@ def GetTrueVector(self, *args): GetTrueVector(GridFunction self) -> Vector """ return _gridfunc.GridFunction_GetTrueVector(self, *args) + GetTrueVector = _swig_new_instance_method(_gridfunc.GridFunction_GetTrueVector) def GetTrueDofs(self, tv): r"""GetTrueDofs(GridFunction self, Vector tv)""" return _gridfunc.GridFunction_GetTrueDofs(self, tv) + GetTrueDofs = _swig_new_instance_method(_gridfunc.GridFunction_GetTrueDofs) def SetTrueVector(self): r"""SetTrueVector(GridFunction self)""" return _gridfunc.GridFunction_SetTrueVector(self) + SetTrueVector = _swig_new_instance_method(_gridfunc.GridFunction_SetTrueVector) def SetFromTrueDofs(self, tv): r"""SetFromTrueDofs(GridFunction self, Vector tv)""" return _gridfunc.GridFunction_SetFromTrueDofs(self, tv) + SetFromTrueDofs = _swig_new_instance_method(_gridfunc.GridFunction_SetFromTrueDofs) def SetFromTrueVector(self): r"""SetFromTrueVector(GridFunction self)""" return _gridfunc.GridFunction_SetFromTrueVector(self) + SetFromTrueVector = _swig_new_instance_method(_gridfunc.GridFunction_SetFromTrueVector) def GetValue(self, i, ip, vdim=1): r"""GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double""" return _gridfunc.GridFunction_GetValue(self, i, ip, vdim) + GetValue = _swig_new_instance_method(_gridfunc.GridFunction_GetValue) def GetVectorValue(self, i, ip, val): r"""GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)""" return _gridfunc.GridFunction_GetVectorValue(self, i, ip, val) + GetVectorValue = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorValue) def GetValues(self, *args): r""" @@ -143,10 +158,28 @@ def GetValues(self, *args): GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) """ return _gridfunc.GridFunction_GetValues(self, *args) + GetValues = _swig_new_instance_method(_gridfunc.GridFunction_GetValues) + + def GetLaplacians(self, *args): + r""" + GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, int vdim=1) + GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, DenseMatrix tr, int vdim=1) + """ + return _gridfunc.GridFunction_GetLaplacians(self, *args) + GetLaplacians = _swig_new_instance_method(_gridfunc.GridFunction_GetLaplacians) + + def GetHessians(self, *args): + r""" + GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1) + GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1) + """ + return _gridfunc.GridFunction_GetHessians(self, *args) + GetHessians = _swig_new_instance_method(_gridfunc.GridFunction_GetHessians) def GetFaceValues(self, i, side, ir, vals, tr, vdim=1): r"""GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int""" return _gridfunc.GridFunction_GetFaceValues(self, i, side, ir, vals, tr, vdim) + GetFaceValues = _swig_new_instance_method(_gridfunc.GridFunction_GetFaceValues) def GetVectorValues(self, *args): r""" @@ -154,26 +187,32 @@ def GetVectorValues(self, *args): GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) """ return _gridfunc.GridFunction_GetVectorValues(self, *args) + GetVectorValues = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorValues) def GetFaceVectorValues(self, i, side, ir, vals, tr): r"""GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int""" return _gridfunc.GridFunction_GetFaceVectorValues(self, i, side, ir, vals, tr) + GetFaceVectorValues = _swig_new_instance_method(_gridfunc.GridFunction_GetFaceVectorValues) def GetValuesFrom(self, orig_func): r"""GetValuesFrom(GridFunction self, GridFunction orig_func)""" return _gridfunc.GridFunction_GetValuesFrom(self, orig_func) + GetValuesFrom = _swig_new_instance_method(_gridfunc.GridFunction_GetValuesFrom) def GetBdrValuesFrom(self, orig_func): r"""GetBdrValuesFrom(GridFunction self, GridFunction orig_func)""" return _gridfunc.GridFunction_GetBdrValuesFrom(self, orig_func) + GetBdrValuesFrom = _swig_new_instance_method(_gridfunc.GridFunction_GetBdrValuesFrom) def GetVectorFieldValues(self, i, ir, vals, tr, comp=0): r"""GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)""" return _gridfunc.GridFunction_GetVectorFieldValues(self, i, ir, vals, tr, comp) + GetVectorFieldValues = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorFieldValues) def ReorderByNodes(self): r"""ReorderByNodes(GridFunction self)""" return _gridfunc.GridFunction_ReorderByNodes(self) + ReorderByNodes = _swig_new_instance_method(_gridfunc.GridFunction_ReorderByNodes) def GetNodalValues(self, *args): ''' @@ -194,26 +233,32 @@ def GetNodalValues(self, *args): def GetVectorFieldNodalValues(self, val, comp): r"""GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)""" return _gridfunc.GridFunction_GetVectorFieldNodalValues(self, val, comp) + GetVectorFieldNodalValues = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorFieldNodalValues) def ProjectVectorFieldOn(self, vec_field, comp=0): r"""ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)""" return _gridfunc.GridFunction_ProjectVectorFieldOn(self, vec_field, comp) + ProjectVectorFieldOn = _swig_new_instance_method(_gridfunc.GridFunction_ProjectVectorFieldOn) def GetDerivative(self, comp, der_comp, der): r"""GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)""" return _gridfunc.GridFunction_GetDerivative(self, comp, der_comp, der) + GetDerivative = _swig_new_instance_method(_gridfunc.GridFunction_GetDerivative) def GetDivergence(self, tr): r"""GetDivergence(GridFunction self, ElementTransformation tr) -> double""" return _gridfunc.GridFunction_GetDivergence(self, tr) + GetDivergence = _swig_new_instance_method(_gridfunc.GridFunction_GetDivergence) def GetCurl(self, tr, curl): r"""GetCurl(GridFunction self, ElementTransformation tr, Vector curl)""" return _gridfunc.GridFunction_GetCurl(self, tr, curl) + GetCurl = _swig_new_instance_method(_gridfunc.GridFunction_GetCurl) def GetGradient(self, tr, grad): r"""GetGradient(GridFunction self, ElementTransformation tr, Vector grad)""" return _gridfunc.GridFunction_GetGradient(self, tr, grad) + GetGradient = _swig_new_instance_method(_gridfunc.GridFunction_GetGradient) def GetGradients(self, *args): r""" @@ -221,14 +266,17 @@ def GetGradients(self, *args): GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad) """ return _gridfunc.GridFunction_GetGradients(self, *args) + GetGradients = _swig_new_instance_method(_gridfunc.GridFunction_GetGradients) def GetVectorGradient(self, tr, grad): r"""GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)""" return _gridfunc.GridFunction_GetVectorGradient(self, tr, grad) + GetVectorGradient = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorGradient) def GetElementAverages(self, avgs): r"""GetElementAverages(GridFunction self, GridFunction avgs)""" return _gridfunc.GridFunction_GetElementAverages(self, avgs) + GetElementAverages = _swig_new_instance_method(_gridfunc.GridFunction_GetElementAverages) def ImposeBounds(self, *args): r""" @@ -236,10 +284,12 @@ def ImposeBounds(self, *args): ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity()) """ return _gridfunc.GridFunction_ImposeBounds(self, *args) + ImposeBounds = _swig_new_instance_method(_gridfunc.GridFunction_ImposeBounds) def ProjectGridFunction(self, src): r"""ProjectGridFunction(GridFunction self, GridFunction src)""" return _gridfunc.GridFunction_ProjectGridFunction(self, src) + ProjectGridFunction = _swig_new_instance_method(_gridfunc.GridFunction_ProjectGridFunction) def ProjectCoefficient(self, *args): r""" @@ -250,6 +300,7 @@ def ProjectCoefficient(self, *args): ProjectCoefficient(GridFunction self, mfem::Coefficient *[] coeff) """ return _gridfunc.GridFunction_ProjectCoefficient(self, *args) + ProjectCoefficient = _swig_new_instance_method(_gridfunc.GridFunction_ProjectCoefficient) ARITHMETIC = _gridfunc.GridFunction_ARITHMETIC HARMONIC = _gridfunc.GridFunction_HARMONIC @@ -262,6 +313,7 @@ def ProjectDiscCoefficient(self, *args): ProjectDiscCoefficient(GridFunction self, VectorCoefficient coeff, mfem::GridFunction::AvgType type) """ return _gridfunc.GridFunction_ProjectDiscCoefficient(self, *args) + ProjectDiscCoefficient = _swig_new_instance_method(_gridfunc.GridFunction_ProjectDiscCoefficient) def ProjectBdrCoefficient(self, *args): r""" @@ -270,14 +322,17 @@ def ProjectBdrCoefficient(self, *args): ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr) """ return _gridfunc.GridFunction_ProjectBdrCoefficient(self, *args) + ProjectBdrCoefficient = _swig_new_instance_method(_gridfunc.GridFunction_ProjectBdrCoefficient) def ProjectBdrCoefficientNormal(self, vcoeff, bdr_attr): r"""ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)""" return _gridfunc.GridFunction_ProjectBdrCoefficientNormal(self, vcoeff, bdr_attr) + ProjectBdrCoefficientNormal = _swig_new_instance_method(_gridfunc.GridFunction_ProjectBdrCoefficientNormal) def ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr): r"""ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)""" return _gridfunc.GridFunction_ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr) + ProjectBdrCoefficientTangent = _swig_new_instance_method(_gridfunc.GridFunction_ProjectBdrCoefficientTangent) def ComputeL2Error(self, *args): r""" @@ -286,10 +341,12 @@ def ComputeL2Error(self, *args): ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double """ return _gridfunc.GridFunction_ComputeL2Error(self, *args) + ComputeL2Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeL2Error) def ComputeH1Error(self, exsol, exgrad, ell_coef, Nu, norm_type): r"""ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double""" return _gridfunc.GridFunction_ComputeH1Error(self, exsol, exgrad, ell_coef, Nu, norm_type) + ComputeH1Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeH1Error) def ComputeMaxError(self, *args): r""" @@ -298,10 +355,12 @@ def ComputeMaxError(self, *args): ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double """ return _gridfunc.GridFunction_ComputeMaxError(self, *args) + ComputeMaxError = _swig_new_instance_method(_gridfunc.GridFunction_ComputeMaxError) def ComputeW11Error(self, exsol, exgrad, norm_type, elems=None, irs=0): r"""ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double""" return _gridfunc.GridFunction_ComputeW11Error(self, exsol, exgrad, norm_type, elems, irs) + ComputeW11Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeW11Error) def ComputeL1Error(self, *args): r""" @@ -309,6 +368,7 @@ def ComputeL1Error(self, *args): ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double """ return _gridfunc.GridFunction_ComputeL1Error(self, *args) + ComputeL1Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeL1Error) def ComputeLpError(self, *args): r""" @@ -316,6 +376,7 @@ def ComputeLpError(self, *args): ComputeLpError(GridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double """ return _gridfunc.GridFunction_ComputeLpError(self, *args) + ComputeLpError = _swig_new_instance_method(_gridfunc.GridFunction_ComputeLpError) def ComputeElementLpErrors(self, *args): r""" @@ -323,6 +384,7 @@ def ComputeElementLpErrors(self, *args): ComputeElementLpErrors(GridFunction self, double const p, VectorCoefficient exsol, GridFunction error, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementLpErrors(self, *args) + ComputeElementLpErrors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementLpErrors) def ComputeElementL1Errors(self, *args): r""" @@ -330,6 +392,7 @@ def ComputeElementL1Errors(self, *args): ComputeElementL1Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementL1Errors(self, *args) + ComputeElementL1Errors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementL1Errors) def ComputeElementL2Errors(self, *args): r""" @@ -337,6 +400,7 @@ def ComputeElementL2Errors(self, *args): ComputeElementL2Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementL2Errors(self, *args) + ComputeElementL2Errors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementL2Errors) def ComputeElementMaxErrors(self, *args): r""" @@ -344,10 +408,12 @@ def ComputeElementMaxErrors(self, *args): ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementMaxErrors(self, *args) + ComputeElementMaxErrors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementMaxErrors) - def ComputeFlux(self, blfi, flux, wcoef=1, subdomain=-1): - r"""ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, int wcoef=1, int subdomain=-1)""" + def ComputeFlux(self, blfi, flux, wcoef=True, subdomain=-1): + r"""ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)""" return _gridfunc.GridFunction_ComputeFlux(self, blfi, flux, wcoef, subdomain) + ComputeFlux = _swig_new_instance_method(_gridfunc.GridFunction_ComputeFlux) def Assign(self, *args): r""" @@ -356,10 +422,12 @@ def Assign(self, *args): Assign(GridFunction self, Vector v) -> GridFunction """ return _gridfunc.GridFunction_Assign(self, *args) + Assign = _swig_new_instance_method(_gridfunc.GridFunction_Assign) def Update(self): r"""Update(GridFunction self)""" return _gridfunc.GridFunction_Update(self) + Update = _swig_new_instance_method(_gridfunc.GridFunction_Update) def FESpace(self, *args): r""" @@ -367,17 +435,22 @@ def FESpace(self, *args): FESpace(GridFunction self) -> FiniteElementSpace """ return _gridfunc.GridFunction_FESpace(self, *args) + FESpace = _swig_new_instance_method(_gridfunc.GridFunction_FESpace) def SetSpace(self, f): r"""SetSpace(GridFunction self, FiniteElementSpace f)""" return _gridfunc.GridFunction_SetSpace(self, f) + SetSpace = _swig_new_instance_method(_gridfunc.GridFunction_SetSpace) def MakeRef(self, *args): r""" + MakeRef(GridFunction self, Vector base, int offset, int size) + MakeRef(GridFunction self, Vector base, int offset) MakeRef(GridFunction self, FiniteElementSpace f, double * v) MakeRef(GridFunction self, FiniteElementSpace f, Vector v, int v_offset) """ return _gridfunc.GridFunction_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_gridfunc.GridFunction_MakeRef) def MakeTRef(self, *args): r""" @@ -385,14 +458,17 @@ def MakeTRef(self, *args): MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset) """ return _gridfunc.GridFunction_MakeTRef(self, *args) + MakeTRef = _swig_new_instance_method(_gridfunc.GridFunction_MakeTRef) def SaveVTK(self, out, field_name, ref): r"""SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)""" return _gridfunc.GridFunction_SaveVTK(self, out, field_name, ref) + SaveVTK = _swig_new_instance_method(_gridfunc.GridFunction_SaveVTK) def SaveSTL(self, out, TimesToRefine=1): r"""SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)""" return _gridfunc.GridFunction_SaveSTL(self, out, TimesToRefine) + SaveSTL = _swig_new_instance_method(_gridfunc.GridFunction_SaveSTL) __swig_destroy__ = _gridfunc.delete_GridFunction def __init__(self, *args): @@ -411,10 +487,12 @@ def __init__(self, *args): def SaveToFile(self, gf_file, precision): r"""SaveToFile(GridFunction self, char const * gf_file, int const precision)""" return _gridfunc.GridFunction_SaveToFile(self, gf_file, precision) + SaveToFile = _swig_new_instance_method(_gridfunc.GridFunction_SaveToFile) def iadd(self, c): r"""iadd(GridFunction self, GridFunction c) -> GridFunction""" return _gridfunc.GridFunction_iadd(self, c) + iadd = _swig_new_instance_method(_gridfunc.GridFunction_iadd) def isub(self, *args): r""" @@ -422,14 +500,17 @@ def isub(self, *args): isub(GridFunction self, double c) -> GridFunction """ return _gridfunc.GridFunction_isub(self, *args) + isub = _swig_new_instance_method(_gridfunc.GridFunction_isub) def imul(self, c): r"""imul(GridFunction self, double c) -> GridFunction""" return _gridfunc.GridFunction_imul(self, c) + imul = _swig_new_instance_method(_gridfunc.GridFunction_imul) def idiv(self, c): r"""idiv(GridFunction self, double c) -> GridFunction""" return _gridfunc.GridFunction_idiv(self, c) + idiv = _swig_new_instance_method(_gridfunc.GridFunction_idiv) def Save(self, *args): r""" @@ -437,6 +518,7 @@ def Save(self, *args): Save(GridFunction self, char const * file, int precision=8) """ return _gridfunc.GridFunction_Save(self, *args) + Save = _swig_new_instance_method(_gridfunc.GridFunction_Save) # Register GridFunction in _gridfunc: _gridfunc.GridFunction_swigregister(GridFunction) @@ -461,6 +543,7 @@ def __init__(self, *args): def GetSpace(self): r"""GetSpace(QuadratureFunction self) -> QuadratureSpace""" return _gridfunc.QuadratureFunction_GetSpace(self) + GetSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetSpace) def SetSpace(self, *args): r""" @@ -468,26 +551,32 @@ def SetSpace(self, *args): SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1) """ return _gridfunc.QuadratureFunction_SetSpace(self, *args) + SetSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_SetSpace) def GetVDim(self): r"""GetVDim(QuadratureFunction self) -> int""" return _gridfunc.QuadratureFunction_GetVDim(self) + GetVDim = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetVDim) def SetVDim(self, vdim_): r"""SetVDim(QuadratureFunction self, int vdim_)""" return _gridfunc.QuadratureFunction_SetVDim(self, vdim_) + SetVDim = _swig_new_instance_method(_gridfunc.QuadratureFunction_SetVDim) def OwnsSpace(self): r"""OwnsSpace(QuadratureFunction self) -> bool""" return _gridfunc.QuadratureFunction_OwnsSpace(self) + OwnsSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_OwnsSpace) def SetOwnsSpace(self, own): r"""SetOwnsSpace(QuadratureFunction self, bool own)""" return _gridfunc.QuadratureFunction_SetOwnsSpace(self, own) + SetOwnsSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_SetOwnsSpace) def GetElementIntRule(self, idx): r"""GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule""" return _gridfunc.QuadratureFunction_GetElementIntRule(self, idx) + GetElementIntRule = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetElementIntRule) def GetElementValues(self, *args): r""" @@ -497,6 +586,7 @@ def GetElementValues(self, *args): GetElementValues(QuadratureFunction self, int idx, DenseMatrix values) """ return _gridfunc.QuadratureFunction_GetElementValues(self, *args) + GetElementValues = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetElementValues) def Save(self, *args): r""" @@ -504,6 +594,7 @@ def Save(self, *args): Save(QuadratureFunction self, char const * file, int precision=8) """ return _gridfunc.QuadratureFunction_Save(self, *args) + Save = _swig_new_instance_method(_gridfunc.QuadratureFunction_Save) # Register QuadratureFunction in _gridfunc: _gridfunc.QuadratureFunction_swigregister(QuadratureFunction) @@ -516,14 +607,17 @@ def __lshift__(*args): __lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream & """ return _gridfunc.__lshift__(*args) +__lshift__ = _gridfunc.__lshift__ -def ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags=None, with_subdomains=1): - r"""ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1) -> double""" - return _gridfunc.ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags, with_subdomains) +def ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags=None, with_subdomains=1, with_coeff=False): + r"""ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double""" + return _gridfunc.ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags, with_subdomains, with_coeff) +ZZErrorEstimator = _gridfunc.ZZErrorEstimator def ComputeElementLpDistance(p, i, gf1, gf2): r"""ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double""" return _gridfunc.ComputeElementLpDistance(p, i, gf1, gf2) +ComputeElementLpDistance = _gridfunc.ComputeElementLpDistance class ExtrudeCoefficient(mfem._par.coefficient.Coefficient): r"""Proxy of C++ mfem::ExtrudeCoefficient class.""" @@ -537,6 +631,7 @@ def __init__(self, m, s, _n): def Eval(self, T, ip): r"""Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _gridfunc.ExtrudeCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_gridfunc.ExtrudeCoefficient_Eval) __swig_destroy__ = _gridfunc.delete_ExtrudeCoefficient # Register ExtrudeCoefficient in _gridfunc: @@ -546,6 +641,7 @@ def Eval(self, T, ip): def Extrude1DGridFunction(mesh, mesh2d, sol, ny): r"""Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction""" return _gridfunc.Extrude1DGridFunction(mesh, mesh2d, sol, ny) +Extrude1DGridFunction = _gridfunc.Extrude1DGridFunction def __iadd__(self, v): ret = _gridfunc.GridFunction_iadd(self, v) diff --git a/mfem/_par/gridfunc_wrap.cxx b/mfem/_par/gridfunc_wrap.cxx index d402e95c..0c986fe7 100644 --- a/mfem/_par/gridfunc_wrap.cxx +++ b/mfem/_par/gridfunc_wrap.cxx @@ -3067,199 +3067,202 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_double swig_types[3] -#define SWIGTYPE_p_hex_t swig_types[4] -#define SWIGTYPE_p_int swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[8] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__Coefficient swig_types[10] -#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[11] -#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[12] -#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[13] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[15] -#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[16] -#define SWIGTYPE_p_mfem__CubicFECollection swig_types[17] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[18] -#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[19] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[20] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[21] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[22] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[23] -#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[24] -#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[25] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[26] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[27] -#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[28] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[29] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[30] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[31] -#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[32] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[33] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[35] -#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[36] -#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[37] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[38] -#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[39] -#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[40] -#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[41] -#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[42] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[43] -#define SWIGTYPE_p_mfem__GridFunction swig_types[44] -#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[45] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[46] -#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[47] -#define SWIGTYPE_p_mfem__H1_FECollection swig_types[48] -#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[49] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[50] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[51] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[52] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[53] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[54] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[56] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[57] -#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[58] -#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[59] -#define SWIGTYPE_p_mfem__LinearFECollection swig_types[60] -#define SWIGTYPE_p_mfem__LinearForm swig_types[61] -#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[62] -#define SWIGTYPE_p_mfem__Local_FECollection swig_types[63] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[66] -#define SWIGTYPE_p_mfem__Mesh swig_types[67] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[74] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[75] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[76] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[77] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[78] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[79] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[80] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[82] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[83] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[86] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[90] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[93] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[94] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[95] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[96] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[97] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[98] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[99] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[100] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[101] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[102] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[103] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[104] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[105] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[106] -#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[107] -#define SWIGTYPE_p_mfem__ND_FECollection swig_types[108] -#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[109] -#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[110] -#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[111] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[112] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[113] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[114] -#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[115] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[116] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[117] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[118] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[119] -#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[120] -#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[121] -#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[122] -#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[123] -#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[124] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[125] -#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[126] -#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[127] -#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[128] -#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[129] -#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[130] -#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[131] -#define SWIGTYPE_p_mfem__RT_FECollection swig_types[132] -#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[133] -#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[134] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[135] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[136] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[137] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[138] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[139] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[140] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[141] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[142] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[143] -#define SWIGTYPE_p_mfem__Vector swig_types[144] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[145] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[146] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[147] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[148] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[149] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[150] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[151] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[152] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[153] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[154] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[155] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[156] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[157] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[158] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[159] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[160] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[161] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[162] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[163] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[164] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[165] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[166] -#define SWIGTYPE_p_p_mfem__Coefficient swig_types[167] -#define SWIGTYPE_p_p_mfem__ConstantCoefficient swig_types[168] -#define SWIGTYPE_p_p_mfem__DeltaCoefficient swig_types[169] -#define SWIGTYPE_p_p_mfem__DeterminantCoefficient swig_types[170] -#define SWIGTYPE_p_p_mfem__DivergenceGridFunctionCoefficient swig_types[171] -#define SWIGTYPE_p_p_mfem__ExtrudeCoefficient swig_types[172] -#define SWIGTYPE_p_p_mfem__FunctionCoefficient swig_types[173] -#define SWIGTYPE_p_p_mfem__GridFunction swig_types[174] -#define SWIGTYPE_p_p_mfem__GridFunctionCoefficient swig_types[175] -#define SWIGTYPE_p_p_mfem__InnerProductCoefficient swig_types[176] -#define SWIGTYPE_p_p_mfem__PWConstCoefficient swig_types[177] -#define SWIGTYPE_p_p_mfem__PowerCoefficient swig_types[178] -#define SWIGTYPE_p_p_mfem__ProductCoefficient swig_types[179] -#define SWIGTYPE_p_p_mfem__PyCoefficientBase swig_types[180] -#define SWIGTYPE_p_p_mfem__RestrictedCoefficient swig_types[181] -#define SWIGTYPE_p_p_mfem__SumCoefficient swig_types[182] -#define SWIGTYPE_p_p_mfem__TransformedCoefficient swig_types[183] -#define SWIGTYPE_p_p_mfem__VectorRotProductCoefficient swig_types[184] -#define SWIGTYPE_p_pri_t swig_types[185] -#define SWIGTYPE_p_quad_t swig_types[186] -#define SWIGTYPE_p_seg_t swig_types[187] -#define SWIGTYPE_p_std__istream swig_types[188] -#define SWIGTYPE_p_std__ostream swig_types[189] -#define SWIGTYPE_p_std__string swig_types[190] -#define SWIGTYPE_p_tet_t swig_types[191] -#define SWIGTYPE_p_tri_t swig_types[192] -static swig_type_info *swig_types[194]; -static swig_module_info swig_module = {swig_types, 193, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_double swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[9] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[10] +#define SWIGTYPE_p_mfem__Coefficient swig_types[11] +#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[12] +#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[13] +#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[14] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[16] +#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[17] +#define SWIGTYPE_p_mfem__CubicFECollection swig_types[18] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[19] +#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[20] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[21] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[22] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[23] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[24] +#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[25] +#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[26] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[27] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[28] +#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[29] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[30] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[31] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[33] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[34] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[36] +#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[37] +#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[38] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[39] +#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[40] +#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[41] +#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[42] +#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[43] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[44] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[45] +#define SWIGTYPE_p_mfem__GridFunction swig_types[46] +#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[47] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[48] +#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[49] +#define SWIGTYPE_p_mfem__H1Ser_FECollection swig_types[50] +#define SWIGTYPE_p_mfem__H1_FECollection swig_types[51] +#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[52] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[53] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[54] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[55] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[56] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[57] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[59] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[60] +#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[61] +#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[62] +#define SWIGTYPE_p_mfem__LinearFECollection swig_types[63] +#define SWIGTYPE_p_mfem__LinearForm swig_types[64] +#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[65] +#define SWIGTYPE_p_mfem__Local_FECollection swig_types[66] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[69] +#define SWIGTYPE_p_mfem__Mesh swig_types[70] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[76] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[77] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[78] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[79] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[80] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[81] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[84] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[85] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[91] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[93] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[95] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[96] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[97] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[98] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[99] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[100] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[101] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[102] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[103] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[104] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[105] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[106] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[107] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[108] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[109] +#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[110] +#define SWIGTYPE_p_mfem__ND_FECollection swig_types[111] +#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[112] +#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[113] +#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[114] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[115] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[116] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[117] +#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[118] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[119] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[120] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[121] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[122] +#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[123] +#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[124] +#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[125] +#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[126] +#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[127] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[128] +#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[129] +#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[130] +#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[131] +#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[132] +#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[133] +#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[134] +#define SWIGTYPE_p_mfem__RT_FECollection swig_types[135] +#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[136] +#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[137] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[138] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[139] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[141] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[142] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[143] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[144] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[145] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[146] +#define SWIGTYPE_p_mfem__Vector swig_types[147] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[148] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[149] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[150] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[151] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[152] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[153] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[154] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[155] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[156] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[157] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[158] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[159] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[160] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[161] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[162] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[163] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[164] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[165] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[166] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[167] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[168] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[169] +#define SWIGTYPE_p_p_mfem__Coefficient swig_types[170] +#define SWIGTYPE_p_p_mfem__ConstantCoefficient swig_types[171] +#define SWIGTYPE_p_p_mfem__DeltaCoefficient swig_types[172] +#define SWIGTYPE_p_p_mfem__DeterminantCoefficient swig_types[173] +#define SWIGTYPE_p_p_mfem__DivergenceGridFunctionCoefficient swig_types[174] +#define SWIGTYPE_p_p_mfem__ExtrudeCoefficient swig_types[175] +#define SWIGTYPE_p_p_mfem__FunctionCoefficient swig_types[176] +#define SWIGTYPE_p_p_mfem__GridFunction swig_types[177] +#define SWIGTYPE_p_p_mfem__GridFunctionCoefficient swig_types[178] +#define SWIGTYPE_p_p_mfem__InnerProductCoefficient swig_types[179] +#define SWIGTYPE_p_p_mfem__PWConstCoefficient swig_types[180] +#define SWIGTYPE_p_p_mfem__PowerCoefficient swig_types[181] +#define SWIGTYPE_p_p_mfem__ProductCoefficient swig_types[182] +#define SWIGTYPE_p_p_mfem__PyCoefficientBase swig_types[183] +#define SWIGTYPE_p_p_mfem__RestrictedCoefficient swig_types[184] +#define SWIGTYPE_p_p_mfem__SumCoefficient swig_types[185] +#define SWIGTYPE_p_p_mfem__TransformedCoefficient swig_types[186] +#define SWIGTYPE_p_p_mfem__VectorRotProductCoefficient swig_types[187] +#define SWIGTYPE_p_pri_t swig_types[188] +#define SWIGTYPE_p_quad_t swig_types[189] +#define SWIGTYPE_p_seg_t swig_types[190] +#define SWIGTYPE_p_std__istream swig_types[191] +#define SWIGTYPE_p_std__ostream swig_types[192] +#define SWIGTYPE_p_std__string swig_types[193] +#define SWIGTYPE_p_tet_t swig_types[194] +#define SWIGTYPE_p_tri_t swig_types[195] +static swig_type_info *swig_types[197]; +static swig_module_info swig_module = {swig_types, 196, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3538,6 +3541,20 @@ SWIG_AsVal_int (PyObject * obj, int *val) } +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + SWIGINTERN swig_type_info* SWIG_pchar_descriptor(void) { @@ -3719,20 +3736,6 @@ SWIGINTERNINLINE PyObject* return PyBool_FromLong(value ? 1 : 0); } - -SWIGINTERN int -SWIG_AsVal_bool (PyObject *obj, bool *val) -{ - int r; - if (!PyBool_Check(obj)) - return SWIG_ERROR; - r = PyObject_IsTrue(obj); - if (r == -1) - return SWIG_ERROR; - if (val) *val = r ? true : false; - return SWIG_OK; -} - SWIGINTERN void mfem_QuadratureFunction_Save__SWIG_1(mfem::QuadratureFunction *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) @@ -4577,77 +4580,921 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *self, PyObject *args) } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValue'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValue'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &,int) const\n" + " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationPoint *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValue", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::GridFunction const *)arg1)->GetVectorValue(arg2,(mfem::IntegrationPoint const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValues", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_3(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValues'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetLaplacians", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_3(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetLaplacians'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &,int) const\n" - " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &) const\n"); + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationPoint *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValue", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->GetVectorValue(arg2,(mfem::IntegrationPoint const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4659,7 +5506,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4670,20 +5517,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -4692,7 +5539,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4705,12 +5552,12 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -4721,7 +5568,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPA if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4732,23 +5579,23 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4761,12 +5608,12 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; int arg6 ; void *argp1 = 0 ; @@ -4781,7 +5628,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4792,26 +5639,26 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { @@ -4822,7 +5669,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4835,12 +5682,12 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4854,7 +5701,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4865,31 +5712,31 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4902,13 +5749,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValues", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetHessians", 0, 6, argv))) SWIG_fail; --argc; if (argc == 4) { int _v; @@ -4929,10 +5776,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); + return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); } } } @@ -4957,14 +5804,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetValues__SWIG_3(self, argc, argv); + return _wrap_GridFunction_GetHessians__SWIG_3(self, argc, argv); } } } @@ -4990,7 +5837,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -5002,7 +5849,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } } if (_v) { - return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); + return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); } } } @@ -5028,7 +5875,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; @@ -5044,7 +5891,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } } if (_v) { - return _wrap_GridFunction_GetValues__SWIG_2(self, argc, argv); + return _wrap_GridFunction_GetHessians__SWIG_2(self, argc, argv); } } } @@ -5054,12 +5901,12 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetHessians'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); return 0; } @@ -12099,7 +12946,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSED mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - int arg4 ; + bool arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -12107,6 +12954,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); @@ -12130,12 +12979,11 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -12162,13 +13010,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNUSED mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - int arg4 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); @@ -12192,12 +13042,11 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { try { (arg1)->ComputeFlux(*arg2,*arg3,arg4); @@ -12304,12 +13153,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *ar _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { return _wrap_GridFunction_ComputeFlux__SWIG_1(self, argc, argv); @@ -12333,12 +13178,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *ar _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { { @@ -12361,8 +13202,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *ar fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeFlux'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,int,int)\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,int)\n" + " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool,int)\n" + " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool)\n" " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &)\n"); return 0; } @@ -12605,53 +13446,166 @@ SWIGINTERN PyObject *_wrap_GridFunction_FESpace(PyObject *self, PyObject *args) return _wrap_GridFunction_FESpace__SWIG_0(self, argc, argv); } } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_FESpace__SWIG_1(self, argc, argv); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_FESpace__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_FESpace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::FESpace()\n" + " mfem::GridFunction::FESpace() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GridFunction_SetSpace", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SetSpace" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SetSpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->SetSpace(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3,arg4); } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_FESpace'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::FESpace()\n" - " mfem::GridFunction::FESpace() const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SetSpace", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SetSpace" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SetSpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->SetSpace(arg2); + (arg1)->MakeRef(*arg2,arg3); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } resultobj = SWIG_Py_Void(); return resultobj; @@ -12660,7 +13614,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -12703,7 +13657,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -12764,6 +13718,30 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_MakeRef", 0, 4, argv))) SWIG_fail; --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_MakeRef__SWIG_0_1(self, argc, argv); + } + } + } + } if (argc == 3) { int _v; void *vptr = 0; @@ -12778,7 +13756,41 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_0(self, argc, argv); + return _wrap_GridFunction_MakeRef__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_MakeRef__SWIG_0_0(self, argc, argv); + } } } } @@ -12806,7 +13818,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_1(self, argc, argv); + return _wrap_GridFunction_MakeRef__SWIG_2(self, argc, argv); } } } @@ -12816,6 +13828,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_MakeRef'.\n" " Possible C/C++ prototypes are:\n" + " MakeRef(mfem::Vector &,int,int)\n" + " MakeRef(mfem::Vector &,int)\n" " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,double *)\n" " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,mfem::Vector &,int)\n"); return 0; @@ -15460,85 +16474,172 @@ SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py arg2 = reinterpret_cast< mfem::QuadratureFunction * >(argp2); { try { - result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::QuadratureFunction const &)*arg2); + result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::QuadratureFunction const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + return resultobj; +fail: + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap___lshift____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap___lshift____SWIG_2(self, argc, argv); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = 0 ; + mfem::GridFunction *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; + int arg6 ; + bool arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool val7 ; + int ecode7 = 0 ; + double result; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ZZErrorEstimator" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + { + try { + result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } - PyErr_Clear(); - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; -} - - -SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap___lshift____SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap___lshift____SWIG_2(self, argc, argv); - } - } - } - -fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + return NULL; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; @@ -15617,7 +16718,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; @@ -15689,7 +16790,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; @@ -15755,11 +16856,11 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "ZZErrorEstimator", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "ZZErrorEstimator", 0, 7, argv))) SWIG_fail; --argc; if (argc == 4) { int _v; @@ -15779,7 +16880,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ZZErrorEstimator__SWIG_2(self, argc, argv); + return _wrap_ZZErrorEstimator__SWIG_3(self, argc, argv); } } } @@ -15807,7 +16908,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ZZErrorEstimator__SWIG_1(self, argc, argv); + return _wrap_ZZErrorEstimator__SWIG_2(self, argc, argv); } } } @@ -15845,7 +16946,52 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_ZZErrorEstimator__SWIG_0(self, argc, argv); + return _wrap_ZZErrorEstimator__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ZZErrorEstimator__SWIG_0(self, argc, argv); + } } } } @@ -15857,6 +17003,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZZErrorEstimator'.\n" " Possible C/C++ prototypes are:\n" + " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int,bool)\n" " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int)\n" " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *)\n" " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &)\n"); @@ -16114,6 +17261,7 @@ SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "GridFunction_MakeOwner", _wrap_GridFunction_MakeOwner, METH_VARARGS, "GridFunction_MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, { "GridFunction_OwnFEC", _wrap_GridFunction_OwnFEC, METH_O, "GridFunction_OwnFEC(GridFunction self) -> FiniteElementCollection"}, { "GridFunction_VectorDim", _wrap_GridFunction_VectorDim, METH_O, "GridFunction_VectorDim(GridFunction self) -> int"}, @@ -16131,6 +17279,14 @@ static PyMethodDef SwigMethods[] = { "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" ""}, + { "GridFunction_GetLaplacians", _wrap_GridFunction_GetLaplacians, METH_VARARGS, "\n" + "GridFunction_GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, int vdim=1)\n" + "GridFunction_GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetHessians", _wrap_GridFunction_GetHessians, METH_VARARGS, "\n" + "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" + "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" + ""}, { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GridFunction_GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" "GridFunction_GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" @@ -16217,7 +17373,7 @@ static PyMethodDef SwigMethods[] = { "GridFunction_ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" "GridFunction_ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" ""}, - { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, int wcoef=1, int subdomain=-1)"}, + { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" "GridFunction_Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" "GridFunction_Assign(GridFunction self, double value) -> GridFunction\n" @@ -16230,6 +17386,8 @@ static PyMethodDef SwigMethods[] = { ""}, { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "GridFunction_SetSpace(GridFunction self, FiniteElementSpace f)"}, { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" + "GridFunction_MakeRef(GridFunction self, Vector base, int offset, int size)\n" + "GridFunction_MakeRef(GridFunction self, Vector base, int offset)\n" "GridFunction_MakeRef(GridFunction self, FiniteElementSpace f, double * v)\n" "GridFunction_MakeRef(GridFunction self, FiniteElementSpace f, Vector v, int v_offset)\n" ""}, @@ -16299,7 +17457,7 @@ static PyMethodDef SwigMethods[] = { "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" ""}, - { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1) -> double"}, + { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "ExtrudeCoefficient_Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, @@ -16311,6 +17469,211 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "GridFunction_MakeOwner", _wrap_GridFunction_MakeOwner, METH_VARARGS, "MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, + { "GridFunction_OwnFEC", _wrap_GridFunction_OwnFEC, METH_O, "OwnFEC(GridFunction self) -> FiniteElementCollection"}, + { "GridFunction_VectorDim", _wrap_GridFunction_VectorDim, METH_O, "VectorDim(GridFunction self) -> int"}, + { "GridFunction_GetTrueVector", _wrap_GridFunction_GetTrueVector, METH_VARARGS, "\n" + "GetTrueVector(GridFunction self) -> Vector\n" + "GetTrueVector(GridFunction self) -> Vector\n" + ""}, + { "GridFunction_GetTrueDofs", _wrap_GridFunction_GetTrueDofs, METH_VARARGS, "GetTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetTrueVector", _wrap_GridFunction_SetTrueVector, METH_O, "SetTrueVector(GridFunction self)"}, + { "GridFunction_SetFromTrueDofs", _wrap_GridFunction_SetFromTrueDofs, METH_VARARGS, "SetFromTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetFromTrueVector", _wrap_GridFunction_SetFromTrueVector, METH_O, "SetFromTrueVector(GridFunction self)"}, + { "GridFunction_GetValue", _wrap_GridFunction_GetValue, METH_VARARGS, "GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, + { "GridFunction_GetVectorValue", _wrap_GridFunction_GetVectorValue, METH_VARARGS, "GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, + { "GridFunction_GetValues", _wrap_GridFunction_GetValues, METH_VARARGS, "\n" + "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" + "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetLaplacians", _wrap_GridFunction_GetLaplacians, METH_VARARGS, "\n" + "GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, int vdim=1)\n" + "GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetHessians", _wrap_GridFunction_GetHessians, METH_VARARGS, "\n" + "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" + "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, + { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" + "GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" + "GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr)\n" + ""}, + { "GridFunction_GetFaceVectorValues", _wrap_GridFunction_GetFaceVectorValues, METH_VARARGS, "GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, + { "GridFunction_GetValuesFrom", _wrap_GridFunction_GetValuesFrom, METH_VARARGS, "GetValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetBdrValuesFrom", _wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS, "GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetVectorFieldValues", _wrap_GridFunction_GetVectorFieldValues, METH_VARARGS, "GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, + { "GridFunction_ReorderByNodes", _wrap_GridFunction_ReorderByNodes, METH_O, "ReorderByNodes(GridFunction self)"}, + { "GridFunction_GetNodalValues", _wrap_GridFunction_GetNodalValues, METH_VARARGS, "\n" + "GetNodalValues(GridFunction self, int i, doubleArray nval, int vdim=1)\n" + "GetNodalValues(GridFunction self, Vector nval, int vdim=1)\n" + ""}, + { "GridFunction_GetVectorFieldNodalValues", _wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS, "GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, + { "GridFunction_ProjectVectorFieldOn", _wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS, "ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, + { "GridFunction_GetDerivative", _wrap_GridFunction_GetDerivative, METH_VARARGS, "GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, + { "GridFunction_GetDivergence", _wrap_GridFunction_GetDivergence, METH_VARARGS, "GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, + { "GridFunction_GetCurl", _wrap_GridFunction_GetCurl, METH_VARARGS, "GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, + { "GridFunction_GetGradient", _wrap_GridFunction_GetGradient, METH_VARARGS, "GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, + { "GridFunction_GetGradients", _wrap_GridFunction_GetGradients, METH_VARARGS, "\n" + "GetGradients(GridFunction self, ElementTransformation tr, IntegrationRule ir, DenseMatrix grad)\n" + "GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad)\n" + ""}, + { "GridFunction_GetVectorGradient", _wrap_GridFunction_GetVectorGradient, METH_VARARGS, "GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, + { "GridFunction_GetElementAverages", _wrap_GridFunction_GetElementAverages, METH_VARARGS, "GetElementAverages(GridFunction self, GridFunction avgs)"}, + { "GridFunction_ImposeBounds", _wrap_GridFunction_ImposeBounds, METH_VARARGS, "\n" + "ImposeBounds(GridFunction self, int i, Vector weights, Vector _lo, Vector _hi)\n" + "ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity())\n" + ""}, + { "GridFunction_ProjectGridFunction", _wrap_GridFunction_ProjectGridFunction, METH_VARARGS, "ProjectGridFunction(GridFunction self, GridFunction src)"}, + { "GridFunction_ProjectCoefficient", _wrap_GridFunction_ProjectCoefficient, METH_VARARGS, "\n" + "ProjectCoefficient(GridFunction self, Coefficient coeff)\n" + "ProjectCoefficient(GridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" + "ProjectCoefficient(GridFunction self, VectorCoefficient vcoeff)\n" + "ProjectCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray dofs)\n" + "ProjectCoefficient(GridFunction self, mfem::Coefficient *[] coeff)\n" + ""}, + { "GridFunction_ProjectDiscCoefficient", _wrap_GridFunction_ProjectDiscCoefficient, METH_VARARGS, "\n" + "ProjectDiscCoefficient(GridFunction self, VectorCoefficient coeff)\n" + "ProjectDiscCoefficient(GridFunction self, Coefficient coeff, mfem::GridFunction::AvgType type)\n" + "ProjectDiscCoefficient(GridFunction self, VectorCoefficient coeff, mfem::GridFunction::AvgType type)\n" + ""}, + { "GridFunction_ProjectBdrCoefficient", _wrap_GridFunction_ProjectBdrCoefficient, METH_VARARGS, "\n" + "ProjectBdrCoefficient(GridFunction self, Coefficient coeff, intArray attr)\n" + "ProjectBdrCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray attr)\n" + "ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" + ""}, + { "GridFunction_ProjectBdrCoefficientNormal", _wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS, "ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientTangent", _wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ComputeL2Error", _wrap_GridFunction_ComputeL2Error, METH_VARARGS, "\n" + "ComputeL2Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL2Error(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double\n" + ""}, + { "GridFunction_ComputeH1Error", _wrap_GridFunction_ComputeH1Error, METH_VARARGS, "ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, + { "GridFunction_ComputeMaxError", _wrap_GridFunction_ComputeMaxError, METH_VARARGS, "\n" + "ComputeMaxError(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeMaxError(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "GridFunction_ComputeW11Error", _wrap_GridFunction_ComputeW11Error, METH_VARARGS, "ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, + { "GridFunction_ComputeL1Error", _wrap_GridFunction_ComputeL1Error, METH_VARARGS, "\n" + "ComputeL1Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "GridFunction_ComputeLpError", _wrap_GridFunction_ComputeLpError, METH_VARARGS, "\n" + "ComputeLpError(GridFunction self, double const p, Coefficient exsol, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeLpError(GridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "GridFunction_ComputeElementLpErrors", _wrap_GridFunction_ComputeElementLpErrors, METH_VARARGS, "\n" + "ComputeElementLpErrors(GridFunction self, double const p, Coefficient exsol, GridFunction error, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementLpErrors(GridFunction self, double const p, VectorCoefficient exsol, GridFunction error, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeElementL1Errors", _wrap_GridFunction_ComputeElementL1Errors, METH_VARARGS, "\n" + "ComputeElementL1Errors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementL1Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeElementL2Errors", _wrap_GridFunction_ComputeElementL2Errors, METH_VARARGS, "\n" + "ComputeElementL2Errors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementL2Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeElementMaxErrors", _wrap_GridFunction_ComputeElementMaxErrors, METH_VARARGS, "\n" + "ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" + "Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" + "Assign(GridFunction self, double value) -> GridFunction\n" + "Assign(GridFunction self, Vector v) -> GridFunction\n" + ""}, + { "GridFunction_Update", _wrap_GridFunction_Update, METH_O, "Update(GridFunction self)"}, + { "GridFunction_FESpace", _wrap_GridFunction_FESpace, METH_VARARGS, "\n" + "FESpace(GridFunction self) -> FiniteElementSpace\n" + "FESpace(GridFunction self) -> FiniteElementSpace\n" + ""}, + { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "SetSpace(GridFunction self, FiniteElementSpace f)"}, + { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" + "MakeRef(GridFunction self, Vector base, int offset, int size)\n" + "MakeRef(GridFunction self, Vector base, int offset)\n" + "MakeRef(GridFunction self, FiniteElementSpace f, double * v)\n" + "MakeRef(GridFunction self, FiniteElementSpace f, Vector v, int v_offset)\n" + ""}, + { "GridFunction_MakeTRef", _wrap_GridFunction_MakeTRef, METH_VARARGS, "\n" + "MakeTRef(GridFunction self, FiniteElementSpace f, double * tv)\n" + "MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset)\n" + ""}, + { "GridFunction_SaveVTK", _wrap_GridFunction_SaveVTK, METH_VARARGS, "SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, + { "GridFunction_SaveSTL", _wrap_GridFunction_SaveSTL, METH_VARARGS, "SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, + { "delete_GridFunction", _wrap_delete_GridFunction, METH_O, "delete_GridFunction(GridFunction self)"}, + { "new_GridFunction", _wrap_new_GridFunction, METH_VARARGS, "\n" + "GridFunction()\n" + "GridFunction(GridFunction orig)\n" + "GridFunction(FiniteElementSpace f)\n" + "GridFunction(FiniteElementSpace f, double * data)\n" + "GridFunction(Mesh m, std::istream & input)\n" + "GridFunction(Mesh m, mfem::GridFunction *[] gf_array, int num_pieces)\n" + "GridFunction(Mesh m, char const * grid_file)\n" + "new_GridFunction(FiniteElementSpace fes, Vector v, int offset) -> GridFunction\n" + ""}, + { "GridFunction_SaveToFile", _wrap_GridFunction_SaveToFile, METH_VARARGS, "SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, + { "GridFunction_iadd", _wrap_GridFunction_iadd, METH_VARARGS, "iadd(GridFunction self, GridFunction c) -> GridFunction"}, + { "GridFunction_isub", _wrap_GridFunction_isub, METH_VARARGS, "\n" + "isub(GridFunction self, GridFunction c) -> GridFunction\n" + "isub(GridFunction self, double c) -> GridFunction\n" + ""}, + { "GridFunction_imul", _wrap_GridFunction_imul, METH_VARARGS, "imul(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_idiv", _wrap_GridFunction_idiv, METH_VARARGS, "idiv(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_Save", _wrap_GridFunction_Save, METH_VARARGS, "\n" + "Save(GridFunction self, std::ostream & out)\n" + "Save(GridFunction self, char const * file, int precision=8)\n" + ""}, + { "GridFunction_swigregister", GridFunction_swigregister, METH_O, NULL}, + { "GridFunction_swiginit", GridFunction_swiginit, METH_VARARGS, NULL}, + { "new_QuadratureFunction", _wrap_new_QuadratureFunction, METH_VARARGS, "\n" + "QuadratureFunction()\n" + "QuadratureFunction(QuadratureFunction orig)\n" + "QuadratureFunction(QuadratureSpace qspace_, int vdim_=1)\n" + "QuadratureFunction(QuadratureSpace qspace_, double * qf_data, int vdim_=1)\n" + "new_QuadratureFunction(Mesh mesh, std::istream & _in) -> QuadratureFunction\n" + ""}, + { "delete_QuadratureFunction", _wrap_delete_QuadratureFunction, METH_O, "delete_QuadratureFunction(QuadratureFunction self)"}, + { "QuadratureFunction_GetSpace", _wrap_QuadratureFunction_GetSpace, METH_O, "GetSpace(QuadratureFunction self) -> QuadratureSpace"}, + { "QuadratureFunction_SetSpace", _wrap_QuadratureFunction_SetSpace, METH_VARARGS, "\n" + "SetSpace(QuadratureFunction self, QuadratureSpace qspace_, int vdim_=-1)\n" + "SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1)\n" + ""}, + { "QuadratureFunction_GetVDim", _wrap_QuadratureFunction_GetVDim, METH_O, "GetVDim(QuadratureFunction self) -> int"}, + { "QuadratureFunction_SetVDim", _wrap_QuadratureFunction_SetVDim, METH_VARARGS, "SetVDim(QuadratureFunction self, int vdim_)"}, + { "QuadratureFunction_OwnsSpace", _wrap_QuadratureFunction_OwnsSpace, METH_O, "OwnsSpace(QuadratureFunction self) -> bool"}, + { "QuadratureFunction_SetOwnsSpace", _wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS, "SetOwnsSpace(QuadratureFunction self, bool own)"}, + { "QuadratureFunction_GetElementIntRule", _wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, + { "QuadratureFunction_GetElementValues", _wrap_QuadratureFunction_GetElementValues, METH_VARARGS, "\n" + "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" + "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" + "GetElementValues(QuadratureFunction self, int idx, DenseMatrix values)\n" + "GetElementValues(QuadratureFunction self, int idx, DenseMatrix values)\n" + ""}, + { "QuadratureFunction_Save", _wrap_QuadratureFunction_Save, METH_VARARGS, "\n" + "Save(QuadratureFunction self, std::ostream & out)\n" + "Save(QuadratureFunction self, char const * file, int precision=8)\n" + ""}, + { "QuadratureFunction_swigregister", QuadratureFunction_swigregister, METH_O, NULL}, + { "QuadratureFunction_swiginit", QuadratureFunction_swiginit, METH_VARARGS, NULL}, + { "__lshift__", _wrap___lshift__, METH_VARARGS, "\n" + "__lshift__(std::ostream & out, Mesh mesh) -> std::ostream\n" + "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" + "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" + ""}, + { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, + { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, + { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, + { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_ExtrudeCoefficient", _wrap_delete_ExtrudeCoefficient, METH_O, "delete_ExtrudeCoefficient(ExtrudeCoefficient self)"}, + { "ExtrudeCoefficient_swigregister", ExtrudeCoefficient_swigregister, METH_O, NULL}, + { "ExtrudeCoefficient_swiginit", ExtrudeCoefficient_swiginit, METH_VARARGS, NULL}, + { "Extrude1DGridFunction", _wrap_Extrude1DGridFunction, METH_VARARGS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, { NULL, NULL, 0, NULL } }; @@ -16383,6 +17746,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -16512,9 +17878,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -16539,6 +17902,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -16683,9 +18049,6 @@ static void *_p_p_mfem__ConstantCoefficientTo_p_p_mfem__Coefficient(void *x, int static void *_p_p_mfem__ExtrudeCoefficientTo_p_p_mfem__Coefficient(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Coefficient **) ((mfem::ExtrudeCoefficient **) x)); } -static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); -} static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); } @@ -16743,12 +18106,18 @@ static void *_p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollect static void *_p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::CrouzeixRaviartFECollection *) x)); } +static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +} static void *_p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::H1_FECollection *) x)); } static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -16782,8 +18151,8 @@ static void *_p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection(vo static void *_p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::QuadraticPosFECollection *) x)); } -static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); } static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::Local_FECollection *) x)); @@ -16805,6 +18174,7 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -16812,7 +18182,6 @@ static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (voi static swig_type_info _swigt__p_mfem__ArrayT_double_t = {"_p_mfem__ArrayT_double_t", "mfem::Array< double > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -16823,6 +18192,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -16844,6 +18214,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -16876,8 +18247,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -16886,6 +18256,7 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Coefficient = {"_p_mfem__Coefficient", "mfem::Coefficient *", 0, 0, (void*)0, 0}; @@ -16909,6 +18280,7 @@ static swig_type_info _swigt__p_mfem__ElementTransformation = {"_p_mfem__Element static swig_type_info _swigt__p_mfem__IsoparametricTransformation = {"_p_mfem__IsoparametricTransformation", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ExtrudeCoefficient = {"_p_mfem__ExtrudeCoefficient", "mfem::ExtrudeCoefficient *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementCollection = {"_p_mfem__FiniteElementCollection", "mfem::FiniteElementCollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GaussLinearDiscont2DFECollection = {"_p_mfem__GaussLinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1OnQuadFECollection = {"_p_mfem__P1OnQuadFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticDiscont2DFECollection = {"_p_mfem__QuadraticDiscont2DFECollection", 0, 0, 0, 0, 0}; @@ -16921,15 +18293,13 @@ static swig_type_info _swigt__p_mfem__QuadraticDiscont3DFECollection = {"_p_mfem static swig_type_info _swigt__p_mfem__RefinedLinearFECollection = {"_p_mfem__RefinedLinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ND1_3DFECollection = {"_p_mfem__ND1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_3DFECollection = {"_p_mfem__RT0_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Const2DFECollection = {"_p_mfem__Const2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT2_2DFECollection = {"_p_mfem__RT2_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1_2DFECollection = {"_p_mfem__RT1_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_2DFECollection = {"_p_mfem__RT0_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearNonConf3DFECollection = {"_p_mfem__LinearNonConf3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CrouzeixRaviartFECollection = {"_p_mfem__CrouzeixRaviartFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticFECollection = {"_p_mfem__QuadraticFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearFECollection = {"_p_mfem__LinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBSFECollection = {"_p_mfem__NURBSFECollection", 0, 0, 0, 0, 0}; @@ -16939,9 +18309,11 @@ static swig_type_info _swigt__p_mfem__DG_Interface_FECollection = {"_p_mfem__DG_ static swig_type_info _swigt__p_mfem__RT_Trace_FECollection = {"_p_mfem__RT_Trace_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT_FECollection = {"_p_mfem__RT_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_Trace_FECollection = {"_p_mfem__H1_Trace_FECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_FECollection = {"_p_mfem__H1Ser_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_FECollection = {"_p_mfem__H1Pos_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_FECollection = {"_p_mfem__H1_FECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Local_FECollection = {"_p_mfem__Local_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; @@ -17000,6 +18372,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_hex_t, @@ -17041,11 +18414,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__GaussLinearDiscont2DFECollection, &_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, &_swigt__p_mfem__GradientGridFunctionCoefficient, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GridFunctionCoefficient, &_swigt__p_mfem__GroupConvectionIntegrator, &_swigt__p_mfem__H1Pos_FECollection, + &_swigt__p_mfem__H1Ser_FECollection, &_swigt__p_mfem__H1_FECollection, &_swigt__p_mfem__H1_Trace_FECollection, &_swigt__p_mfem__HypreParVector, @@ -17195,13 +18570,13 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_double_t[] = { {&_swigt__p_mfem__ArrayT_double_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -17212,6 +18587,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -17233,6 +18609,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -17265,8 +18642,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -17275,9 +18651,10 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyCoefficientBase[] = {{&_swigt__p_mfem__PyCoefficientBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DeterminantCoefficient[] = {{&_swigt__p_mfem__DeterminantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorRotProductCoefficient[] = {{&_swigt__p_mfem__VectorRotProductCoefficient, 0, 0, 0},{0, 0, 0, 0}}; @@ -17298,6 +18675,7 @@ static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__Dense static swig_cast_info _swigc__p_mfem__IsoparametricTransformation[] = {{&_swigt__p_mfem__IsoparametricTransformation, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0}, {&_swigt__p_mfem__IsoparametricTransformation, _p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ExtrudeCoefficient[] = { {&_swigt__p_mfem__ExtrudeCoefficient, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussLinearDiscont2DFECollection[] = {{&_swigt__p_mfem__GaussLinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1OnQuadFECollection[] = {{&_swigt__p_mfem__P1OnQuadFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticDiscont2DFECollection[] = {{&_swigt__p_mfem__QuadraticDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -17310,15 +18688,13 @@ static swig_cast_info _swigc__p_mfem__QuadraticDiscont3DFECollection[] = {{&_swi static swig_cast_info _swigc__p_mfem__RefinedLinearFECollection[] = {{&_swigt__p_mfem__RefinedLinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ND1_3DFECollection[] = {{&_swigt__p_mfem__ND1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_3DFECollection[] = {{&_swigt__p_mfem__RT0_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Const2DFECollection[] = {{&_swigt__p_mfem__Const2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT2_2DFECollection[] = {{&_swigt__p_mfem__RT2_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1_2DFECollection[] = {{&_swigt__p_mfem__RT1_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_2DFECollection[] = {{&_swigt__p_mfem__RT0_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearNonConf3DFECollection[] = {{&_swigt__p_mfem__LinearNonConf3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CrouzeixRaviartFECollection[] = {{&_swigt__p_mfem__CrouzeixRaviartFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticFECollection[] = {{&_swigt__p_mfem__QuadraticFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearFECollection[] = {{&_swigt__p_mfem__LinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBSFECollection[] = {{&_swigt__p_mfem__NURBSFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -17328,11 +18704,13 @@ static swig_cast_info _swigc__p_mfem__DG_Interface_FECollection[] = {{&_swigt__p static swig_cast_info _swigc__p_mfem__RT_Trace_FECollection[] = {{&_swigt__p_mfem__RT_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT_FECollection[] = {{&_swigt__p_mfem__RT_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_Trace_FECollection[] = {{&_swigt__p_mfem__H1_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_FECollection[] = {{&_swigt__p_mfem__H1Ser_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_FECollection[] = {{&_swigt__p_mfem__H1Pos_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_FECollection[] = {{&_swigt__p_mfem__H1_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Local_FECollection[] = {{&_swigt__p_mfem__Local_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationPoint[] = { {&_swigt__p_mfem__IntegrationPoint, 0, 0, 0},{0, 0, 0, 0}}; @@ -17390,6 +18768,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_hex_t, @@ -17431,11 +18810,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__GaussLinearDiscont2DFECollection, _swigc__p_mfem__GaussQuadraticDiscont2DFECollection, _swigc__p_mfem__GradientGridFunctionCoefficient, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GridFunctionCoefficient, _swigc__p_mfem__GroupConvectionIntegrator, _swigc__p_mfem__H1Pos_FECollection, + _swigc__p_mfem__H1Ser_FECollection, _swigc__p_mfem__H1_FECollection, _swigc__p_mfem__H1_Trace_FECollection, _swigc__p_mfem__HypreParVector, diff --git a/mfem/_par/handle.py b/mfem/_par/handle.py index 36c66314..7b661f9b 100644 --- a/mfem/_par/handle.py +++ b/mfem/_par/handle.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _handle.SWIG_PyInstanceMethod_New +_swig_new_static_method = _handle.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -112,74 +115,92 @@ def __init__(self, *args): def Ptr(self): r"""Ptr(OperatorHandle self) -> Operator""" return _handle.OperatorHandle_Ptr(self) + Ptr = _swig_new_instance_method(_handle.OperatorHandle_Ptr) def __deref__(self): r"""__deref__(OperatorHandle self) -> Operator""" return _handle.OperatorHandle___deref__(self) + __deref__ = _swig_new_instance_method(_handle.OperatorHandle___deref__) def __ref__(self): r"""__ref__(OperatorHandle self) -> Operator""" return _handle.OperatorHandle___ref__(self) + __ref__ = _swig_new_instance_method(_handle.OperatorHandle___ref__) def Type(self): r"""Type(OperatorHandle self) -> mfem::Operator::Type""" return _handle.OperatorHandle_Type(self) + Type = _swig_new_instance_method(_handle.OperatorHandle_Type) def OwnsOperator(self): r"""OwnsOperator(OperatorHandle self) -> bool""" return _handle.OperatorHandle_OwnsOperator(self) + OwnsOperator = _swig_new_instance_method(_handle.OperatorHandle_OwnsOperator) def SetOperatorOwner(self, own=True): r"""SetOperatorOwner(OperatorHandle self, bool own=True)""" return _handle.OperatorHandle_SetOperatorOwner(self, own) + SetOperatorOwner = _swig_new_instance_method(_handle.OperatorHandle_SetOperatorOwner) def Clear(self): r"""Clear(OperatorHandle self)""" return _handle.OperatorHandle_Clear(self) + Clear = _swig_new_instance_method(_handle.OperatorHandle_Clear) def SetType(self, tid): r"""SetType(OperatorHandle self, mfem::Operator::Type tid)""" return _handle.OperatorHandle_SetType(self, tid) + SetType = _swig_new_instance_method(_handle.OperatorHandle_SetType) def MakeSquareBlockDiag(self, comm, glob_size, row_starts, diag): r"""MakeSquareBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * row_starts, SparseMatrix diag)""" return _handle.OperatorHandle_MakeSquareBlockDiag(self, comm, glob_size, row_starts, diag) + MakeSquareBlockDiag = _swig_new_instance_method(_handle.OperatorHandle_MakeSquareBlockDiag) def MakeRectangularBlockDiag(self, comm, glob_num_rows, glob_num_cols, row_starts, col_starts, diag): r"""MakeRectangularBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_num_rows, HYPRE_Int glob_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag)""" return _handle.OperatorHandle_MakeRectangularBlockDiag(self, comm, glob_num_rows, glob_num_cols, row_starts, col_starts, diag) + MakeRectangularBlockDiag = _swig_new_instance_method(_handle.OperatorHandle_MakeRectangularBlockDiag) def MakePtAP(self, A, P): r"""MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)""" return _handle.OperatorHandle_MakePtAP(self, A, P) + MakePtAP = _swig_new_instance_method(_handle.OperatorHandle_MakePtAP) def MakeRAP(self, Rt, A, P): r"""MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)""" return _handle.OperatorHandle_MakeRAP(self, Rt, A, P) + MakeRAP = _swig_new_instance_method(_handle.OperatorHandle_MakeRAP) def EliminateRowsCols(self, A, ess_dof_list): r"""EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)""" return _handle.OperatorHandle_EliminateRowsCols(self, A, ess_dof_list) + EliminateRowsCols = _swig_new_instance_method(_handle.OperatorHandle_EliminateRowsCols) def EliminateBC(self, A_e, ess_dof_list, X, B): r"""EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)""" return _handle.OperatorHandle_EliminateBC(self, A_e, ess_dof_list, X, B) + EliminateBC = _swig_new_instance_method(_handle.OperatorHandle_EliminateBC) def As(self): r"""As(OperatorHandle self) -> HypreParMatrix""" return _handle.OperatorHandle_As(self) + As = _swig_new_instance_method(_handle.OperatorHandle_As) def Is(self): r"""Is(OperatorHandle self) -> HypreParMatrix""" return _handle.OperatorHandle_Is(self) + Is = _swig_new_instance_method(_handle.OperatorHandle_Is) def Get(self, A): r"""Get(OperatorHandle self, mfem::HypreParMatrix *& A)""" return _handle.OperatorHandle_Get(self, A) + Get = _swig_new_instance_method(_handle.OperatorHandle_Get) def Reset(self, A, own_A=True): r"""Reset(OperatorHandle self, HypreParMatrix A, bool own_A=True)""" return _handle.OperatorHandle_Reset(self, A, own_A) + Reset = _swig_new_instance_method(_handle.OperatorHandle_Reset) def ConvertFrom(self, *args): r""" @@ -187,62 +208,112 @@ def ConvertFrom(self, *args): ConvertFrom(OperatorHandle self, HypreParMatrix A) """ return _handle.OperatorHandle_ConvertFrom(self, *args) + ConvertFrom = _swig_new_instance_method(_handle.OperatorHandle_ConvertFrom) + + def InitTVectors(self, Po, Ri, Pi, x, b, X, B): + r"""InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)""" + return _handle.OperatorHandle_InitTVectors(self, Po, Ri, Pi, x, b, X, B) + InitTVectors = _swig_new_instance_method(_handle.OperatorHandle_InitTVectors) def Height(self): r"""Height(OperatorHandle self) -> int""" return _handle.OperatorHandle_Height(self) + Height = _swig_new_instance_method(_handle.OperatorHandle_Height) def NumRows(self): r"""NumRows(OperatorHandle self) -> int""" return _handle.OperatorHandle_NumRows(self) + NumRows = _swig_new_instance_method(_handle.OperatorHandle_NumRows) def Width(self): r"""Width(OperatorHandle self) -> int""" return _handle.OperatorHandle_Width(self) + Width = _swig_new_instance_method(_handle.OperatorHandle_Width) def NumCols(self): r"""NumCols(OperatorHandle self) -> int""" return _handle.OperatorHandle_NumCols(self) + NumCols = _swig_new_instance_method(_handle.OperatorHandle_NumCols) def GetMemoryClass(self): r"""GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass""" return _handle.OperatorHandle_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_handle.OperatorHandle_GetMemoryClass) def Mult(self, x, y): r"""Mult(OperatorHandle self, Vector x, Vector y)""" return _handle.OperatorHandle_Mult(self, x, y) + Mult = _swig_new_instance_method(_handle.OperatorHandle_Mult) def MultTranspose(self, x, y): r"""MultTranspose(OperatorHandle self, Vector x, Vector y)""" return _handle.OperatorHandle_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_handle.OperatorHandle_MultTranspose) def GetGradient(self, x): r"""GetGradient(OperatorHandle self, Vector x) -> Operator""" return _handle.OperatorHandle_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_handle.OperatorHandle_GetGradient) def GetProlongation(self): r"""GetProlongation(OperatorHandle self) -> Operator""" return _handle.OperatorHandle_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_handle.OperatorHandle_GetProlongation) def GetRestriction(self): r"""GetRestriction(OperatorHandle self) -> Operator""" return _handle.OperatorHandle_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_handle.OperatorHandle_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(OperatorHandle self) -> Operator""" + return _handle.OperatorHandle_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_handle.OperatorHandle_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(OperatorHandle self) -> Operator""" + return _handle.OperatorHandle_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_handle.OperatorHandle_GetOutputRestriction) def FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior=0): r"""FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)""" return _handle.OperatorHandle_FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior) + FormLinearSystem = _swig_new_instance_method(_handle.OperatorHandle_FormLinearSystem) + + def FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B): + r"""FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)""" + return _handle.OperatorHandle_FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B) + FormRectangularLinearSystem = _swig_new_instance_method(_handle.OperatorHandle_FormRectangularLinearSystem) def RecoverFEMSolution(self, X, b, x): r"""RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)""" return _handle.OperatorHandle_RecoverFEMSolution(self, X, b, x) + RecoverFEMSolution = _swig_new_instance_method(_handle.OperatorHandle_RecoverFEMSolution) + + def FormSystemOperator(self, ess_tdof_list, A): + r"""FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)""" + return _handle.OperatorHandle_FormSystemOperator(self, ess_tdof_list, A) + FormSystemOperator = _swig_new_instance_method(_handle.OperatorHandle_FormSystemOperator) + + def FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A): + r"""FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)""" + return _handle.OperatorHandle_FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A) + FormRectangularSystemOperator = _swig_new_instance_method(_handle.OperatorHandle_FormRectangularSystemOperator) + + def FormDiscreteOperator(self, A): + r"""FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)""" + return _handle.OperatorHandle_FormDiscreteOperator(self, A) + FormDiscreteOperator = _swig_new_instance_method(_handle.OperatorHandle_FormDiscreteOperator) def PrintMatlab(self, out, n=0, m=0): r"""PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)""" return _handle.OperatorHandle_PrintMatlab(self, out, n, m) + PrintMatlab = _swig_new_instance_method(_handle.OperatorHandle_PrintMatlab) def GetType(self): r"""GetType(OperatorHandle self) -> mfem::Operator::Type""" return _handle.OperatorHandle_GetType(self) + GetType = _swig_new_instance_method(_handle.OperatorHandle_GetType) # Register OperatorHandle in _handle: _handle.OperatorHandle_swigregister(OperatorHandle) diff --git a/mfem/_par/handle_wrap.cxx b/mfem/_par/handle_wrap.cxx index f3d5b414..25506707 100644 --- a/mfem/_par/handle_wrap.cxx +++ b/mfem/_par/handle_wrap.cxx @@ -3096,43 +3096,49 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[28] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[29] #define SWIGTYPE_p_mfem__RAPOperator swig_types[30] -#define SWIGTYPE_p_mfem__Solver swig_types[31] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[32] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[33] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[34] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[35] -#define SWIGTYPE_p_mfem__Vector swig_types[36] -#define SWIGTYPE_p_p_mfem__AbstractSparseMatrix swig_types[37] -#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[38] -#define SWIGTYPE_p_p_mfem__DenseMatrix swig_types[39] -#define SWIGTYPE_p_p_mfem__DenseMatrixInverse swig_types[40] -#define SWIGTYPE_p_p_mfem__HypreADS swig_types[41] -#define SWIGTYPE_p_p_mfem__HypreAMS swig_types[42] -#define SWIGTYPE_p_p_mfem__HypreBoomerAMG swig_types[43] -#define SWIGTYPE_p_p_mfem__HypreDiagScale swig_types[44] -#define SWIGTYPE_p_p_mfem__HypreEuclid swig_types[45] -#define SWIGTYPE_p_p_mfem__HypreGMRES swig_types[46] -#define SWIGTYPE_p_p_mfem__HypreIdentity swig_types[47] -#define SWIGTYPE_p_p_mfem__HyprePCG swig_types[48] -#define SWIGTYPE_p_p_mfem__HypreParMatrix swig_types[49] -#define SWIGTYPE_p_p_mfem__HypreParaSails swig_types[50] -#define SWIGTYPE_p_p_mfem__HypreSmoother swig_types[51] -#define SWIGTYPE_p_p_mfem__HypreSolver swig_types[52] -#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[53] -#define SWIGTYPE_p_p_mfem__Matrix swig_types[54] -#define SWIGTYPE_p_p_mfem__MatrixInverse swig_types[55] -#define SWIGTYPE_p_p_mfem__Operator swig_types[56] -#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[57] -#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[58] -#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[59] -#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[60] -#define SWIGTYPE_p_p_mfem__Solver swig_types[61] -#define SWIGTYPE_p_p_mfem__SparseMatrix swig_types[62] -#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[63] -#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[64] -#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[65] -static swig_type_info *swig_types[67]; -static swig_module_info swig_module = {swig_types, 66, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[31] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[32] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[33] +#define SWIGTYPE_p_mfem__Solver swig_types[34] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[35] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[36] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[37] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[38] +#define SWIGTYPE_p_mfem__Vector swig_types[39] +#define SWIGTYPE_p_p_mfem__AbstractSparseMatrix swig_types[40] +#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[41] +#define SWIGTYPE_p_p_mfem__DenseMatrix swig_types[42] +#define SWIGTYPE_p_p_mfem__DenseMatrixInverse swig_types[43] +#define SWIGTYPE_p_p_mfem__HypreADS swig_types[44] +#define SWIGTYPE_p_p_mfem__HypreAMS swig_types[45] +#define SWIGTYPE_p_p_mfem__HypreBoomerAMG swig_types[46] +#define SWIGTYPE_p_p_mfem__HypreDiagScale swig_types[47] +#define SWIGTYPE_p_p_mfem__HypreEuclid swig_types[48] +#define SWIGTYPE_p_p_mfem__HypreGMRES swig_types[49] +#define SWIGTYPE_p_p_mfem__HypreIdentity swig_types[50] +#define SWIGTYPE_p_p_mfem__HyprePCG swig_types[51] +#define SWIGTYPE_p_p_mfem__HypreParMatrix swig_types[52] +#define SWIGTYPE_p_p_mfem__HypreParaSails swig_types[53] +#define SWIGTYPE_p_p_mfem__HypreSmoother swig_types[54] +#define SWIGTYPE_p_p_mfem__HypreSolver swig_types[55] +#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[56] +#define SWIGTYPE_p_p_mfem__Matrix swig_types[57] +#define SWIGTYPE_p_p_mfem__MatrixInverse swig_types[58] +#define SWIGTYPE_p_p_mfem__Operator swig_types[59] +#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[60] +#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[61] +#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[62] +#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[63] +#define SWIGTYPE_p_p_mfem__RectangularConstrainedOperator swig_types[64] +#define SWIGTYPE_p_p_mfem__ScaledOperator swig_types[65] +#define SWIGTYPE_p_p_mfem__SecondOrderTimeDependentOperator swig_types[66] +#define SWIGTYPE_p_p_mfem__Solver swig_types[67] +#define SWIGTYPE_p_p_mfem__SparseMatrix swig_types[68] +#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[69] +#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[70] +#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[71] +static swig_type_info *swig_types[73]; +static swig_module_info swig_module = {swig_types, 72, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4777,6 +4783,107 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom(PyObject *self, PyObject * } +SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Operator *arg2 = (mfem::Operator *) 0 ; + mfem::Operator *arg3 = (mfem::Operator *) 0 ; + mfem::Operator *arg4 = (mfem::Operator *) 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_InitTVectors", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_InitTVectors" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); + } + arg3 = reinterpret_cast< mfem::Operator * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); + } + arg4 = reinterpret_cast< mfem::Operator * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + (*arg1)->InitTVectors((mfem::Operator const *)arg2,(mfem::Operator const *)arg3,(mfem::Operator const *)arg4,*arg5,*arg6,*arg7,*arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_Height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5177,6 +5284,76 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetRestriction(PyObject *SWIGUNUSEDPAR } +SWIGINTERN PyObject *_wrap_OperatorHandle_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_GetOutputProlongation" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + { + try { + result = (mfem::Operator *)(*arg1)->GetOutputProlongation(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OperatorHandle_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_GetOutputRestriction" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + { + try { + result = (mfem::Operator *)(*arg1)->GetOutputRestriction(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5484,6 +5661,116 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem(PyObject *self, PyObj } +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Operator **arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + arg6 = reinterpret_cast< mfem::Operator ** >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + (*arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5550,6 +5837,171 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE } +SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Operator **arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); + } + arg3 = reinterpret_cast< mfem::Operator ** >(argp3); + { + try { + (*arg1)->FormSystemOperator((mfem::Array< int > const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Operator **arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + arg4 = reinterpret_cast< mfem::Operator ** >(argp4); + { + try { + (*arg1)->FormRectangularSystemOperator((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Operator **arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + arg2 = reinterpret_cast< mfem::Operator ** >(argp2); + { + try { + (*arg1)->FormDiscreteOperator(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5908,6 +6360,7 @@ SWIGINTERN PyObject *OperatorHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_OperatorHandle", _wrap_new_OperatorHandle, METH_VARARGS, "\n" "OperatorHandle()\n" "new_OperatorHandle(mfem::Operator::Type tid) -> OperatorHandle\n" @@ -5935,6 +6388,7 @@ static PyMethodDef SwigMethods[] = { "OperatorHandle_ConvertFrom(OperatorHandle self, OperatorHandle A)\n" "OperatorHandle_ConvertFrom(OperatorHandle self, HypreParMatrix A)\n" ""}, + { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "OperatorHandle_InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "OperatorHandle_Height(OperatorHandle self) -> int"}, { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "OperatorHandle_NumRows(OperatorHandle self) -> int"}, { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "OperatorHandle_Width(OperatorHandle self) -> int"}, @@ -5945,8 +6399,14 @@ static PyMethodDef SwigMethods[] = { { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "OperatorHandle_GetGradient(OperatorHandle self, Vector x) -> Operator"}, { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "OperatorHandle_GetProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "OperatorHandle_GetRestriction(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "OperatorHandle_GetOutputProlongation(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "OperatorHandle_GetOutputRestriction(OperatorHandle self) -> Operator"}, { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "OperatorHandle_FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "OperatorHandle_FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "OperatorHandle_RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "OperatorHandle_FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "OperatorHandle_FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "OperatorHandle_FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "OperatorHandle_PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "OperatorHandle_GetType(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, @@ -5955,6 +6415,58 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_OperatorHandle", _wrap_new_OperatorHandle, METH_VARARGS, "\n" + "OperatorHandle()\n" + "new_OperatorHandle(mfem::Operator::Type tid) -> OperatorHandle\n" + ""}, + { "delete_OperatorHandle", _wrap_delete_OperatorHandle, METH_O, "delete_OperatorHandle(OperatorHandle self)"}, + { "OperatorHandle_Ptr", _wrap_OperatorHandle_Ptr, METH_O, "Ptr(OperatorHandle self) -> Operator"}, + { "OperatorHandle___deref__", _wrap_OperatorHandle___deref__, METH_O, "__deref__(OperatorHandle self) -> Operator"}, + { "OperatorHandle___ref__", _wrap_OperatorHandle___ref__, METH_O, "__ref__(OperatorHandle self) -> Operator"}, + { "OperatorHandle_Type", _wrap_OperatorHandle_Type, METH_O, "Type(OperatorHandle self) -> mfem::Operator::Type"}, + { "OperatorHandle_OwnsOperator", _wrap_OperatorHandle_OwnsOperator, METH_O, "OwnsOperator(OperatorHandle self) -> bool"}, + { "OperatorHandle_SetOperatorOwner", _wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS, "SetOperatorOwner(OperatorHandle self, bool own=True)"}, + { "OperatorHandle_Clear", _wrap_OperatorHandle_Clear, METH_O, "Clear(OperatorHandle self)"}, + { "OperatorHandle_SetType", _wrap_OperatorHandle_SetType, METH_VARARGS, "SetType(OperatorHandle self, mfem::Operator::Type tid)"}, + { "OperatorHandle_MakeSquareBlockDiag", _wrap_OperatorHandle_MakeSquareBlockDiag, METH_VARARGS, "MakeSquareBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * row_starts, SparseMatrix diag)"}, + { "OperatorHandle_MakeRectangularBlockDiag", _wrap_OperatorHandle_MakeRectangularBlockDiag, METH_VARARGS, "MakeRectangularBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_num_rows, HYPRE_Int glob_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag)"}, + { "OperatorHandle_MakePtAP", _wrap_OperatorHandle_MakePtAP, METH_VARARGS, "MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_MakeRAP", _wrap_OperatorHandle_MakeRAP, METH_VARARGS, "MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_EliminateRowsCols", _wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS, "EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, + { "OperatorHandle_EliminateBC", _wrap_OperatorHandle_EliminateBC, METH_VARARGS, "EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, + { "OperatorHandle_As", _wrap_OperatorHandle_As, METH_O, "As(OperatorHandle self) -> HypreParMatrix"}, + { "OperatorHandle_Is", _wrap_OperatorHandle_Is, METH_O, "Is(OperatorHandle self) -> HypreParMatrix"}, + { "OperatorHandle_Get", _wrap_OperatorHandle_Get, METH_VARARGS, "Get(OperatorHandle self, mfem::HypreParMatrix *& A)"}, + { "OperatorHandle_Reset", _wrap_OperatorHandle_Reset, METH_VARARGS, "Reset(OperatorHandle self, HypreParMatrix A, bool own_A=True)"}, + { "OperatorHandle_ConvertFrom", _wrap_OperatorHandle_ConvertFrom, METH_VARARGS, "\n" + "ConvertFrom(OperatorHandle self, OperatorHandle A)\n" + "ConvertFrom(OperatorHandle self, HypreParMatrix A)\n" + ""}, + { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "Height(OperatorHandle self) -> int"}, + { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "NumRows(OperatorHandle self) -> int"}, + { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "Width(OperatorHandle self) -> int"}, + { "OperatorHandle_NumCols", _wrap_OperatorHandle_NumCols, METH_O, "NumCols(OperatorHandle self) -> int"}, + { "OperatorHandle_GetMemoryClass", _wrap_OperatorHandle_GetMemoryClass, METH_O, "GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass"}, + { "OperatorHandle_Mult", _wrap_OperatorHandle_Mult, METH_VARARGS, "Mult(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_MultTranspose", _wrap_OperatorHandle_MultTranspose, METH_VARARGS, "MultTranspose(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "GetGradient(OperatorHandle self, Vector x) -> Operator"}, + { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "GetProlongation(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "GetRestriction(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "GetOutputProlongation(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "GetOutputRestriction(OperatorHandle self) -> Operator"}, + { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, + { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, + { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "GetType(OperatorHandle self) -> mfem::Operator::Type"}, + { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, + { "OperatorHandle_swiginit", OperatorHandle_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5997,12 +6509,12 @@ static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(new static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } @@ -6024,6 +6536,9 @@ static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPAR static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -6039,9 +6554,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -6081,12 +6602,12 @@ static void *_p_p_mfem__SolverTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM static void *_p_p_mfem__HypreIdentityTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity **) x)); } -static void *_p_p_mfem__DenseMatrixTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator **) (mfem::Matrix *) ((mfem::DenseMatrix **) x)); -} static void *_p_p_mfem__AbstractSparseMatrixTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) (mfem::Matrix *) ((mfem::AbstractSparseMatrix **) x)); } +static void *_p_p_mfem__DenseMatrixTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) (mfem::Matrix *) ((mfem::DenseMatrix **) x)); +} static void *_p_p_mfem__SparseMatrixTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix **) x)); } @@ -6108,6 +6629,9 @@ static void *_p_p_mfem__HypreEuclidTo_p_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_p_mfem__HypreADSTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS **) x)); } +static void *_p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::RectangularConstrainedOperator **) x)); +} static void *_p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::ConstrainedOperator **) x)); } @@ -6123,9 +6647,15 @@ static void *_p_p_mfem__ProductOperatorTo_p_p_mfem__Operator(void *x, int *SWIGU static void *_p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TransposeOperator **) x)); } +static void *_p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::ScaledOperator **) x)); +} static void *_p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::IdentityOperator **) x)); } +static void *_p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator **) x)); +} static void *_p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TimeDependentOperator **) x)); } @@ -6150,19 +6680,22 @@ static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreSmoother = {"_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; @@ -6182,20 +6715,23 @@ static swig_type_info _swigt__p_p_mfem__MatrixInverse = {"_p_p_mfem__MatrixInver static swig_type_info _swigt__p_p_mfem__DenseMatrixInverse = {"_p_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__HypreDiagScale = {"_p_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__HypreIdentity = {"_p_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_p_mfem__DenseMatrix = {"_p_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__AbstractSparseMatrix = {"_p_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__DenseMatrix = {"_p_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__SparseMatrix = {"_p_p_mfem__SparseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__Matrix = {"_p_p_mfem__Matrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__HyprePCG = {"_p_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__HypreAMS = {"_p_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__HypreEuclid = {"_p_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__HypreADS = {"_p_p_mfem__HypreADS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__RectangularConstrainedOperator = {"_p_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ConstrainedOperator = {"_p_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TripleProductOperator = {"_p_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__RAPOperator = {"_p_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ProductOperator = {"_p_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TransposeOperator = {"_p_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__ScaledOperator = {"_p_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__IdentityOperator = {"_p_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__SecondOrderTimeDependentOperator = {"_p_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TimeDependentOperator = {"_p_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__HypreSmoother = {"_p_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; @@ -6231,6 +6767,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -6261,6 +6800,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_p_mfem__PyOperatorBase, &_swigt__p_p_mfem__PyTimeDependentOperatorBase, &_swigt__p_p_mfem__RAPOperator, + &_swigt__p_p_mfem__RectangularConstrainedOperator, + &_swigt__p_p_mfem__ScaledOperator, + &_swigt__p_p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_p_mfem__Solver, &_swigt__p_p_mfem__SparseMatrix, &_swigt__p_p_mfem__TimeDependentOperator, @@ -6285,22 +6827,25 @@ static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__Matri static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; @@ -6317,23 +6862,26 @@ static swig_cast_info _swigc__p_p_mfem__MatrixInverse[] = {{&_swigt__p_p_mfem__M static swig_cast_info _swigc__p_p_mfem__DenseMatrixInverse[] = {{&_swigt__p_p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__HypreDiagScale[] = {{&_swigt__p_p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__HypreIdentity[] = {{&_swigt__p_p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__DenseMatrix[] = {{&_swigt__p_p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__DenseMatrix[] = {{&_swigt__p_p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__SparseMatrix[] = {{&_swigt__p_p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Matrix[] = {{&_swigt__p_p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__HyprePCG[] = {{&_swigt__p_p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__HypreAMS[] = {{&_swigt__p_p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__HypreEuclid[] = {{&_swigt__p_p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__HypreADS[] = {{&_swigt__p_p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ConstrainedOperator[] = {{&_swigt__p_p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TripleProductOperator[] = {{&_swigt__p_p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__RAPOperator[] = {{&_swigt__p_p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ProductOperator[] = {{&_swigt__p_p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TransposeOperator[] = {{&_swigt__p_p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__ScaledOperator[] = {{&_swigt__p_p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__IdentityOperator[] = {{&_swigt__p_p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TimeDependentOperator[] = {{&_swigt__p_p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__HypreSmoother[] = {{&_swigt__p_p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreGMRES, _p_p_mfem__HypreGMRESTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreParaSails, _p_p_mfem__HypreParaSailsTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreSolver, _p_p_mfem__HypreSolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreBoomerAMG, _p_p_mfem__HypreBoomerAMGTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__MatrixInverse, _p_p_mfem__MatrixInverseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__DenseMatrixInverse, _p_p_mfem__DenseMatrixInverseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreDiagScale, _p_p_mfem__HypreDiagScaleTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreIdentity, _p_p_mfem__HypreIdentityTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__DenseMatrix, _p_p_mfem__DenseMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__AbstractSparseMatrix, _p_p_mfem__AbstractSparseMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__SparseMatrix, _p_p_mfem__SparseMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Matrix, _p_p_mfem__MatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreParMatrix, _p_p_mfem__HypreParMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HyprePCG, _p_p_mfem__HyprePCGTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreAMS, _p_p_mfem__HypreAMSTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreEuclid, _p_p_mfem__HypreEuclidTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreADS, _p_p_mfem__HypreADSTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreSmoother, _p_p_mfem__HypreSmootherTo_p_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreGMRES, _p_p_mfem__HypreGMRESTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreParaSails, _p_p_mfem__HypreParaSailsTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreSolver, _p_p_mfem__HypreSolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreBoomerAMG, _p_p_mfem__HypreBoomerAMGTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__MatrixInverse, _p_p_mfem__MatrixInverseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__DenseMatrixInverse, _p_p_mfem__DenseMatrixInverseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreDiagScale, _p_p_mfem__HypreDiagScaleTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreIdentity, _p_p_mfem__HypreIdentityTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__AbstractSparseMatrix, _p_p_mfem__AbstractSparseMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__DenseMatrix, _p_p_mfem__DenseMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__SparseMatrix, _p_p_mfem__SparseMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Matrix, _p_p_mfem__MatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreParMatrix, _p_p_mfem__HypreParMatrixTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HyprePCG, _p_p_mfem__HyprePCGTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreAMS, _p_p_mfem__HypreAMSTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreEuclid, _p_p_mfem__HypreEuclidTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreADS, _p_p_mfem__HypreADSTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0}, {&_swigt__p_p_mfem__RectangularConstrainedOperator, _p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ScaledOperator, _p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, _p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__HypreSmoother, _p_p_mfem__HypreSmootherTo_p_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, @@ -6367,6 +6915,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, @@ -6397,6 +6948,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_p_mfem__PyOperatorBase, _swigc__p_p_mfem__PyTimeDependentOperatorBase, _swigc__p_p_mfem__RAPOperator, + _swigc__p_p_mfem__RectangularConstrainedOperator, + _swigc__p_p_mfem__ScaledOperator, + _swigc__p_p_mfem__SecondOrderTimeDependentOperator, _swigc__p_p_mfem__Solver, _swigc__p_p_mfem__SparseMatrix, _swigc__p_p_mfem__TimeDependentOperator, @@ -7131,18 +7685,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/hash.py b/mfem/_par/hash.py index 6c572199..d07a5926 100644 --- a/mfem/_par/hash.py +++ b/mfem/_par/hash.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _hash.SWIG_PyInstanceMethod_New +_swig_new_static_method = _hash.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -103,9 +106,16 @@ def __init__(self): def sort3(a, b, c): r"""sort3(int & a, int & b, int & c)""" return _hash.sort3(a, b, c) +sort3 = _hash.sort3 def sort4(a, b, c, d): r"""sort4(int & a, int & b, int & c, int & d)""" return _hash.sort4(a, b, c, d) +sort4 = _hash.sort4 + +def sort4_ext(a, b, c, d): + r"""sort4_ext(int & a, int & b, int & c, int & d)""" + return _hash.sort4_ext(a, b, c, d) +sort4_ext = _hash.sort4_ext diff --git a/mfem/_par/hash_wrap.cxx b/mfem/_par/hash_wrap.cxx index b7ec90e4..edf4b001 100644 --- a/mfem/_par/hash_wrap.cxx +++ b/mfem/_par/hash_wrap.cxx @@ -3425,8 +3425,81 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } +SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "sort4_ext", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); + } + arg1 = reinterpret_cast< int * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sort4_ext" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + { + try { + mfem::internal::sort4_ext(*arg1,*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Hashed2_p1_set", _wrap_Hashed2_p1_set, METH_VARARGS, "Hashed2_p1_set(Hashed2 self, int p1)"}, { "Hashed2_p1_get", _wrap_Hashed2_p1_get, METH_O, "Hashed2_p1_get(Hashed2 self) -> int"}, { "Hashed2_p2_set", _wrap_Hashed2_p2_set, METH_VARARGS, "Hashed2_p2_set(Hashed2 self, int p2)"}, @@ -3451,10 +3524,38 @@ static PyMethodDef SwigMethods[] = { { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Hashed2_p1_set", _wrap_Hashed2_p1_set, METH_VARARGS, "Hashed2_p1_set(Hashed2 self, int p1)"}, + { "Hashed2_p1_get", _wrap_Hashed2_p1_get, METH_O, "Hashed2_p1_get(Hashed2 self) -> int"}, + { "Hashed2_p2_set", _wrap_Hashed2_p2_set, METH_VARARGS, "Hashed2_p2_set(Hashed2 self, int p2)"}, + { "Hashed2_p2_get", _wrap_Hashed2_p2_get, METH_O, "Hashed2_p2_get(Hashed2 self) -> int"}, + { "Hashed2_next_set", _wrap_Hashed2_next_set, METH_VARARGS, "Hashed2_next_set(Hashed2 self, int next)"}, + { "Hashed2_next_get", _wrap_Hashed2_next_get, METH_O, "Hashed2_next_get(Hashed2 self) -> int"}, + { "new_Hashed2", _wrap_new_Hashed2, METH_NOARGS, "new_Hashed2() -> Hashed2"}, + { "delete_Hashed2", _wrap_delete_Hashed2, METH_O, "delete_Hashed2(Hashed2 self)"}, + { "Hashed2_swigregister", Hashed2_swigregister, METH_O, NULL}, + { "Hashed2_swiginit", Hashed2_swiginit, METH_VARARGS, NULL}, + { "Hashed4_p1_set", _wrap_Hashed4_p1_set, METH_VARARGS, "Hashed4_p1_set(Hashed4 self, int p1)"}, + { "Hashed4_p1_get", _wrap_Hashed4_p1_get, METH_O, "Hashed4_p1_get(Hashed4 self) -> int"}, + { "Hashed4_p2_set", _wrap_Hashed4_p2_set, METH_VARARGS, "Hashed4_p2_set(Hashed4 self, int p2)"}, + { "Hashed4_p2_get", _wrap_Hashed4_p2_get, METH_O, "Hashed4_p2_get(Hashed4 self) -> int"}, + { "Hashed4_p3_set", _wrap_Hashed4_p3_set, METH_VARARGS, "Hashed4_p3_set(Hashed4 self, int p3)"}, + { "Hashed4_p3_get", _wrap_Hashed4_p3_get, METH_O, "Hashed4_p3_get(Hashed4 self) -> int"}, + { "Hashed4_next_set", _wrap_Hashed4_next_set, METH_VARARGS, "Hashed4_next_set(Hashed4 self, int next)"}, + { "Hashed4_next_get", _wrap_Hashed4_next_get, METH_O, "Hashed4_next_get(Hashed4 self) -> int"}, + { "new_Hashed4", _wrap_new_Hashed4, METH_NOARGS, "new_Hashed4() -> Hashed4"}, + { "delete_Hashed4", _wrap_delete_Hashed4, METH_O, "delete_Hashed4(Hashed4 self)"}, + { "Hashed4_swigregister", Hashed4_swigregister, METH_O, NULL}, + { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, + { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, + { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/hybridization.py b/mfem/_par/hybridization.py index e74da6f7..c46111a2 100644 --- a/mfem/_par/hybridization.py +++ b/mfem/_par/hybridization.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _hybridization.SWIG_PyInstanceMethod_New +_swig_new_static_method = _hybridization.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -80,6 +83,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -89,6 +93,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.fe_coll import mfem._par.lininteg import mfem._par.linearform +import mfem._par.restriction class Hybridization(object): r"""Proxy of C++ mfem::Hybridization class.""" @@ -103,26 +108,32 @@ def __init__(self, fespace, c_fespace): def SetConstraintIntegrator(self, c_integ): r"""SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)""" return _hybridization.Hybridization_SetConstraintIntegrator(self, c_integ) + SetConstraintIntegrator = _swig_new_instance_method(_hybridization.Hybridization_SetConstraintIntegrator) def Init(self, ess_tdof_list): r"""Init(Hybridization self, intArray ess_tdof_list)""" return _hybridization.Hybridization_Init(self, ess_tdof_list) + Init = _swig_new_instance_method(_hybridization.Hybridization_Init) def AssembleMatrix(self, el, A): r"""AssembleMatrix(Hybridization self, int el, DenseMatrix A)""" return _hybridization.Hybridization_AssembleMatrix(self, el, A) + AssembleMatrix = _swig_new_instance_method(_hybridization.Hybridization_AssembleMatrix) def AssembleBdrMatrix(self, bdr_el, A): r"""AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)""" return _hybridization.Hybridization_AssembleBdrMatrix(self, bdr_el, A) + AssembleBdrMatrix = _swig_new_instance_method(_hybridization.Hybridization_AssembleBdrMatrix) def Finalize(self): r"""Finalize(Hybridization self)""" return _hybridization.Hybridization_Finalize(self) + Finalize = _swig_new_instance_method(_hybridization.Hybridization_Finalize) def GetMatrix(self): r"""GetMatrix(Hybridization self) -> SparseMatrix""" return _hybridization.Hybridization_GetMatrix(self) + GetMatrix = _swig_new_instance_method(_hybridization.Hybridization_GetMatrix) def GetParallelMatrix(self, *args): r""" @@ -130,22 +141,27 @@ def GetParallelMatrix(self, *args): GetParallelMatrix(Hybridization self, OperatorHandle H_h) """ return _hybridization.Hybridization_GetParallelMatrix(self, *args) + GetParallelMatrix = _swig_new_instance_method(_hybridization.Hybridization_GetParallelMatrix) def SetOperatorType(self, tid): r"""SetOperatorType(Hybridization self, mfem::Operator::Type tid)""" return _hybridization.Hybridization_SetOperatorType(self, tid) + SetOperatorType = _swig_new_instance_method(_hybridization.Hybridization_SetOperatorType) def ReduceRHS(self, b, b_r): r"""ReduceRHS(Hybridization self, Vector b, Vector b_r)""" return _hybridization.Hybridization_ReduceRHS(self, b, b_r) + ReduceRHS = _swig_new_instance_method(_hybridization.Hybridization_ReduceRHS) def ComputeSolution(self, b, sol_r, sol): r"""ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)""" return _hybridization.Hybridization_ComputeSolution(self, b, sol_r, sol) + ComputeSolution = _swig_new_instance_method(_hybridization.Hybridization_ComputeSolution) def Reset(self): r"""Reset(Hybridization self)""" return _hybridization.Hybridization_Reset(self) + Reset = _swig_new_instance_method(_hybridization.Hybridization_Reset) # Register Hybridization in _hybridization: _hybridization.Hybridization_swigregister(Hybridization) diff --git a/mfem/_par/hybridization_wrap.cxx b/mfem/_par/hybridization_wrap.cxx index 264b6883..e551b1e0 100644 --- a/mfem/_par/hybridization_wrap.cxx +++ b/mfem/_par/hybridization_wrap.cxx @@ -3064,107 +3064,109 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[5] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[6] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[7] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[8] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[10] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[11] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[12] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[14] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[17] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[18] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[19] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[20] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[21] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[22] -#define SWIGTYPE_p_mfem__GridFunction swig_types[23] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[24] -#define SWIGTYPE_p_mfem__Hybridization swig_types[25] -#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[26] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[27] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[28] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[29] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[31] -#define SWIGTYPE_p_mfem__LinearForm swig_types[32] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[33] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[35] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[36] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[38] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[39] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[40] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[41] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[42] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[43] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[44] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[45] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[46] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[47] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[48] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[49] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[50] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[51] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[53] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[57] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[58] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[59] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[60] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[61] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[62] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[63] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[66] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[67] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[74] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[75] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[76] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[77] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[78] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[79] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[80] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[82] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[83] -#define SWIGTYPE_p_mfem__Vector swig_types[84] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[85] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[86] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[90] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[93] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[94] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[95] -#define SWIGTYPE_p_pri_t swig_types[96] -#define SWIGTYPE_p_quad_t swig_types[97] -#define SWIGTYPE_p_seg_t swig_types[98] -#define SWIGTYPE_p_tet_t swig_types[99] -#define SWIGTYPE_p_tri_t swig_types[100] -static swig_type_info *swig_types[102]; -static swig_module_info swig_module = {swig_types, 101, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[7] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[8] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[9] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[10] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[11] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[12] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[13] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[15] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[18] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[19] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[20] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[21] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[22] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[23] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[24] +#define SWIGTYPE_p_mfem__GridFunction swig_types[25] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[26] +#define SWIGTYPE_p_mfem__Hybridization swig_types[27] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[28] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[29] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[30] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[31] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[33] +#define SWIGTYPE_p_mfem__LinearForm swig_types[34] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[36] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[37] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[39] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[40] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[41] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[42] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[43] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[44] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[45] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[46] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[47] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[48] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[49] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[50] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[51] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[52] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[53] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[56] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[57] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[60] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[61] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[62] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[63] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[64] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[65] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[66] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[69] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[70] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[76] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[77] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[78] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[79] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[80] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[81] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[82] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[84] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[85] +#define SWIGTYPE_p_mfem__Vector swig_types[86] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[87] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[91] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[93] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[95] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[96] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[97] +#define SWIGTYPE_p_pri_t swig_types[98] +#define SWIGTYPE_p_quad_t swig_types[99] +#define SWIGTYPE_p_seg_t swig_types[100] +#define SWIGTYPE_p_tet_t swig_types[101] +#define SWIGTYPE_p_tri_t swig_types[102] +static swig_type_info *swig_types[104]; +static swig_module_info swig_module = {swig_types, 103, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4026,6 +4028,7 @@ SWIGINTERN PyObject *Hybridization_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "Hybridization_SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, @@ -4048,6 +4051,26 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, + { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, + { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, + { "Hybridization_Init", _wrap_Hybridization_Init, METH_VARARGS, "Init(Hybridization self, intArray ess_tdof_list)"}, + { "Hybridization_AssembleMatrix", _wrap_Hybridization_AssembleMatrix, METH_VARARGS, "AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, + { "Hybridization_AssembleBdrMatrix", _wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS, "AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, + { "Hybridization_Finalize", _wrap_Hybridization_Finalize, METH_O, "Finalize(Hybridization self)"}, + { "Hybridization_GetMatrix", _wrap_Hybridization_GetMatrix, METH_O, "GetMatrix(Hybridization self) -> SparseMatrix"}, + { "Hybridization_GetParallelMatrix", _wrap_Hybridization_GetParallelMatrix, METH_VARARGS, "\n" + "GetParallelMatrix(Hybridization self) -> HypreParMatrix\n" + "GetParallelMatrix(Hybridization self, OperatorHandle H_h)\n" + ""}, + { "Hybridization_SetOperatorType", _wrap_Hybridization_SetOperatorType, METH_VARARGS, "SetOperatorType(Hybridization self, mfem::Operator::Type tid)"}, + { "Hybridization_ReduceRHS", _wrap_Hybridization_ReduceRHS, METH_VARARGS, "ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, + { "Hybridization_ComputeSolution", _wrap_Hybridization_ComputeSolution, METH_VARARGS, "ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, + { "Hybridization_Reset", _wrap_Hybridization_Reset, METH_O, "Reset(Hybridization self)"}, + { "Hybridization_swigregister", Hybridization_swigregister, METH_O, NULL}, + { "Hybridization_swiginit", Hybridization_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4132,6 +4155,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -4261,9 +4287,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -4288,6 +4311,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -4296,12 +4322,12 @@ static void *_p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormInteg } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -4312,6 +4338,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -4333,6 +4360,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -4365,8 +4393,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -4375,6 +4402,7 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mfem::DenseMatrix *", 0, 0, (void*)0, 0}; @@ -4399,6 +4427,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -4419,6 +4448,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__DivergenceInterpolator, &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GroupConvectionIntegrator, @@ -4502,11 +4532,11 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4517,6 +4547,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4538,6 +4569,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4570,8 +4602,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4580,9 +4611,10 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -4605,6 +4637,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -4625,6 +4658,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__DivergenceInterpolator, _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GroupConvectionIntegrator, diff --git a/mfem/_par/hypre.py b/mfem/_par/hypre.py index 075f8b30..e67e89f2 100644 --- a/mfem/_par/hypre.py +++ b/mfem/_par/hypre.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _hypre.SWIG_PyInstanceMethod_New +_swig_new_static_method = _hypre.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -98,6 +101,7 @@ class _SwigNonDynamicMeta(type): def sizeof_HYPRE_Int(): r"""sizeof_HYPRE_Int() -> int""" return _hypre.sizeof_HYPRE_Int() +sizeof_HYPRE_Int = _hypre.sizeof_HYPRE_Int class HypreParVector(mfem._par.vector.Vector): r"""Proxy of C++ mfem::HypreParVector class.""" @@ -137,47 +141,58 @@ def __init__(self, *args): def GetComm(self): r"""GetComm(HypreParVector self) -> MPI_Comm""" return _hypre.HypreParVector_GetComm(self) + GetComm = _swig_new_instance_method(_hypre.HypreParVector_GetComm) def Partitioning(self): r"""Partitioning(HypreParVector self) -> HYPRE_Int *""" return _hypre.HypreParVector_Partitioning(self) + Partitioning = _swig_new_instance_method(_hypre.HypreParVector_Partitioning) def GlobalSize(self): r"""GlobalSize(HypreParVector self) -> HYPRE_Int""" return _hypre.HypreParVector_GlobalSize(self) + GlobalSize = _swig_new_instance_method(_hypre.HypreParVector_GlobalSize) def StealParVector(self): r"""StealParVector(HypreParVector self) -> hypre_ParVector *""" return _hypre.HypreParVector_StealParVector(self) + StealParVector = _swig_new_instance_method(_hypre.HypreParVector_StealParVector) def SetOwnership(self, own): r"""SetOwnership(HypreParVector self, int own)""" return _hypre.HypreParVector_SetOwnership(self, own) + SetOwnership = _swig_new_instance_method(_hypre.HypreParVector_SetOwnership) def GetOwnership(self): r"""GetOwnership(HypreParVector self) -> int""" return _hypre.HypreParVector_GetOwnership(self) + GetOwnership = _swig_new_instance_method(_hypre.HypreParVector_GetOwnership) def GlobalVector(self): r"""GlobalVector(HypreParVector self) -> Vector""" return _hypre.HypreParVector_GlobalVector(self) + GlobalVector = _swig_new_instance_method(_hypre.HypreParVector_GlobalVector) def SetData(self, _data): r"""SetData(HypreParVector self, double * _data)""" return _hypre.HypreParVector_SetData(self, _data) + SetData = _swig_new_instance_method(_hypre.HypreParVector_SetData) def Randomize(self, seed): r"""Randomize(HypreParVector self, HYPRE_Int seed) -> HYPRE_Int""" return _hypre.HypreParVector_Randomize(self, seed) + Randomize = _swig_new_instance_method(_hypre.HypreParVector_Randomize) def Print(self, fname): r"""Print(HypreParVector self, char const * fname)""" return _hypre.HypreParVector_Print(self, fname) + Print = _swig_new_instance_method(_hypre.HypreParVector_Print) __swig_destroy__ = _hypre.delete_HypreParVector def GetPartitioningArray(self): r"""GetPartitioningArray(HypreParVector self) -> PyObject *""" return _hypre.HypreParVector_GetPartitioningArray(self) + GetPartitioningArray = _swig_new_instance_method(_hypre.HypreParVector_GetPartitioningArray) # Register HypreParVector in _hypre: _hypre.HypreParVector_swigregister(HypreParVector) @@ -186,6 +201,7 @@ def GetPartitioningArray(self): def ParNormlp(vec, p, comm): r"""ParNormlp(Vector vec, double p, MPI_Comm comm) -> double""" return _hypre.ParNormlp(vec, p, comm) +ParNormlp = _hypre.ParNormlp class HypreParMatrix(mfem._par.operators.Operator): r"""Proxy of C++ mfem::HypreParMatrix class.""" @@ -204,48 +220,59 @@ def __init__(self, *args): __init__(HypreParMatrix self, MPI_Comm comm, HYPRE_Int global_num_rows, HYPRE_Int global_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, mfem::Table * diag) -> HypreParMatrix __init__(HypreParMatrix self, MPI_Comm comm, int id, int np, HYPRE_Int * row, HYPRE_Int * col, HYPRE_Int * i_diag, HYPRE_Int * j_diag, HYPRE_Int * i_offd, HYPRE_Int * j_offd, HYPRE_Int * cmap, HYPRE_Int cmap_size) -> HypreParMatrix __init__(HypreParMatrix self, MPI_Comm comm, int nrows, HYPRE_Int glob_nrows, HYPRE_Int glob_ncols, int * I) -> HypreParMatrix + __init__(HypreParMatrix self, HypreParMatrix P) -> HypreParMatrix """ _hypre.HypreParMatrix_swiginit(self, _hypre.new_HypreParMatrix(*args)) def MakeRef(self, master): r"""MakeRef(HypreParMatrix self, HypreParMatrix master)""" return _hypre.HypreParMatrix_MakeRef(self, master) + MakeRef = _swig_new_instance_method(_hypre.HypreParMatrix_MakeRef) def GetComm(self): r"""GetComm(HypreParMatrix self) -> MPI_Comm""" return _hypre.HypreParMatrix_GetComm(self) + GetComm = _swig_new_instance_method(_hypre.HypreParMatrix_GetComm) def StealData(self): r"""StealData(HypreParMatrix self) -> hypre_ParCSRMatrix *""" return _hypre.HypreParMatrix_StealData(self) + StealData = _swig_new_instance_method(_hypre.HypreParMatrix_StealData) def SetOwnerFlags(self, diag, offd, colmap): r"""SetOwnerFlags(HypreParMatrix self, signed char diag, signed char offd, signed char colmap)""" return _hypre.HypreParMatrix_SetOwnerFlags(self, diag, offd, colmap) + SetOwnerFlags = _swig_new_instance_method(_hypre.HypreParMatrix_SetOwnerFlags) def OwnsDiag(self): r"""OwnsDiag(HypreParMatrix self) -> signed char""" return _hypre.HypreParMatrix_OwnsDiag(self) + OwnsDiag = _swig_new_instance_method(_hypre.HypreParMatrix_OwnsDiag) def OwnsOffd(self): r"""OwnsOffd(HypreParMatrix self) -> signed char""" return _hypre.HypreParMatrix_OwnsOffd(self) + OwnsOffd = _swig_new_instance_method(_hypre.HypreParMatrix_OwnsOffd) def OwnsColMap(self): r"""OwnsColMap(HypreParMatrix self) -> signed char""" return _hypre.HypreParMatrix_OwnsColMap(self) + OwnsColMap = _swig_new_instance_method(_hypre.HypreParMatrix_OwnsColMap) def CopyRowStarts(self): r"""CopyRowStarts(HypreParMatrix self)""" return _hypre.HypreParMatrix_CopyRowStarts(self) + CopyRowStarts = _swig_new_instance_method(_hypre.HypreParMatrix_CopyRowStarts) def CopyColStarts(self): r"""CopyColStarts(HypreParMatrix self)""" return _hypre.HypreParMatrix_CopyColStarts(self) + CopyColStarts = _swig_new_instance_method(_hypre.HypreParMatrix_CopyColStarts) def NNZ(self): r"""NNZ(HypreParMatrix self) -> HYPRE_Int""" return _hypre.HypreParMatrix_NNZ(self) + NNZ = _swig_new_instance_method(_hypre.HypreParMatrix_NNZ) def RowPart(self, *args): r""" @@ -253,6 +280,7 @@ def RowPart(self, *args): RowPart(HypreParMatrix self) -> HYPRE_Int const * """ return _hypre.HypreParMatrix_RowPart(self, *args) + RowPart = _swig_new_instance_method(_hypre.HypreParMatrix_RowPart) def ColPart(self, *args): r""" @@ -260,14 +288,17 @@ def ColPart(self, *args): ColPart(HypreParMatrix self) -> HYPRE_Int const * """ return _hypre.HypreParMatrix_ColPart(self, *args) + ColPart = _swig_new_instance_method(_hypre.HypreParMatrix_ColPart) def M(self): r"""M(HypreParMatrix self) -> HYPRE_Int""" return _hypre.HypreParMatrix_M(self) + M = _swig_new_instance_method(_hypre.HypreParMatrix_M) def N(self): r"""N(HypreParMatrix self) -> HYPRE_Int""" return _hypre.HypreParMatrix_N(self) + N = _swig_new_instance_method(_hypre.HypreParMatrix_N) def GetDiag(self, *args): r""" @@ -275,42 +306,52 @@ def GetDiag(self, *args): GetDiag(HypreParMatrix self, SparseMatrix diag) """ return _hypre.HypreParMatrix_GetDiag(self, *args) + GetDiag = _swig_new_instance_method(_hypre.HypreParMatrix_GetDiag) def GetOffd(self, offd, cmap): r"""GetOffd(HypreParMatrix self, SparseMatrix offd, HYPRE_Int *& cmap)""" return _hypre.HypreParMatrix_GetOffd(self, offd, cmap) + GetOffd = _swig_new_instance_method(_hypre.HypreParMatrix_GetOffd) def GetBlocks(self, blocks, interleaved_rows=False, interleaved_cols=False): r"""GetBlocks(HypreParMatrix self, mfem::Array2D< mfem::HypreParMatrix * > & blocks, bool interleaved_rows=False, bool interleaved_cols=False)""" return _hypre.HypreParMatrix_GetBlocks(self, blocks, interleaved_rows, interleaved_cols) + GetBlocks = _swig_new_instance_method(_hypre.HypreParMatrix_GetBlocks) def Transpose(self): r"""Transpose(HypreParMatrix self) -> HypreParMatrix""" return _hypre.HypreParMatrix_Transpose(self) + Transpose = _swig_new_instance_method(_hypre.HypreParMatrix_Transpose) def GetNumRows(self): r"""GetNumRows(HypreParMatrix self) -> int""" return _hypre.HypreParMatrix_GetNumRows(self) + GetNumRows = _swig_new_instance_method(_hypre.HypreParMatrix_GetNumRows) def GetNumCols(self): r"""GetNumCols(HypreParMatrix self) -> int""" return _hypre.HypreParMatrix_GetNumCols(self) + GetNumCols = _swig_new_instance_method(_hypre.HypreParMatrix_GetNumCols) def GetGlobalNumRows(self): r"""GetGlobalNumRows(HypreParMatrix self) -> HYPRE_Int""" return _hypre.HypreParMatrix_GetGlobalNumRows(self) + GetGlobalNumRows = _swig_new_instance_method(_hypre.HypreParMatrix_GetGlobalNumRows) def GetGlobalNumCols(self): r"""GetGlobalNumCols(HypreParMatrix self) -> HYPRE_Int""" return _hypre.HypreParMatrix_GetGlobalNumCols(self) + GetGlobalNumCols = _swig_new_instance_method(_hypre.HypreParMatrix_GetGlobalNumCols) def GetRowStarts(self): r"""GetRowStarts(HypreParMatrix self) -> HYPRE_Int *""" return _hypre.HypreParMatrix_GetRowStarts(self) + GetRowStarts = _swig_new_instance_method(_hypre.HypreParMatrix_GetRowStarts) def GetColStarts(self): r"""GetColStarts(HypreParMatrix self) -> HYPRE_Int *""" return _hypre.HypreParMatrix_GetColStarts(self) + GetColStarts = _swig_new_instance_method(_hypre.HypreParMatrix_GetColStarts) def Mult(self, *args): r""" @@ -320,6 +361,7 @@ def Mult(self, *args): Mult(HypreParMatrix self, Vector x, Vector y) """ return _hypre.HypreParMatrix_Mult(self, *args) + Mult = _swig_new_instance_method(_hypre.HypreParMatrix_Mult) def MultTranspose(self, *args): r""" @@ -328,34 +370,42 @@ def MultTranspose(self, *args): MultTranspose(HypreParMatrix self, Vector x, Vector y) """ return _hypre.HypreParMatrix_MultTranspose(self, *args) + MultTranspose = _swig_new_instance_method(_hypre.HypreParMatrix_MultTranspose) def BooleanMult(self, alpha, x, beta, y): r"""BooleanMult(HypreParMatrix self, int alpha, int const * x, int beta, int * y)""" return _hypre.HypreParMatrix_BooleanMult(self, alpha, x, beta, y) + BooleanMult = _swig_new_instance_method(_hypre.HypreParMatrix_BooleanMult) def BooleanMultTranspose(self, alpha, x, beta, y): r"""BooleanMultTranspose(HypreParMatrix self, int alpha, int const * x, int beta, int * y)""" return _hypre.HypreParMatrix_BooleanMultTranspose(self, alpha, x, beta, y) + BooleanMultTranspose = _swig_new_instance_method(_hypre.HypreParMatrix_BooleanMultTranspose) def __iadd__(self, B): r"""__iadd__(HypreParMatrix self, HypreParMatrix B) -> HypreParMatrix""" return _hypre.HypreParMatrix___iadd__(self, B) + __iadd__ = _swig_new_instance_method(_hypre.HypreParMatrix___iadd__) def Add(self, beta, B): r"""Add(HypreParMatrix self, double const beta, HypreParMatrix B) -> HypreParMatrix""" return _hypre.HypreParMatrix_Add(self, beta, B) + Add = _swig_new_instance_method(_hypre.HypreParMatrix_Add) def LeftDiagMult(self, D, row_starts=None): r"""LeftDiagMult(HypreParMatrix self, SparseMatrix D, HYPRE_Int * row_starts=None) -> HypreParMatrix""" return _hypre.HypreParMatrix_LeftDiagMult(self, D, row_starts) + LeftDiagMult = _swig_new_instance_method(_hypre.HypreParMatrix_LeftDiagMult) def ScaleRows(self, s): r"""ScaleRows(HypreParMatrix self, Vector s)""" return _hypre.HypreParMatrix_ScaleRows(self, s) + ScaleRows = _swig_new_instance_method(_hypre.HypreParMatrix_ScaleRows) def InvScaleRows(self, s): r"""InvScaleRows(HypreParMatrix self, Vector s)""" return _hypre.HypreParMatrix_InvScaleRows(self, s) + InvScaleRows = _swig_new_instance_method(_hypre.HypreParMatrix_InvScaleRows) def __imul__(self, s): r"""__imul__(HypreParMatrix self, double s)""" @@ -371,10 +421,12 @@ def __imul__(self, s): def Threshold(self, threshold=0.0): r"""Threshold(HypreParMatrix self, double threshold=0.0)""" return _hypre.HypreParMatrix_Threshold(self, threshold) + Threshold = _swig_new_instance_method(_hypre.HypreParMatrix_Threshold) def EliminateZeroRows(self): r"""EliminateZeroRows(HypreParMatrix self)""" return _hypre.HypreParMatrix_EliminateZeroRows(self) + EliminateZeroRows = _swig_new_instance_method(_hypre.HypreParMatrix_EliminateZeroRows) def EliminateRowsCols(self, *args): r""" @@ -382,43 +434,63 @@ def EliminateRowsCols(self, *args): EliminateRowsCols(HypreParMatrix self, intArray rows_cols) -> HypreParMatrix """ return _hypre.HypreParMatrix_EliminateRowsCols(self, *args) + EliminateRowsCols = _swig_new_instance_method(_hypre.HypreParMatrix_EliminateRowsCols) + + def EliminateCols(self, cols): + r"""EliminateCols(HypreParMatrix self, intArray cols) -> HypreParMatrix""" + return _hypre.HypreParMatrix_EliminateCols(self, cols) + EliminateCols = _swig_new_instance_method(_hypre.HypreParMatrix_EliminateCols) + + def EliminateRows(self, rows): + r"""EliminateRows(HypreParMatrix self, intArray rows)""" + return _hypre.HypreParMatrix_EliminateRows(self, rows) + EliminateRows = _swig_new_instance_method(_hypre.HypreParMatrix_EliminateRows) def Print(self, fname, offi=0, offj=0): r"""Print(HypreParMatrix self, char const * fname, HYPRE_Int offi=0, HYPRE_Int offj=0)""" return _hypre.HypreParMatrix_Print(self, fname, offi, offj) + Print = _swig_new_instance_method(_hypre.HypreParMatrix_Print) def Read(self, comm, fname): r"""Read(HypreParMatrix self, MPI_Comm comm, char const * fname)""" return _hypre.HypreParMatrix_Read(self, comm, fname) + Read = _swig_new_instance_method(_hypre.HypreParMatrix_Read) def Read_IJMatrix(self, comm, fname): r"""Read_IJMatrix(HypreParMatrix self, MPI_Comm comm, char const * fname)""" return _hypre.HypreParMatrix_Read_IJMatrix(self, comm, fname) + Read_IJMatrix = _swig_new_instance_method(_hypre.HypreParMatrix_Read_IJMatrix) __swig_destroy__ = _hypre.delete_HypreParMatrix def GetType(self): r"""GetType(HypreParMatrix self) -> mfem::Operator::Type""" return _hypre.HypreParMatrix_GetType(self) + GetType = _swig_new_instance_method(_hypre.HypreParMatrix_GetType) def GetRowPartArray(self): r"""GetRowPartArray(HypreParMatrix self) -> PyObject *""" return _hypre.HypreParMatrix_GetRowPartArray(self) + GetRowPartArray = _swig_new_instance_method(_hypre.HypreParMatrix_GetRowPartArray) def GetColPartArray(self): r"""GetColPartArray(HypreParMatrix self) -> PyObject *""" return _hypre.HypreParMatrix_GetColPartArray(self) + GetColPartArray = _swig_new_instance_method(_hypre.HypreParMatrix_GetColPartArray) def get_local_nnz(self): r"""get_local_nnz(HypreParMatrix self) -> HYPRE_Int""" return _hypre.HypreParMatrix_get_local_nnz(self) + get_local_nnz = _swig_new_instance_method(_hypre.HypreParMatrix_get_local_nnz) def get_local_true_nnz(self): r"""get_local_true_nnz(HypreParMatrix self) -> PyObject *""" return _hypre.HypreParMatrix_get_local_true_nnz(self) + get_local_true_nnz = _swig_new_instance_method(_hypre.HypreParMatrix_get_local_true_nnz) def GetCooDataArray(self, base_i=0, base_j=0): r"""GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject""" return _hypre.HypreParMatrix_GetCooDataArray(self, base_i, base_j) + GetCooDataArray = _swig_new_instance_method(_hypre.HypreParMatrix_GetCooDataArray) def PrintCommPkg(self, *args): r""" @@ -426,22 +498,26 @@ def PrintCommPkg(self, *args): PrintCommPkg(HypreParMatrix self, char const * file, int precision=8) """ return _hypre.HypreParMatrix_PrintCommPkg(self, *args) + PrintCommPkg = _swig_new_instance_method(_hypre.HypreParMatrix_PrintCommPkg) # Register HypreParMatrix in _hypre: _hypre.HypreParMatrix_swigregister(HypreParMatrix) -def ParMult(A, B): - r"""ParMult(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix""" - return _hypre.ParMult(A, B) +def ParMult(A, B, own_matrix=False): + r"""ParMult(HypreParMatrix A, HypreParMatrix B, bool own_matrix=False) -> HypreParMatrix""" + return _hypre.ParMult(A, B, own_matrix) +ParMult = _hypre.ParMult def ParAdd(A, B): r"""ParAdd(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix""" return _hypre.ParAdd(A, B) +ParAdd = _hypre.ParAdd def EliminateBC(A, Ae, ess_dof_list, X, B): r"""EliminateBC(HypreParMatrix A, HypreParMatrix Ae, intArray ess_dof_list, Vector X, Vector B)""" return _hypre.EliminateBC(A, Ae, ess_dof_list, X, B) +EliminateBC = _hypre.EliminateBC class HypreSmoother(mfem._par.operators.Solver): r"""Proxy of C++ mfem::HypreSmoother class.""" @@ -476,38 +552,47 @@ def __init__(self, *args): def SetType(self, type, relax_times=1): r"""SetType(HypreSmoother self, mfem::HypreSmoother::Type type, int relax_times=1)""" return _hypre.HypreSmoother_SetType(self, type, relax_times) + SetType = _swig_new_instance_method(_hypre.HypreSmoother_SetType) def SetSOROptions(self, relax_weight, omega): r"""SetSOROptions(HypreSmoother self, double relax_weight, double omega)""" return _hypre.HypreSmoother_SetSOROptions(self, relax_weight, omega) + SetSOROptions = _swig_new_instance_method(_hypre.HypreSmoother_SetSOROptions) def SetPolyOptions(self, poly_order, poly_fraction): r"""SetPolyOptions(HypreSmoother self, int poly_order, double poly_fraction)""" return _hypre.HypreSmoother_SetPolyOptions(self, poly_order, poly_fraction) + SetPolyOptions = _swig_new_instance_method(_hypre.HypreSmoother_SetPolyOptions) def SetTaubinOptions(self, _lambda, mu, iter): r"""SetTaubinOptions(HypreSmoother self, double _lambda, double mu, int iter)""" return _hypre.HypreSmoother_SetTaubinOptions(self, _lambda, mu, iter) + SetTaubinOptions = _swig_new_instance_method(_hypre.HypreSmoother_SetTaubinOptions) def SetWindowByName(self, window_name): r"""SetWindowByName(HypreSmoother self, char const * window_name)""" return _hypre.HypreSmoother_SetWindowByName(self, window_name) + SetWindowByName = _swig_new_instance_method(_hypre.HypreSmoother_SetWindowByName) def SetWindowParameters(self, a, b, c): r"""SetWindowParameters(HypreSmoother self, double a, double b, double c)""" return _hypre.HypreSmoother_SetWindowParameters(self, a, b, c) + SetWindowParameters = _swig_new_instance_method(_hypre.HypreSmoother_SetWindowParameters) def SetFIRCoefficients(self, max_eig): r"""SetFIRCoefficients(HypreSmoother self, double max_eig)""" return _hypre.HypreSmoother_SetFIRCoefficients(self, max_eig) + SetFIRCoefficients = _swig_new_instance_method(_hypre.HypreSmoother_SetFIRCoefficients) def SetPositiveDiagonal(self, pos=True): r"""SetPositiveDiagonal(HypreSmoother self, bool pos=True)""" return _hypre.HypreSmoother_SetPositiveDiagonal(self, pos) + SetPositiveDiagonal = _swig_new_instance_method(_hypre.HypreSmoother_SetPositiveDiagonal) def SetOperator(self, op): r"""SetOperator(HypreSmoother self, Operator op)""" return _hypre.HypreSmoother_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreSmoother_SetOperator) def Mult(self, *args): r""" @@ -515,6 +600,7 @@ def Mult(self, *args): Mult(HypreSmoother self, Vector b, Vector x) """ return _hypre.HypreSmoother_Mult(self, *args) + Mult = _swig_new_instance_method(_hypre.HypreSmoother_Mult) __swig_destroy__ = _hypre.delete_HypreSmoother # Register HypreSmoother in _hypre: @@ -528,18 +614,27 @@ class HypreSolver(mfem._par.operators.Solver): def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract") __repr__ = _swig_repr + IGNORE_HYPRE_ERRORS = _hypre.HypreSolver_IGNORE_HYPRE_ERRORS + + WARN_HYPRE_ERRORS = _hypre.HypreSolver_WARN_HYPRE_ERRORS + + ABORT_HYPRE_ERRORS = _hypre.HypreSolver_ABORT_HYPRE_ERRORS + def SetupFcn(self): r"""SetupFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreSolver_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreSolver_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreSolver_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreSolver_SolveFcn) def SetOperator(self, op): r"""SetOperator(HypreSolver self, Operator op)""" return _hypre.HypreSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreSolver_SetOperator) def Mult(self, *args): r""" @@ -547,6 +642,12 @@ def Mult(self, *args): Mult(HypreSolver self, Vector b, Vector x) """ return _hypre.HypreSolver_Mult(self, *args) + Mult = _swig_new_instance_method(_hypre.HypreSolver_Mult) + + def SetErrorMode(self, err_mode): + r"""SetErrorMode(HypreSolver self, mfem::HypreSolver::ErrorMode err_mode)""" + return _hypre.HypreSolver_SetErrorMode(self, err_mode) + SetErrorMode = _swig_new_instance_method(_hypre.HypreSolver_SetErrorMode) __swig_destroy__ = _hypre.delete_HypreSolver # Register HypreSolver in _hypre: @@ -558,49 +659,67 @@ class HyprePCG(HypreSolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, _A): - r"""__init__(HyprePCG self, HypreParMatrix _A) -> HyprePCG""" - _hypre.HyprePCG_swiginit(self, _hypre.new_HyprePCG(_A)) + def __init__(self, *args): + r""" + __init__(HyprePCG self, MPI_Comm comm) -> HyprePCG + __init__(HyprePCG self, HypreParMatrix _A) -> HyprePCG + """ + _hypre.HyprePCG_swiginit(self, _hypre.new_HyprePCG(*args)) + + def SetOperator(self, op): + r"""SetOperator(HyprePCG self, Operator op)""" + return _hypre.HyprePCG_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HyprePCG_SetOperator) def SetTol(self, tol): r"""SetTol(HyprePCG self, double tol)""" return _hypre.HyprePCG_SetTol(self, tol) + SetTol = _swig_new_instance_method(_hypre.HyprePCG_SetTol) def SetMaxIter(self, max_iter): r"""SetMaxIter(HyprePCG self, int max_iter)""" return _hypre.HyprePCG_SetMaxIter(self, max_iter) + SetMaxIter = _swig_new_instance_method(_hypre.HyprePCG_SetMaxIter) def SetLogging(self, logging): r"""SetLogging(HyprePCG self, int logging)""" return _hypre.HyprePCG_SetLogging(self, logging) + SetLogging = _swig_new_instance_method(_hypre.HyprePCG_SetLogging) def SetPrintLevel(self, print_lvl): r"""SetPrintLevel(HyprePCG self, int print_lvl)""" return _hypre.HyprePCG_SetPrintLevel(self, print_lvl) + SetPrintLevel = _swig_new_instance_method(_hypre.HyprePCG_SetPrintLevel) def SetPreconditioner(self, precond): r"""SetPreconditioner(HyprePCG self, HypreSolver precond)""" return _hypre.HyprePCG_SetPreconditioner(self, precond) + SetPreconditioner = _swig_new_instance_method(_hypre.HyprePCG_SetPreconditioner) def SetResidualConvergenceOptions(self, res_frequency=-1, rtol=0.0): r"""SetResidualConvergenceOptions(HyprePCG self, int res_frequency=-1, double rtol=0.0)""" return _hypre.HyprePCG_SetResidualConvergenceOptions(self, res_frequency, rtol) + SetResidualConvergenceOptions = _swig_new_instance_method(_hypre.HyprePCG_SetResidualConvergenceOptions) def SetZeroInintialIterate(self): r"""SetZeroInintialIterate(HyprePCG self)""" return _hypre.HyprePCG_SetZeroInintialIterate(self) + SetZeroInintialIterate = _swig_new_instance_method(_hypre.HyprePCG_SetZeroInintialIterate) def GetNumIterations(self, num_iterations): r"""GetNumIterations(HyprePCG self, int & num_iterations)""" return _hypre.HyprePCG_GetNumIterations(self, num_iterations) + GetNumIterations = _swig_new_instance_method(_hypre.HyprePCG_GetNumIterations) def SetupFcn(self): r"""SetupFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HyprePCG_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HyprePCG_SetupFcn) def SolveFcn(self): r"""SolveFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HyprePCG_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HyprePCG_SolveFcn) def Mult(self, *args): r""" @@ -608,6 +727,7 @@ def Mult(self, *args): Mult(HyprePCG self, Vector b, Vector x) """ return _hypre.HyprePCG_Mult(self, *args) + Mult = _swig_new_instance_method(_hypre.HyprePCG_Mult) __swig_destroy__ = _hypre.delete_HyprePCG # Register HyprePCG in _hypre: @@ -619,45 +739,62 @@ class HypreGMRES(HypreSolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, _A): - r"""__init__(HypreGMRES self, HypreParMatrix _A) -> HypreGMRES""" - _hypre.HypreGMRES_swiginit(self, _hypre.new_HypreGMRES(_A)) + def __init__(self, *args): + r""" + __init__(HypreGMRES self, MPI_Comm comm) -> HypreGMRES + __init__(HypreGMRES self, HypreParMatrix _A) -> HypreGMRES + """ + _hypre.HypreGMRES_swiginit(self, _hypre.new_HypreGMRES(*args)) + + def SetOperator(self, op): + r"""SetOperator(HypreGMRES self, Operator op)""" + return _hypre.HypreGMRES_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreGMRES_SetOperator) def SetTol(self, tol): r"""SetTol(HypreGMRES self, double tol)""" return _hypre.HypreGMRES_SetTol(self, tol) + SetTol = _swig_new_instance_method(_hypre.HypreGMRES_SetTol) def SetMaxIter(self, max_iter): r"""SetMaxIter(HypreGMRES self, int max_iter)""" return _hypre.HypreGMRES_SetMaxIter(self, max_iter) + SetMaxIter = _swig_new_instance_method(_hypre.HypreGMRES_SetMaxIter) def SetKDim(self, dim): r"""SetKDim(HypreGMRES self, int dim)""" return _hypre.HypreGMRES_SetKDim(self, dim) + SetKDim = _swig_new_instance_method(_hypre.HypreGMRES_SetKDim) def SetLogging(self, logging): r"""SetLogging(HypreGMRES self, int logging)""" return _hypre.HypreGMRES_SetLogging(self, logging) + SetLogging = _swig_new_instance_method(_hypre.HypreGMRES_SetLogging) def SetPrintLevel(self, print_lvl): r"""SetPrintLevel(HypreGMRES self, int print_lvl)""" return _hypre.HypreGMRES_SetPrintLevel(self, print_lvl) + SetPrintLevel = _swig_new_instance_method(_hypre.HypreGMRES_SetPrintLevel) def SetPreconditioner(self, precond): r"""SetPreconditioner(HypreGMRES self, HypreSolver precond)""" return _hypre.HypreGMRES_SetPreconditioner(self, precond) + SetPreconditioner = _swig_new_instance_method(_hypre.HypreGMRES_SetPreconditioner) def SetZeroInintialIterate(self): r"""SetZeroInintialIterate(HypreGMRES self)""" return _hypre.HypreGMRES_SetZeroInintialIterate(self) + SetZeroInintialIterate = _swig_new_instance_method(_hypre.HypreGMRES_SetZeroInintialIterate) def SetupFcn(self): r"""SetupFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreGMRES_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreGMRES_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreGMRES_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreGMRES_SolveFcn) def Mult(self, *args): r""" @@ -665,6 +802,7 @@ def Mult(self, *args): Mult(HypreGMRES self, Vector b, Vector x) """ return _hypre.HypreGMRES_Mult(self, *args) + Mult = _swig_new_instance_method(_hypre.HypreGMRES_Mult) __swig_destroy__ = _hypre.delete_HypreGMRES # Register HypreGMRES in _hypre: @@ -679,10 +817,12 @@ class HypreIdentity(HypreSolver): def SetupFcn(self): r"""SetupFcn(HypreIdentity self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreIdentity_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreIdentity_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreIdentity self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreIdentity_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreIdentity_SolveFcn) __swig_destroy__ = _hypre.delete_HypreIdentity def __init__(self): @@ -705,17 +845,25 @@ def __init__(self, *args): """ _hypre.HypreDiagScale_swiginit(self, _hypre.new_HypreDiagScale(*args)) + def SetOperator(self, op): + r"""SetOperator(HypreDiagScale self, Operator op)""" + return _hypre.HypreDiagScale_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreDiagScale_SetOperator) + def SetupFcn(self): r"""SetupFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreDiagScale_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreDiagScale_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreDiagScale_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreDiagScale_SolveFcn) def GetData(self): r"""GetData(HypreDiagScale self) -> HypreParMatrix""" return _hypre.HypreDiagScale_GetData(self) + GetData = _swig_new_instance_method(_hypre.HypreDiagScale_GetData) __swig_destroy__ = _hypre.delete_HypreDiagScale # Register HypreDiagScale in _hypre: @@ -727,21 +875,32 @@ class HypreParaSails(HypreSolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, A): - r"""__init__(HypreParaSails self, HypreParMatrix A) -> HypreParaSails""" - _hypre.HypreParaSails_swiginit(self, _hypre.new_HypreParaSails(A)) + def __init__(self, *args): + r""" + __init__(HypreParaSails self, MPI_Comm comm) -> HypreParaSails + __init__(HypreParaSails self, HypreParMatrix A) -> HypreParaSails + """ + _hypre.HypreParaSails_swiginit(self, _hypre.new_HypreParaSails(*args)) + + def SetOperator(self, op): + r"""SetOperator(HypreParaSails self, Operator op)""" + return _hypre.HypreParaSails_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreParaSails_SetOperator) def SetSymmetry(self, sym): r"""SetSymmetry(HypreParaSails self, int sym)""" return _hypre.HypreParaSails_SetSymmetry(self, sym) + SetSymmetry = _swig_new_instance_method(_hypre.HypreParaSails_SetSymmetry) def SetupFcn(self): r"""SetupFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreParaSails_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreParaSails_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreParaSails_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreParaSails_SolveFcn) __swig_destroy__ = _hypre.delete_HypreParaSails # Register HypreParaSails in _hypre: @@ -753,17 +912,27 @@ class HypreEuclid(HypreSolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, A): - r"""__init__(HypreEuclid self, HypreParMatrix A) -> HypreEuclid""" - _hypre.HypreEuclid_swiginit(self, _hypre.new_HypreEuclid(A)) + def __init__(self, *args): + r""" + __init__(HypreEuclid self, MPI_Comm comm) -> HypreEuclid + __init__(HypreEuclid self, HypreParMatrix A) -> HypreEuclid + """ + _hypre.HypreEuclid_swiginit(self, _hypre.new_HypreEuclid(*args)) + + def SetOperator(self, op): + r"""SetOperator(HypreEuclid self, Operator op)""" + return _hypre.HypreEuclid_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreEuclid_SetOperator) def SetupFcn(self): r"""SetupFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreEuclid_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreEuclid_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreEuclid_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreEuclid_SolveFcn) __swig_destroy__ = _hypre.delete_HypreEuclid # Register HypreEuclid in _hypre: @@ -785,26 +954,32 @@ def __init__(self, *args): def SetOperator(self, op): r"""SetOperator(HypreBoomerAMG self, Operator op)""" return _hypre.HypreBoomerAMG_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreBoomerAMG_SetOperator) def SetSystemsOptions(self, dim): r"""SetSystemsOptions(HypreBoomerAMG self, int dim)""" return _hypre.HypreBoomerAMG_SetSystemsOptions(self, dim) + SetSystemsOptions = _swig_new_instance_method(_hypre.HypreBoomerAMG_SetSystemsOptions) def SetElasticityOptions(self, fespace): r"""SetElasticityOptions(HypreBoomerAMG self, mfem::ParFiniteElementSpace * fespace)""" return _hypre.HypreBoomerAMG_SetElasticityOptions(self, fespace) + SetElasticityOptions = _swig_new_instance_method(_hypre.HypreBoomerAMG_SetElasticityOptions) def SetPrintLevel(self, print_level): r"""SetPrintLevel(HypreBoomerAMG self, int print_level)""" return _hypre.HypreBoomerAMG_SetPrintLevel(self, print_level) + SetPrintLevel = _swig_new_instance_method(_hypre.HypreBoomerAMG_SetPrintLevel) def SetupFcn(self): r"""SetupFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreBoomerAMG_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreBoomerAMG_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreBoomerAMG_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreBoomerAMG_SolveFcn) __swig_destroy__ = _hypre.delete_HypreBoomerAMG # Register HypreBoomerAMG in _hypre: @@ -816,25 +991,37 @@ class HypreAMS(HypreSolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, A, edge_fespace): - r"""__init__(HypreAMS self, HypreParMatrix A, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS""" - _hypre.HypreAMS_swiginit(self, _hypre.new_HypreAMS(A, edge_fespace)) + def __init__(self, *args): + r""" + __init__(HypreAMS self, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS + __init__(HypreAMS self, HypreParMatrix A, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS + """ + _hypre.HypreAMS_swiginit(self, _hypre.new_HypreAMS(*args)) + + def SetOperator(self, op): + r"""SetOperator(HypreAMS self, Operator op)""" + return _hypre.HypreAMS_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreAMS_SetOperator) def SetPrintLevel(self, print_lvl): r"""SetPrintLevel(HypreAMS self, int print_lvl)""" return _hypre.HypreAMS_SetPrintLevel(self, print_lvl) + SetPrintLevel = _swig_new_instance_method(_hypre.HypreAMS_SetPrintLevel) def SetSingularProblem(self): r"""SetSingularProblem(HypreAMS self)""" return _hypre.HypreAMS_SetSingularProblem(self) + SetSingularProblem = _swig_new_instance_method(_hypre.HypreAMS_SetSingularProblem) def SetupFcn(self): r"""SetupFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreAMS_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreAMS_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreAMS_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreAMS_SolveFcn) __swig_destroy__ = _hypre.delete_HypreAMS # Register HypreAMS in _hypre: @@ -846,21 +1033,32 @@ class HypreADS(HypreSolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, A, face_fespace): - r"""__init__(HypreADS self, HypreParMatrix A, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS""" - _hypre.HypreADS_swiginit(self, _hypre.new_HypreADS(A, face_fespace)) + def __init__(self, *args): + r""" + __init__(HypreADS self, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS + __init__(HypreADS self, HypreParMatrix A, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS + """ + _hypre.HypreADS_swiginit(self, _hypre.new_HypreADS(*args)) + + def SetOperator(self, op): + r"""SetOperator(HypreADS self, Operator op)""" + return _hypre.HypreADS_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_hypre.HypreADS_SetOperator) def SetPrintLevel(self, print_lvl): r"""SetPrintLevel(HypreADS self, int print_lvl)""" return _hypre.HypreADS_SetPrintLevel(self, print_lvl) + SetPrintLevel = _swig_new_instance_method(_hypre.HypreADS_SetPrintLevel) def SetupFcn(self): r"""SetupFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreADS_SetupFcn(self) + SetupFcn = _swig_new_instance_method(_hypre.HypreADS_SetupFcn) def SolveFcn(self): r"""SolveFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn""" return _hypre.HypreADS_SolveFcn(self) + SolveFcn = _swig_new_instance_method(_hypre.HypreADS_SolveFcn) __swig_destroy__ = _hypre.delete_HypreADS # Register HypreADS in _hypre: @@ -880,66 +1078,82 @@ def __init__(self, comm): def SetTol(self, tol): r"""SetTol(HypreLOBPCG self, double tol)""" return _hypre.HypreLOBPCG_SetTol(self, tol) + SetTol = _swig_new_instance_method(_hypre.HypreLOBPCG_SetTol) def SetRelTol(self, rel_tol): r"""SetRelTol(HypreLOBPCG self, double rel_tol)""" return _hypre.HypreLOBPCG_SetRelTol(self, rel_tol) + SetRelTol = _swig_new_instance_method(_hypre.HypreLOBPCG_SetRelTol) def SetMaxIter(self, max_iter): r"""SetMaxIter(HypreLOBPCG self, int max_iter)""" return _hypre.HypreLOBPCG_SetMaxIter(self, max_iter) + SetMaxIter = _swig_new_instance_method(_hypre.HypreLOBPCG_SetMaxIter) def SetPrintLevel(self, logging): r"""SetPrintLevel(HypreLOBPCG self, int logging)""" return _hypre.HypreLOBPCG_SetPrintLevel(self, logging) + SetPrintLevel = _swig_new_instance_method(_hypre.HypreLOBPCG_SetPrintLevel) def SetNumModes(self, num_eigs): r"""SetNumModes(HypreLOBPCG self, int num_eigs)""" return _hypre.HypreLOBPCG_SetNumModes(self, num_eigs) + SetNumModes = _swig_new_instance_method(_hypre.HypreLOBPCG_SetNumModes) def SetPrecondUsageMode(self, pcg_mode): r"""SetPrecondUsageMode(HypreLOBPCG self, int pcg_mode)""" return _hypre.HypreLOBPCG_SetPrecondUsageMode(self, pcg_mode) + SetPrecondUsageMode = _swig_new_instance_method(_hypre.HypreLOBPCG_SetPrecondUsageMode) def SetRandomSeed(self, s): r"""SetRandomSeed(HypreLOBPCG self, int s)""" return _hypre.HypreLOBPCG_SetRandomSeed(self, s) + SetRandomSeed = _swig_new_instance_method(_hypre.HypreLOBPCG_SetRandomSeed) def SetInitialVectors(self, num_vecs, vecs): r"""SetInitialVectors(HypreLOBPCG self, int num_vecs, mfem::HypreParVector ** vecs)""" return _hypre.HypreLOBPCG_SetInitialVectors(self, num_vecs, vecs) + SetInitialVectors = _swig_new_instance_method(_hypre.HypreLOBPCG_SetInitialVectors) def SetPreconditioner(self, precond): r"""SetPreconditioner(HypreLOBPCG self, Solver precond)""" return _hypre.HypreLOBPCG_SetPreconditioner(self, precond) + SetPreconditioner = _swig_new_instance_method(_hypre.HypreLOBPCG_SetPreconditioner) def SetOperator(self, A): r"""SetOperator(HypreLOBPCG self, Operator A)""" return _hypre.HypreLOBPCG_SetOperator(self, A) + SetOperator = _swig_new_instance_method(_hypre.HypreLOBPCG_SetOperator) def SetMassMatrix(self, M): r"""SetMassMatrix(HypreLOBPCG self, Operator M)""" return _hypre.HypreLOBPCG_SetMassMatrix(self, M) + SetMassMatrix = _swig_new_instance_method(_hypre.HypreLOBPCG_SetMassMatrix) def SetSubSpaceProjector(self, proj): r"""SetSubSpaceProjector(HypreLOBPCG self, Operator proj)""" return _hypre.HypreLOBPCG_SetSubSpaceProjector(self, proj) + SetSubSpaceProjector = _swig_new_instance_method(_hypre.HypreLOBPCG_SetSubSpaceProjector) def Solve(self): r"""Solve(HypreLOBPCG self)""" return _hypre.HypreLOBPCG_Solve(self) + Solve = _swig_new_instance_method(_hypre.HypreLOBPCG_Solve) def GetEigenvalues(self, eigenvalues): r"""GetEigenvalues(HypreLOBPCG self, doubleArray eigenvalues)""" return _hypre.HypreLOBPCG_GetEigenvalues(self, eigenvalues) + GetEigenvalues = _swig_new_instance_method(_hypre.HypreLOBPCG_GetEigenvalues) def GetEigenvector(self, i): r"""GetEigenvector(HypreLOBPCG self, unsigned int i) -> HypreParVector""" return _hypre.HypreLOBPCG_GetEigenvector(self, i) + GetEigenvector = _swig_new_instance_method(_hypre.HypreLOBPCG_GetEigenvector) def StealEigenvectors(self): r"""StealEigenvectors(HypreLOBPCG self) -> mfem::HypreParVector **""" return _hypre.HypreLOBPCG_StealEigenvectors(self) + StealEigenvectors = _swig_new_instance_method(_hypre.HypreLOBPCG_StealEigenvectors) # Register HypreLOBPCG in _hypre: _hypre.HypreLOBPCG_swigregister(HypreLOBPCG) @@ -958,50 +1172,62 @@ def __init__(self, comm): def SetTol(self, tol): r"""SetTol(HypreAME self, double tol)""" return _hypre.HypreAME_SetTol(self, tol) + SetTol = _swig_new_instance_method(_hypre.HypreAME_SetTol) def SetRelTol(self, rel_tol): r"""SetRelTol(HypreAME self, double rel_tol)""" return _hypre.HypreAME_SetRelTol(self, rel_tol) + SetRelTol = _swig_new_instance_method(_hypre.HypreAME_SetRelTol) def SetMaxIter(self, max_iter): r"""SetMaxIter(HypreAME self, int max_iter)""" return _hypre.HypreAME_SetMaxIter(self, max_iter) + SetMaxIter = _swig_new_instance_method(_hypre.HypreAME_SetMaxIter) def SetPrintLevel(self, logging): r"""SetPrintLevel(HypreAME self, int logging)""" return _hypre.HypreAME_SetPrintLevel(self, logging) + SetPrintLevel = _swig_new_instance_method(_hypre.HypreAME_SetPrintLevel) def SetNumModes(self, num_eigs): r"""SetNumModes(HypreAME self, int num_eigs)""" return _hypre.HypreAME_SetNumModes(self, num_eigs) + SetNumModes = _swig_new_instance_method(_hypre.HypreAME_SetNumModes) def SetPreconditioner(self, precond): r"""SetPreconditioner(HypreAME self, HypreSolver precond)""" return _hypre.HypreAME_SetPreconditioner(self, precond) + SetPreconditioner = _swig_new_instance_method(_hypre.HypreAME_SetPreconditioner) def SetOperator(self, A): r"""SetOperator(HypreAME self, HypreParMatrix A)""" return _hypre.HypreAME_SetOperator(self, A) + SetOperator = _swig_new_instance_method(_hypre.HypreAME_SetOperator) def SetMassMatrix(self, M): r"""SetMassMatrix(HypreAME self, HypreParMatrix M)""" return _hypre.HypreAME_SetMassMatrix(self, M) + SetMassMatrix = _swig_new_instance_method(_hypre.HypreAME_SetMassMatrix) def Solve(self): r"""Solve(HypreAME self)""" return _hypre.HypreAME_Solve(self) + Solve = _swig_new_instance_method(_hypre.HypreAME_Solve) def GetEigenvalues(self, eigenvalues): r"""GetEigenvalues(HypreAME self, doubleArray eigenvalues)""" return _hypre.HypreAME_GetEigenvalues(self, eigenvalues) + GetEigenvalues = _swig_new_instance_method(_hypre.HypreAME_GetEigenvalues) def GetEigenvector(self, i): r"""GetEigenvector(HypreAME self, unsigned int i) -> HypreParVector""" return _hypre.HypreAME_GetEigenvector(self, i) + GetEigenvector = _swig_new_instance_method(_hypre.HypreAME_GetEigenvector) def StealEigenvectors(self): r"""StealEigenvectors(HypreAME self) -> mfem::HypreParVector **""" return _hypre.HypreAME_StealEigenvectors(self) + StealEigenvectors = _swig_new_instance_method(_hypre.HypreAME_StealEigenvectors) # Register HypreAME in _hypre: _hypre.HypreAME_swigregister(HypreAME) diff --git a/mfem/_par/hypre_wrap.cxx b/mfem/_par/hypre_wrap.cxx index 4464b159..03cee99b 100644 --- a/mfem/_par/hypre_wrap.cxx +++ b/mfem/_par/hypre_wrap.cxx @@ -3105,17 +3105,20 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[37] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[38] #define SWIGTYPE_p_mfem__RAPOperator swig_types[39] -#define SWIGTYPE_p_mfem__Solver swig_types[40] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[41] -#define SWIGTYPE_p_mfem__Table swig_types[42] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[43] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[44] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[45] -#define SWIGTYPE_p_mfem__Vector swig_types[46] -#define SWIGTYPE_p_p_int swig_types[47] -#define SWIGTYPE_p_p_mfem__HypreParVector swig_types[48] -static swig_type_info *swig_types[50]; -static swig_module_info swig_module = {swig_types, 49, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[40] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[41] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[42] +#define SWIGTYPE_p_mfem__Solver swig_types[43] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[44] +#define SWIGTYPE_p_mfem__Table swig_types[45] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[46] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[47] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[48] +#define SWIGTYPE_p_mfem__Vector swig_types[49] +#define SWIGTYPE_p_p_int swig_types[50] +#define SWIGTYPE_p_p_mfem__HypreParVector swig_types[51] +static swig_type_info *swig_types[53]; +static swig_module_info swig_module = {swig_types, 52, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5836,6 +5839,42 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_10(PyObject *SWIGUNUSEDPARM( } +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::HypreParMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreParMatrix" "', argument " "1"" of type '" "mfem::HypreParMatrix const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreParMatrix" "', argument " "1"" of type '" "mfem::HypreParMatrix const &""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + { + try { + result = (mfem::HypreParMatrix *)new mfem::HypreParMatrix((mfem::HypreParMatrix const &)*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[14] = { @@ -5856,6 +5895,14 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { return _wrap_new_HypreParMatrix__SWIG_2(self, argc, argv); } } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreParMatrix__SWIG_11(self, argc, argv); + } + } if (argc == 2) { int _v; void *vptr = 0; @@ -6026,10 +6073,10 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Table, 0); + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_8(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_4(self, argc, argv); } } } @@ -6069,10 +6116,10 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_4(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_8(self, argc, argv); } } } @@ -6303,7 +6350,8 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,HYPRE_Int *,HYPRE_Int *,mfem::SparseMatrix *)\n" " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,HYPRE_Int,HYPRE_Int,HYPRE_Int *,HYPRE_Int *,mfem::Table *)\n" " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,int,int,HYPRE_Int *,HYPRE_Int *,HYPRE_Int *,HYPRE_Int *,HYPRE_Int *,HYPRE_Int *,HYPRE_Int *,HYPRE_Int)\n" - " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,int,HYPRE_Int,HYPRE_Int,int *,HYPRE_Int *,double *,HYPRE_Int *,HYPRE_Int *)\n"); + " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,int,HYPRE_Int,HYPRE_Int,int *,HYPRE_Int *,double *,HYPRE_Int *,HYPRE_Int *)\n" + " mfem::HypreParMatrix::HypreParMatrix(mfem::HypreParMatrix const &)\n"); return 0; } @@ -9638,6 +9686,95 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateRowsCols(PyObject *self, PyOb } +SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::HypreParMatrix *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_EliminateCols", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + result = (mfem::HypreParMatrix *)(arg1)->EliminateCols((mfem::Array< int > const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_EliminateRows", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_EliminateRows" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_EliminateRows" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_EliminateRows" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + (arg1)->EliminateRows((mfem::Array< int > const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_HypreParMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; @@ -10670,18 +10807,66 @@ SWIGINTERN PyObject *HypreParMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ParMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + bool val3 ; + int ecode3 = 0 ; mfem::HypreParMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParMult", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMult" "', argument " "2"" of type '" "mfem::HypreParMatrix const *""'"); + } + arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMult" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + { + try { + result = (mfem::HypreParMatrix *)mfem::ParMult((mfem::HypreParMatrix const *)arg1,(mfem::HypreParMatrix const *)arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_OWN | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; + mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::HypreParMatrix *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); @@ -10712,6 +10897,58 @@ SWIGINTERN PyObject *_wrap_ParMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } +SWIGINTERN PyObject *_wrap_ParMult(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ParMult", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ParMult__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ParMult__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMult'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParMult(mfem::HypreParMatrix const *,mfem::HypreParMatrix const *,bool)\n" + " mfem::ParMult(mfem::HypreParMatrix const *,mfem::HypreParMatrix const *)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ParAdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; @@ -12615,23 +12852,30 @@ SWIGINTERN PyObject *_wrap_HypreSolver_Mult(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_delete_HypreSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSolver_SetErrorMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreSolver *arg1 = (mfem::HypreSolver *) 0 ; + mfem::HypreSolver::ErrorMode arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "HypreSolver_SetErrorMode", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HypreSolver" "', argument " "1"" of type '" "mfem::HypreSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSolver_SetErrorMode" "', argument " "1"" of type '" "mfem::HypreSolver const *""'"); } arg1 = reinterpret_cast< mfem::HypreSolver * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSolver_SetErrorMode" "', argument " "2"" of type '" "mfem::HypreSolver::ErrorMode""'"); + } + arg2 = static_cast< mfem::HypreSolver::ErrorMode >(val2); { try { - delete arg1; + ((mfem::HypreSolver const *)arg1)->SetErrorMode(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12649,34 +12893,23 @@ SWIGINTERN PyObject *_wrap_delete_HypreSolver(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *HypreSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__HypreSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_HyprePCG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_HypreSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; + mfem::HypreSolver *arg1 = (mfem::HypreSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::HyprePCG *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HyprePCG" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HyprePCG" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HypreSolver" "', argument " "1"" of type '" "mfem::HypreSolver *""'"); } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + arg1 = reinterpret_cast< mfem::HypreSolver * >(argp1); { try { - result = (mfem::HyprePCG *)new mfem::HyprePCG(*arg1); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12687,16 +12920,173 @@ SWIGINTERN PyObject *_wrap_new_HyprePCG(PyObject *SWIGUNUSEDPARM(self), PyObject // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HyprePCG, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HyprePCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; +SWIGINTERN PyObject *HypreSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__HypreSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_HyprePCG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + MPI_Comm arg1 ; + mfem::HyprePCG *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HyprePCG" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + try { + result = (mfem::HyprePCG *)new mfem::HyprePCG(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HyprePCG, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HyprePCG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::HyprePCG *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HyprePCG" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HyprePCG" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + { + try { + result = (mfem::HyprePCG *)new mfem::HyprePCG(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HyprePCG, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HyprePCG(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HyprePCG", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HyprePCG__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HyprePCG__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HyprePCG'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HyprePCG::HyprePCG(MPI_Comm)\n" + " mfem::HyprePCG::HyprePCG(mfem::HypreParMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_HyprePCG_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "HyprePCG_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetOperator" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); + } + arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyprePCG_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyprePCG_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_HyprePCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; double arg2 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13444,16 +13834,49 @@ SWIGINTERN PyObject *HyprePCG_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HypreGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreGMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + MPI_Comm arg1 ; + mfem::HypreGMRES *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HypreGMRES" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + try { + result = (mfem::HypreGMRES *)new mfem::HypreGMRES(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreGMRES, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HypreGMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::HypreGMRES *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreGMRES" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); @@ -13482,6 +13905,85 @@ SWIGINTERN PyObject *_wrap_new_HypreGMRES(PyObject *SWIGUNUSEDPARM(self), PyObje } +SWIGINTERN PyObject *_wrap_new_HypreGMRES(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HypreGMRES", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreGMRES__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreGMRES__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HypreGMRES'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HypreGMRES::HypreGMRES(MPI_Comm)\n" + " mfem::HypreGMRES::HypreGMRES(mfem::HypreParMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_HypreGMRES_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetOperator" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); + } + arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreGMRES_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreGMRES_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_HypreGMRES_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; @@ -14269,16 +14771,60 @@ SWIGINTERN PyObject *_wrap_new_HypreDiagScale(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreDiagScale_SetupFcn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreDiagScale_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreDiagScale *arg1 = (mfem::HypreDiagScale *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - HYPRE_PtrToParSolverFcn result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "HypreDiagScale_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreDiagScale, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreDiagScale_SetOperator" "', argument " "1"" of type '" "mfem::HypreDiagScale *""'"); + } + arg1 = reinterpret_cast< mfem::HypreDiagScale * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreDiagScale_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreDiagScale_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_HypreDiagScale_SetupFcn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreDiagScale *arg1 = (mfem::HypreDiagScale *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + HYPRE_PtrToParSolverFcn result; + + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreDiagScale, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreDiagScale_SetupFcn" "', argument " "1"" of type '" "mfem::HypreDiagScale const *""'"); @@ -14419,16 +14965,49 @@ SWIGINTERN PyObject *HypreDiagScale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HypreParaSails(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreParaSails__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + MPI_Comm arg1 ; + mfem::HypreParaSails *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HypreParaSails" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + try { + result = (mfem::HypreParaSails *)new mfem::HypreParaSails(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParaSails, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HypreParaSails__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::HypreParaSails *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreParaSails" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); @@ -14457,6 +15036,85 @@ SWIGINTERN PyObject *_wrap_new_HypreParaSails(PyObject *SWIGUNUSEDPARM(self), Py } +SWIGINTERN PyObject *_wrap_new_HypreParaSails(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HypreParaSails", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreParaSails__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreParaSails__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HypreParaSails'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HypreParaSails::HypreParaSails(MPI_Comm)\n" + " mfem::HypreParaSails::HypreParaSails(mfem::HypreParMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_HypreParaSails_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreParaSails *arg1 = (mfem::HypreParaSails *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "HypreParaSails_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParaSails, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParaSails_SetOperator" "', argument " "1"" of type '" "mfem::HypreParaSails *""'"); + } + arg1 = reinterpret_cast< mfem::HypreParaSails * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParaSails_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParaSails_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_HypreParaSails_SetSymmetry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreParaSails *arg1 = (mfem::HypreParaSails *) 0 ; @@ -14612,16 +15270,49 @@ SWIGINTERN PyObject *HypreParaSails_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HypreEuclid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreEuclid__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + MPI_Comm arg1 ; + mfem::HypreEuclid *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HypreEuclid" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + try { + result = (mfem::HypreEuclid *)new mfem::HypreEuclid(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreEuclid, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HypreEuclid__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::HypreEuclid *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreEuclid" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); @@ -14650,6 +15341,85 @@ SWIGINTERN PyObject *_wrap_new_HypreEuclid(PyObject *SWIGUNUSEDPARM(self), PyObj } +SWIGINTERN PyObject *_wrap_new_HypreEuclid(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HypreEuclid", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreEuclid__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreEuclid__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HypreEuclid'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HypreEuclid::HypreEuclid(MPI_Comm)\n" + " mfem::HypreEuclid::HypreEuclid(mfem::HypreParMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_HypreEuclid_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreEuclid *arg1 = (mfem::HypreEuclid *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "HypreEuclid_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreEuclid, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreEuclid_SetOperator" "', argument " "1"" of type '" "mfem::HypreEuclid *""'"); + } + arg1 = reinterpret_cast< mfem::HypreEuclid * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreEuclid_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreEuclid_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_HypreEuclid_SetupFcn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreEuclid *arg1 = (mfem::HypreEuclid *) 0 ; @@ -15136,7 +15906,40 @@ SWIGINTERN PyObject *HypreBoomerAMG_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HypreAMS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreAMS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::HypreAMS *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreAMS" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + { + try { + result = (mfem::HypreAMS *)new mfem::HypreAMS(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreAMS, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HypreAMS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = 0 ; mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; @@ -15144,26 +15947,110 @@ SWIGINTERN PyObject *_wrap_new_HypreAMS(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + mfem::HypreAMS *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreAMS" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreAMS" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HypreAMS" "', argument " "2"" of type '" "mfem::ParFiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp2); + { + try { + result = (mfem::HypreAMS *)new mfem::HypreAMS(*arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreAMS, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HypreAMS(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HypreAMS", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreAMS__SWIG_0(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreAMS__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HypreAMS'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HypreAMS::HypreAMS(mfem::ParFiniteElementSpace *)\n" + " mfem::HypreAMS::HypreAMS(mfem::HypreParMatrix &,mfem::ParFiniteElementSpace *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_HypreAMS_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreAMS *arg1 = (mfem::HypreAMS *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; PyObject *swig_obj[2] ; - mfem::HypreAMS *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_HypreAMS", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + if (!SWIG_Python_UnpackTuple(args, "HypreAMS_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreAMS" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreAMS" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAMS_SetOperator" "', argument " "1"" of type '" "mfem::HypreAMS *""'"); } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + arg1 = reinterpret_cast< mfem::HypreAMS * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HypreAMS" "', argument " "2"" of type '" "mfem::ParFiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreAMS_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - arg2 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreAMS_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - result = (mfem::HypreAMS *)new mfem::HypreAMS(*arg1,arg2); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15174,7 +16061,7 @@ SWIGINTERN PyObject *_wrap_new_HypreAMS(PyObject *SWIGUNUSEDPARM(self), PyObject // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreAMS, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; @@ -15370,7 +16257,40 @@ SWIGINTERN PyObject *HypreAMS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HypreADS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreADS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::HypreADS *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreADS" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + { + try { + result = (mfem::HypreADS *)new mfem::HypreADS(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreADS, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HypreADS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = 0 ; mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; @@ -15378,10 +16298,9 @@ SWIGINTERN PyObject *_wrap_new_HypreADS(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; mfem::HypreADS *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_HypreADS", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreADS" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); @@ -15415,6 +16334,91 @@ SWIGINTERN PyObject *_wrap_new_HypreADS(PyObject *SWIGUNUSEDPARM(self), PyObject } +SWIGINTERN PyObject *_wrap_new_HypreADS(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HypreADS", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreADS__SWIG_0(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreADS__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HypreADS'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HypreADS::HypreADS(mfem::ParFiniteElementSpace *)\n" + " mfem::HypreADS::HypreADS(mfem::HypreParMatrix &,mfem::ParFiniteElementSpace *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_HypreADS_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreADS *arg1 = (mfem::HypreADS *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "HypreADS_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreADS, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreADS_SetOperator" "', argument " "1"" of type '" "mfem::HypreADS *""'"); + } + arg1 = reinterpret_cast< mfem::HypreADS * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreADS_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreADS_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_HypreADS_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreADS *arg1 = (mfem::HypreADS *) 0 ; @@ -16886,6 +17890,7 @@ SWIGINTERN PyObject *HypreAME_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "sizeof_HYPRE_Int", _wrap_sizeof_HYPRE_Int, METH_NOARGS, "sizeof_HYPRE_Int() -> int"}, { "new_HypreParVector", _wrap_new_HypreParVector, METH_VARARGS, "\n" "HypreParVector(MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * col)\n" @@ -16920,7 +17925,8 @@ static PyMethodDef SwigMethods[] = { "HypreParMatrix(MPI_Comm comm, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix a)\n" "HypreParMatrix(MPI_Comm comm, HYPRE_Int global_num_rows, HYPRE_Int global_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, mfem::Table * diag)\n" "HypreParMatrix(MPI_Comm comm, int id, int np, HYPRE_Int * row, HYPRE_Int * col, HYPRE_Int * i_diag, HYPRE_Int * j_diag, HYPRE_Int * i_offd, HYPRE_Int * j_offd, HYPRE_Int * cmap, HYPRE_Int cmap_size)\n" - "new_HypreParMatrix(MPI_Comm comm, int nrows, HYPRE_Int glob_nrows, HYPRE_Int glob_ncols, int * I) -> HypreParMatrix\n" + "HypreParMatrix(MPI_Comm comm, int nrows, HYPRE_Int glob_nrows, HYPRE_Int glob_ncols, int * I)\n" + "new_HypreParMatrix(HypreParMatrix P) -> HypreParMatrix\n" ""}, { "HypreParMatrix_MakeRef", _wrap_HypreParMatrix_MakeRef, METH_VARARGS, "HypreParMatrix_MakeRef(HypreParMatrix self, HypreParMatrix master)"}, { "HypreParMatrix_GetComm", _wrap_HypreParMatrix_GetComm, METH_O, "HypreParMatrix_GetComm(HypreParMatrix self) -> MPI_Comm"}, @@ -16980,6 +17986,8 @@ static PyMethodDef SwigMethods[] = { "HypreParMatrix_EliminateRowsCols(HypreParMatrix self, intArray rows_cols, HypreParVector X, HypreParVector B)\n" "HypreParMatrix_EliminateRowsCols(HypreParMatrix self, intArray rows_cols) -> HypreParMatrix\n" ""}, + { "HypreParMatrix_EliminateCols", _wrap_HypreParMatrix_EliminateCols, METH_VARARGS, "HypreParMatrix_EliminateCols(HypreParMatrix self, intArray cols) -> HypreParMatrix"}, + { "HypreParMatrix_EliminateRows", _wrap_HypreParMatrix_EliminateRows, METH_VARARGS, "HypreParMatrix_EliminateRows(HypreParMatrix self, intArray rows)"}, { "HypreParMatrix_Print", _wrap_HypreParMatrix_Print, METH_VARARGS, "HypreParMatrix_Print(HypreParMatrix self, char const * fname, HYPRE_Int offi=0, HYPRE_Int offj=0)"}, { "HypreParMatrix_Read", _wrap_HypreParMatrix_Read, METH_VARARGS, "HypreParMatrix_Read(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, { "HypreParMatrix_Read_IJMatrix", _wrap_HypreParMatrix_Read_IJMatrix, METH_VARARGS, "HypreParMatrix_Read_IJMatrix(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, @@ -16996,7 +18004,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "HypreParMatrix_swigregister", HypreParMatrix_swigregister, METH_O, NULL}, { "HypreParMatrix_swiginit", HypreParMatrix_swiginit, METH_VARARGS, NULL}, - { "ParMult", _wrap_ParMult, METH_VARARGS, "ParMult(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix"}, + { "ParMult", _wrap_ParMult, METH_VARARGS, "ParMult(HypreParMatrix A, HypreParMatrix B, bool own_matrix=False) -> HypreParMatrix"}, { "ParAdd", _wrap_ParAdd, METH_VARARGS, "ParAdd(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix"}, { "EliminateBC", _wrap_EliminateBC, METH_VARARGS, "EliminateBC(HypreParMatrix A, HypreParMatrix Ae, intArray ess_dof_list, Vector X, Vector B)"}, { "new_HypreSmoother", _wrap_new_HypreSmoother, METH_VARARGS, "\n" @@ -17026,9 +18034,14 @@ static PyMethodDef SwigMethods[] = { "HypreSolver_Mult(HypreSolver self, HypreParVector b, HypreParVector x)\n" "HypreSolver_Mult(HypreSolver self, Vector b, Vector x)\n" ""}, + { "HypreSolver_SetErrorMode", _wrap_HypreSolver_SetErrorMode, METH_VARARGS, "HypreSolver_SetErrorMode(HypreSolver self, mfem::HypreSolver::ErrorMode err_mode)"}, { "delete_HypreSolver", _wrap_delete_HypreSolver, METH_O, "delete_HypreSolver(HypreSolver self)"}, { "HypreSolver_swigregister", HypreSolver_swigregister, METH_O, NULL}, - { "new_HyprePCG", _wrap_new_HyprePCG, METH_O, "new_HyprePCG(HypreParMatrix _A) -> HyprePCG"}, + { "new_HyprePCG", _wrap_new_HyprePCG, METH_VARARGS, "\n" + "HyprePCG(MPI_Comm comm)\n" + "new_HyprePCG(HypreParMatrix _A) -> HyprePCG\n" + ""}, + { "HyprePCG_SetOperator", _wrap_HyprePCG_SetOperator, METH_VARARGS, "HyprePCG_SetOperator(HyprePCG self, Operator op)"}, { "HyprePCG_SetTol", _wrap_HyprePCG_SetTol, METH_VARARGS, "HyprePCG_SetTol(HyprePCG self, double tol)"}, { "HyprePCG_SetMaxIter", _wrap_HyprePCG_SetMaxIter, METH_VARARGS, "HyprePCG_SetMaxIter(HyprePCG self, int max_iter)"}, { "HyprePCG_SetLogging", _wrap_HyprePCG_SetLogging, METH_VARARGS, "HyprePCG_SetLogging(HyprePCG self, int logging)"}, @@ -17046,7 +18059,11 @@ static PyMethodDef SwigMethods[] = { { "delete_HyprePCG", _wrap_delete_HyprePCG, METH_O, "delete_HyprePCG(HyprePCG self)"}, { "HyprePCG_swigregister", HyprePCG_swigregister, METH_O, NULL}, { "HyprePCG_swiginit", HyprePCG_swiginit, METH_VARARGS, NULL}, - { "new_HypreGMRES", _wrap_new_HypreGMRES, METH_O, "new_HypreGMRES(HypreParMatrix _A) -> HypreGMRES"}, + { "new_HypreGMRES", _wrap_new_HypreGMRES, METH_VARARGS, "\n" + "HypreGMRES(MPI_Comm comm)\n" + "new_HypreGMRES(HypreParMatrix _A) -> HypreGMRES\n" + ""}, + { "HypreGMRES_SetOperator", _wrap_HypreGMRES_SetOperator, METH_VARARGS, "HypreGMRES_SetOperator(HypreGMRES self, Operator op)"}, { "HypreGMRES_SetTol", _wrap_HypreGMRES_SetTol, METH_VARARGS, "HypreGMRES_SetTol(HypreGMRES self, double tol)"}, { "HypreGMRES_SetMaxIter", _wrap_HypreGMRES_SetMaxIter, METH_VARARGS, "HypreGMRES_SetMaxIter(HypreGMRES self, int max_iter)"}, { "HypreGMRES_SetKDim", _wrap_HypreGMRES_SetKDim, METH_VARARGS, "HypreGMRES_SetKDim(HypreGMRES self, int dim)"}, @@ -17073,20 +18090,29 @@ static PyMethodDef SwigMethods[] = { "HypreDiagScale()\n" "new_HypreDiagScale(HypreParMatrix A) -> HypreDiagScale\n" ""}, + { "HypreDiagScale_SetOperator", _wrap_HypreDiagScale_SetOperator, METH_VARARGS, "HypreDiagScale_SetOperator(HypreDiagScale self, Operator op)"}, { "HypreDiagScale_SetupFcn", _wrap_HypreDiagScale_SetupFcn, METH_O, "HypreDiagScale_SetupFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, { "HypreDiagScale_SolveFcn", _wrap_HypreDiagScale_SolveFcn, METH_O, "HypreDiagScale_SolveFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, { "HypreDiagScale_GetData", _wrap_HypreDiagScale_GetData, METH_O, "HypreDiagScale_GetData(HypreDiagScale self) -> HypreParMatrix"}, { "delete_HypreDiagScale", _wrap_delete_HypreDiagScale, METH_O, "delete_HypreDiagScale(HypreDiagScale self)"}, { "HypreDiagScale_swigregister", HypreDiagScale_swigregister, METH_O, NULL}, { "HypreDiagScale_swiginit", HypreDiagScale_swiginit, METH_VARARGS, NULL}, - { "new_HypreParaSails", _wrap_new_HypreParaSails, METH_O, "new_HypreParaSails(HypreParMatrix A) -> HypreParaSails"}, + { "new_HypreParaSails", _wrap_new_HypreParaSails, METH_VARARGS, "\n" + "HypreParaSails(MPI_Comm comm)\n" + "new_HypreParaSails(HypreParMatrix A) -> HypreParaSails\n" + ""}, + { "HypreParaSails_SetOperator", _wrap_HypreParaSails_SetOperator, METH_VARARGS, "HypreParaSails_SetOperator(HypreParaSails self, Operator op)"}, { "HypreParaSails_SetSymmetry", _wrap_HypreParaSails_SetSymmetry, METH_VARARGS, "HypreParaSails_SetSymmetry(HypreParaSails self, int sym)"}, { "HypreParaSails_SetupFcn", _wrap_HypreParaSails_SetupFcn, METH_O, "HypreParaSails_SetupFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, { "HypreParaSails_SolveFcn", _wrap_HypreParaSails_SolveFcn, METH_O, "HypreParaSails_SolveFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreParaSails", _wrap_delete_HypreParaSails, METH_O, "delete_HypreParaSails(HypreParaSails self)"}, { "HypreParaSails_swigregister", HypreParaSails_swigregister, METH_O, NULL}, { "HypreParaSails_swiginit", HypreParaSails_swiginit, METH_VARARGS, NULL}, - { "new_HypreEuclid", _wrap_new_HypreEuclid, METH_O, "new_HypreEuclid(HypreParMatrix A) -> HypreEuclid"}, + { "new_HypreEuclid", _wrap_new_HypreEuclid, METH_VARARGS, "\n" + "HypreEuclid(MPI_Comm comm)\n" + "new_HypreEuclid(HypreParMatrix A) -> HypreEuclid\n" + ""}, + { "HypreEuclid_SetOperator", _wrap_HypreEuclid_SetOperator, METH_VARARGS, "HypreEuclid_SetOperator(HypreEuclid self, Operator op)"}, { "HypreEuclid_SetupFcn", _wrap_HypreEuclid_SetupFcn, METH_O, "HypreEuclid_SetupFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, { "HypreEuclid_SolveFcn", _wrap_HypreEuclid_SolveFcn, METH_O, "HypreEuclid_SolveFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreEuclid", _wrap_delete_HypreEuclid, METH_O, "delete_HypreEuclid(HypreEuclid self)"}, @@ -17105,7 +18131,11 @@ static PyMethodDef SwigMethods[] = { { "delete_HypreBoomerAMG", _wrap_delete_HypreBoomerAMG, METH_O, "delete_HypreBoomerAMG(HypreBoomerAMG self)"}, { "HypreBoomerAMG_swigregister", HypreBoomerAMG_swigregister, METH_O, NULL}, { "HypreBoomerAMG_swiginit", HypreBoomerAMG_swiginit, METH_VARARGS, NULL}, - { "new_HypreAMS", _wrap_new_HypreAMS, METH_VARARGS, "new_HypreAMS(HypreParMatrix A, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS"}, + { "new_HypreAMS", _wrap_new_HypreAMS, METH_VARARGS, "\n" + "HypreAMS(mfem::ParFiniteElementSpace * edge_fespace)\n" + "new_HypreAMS(HypreParMatrix A, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS\n" + ""}, + { "HypreAMS_SetOperator", _wrap_HypreAMS_SetOperator, METH_VARARGS, "HypreAMS_SetOperator(HypreAMS self, Operator op)"}, { "HypreAMS_SetPrintLevel", _wrap_HypreAMS_SetPrintLevel, METH_VARARGS, "HypreAMS_SetPrintLevel(HypreAMS self, int print_lvl)"}, { "HypreAMS_SetSingularProblem", _wrap_HypreAMS_SetSingularProblem, METH_O, "HypreAMS_SetSingularProblem(HypreAMS self)"}, { "HypreAMS_SetupFcn", _wrap_HypreAMS_SetupFcn, METH_O, "HypreAMS_SetupFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn"}, @@ -17113,7 +18143,11 @@ static PyMethodDef SwigMethods[] = { { "delete_HypreAMS", _wrap_delete_HypreAMS, METH_O, "delete_HypreAMS(HypreAMS self)"}, { "HypreAMS_swigregister", HypreAMS_swigregister, METH_O, NULL}, { "HypreAMS_swiginit", HypreAMS_swiginit, METH_VARARGS, NULL}, - { "new_HypreADS", _wrap_new_HypreADS, METH_VARARGS, "new_HypreADS(HypreParMatrix A, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS"}, + { "new_HypreADS", _wrap_new_HypreADS, METH_VARARGS, "\n" + "HypreADS(mfem::ParFiniteElementSpace * face_fespace)\n" + "new_HypreADS(HypreParMatrix A, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS\n" + ""}, + { "HypreADS_SetOperator", _wrap_HypreADS_SetOperator, METH_VARARGS, "HypreADS_SetOperator(HypreADS self, Operator op)"}, { "HypreADS_SetPrintLevel", _wrap_HypreADS_SetPrintLevel, METH_VARARGS, "HypreADS_SetPrintLevel(HypreADS self, int print_lvl)"}, { "HypreADS_SetupFcn", _wrap_HypreADS_SetupFcn, METH_O, "HypreADS_SetupFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, { "HypreADS_SolveFcn", _wrap_HypreADS_SolveFcn, METH_O, "HypreADS_SolveFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, @@ -17160,6 +18194,307 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "sizeof_HYPRE_Int", _wrap_sizeof_HYPRE_Int, METH_NOARGS, "sizeof_HYPRE_Int() -> int"}, + { "new_HypreParVector", _wrap_new_HypreParVector, METH_VARARGS, "\n" + "HypreParVector(MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * col)\n" + "HypreParVector(MPI_Comm comm, HYPRE_Int glob_size, double * _data)\n" + "HypreParVector(HypreParVector y)\n" + "HypreParVector(HypreParMatrix A, int transpose=0)\n" + "HypreParVector(HYPRE_ParVector y)\n" + "new_HypreParVector(mfem::ParFiniteElementSpace * pfes) -> HypreParVector\n" + ""}, + { "HypreParVector_GetComm", _wrap_HypreParVector_GetComm, METH_O, "GetComm(HypreParVector self) -> MPI_Comm"}, + { "HypreParVector_Partitioning", _wrap_HypreParVector_Partitioning, METH_O, "Partitioning(HypreParVector self) -> HYPRE_Int *"}, + { "HypreParVector_GlobalSize", _wrap_HypreParVector_GlobalSize, METH_O, "GlobalSize(HypreParVector self) -> HYPRE_Int"}, + { "HypreParVector_StealParVector", _wrap_HypreParVector_StealParVector, METH_O, "StealParVector(HypreParVector self) -> hypre_ParVector *"}, + { "HypreParVector_SetOwnership", _wrap_HypreParVector_SetOwnership, METH_VARARGS, "SetOwnership(HypreParVector self, int own)"}, + { "HypreParVector_GetOwnership", _wrap_HypreParVector_GetOwnership, METH_O, "GetOwnership(HypreParVector self) -> int"}, + { "HypreParVector_GlobalVector", _wrap_HypreParVector_GlobalVector, METH_O, "GlobalVector(HypreParVector self) -> Vector"}, + { "HypreParVector_SetData", _wrap_HypreParVector_SetData, METH_VARARGS, "SetData(HypreParVector self, double * _data)"}, + { "HypreParVector_Randomize", _wrap_HypreParVector_Randomize, METH_VARARGS, "Randomize(HypreParVector self, HYPRE_Int seed) -> HYPRE_Int"}, + { "HypreParVector_Print", _wrap_HypreParVector_Print, METH_VARARGS, "Print(HypreParVector self, char const * fname)"}, + { "delete_HypreParVector", _wrap_delete_HypreParVector, METH_O, "delete_HypreParVector(HypreParVector self)"}, + { "HypreParVector_GetPartitioningArray", _wrap_HypreParVector_GetPartitioningArray, METH_O, "GetPartitioningArray(HypreParVector self) -> PyObject *"}, + { "HypreParVector_swigregister", HypreParVector_swigregister, METH_O, NULL}, + { "HypreParVector_swiginit", HypreParVector_swiginit, METH_VARARGS, NULL}, + { "ParNormlp", _wrap_ParNormlp, METH_VARARGS, "ParNormlp(Vector vec, double p, MPI_Comm comm) -> double"}, + { "new_HypreParMatrix", _wrap_new_HypreParMatrix, METH_VARARGS, "\n" + "HypreParMatrix()\n" + "HypreParMatrix(hypre_ParCSRMatrix * a, bool owner=True)\n" + "HypreParMatrix(MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * row_starts, SparseMatrix diag)\n" + "HypreParMatrix(MPI_Comm comm, HYPRE_Int global_num_rows, HYPRE_Int global_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag)\n" + "HypreParMatrix(MPI_Comm comm, HYPRE_Int global_num_rows, HYPRE_Int global_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag, SparseMatrix offd, HYPRE_Int * cmap)\n" + "HypreParMatrix(MPI_Comm comm, HYPRE_Int global_num_rows, HYPRE_Int global_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, HYPRE_Int * diag_i, HYPRE_Int * diag_j, double * diag_data, HYPRE_Int * offd_i, HYPRE_Int * offd_j, double * offd_data, HYPRE_Int offd_num_cols, HYPRE_Int * offd_col_map)\n" + "HypreParMatrix(MPI_Comm comm, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix a)\n" + "HypreParMatrix(MPI_Comm comm, HYPRE_Int global_num_rows, HYPRE_Int global_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, mfem::Table * diag)\n" + "HypreParMatrix(MPI_Comm comm, int id, int np, HYPRE_Int * row, HYPRE_Int * col, HYPRE_Int * i_diag, HYPRE_Int * j_diag, HYPRE_Int * i_offd, HYPRE_Int * j_offd, HYPRE_Int * cmap, HYPRE_Int cmap_size)\n" + "HypreParMatrix(MPI_Comm comm, int nrows, HYPRE_Int glob_nrows, HYPRE_Int glob_ncols, int * I)\n" + "new_HypreParMatrix(HypreParMatrix P) -> HypreParMatrix\n" + ""}, + { "HypreParMatrix_MakeRef", _wrap_HypreParMatrix_MakeRef, METH_VARARGS, "MakeRef(HypreParMatrix self, HypreParMatrix master)"}, + { "HypreParMatrix_GetComm", _wrap_HypreParMatrix_GetComm, METH_O, "GetComm(HypreParMatrix self) -> MPI_Comm"}, + { "HypreParMatrix_StealData", _wrap_HypreParMatrix_StealData, METH_O, "StealData(HypreParMatrix self) -> hypre_ParCSRMatrix *"}, + { "HypreParMatrix_SetOwnerFlags", _wrap_HypreParMatrix_SetOwnerFlags, METH_VARARGS, "SetOwnerFlags(HypreParMatrix self, signed char diag, signed char offd, signed char colmap)"}, + { "HypreParMatrix_OwnsDiag", _wrap_HypreParMatrix_OwnsDiag, METH_O, "OwnsDiag(HypreParMatrix self) -> signed char"}, + { "HypreParMatrix_OwnsOffd", _wrap_HypreParMatrix_OwnsOffd, METH_O, "OwnsOffd(HypreParMatrix self) -> signed char"}, + { "HypreParMatrix_OwnsColMap", _wrap_HypreParMatrix_OwnsColMap, METH_O, "OwnsColMap(HypreParMatrix self) -> signed char"}, + { "HypreParMatrix_CopyRowStarts", _wrap_HypreParMatrix_CopyRowStarts, METH_O, "CopyRowStarts(HypreParMatrix self)"}, + { "HypreParMatrix_CopyColStarts", _wrap_HypreParMatrix_CopyColStarts, METH_O, "CopyColStarts(HypreParMatrix self)"}, + { "HypreParMatrix_NNZ", _wrap_HypreParMatrix_NNZ, METH_O, "NNZ(HypreParMatrix self) -> HYPRE_Int"}, + { "HypreParMatrix_RowPart", _wrap_HypreParMatrix_RowPart, METH_VARARGS, "\n" + "RowPart(HypreParMatrix self) -> HYPRE_Int\n" + "RowPart(HypreParMatrix self) -> HYPRE_Int const *\n" + ""}, + { "HypreParMatrix_ColPart", _wrap_HypreParMatrix_ColPart, METH_VARARGS, "\n" + "ColPart(HypreParMatrix self) -> HYPRE_Int\n" + "ColPart(HypreParMatrix self) -> HYPRE_Int const *\n" + ""}, + { "HypreParMatrix_M", _wrap_HypreParMatrix_M, METH_O, "M(HypreParMatrix self) -> HYPRE_Int"}, + { "HypreParMatrix_N", _wrap_HypreParMatrix_N, METH_O, "N(HypreParMatrix self) -> HYPRE_Int"}, + { "HypreParMatrix_GetDiag", _wrap_HypreParMatrix_GetDiag, METH_VARARGS, "\n" + "GetDiag(HypreParMatrix self, Vector diag)\n" + "GetDiag(HypreParMatrix self, SparseMatrix diag)\n" + ""}, + { "HypreParMatrix_GetOffd", _wrap_HypreParMatrix_GetOffd, METH_VARARGS, "GetOffd(HypreParMatrix self, SparseMatrix offd, HYPRE_Int *& cmap)"}, + { "HypreParMatrix_GetBlocks", _wrap_HypreParMatrix_GetBlocks, METH_VARARGS, "GetBlocks(HypreParMatrix self, mfem::Array2D< mfem::HypreParMatrix * > & blocks, bool interleaved_rows=False, bool interleaved_cols=False)"}, + { "HypreParMatrix_Transpose", _wrap_HypreParMatrix_Transpose, METH_O, "Transpose(HypreParMatrix self) -> HypreParMatrix"}, + { "HypreParMatrix_GetNumRows", _wrap_HypreParMatrix_GetNumRows, METH_O, "GetNumRows(HypreParMatrix self) -> int"}, + { "HypreParMatrix_GetNumCols", _wrap_HypreParMatrix_GetNumCols, METH_O, "GetNumCols(HypreParMatrix self) -> int"}, + { "HypreParMatrix_GetGlobalNumRows", _wrap_HypreParMatrix_GetGlobalNumRows, METH_O, "GetGlobalNumRows(HypreParMatrix self) -> HYPRE_Int"}, + { "HypreParMatrix_GetGlobalNumCols", _wrap_HypreParMatrix_GetGlobalNumCols, METH_O, "GetGlobalNumCols(HypreParMatrix self) -> HYPRE_Int"}, + { "HypreParMatrix_GetRowStarts", _wrap_HypreParMatrix_GetRowStarts, METH_O, "GetRowStarts(HypreParMatrix self) -> HYPRE_Int *"}, + { "HypreParMatrix_GetColStarts", _wrap_HypreParMatrix_GetColStarts, METH_O, "GetColStarts(HypreParMatrix self) -> HYPRE_Int *"}, + { "HypreParMatrix_Mult", _wrap_HypreParMatrix_Mult, METH_VARARGS, "\n" + "Mult(HypreParMatrix self, HypreParVector x, HypreParVector y, double alpha=1.0, double beta=0.0) -> HYPRE_Int\n" + "Mult(HypreParMatrix self, HYPRE_ParVector x, HYPRE_ParVector y, double alpha=1.0, double beta=0.0) -> HYPRE_Int\n" + "Mult(HypreParMatrix self, double a, Vector x, double b, Vector y)\n" + "Mult(HypreParMatrix self, Vector x, Vector y)\n" + ""}, + { "HypreParMatrix_MultTranspose", _wrap_HypreParMatrix_MultTranspose, METH_VARARGS, "\n" + "MultTranspose(HypreParMatrix self, HypreParVector x, HypreParVector y, double alpha=1.0, double beta=0.0) -> HYPRE_Int\n" + "MultTranspose(HypreParMatrix self, double a, Vector x, double b, Vector y)\n" + "MultTranspose(HypreParMatrix self, Vector x, Vector y)\n" + ""}, + { "HypreParMatrix_BooleanMult", _wrap_HypreParMatrix_BooleanMult, METH_VARARGS, "BooleanMult(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, + { "HypreParMatrix_BooleanMultTranspose", _wrap_HypreParMatrix_BooleanMultTranspose, METH_VARARGS, "BooleanMultTranspose(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, + { "HypreParMatrix___iadd__", _wrap_HypreParMatrix___iadd__, METH_VARARGS, "__iadd__(HypreParMatrix self, HypreParMatrix B) -> HypreParMatrix"}, + { "HypreParMatrix_Add", _wrap_HypreParMatrix_Add, METH_VARARGS, "Add(HypreParMatrix self, double const beta, HypreParMatrix B) -> HypreParMatrix"}, + { "HypreParMatrix_LeftDiagMult", _wrap_HypreParMatrix_LeftDiagMult, METH_VARARGS, "LeftDiagMult(HypreParMatrix self, SparseMatrix D, HYPRE_Int * row_starts=None) -> HypreParMatrix"}, + { "HypreParMatrix_ScaleRows", _wrap_HypreParMatrix_ScaleRows, METH_VARARGS, "ScaleRows(HypreParMatrix self, Vector s)"}, + { "HypreParMatrix_InvScaleRows", _wrap_HypreParMatrix_InvScaleRows, METH_VARARGS, "InvScaleRows(HypreParMatrix self, Vector s)"}, + { "HypreParMatrix___imul__", _wrap_HypreParMatrix___imul__, METH_VARARGS, "__imul__(HypreParMatrix self, double s)"}, + { "HypreParMatrix_Threshold", _wrap_HypreParMatrix_Threshold, METH_VARARGS, "Threshold(HypreParMatrix self, double threshold=0.0)"}, + { "HypreParMatrix_EliminateZeroRows", _wrap_HypreParMatrix_EliminateZeroRows, METH_O, "EliminateZeroRows(HypreParMatrix self)"}, + { "HypreParMatrix_EliminateRowsCols", _wrap_HypreParMatrix_EliminateRowsCols, METH_VARARGS, "\n" + "EliminateRowsCols(HypreParMatrix self, intArray rows_cols, HypreParVector X, HypreParVector B)\n" + "EliminateRowsCols(HypreParMatrix self, intArray rows_cols) -> HypreParMatrix\n" + ""}, + { "HypreParMatrix_EliminateCols", _wrap_HypreParMatrix_EliminateCols, METH_VARARGS, "EliminateCols(HypreParMatrix self, intArray cols) -> HypreParMatrix"}, + { "HypreParMatrix_EliminateRows", _wrap_HypreParMatrix_EliminateRows, METH_VARARGS, "EliminateRows(HypreParMatrix self, intArray rows)"}, + { "HypreParMatrix_Print", _wrap_HypreParMatrix_Print, METH_VARARGS, "Print(HypreParMatrix self, char const * fname, HYPRE_Int offi=0, HYPRE_Int offj=0)"}, + { "HypreParMatrix_Read", _wrap_HypreParMatrix_Read, METH_VARARGS, "Read(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, + { "HypreParMatrix_Read_IJMatrix", _wrap_HypreParMatrix_Read_IJMatrix, METH_VARARGS, "Read_IJMatrix(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, + { "delete_HypreParMatrix", _wrap_delete_HypreParMatrix, METH_O, "delete_HypreParMatrix(HypreParMatrix self)"}, + { "HypreParMatrix_GetType", _wrap_HypreParMatrix_GetType, METH_O, "GetType(HypreParMatrix self) -> mfem::Operator::Type"}, + { "HypreParMatrix_GetRowPartArray", _wrap_HypreParMatrix_GetRowPartArray, METH_O, "GetRowPartArray(HypreParMatrix self) -> PyObject *"}, + { "HypreParMatrix_GetColPartArray", _wrap_HypreParMatrix_GetColPartArray, METH_O, "GetColPartArray(HypreParMatrix self) -> PyObject *"}, + { "HypreParMatrix_get_local_nnz", _wrap_HypreParMatrix_get_local_nnz, METH_O, "get_local_nnz(HypreParMatrix self) -> HYPRE_Int"}, + { "HypreParMatrix_get_local_true_nnz", _wrap_HypreParMatrix_get_local_true_nnz, METH_O, "get_local_true_nnz(HypreParMatrix self) -> PyObject *"}, + { "HypreParMatrix_GetCooDataArray", _wrap_HypreParMatrix_GetCooDataArray, METH_VARARGS, "GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject"}, + { "HypreParMatrix_PrintCommPkg", _wrap_HypreParMatrix_PrintCommPkg, METH_VARARGS, "\n" + "PrintCommPkg(HypreParMatrix self, std::ostream & out=mfem::out)\n" + "PrintCommPkg(HypreParMatrix self, char const * file, int precision=8)\n" + ""}, + { "HypreParMatrix_swigregister", HypreParMatrix_swigregister, METH_O, NULL}, + { "HypreParMatrix_swiginit", HypreParMatrix_swiginit, METH_VARARGS, NULL}, + { "ParMult", _wrap_ParMult, METH_VARARGS, "ParMult(HypreParMatrix A, HypreParMatrix B, bool own_matrix=False) -> HypreParMatrix"}, + { "ParAdd", _wrap_ParAdd, METH_VARARGS, "ParAdd(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix"}, + { "EliminateBC", _wrap_EliminateBC, METH_VARARGS, "EliminateBC(HypreParMatrix A, HypreParMatrix Ae, intArray ess_dof_list, Vector X, Vector B)"}, + { "new_HypreSmoother", _wrap_new_HypreSmoother, METH_VARARGS, "\n" + "HypreSmoother()\n" + "HypreSmoother(HypreParMatrix _A, int type=l1GS, int relax_times=1, double relax_weight=1.0, double omega=1.0, int poly_order=2, double poly_fraction=.3)\n" + ""}, + { "HypreSmoother_SetType", _wrap_HypreSmoother_SetType, METH_VARARGS, "SetType(HypreSmoother self, mfem::HypreSmoother::Type type, int relax_times=1)"}, + { "HypreSmoother_SetSOROptions", _wrap_HypreSmoother_SetSOROptions, METH_VARARGS, "SetSOROptions(HypreSmoother self, double relax_weight, double omega)"}, + { "HypreSmoother_SetPolyOptions", _wrap_HypreSmoother_SetPolyOptions, METH_VARARGS, "SetPolyOptions(HypreSmoother self, int poly_order, double poly_fraction)"}, + { "HypreSmoother_SetTaubinOptions", _wrap_HypreSmoother_SetTaubinOptions, METH_VARARGS, "SetTaubinOptions(HypreSmoother self, double _lambda, double mu, int iter)"}, + { "HypreSmoother_SetWindowByName", _wrap_HypreSmoother_SetWindowByName, METH_VARARGS, "SetWindowByName(HypreSmoother self, char const * window_name)"}, + { "HypreSmoother_SetWindowParameters", _wrap_HypreSmoother_SetWindowParameters, METH_VARARGS, "SetWindowParameters(HypreSmoother self, double a, double b, double c)"}, + { "HypreSmoother_SetFIRCoefficients", _wrap_HypreSmoother_SetFIRCoefficients, METH_VARARGS, "SetFIRCoefficients(HypreSmoother self, double max_eig)"}, + { "HypreSmoother_SetPositiveDiagonal", _wrap_HypreSmoother_SetPositiveDiagonal, METH_VARARGS, "SetPositiveDiagonal(HypreSmoother self, bool pos=True)"}, + { "HypreSmoother_SetOperator", _wrap_HypreSmoother_SetOperator, METH_VARARGS, "SetOperator(HypreSmoother self, Operator op)"}, + { "HypreSmoother_Mult", _wrap_HypreSmoother_Mult, METH_VARARGS, "\n" + "Mult(HypreSmoother self, HypreParVector b, HypreParVector x)\n" + "Mult(HypreSmoother self, Vector b, Vector x)\n" + ""}, + { "delete_HypreSmoother", _wrap_delete_HypreSmoother, METH_O, "delete_HypreSmoother(HypreSmoother self)"}, + { "HypreSmoother_swigregister", HypreSmoother_swigregister, METH_O, NULL}, + { "HypreSmoother_swiginit", HypreSmoother_swiginit, METH_VARARGS, NULL}, + { "HypreSolver_SetupFcn", _wrap_HypreSolver_SetupFcn, METH_O, "SetupFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreSolver_SolveFcn", _wrap_HypreSolver_SolveFcn, METH_O, "SolveFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreSolver_SetOperator", _wrap_HypreSolver_SetOperator, METH_VARARGS, "SetOperator(HypreSolver self, Operator op)"}, + { "HypreSolver_Mult", _wrap_HypreSolver_Mult, METH_VARARGS, "\n" + "Mult(HypreSolver self, HypreParVector b, HypreParVector x)\n" + "Mult(HypreSolver self, Vector b, Vector x)\n" + ""}, + { "HypreSolver_SetErrorMode", _wrap_HypreSolver_SetErrorMode, METH_VARARGS, "SetErrorMode(HypreSolver self, mfem::HypreSolver::ErrorMode err_mode)"}, + { "delete_HypreSolver", _wrap_delete_HypreSolver, METH_O, "delete_HypreSolver(HypreSolver self)"}, + { "HypreSolver_swigregister", HypreSolver_swigregister, METH_O, NULL}, + { "new_HyprePCG", _wrap_new_HyprePCG, METH_VARARGS, "\n" + "HyprePCG(MPI_Comm comm)\n" + "new_HyprePCG(HypreParMatrix _A) -> HyprePCG\n" + ""}, + { "HyprePCG_SetOperator", _wrap_HyprePCG_SetOperator, METH_VARARGS, "SetOperator(HyprePCG self, Operator op)"}, + { "HyprePCG_SetTol", _wrap_HyprePCG_SetTol, METH_VARARGS, "SetTol(HyprePCG self, double tol)"}, + { "HyprePCG_SetMaxIter", _wrap_HyprePCG_SetMaxIter, METH_VARARGS, "SetMaxIter(HyprePCG self, int max_iter)"}, + { "HyprePCG_SetLogging", _wrap_HyprePCG_SetLogging, METH_VARARGS, "SetLogging(HyprePCG self, int logging)"}, + { "HyprePCG_SetPrintLevel", _wrap_HyprePCG_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HyprePCG self, int print_lvl)"}, + { "HyprePCG_SetPreconditioner", _wrap_HyprePCG_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HyprePCG self, HypreSolver precond)"}, + { "HyprePCG_SetResidualConvergenceOptions", _wrap_HyprePCG_SetResidualConvergenceOptions, METH_VARARGS, "SetResidualConvergenceOptions(HyprePCG self, int res_frequency=-1, double rtol=0.0)"}, + { "HyprePCG_SetZeroInintialIterate", _wrap_HyprePCG_SetZeroInintialIterate, METH_O, "SetZeroInintialIterate(HyprePCG self)"}, + { "HyprePCG_GetNumIterations", _wrap_HyprePCG_GetNumIterations, METH_VARARGS, "GetNumIterations(HyprePCG self, int & num_iterations)"}, + { "HyprePCG_SetupFcn", _wrap_HyprePCG_SetupFcn, METH_O, "SetupFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn"}, + { "HyprePCG_SolveFcn", _wrap_HyprePCG_SolveFcn, METH_O, "SolveFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn"}, + { "HyprePCG_Mult", _wrap_HyprePCG_Mult, METH_VARARGS, "\n" + "Mult(HyprePCG self, HypreParVector b, HypreParVector x)\n" + "Mult(HyprePCG self, Vector b, Vector x)\n" + ""}, + { "delete_HyprePCG", _wrap_delete_HyprePCG, METH_O, "delete_HyprePCG(HyprePCG self)"}, + { "HyprePCG_swigregister", HyprePCG_swigregister, METH_O, NULL}, + { "HyprePCG_swiginit", HyprePCG_swiginit, METH_VARARGS, NULL}, + { "new_HypreGMRES", _wrap_new_HypreGMRES, METH_VARARGS, "\n" + "HypreGMRES(MPI_Comm comm)\n" + "new_HypreGMRES(HypreParMatrix _A) -> HypreGMRES\n" + ""}, + { "HypreGMRES_SetOperator", _wrap_HypreGMRES_SetOperator, METH_VARARGS, "SetOperator(HypreGMRES self, Operator op)"}, + { "HypreGMRES_SetTol", _wrap_HypreGMRES_SetTol, METH_VARARGS, "SetTol(HypreGMRES self, double tol)"}, + { "HypreGMRES_SetMaxIter", _wrap_HypreGMRES_SetMaxIter, METH_VARARGS, "SetMaxIter(HypreGMRES self, int max_iter)"}, + { "HypreGMRES_SetKDim", _wrap_HypreGMRES_SetKDim, METH_VARARGS, "SetKDim(HypreGMRES self, int dim)"}, + { "HypreGMRES_SetLogging", _wrap_HypreGMRES_SetLogging, METH_VARARGS, "SetLogging(HypreGMRES self, int logging)"}, + { "HypreGMRES_SetPrintLevel", _wrap_HypreGMRES_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreGMRES self, int print_lvl)"}, + { "HypreGMRES_SetPreconditioner", _wrap_HypreGMRES_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HypreGMRES self, HypreSolver precond)"}, + { "HypreGMRES_SetZeroInintialIterate", _wrap_HypreGMRES_SetZeroInintialIterate, METH_O, "SetZeroInintialIterate(HypreGMRES self)"}, + { "HypreGMRES_SetupFcn", _wrap_HypreGMRES_SetupFcn, METH_O, "SetupFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreGMRES_SolveFcn", _wrap_HypreGMRES_SolveFcn, METH_O, "SolveFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreGMRES_Mult", _wrap_HypreGMRES_Mult, METH_VARARGS, "\n" + "Mult(HypreGMRES self, HypreParVector b, HypreParVector x)\n" + "Mult(HypreGMRES self, Vector b, Vector x)\n" + ""}, + { "delete_HypreGMRES", _wrap_delete_HypreGMRES, METH_O, "delete_HypreGMRES(HypreGMRES self)"}, + { "HypreGMRES_swigregister", HypreGMRES_swigregister, METH_O, NULL}, + { "HypreGMRES_swiginit", HypreGMRES_swiginit, METH_VARARGS, NULL}, + { "HypreIdentity_SetupFcn", _wrap_HypreIdentity_SetupFcn, METH_O, "SetupFcn(HypreIdentity self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreIdentity_SolveFcn", _wrap_HypreIdentity_SolveFcn, METH_O, "SolveFcn(HypreIdentity self) -> HYPRE_PtrToParSolverFcn"}, + { "delete_HypreIdentity", _wrap_delete_HypreIdentity, METH_O, "delete_HypreIdentity(HypreIdentity self)"}, + { "new_HypreIdentity", _wrap_new_HypreIdentity, METH_NOARGS, "new_HypreIdentity() -> HypreIdentity"}, + { "HypreIdentity_swigregister", HypreIdentity_swigregister, METH_O, NULL}, + { "HypreIdentity_swiginit", HypreIdentity_swiginit, METH_VARARGS, NULL}, + { "new_HypreDiagScale", _wrap_new_HypreDiagScale, METH_VARARGS, "\n" + "HypreDiagScale()\n" + "new_HypreDiagScale(HypreParMatrix A) -> HypreDiagScale\n" + ""}, + { "HypreDiagScale_SetOperator", _wrap_HypreDiagScale_SetOperator, METH_VARARGS, "SetOperator(HypreDiagScale self, Operator op)"}, + { "HypreDiagScale_SetupFcn", _wrap_HypreDiagScale_SetupFcn, METH_O, "SetupFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreDiagScale_SolveFcn", _wrap_HypreDiagScale_SolveFcn, METH_O, "SolveFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreDiagScale_GetData", _wrap_HypreDiagScale_GetData, METH_O, "GetData(HypreDiagScale self) -> HypreParMatrix"}, + { "delete_HypreDiagScale", _wrap_delete_HypreDiagScale, METH_O, "delete_HypreDiagScale(HypreDiagScale self)"}, + { "HypreDiagScale_swigregister", HypreDiagScale_swigregister, METH_O, NULL}, + { "HypreDiagScale_swiginit", HypreDiagScale_swiginit, METH_VARARGS, NULL}, + { "new_HypreParaSails", _wrap_new_HypreParaSails, METH_VARARGS, "\n" + "HypreParaSails(MPI_Comm comm)\n" + "new_HypreParaSails(HypreParMatrix A) -> HypreParaSails\n" + ""}, + { "HypreParaSails_SetOperator", _wrap_HypreParaSails_SetOperator, METH_VARARGS, "SetOperator(HypreParaSails self, Operator op)"}, + { "HypreParaSails_SetSymmetry", _wrap_HypreParaSails_SetSymmetry, METH_VARARGS, "SetSymmetry(HypreParaSails self, int sym)"}, + { "HypreParaSails_SetupFcn", _wrap_HypreParaSails_SetupFcn, METH_O, "SetupFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreParaSails_SolveFcn", _wrap_HypreParaSails_SolveFcn, METH_O, "SolveFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, + { "delete_HypreParaSails", _wrap_delete_HypreParaSails, METH_O, "delete_HypreParaSails(HypreParaSails self)"}, + { "HypreParaSails_swigregister", HypreParaSails_swigregister, METH_O, NULL}, + { "HypreParaSails_swiginit", HypreParaSails_swiginit, METH_VARARGS, NULL}, + { "new_HypreEuclid", _wrap_new_HypreEuclid, METH_VARARGS, "\n" + "HypreEuclid(MPI_Comm comm)\n" + "new_HypreEuclid(HypreParMatrix A) -> HypreEuclid\n" + ""}, + { "HypreEuclid_SetOperator", _wrap_HypreEuclid_SetOperator, METH_VARARGS, "SetOperator(HypreEuclid self, Operator op)"}, + { "HypreEuclid_SetupFcn", _wrap_HypreEuclid_SetupFcn, METH_O, "SetupFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreEuclid_SolveFcn", _wrap_HypreEuclid_SolveFcn, METH_O, "SolveFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, + { "delete_HypreEuclid", _wrap_delete_HypreEuclid, METH_O, "delete_HypreEuclid(HypreEuclid self)"}, + { "HypreEuclid_swigregister", HypreEuclid_swigregister, METH_O, NULL}, + { "HypreEuclid_swiginit", HypreEuclid_swiginit, METH_VARARGS, NULL}, + { "new_HypreBoomerAMG", _wrap_new_HypreBoomerAMG, METH_VARARGS, "\n" + "HypreBoomerAMG()\n" + "new_HypreBoomerAMG(HypreParMatrix A) -> HypreBoomerAMG\n" + ""}, + { "HypreBoomerAMG_SetOperator", _wrap_HypreBoomerAMG_SetOperator, METH_VARARGS, "SetOperator(HypreBoomerAMG self, Operator op)"}, + { "HypreBoomerAMG_SetSystemsOptions", _wrap_HypreBoomerAMG_SetSystemsOptions, METH_VARARGS, "SetSystemsOptions(HypreBoomerAMG self, int dim)"}, + { "HypreBoomerAMG_SetElasticityOptions", _wrap_HypreBoomerAMG_SetElasticityOptions, METH_VARARGS, "SetElasticityOptions(HypreBoomerAMG self, mfem::ParFiniteElementSpace * fespace)"}, + { "HypreBoomerAMG_SetPrintLevel", _wrap_HypreBoomerAMG_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreBoomerAMG self, int print_level)"}, + { "HypreBoomerAMG_SetupFcn", _wrap_HypreBoomerAMG_SetupFcn, METH_O, "SetupFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreBoomerAMG_SolveFcn", _wrap_HypreBoomerAMG_SolveFcn, METH_O, "SolveFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn"}, + { "delete_HypreBoomerAMG", _wrap_delete_HypreBoomerAMG, METH_O, "delete_HypreBoomerAMG(HypreBoomerAMG self)"}, + { "HypreBoomerAMG_swigregister", HypreBoomerAMG_swigregister, METH_O, NULL}, + { "HypreBoomerAMG_swiginit", HypreBoomerAMG_swiginit, METH_VARARGS, NULL}, + { "new_HypreAMS", _wrap_new_HypreAMS, METH_VARARGS, "\n" + "HypreAMS(mfem::ParFiniteElementSpace * edge_fespace)\n" + "new_HypreAMS(HypreParMatrix A, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS\n" + ""}, + { "HypreAMS_SetOperator", _wrap_HypreAMS_SetOperator, METH_VARARGS, "SetOperator(HypreAMS self, Operator op)"}, + { "HypreAMS_SetPrintLevel", _wrap_HypreAMS_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreAMS self, int print_lvl)"}, + { "HypreAMS_SetSingularProblem", _wrap_HypreAMS_SetSingularProblem, METH_O, "SetSingularProblem(HypreAMS self)"}, + { "HypreAMS_SetupFcn", _wrap_HypreAMS_SetupFcn, METH_O, "SetupFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreAMS_SolveFcn", _wrap_HypreAMS_SolveFcn, METH_O, "SolveFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn"}, + { "delete_HypreAMS", _wrap_delete_HypreAMS, METH_O, "delete_HypreAMS(HypreAMS self)"}, + { "HypreAMS_swigregister", HypreAMS_swigregister, METH_O, NULL}, + { "HypreAMS_swiginit", HypreAMS_swiginit, METH_VARARGS, NULL}, + { "new_HypreADS", _wrap_new_HypreADS, METH_VARARGS, "\n" + "HypreADS(mfem::ParFiniteElementSpace * face_fespace)\n" + "new_HypreADS(HypreParMatrix A, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS\n" + ""}, + { "HypreADS_SetOperator", _wrap_HypreADS_SetOperator, METH_VARARGS, "SetOperator(HypreADS self, Operator op)"}, + { "HypreADS_SetPrintLevel", _wrap_HypreADS_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreADS self, int print_lvl)"}, + { "HypreADS_SetupFcn", _wrap_HypreADS_SetupFcn, METH_O, "SetupFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, + { "HypreADS_SolveFcn", _wrap_HypreADS_SolveFcn, METH_O, "SolveFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, + { "delete_HypreADS", _wrap_delete_HypreADS, METH_O, "delete_HypreADS(HypreADS self)"}, + { "HypreADS_swigregister", HypreADS_swigregister, METH_O, NULL}, + { "HypreADS_swiginit", HypreADS_swiginit, METH_VARARGS, NULL}, + { "new_HypreLOBPCG", _wrap_new_HypreLOBPCG, METH_O, "new_HypreLOBPCG(MPI_Comm comm) -> HypreLOBPCG"}, + { "delete_HypreLOBPCG", _wrap_delete_HypreLOBPCG, METH_O, "delete_HypreLOBPCG(HypreLOBPCG self)"}, + { "HypreLOBPCG_SetTol", _wrap_HypreLOBPCG_SetTol, METH_VARARGS, "SetTol(HypreLOBPCG self, double tol)"}, + { "HypreLOBPCG_SetRelTol", _wrap_HypreLOBPCG_SetRelTol, METH_VARARGS, "SetRelTol(HypreLOBPCG self, double rel_tol)"}, + { "HypreLOBPCG_SetMaxIter", _wrap_HypreLOBPCG_SetMaxIter, METH_VARARGS, "SetMaxIter(HypreLOBPCG self, int max_iter)"}, + { "HypreLOBPCG_SetPrintLevel", _wrap_HypreLOBPCG_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreLOBPCG self, int logging)"}, + { "HypreLOBPCG_SetNumModes", _wrap_HypreLOBPCG_SetNumModes, METH_VARARGS, "SetNumModes(HypreLOBPCG self, int num_eigs)"}, + { "HypreLOBPCG_SetPrecondUsageMode", _wrap_HypreLOBPCG_SetPrecondUsageMode, METH_VARARGS, "SetPrecondUsageMode(HypreLOBPCG self, int pcg_mode)"}, + { "HypreLOBPCG_SetRandomSeed", _wrap_HypreLOBPCG_SetRandomSeed, METH_VARARGS, "SetRandomSeed(HypreLOBPCG self, int s)"}, + { "HypreLOBPCG_SetInitialVectors", _wrap_HypreLOBPCG_SetInitialVectors, METH_VARARGS, "SetInitialVectors(HypreLOBPCG self, int num_vecs, mfem::HypreParVector ** vecs)"}, + { "HypreLOBPCG_SetPreconditioner", _wrap_HypreLOBPCG_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HypreLOBPCG self, Solver precond)"}, + { "HypreLOBPCG_SetOperator", _wrap_HypreLOBPCG_SetOperator, METH_VARARGS, "SetOperator(HypreLOBPCG self, Operator A)"}, + { "HypreLOBPCG_SetMassMatrix", _wrap_HypreLOBPCG_SetMassMatrix, METH_VARARGS, "SetMassMatrix(HypreLOBPCG self, Operator M)"}, + { "HypreLOBPCG_SetSubSpaceProjector", _wrap_HypreLOBPCG_SetSubSpaceProjector, METH_VARARGS, "SetSubSpaceProjector(HypreLOBPCG self, Operator proj)"}, + { "HypreLOBPCG_Solve", _wrap_HypreLOBPCG_Solve, METH_O, "Solve(HypreLOBPCG self)"}, + { "HypreLOBPCG_GetEigenvalues", _wrap_HypreLOBPCG_GetEigenvalues, METH_VARARGS, "GetEigenvalues(HypreLOBPCG self, doubleArray eigenvalues)"}, + { "HypreLOBPCG_GetEigenvector", _wrap_HypreLOBPCG_GetEigenvector, METH_VARARGS, "GetEigenvector(HypreLOBPCG self, unsigned int i) -> HypreParVector"}, + { "HypreLOBPCG_StealEigenvectors", _wrap_HypreLOBPCG_StealEigenvectors, METH_O, "StealEigenvectors(HypreLOBPCG self) -> mfem::HypreParVector **"}, + { "HypreLOBPCG_swigregister", HypreLOBPCG_swigregister, METH_O, NULL}, + { "HypreLOBPCG_swiginit", HypreLOBPCG_swiginit, METH_VARARGS, NULL}, + { "new_HypreAME", _wrap_new_HypreAME, METH_O, "new_HypreAME(MPI_Comm comm) -> HypreAME"}, + { "delete_HypreAME", _wrap_delete_HypreAME, METH_O, "delete_HypreAME(HypreAME self)"}, + { "HypreAME_SetTol", _wrap_HypreAME_SetTol, METH_VARARGS, "SetTol(HypreAME self, double tol)"}, + { "HypreAME_SetRelTol", _wrap_HypreAME_SetRelTol, METH_VARARGS, "SetRelTol(HypreAME self, double rel_tol)"}, + { "HypreAME_SetMaxIter", _wrap_HypreAME_SetMaxIter, METH_VARARGS, "SetMaxIter(HypreAME self, int max_iter)"}, + { "HypreAME_SetPrintLevel", _wrap_HypreAME_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreAME self, int logging)"}, + { "HypreAME_SetNumModes", _wrap_HypreAME_SetNumModes, METH_VARARGS, "SetNumModes(HypreAME self, int num_eigs)"}, + { "HypreAME_SetPreconditioner", _wrap_HypreAME_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HypreAME self, HypreSolver precond)"}, + { "HypreAME_SetOperator", _wrap_HypreAME_SetOperator, METH_VARARGS, "SetOperator(HypreAME self, HypreParMatrix A)"}, + { "HypreAME_SetMassMatrix", _wrap_HypreAME_SetMassMatrix, METH_VARARGS, "SetMassMatrix(HypreAME self, HypreParMatrix M)"}, + { "HypreAME_Solve", _wrap_HypreAME_Solve, METH_O, "Solve(HypreAME self)"}, + { "HypreAME_GetEigenvalues", _wrap_HypreAME_GetEigenvalues, METH_VARARGS, "GetEigenvalues(HypreAME self, doubleArray eigenvalues)"}, + { "HypreAME_GetEigenvector", _wrap_HypreAME_GetEigenvector, METH_VARARGS, "GetEigenvector(HypreAME self, unsigned int i) -> HypreParVector"}, + { "HypreAME_StealEigenvectors", _wrap_HypreAME_StealEigenvectors, METH_O, "StealEigenvectors(HypreAME self) -> mfem::HypreParVector **"}, + { "HypreAME_swigregister", HypreAME_swigregister, METH_O, NULL}, + { "HypreAME_swiginit", HypreAME_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -17199,12 +18534,12 @@ static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(new static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } @@ -17226,6 +18561,9 @@ static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPAR static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -17241,9 +18579,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -17351,15 +18695,18 @@ static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__P static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ParFiniteElementSpace = {"_p_mfem__ParFiniteElementSpace", "mfem::ParFiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; @@ -17410,6 +18757,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__Table, @@ -17452,17 +18802,20 @@ static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt_ static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParFiniteElementSpace[] = { {&_swigt__p_mfem__ParFiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; @@ -17512,6 +18865,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__Table, @@ -18250,18 +19606,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 @@ -18282,6 +19638,9 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "HypreSmoother_Chebyshev",SWIG_From_int(static_cast< int >(mfem::HypreSmoother::Chebyshev))); SWIG_Python_SetConstant(d, "HypreSmoother_Taubin",SWIG_From_int(static_cast< int >(mfem::HypreSmoother::Taubin))); SWIG_Python_SetConstant(d, "HypreSmoother_FIR",SWIG_From_int(static_cast< int >(mfem::HypreSmoother::FIR))); + SWIG_Python_SetConstant(d, "HypreSolver_IGNORE_HYPRE_ERRORS",SWIG_From_int(static_cast< int >(mfem::HypreSolver::IGNORE_HYPRE_ERRORS))); + SWIG_Python_SetConstant(d, "HypreSolver_WARN_HYPRE_ERRORS",SWIG_From_int(static_cast< int >(mfem::HypreSolver::WARN_HYPRE_ERRORS))); + SWIG_Python_SetConstant(d, "HypreSolver_ABORT_HYPRE_ERRORS",SWIG_From_int(static_cast< int >(mfem::HypreSolver::ABORT_HYPRE_ERRORS))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/intrules.py b/mfem/_par/intrules.py index e2243139..6148b78e 100644 --- a/mfem/_par/intrules.py +++ b/mfem/_par/intrules.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _intrules.SWIG_PyInstanceMethod_New +_swig_new_static_method = _intrules.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -71,7 +74,9 @@ class IntegrationPointArray(object): def __init__(self, *args): r""" - __init__(IntegrationPointArray self, int asize=0) -> IntegrationPointArray + __init__(IntegrationPointArray self) -> IntegrationPointArray + __init__(IntegrationPointArray self, mfem::MemoryType mt) -> IntegrationPointArray + __init__(IntegrationPointArray self, int asize) -> IntegrationPointArray __init__(IntegrationPointArray self, IntegrationPoint _data, int asize) -> IntegrationPointArray __init__(IntegrationPointArray self, IntegrationPointArray src) -> IntegrationPointArray """ @@ -90,6 +95,7 @@ def GetData(self, *args): GetData(IntegrationPointArray self) -> IntegrationPoint """ return _intrules.IntegrationPointArray_GetData(self, *args) + GetData = _swig_new_instance_method(_intrules.IntegrationPointArray_GetData) def GetMemory(self, *args): r""" @@ -97,30 +103,37 @@ def GetMemory(self, *args): GetMemory(IntegrationPointArray self) -> mfem::Memory< mfem::IntegrationPoint > const & """ return _intrules.IntegrationPointArray_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_intrules.IntegrationPointArray_GetMemory) def UseDevice(self): r"""UseDevice(IntegrationPointArray self) -> bool""" return _intrules.IntegrationPointArray_UseDevice(self) + UseDevice = _swig_new_instance_method(_intrules.IntegrationPointArray_UseDevice) def OwnsData(self): r"""OwnsData(IntegrationPointArray self) -> bool""" return _intrules.IntegrationPointArray_OwnsData(self) + OwnsData = _swig_new_instance_method(_intrules.IntegrationPointArray_OwnsData) def StealData(self, p): r"""StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)""" return _intrules.IntegrationPointArray_StealData(self, p) + StealData = _swig_new_instance_method(_intrules.IntegrationPointArray_StealData) def LoseData(self): r"""LoseData(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_LoseData(self) + LoseData = _swig_new_instance_method(_intrules.IntegrationPointArray_LoseData) def MakeDataOwner(self): r"""MakeDataOwner(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_intrules.IntegrationPointArray_MakeDataOwner) def Size(self): r"""Size(IntegrationPointArray self) -> int""" return _intrules.IntegrationPointArray_Size(self) + Size = _swig_new_instance_method(_intrules.IntegrationPointArray_Size) def SetSize(self, *args): r""" @@ -129,14 +142,17 @@ def SetSize(self, *args): SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt) """ return _intrules.IntegrationPointArray_SetSize(self, *args) + SetSize = _swig_new_instance_method(_intrules.IntegrationPointArray_SetSize) def Capacity(self): r"""Capacity(IntegrationPointArray self) -> int""" return _intrules.IntegrationPointArray_Capacity(self) + Capacity = _swig_new_instance_method(_intrules.IntegrationPointArray_Capacity) def Reserve(self, capacity): r"""Reserve(IntegrationPointArray self, int capacity)""" return _intrules.IntegrationPointArray_Reserve(self, capacity) + Reserve = _swig_new_instance_method(_intrules.IntegrationPointArray_Reserve) def Append(self, *args): r""" @@ -145,10 +161,12 @@ def Append(self, *args): Append(IntegrationPointArray self, IntegrationPointArray els) -> int """ return _intrules.IntegrationPointArray_Append(self, *args) + Append = _swig_new_instance_method(_intrules.IntegrationPointArray_Append) def Prepend(self, el): r"""Prepend(IntegrationPointArray self, IntegrationPoint el) -> int""" return _intrules.IntegrationPointArray_Prepend(self, el) + Prepend = _swig_new_instance_method(_intrules.IntegrationPointArray_Prepend) def Last(self, *args): r""" @@ -156,18 +174,22 @@ def Last(self, *args): Last(IntegrationPointArray self) -> IntegrationPoint """ return _intrules.IntegrationPointArray_Last(self, *args) + Last = _swig_new_instance_method(_intrules.IntegrationPointArray_Last) def DeleteLast(self): r"""DeleteLast(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_DeleteLast(self) + DeleteLast = _swig_new_instance_method(_intrules.IntegrationPointArray_DeleteLast) def DeleteAll(self): r"""DeleteAll(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_DeleteAll(self) + DeleteAll = _swig_new_instance_method(_intrules.IntegrationPointArray_DeleteAll) def Copy(self, copy): r"""Copy(IntegrationPointArray self, IntegrationPointArray copy)""" return _intrules.IntegrationPointArray_Copy(self, copy) + Copy = _swig_new_instance_method(_intrules.IntegrationPointArray_Copy) def MakeRef(self, *args): r""" @@ -175,54 +197,73 @@ def MakeRef(self, *args): MakeRef(IntegrationPointArray self, IntegrationPointArray master) """ return _intrules.IntegrationPointArray_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_intrules.IntegrationPointArray_MakeRef) def GetSubArray(self, offset, sa_size, sa): r"""GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)""" return _intrules.IntegrationPointArray_GetSubArray(self, offset, sa_size, sa) + GetSubArray = _swig_new_instance_method(_intrules.IntegrationPointArray_GetSubArray) - def begin(self): - r"""begin(IntegrationPointArray self) -> IntegrationPoint""" - return _intrules.IntegrationPointArray_begin(self) + def begin(self, *args): + r""" + begin(IntegrationPointArray self) -> IntegrationPoint + begin(IntegrationPointArray self) -> IntegrationPoint + """ + return _intrules.IntegrationPointArray_begin(self, *args) + begin = _swig_new_instance_method(_intrules.IntegrationPointArray_begin) - def end(self): - r"""end(IntegrationPointArray self) -> IntegrationPoint""" - return _intrules.IntegrationPointArray_end(self) + def end(self, *args): + r""" + end(IntegrationPointArray self) -> IntegrationPoint + end(IntegrationPointArray self) -> IntegrationPoint + """ + return _intrules.IntegrationPointArray_end(self, *args) + end = _swig_new_instance_method(_intrules.IntegrationPointArray_end) def MemoryUsage(self): r"""MemoryUsage(IntegrationPointArray self) -> long""" return _intrules.IntegrationPointArray_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_intrules.IntegrationPointArray_MemoryUsage) def Read(self, on_dev=True): r"""Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint""" return _intrules.IntegrationPointArray_Read(self, on_dev) + Read = _swig_new_instance_method(_intrules.IntegrationPointArray_Read) def HostRead(self): r"""HostRead(IntegrationPointArray self) -> IntegrationPoint""" return _intrules.IntegrationPointArray_HostRead(self) + HostRead = _swig_new_instance_method(_intrules.IntegrationPointArray_HostRead) def Write(self, on_dev=True): r"""Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint""" return _intrules.IntegrationPointArray_Write(self, on_dev) + Write = _swig_new_instance_method(_intrules.IntegrationPointArray_Write) def HostWrite(self): r"""HostWrite(IntegrationPointArray self) -> IntegrationPoint""" return _intrules.IntegrationPointArray_HostWrite(self) + HostWrite = _swig_new_instance_method(_intrules.IntegrationPointArray_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint""" return _intrules.IntegrationPointArray_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_intrules.IntegrationPointArray_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(IntegrationPointArray self) -> IntegrationPoint""" return _intrules.IntegrationPointArray_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_intrules.IntegrationPointArray_HostReadWrite) def __setitem__(self, i, v): r"""__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)""" return _intrules.IntegrationPointArray___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_intrules.IntegrationPointArray___setitem__) def __getitem__(self, i): r"""__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint""" return _intrules.IntegrationPointArray___getitem__(self, i) + __getitem__ = _swig_new_instance_method(_intrules.IntegrationPointArray___getitem__) def Assign(self, *args): r""" @@ -230,6 +271,7 @@ def Assign(self, *args): Assign(IntegrationPointArray self, IntegrationPoint a) """ return _intrules.IntegrationPointArray_Assign(self, *args) + Assign = _swig_new_instance_method(_intrules.IntegrationPointArray_Assign) def ToList(self): return [self[i] for i in range(self.Size())] @@ -248,14 +290,17 @@ class IntegrationPoint(object): y = property(_intrules.IntegrationPoint_y_get, _intrules.IntegrationPoint_y_set, doc=r"""y : double""") z = property(_intrules.IntegrationPoint_z_get, _intrules.IntegrationPoint_z_set, doc=r"""z : double""") weight = property(_intrules.IntegrationPoint_weight_get, _intrules.IntegrationPoint_weight_set, doc=r"""weight : double""") + index = property(_intrules.IntegrationPoint_index_get, _intrules.IntegrationPoint_index_set, doc=r"""index : int""") - def Init(self): - r"""Init(IntegrationPoint self)""" - return _intrules.IntegrationPoint_Init(self) + def Init(self, i): + r"""Init(IntegrationPoint self, int const i)""" + return _intrules.IntegrationPoint_Init(self, i) + Init = _swig_new_instance_method(_intrules.IntegrationPoint_Init) def Get(self, p, dim): r"""Get(IntegrationPoint self, double * p, int const dim)""" return _intrules.IntegrationPoint_Get(self, p, dim) + Get = _swig_new_instance_method(_intrules.IntegrationPoint_Get) def Set(self, *args): r""" @@ -263,10 +308,12 @@ def Set(self, *args): Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w) """ return _intrules.IntegrationPoint_Set(self, *args) + Set = _swig_new_instance_method(_intrules.IntegrationPoint_Set) def Set3w(self, p): r"""Set3w(IntegrationPoint self, double const * p)""" return _intrules.IntegrationPoint_Set3w(self, p) + Set3w = _swig_new_instance_method(_intrules.IntegrationPoint_Set3w) def Set3(self, *args): r""" @@ -274,6 +321,7 @@ def Set3(self, *args): Set3(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set3(self, *args) + Set3 = _swig_new_instance_method(_intrules.IntegrationPoint_Set3) def Set2w(self, *args): r""" @@ -281,6 +329,7 @@ def Set2w(self, *args): Set2w(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set2w(self, *args) + Set2w = _swig_new_instance_method(_intrules.IntegrationPoint_Set2w) def Set2(self, *args): r""" @@ -288,6 +337,7 @@ def Set2(self, *args): Set2(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set2(self, *args) + Set2 = _swig_new_instance_method(_intrules.IntegrationPoint_Set2) def Set1w(self, *args): r""" @@ -295,6 +345,7 @@ def Set1w(self, *args): Set1w(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set1w(self, *args) + Set1w = _swig_new_instance_method(_intrules.IntegrationPoint_Set1w) def __init__(self): r"""__init__(IntegrationPoint self) -> IntegrationPoint""" @@ -322,14 +373,17 @@ def __init__(self, *args): def GetOrder(self): r"""GetOrder(IntegrationRule self) -> int""" return _intrules.IntegrationRule_GetOrder(self) + GetOrder = _swig_new_instance_method(_intrules.IntegrationRule_GetOrder) def SetOrder(self, order): r"""SetOrder(IntegrationRule self, int const order)""" return _intrules.IntegrationRule_SetOrder(self, order) + SetOrder = _swig_new_instance_method(_intrules.IntegrationRule_SetOrder) def GetNPoints(self): r"""GetNPoints(IntegrationRule self) -> int""" return _intrules.IntegrationRule_GetNPoints(self) + GetNPoints = _swig_new_instance_method(_intrules.IntegrationRule_GetNPoints) def IntPoint(self, *args): r""" @@ -337,10 +391,12 @@ def IntPoint(self, *args): IntPoint(IntegrationRule self, int i) -> IntegrationPoint """ return _intrules.IntegrationRule_IntPoint(self, *args) + IntPoint = _swig_new_instance_method(_intrules.IntegrationRule_IntPoint) def GetWeights(self): r"""GetWeights(IntegrationRule self) -> doubleArray""" return _intrules.IntegrationRule_GetWeights(self) + GetWeights = _swig_new_instance_method(_intrules.IntegrationRule_GetWeights) __swig_destroy__ = _intrules.delete_IntegrationRule # Register IntegrationRule in _intrules: @@ -355,26 +411,32 @@ class QuadratureFunctions1D(object): def GaussLegendre(self, np, ir): r"""GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_GaussLegendre(self, np, ir) + GaussLegendre = _swig_new_instance_method(_intrules.QuadratureFunctions1D_GaussLegendre) def GaussLobatto(self, np, ir): r"""GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_GaussLobatto(self, np, ir) + GaussLobatto = _swig_new_instance_method(_intrules.QuadratureFunctions1D_GaussLobatto) def OpenUniform(self, np, ir): r"""OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_OpenUniform(self, np, ir) + OpenUniform = _swig_new_instance_method(_intrules.QuadratureFunctions1D_OpenUniform) def ClosedUniform(self, np, ir): r"""ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_ClosedUniform(self, np, ir) + ClosedUniform = _swig_new_instance_method(_intrules.QuadratureFunctions1D_ClosedUniform) def OpenHalfUniform(self, np, ir): r"""OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_OpenHalfUniform(self, np, ir) + OpenHalfUniform = _swig_new_instance_method(_intrules.QuadratureFunctions1D_OpenHalfUniform) def GivePolyPoints(self, np, pts, type): r"""GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)""" return _intrules.QuadratureFunctions1D_GivePolyPoints(self, np, pts, type) + GivePolyPoints = _swig_new_instance_method(_intrules.QuadratureFunctions1D_GivePolyPoints) def __init__(self): r"""__init__(QuadratureFunctions1D self) -> QuadratureFunctions1D""" @@ -406,11 +468,13 @@ class Quadrature1D(object): def CheckClosed(type): r"""CheckClosed(int type) -> int""" return _intrules.Quadrature1D_CheckClosed(type) + CheckClosed = _swig_new_static_method(_intrules.Quadrature1D_CheckClosed) @staticmethod def CheckOpen(type): r"""CheckOpen(int type) -> int""" return _intrules.Quadrature1D_CheckOpen(type) + CheckOpen = _swig_new_static_method(_intrules.Quadrature1D_CheckOpen) def __init__(self): r"""__init__(Quadrature1D self) -> Quadrature1D""" @@ -423,10 +487,12 @@ def __init__(self): def Quadrature1D_CheckClosed(type): r"""Quadrature1D_CheckClosed(int type) -> int""" return _intrules.Quadrature1D_CheckClosed(type) +Quadrature1D_CheckClosed = _intrules.Quadrature1D_CheckClosed def Quadrature1D_CheckOpen(type): r"""Quadrature1D_CheckOpen(int type) -> int""" return _intrules.Quadrature1D_CheckOpen(type) +Quadrature1D_CheckOpen = _intrules.Quadrature1D_CheckOpen class IntegrationRules(object): r"""Proxy of C++ mfem::IntegrationRules class.""" @@ -441,14 +507,17 @@ def __init__(self, *args): def Get(self, GeomType, Order): r"""Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule""" return _intrules.IntegrationRules_Get(self, GeomType, Order) + Get = _swig_new_instance_method(_intrules.IntegrationRules_Get) def Set(self, GeomType, Order, IntRule): r"""Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)""" return _intrules.IntegrationRules_Set(self, GeomType, Order, IntRule) + Set = _swig_new_instance_method(_intrules.IntegrationRules_Set) def SetOwnRules(self, o): r"""SetOwnRules(IntegrationRules self, int o)""" return _intrules.IntegrationRules_SetOwnRules(self, o) + SetOwnRules = _swig_new_instance_method(_intrules.IntegrationRules_SetOwnRules) __swig_destroy__ = _intrules.delete_IntegrationRules # Register IntegrationRules in _intrules: diff --git a/mfem/_par/intrules_wrap.cxx b/mfem/_par/intrules_wrap.cxx index 657addca..751a9430 100644 --- a/mfem/_par/intrules_wrap.cxx +++ b/mfem/_par/intrules_wrap.cxx @@ -2977,9 +2977,37 @@ SWIGINTERN void mfem_Array_Sl_mfem_IntegrationPoint_Sg__FakeToList(mfem::Array< #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - int arg1 ; + mfem::Array< mfem::IntegrationPoint > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; mfem::Array< mfem::IntegrationPoint > *result = 0 ; @@ -2987,9 +3015,9 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSE if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationPointArray" "', argument " "1"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationPointArray" "', argument " "1"" of type '" "mfem::MemoryType""'"); } - arg1 = static_cast< int >(val1); + arg1 = static_cast< mfem::MemoryType >(val1); { try { result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(arg1); @@ -3013,14 +3041,22 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; mfem::Array< mfem::IntegrationPoint > *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationPointArray" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); { try { - result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(); + result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3041,7 +3077,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; int arg2 ; @@ -3085,7 +3121,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_2(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = 0 ; void *argp1 = 0 ; @@ -3133,14 +3169,24 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntegrationPointArray", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_IntegrationPointArray__SWIG_1(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_IntegrationPointArray__SWIG_3(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_4(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_IntegrationPointArray__SWIG_2(self, argc, argv); } } if (argc == 1) { @@ -3150,7 +3196,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_IntegrationPointArray__SWIG_0(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -3164,7 +3210,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_IntegrationPointArray__SWIG_2(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_3(self, argc, argv); } } } @@ -3172,8 +3218,9 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntegrationPointArray'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::Array(int)\n" " mfem::Array< mfem::IntegrationPoint >::Array()\n" + " mfem::Array< mfem::IntegrationPoint >::Array(mfem::MemoryType)\n" + " mfem::Array< mfem::IntegrationPoint >::Array(int)\n" " mfem::Array< mfem::IntegrationPoint >::Array(mfem::IntegrationPoint *,int)\n" " mfem::Array< mfem::IntegrationPoint >::Array(mfem::Array< mfem::IntegrationPoint > const &)\n"); return 0; @@ -4711,16 +4758,14 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Assign__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::IntegrationPoint *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_begin" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); @@ -4749,16 +4794,14 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::IntegrationPoint *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_end" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); @@ -4787,6 +4830,150 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_end(PyObject *SWIGUNUSEDPARM(se } +SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::IntegrationPoint *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_begin" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); + { + try { + result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->begin(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_begin", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_begin__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_begin__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_begin'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< mfem::IntegrationPoint >::begin()\n" + " mfem::Array< mfem::IntegrationPoint >::begin() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPointArray_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::IntegrationPoint *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_end" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); + { + try { + result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->end(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPointArray_end(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_end", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_end__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_end__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_end'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< mfem::IntegrationPoint >::end()\n" + " mfem::Array< mfem::IntegrationPoint >::end() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_IntegrationPointArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5757,23 +5944,82 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_weight_get(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_index_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_index_set" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); + } + arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPoint_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->index = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPoint_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + int result; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_index_get" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); + } + arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); + result = (int) ((arg1)->index); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Init" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPoint_Init" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); { try { - (arg1)->Init(); + (arg1)->Init(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8296,8 +8542,11 @@ SWIGINTERN PyObject *Swig_var_RefinedIntRules_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_IntegrationPointArray", _wrap_new_IntegrationPointArray, METH_VARARGS, "\n" - "IntegrationPointArray(int asize=0)\n" + "IntegrationPointArray()\n" + "IntegrationPointArray(mfem::MemoryType mt)\n" + "IntegrationPointArray(int asize)\n" "IntegrationPointArray(IntegrationPoint _data, int asize)\n" "new_IntegrationPointArray(IntegrationPointArray src) -> IntegrationPointArray\n" ""}, @@ -8341,8 +8590,14 @@ static PyMethodDef SwigMethods[] = { "IntegrationPointArray_MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" ""}, { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "IntegrationPointArray_GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, - { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_O, "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_end", _wrap_IntegrationPointArray_end, METH_O, "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" + "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" + "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_end", _wrap_IntegrationPointArray_end, METH_VARARGS, "\n" + "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint\n" + "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "IntegrationPointArray_MemoryUsage(IntegrationPointArray self) -> long"}, { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "IntegrationPointArray_Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "IntegrationPointArray_HostRead(IntegrationPointArray self) -> IntegrationPoint"}, @@ -8367,7 +8622,9 @@ static PyMethodDef SwigMethods[] = { { "IntegrationPoint_z_get", _wrap_IntegrationPoint_z_get, METH_O, "IntegrationPoint_z_get(IntegrationPoint self) -> double"}, { "IntegrationPoint_weight_set", _wrap_IntegrationPoint_weight_set, METH_VARARGS, "IntegrationPoint_weight_set(IntegrationPoint self, double weight)"}, { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, - { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_O, "IntegrationPoint_Init(IntegrationPoint self)"}, + { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, + { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, + { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "IntegrationPoint_Init(IntegrationPoint self, int const i)"}, { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "IntegrationPoint_Get(IntegrationPoint self, double * p, int const dim)"}, { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" "IntegrationPoint_Set(IntegrationPoint self, double const * p, int const dim)\n" @@ -8438,6 +8695,156 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_IntegrationPointArray", _wrap_new_IntegrationPointArray, METH_VARARGS, "\n" + "IntegrationPointArray()\n" + "IntegrationPointArray(mfem::MemoryType mt)\n" + "IntegrationPointArray(int asize)\n" + "IntegrationPointArray(IntegrationPoint _data, int asize)\n" + "new_IntegrationPointArray(IntegrationPointArray src) -> IntegrationPointArray\n" + ""}, + { "delete_IntegrationPointArray", _wrap_delete_IntegrationPointArray, METH_O, "delete_IntegrationPointArray(IntegrationPointArray self)"}, + { "IntegrationPointArray_GetData", _wrap_IntegrationPointArray_GetData, METH_VARARGS, "\n" + "GetData(IntegrationPointArray self) -> IntegrationPoint\n" + "GetData(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_GetMemory", _wrap_IntegrationPointArray_GetMemory, METH_VARARGS, "\n" + "GetMemory(IntegrationPointArray self) -> mfem::Memory< mfem::IntegrationPoint >\n" + "GetMemory(IntegrationPointArray self) -> mfem::Memory< mfem::IntegrationPoint > const &\n" + ""}, + { "IntegrationPointArray_UseDevice", _wrap_IntegrationPointArray_UseDevice, METH_O, "UseDevice(IntegrationPointArray self) -> bool"}, + { "IntegrationPointArray_OwnsData", _wrap_IntegrationPointArray_OwnsData, METH_O, "OwnsData(IntegrationPointArray self) -> bool"}, + { "IntegrationPointArray_StealData", _wrap_IntegrationPointArray_StealData, METH_VARARGS, "StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, + { "IntegrationPointArray_LoseData", _wrap_IntegrationPointArray_LoseData, METH_O, "LoseData(IntegrationPointArray self)"}, + { "IntegrationPointArray_MakeDataOwner", _wrap_IntegrationPointArray_MakeDataOwner, METH_O, "MakeDataOwner(IntegrationPointArray self)"}, + { "IntegrationPointArray_Size", _wrap_IntegrationPointArray_Size, METH_O, "Size(IntegrationPointArray self) -> int"}, + { "IntegrationPointArray_SetSize", _wrap_IntegrationPointArray_SetSize, METH_VARARGS, "\n" + "SetSize(IntegrationPointArray self, int nsize)\n" + "SetSize(IntegrationPointArray self, int nsize, IntegrationPoint initval)\n" + "SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt)\n" + ""}, + { "IntegrationPointArray_Capacity", _wrap_IntegrationPointArray_Capacity, METH_O, "Capacity(IntegrationPointArray self) -> int"}, + { "IntegrationPointArray_Reserve", _wrap_IntegrationPointArray_Reserve, METH_VARARGS, "Reserve(IntegrationPointArray self, int capacity)"}, + { "IntegrationPointArray_Append", _wrap_IntegrationPointArray_Append, METH_VARARGS, "\n" + "Append(IntegrationPointArray self, IntegrationPoint el) -> int\n" + "Append(IntegrationPointArray self, IntegrationPoint els, int nels) -> int\n" + "Append(IntegrationPointArray self, IntegrationPointArray els) -> int\n" + ""}, + { "IntegrationPointArray_Prepend", _wrap_IntegrationPointArray_Prepend, METH_VARARGS, "Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, + { "IntegrationPointArray_Last", _wrap_IntegrationPointArray_Last, METH_VARARGS, "\n" + "Last(IntegrationPointArray self) -> IntegrationPoint\n" + "Last(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_DeleteLast", _wrap_IntegrationPointArray_DeleteLast, METH_O, "DeleteLast(IntegrationPointArray self)"}, + { "IntegrationPointArray_DeleteAll", _wrap_IntegrationPointArray_DeleteAll, METH_O, "DeleteAll(IntegrationPointArray self)"}, + { "IntegrationPointArray_Copy", _wrap_IntegrationPointArray_Copy, METH_VARARGS, "Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, + { "IntegrationPointArray_MakeRef", _wrap_IntegrationPointArray_MakeRef, METH_VARARGS, "\n" + "MakeRef(IntegrationPointArray self, IntegrationPoint arg2, int arg3)\n" + "MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" + ""}, + { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, + { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" + "begin(IntegrationPointArray self) -> IntegrationPoint\n" + "begin(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_end", _wrap_IntegrationPointArray_end, METH_VARARGS, "\n" + "end(IntegrationPointArray self) -> IntegrationPoint\n" + "end(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "MemoryUsage(IntegrationPointArray self) -> long"}, + { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "HostRead(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray_Write", _wrap_IntegrationPointArray_Write, METH_VARARGS, "Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_HostWrite", _wrap_IntegrationPointArray_HostWrite, METH_O, "HostWrite(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray_ReadWrite", _wrap_IntegrationPointArray_ReadWrite, METH_VARARGS, "ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_HostReadWrite", _wrap_IntegrationPointArray_HostReadWrite, METH_O, "HostReadWrite(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray___setitem__", _wrap_IntegrationPointArray___setitem__, METH_VARARGS, "__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, + { "IntegrationPointArray___getitem__", _wrap_IntegrationPointArray___getitem__, METH_VARARGS, "__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, + { "IntegrationPointArray_Assign", _wrap_IntegrationPointArray_Assign, METH_VARARGS, "\n" + "Assign(IntegrationPointArray self, IntegrationPoint arg2)\n" + "Assign(IntegrationPointArray self, IntegrationPoint a)\n" + ""}, + { "IntegrationPointArray_FakeToList", _wrap_IntegrationPointArray_FakeToList, METH_O, "FakeToList(IntegrationPointArray self)"}, + { "IntegrationPointArray_swigregister", IntegrationPointArray_swigregister, METH_O, NULL}, + { "IntegrationPointArray_swiginit", IntegrationPointArray_swiginit, METH_VARARGS, NULL}, + { "IntegrationPoint_x_set", _wrap_IntegrationPoint_x_set, METH_VARARGS, "IntegrationPoint_x_set(IntegrationPoint self, double x)"}, + { "IntegrationPoint_x_get", _wrap_IntegrationPoint_x_get, METH_O, "IntegrationPoint_x_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_y_set", _wrap_IntegrationPoint_y_set, METH_VARARGS, "IntegrationPoint_y_set(IntegrationPoint self, double y)"}, + { "IntegrationPoint_y_get", _wrap_IntegrationPoint_y_get, METH_O, "IntegrationPoint_y_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_z_set", _wrap_IntegrationPoint_z_set, METH_VARARGS, "IntegrationPoint_z_set(IntegrationPoint self, double z)"}, + { "IntegrationPoint_z_get", _wrap_IntegrationPoint_z_get, METH_O, "IntegrationPoint_z_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_weight_set", _wrap_IntegrationPoint_weight_set, METH_VARARGS, "IntegrationPoint_weight_set(IntegrationPoint self, double weight)"}, + { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, + { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, + { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "Init(IntegrationPoint self, int const i)"}, + { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "Get(IntegrationPoint self, double * p, int const dim)"}, + { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" + "Set(IntegrationPoint self, double const * p, int const dim)\n" + "Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w)\n" + ""}, + { "IntegrationPoint_Set3w", _wrap_IntegrationPoint_Set3w, METH_VARARGS, "Set3w(IntegrationPoint self, double const * p)"}, + { "IntegrationPoint_Set3", _wrap_IntegrationPoint_Set3, METH_VARARGS, "\n" + "Set3(IntegrationPoint self, double const x1, double const x2, double const x3)\n" + "Set3(IntegrationPoint self, double const * p)\n" + ""}, + { "IntegrationPoint_Set2w", _wrap_IntegrationPoint_Set2w, METH_VARARGS, "\n" + "Set2w(IntegrationPoint self, double const x1, double const x2, double const w)\n" + "Set2w(IntegrationPoint self, double const * p)\n" + ""}, + { "IntegrationPoint_Set2", _wrap_IntegrationPoint_Set2, METH_VARARGS, "\n" + "Set2(IntegrationPoint self, double const x1, double const x2)\n" + "Set2(IntegrationPoint self, double const * p)\n" + ""}, + { "IntegrationPoint_Set1w", _wrap_IntegrationPoint_Set1w, METH_VARARGS, "\n" + "Set1w(IntegrationPoint self, double const x1, double const w)\n" + "Set1w(IntegrationPoint self, double const * p)\n" + ""}, + { "new_IntegrationPoint", _wrap_new_IntegrationPoint, METH_NOARGS, "new_IntegrationPoint() -> IntegrationPoint"}, + { "delete_IntegrationPoint", _wrap_delete_IntegrationPoint, METH_O, "delete_IntegrationPoint(IntegrationPoint self)"}, + { "IntegrationPoint_swigregister", IntegrationPoint_swigregister, METH_O, NULL}, + { "IntegrationPoint_swiginit", IntegrationPoint_swiginit, METH_VARARGS, NULL}, + { "new_IntegrationRule", _wrap_new_IntegrationRule, METH_VARARGS, "\n" + "IntegrationRule()\n" + "IntegrationRule(int NP)\n" + "IntegrationRule(IntegrationRule irx, IntegrationRule iry)\n" + "new_IntegrationRule(IntegrationRule irx, IntegrationRule iry, IntegrationRule irz) -> IntegrationRule\n" + ""}, + { "IntegrationRule_GetOrder", _wrap_IntegrationRule_GetOrder, METH_O, "GetOrder(IntegrationRule self) -> int"}, + { "IntegrationRule_SetOrder", _wrap_IntegrationRule_SetOrder, METH_VARARGS, "SetOrder(IntegrationRule self, int const order)"}, + { "IntegrationRule_GetNPoints", _wrap_IntegrationRule_GetNPoints, METH_O, "GetNPoints(IntegrationRule self) -> int"}, + { "IntegrationRule_IntPoint", _wrap_IntegrationRule_IntPoint, METH_VARARGS, "\n" + "IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" + "IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" + ""}, + { "IntegrationRule_GetWeights", _wrap_IntegrationRule_GetWeights, METH_O, "GetWeights(IntegrationRule self) -> doubleArray"}, + { "delete_IntegrationRule", _wrap_delete_IntegrationRule, METH_O, "delete_IntegrationRule(IntegrationRule self)"}, + { "IntegrationRule_swigregister", IntegrationRule_swigregister, METH_O, NULL}, + { "IntegrationRule_swiginit", IntegrationRule_swiginit, METH_VARARGS, NULL}, + { "QuadratureFunctions1D_GaussLegendre", _wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS, "GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GaussLobatto", _wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS, "GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenUniform", _wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS, "OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_ClosedUniform", _wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS, "ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenHalfUniform", _wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS, "OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GivePolyPoints", _wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS, "GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, + { "new_QuadratureFunctions1D", _wrap_new_QuadratureFunctions1D, METH_NOARGS, "new_QuadratureFunctions1D() -> QuadratureFunctions1D"}, + { "delete_QuadratureFunctions1D", _wrap_delete_QuadratureFunctions1D, METH_O, "delete_QuadratureFunctions1D(QuadratureFunctions1D self)"}, + { "QuadratureFunctions1D_swigregister", QuadratureFunctions1D_swigregister, METH_O, NULL}, + { "QuadratureFunctions1D_swiginit", QuadratureFunctions1D_swiginit, METH_VARARGS, NULL}, + { "Quadrature1D_CheckClosed", _wrap_Quadrature1D_CheckClosed, METH_O, "CheckClosed(int type) -> int"}, + { "Quadrature1D_CheckOpen", _wrap_Quadrature1D_CheckOpen, METH_O, "CheckOpen(int type) -> int"}, + { "new_Quadrature1D", _wrap_new_Quadrature1D, METH_NOARGS, "new_Quadrature1D() -> Quadrature1D"}, + { "delete_Quadrature1D", _wrap_delete_Quadrature1D, METH_O, "delete_Quadrature1D(Quadrature1D self)"}, + { "Quadrature1D_swigregister", Quadrature1D_swigregister, METH_O, NULL}, + { "Quadrature1D_swiginit", Quadrature1D_swiginit, METH_VARARGS, NULL}, + { "new_IntegrationRules", _wrap_new_IntegrationRules, METH_VARARGS, "IntegrationRules(int Ref=0, int type=GaussLegendre)"}, + { "IntegrationRules_Get", _wrap_IntegrationRules_Get, METH_VARARGS, "Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, + { "IntegrationRules_Set", _wrap_IntegrationRules_Set, METH_VARARGS, "Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, + { "IntegrationRules_SetOwnRules", _wrap_IntegrationRules_SetOwnRules, METH_VARARGS, "SetOwnRules(IntegrationRules self, int o)"}, + { "delete_IntegrationRules", _wrap_delete_IntegrationRules, METH_O, "delete_IntegrationRules(IntegrationRules self)"}, + { "IntegrationRules_swigregister", IntegrationRules_swigregister, METH_O, NULL}, + { "IntegrationRules_swiginit", IntegrationRules_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/io_stream.py b/mfem/_par/io_stream.py index aefd0792..b63a6b7e 100644 --- a/mfem/_par/io_stream.py +++ b/mfem/_par/io_stream.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _io_stream.SWIG_PyInstanceMethod_New +_swig_new_static_method = _io_stream.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -77,18 +80,22 @@ def __init__(self, *args): def isSTDOUT(self): r"""isSTDOUT(wFILE self) -> int""" return _io_stream.wFILE_isSTDOUT(self) + isSTDOUT = _swig_new_instance_method(_io_stream.wFILE_isSTDOUT) def getFilename(self): r"""getFilename(wFILE self) -> char *""" return _io_stream.wFILE_getFilename(self) + getFilename = _swig_new_instance_method(_io_stream.wFILE_getFilename) def getPrecision(self): r"""getPrecision(wFILE self) -> int""" return _io_stream.wFILE_getPrecision(self) + getPrecision = _swig_new_instance_method(_io_stream.wFILE_getPrecision) def setPrecision(self, precision): r"""setPrecision(wFILE self, int precision)""" return _io_stream.wFILE_setPrecision(self, precision) + setPrecision = _swig_new_instance_method(_io_stream.wFILE_setPrecision) __swig_destroy__ = _io_stream.delete_wFILE # Register wFILE in _io_stream: diff --git a/mfem/_par/io_stream_wrap.cxx b/mfem/_par/io_stream_wrap.cxx index 5234e352..9b6364f4 100644 --- a/mfem/_par/io_stream_wrap.cxx +++ b/mfem/_par/io_stream_wrap.cxx @@ -3331,6 +3331,7 @@ SWIGINTERN PyObject *wFILE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *ar static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" "wFILE()\n" "wFILE(char const * filename, int precision=8)\n" @@ -3346,6 +3347,19 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" + "wFILE()\n" + "wFILE(char const * filename, int precision=8)\n" + ""}, + { "wFILE_isSTDOUT", _wrap_wFILE_isSTDOUT, METH_O, "isSTDOUT(wFILE self) -> int"}, + { "wFILE_getFilename", _wrap_wFILE_getFilename, METH_O, "getFilename(wFILE self) -> char *"}, + { "wFILE_getPrecision", _wrap_wFILE_getPrecision, METH_O, "getPrecision(wFILE self) -> int"}, + { "wFILE_setPrecision", _wrap_wFILE_setPrecision, METH_VARARGS, "setPrecision(wFILE self, int precision)"}, + { "delete_wFILE", _wrap_delete_wFILE, METH_O, "delete_wFILE(wFILE self)"}, + { "wFILE_swigregister", wFILE_swigregister, METH_O, NULL}, + { "wFILE_swiginit", wFILE_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/istream_typemap.py b/mfem/_par/istream_typemap.py index c403dc6e..d66724c6 100644 --- a/mfem/_par/istream_typemap.py +++ b/mfem/_par/istream_typemap.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _istream_typemap.SWIG_PyInstanceMethod_New +_swig_new_static_method = _istream_typemap.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() diff --git a/mfem/_par/istream_typemap_wrap.cxx b/mfem/_par/istream_typemap_wrap.cxx index 2061a8e6..4b015f3f 100644 --- a/mfem/_par/istream_typemap_wrap.cxx +++ b/mfem/_par/istream_typemap_wrap.cxx @@ -2767,10 +2767,13 @@ extern "C" { #endif static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/linearform.py b/mfem/_par/linearform.py index aca299af..2c6d3da1 100644 --- a/mfem/_par/linearform.py +++ b/mfem/_par/linearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _linearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _linearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -77,6 +80,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -87,6 +91,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg class LinearForm(mfem._par.vector.Vector): r"""Proxy of C++ mfem::LinearForm class.""" @@ -99,12 +104,14 @@ def __init__(self, *args): __init__(LinearForm self, FiniteElementSpace f) -> LinearForm __init__(LinearForm self, FiniteElementSpace f, LinearForm lf) -> LinearForm __init__(LinearForm self) -> LinearForm + __init__(LinearForm self, FiniteElementSpace f, double * data) -> LinearForm """ _linearform.LinearForm_swiginit(self, _linearform.new_LinearForm(*args)) def GetFES(self): r"""GetFES(LinearForm self) -> FiniteElementSpace""" return _linearform.LinearForm_GetFES(self) + GetFES = _swig_new_instance_method(_linearform.LinearForm_GetFES) def FESpace(self, *args): r""" @@ -112,6 +119,7 @@ def FESpace(self, *args): FESpace(LinearForm self) -> FiniteElementSpace """ return _linearform.LinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_linearform.LinearForm_FESpace) def AddDomainIntegrator(self, lfi): r"""AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)""" @@ -157,30 +165,37 @@ def AddBdrFaceIntegrator(self, *args): def GetDLFI(self): r"""GetDLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *""" return _linearform.LinearForm_GetDLFI(self) + GetDLFI = _swig_new_instance_method(_linearform.LinearForm_GetDLFI) def GetDLFI_Delta(self): r"""GetDLFI_Delta(LinearForm self) -> mfem::Array< mfem::DeltaLFIntegrator * > *""" return _linearform.LinearForm_GetDLFI_Delta(self) + GetDLFI_Delta = _swig_new_instance_method(_linearform.LinearForm_GetDLFI_Delta) def GetBLFI(self): r"""GetBLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *""" return _linearform.LinearForm_GetBLFI(self) + GetBLFI = _swig_new_instance_method(_linearform.LinearForm_GetBLFI) def GetFLFI(self): r"""GetFLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *""" return _linearform.LinearForm_GetFLFI(self) + GetFLFI = _swig_new_instance_method(_linearform.LinearForm_GetFLFI) def GetFLFI_Marker(self): r"""GetFLFI_Marker(LinearForm self) -> mfem::Array< mfem::Array< int > * > *""" return _linearform.LinearForm_GetFLFI_Marker(self) + GetFLFI_Marker = _swig_new_instance_method(_linearform.LinearForm_GetFLFI_Marker) def Assemble(self): r"""Assemble(LinearForm self)""" return _linearform.LinearForm_Assemble(self) + Assemble = _swig_new_instance_method(_linearform.LinearForm_Assemble) def AssembleDelta(self): r"""AssembleDelta(LinearForm self)""" return _linearform.LinearForm_AssembleDelta(self) + AssembleDelta = _swig_new_instance_method(_linearform.LinearForm_AssembleDelta) def Update(self, *args): r""" @@ -189,10 +204,12 @@ def Update(self, *args): Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset) """ return _linearform.LinearForm_Update(self, *args) + Update = _swig_new_instance_method(_linearform.LinearForm_Update) def __call__(self, gf): r"""__call__(LinearForm self, GridFunction gf) -> double""" return _linearform.LinearForm___call__(self, gf) + __call__ = _swig_new_instance_method(_linearform.LinearForm___call__) __swig_destroy__ = _linearform.delete_LinearForm # Register LinearForm in _linearform: diff --git a/mfem/_par/linearform_wrap.cxx b/mfem/_par/linearform_wrap.cxx index 1a755457..5194c500 100644 --- a/mfem/_par/linearform_wrap.cxx +++ b/mfem/_par/linearform_wrap.cxx @@ -3064,44 +3064,46 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_mfem__DeltaLFIntegrator_p_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_mfem__LinearFormIntegrator_p_t swig_types[8] -#define SWIGTYPE_p_mfem__BoundaryFlowIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__BoundaryLFIntegrator swig_types[10] -#define SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator swig_types[11] -#define SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator swig_types[12] -#define SWIGTYPE_p_mfem__DGDirichletLFIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__DGElasticityDirichletLFIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__DeltaLFIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__DomainLFIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[17] -#define SWIGTYPE_p_mfem__GridFunction swig_types[18] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[19] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[20] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[21] -#define SWIGTYPE_p_mfem__LinearForm swig_types[22] -#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[23] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[24] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[25] -#define SWIGTYPE_p_mfem__Vector swig_types[26] -#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[27] -#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[29] -#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[31] -#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[32] -#define SWIGTYPE_p_pri_t swig_types[33] -#define SWIGTYPE_p_quad_t swig_types[34] -#define SWIGTYPE_p_seg_t swig_types[35] -#define SWIGTYPE_p_tet_t swig_types[36] -#define SWIGTYPE_p_tri_t swig_types[37] -static swig_type_info *swig_types[39]; -static swig_module_info swig_module = {swig_types, 38, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_double swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_mfem__DeltaLFIntegrator_p_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__LinearFormIntegrator_p_t swig_types[10] +#define SWIGTYPE_p_mfem__BoundaryFlowIntegrator swig_types[11] +#define SWIGTYPE_p_mfem__BoundaryLFIntegrator swig_types[12] +#define SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator swig_types[13] +#define SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__DGDirichletLFIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__DGElasticityDirichletLFIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__DeltaLFIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__DomainLFIntegrator swig_types[18] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[19] +#define SWIGTYPE_p_mfem__GridFunction swig_types[20] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[21] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[22] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[23] +#define SWIGTYPE_p_mfem__LinearForm swig_types[24] +#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[25] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[26] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[27] +#define SWIGTYPE_p_mfem__Vector swig_types[28] +#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[29] +#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[30] +#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[34] +#define SWIGTYPE_p_pri_t swig_types[35] +#define SWIGTYPE_p_quad_t swig_types[36] +#define SWIGTYPE_p_seg_t swig_types[37] +#define SWIGTYPE_p_tet_t swig_types[38] +#define SWIGTYPE_p_tri_t swig_types[39] +static swig_type_info *swig_types[41]; +static swig_module_info swig_module = {swig_types, 40, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3320,6 +3322,42 @@ SWIGINTERN PyObject *_wrap_new_LinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } +SWIGINTERN PyObject *_wrap_new_LinearForm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + double *arg2 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::LinearForm *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearForm" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (mfem::LinearForm *)new mfem::LinearForm(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LinearForm, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_new_LinearForm(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { @@ -3354,13 +3392,28 @@ SWIGINTERN PyObject *_wrap_new_LinearForm(PyObject *self, PyObject *args) { } } } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_LinearForm__SWIG_3(self, argc, argv); + } + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LinearForm'.\n" " Possible C/C++ prototypes are:\n" " mfem::LinearForm::LinearForm(mfem::FiniteElementSpace *)\n" " mfem::LinearForm::LinearForm(mfem::FiniteElementSpace *,mfem::LinearForm *)\n" - " mfem::LinearForm::LinearForm()\n"); + " mfem::LinearForm::LinearForm()\n" + " mfem::LinearForm::LinearForm(mfem::FiniteElementSpace *,double *)\n"); return 0; } @@ -4263,10 +4316,12 @@ SWIGINTERN PyObject *LinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_LinearForm", _wrap_new_LinearForm, METH_VARARGS, "\n" "LinearForm(FiniteElementSpace f)\n" "LinearForm(FiniteElementSpace f, LinearForm lf)\n" - "new_LinearForm() -> LinearForm\n" + "LinearForm()\n" + "new_LinearForm(FiniteElementSpace f, double * data) -> LinearForm\n" ""}, { "LinearForm_GetFES", _wrap_LinearForm_GetFES, METH_O, "LinearForm_GetFES(LinearForm self) -> FiniteElementSpace"}, { "LinearForm_FESpace", _wrap_LinearForm_FESpace, METH_VARARGS, "\n" @@ -4302,6 +4357,44 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_LinearForm", _wrap_new_LinearForm, METH_VARARGS, "\n" + "LinearForm(FiniteElementSpace f)\n" + "LinearForm(FiniteElementSpace f, LinearForm lf)\n" + "LinearForm()\n" + "new_LinearForm(FiniteElementSpace f, double * data) -> LinearForm\n" + ""}, + { "LinearForm_GetFES", _wrap_LinearForm_GetFES, METH_O, "GetFES(LinearForm self) -> FiniteElementSpace"}, + { "LinearForm_FESpace", _wrap_LinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(LinearForm self) -> FiniteElementSpace\n" + "FESpace(LinearForm self) -> FiniteElementSpace\n" + ""}, + { "LinearForm_AddDomainIntegrator", _wrap_LinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, + { "LinearForm_AddBoundaryIntegrator", _wrap_LinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" + "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" + ""}, + { "LinearForm_AddBdrFaceIntegrator", _wrap_LinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" + "AddBdrFaceIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" + ""}, + { "LinearForm_GetDLFI", _wrap_LinearForm_GetDLFI, METH_O, "GetDLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *"}, + { "LinearForm_GetDLFI_Delta", _wrap_LinearForm_GetDLFI_Delta, METH_O, "GetDLFI_Delta(LinearForm self) -> mfem::Array< mfem::DeltaLFIntegrator * > *"}, + { "LinearForm_GetBLFI", _wrap_LinearForm_GetBLFI, METH_O, "GetBLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *"}, + { "LinearForm_GetFLFI", _wrap_LinearForm_GetFLFI, METH_O, "GetFLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *"}, + { "LinearForm_GetFLFI_Marker", _wrap_LinearForm_GetFLFI_Marker, METH_O, "GetFLFI_Marker(LinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "LinearForm_Assemble", _wrap_LinearForm_Assemble, METH_O, "Assemble(LinearForm self)"}, + { "LinearForm_AssembleDelta", _wrap_LinearForm_AssembleDelta, METH_O, "AssembleDelta(LinearForm self)"}, + { "LinearForm_Update", _wrap_LinearForm_Update, METH_VARARGS, "\n" + "Update(LinearForm self)\n" + "Update(LinearForm self, FiniteElementSpace f)\n" + "Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset)\n" + ""}, + { "LinearForm___call__", _wrap_LinearForm___call__, METH_VARARGS, "__call__(LinearForm self, GridFunction gf) -> double"}, + { "delete_LinearForm", _wrap_delete_LinearForm, METH_O, "delete_LinearForm(LinearForm self)"}, + { "LinearForm_swigregister", LinearForm_swigregister, METH_O, NULL}, + { "LinearForm_swiginit", LinearForm_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4364,7 +4457,9 @@ static void *_p_mfem__DeltaLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; @@ -4404,7 +4499,9 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, + &_swigt__p_double, &_swigt__p_hex_t, &_swigt__p_int, &_swigt__p_mfem__ArrayT_int_t, @@ -4444,7 +4541,9 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -4484,7 +4583,9 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, + _swigc__p_double, _swigc__p_hex_t, _swigc__p_int, _swigc__p_mfem__ArrayT_int_t, diff --git a/mfem/_par/lininteg.py b/mfem/_par/lininteg.py index 929b68ce..6e97f257 100644 --- a/mfem/_par/lininteg.py +++ b/mfem/_par/lininteg.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _lininteg.SWIG_PyInstanceMethod_New +_swig_new_static_method = _lininteg.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -90,14 +93,17 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.LinearFormIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.LinearFormIntegrator_AssembleRHSElementVect) def SetIntRule(self, ir): r"""SetIntRule(LinearFormIntegrator self, IntegrationRule ir)""" return _lininteg.LinearFormIntegrator_SetIntRule(self, ir) + SetIntRule = _swig_new_instance_method(_lininteg.LinearFormIntegrator_SetIntRule) def GetIntRule(self): r"""GetIntRule(LinearFormIntegrator self) -> IntegrationRule""" return _lininteg.LinearFormIntegrator_GetIntRule(self) + GetIntRule = _swig_new_instance_method(_lininteg.LinearFormIntegrator_GetIntRule) __swig_destroy__ = _lininteg.delete_LinearFormIntegrator # Register LinearFormIntegrator in _lininteg: @@ -115,14 +121,17 @@ def __init__(self, *args, **kwargs): def IsDelta(self): r"""IsDelta(DeltaLFIntegrator self) -> bool""" return _lininteg.DeltaLFIntegrator_IsDelta(self) + IsDelta = _swig_new_instance_method(_lininteg.DeltaLFIntegrator_IsDelta) def GetDeltaCenter(self, center): r"""GetDeltaCenter(DeltaLFIntegrator self, Vector center)""" return _lininteg.DeltaLFIntegrator_GetDeltaCenter(self, center) + GetDeltaCenter = _swig_new_instance_method(_lininteg.DeltaLFIntegrator_GetDeltaCenter) def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.DeltaLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.DeltaLFIntegrator_AssembleDeltaElementVect) __swig_destroy__ = _lininteg.delete_DeltaLFIntegrator # Register DeltaLFIntegrator in _lininteg: @@ -149,6 +158,7 @@ def __init__(self, *args): def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.DomainLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.DomainLFIntegrator_AssembleDeltaElementVect) def AssembleRHSElementVect(self, *args): r""" @@ -156,6 +166,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.DomainLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.DomainLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_DomainLFIntegrator # Register DomainLFIntegrator in _lininteg: @@ -182,6 +193,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryLFIntegrator # Register BoundaryLFIntegrator in _lininteg: @@ -203,6 +215,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryNormalLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryNormalLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryNormalLFIntegrator # Register BoundaryNormalLFIntegrator in _lininteg: @@ -224,6 +237,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryTangentialLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryTangentialLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryTangentialLFIntegrator # Register BoundaryTangentialLFIntegrator in _lininteg: @@ -242,6 +256,7 @@ def __init__(self, QF): def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.VectorDomainLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.VectorDomainLFIntegrator_AssembleDeltaElementVect) def AssembleRHSElementVect(self, *args): r""" @@ -249,6 +264,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorDomainLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorDomainLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorDomainLFIntegrator # Register VectorDomainLFIntegrator in _lininteg: @@ -270,6 +286,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorBoundaryLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorBoundaryLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorBoundaryLFIntegrator # Register VectorBoundaryLFIntegrator in _lininteg: @@ -293,6 +310,7 @@ def __init__(self, F): def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.VectorFEDomainLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.VectorFEDomainLFIntegrator_AssembleDeltaElementVect) def AssembleRHSElementVect(self, *args): r""" @@ -300,6 +318,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorFEDomainLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorFEDomainLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorFEDomainLFIntegrator # Register VectorFEDomainLFIntegrator in _lininteg: @@ -321,6 +340,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorBoundaryFluxLFIntegrator # Register VectorBoundaryFluxLFIntegrator in _lininteg: @@ -332,9 +352,12 @@ class VectorFEBoundaryFluxLFIntegrator(LinearFormIntegrator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, f): - r"""__init__(VectorFEBoundaryFluxLFIntegrator self, Coefficient f) -> VectorFEBoundaryFluxLFIntegrator""" - _lininteg.VectorFEBoundaryFluxLFIntegrator_swiginit(self, _lininteg.new_VectorFEBoundaryFluxLFIntegrator(f)) + def __init__(self, *args): + r""" + __init__(VectorFEBoundaryFluxLFIntegrator self) -> VectorFEBoundaryFluxLFIntegrator + __init__(VectorFEBoundaryFluxLFIntegrator self, Coefficient f) -> VectorFEBoundaryFluxLFIntegrator + """ + _lininteg.VectorFEBoundaryFluxLFIntegrator_swiginit(self, _lininteg.new_VectorFEBoundaryFluxLFIntegrator(*args)) def AssembleRHSElementVect(self, *args): r""" @@ -342,6 +365,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorFEBoundaryFluxLFIntegrator # Register VectorFEBoundaryFluxLFIntegrator in _lininteg: @@ -368,6 +392,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorFEBoundaryTangentLFIntegrator # Register VectorFEBoundaryTangentLFIntegrator in _lininteg: @@ -389,6 +414,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryFlowIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryFlowIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryFlowIntegrator # Register BoundaryFlowIntegrator in _lininteg: @@ -414,6 +440,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(DGDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.DGDirichletLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.DGDirichletLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_DGDirichletLFIntegrator # Register DGDirichletLFIntegrator in _lininteg: @@ -435,6 +462,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.DGElasticityDirichletLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.DGElasticityDirichletLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_DGElasticityDirichletLFIntegrator # Register DGElasticityDirichletLFIntegrator in _lininteg: diff --git a/mfem/_par/lininteg_wrap.cxx b/mfem/_par/lininteg_wrap.cxx index 752c2de5..a75c2383 100644 --- a/mfem/_par/lininteg_wrap.cxx +++ b/mfem/_par/lininteg_wrap.cxx @@ -3106,126 +3106,128 @@ namespace Swig { #define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[41] #define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[42] #define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[43] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[44] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[45] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[46] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[47] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[48] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[49] -#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[50] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[51] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[52] -#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[53] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[54] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[55] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[56] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[57] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[59] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[60] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[62] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[63] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[64] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[65] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[66] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[67] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[68] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[69] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[70] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[73] -#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[74] -#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[75] -#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[76] -#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[77] -#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[78] -#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[79] -#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[80] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[81] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[82] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[83] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[84] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[85] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[94] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[105] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[109] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[110] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[111] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[114] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[118] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[119] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[123] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[124] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[125] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[126] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[127] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[128] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[129] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[130] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[131] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[132] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[133] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[134] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[135] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[136] -#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[137] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[138] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[139] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[140] -#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[141] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[142] -#define SWIGTYPE_p_mfem__Vector swig_types[143] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[144] -#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[145] -#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[146] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[147] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[148] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[149] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[150] -#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[151] -#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[152] -#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[153] -#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[154] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[155] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[156] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[157] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[158] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[159] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[160] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[161] -static swig_type_info *swig_types[163]; -static swig_module_info swig_module = {swig_types, 162, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[44] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[45] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[46] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[47] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[49] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[50] +#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[51] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[52] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[53] +#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[54] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[55] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[56] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[57] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[58] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[59] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[60] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[61] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[63] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[64] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[65] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[66] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[67] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[70] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[71] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[72] +#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[74] +#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[75] +#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[76] +#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[77] +#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[78] +#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[79] +#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[80] +#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[81] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[82] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[83] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[84] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[85] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[86] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[95] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[99] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[106] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[110] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[111] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[112] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[117] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[118] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[125] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[126] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[127] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[128] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[129] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[130] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[131] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[132] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[133] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[134] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[135] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[136] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[137] +#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[138] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[139] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[141] +#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[142] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[143] +#define SWIGTYPE_p_mfem__Vector swig_types[144] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[145] +#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[146] +#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[147] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[148] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[149] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[150] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[151] +#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[152] +#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[153] +#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[154] +#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[155] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[156] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[157] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[158] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[159] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[160] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[161] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[162] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[163] +static swig_type_info *swig_types[165]; +static swig_module_info swig_module = {swig_types, 164, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -7199,16 +7201,39 @@ SWIGINTERN PyObject *VectorBoundaryFluxLFIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorFEBoundaryFluxLFIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorFEBoundaryFluxLFIntegrator *)new mfem::VectorFEBoundaryFluxLFIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::VectorFEBoundaryFluxLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -7237,6 +7262,36 @@ SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator(PyObject *SWIGUN } +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEBoundaryFluxLFIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEBoundaryFluxLFIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorFEBoundaryFluxLFIntegrator::VectorFEBoundaryFluxLFIntegrator()\n" + " mfem::VectorFEBoundaryFluxLFIntegrator::VectorFEBoundaryFluxLFIntegrator(mfem::Coefficient &)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorFEBoundaryFluxLFIntegrator *arg1 = (mfem::VectorFEBoundaryFluxLFIntegrator *) 0 ; @@ -8881,6 +8936,7 @@ SWIGINTERN PyObject *DGElasticityDirichletLFIntegrator_swiginit(PyObject *SWIGUN static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "LinearFormIntegrator_AssembleRHSElementVect", _wrap_LinearFormIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -8964,7 +9020,10 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorBoundaryFluxLFIntegrator", _wrap_delete_VectorBoundaryFluxLFIntegrator, METH_O, "delete_VectorBoundaryFluxLFIntegrator(VectorBoundaryFluxLFIntegrator self)"}, { "VectorBoundaryFluxLFIntegrator_swigregister", VectorBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, { "VectorBoundaryFluxLFIntegrator_swiginit", VectorBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEBoundaryFluxLFIntegrator", _wrap_new_VectorFEBoundaryFluxLFIntegrator, METH_O, "new_VectorFEBoundaryFluxLFIntegrator(Coefficient f) -> VectorFEBoundaryFluxLFIntegrator"}, + { "new_VectorFEBoundaryFluxLFIntegrator", _wrap_new_VectorFEBoundaryFluxLFIntegrator, METH_VARARGS, "\n" + "VectorFEBoundaryFluxLFIntegrator()\n" + "new_VectorFEBoundaryFluxLFIntegrator(Coefficient f) -> VectorFEBoundaryFluxLFIntegrator\n" + ""}, { "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9012,6 +9071,138 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "LinearFormIntegrator_AssembleRHSElementVect", _wrap_LinearFormIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "LinearFormIntegrator_SetIntRule", _wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, + { "LinearFormIntegrator_GetIntRule", _wrap_LinearFormIntegrator_GetIntRule, METH_O, "GetIntRule(LinearFormIntegrator self) -> IntegrationRule"}, + { "delete_LinearFormIntegrator", _wrap_delete_LinearFormIntegrator, METH_O, "delete_LinearFormIntegrator(LinearFormIntegrator self)"}, + { "LinearFormIntegrator_swigregister", LinearFormIntegrator_swigregister, METH_O, NULL}, + { "DeltaLFIntegrator_IsDelta", _wrap_DeltaLFIntegrator_IsDelta, METH_O, "IsDelta(DeltaLFIntegrator self) -> bool"}, + { "DeltaLFIntegrator_GetDeltaCenter", _wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, + { "DeltaLFIntegrator_AssembleDeltaElementVect", _wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "delete_DeltaLFIntegrator", _wrap_delete_DeltaLFIntegrator, METH_O, "delete_DeltaLFIntegrator(DeltaLFIntegrator self)"}, + { "DeltaLFIntegrator_swigregister", DeltaLFIntegrator_swigregister, METH_O, NULL}, + { "new_DomainLFIntegrator", _wrap_new_DomainLFIntegrator, METH_VARARGS, "\n" + "DomainLFIntegrator(Coefficient QF, int a=2, int b=0)\n" + "new_DomainLFIntegrator(Coefficient QF, IntegrationRule ir) -> DomainLFIntegrator\n" + ""}, + { "DomainLFIntegrator_AssembleDeltaElementVect", _wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DomainLFIntegrator_AssembleRHSElementVect", _wrap_DomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_DomainLFIntegrator", _wrap_delete_DomainLFIntegrator, METH_O, "delete_DomainLFIntegrator(DomainLFIntegrator self)"}, + { "DomainLFIntegrator_swigregister", DomainLFIntegrator_swigregister, METH_O, NULL}, + { "DomainLFIntegrator_swiginit", DomainLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryLFIntegrator", _wrap_new_BoundaryLFIntegrator, METH_VARARGS, "BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1)"}, + { "BoundaryLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryLFIntegrator", _wrap_delete_BoundaryLFIntegrator, METH_O, "delete_BoundaryLFIntegrator(BoundaryLFIntegrator self)"}, + { "BoundaryLFIntegrator_swigregister", BoundaryLFIntegrator_swigregister, METH_O, NULL}, + { "BoundaryLFIntegrator_swiginit", BoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryNormalLFIntegrator", _wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS, "BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "BoundaryNormalLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryNormalLFIntegrator", _wrap_delete_BoundaryNormalLFIntegrator, METH_O, "delete_BoundaryNormalLFIntegrator(BoundaryNormalLFIntegrator self)"}, + { "BoundaryNormalLFIntegrator_swigregister", BoundaryNormalLFIntegrator_swigregister, METH_O, NULL}, + { "BoundaryNormalLFIntegrator_swiginit", BoundaryNormalLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryTangentialLFIntegrator", _wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS, "BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "BoundaryTangentialLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryTangentialLFIntegrator", _wrap_delete_BoundaryTangentialLFIntegrator, METH_O, "delete_BoundaryTangentialLFIntegrator(BoundaryTangentialLFIntegrator self)"}, + { "BoundaryTangentialLFIntegrator_swigregister", BoundaryTangentialLFIntegrator_swigregister, METH_O, NULL}, + { "BoundaryTangentialLFIntegrator_swiginit", BoundaryTangentialLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorDomainLFIntegrator", _wrap_new_VectorDomainLFIntegrator, METH_O, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, + { "VectorDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "VectorDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorDomainLFIntegrator", _wrap_delete_VectorDomainLFIntegrator, METH_O, "delete_VectorDomainLFIntegrator(VectorDomainLFIntegrator self)"}, + { "VectorDomainLFIntegrator_swigregister", VectorDomainLFIntegrator_swigregister, METH_O, NULL}, + { "VectorDomainLFIntegrator_swiginit", VectorDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorBoundaryLFIntegrator", _wrap_new_VectorBoundaryLFIntegrator, METH_O, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, + { "VectorBoundaryLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorBoundaryLFIntegrator", _wrap_delete_VectorBoundaryLFIntegrator, METH_O, "delete_VectorBoundaryLFIntegrator(VectorBoundaryLFIntegrator self)"}, + { "VectorBoundaryLFIntegrator_swigregister", VectorBoundaryLFIntegrator_swigregister, METH_O, NULL}, + { "VectorBoundaryLFIntegrator_swiginit", VectorBoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEDomainLFIntegrator", _wrap_new_VectorFEDomainLFIntegrator, METH_O, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, + { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "VectorFEDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorFEDomainLFIntegrator", _wrap_delete_VectorFEDomainLFIntegrator, METH_O, "delete_VectorFEDomainLFIntegrator(VectorFEDomainLFIntegrator self)"}, + { "VectorFEDomainLFIntegrator_swigregister", VectorFEDomainLFIntegrator_swigregister, METH_O, NULL}, + { "VectorFEDomainLFIntegrator_swiginit", VectorFEDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorBoundaryFluxLFIntegrator", _wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS, "VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None)"}, + { "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorBoundaryFluxLFIntegrator", _wrap_delete_VectorBoundaryFluxLFIntegrator, METH_O, "delete_VectorBoundaryFluxLFIntegrator(VectorBoundaryFluxLFIntegrator self)"}, + { "VectorBoundaryFluxLFIntegrator_swigregister", VectorBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, + { "VectorBoundaryFluxLFIntegrator_swiginit", VectorBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEBoundaryFluxLFIntegrator", _wrap_new_VectorFEBoundaryFluxLFIntegrator, METH_VARARGS, "\n" + "VectorFEBoundaryFluxLFIntegrator()\n" + "new_VectorFEBoundaryFluxLFIntegrator(Coefficient f) -> VectorFEBoundaryFluxLFIntegrator\n" + ""}, + { "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorFEBoundaryFluxLFIntegrator", _wrap_delete_VectorFEBoundaryFluxLFIntegrator, METH_O, "delete_VectorFEBoundaryFluxLFIntegrator(VectorFEBoundaryFluxLFIntegrator self)"}, + { "VectorFEBoundaryFluxLFIntegrator_swigregister", VectorFEBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, + { "VectorFEBoundaryFluxLFIntegrator_swiginit", VectorFEBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEBoundaryTangentLFIntegrator", _wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_O, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, + { "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorFEBoundaryTangentLFIntegrator", _wrap_delete_VectorFEBoundaryTangentLFIntegrator, METH_O, "delete_VectorFEBoundaryTangentLFIntegrator(VectorFEBoundaryTangentLFIntegrator self)"}, + { "VectorFEBoundaryTangentLFIntegrator_swigregister", VectorFEBoundaryTangentLFIntegrator_swigregister, METH_O, NULL}, + { "VectorFEBoundaryTangentLFIntegrator_swiginit", VectorFEBoundaryTangentLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryFlowIntegrator", _wrap_new_BoundaryFlowIntegrator, METH_VARARGS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, + { "BoundaryFlowIntegrator_AssembleRHSElementVect", _wrap_BoundaryFlowIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryFlowIntegrator", _wrap_delete_BoundaryFlowIntegrator, METH_O, "delete_BoundaryFlowIntegrator(BoundaryFlowIntegrator self)"}, + { "BoundaryFlowIntegrator_swigregister", BoundaryFlowIntegrator_swigregister, METH_O, NULL}, + { "BoundaryFlowIntegrator_swiginit", BoundaryFlowIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGDirichletLFIntegrator", _wrap_new_DGDirichletLFIntegrator, METH_VARARGS, "\n" + "DGDirichletLFIntegrator(Coefficient u, double const s, double const k)\n" + "DGDirichletLFIntegrator(Coefficient u, Coefficient q, double const s, double const k)\n" + "new_DGDirichletLFIntegrator(Coefficient u, MatrixCoefficient q, double const s, double const k) -> DGDirichletLFIntegrator\n" + ""}, + { "DGDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(DGDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(DGDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_DGDirichletLFIntegrator", _wrap_delete_DGDirichletLFIntegrator, METH_O, "delete_DGDirichletLFIntegrator(DGDirichletLFIntegrator self)"}, + { "DGDirichletLFIntegrator_swigregister", DGDirichletLFIntegrator_swigregister, METH_O, NULL}, + { "DGDirichletLFIntegrator_swiginit", DGDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGElasticityDirichletLFIntegrator", _wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, + { "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGElasticityDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_DGElasticityDirichletLFIntegrator", _wrap_delete_DGElasticityDirichletLFIntegrator, METH_O, "delete_DGElasticityDirichletLFIntegrator(DGElasticityDirichletLFIntegrator self)"}, + { "DGElasticityDirichletLFIntegrator_swigregister", DGElasticityDirichletLFIntegrator_swigregister, METH_O, NULL}, + { "DGElasticityDirichletLFIntegrator_swiginit", DGElasticityDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -9189,12 +9380,6 @@ static void *_p_mfem__DomainLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, static void *_p_mfem__DeltaLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::LinearFormIntegrator *) ((mfem::DeltaLFIntegrator *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -9228,6 +9413,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -9243,6 +9431,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -9411,6 +9602,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -9454,10 +9651,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -9525,13 +9722,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -9543,6 +9738,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -9584,6 +9781,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -9688,6 +9887,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -9806,6 +10006,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorRestrictedCoefficient, &_swigt__p_mfem__VectorRotProductCoefficient, &_swigt__p_mfem__VectorSumCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; @@ -9852,13 +10053,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -9870,6 +10069,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -9911,6 +10112,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -9934,7 +10137,7 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearFormIntegrator[] = { {&_swigt__p_mfem__DGElasticityDirichletLFIntegrator, _p_mfem__DGElasticityDirichletLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDirichletLFIntegrator, _p_mfem__DGDirichletLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryFlowIntegrator, _p_mfem__BoundaryFlowIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEBoundaryTangentLFIntegrator, _p_mfem__VectorFEBoundaryTangentLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEBoundaryFluxLFIntegrator, _p_mfem__VectorFEBoundaryFluxLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorBoundaryFluxLFIntegrator, _p_mfem__VectorBoundaryFluxLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDomainLFIntegrator, _p_mfem__VectorFEDomainLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorBoundaryLFIntegrator, _p_mfem__VectorBoundaryLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDomainLFIntegrator, _p_mfem__VectorDomainLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryTangentialLFIntegrator, _p_mfem__BoundaryTangentialLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryNormalLFIntegrator, _p_mfem__BoundaryNormalLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryLFIntegrator, _p_mfem__BoundaryLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DomainLFIntegrator, _p_mfem__DomainLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__DeltaLFIntegrator, _p_mfem__DeltaLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixConstantCoefficient[] = {{&_swigt__p_mfem__MatrixConstantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; @@ -10016,6 +10219,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -10134,6 +10338,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorRestrictedCoefficient, _swigc__p_mfem__VectorRotProductCoefficient, _swigc__p_mfem__VectorSumCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, }; diff --git a/mfem/_par/matrix.py b/mfem/_par/matrix.py index b2c9fd4b..db0f8013 100644 --- a/mfem/_par/matrix.py +++ b/mfem/_par/matrix.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _matrix.SWIG_PyInstanceMethod_New +_swig_new_static_method = _matrix.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,20 +85,28 @@ def __init__(self, *args, **kwargs): DIAG_KEEP = _matrix.Matrix_DIAG_KEEP + def IsSquare(self): + r"""IsSquare(Matrix self) -> bool""" + return _matrix.Matrix_IsSquare(self) + IsSquare = _swig_new_instance_method(_matrix.Matrix_IsSquare) + def Elem(self, *args): r""" Elem(Matrix self, int i, int j) -> double Elem(Matrix self, int i, int j) -> double const & """ return _matrix.Matrix_Elem(self, *args) + Elem = _swig_new_instance_method(_matrix.Matrix_Elem) def Inverse(self): r"""Inverse(Matrix self) -> MatrixInverse""" return _matrix.Matrix_Inverse(self) + Inverse = _swig_new_instance_method(_matrix.Matrix_Inverse) def Finalize(self, arg2): r"""Finalize(Matrix self, int arg2)""" return _matrix.Matrix_Finalize(self, arg2) + Finalize = _swig_new_instance_method(_matrix.Matrix_Finalize) __swig_destroy__ = _matrix.delete_Matrix def Print(self, *args): @@ -104,6 +115,7 @@ def Print(self, *args): Print(Matrix self, char const * file, int precision=8) """ return _matrix.Matrix_Print(self, *args) + Print = _swig_new_instance_method(_matrix.Matrix_Print) # Register Matrix in _matrix: _matrix.Matrix_swigregister(Matrix) @@ -133,30 +145,37 @@ def __init__(self, *args, **kwargs): def NumNonZeroElems(self): r"""NumNonZeroElems(AbstractSparseMatrix self) -> int""" return _matrix.AbstractSparseMatrix_NumNonZeroElems(self) + NumNonZeroElems = _swig_new_instance_method(_matrix.AbstractSparseMatrix_NumNonZeroElems) def GetRow(self, row, cols, srow): r"""GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int""" return _matrix.AbstractSparseMatrix_GetRow(self, row, cols, srow) + GetRow = _swig_new_instance_method(_matrix.AbstractSparseMatrix_GetRow) def EliminateZeroRows(self, threshold=1e-12): r"""EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)""" return _matrix.AbstractSparseMatrix_EliminateZeroRows(self, threshold) + EliminateZeroRows = _swig_new_instance_method(_matrix.AbstractSparseMatrix_EliminateZeroRows) def Mult(self, x, y): r"""Mult(AbstractSparseMatrix self, Vector x, Vector y)""" return _matrix.AbstractSparseMatrix_Mult(self, x, y) + Mult = _swig_new_instance_method(_matrix.AbstractSparseMatrix_Mult) def AddMult(self, x, y, val=1.): r"""AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)""" return _matrix.AbstractSparseMatrix_AddMult(self, x, y, val) + AddMult = _swig_new_instance_method(_matrix.AbstractSparseMatrix_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)""" return _matrix.AbstractSparseMatrix_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_matrix.AbstractSparseMatrix_MultTranspose) def AddMultTranspose(self, x, y, val=1.): r"""AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)""" return _matrix.AbstractSparseMatrix_AddMultTranspose(self, x, y, val) + AddMultTranspose = _swig_new_instance_method(_matrix.AbstractSparseMatrix_AddMultTranspose) __swig_destroy__ = _matrix.delete_AbstractSparseMatrix # Register AbstractSparseMatrix in _matrix: diff --git a/mfem/_par/matrix_wrap.cxx b/mfem/_par/matrix_wrap.cxx index fcb1048c..e44233df 100644 --- a/mfem/_par/matrix_wrap.cxx +++ b/mfem/_par/matrix_wrap.cxx @@ -3079,13 +3079,16 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[11] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[12] #define SWIGTYPE_p_mfem__RAPOperator swig_types[13] -#define SWIGTYPE_p_mfem__Solver swig_types[14] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[15] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[16] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[17] -#define SWIGTYPE_p_mfem__Vector swig_types[18] -static swig_type_info *swig_types[20]; -static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[14] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[15] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[16] +#define SWIGTYPE_p_mfem__Solver swig_types[17] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[18] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[19] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[20] +#define SWIGTYPE_p_mfem__Vector swig_types[21] +static swig_type_info *swig_types[23]; +static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3204,6 +3207,13 @@ SWIGINTERNINLINE PyObject* } +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + #define SWIG_From_double PyFloat_FromDouble @@ -3397,6 +3407,41 @@ SWIG_AsVal_double (PyObject *obj, double *val) #ifdef __cplusplus extern "C" { #endif +SWIGINTERN PyObject *_wrap_Matrix_IsSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_IsSquare" "', argument " "1"" of type '" "mfem::Matrix const *""'"); + } + arg1 = reinterpret_cast< mfem::Matrix * >(argp1); + { + try { + result = (bool)((mfem::Matrix const *)arg1)->IsSquare(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Matrix_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; @@ -4809,6 +4854,8 @@ SWIGINTERN PyObject *AbstractSparseMatrix_swigregister(PyObject *SWIGUNUSEDPARM( static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Matrix_IsSquare", _wrap_Matrix_IsSquare, METH_O, "Matrix_IsSquare(Matrix self) -> bool"}, { "Matrix_Elem", _wrap_Matrix_Elem, METH_VARARGS, "\n" "Matrix_Elem(Matrix self, int i, int j) -> double\n" "Matrix_Elem(Matrix self, int i, int j) -> double const &\n" @@ -4836,6 +4883,32 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Matrix_IsSquare", _wrap_Matrix_IsSquare, METH_O, "IsSquare(Matrix self) -> bool"}, + { "Matrix_Elem", _wrap_Matrix_Elem, METH_VARARGS, "\n" + "Elem(Matrix self, int i, int j) -> double\n" + "Elem(Matrix self, int i, int j) -> double const &\n" + ""}, + { "Matrix_Inverse", _wrap_Matrix_Inverse, METH_O, "Inverse(Matrix self) -> MatrixInverse"}, + { "Matrix_Finalize", _wrap_Matrix_Finalize, METH_VARARGS, "Finalize(Matrix self, int arg2)"}, + { "delete_Matrix", _wrap_delete_Matrix, METH_O, "delete_Matrix(Matrix self)"}, + { "Matrix_Print", _wrap_Matrix_Print, METH_VARARGS, "\n" + "Print(Matrix self, std::ostream & out=mfem::out, int width_=4)\n" + "Print(Matrix self, char const * file, int precision=8)\n" + ""}, + { "Matrix_swigregister", Matrix_swigregister, METH_O, NULL}, + { "delete_MatrixInverse", _wrap_delete_MatrixInverse, METH_O, "delete_MatrixInverse(MatrixInverse self)"}, + { "MatrixInverse_swigregister", MatrixInverse_swigregister, METH_O, NULL}, + { "AbstractSparseMatrix_NumNonZeroElems", _wrap_AbstractSparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(AbstractSparseMatrix self) -> int"}, + { "AbstractSparseMatrix_GetRow", _wrap_AbstractSparseMatrix_GetRow, METH_VARARGS, "GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "AbstractSparseMatrix_EliminateZeroRows", _wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, + { "AbstractSparseMatrix_Mult", _wrap_AbstractSparseMatrix_Mult, METH_VARARGS, "Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMult", _wrap_AbstractSparseMatrix_AddMult, METH_VARARGS, "AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_MultTranspose", _wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMultTranspose", _wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "delete_AbstractSparseMatrix", _wrap_delete_AbstractSparseMatrix, METH_O, "delete_AbstractSparseMatrix(AbstractSparseMatrix self)"}, + { "AbstractSparseMatrix_swigregister", AbstractSparseMatrix_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } }; @@ -4845,44 +4918,53 @@ static PyMethodDef SwigMethods_proxydocs[] = { static void *_p_mfem__MatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) ((mfem::MatrixInverse *) x)); } +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +} static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); -} -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Matrix(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); @@ -4895,15 +4977,18 @@ static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", " static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", "mfem::Matrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", "mfem::MatrixInverse *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -4922,6 +5007,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, @@ -4936,16 +5024,19 @@ static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = { {&_swigt__p_mf static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = { {&_swigt__p_mfem__Matrix, 0, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Matrix, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -4964,6 +5055,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, diff --git a/mfem/_par/mem_manager.py b/mfem/_par/mem_manager.py index 1a957c13..61f282ee 100644 --- a/mfem/_par/mem_manager.py +++ b/mfem/_par/mem_manager.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _mem_manager.SWIG_PyInstanceMethod_New +_swig_new_static_method = _mem_manager.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -64,22 +67,34 @@ class _SwigNonDynamicMeta(type): MemoryType_HOST = _mem_manager.MemoryType_HOST MemoryType_HOST_32 = _mem_manager.MemoryType_HOST_32 MemoryType_HOST_64 = _mem_manager.MemoryType_HOST_64 -MemoryType_CUDA = _mem_manager.MemoryType_CUDA -MemoryType_CUDA_UVM = _mem_manager.MemoryType_CUDA_UVM +MemoryType_HOST_DEBUG = _mem_manager.MemoryType_HOST_DEBUG +MemoryType_HOST_UMPIRE = _mem_manager.MemoryType_HOST_UMPIRE +MemoryType_MANAGED = _mem_manager.MemoryType_MANAGED +MemoryType_DEVICE = _mem_manager.MemoryType_DEVICE +MemoryType_DEVICE_DEBUG = _mem_manager.MemoryType_DEVICE_DEBUG +MemoryType_DEVICE_UMPIRE = _mem_manager.MemoryType_DEVICE_UMPIRE +MemoryType_SIZE = _mem_manager.MemoryType_SIZE MemoryClass_HOST = _mem_manager.MemoryClass_HOST MemoryClass_HOST_32 = _mem_manager.MemoryClass_HOST_32 MemoryClass_HOST_64 = _mem_manager.MemoryClass_HOST_64 -MemoryClass_CUDA = _mem_manager.MemoryClass_CUDA -MemoryClass_CUDA_UVM = _mem_manager.MemoryClass_CUDA_UVM +MemoryClass_DEVICE = _mem_manager.MemoryClass_DEVICE +MemoryClass_MANAGED = _mem_manager.MemoryClass_MANAGED def IsHostMemory(mt): return _mem_manager.IsHostMemory(mt) +IsHostMemory = _mem_manager.IsHostMemory + +def IsDeviceMemory(mt): + return _mem_manager.IsDeviceMemory(mt) +IsDeviceMemory = _mem_manager.IsDeviceMemory def GetMemoryType(mc): return _mem_manager.GetMemoryType(mc) +GetMemoryType = _mem_manager.GetMemoryType def __mul__(mc1, mc2): return _mem_manager.__mul__(mc1, mc2) +__mul__ = _mem_manager.__mul__ class MemoryManager(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -88,28 +103,68 @@ def __init__(self): _mem_manager.MemoryManager_swiginit(self, _mem_manager.new_MemoryManager()) __swig_destroy__ = _mem_manager.delete_MemoryManager + def Init(self): + return _mem_manager.MemoryManager_Init(self) + Init = _swig_new_instance_method(_mem_manager.MemoryManager_Init) + + def Configure(self, h_mt, d_mt): + return _mem_manager.MemoryManager_Configure(self, h_mt, d_mt) + Configure = _swig_new_instance_method(_mem_manager.MemoryManager_Configure) + def Destroy(self): return _mem_manager.MemoryManager_Destroy(self) + Destroy = _swig_new_instance_method(_mem_manager.MemoryManager_Destroy) - @staticmethod - def Exists(): - return _mem_manager.MemoryManager_Exists() + def IsKnown(self, h_ptr): + return _mem_manager.MemoryManager_IsKnown(self, h_ptr) + IsKnown = _swig_new_instance_method(_mem_manager.MemoryManager_IsKnown) + + def IsAlias(self, h_ptr): + return _mem_manager.MemoryManager_IsAlias(self, h_ptr) + IsAlias = _swig_new_instance_method(_mem_manager.MemoryManager_IsAlias) + + def RegisterCheck(self, h_ptr): + return _mem_manager.MemoryManager_RegisterCheck(self, h_ptr) + RegisterCheck = _swig_new_instance_method(_mem_manager.MemoryManager_RegisterCheck) - def RegisterCheck(self, ptr): - return _mem_manager.MemoryManager_RegisterCheck(self, ptr) + def PrintPtrs(self, *args): + return _mem_manager.MemoryManager_PrintPtrs(self, *args) + PrintPtrs = _swig_new_instance_method(_mem_manager.MemoryManager_PrintPtrs) - def PrintPtrs(self): - return _mem_manager.MemoryManager_PrintPtrs(self) + def PrintAliases(self, *args): + return _mem_manager.MemoryManager_PrintAliases(self, *args) + PrintAliases = _swig_new_instance_method(_mem_manager.MemoryManager_PrintAliases) + + @staticmethod + def GetHostMemoryType(): + return _mem_manager.MemoryManager_GetHostMemoryType() + GetHostMemoryType = _swig_new_static_method(_mem_manager.MemoryManager_GetHostMemoryType) + + @staticmethod + def GetDeviceMemoryType(): + return _mem_manager.MemoryManager_GetDeviceMemoryType() + GetDeviceMemoryType = _swig_new_static_method(_mem_manager.MemoryManager_GetDeviceMemoryType) # Register MemoryManager in _mem_manager: _mem_manager.MemoryManager_swigregister(MemoryManager) +cvar = _mem_manager.cvar +MemoryTypeSize = cvar.MemoryTypeSize +HostMemoryType = cvar.HostMemoryType +HostMemoryTypeSize = cvar.HostMemoryTypeSize +DeviceMemoryType = cvar.DeviceMemoryType +DeviceMemoryTypeSize = cvar.DeviceMemoryTypeSize + +def MemoryManager_GetHostMemoryType(): + return _mem_manager.MemoryManager_GetHostMemoryType() +MemoryManager_GetHostMemoryType = _mem_manager.MemoryManager_GetHostMemoryType -def MemoryManager_Exists(): - return _mem_manager.MemoryManager_Exists() +def MemoryManager_GetDeviceMemoryType(): + return _mem_manager.MemoryManager_GetDeviceMemoryType() +MemoryManager_GetDeviceMemoryType = _mem_manager.MemoryManager_GetDeviceMemoryType def MemoryPrintFlags(flags): return _mem_manager.MemoryPrintFlags(flags) +MemoryPrintFlags = _mem_manager.MemoryPrintFlags -cvar = _mem_manager.cvar diff --git a/mfem/_par/mem_manager_wrap.cxx b/mfem/_par/mem_manager_wrap.cxx index d497e35c..af5ea2e1 100644 --- a/mfem/_par/mem_manager_wrap.cxx +++ b/mfem/_par/mem_manager_wrap.cxx @@ -2662,8 +2662,10 @@ SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyO #define SWIGTYPE_p_char swig_types[0] #define SWIGTYPE_p_mfem__MemoryManager swig_types[1] -static swig_type_info *swig_types[3]; -static swig_module_info swig_module = {swig_types, 2, 0, 0, 0, 0}; +#define SWIGTYPE_p_p_char swig_types[2] +#define SWIGTYPE_p_std__ostream swig_types[3] +static swig_type_info *swig_types[5]; +static swig_module_info swig_module = {swig_types, 4, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3003,6 +3005,103 @@ SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) #ifdef __cplusplus extern "C" { #endif +SWIGINTERN int Swig_var_MemoryTypeSize_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable MemoryTypeSize is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_MemoryTypeSize_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::MemoryTypeSize)); + return pyobj; +} + + +SWIGINTERN int Swig_var_HostMemoryType_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable HostMemoryType is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_HostMemoryType_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::HostMemoryType)); + return pyobj; +} + + +SWIGINTERN int Swig_var_HostMemoryTypeSize_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable HostMemoryTypeSize is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_HostMemoryTypeSize_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::HostMemoryTypeSize)); + return pyobj; +} + + +SWIGINTERN int Swig_var_DeviceMemoryType_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable DeviceMemoryType is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_DeviceMemoryType_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::DeviceMemoryType)); + return pyobj; +} + + +SWIGINTERN int Swig_var_DeviceMemoryTypeSize_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable DeviceMemoryTypeSize is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_DeviceMemoryTypeSize_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::DeviceMemoryTypeSize)); + return pyobj; +} + + +SWIGINTERN int Swig_var_MemoryTypeName_set(PyObject *_val) { + { + char const * *inp = 0; + int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""mfem::MemoryTypeName""' of type '""char const *[mfem::MemoryTypeSize]""'"); + } else if (inp) { + size_t ii = 0; + for (; ii < (size_t)mfem::MemoryTypeSize; ++ii) *(char const * *)&mfem::MemoryTypeName[ii] = *((char const * *)inp + ii); + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mfem::MemoryTypeName""' of type '""char const *[mfem::MemoryTypeSize]""'"); + } + } + return 0; +fail: + return 1; +} + + +SWIGINTERN PyObject *Swig_var_MemoryTypeName_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mfem::MemoryTypeName), SWIGTYPE_p_p_char, 0 ); + return pyobj; +} + + SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryType arg1 ; @@ -3041,6 +3140,44 @@ SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject } +SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDeviceMemory" "', argument " "1"" of type '" "mfem::MemoryType""'"); + } + arg1 = static_cast< mfem::MemoryType >(val1); + { + try { + result = (bool)mfem::IsDeviceMemory(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryClass arg1 ; @@ -3191,6 +3328,95 @@ SWIGINTERN PyObject *_wrap_delete_MemoryManager(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_MemoryManager_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_Init" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + { + try { + (arg1)->Init(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + mfem::MemoryType arg2 ; + mfem::MemoryType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_Configure", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_Configure" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryManager_Configure" "', argument " "2"" of type '" "mfem::MemoryType""'"); + } + arg2 = static_cast< mfem::MemoryType >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryManager_Configure" "', argument " "3"" of type '" "mfem::MemoryType""'"); + } + arg3 = static_cast< mfem::MemoryType >(val3); + { + try { + (arg1)->Configure(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_MemoryManager_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; @@ -3228,14 +3454,72 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Destroy(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *arg2 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsKnown", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsKnown" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsKnown" "', argument " "2"" of type '" "void const *""'"); + } + { + try { + result = (bool)(arg1)->IsKnown((void const *)arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *arg2 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + PyObject *swig_obj[2] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_Exists", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsAlias", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsAlias" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsAlias" "', argument " "2"" of type '" "void const *""'"); + } { try { - result = (bool)mfem::MemoryManager::Exists(); + result = (bool)(arg1)->IsAlias((void const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3298,23 +3582,33 @@ SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); { try { - (arg1)->PrintPtrs(); + result = (int)(arg1)->PrintPtrs(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3328,7 +3622,264 @@ SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + { + try { + result = (int)(arg1)->PrintPtrs(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintPtrs", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintPtrs__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintPtrs__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintPtrs'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MemoryManager::PrintPtrs(std::ostream &)\n" + " mfem::MemoryManager::PrintPtrs()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + { + try { + result = (int)(arg1)->PrintAliases(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + { + try { + result = (int)(arg1)->PrintAliases(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintAliases", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintAliases__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintAliases__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintAliases'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MemoryManager::PrintAliases(std::ostream &)\n" + " mfem::MemoryManager::PrintAliases()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_GetHostMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_GetHostMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::MemoryManager::GetHostMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_GetDeviceMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_GetDeviceMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::MemoryManager::GetDeviceMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; @@ -3415,15 +3966,23 @@ SWIGINTERN PyObject *Swig_var_mm_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, + { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, + { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, + { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, - { "MemoryManager_Exists", _wrap_MemoryManager_Exists, METH_NOARGS, NULL}, + { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, + { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, - { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_O, NULL}, + { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, + { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, + { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, @@ -3431,6 +3990,27 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, + { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, + { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, + { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, + { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, + { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, + { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, + { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, + { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, + { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, + { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, + { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, + { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, + { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, + { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, + { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, + { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, + { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, { NULL, NULL, 0, NULL } }; @@ -3439,18 +4019,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__MemoryManager = {"_p_mfem__MemoryManager", "mfem::MemoryManager *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_char, &_swigt__p_mfem__MemoryManager, + &_swigt__p_p_char, + &_swigt__p_std__ostream, }; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MemoryManager[] = { {&_swigt__p_mfem__MemoryManager, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_char, _swigc__p_mfem__MemoryManager, + _swigc__p_p_char, + _swigc__p_std__ostream, }; @@ -4186,13 +4774,13 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MemoryType_HOST",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST))); SWIG_Python_SetConstant(d, "MemoryType_HOST_32",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_32))); SWIG_Python_SetConstant(d, "MemoryType_HOST_64",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_64))); - SWIG_Python_SetConstant(d, "MemoryType_CUDA",SWIG_From_int(static_cast< int >(mfem::MemoryType::CUDA))); - SWIG_Python_SetConstant(d, "MemoryType_CUDA_UVM",SWIG_From_int(static_cast< int >(mfem::MemoryType::CUDA_UVM))); - SWIG_Python_SetConstant(d, "MemoryClass_HOST",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST))); - SWIG_Python_SetConstant(d, "MemoryClass_HOST_32",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_32))); - SWIG_Python_SetConstant(d, "MemoryClass_HOST_64",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_64))); - SWIG_Python_SetConstant(d, "MemoryClass_CUDA",SWIG_From_int(static_cast< int >(mfem::MemoryClass::CUDA))); - SWIG_Python_SetConstant(d, "MemoryClass_CUDA_UVM",SWIG_From_int(static_cast< int >(mfem::MemoryClass::CUDA_UVM))); + SWIG_Python_SetConstant(d, "MemoryType_HOST_DEBUG",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_DEBUG))); + SWIG_Python_SetConstant(d, "MemoryType_HOST_UMPIRE",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_UMPIRE))); + SWIG_Python_SetConstant(d, "MemoryType_MANAGED",SWIG_From_int(static_cast< int >(mfem::MemoryType::MANAGED))); + SWIG_Python_SetConstant(d, "MemoryType_DEVICE",SWIG_From_int(static_cast< int >(mfem::MemoryType::DEVICE))); + SWIG_Python_SetConstant(d, "MemoryType_DEVICE_DEBUG",SWIG_From_int(static_cast< int >(mfem::MemoryType::DEVICE_DEBUG))); + SWIG_Python_SetConstant(d, "MemoryType_DEVICE_UMPIRE",SWIG_From_int(static_cast< int >(mfem::MemoryType::DEVICE_UMPIRE))); + SWIG_Python_SetConstant(d, "MemoryType_SIZE",SWIG_From_int(static_cast< int >(mfem::MemoryType::SIZE))); globals = SWIG_globals(); if (!globals) { PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals."); @@ -4204,6 +4792,17 @@ SWIG_init(void) { } PyDict_SetItemString(md, "cvar", globals); Py_DECREF(globals); + SWIG_addvarlink(globals, "MemoryTypeSize", Swig_var_MemoryTypeSize_get, Swig_var_MemoryTypeSize_set); + SWIG_addvarlink(globals, "HostMemoryType", Swig_var_HostMemoryType_get, Swig_var_HostMemoryType_set); + SWIG_addvarlink(globals, "HostMemoryTypeSize", Swig_var_HostMemoryTypeSize_get, Swig_var_HostMemoryTypeSize_set); + SWIG_addvarlink(globals, "DeviceMemoryType", Swig_var_DeviceMemoryType_get, Swig_var_DeviceMemoryType_set); + SWIG_addvarlink(globals, "DeviceMemoryTypeSize", Swig_var_DeviceMemoryTypeSize_get, Swig_var_DeviceMemoryTypeSize_set); + SWIG_addvarlink(globals, "MemoryTypeName", Swig_var_MemoryTypeName_get, Swig_var_MemoryTypeName_set); + SWIG_Python_SetConstant(d, "MemoryClass_HOST",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST))); + SWIG_Python_SetConstant(d, "MemoryClass_HOST_32",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_32))); + SWIG_Python_SetConstant(d, "MemoryClass_HOST_64",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_64))); + SWIG_Python_SetConstant(d, "MemoryClass_DEVICE",SWIG_From_int(static_cast< int >(mfem::MemoryClass::DEVICE))); + SWIG_Python_SetConstant(d, "MemoryClass_MANAGED",SWIG_From_int(static_cast< int >(mfem::MemoryClass::MANAGED))); SWIG_addvarlink(globals, "mm", Swig_var_mm_get, Swig_var_mm_set); #if PY_VERSION_HEX >= 0x03000000 return m; diff --git a/mfem/_par/mesh.i b/mfem/_par/mesh.i index 0cc6e204..66947023 100644 --- a/mfem/_par/mesh.i +++ b/mfem/_par/mesh.i @@ -31,6 +31,7 @@ import_array(); %import "array.i" %import "ncmesh.i" %import "vector.i" +%import "vtk.i" %import "element.i" %import "vertex.i" %import "gridfunc.i" diff --git a/mfem/_par/mesh.py b/mfem/_par/mesh.py index 7587d014..46d5d738 100644 --- a/mfem/_par/mesh.py +++ b/mfem/_par/mesh.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _mesh.SWIG_PyInstanceMethod_New +_swig_new_static_method = _mesh.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -69,6 +72,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.mem_manager import mfem._par.operators import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.densemat import mfem._par.geom @@ -86,8 +90,13 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform +FaceType_Interior = _mesh.FaceType_Interior + +FaceType_Boundary = _mesh.FaceType_Boundary + class Mesh(object): r"""Proxy of C++ mfem::Mesh class.""" @@ -106,183 +115,248 @@ class Mesh(object): NURBSext = property(_mesh.Mesh_NURBSext_get, _mesh.Mesh_NURBSext_set, doc=r"""NURBSext : p.mfem::NURBSExtension""") ncmesh = property(_mesh.Mesh_ncmesh_get, _mesh.Mesh_ncmesh_set, doc=r"""ncmesh : p.mfem::NCMesh""") geom_factors = property(_mesh.Mesh_geom_factors_get, _mesh.Mesh_geom_factors_set, doc=r"""geom_factors : mfem::Array<(p.mfem::GeometricFactors)>""") + face_geom_factors = property(_mesh.Mesh_face_geom_factors_get, _mesh.Mesh_face_geom_factors_set, doc=r"""face_geom_factors : mfem::Array<(p.mfem::FaceGeometricFactors)>""") remove_unused_vertices = property(_mesh.Mesh_remove_unused_vertices_get, _mesh.Mesh_remove_unused_vertices_set, doc=r"""remove_unused_vertices : bool""") def NewElement(self, geom): r"""NewElement(Mesh self, int geom) -> Element""" return _mesh.Mesh_NewElement(self, geom) + NewElement = _swig_new_instance_method(_mesh.Mesh_NewElement) def AddVertex(self, arg2): r"""AddVertex(Mesh self, double const * arg2)""" return _mesh.Mesh_AddVertex(self, arg2) + AddVertex = _swig_new_instance_method(_mesh.Mesh_AddVertex) + + def AddSegment(self, vi, attr=1): + r"""AddSegment(Mesh self, int const * vi, int attr=1)""" + return _mesh.Mesh_AddSegment(self, vi, attr) + AddSegment = _swig_new_instance_method(_mesh.Mesh_AddSegment) def AddTri(self, vi, attr=1): r"""AddTri(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddTri(self, vi, attr) + AddTri = _swig_new_instance_method(_mesh.Mesh_AddTri) def AddTriangle(self, vi, attr=1): r"""AddTriangle(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddTriangle(self, vi, attr) + AddTriangle = _swig_new_instance_method(_mesh.Mesh_AddTriangle) def AddQuad(self, vi, attr=1): r"""AddQuad(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddQuad(self, vi, attr) + AddQuad = _swig_new_instance_method(_mesh.Mesh_AddQuad) def AddTet(self, vi, attr=1): r"""AddTet(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddTet(self, vi, attr) + AddTet = _swig_new_instance_method(_mesh.Mesh_AddTet) def AddWedge(self, vi, attr=1): r"""AddWedge(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddWedge(self, vi, attr) + AddWedge = _swig_new_instance_method(_mesh.Mesh_AddWedge) def AddHex(self, vi, attr=1): r"""AddHex(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddHex(self, vi, attr) + AddHex = _swig_new_instance_method(_mesh.Mesh_AddHex) def AddHexAsTets(self, vi, attr=1): r"""AddHexAsTets(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddHexAsTets(self, vi, attr) + AddHexAsTets = _swig_new_instance_method(_mesh.Mesh_AddHexAsTets) def AddHexAsWedges(self, vi, attr=1): r"""AddHexAsWedges(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddHexAsWedges(self, vi, attr) + AddHexAsWedges = _swig_new_instance_method(_mesh.Mesh_AddHexAsWedges) def AddElement(self, elem): r"""AddElement(Mesh self, Element elem)""" return _mesh.Mesh_AddElement(self, elem) + AddElement = _swig_new_instance_method(_mesh.Mesh_AddElement) def AddBdrElement(self, elem): r"""AddBdrElement(Mesh self, Element elem)""" return _mesh.Mesh_AddBdrElement(self, elem) + AddBdrElement = _swig_new_instance_method(_mesh.Mesh_AddBdrElement) def AddBdrSegment(self, vi, attr=1): r"""AddBdrSegment(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrSegment(self, vi, attr) + AddBdrSegment = _swig_new_instance_method(_mesh.Mesh_AddBdrSegment) def AddBdrTriangle(self, vi, attr=1): r"""AddBdrTriangle(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrTriangle(self, vi, attr) + AddBdrTriangle = _swig_new_instance_method(_mesh.Mesh_AddBdrTriangle) def AddBdrQuad(self, vi, attr=1): r"""AddBdrQuad(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrQuad(self, vi, attr) + AddBdrQuad = _swig_new_instance_method(_mesh.Mesh_AddBdrQuad) def AddBdrQuadAsTriangles(self, vi, attr=1): r"""AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrQuadAsTriangles(self, vi, attr) + AddBdrQuadAsTriangles = _swig_new_instance_method(_mesh.Mesh_AddBdrQuadAsTriangles) def GenerateBoundaryElements(self): r"""GenerateBoundaryElements(Mesh self)""" return _mesh.Mesh_GenerateBoundaryElements(self) + GenerateBoundaryElements = _swig_new_instance_method(_mesh.Mesh_GenerateBoundaryElements) def FinalizeTriMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeTriMesh(self, generate_edges, refine, fix_orientation) + FinalizeTriMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeTriMesh) def FinalizeQuadMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeQuadMesh(self, generate_edges, refine, fix_orientation) + FinalizeQuadMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeQuadMesh) def FinalizeTetMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeTetMesh(self, generate_edges, refine, fix_orientation) + FinalizeTetMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeTetMesh) def FinalizeWedgeMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeWedgeMesh(self, generate_edges, refine, fix_orientation) + FinalizeWedgeMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeWedgeMesh) def FinalizeHexMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeHexMesh(self, generate_edges, refine, fix_orientation) + FinalizeHexMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeHexMesh) def FinalizeMesh(self, refine=0, fix_orientation=True): r"""FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeMesh(self, refine, fix_orientation) + FinalizeMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeMesh) - def FinalizeTopology(self): - r"""FinalizeTopology(Mesh self)""" - return _mesh.Mesh_FinalizeTopology(self) + def FinalizeTopology(self, generate_bdr=True): + r"""FinalizeTopology(Mesh self, bool generate_bdr=True)""" + return _mesh.Mesh_FinalizeTopology(self, generate_bdr) + FinalizeTopology = _swig_new_instance_method(_mesh.Mesh_FinalizeTopology) def Finalize(self, refine=False, fix_orientation=False): r"""Finalize(Mesh self, bool refine=False, bool fix_orientation=False)""" return _mesh.Mesh_Finalize(self, refine, fix_orientation) + Finalize = _swig_new_instance_method(_mesh.Mesh_Finalize) def SetAttributes(self): r"""SetAttributes(Mesh self)""" return _mesh.Mesh_SetAttributes(self) + SetAttributes = _swig_new_instance_method(_mesh.Mesh_SetAttributes) + + def GetHilbertElementOrdering(self, ordering): + r"""GetHilbertElementOrdering(Mesh self, intArray ordering)""" + return _mesh.Mesh_GetHilbertElementOrdering(self, ordering) + GetHilbertElementOrdering = _swig_new_instance_method(_mesh.Mesh_GetHilbertElementOrdering) def ReorderElements(self, ordering, reorder_vertices=True): r"""ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)""" return _mesh.Mesh_ReorderElements(self, ordering, reorder_vertices) + ReorderElements = _swig_new_instance_method(_mesh.Mesh_ReorderElements) def Load(self, input, generate_edges=0, refine=1, fix_orientation=True): r"""Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)""" return _mesh.Mesh_Load(self, input, generate_edges, refine, fix_orientation) + Load = _swig_new_instance_method(_mesh.Mesh_Load) def Clear(self): r"""Clear(Mesh self)""" return _mesh.Mesh_Clear(self) + Clear = _swig_new_instance_method(_mesh.Mesh_Clear) def MeshGenerator(self): r"""MeshGenerator(Mesh self) -> int""" return _mesh.Mesh_MeshGenerator(self) + MeshGenerator = _swig_new_instance_method(_mesh.Mesh_MeshGenerator) def GetNV(self): r"""GetNV(Mesh self) -> int""" return _mesh.Mesh_GetNV(self) + GetNV = _swig_new_instance_method(_mesh.Mesh_GetNV) def GetNE(self): r"""GetNE(Mesh self) -> int""" return _mesh.Mesh_GetNE(self) + GetNE = _swig_new_instance_method(_mesh.Mesh_GetNE) def GetNBE(self): r"""GetNBE(Mesh self) -> int""" return _mesh.Mesh_GetNBE(self) + GetNBE = _swig_new_instance_method(_mesh.Mesh_GetNBE) def GetNEdges(self): r"""GetNEdges(Mesh self) -> int""" return _mesh.Mesh_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_mesh.Mesh_GetNEdges) def GetNFaces(self): r"""GetNFaces(Mesh self) -> int""" return _mesh.Mesh_GetNFaces(self) + GetNFaces = _swig_new_instance_method(_mesh.Mesh_GetNFaces) def GetNumFaces(self): r"""GetNumFaces(Mesh self) -> int""" return _mesh.Mesh_GetNumFaces(self) + GetNumFaces = _swig_new_instance_method(_mesh.Mesh_GetNumFaces) + + def GetNFbyType(self, type): + r"""GetNFbyType(Mesh self, mfem::FaceType type) -> int""" + return _mesh.Mesh_GetNFbyType(self, type) + GetNFbyType = _swig_new_instance_method(_mesh.Mesh_GetNFbyType) def ReduceInt(self, value): r"""ReduceInt(Mesh self, int value) -> long""" return _mesh.Mesh_ReduceInt(self, value) + ReduceInt = _swig_new_instance_method(_mesh.Mesh_ReduceInt) def GetGlobalNE(self): r"""GetGlobalNE(Mesh self) -> long""" return _mesh.Mesh_GetGlobalNE(self) + GetGlobalNE = _swig_new_instance_method(_mesh.Mesh_GetGlobalNE) def GetGeometricFactors(self, ir, flags): r"""GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors""" return _mesh.Mesh_GetGeometricFactors(self, ir, flags) + GetGeometricFactors = _swig_new_instance_method(_mesh.Mesh_GetGeometricFactors) + + def GetFaceGeometricFactors(self, ir, flags, type): + r"""GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors""" + return _mesh.Mesh_GetFaceGeometricFactors(self, ir, flags, type) + GetFaceGeometricFactors = _swig_new_instance_method(_mesh.Mesh_GetFaceGeometricFactors) def DeleteGeometricFactors(self): r"""DeleteGeometricFactors(Mesh self)""" return _mesh.Mesh_DeleteGeometricFactors(self) + DeleteGeometricFactors = _swig_new_instance_method(_mesh.Mesh_DeleteGeometricFactors) def EulerNumber(self): r"""EulerNumber(Mesh self) -> int""" return _mesh.Mesh_EulerNumber(self) + EulerNumber = _swig_new_instance_method(_mesh.Mesh_EulerNumber) def EulerNumber2D(self): r"""EulerNumber2D(Mesh self) -> int""" return _mesh.Mesh_EulerNumber2D(self) + EulerNumber2D = _swig_new_instance_method(_mesh.Mesh_EulerNumber2D) def Dimension(self): r"""Dimension(Mesh self) -> int""" return _mesh.Mesh_Dimension(self) + Dimension = _swig_new_instance_method(_mesh.Mesh_Dimension) def SpaceDimension(self): r"""SpaceDimension(Mesh self) -> int""" return _mesh.Mesh_SpaceDimension(self) + SpaceDimension = _swig_new_instance_method(_mesh.Mesh_SpaceDimension) def GetVertex(self, *args): r""" @@ -290,22 +364,27 @@ def GetVertex(self, *args): GetVertex(Mesh self, int i) -> double * """ return _mesh.Mesh_GetVertex(self, *args) + GetVertex = _swig_new_instance_method(_mesh.Mesh_GetVertex) def GetElementData(self, geom, elem_vtx, attr): r"""GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)""" return _mesh.Mesh_GetElementData(self, geom, elem_vtx, attr) + GetElementData = _swig_new_instance_method(_mesh.Mesh_GetElementData) def GetBdrElementData(self, geom, bdr_elem_vtx, bdr_attr): r"""GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)""" return _mesh.Mesh_GetBdrElementData(self, geom, bdr_elem_vtx, bdr_attr) + GetBdrElementData = _swig_new_instance_method(_mesh.Mesh_GetBdrElementData) def ChangeVertexDataOwnership(self, vertices, len_vertices, zerocopy=False): r"""ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)""" return _mesh.Mesh_ChangeVertexDataOwnership(self, vertices, len_vertices, zerocopy) + ChangeVertexDataOwnership = _swig_new_instance_method(_mesh.Mesh_ChangeVertexDataOwnership) def GetElementsArray(self): r"""GetElementsArray(Mesh self) -> mfem::Element const *const *""" return _mesh.Mesh_GetElementsArray(self) + GetElementsArray = _swig_new_instance_method(_mesh.Mesh_GetElementsArray) def GetElement(self, *args): r""" @@ -313,6 +392,7 @@ def GetElement(self, *args): GetElement(Mesh self, int i) -> Element """ return _mesh.Mesh_GetElement(self, *args) + GetElement = _swig_new_instance_method(_mesh.Mesh_GetElement) def GetBdrElement(self, *args): r""" @@ -320,34 +400,42 @@ def GetBdrElement(self, *args): GetBdrElement(Mesh self, int i) -> Element """ return _mesh.Mesh_GetBdrElement(self, *args) + GetBdrElement = _swig_new_instance_method(_mesh.Mesh_GetBdrElement) def GetFace(self, i): r"""GetFace(Mesh self, int i) -> Element""" return _mesh.Mesh_GetFace(self, i) + GetFace = _swig_new_instance_method(_mesh.Mesh_GetFace) def GetFaceBaseGeometry(self, i): r"""GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type""" return _mesh.Mesh_GetFaceBaseGeometry(self, i) + GetFaceBaseGeometry = _swig_new_instance_method(_mesh.Mesh_GetFaceBaseGeometry) def GetElementBaseGeometry(self, i): r"""GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type""" return _mesh.Mesh_GetElementBaseGeometry(self, i) + GetElementBaseGeometry = _swig_new_instance_method(_mesh.Mesh_GetElementBaseGeometry) def GetBdrElementBaseGeometry(self, i): r"""GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type""" return _mesh.Mesh_GetBdrElementBaseGeometry(self, i) + GetBdrElementBaseGeometry = _swig_new_instance_method(_mesh.Mesh_GetBdrElementBaseGeometry) def HasGeometry(self, geom): r"""HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool""" return _mesh.Mesh_HasGeometry(self, geom) + HasGeometry = _swig_new_instance_method(_mesh.Mesh_HasGeometry) def GetNumGeometries(self, dim): r"""GetNumGeometries(Mesh self, int dim) -> int""" return _mesh.Mesh_GetNumGeometries(self, dim) + GetNumGeometries = _swig_new_instance_method(_mesh.Mesh_GetNumGeometries) def GetGeometries(self, dim, el_geoms): r"""GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)""" return _mesh.Mesh_GetGeometries(self, dim, el_geoms) + GetGeometries = _swig_new_instance_method(_mesh.Mesh_GetGeometries) def GetElementVertices(self, i): from .array import intArray @@ -411,10 +499,12 @@ def GetEdgeVertices(self, i): def GetFaceEdgeTable(self): r"""GetFaceEdgeTable(Mesh self) -> Table""" return _mesh.Mesh_GetFaceEdgeTable(self) + GetFaceEdgeTable = _swig_new_instance_method(_mesh.Mesh_GetFaceEdgeTable) def GetEdgeVertexTable(self): r"""GetEdgeVertexTable(Mesh self) -> Table""" return _mesh.Mesh_GetEdgeVertexTable(self) + GetEdgeVertexTable = _swig_new_instance_method(_mesh.Mesh_GetEdgeVertexTable) def GetElementFaces(self, i): from .array import intArray @@ -428,6 +518,7 @@ def GetElementFaces(self, i): def GetBdrElementEdgeIndex(self, i): r"""GetBdrElementEdgeIndex(Mesh self, int i) -> int""" return _mesh.Mesh_GetBdrElementEdgeIndex(self, i) + GetBdrElementEdgeIndex = _swig_new_instance_method(_mesh.Mesh_GetBdrElementEdgeIndex) def GetBdrElementAdjacentElement(self, bdr_el): from mfem._par import intp @@ -441,23 +532,28 @@ def GetBdrElementAdjacentElement(self, bdr_el): def GetElementType(self, i): r"""GetElementType(Mesh self, int i) -> mfem::Element::Type""" return _mesh.Mesh_GetElementType(self, i) + GetElementType = _swig_new_instance_method(_mesh.Mesh_GetElementType) def GetBdrElementType(self, i): r"""GetBdrElementType(Mesh self, int i) -> mfem::Element::Type""" return _mesh.Mesh_GetBdrElementType(self, i) + GetBdrElementType = _swig_new_instance_method(_mesh.Mesh_GetBdrElementType) def GetPointMatrix(self, i, pointmat): r"""GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)""" return _mesh.Mesh_GetPointMatrix(self, i, pointmat) + GetPointMatrix = _swig_new_instance_method(_mesh.Mesh_GetPointMatrix) def GetBdrPointMatrix(self, i, pointmat): r"""GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)""" return _mesh.Mesh_GetBdrPointMatrix(self, i, pointmat) + GetBdrPointMatrix = _swig_new_instance_method(_mesh.Mesh_GetBdrPointMatrix) @staticmethod def GetTransformationFEforElementType(arg1): r"""GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement""" return _mesh.Mesh_GetTransformationFEforElementType(arg1) + GetTransformationFEforElementType = _swig_new_static_method(_mesh.Mesh_GetTransformationFEforElementType) def GetElementTransformation(self, i): from mfem.par import IsoparametricTransformation @@ -478,6 +574,7 @@ def GetBdrElementTransformation(self, i): def GetLocalFaceTransformation(self, face_type, elem_type, Transf, info): r"""GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)""" return _mesh.Mesh_GetLocalFaceTransformation(self, face_type, elem_type, Transf, info) + GetLocalFaceTransformation = _swig_new_instance_method(_mesh.Mesh_GetLocalFaceTransformation) def GetFaceTransformation(self, i): from mfem.par import IsoparametricTransformation @@ -498,18 +595,22 @@ def GetEdgeTransformation(self, i): def GetFaceElementTransformations(self, FaceNo, mask=31): r"""GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations""" return _mesh.Mesh_GetFaceElementTransformations(self, FaceNo, mask) + GetFaceElementTransformations = _swig_new_instance_method(_mesh.Mesh_GetFaceElementTransformations) def GetInteriorFaceTransformations(self, FaceNo): r"""GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations""" return _mesh.Mesh_GetInteriorFaceTransformations(self, FaceNo) + GetInteriorFaceTransformations = _swig_new_instance_method(_mesh.Mesh_GetInteriorFaceTransformations) def GetBdrFaceTransformations(self, BdrElemNo): r"""GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations""" return _mesh.Mesh_GetBdrFaceTransformations(self, BdrElemNo) + GetBdrFaceTransformations = _swig_new_instance_method(_mesh.Mesh_GetBdrFaceTransformations) def FaceIsInterior(self, FaceNo): r"""FaceIsInterior(Mesh self, int FaceNo) -> bool""" return _mesh.Mesh_FaceIsInterior(self, FaceNo) + FaceIsInterior = _swig_new_instance_method(_mesh.Mesh_FaceIsInterior) def GetFaceElements(self, Face): from mfem.par import intp @@ -523,118 +624,147 @@ def GetFaceElements(self, Face): def GetFaceInfos(self, Face, Inf1, Inf2): r"""GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)""" return _mesh.Mesh_GetFaceInfos(self, Face, Inf1, Inf2) + GetFaceInfos = _swig_new_instance_method(_mesh.Mesh_GetFaceInfos) def GetFaceGeometryType(self, Face): r"""GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type""" return _mesh.Mesh_GetFaceGeometryType(self, Face) + GetFaceGeometryType = _swig_new_instance_method(_mesh.Mesh_GetFaceGeometryType) def GetFaceElementType(self, Face): r"""GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type""" return _mesh.Mesh_GetFaceElementType(self, Face) + GetFaceElementType = _swig_new_instance_method(_mesh.Mesh_GetFaceElementType) def CheckElementOrientation(self, fix_it=True): r"""CheckElementOrientation(Mesh self, bool fix_it=True) -> int""" return _mesh.Mesh_CheckElementOrientation(self, fix_it) + CheckElementOrientation = _swig_new_instance_method(_mesh.Mesh_CheckElementOrientation) def CheckBdrElementOrientation(self, fix_it=True): r"""CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int""" return _mesh.Mesh_CheckBdrElementOrientation(self, fix_it) + CheckBdrElementOrientation = _swig_new_instance_method(_mesh.Mesh_CheckBdrElementOrientation) def GetAttribute(self, i): r"""GetAttribute(Mesh self, int i) -> int""" return _mesh.Mesh_GetAttribute(self, i) + GetAttribute = _swig_new_instance_method(_mesh.Mesh_GetAttribute) def SetAttribute(self, i, attr): r"""SetAttribute(Mesh self, int i, int attr)""" return _mesh.Mesh_SetAttribute(self, i, attr) + SetAttribute = _swig_new_instance_method(_mesh.Mesh_SetAttribute) def GetBdrAttribute(self, i): r"""GetBdrAttribute(Mesh self, int i) -> int""" return _mesh.Mesh_GetBdrAttribute(self, i) + GetBdrAttribute = _swig_new_instance_method(_mesh.Mesh_GetBdrAttribute) def ElementToElementTable(self): r"""ElementToElementTable(Mesh self) -> Table""" return _mesh.Mesh_ElementToElementTable(self) + ElementToElementTable = _swig_new_instance_method(_mesh.Mesh_ElementToElementTable) def ElementToFaceTable(self): r"""ElementToFaceTable(Mesh self) -> Table""" return _mesh.Mesh_ElementToFaceTable(self) + ElementToFaceTable = _swig_new_instance_method(_mesh.Mesh_ElementToFaceTable) def ElementToEdgeTable(self): r"""ElementToEdgeTable(Mesh self) -> Table""" return _mesh.Mesh_ElementToEdgeTable(self) + ElementToEdgeTable = _swig_new_instance_method(_mesh.Mesh_ElementToEdgeTable) def GetVertexToElementTable(self): r"""GetVertexToElementTable(Mesh self) -> Table""" return _mesh.Mesh_GetVertexToElementTable(self) + GetVertexToElementTable = _swig_new_instance_method(_mesh.Mesh_GetVertexToElementTable) def GetFaceToElementTable(self): r"""GetFaceToElementTable(Mesh self) -> Table""" return _mesh.Mesh_GetFaceToElementTable(self) + GetFaceToElementTable = _swig_new_instance_method(_mesh.Mesh_GetFaceToElementTable) def ReorientTetMesh(self): r"""ReorientTetMesh(Mesh self)""" return _mesh.Mesh_ReorientTetMesh(self) + ReorientTetMesh = _swig_new_instance_method(_mesh.Mesh_ReorientTetMesh) def CartesianPartitioning(self, nxyz): r"""CartesianPartitioning(Mesh self, int [] nxyz) -> int *""" return _mesh.Mesh_CartesianPartitioning(self, nxyz) + CartesianPartitioning = _swig_new_instance_method(_mesh.Mesh_CartesianPartitioning) def GeneratePartitioning(self, nparts, part_method=1): r"""GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int""" return _mesh.Mesh_GeneratePartitioning(self, nparts, part_method) + GeneratePartitioning = _swig_new_instance_method(_mesh.Mesh_GeneratePartitioning) def CheckPartitioning(self, partitioning): r"""CheckPartitioning(Mesh self, int * partitioning)""" return _mesh.Mesh_CheckPartitioning(self, partitioning) + CheckPartitioning = _swig_new_instance_method(_mesh.Mesh_CheckPartitioning) def CheckDisplacements(self, displacements, tmax): r"""CheckDisplacements(Mesh self, Vector displacements, double & tmax)""" return _mesh.Mesh_CheckDisplacements(self, displacements, tmax) + CheckDisplacements = _swig_new_instance_method(_mesh.Mesh_CheckDisplacements) def MoveVertices(self, displacements): r"""MoveVertices(Mesh self, Vector displacements)""" return _mesh.Mesh_MoveVertices(self, displacements) + MoveVertices = _swig_new_instance_method(_mesh.Mesh_MoveVertices) def GetVertices(self, vert_coord): r"""GetVertices(Mesh self, Vector vert_coord)""" return _mesh.Mesh_GetVertices(self, vert_coord) + GetVertices = _swig_new_instance_method(_mesh.Mesh_GetVertices) def SetVertices(self, vert_coord): r"""SetVertices(Mesh self, Vector vert_coord)""" return _mesh.Mesh_SetVertices(self, vert_coord) + SetVertices = _swig_new_instance_method(_mesh.Mesh_SetVertices) def GetNode(self, i, coord): r"""GetNode(Mesh self, int i, double * coord)""" return _mesh.Mesh_GetNode(self, i, coord) + GetNode = _swig_new_instance_method(_mesh.Mesh_GetNode) def SetNode(self, i, coord): r"""SetNode(Mesh self, int i, double const * coord)""" return _mesh.Mesh_SetNode(self, i, coord) + SetNode = _swig_new_instance_method(_mesh.Mesh_SetNode) def MoveNodes(self, displacements): r"""MoveNodes(Mesh self, Vector displacements)""" return _mesh.Mesh_MoveNodes(self, displacements) + MoveNodes = _swig_new_instance_method(_mesh.Mesh_MoveNodes) def SetNodes(self, node_coord): r"""SetNodes(Mesh self, Vector node_coord)""" return _mesh.Mesh_SetNodes(self, node_coord) + SetNodes = _swig_new_instance_method(_mesh.Mesh_SetNodes) def OwnsNodes(self): r"""OwnsNodes(Mesh self) -> bool""" return _mesh.Mesh_OwnsNodes(self) + OwnsNodes = _swig_new_instance_method(_mesh.Mesh_OwnsNodes) def SetNodesOwner(self, nodes_owner): r"""SetNodesOwner(Mesh self, bool nodes_owner)""" return _mesh.Mesh_SetNodesOwner(self, nodes_owner) + SetNodesOwner = _swig_new_instance_method(_mesh.Mesh_SetNodesOwner) def NewNodes(self, nodes, make_owner=False): r"""NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)""" return _mesh.Mesh_NewNodes(self, nodes, make_owner) + NewNodes = _swig_new_instance_method(_mesh.Mesh_NewNodes) def SwapNodes(self, nodes, own_nodes_): r"""SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)""" return _mesh.Mesh_SwapNodes(self, nodes, own_nodes_) + SwapNodes = _swig_new_instance_method(_mesh.Mesh_SwapNodes) def GetNodes(self, *args): r""" @@ -644,30 +774,37 @@ def GetNodes(self, *args): GetNodes(Mesh self, GridFunction nodes) """ return _mesh.Mesh_GetNodes(self, *args) + GetNodes = _swig_new_instance_method(_mesh.Mesh_GetNodes) def SetNodalFESpace(self, nfes): r"""SetNodalFESpace(Mesh self, FiniteElementSpace nfes)""" return _mesh.Mesh_SetNodalFESpace(self, nfes) + SetNodalFESpace = _swig_new_instance_method(_mesh.Mesh_SetNodalFESpace) def SetNodalGridFunction(self, nodes, make_owner=False): r"""SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)""" return _mesh.Mesh_SetNodalGridFunction(self, nodes, make_owner) + SetNodalGridFunction = _swig_new_instance_method(_mesh.Mesh_SetNodalGridFunction) def GetNodalFESpace(self): r"""GetNodalFESpace(Mesh self) -> FiniteElementSpace""" return _mesh.Mesh_GetNodalFESpace(self) + GetNodalFESpace = _swig_new_instance_method(_mesh.Mesh_GetNodalFESpace) def EnsureNodes(self): r"""EnsureNodes(Mesh self)""" return _mesh.Mesh_EnsureNodes(self) + EnsureNodes = _swig_new_instance_method(_mesh.Mesh_EnsureNodes) def SetCurvature(self, order, discont=False, space_dim=-1, ordering=1): r"""SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)""" return _mesh.Mesh_SetCurvature(self, order, discont, space_dim, ordering) + SetCurvature = _swig_new_instance_method(_mesh.Mesh_SetCurvature) def UniformRefinement(self, ref_algo=0): r"""UniformRefinement(Mesh self, int ref_algo=0)""" return _mesh.Mesh_UniformRefinement(self, ref_algo) + UniformRefinement = _swig_new_instance_method(_mesh.Mesh_UniformRefinement) def GeneralRefinement(self, *args): r""" @@ -675,14 +812,17 @@ def GeneralRefinement(self, *args): GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0) """ return _mesh.Mesh_GeneralRefinement(self, *args) + GeneralRefinement = _swig_new_instance_method(_mesh.Mesh_GeneralRefinement) def RandomRefinement(self, prob, aniso=False, nonconforming=-1, nc_limit=0): r"""RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)""" return _mesh.Mesh_RandomRefinement(self, prob, aniso, nonconforming, nc_limit) + RandomRefinement = _swig_new_instance_method(_mesh.Mesh_RandomRefinement) def RefineAtVertex(self, vert, eps=0.0, nonconforming=-1): r"""RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)""" return _mesh.Mesh_RefineAtVertex(self, vert, eps, nonconforming) + RefineAtVertex = _swig_new_instance_method(_mesh.Mesh_RefineAtVertex) def RefineByError(self, *args): r""" @@ -690,6 +830,7 @@ def RefineByError(self, *args): RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool """ return _mesh.Mesh_RefineByError(self, *args) + RefineByError = _swig_new_instance_method(_mesh.Mesh_RefineByError) def DerefineByError(self, *args): r""" @@ -697,62 +838,88 @@ def DerefineByError(self, *args): DerefineByError(Mesh self, Vector elem_error, double threshold, int nc_limit=0, int op=1) -> bool """ return _mesh.Mesh_DerefineByError(self, *args) + DerefineByError = _swig_new_instance_method(_mesh.Mesh_DerefineByError) - def KnotInsert(self, kv): - r"""KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)""" - return _mesh.Mesh_KnotInsert(self, kv) + def KnotInsert(self, *args): + r""" + KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv) + KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv) + """ + return _mesh.Mesh_KnotInsert(self, *args) + KnotInsert = _swig_new_instance_method(_mesh.Mesh_KnotInsert) def DegreeElevate(self, rel_degree, degree=16): r"""DegreeElevate(Mesh self, int rel_degree, int degree=16)""" return _mesh.Mesh_DegreeElevate(self, rel_degree, degree) + DegreeElevate = _swig_new_instance_method(_mesh.Mesh_DegreeElevate) - def EnsureNCMesh(self, triangles_nonconforming=False): - r"""EnsureNCMesh(Mesh self, bool triangles_nonconforming=False)""" - return _mesh.Mesh_EnsureNCMesh(self, triangles_nonconforming) + def EnsureNCMesh(self, simplices_nonconforming=False): + r"""EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)""" + return _mesh.Mesh_EnsureNCMesh(self, simplices_nonconforming) + EnsureNCMesh = _swig_new_instance_method(_mesh.Mesh_EnsureNCMesh) def Conforming(self): r"""Conforming(Mesh self) -> bool""" return _mesh.Mesh_Conforming(self) + Conforming = _swig_new_instance_method(_mesh.Mesh_Conforming) def Nonconforming(self): r"""Nonconforming(Mesh self) -> bool""" return _mesh.Mesh_Nonconforming(self) + Nonconforming = _swig_new_instance_method(_mesh.Mesh_Nonconforming) def GetRefinementTransforms(self): r"""GetRefinementTransforms(Mesh self) -> CoarseFineTransformations""" return _mesh.Mesh_GetRefinementTransforms(self) + GetRefinementTransforms = _swig_new_instance_method(_mesh.Mesh_GetRefinementTransforms) def GetLastOperation(self): r"""GetLastOperation(Mesh self) -> mfem::Mesh::Operation""" return _mesh.Mesh_GetLastOperation(self) + GetLastOperation = _swig_new_instance_method(_mesh.Mesh_GetLastOperation) def GetSequence(self): r"""GetSequence(Mesh self) -> long""" return _mesh.Mesh_GetSequence(self) + GetSequence = _swig_new_instance_method(_mesh.Mesh_GetSequence) + + def PrintVTU(self, *args): + r""" + PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0) + PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0) + """ + return _mesh.Mesh_PrintVTU(self, *args) + PrintVTU = _swig_new_instance_method(_mesh.Mesh_PrintVTU) def GetElementColoring(self, colors, el0=0): r"""GetElementColoring(Mesh self, intArray colors, int el0=0)""" return _mesh.Mesh_GetElementColoring(self, colors, el0) + GetElementColoring = _swig_new_instance_method(_mesh.Mesh_GetElementColoring) def PrintWithPartitioning(self, partitioning, out, elem_attr=0): r"""PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)""" return _mesh.Mesh_PrintWithPartitioning(self, partitioning, out, elem_attr) + PrintWithPartitioning = _swig_new_instance_method(_mesh.Mesh_PrintWithPartitioning) def PrintElementsWithPartitioning(self, partitioning, out, interior_faces=0): r"""PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)""" return _mesh.Mesh_PrintElementsWithPartitioning(self, partitioning, out, interior_faces) + PrintElementsWithPartitioning = _swig_new_instance_method(_mesh.Mesh_PrintElementsWithPartitioning) def PrintSurfaces(self, Aface_face, out): r"""PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)""" return _mesh.Mesh_PrintSurfaces(self, Aface_face, out) + PrintSurfaces = _swig_new_instance_method(_mesh.Mesh_PrintSurfaces) def ScaleSubdomains(self, sf): r"""ScaleSubdomains(Mesh self, double sf)""" return _mesh.Mesh_ScaleSubdomains(self, sf) + ScaleSubdomains = _swig_new_instance_method(_mesh.Mesh_ScaleSubdomains) def ScaleElements(self, sf): r"""ScaleElements(Mesh self, double sf)""" return _mesh.Mesh_ScaleElements(self, sf) + ScaleElements = _swig_new_instance_method(_mesh.Mesh_ScaleElements) def Transform(self, *args): r""" @@ -760,14 +927,17 @@ def Transform(self, *args): Transform(Mesh self, VectorCoefficient deformation) """ return _mesh.Mesh_Transform(self, *args) + Transform = _swig_new_instance_method(_mesh.Mesh_Transform) def RemoveUnusedVertices(self): r"""RemoveUnusedVertices(Mesh self)""" return _mesh.Mesh_RemoveUnusedVertices(self) + RemoveUnusedVertices = _swig_new_instance_method(_mesh.Mesh_RemoveUnusedVertices) def RemoveInternalBoundaries(self): r"""RemoveInternalBoundaries(Mesh self)""" return _mesh.Mesh_RemoveInternalBoundaries(self) + RemoveInternalBoundaries = _swig_new_instance_method(_mesh.Mesh_RemoveInternalBoundaries) def GetElementSize(self, *args): r""" @@ -775,10 +945,12 @@ def GetElementSize(self, *args): GetElementSize(Mesh self, int i, Vector dir) -> double """ return _mesh.Mesh_GetElementSize(self, *args) + GetElementSize = _swig_new_instance_method(_mesh.Mesh_GetElementSize) def GetElementVolume(self, i): r"""GetElementVolume(Mesh self, int i) -> double""" return _mesh.Mesh_GetElementVolume(self, i) + GetElementVolume = _swig_new_instance_method(_mesh.Mesh_GetElementVolume) def GetBoundingBox(self, ref = 2): from .vector import Vector @@ -792,19 +964,23 @@ def GetBoundingBox(self, ref = 2): def GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max, Vh=None, Vk=None): r"""GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)""" return _mesh.Mesh_GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max, Vh, Vk) + GetCharacteristics = _swig_new_instance_method(_mesh.Mesh_GetCharacteristics) @staticmethod def PrintElementsByGeometry(dim, num_elems_by_geom, out): r"""PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)""" return _mesh.Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out) + PrintElementsByGeometry = _swig_new_static_method(_mesh.Mesh_PrintElementsByGeometry) def PrintCharacteristics(self, *args): r"""PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)""" return _mesh.Mesh_PrintCharacteristics(self, *args) + PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) def FindPoints(self, point_mat, elem_ids, ips, warn=True, inv_trans=None): r"""FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int""" return _mesh.Mesh_FindPoints(self, point_mat, elem_ids, ips, warn, inv_trans) + FindPoints = _swig_new_instance_method(_mesh.Mesh_FindPoints) __swig_destroy__ = _mesh.delete_Mesh def __init__(self, *args): @@ -828,14 +1004,17 @@ def __init__(self, *args): def PrintToFile(self, mesh_file, precision): r"""PrintToFile(Mesh self, char const * mesh_file, int const precision)""" return _mesh.Mesh_PrintToFile(self, mesh_file, precision) + PrintToFile = _swig_new_instance_method(_mesh.Mesh_PrintToFile) def GetAttributeArray(self): r"""GetAttributeArray(Mesh self) -> PyObject *""" return _mesh.Mesh_GetAttributeArray(self) + GetAttributeArray = _swig_new_instance_method(_mesh.Mesh_GetAttributeArray) def GetVertexArray(self, i): r"""GetVertexArray(Mesh self, int i) -> PyObject *""" return _mesh.Mesh_GetVertexArray(self, i) + GetVertexArray = _swig_new_instance_method(_mesh.Mesh_GetVertexArray) def GetBdrElementFace(self, *args): r""" @@ -843,18 +1022,22 @@ def GetBdrElementFace(self, *args): GetBdrElementFace(Mesh self, int i) -> PyObject * """ return _mesh.Mesh_GetBdrElementFace(self, *args) + GetBdrElementFace = _swig_new_instance_method(_mesh.Mesh_GetBdrElementFace) def GetBdrAttributeArray(self): r"""GetBdrAttributeArray(Mesh self) -> PyObject *""" return _mesh.Mesh_GetBdrAttributeArray(self) + GetBdrAttributeArray = _swig_new_instance_method(_mesh.Mesh_GetBdrAttributeArray) def GetBdrArray(self, idx): r"""GetBdrArray(Mesh self, int idx) -> PyObject *""" return _mesh.Mesh_GetBdrArray(self, idx) + GetBdrArray = _swig_new_instance_method(_mesh.Mesh_GetBdrArray) def GetDomainArray(self, idx): r"""GetDomainArray(Mesh self, int idx) -> PyObject *""" return _mesh.Mesh_GetDomainArray(self, idx) + GetDomainArray = _swig_new_instance_method(_mesh.Mesh_GetDomainArray) def PrintInfo(self, *args): r""" @@ -862,6 +1045,7 @@ def PrintInfo(self, *args): PrintInfo(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_PrintInfo(self, *args) + PrintInfo = _swig_new_instance_method(_mesh.Mesh_PrintInfo) def Print(self, *args): r""" @@ -869,6 +1053,7 @@ def Print(self, *args): Print(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_Print(self, *args) + Print = _swig_new_instance_method(_mesh.Mesh_Print) def PrintXG(self, *args): r""" @@ -876,6 +1061,7 @@ def PrintXG(self, *args): PrintXG(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_PrintXG(self, *args) + PrintXG = _swig_new_instance_method(_mesh.Mesh_PrintXG) def PrintVTK(self, *args): r""" @@ -884,6 +1070,7 @@ def PrintVTK(self, *args): PrintVTK(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_PrintVTK(self, *args) + PrintVTK = _swig_new_instance_method(_mesh.Mesh_PrintVTK) # Register Mesh in _mesh: _mesh.Mesh_swigregister(Mesh) @@ -892,10 +1079,12 @@ def PrintVTK(self, *args): def Mesh_GetTransformationFEforElementType(arg1): r"""Mesh_GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement""" return _mesh.Mesh_GetTransformationFEforElementType(arg1) +Mesh_GetTransformationFEforElementType = _mesh.Mesh_GetTransformationFEforElementType def Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out): r"""Mesh_PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)""" return _mesh.Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out) +Mesh_PrintElementsByGeometry = _mesh.Mesh_PrintElementsByGeometry def __lshift__(*args): @@ -905,6 +1094,7 @@ def __lshift__(*args): __lshift__(std::ostream & out, Mesh mesh) -> std::ostream & """ return _mesh.__lshift__(*args) +__lshift__ = _mesh.__lshift__ class GeometricFactors(object): r"""Proxy of C++ mfem::GeometricFactors class.""" @@ -931,6 +1121,36 @@ def __init__(self, mesh, ir, flags): # Register GeometricFactors in _mesh: _mesh.GeometricFactors_swigregister(GeometricFactors) +class FaceGeometricFactors(object): + r"""Proxy of C++ mfem::FaceGeometricFactors class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + mesh = property(_mesh.FaceGeometricFactors_mesh_get, _mesh.FaceGeometricFactors_mesh_set, doc=r"""mesh : p.q(const).mfem::Mesh""") + IntRule = property(_mesh.FaceGeometricFactors_IntRule_get, _mesh.FaceGeometricFactors_IntRule_set, doc=r"""IntRule : p.q(const).mfem::IntegrationRule""") + computed_factors = property(_mesh.FaceGeometricFactors_computed_factors_get, _mesh.FaceGeometricFactors_computed_factors_set, doc=r"""computed_factors : int""") + type = property(_mesh.FaceGeometricFactors_type_get, _mesh.FaceGeometricFactors_type_set, doc=r"""type : mfem::FaceType""") + COORDINATES = _mesh.FaceGeometricFactors_COORDINATES + + JACOBIANS = _mesh.FaceGeometricFactors_JACOBIANS + + DETERMINANTS = _mesh.FaceGeometricFactors_DETERMINANTS + + NORMALS = _mesh.FaceGeometricFactors_NORMALS + + + def __init__(self, mesh, ir, flags, type): + r"""__init__(FaceGeometricFactors self, Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors""" + _mesh.FaceGeometricFactors_swiginit(self, _mesh.new_FaceGeometricFactors(mesh, ir, flags, type)) + X = property(_mesh.FaceGeometricFactors_X_get, _mesh.FaceGeometricFactors_X_set, doc=r"""X : mfem::Vector""") + J = property(_mesh.FaceGeometricFactors_J_get, _mesh.FaceGeometricFactors_J_set, doc=r"""J : mfem::Vector""") + detJ = property(_mesh.FaceGeometricFactors_detJ_get, _mesh.FaceGeometricFactors_detJ_set, doc=r"""detJ : mfem::Vector""") + normal = property(_mesh.FaceGeometricFactors_normal_get, _mesh.FaceGeometricFactors_normal_set, doc=r"""normal : mfem::Vector""") + __swig_destroy__ = _mesh.delete_FaceGeometricFactors + +# Register FaceGeometricFactors in _mesh: +_mesh.FaceGeometricFactors_swigregister(FaceGeometricFactors) + class NodeExtrudeCoefficient(mfem._par.coefficient.VectorCoefficient): r"""Proxy of C++ mfem::NodeExtrudeCoefficient class.""" @@ -943,6 +1163,7 @@ def __init__(self, *args, **kwargs): def SetLayer(self, l): r"""SetLayer(NodeExtrudeCoefficient self, int const l)""" return _mesh.NodeExtrudeCoefficient_SetLayer(self, l) + SetLayer = _swig_new_instance_method(_mesh.NodeExtrudeCoefficient_SetLayer) def Eval(self, *args): r""" @@ -951,6 +1172,7 @@ def Eval(self, *args): Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _mesh.NodeExtrudeCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_mesh.NodeExtrudeCoefficient_Eval) __swig_destroy__ = _mesh.delete_NodeExtrudeCoefficient # Register NodeExtrudeCoefficient in _mesh: @@ -960,24 +1182,16 @@ def Eval(self, *args): def Extrude1D(mesh, ny, sy, closed=False): r"""Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh""" return _mesh.Extrude1D(mesh, ny, sy, closed) +Extrude1D = _mesh.Extrude1D def Extrude2D(mesh, nz, sz): r"""Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh""" return _mesh.Extrude2D(mesh, nz, sz) -class named_ifgzstream(object): - r"""Proxy of C++ mfem::named_ifgzstream class.""" - - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") - __repr__ = _swig_repr - filename = property(_mesh.named_ifgzstream_filename_get, _mesh.named_ifgzstream_filename_set, doc=r"""filename : p.q(const).char""") - - def __init__(self, mesh_name): - r"""__init__(named_ifgzstream self, char const * mesh_name) -> named_ifgzstream""" - _mesh.named_ifgzstream_swiginit(self, _mesh.new_named_ifgzstream(mesh_name)) - __swig_destroy__ = _mesh.delete_named_ifgzstream - -# Register named_ifgzstream in _mesh: -_mesh.named_ifgzstream_swigregister(named_ifgzstream) +Extrude2D = _mesh.Extrude2D +def ShiftRight(a, b, c): + r"""ShiftRight(int & a, int & b, int & c)""" + return _mesh.ShiftRight(a, b, c) +ShiftRight = _mesh.ShiftRight diff --git a/mfem/_par/mesh_operators.py b/mfem/_par/mesh_operators.py index 4ec9cc73..64ad6eed 100644 --- a/mfem/_par/mesh_operators.py +++ b/mfem/_par/mesh_operators.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _mesh_operators.SWIG_PyInstanceMethod_New +_swig_new_static_method = _mesh_operators.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -70,6 +73,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.matrix import mfem._par.operators import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.densemat import mfem._par.geom @@ -87,6 +91,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform import mfem._par.estimators @@ -123,38 +128,47 @@ def __init__(self, *args, **kwargs): def Apply(self, mesh): r"""Apply(MeshOperator self, Mesh mesh) -> bool""" return _mesh_operators.MeshOperator_Apply(self, mesh) + Apply = _swig_new_instance_method(_mesh_operators.MeshOperator_Apply) def Stop(self): r"""Stop(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Stop(self) + Stop = _swig_new_instance_method(_mesh_operators.MeshOperator_Stop) def Repeat(self): r"""Repeat(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Repeat(self) + Repeat = _swig_new_instance_method(_mesh_operators.MeshOperator_Repeat) def Continue(self): r"""Continue(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Continue(self) + Continue = _swig_new_instance_method(_mesh_operators.MeshOperator_Continue) def Refined(self): r"""Refined(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Refined(self) + Refined = _swig_new_instance_method(_mesh_operators.MeshOperator_Refined) def Derefined(self): r"""Derefined(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Derefined(self) + Derefined = _swig_new_instance_method(_mesh_operators.MeshOperator_Derefined) def Rebalanced(self): r"""Rebalanced(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Rebalanced(self) + Rebalanced = _swig_new_instance_method(_mesh_operators.MeshOperator_Rebalanced) def GetActionInfo(self): r"""GetActionInfo(MeshOperator self) -> int""" return _mesh_operators.MeshOperator_GetActionInfo(self) + GetActionInfo = _swig_new_instance_method(_mesh_operators.MeshOperator_GetActionInfo) def Reset(self): r"""Reset(MeshOperator self)""" return _mesh_operators.MeshOperator_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.MeshOperator_Reset) __swig_destroy__ = _mesh_operators.delete_MeshOperator # Register MeshOperator in _mesh_operators: @@ -174,14 +188,17 @@ def __init__(self): def Append(self, mc): r"""Append(MeshOperatorSequence self, MeshOperator mc)""" return _mesh_operators.MeshOperatorSequence_Append(self, mc) + Append = _swig_new_instance_method(_mesh_operators.MeshOperatorSequence_Append) def GetSequence(self): r"""GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &""" return _mesh_operators.MeshOperatorSequence_GetSequence(self) + GetSequence = _swig_new_instance_method(_mesh_operators.MeshOperatorSequence_GetSequence) def Reset(self): r"""Reset(MeshOperatorSequence self)""" return _mesh_operators.MeshOperatorSequence_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.MeshOperatorSequence_Reset) # Register MeshOperatorSequence in _mesh_operators: _mesh_operators.MeshOperatorSequence_swigregister(MeshOperatorSequence) @@ -199,46 +216,57 @@ def __init__(self, est): def SetTotalErrorNormP(self, *args): r"""SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())""" return _mesh_operators.ThresholdRefiner_SetTotalErrorNormP(self, *args) + SetTotalErrorNormP = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorNormP) def SetTotalErrorGoal(self, err_goal): r"""SetTotalErrorGoal(ThresholdRefiner self, double err_goal)""" return _mesh_operators.ThresholdRefiner_SetTotalErrorGoal(self, err_goal) + SetTotalErrorGoal = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorGoal) def SetTotalErrorFraction(self, fraction): r"""SetTotalErrorFraction(ThresholdRefiner self, double fraction)""" return _mesh_operators.ThresholdRefiner_SetTotalErrorFraction(self, fraction) + SetTotalErrorFraction = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorFraction) def SetLocalErrorGoal(self, err_goal): r"""SetLocalErrorGoal(ThresholdRefiner self, double err_goal)""" return _mesh_operators.ThresholdRefiner_SetLocalErrorGoal(self, err_goal) + SetLocalErrorGoal = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetLocalErrorGoal) def SetMaxElements(self, max_elem): r"""SetMaxElements(ThresholdRefiner self, long max_elem)""" return _mesh_operators.ThresholdRefiner_SetMaxElements(self, max_elem) + SetMaxElements = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetMaxElements) def PreferNonconformingRefinement(self): r"""PreferNonconformingRefinement(ThresholdRefiner self)""" return _mesh_operators.ThresholdRefiner_PreferNonconformingRefinement(self) + PreferNonconformingRefinement = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_PreferNonconformingRefinement) def PreferConformingRefinement(self): r"""PreferConformingRefinement(ThresholdRefiner self)""" return _mesh_operators.ThresholdRefiner_PreferConformingRefinement(self) + PreferConformingRefinement = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_PreferConformingRefinement) def SetNCLimit(self, nc_limit): r"""SetNCLimit(ThresholdRefiner self, int nc_limit)""" return _mesh_operators.ThresholdRefiner_SetNCLimit(self, nc_limit) + SetNCLimit = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetNCLimit) def GetNumMarkedElements(self): r"""GetNumMarkedElements(ThresholdRefiner self) -> long""" return _mesh_operators.ThresholdRefiner_GetNumMarkedElements(self) + GetNumMarkedElements = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_GetNumMarkedElements) def GetThreshold(self): r"""GetThreshold(ThresholdRefiner self) -> double""" return _mesh_operators.ThresholdRefiner_GetThreshold(self) + GetThreshold = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_GetThreshold) def Reset(self): r"""Reset(ThresholdRefiner self)""" return _mesh_operators.ThresholdRefiner_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_Reset) __swig_destroy__ = _mesh_operators.delete_ThresholdRefiner # Register ThresholdRefiner in _mesh_operators: @@ -257,18 +285,22 @@ def __init__(self, est): def SetThreshold(self, thresh): r"""SetThreshold(ThresholdDerefiner self, double thresh)""" return _mesh_operators.ThresholdDerefiner_SetThreshold(self, thresh) + SetThreshold = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_SetThreshold) def SetOp(self, op): r"""SetOp(ThresholdDerefiner self, int op)""" return _mesh_operators.ThresholdDerefiner_SetOp(self, op) + SetOp = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_SetOp) def SetNCLimit(self, nc_limit): r"""SetNCLimit(ThresholdDerefiner self, int nc_limit)""" return _mesh_operators.ThresholdDerefiner_SetNCLimit(self, nc_limit) + SetNCLimit = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_SetNCLimit) def Reset(self): r"""Reset(ThresholdDerefiner self)""" return _mesh_operators.ThresholdDerefiner_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_Reset) __swig_destroy__ = _mesh_operators.delete_ThresholdDerefiner # Register ThresholdDerefiner in _mesh_operators: @@ -283,6 +315,7 @@ class Rebalancer(MeshOperator): def Reset(self): r"""Reset(Rebalancer self)""" return _mesh_operators.Rebalancer_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.Rebalancer_Reset) def __init__(self): r"""__init__(Rebalancer self) -> Rebalancer""" diff --git a/mfem/_par/mesh_operators_wrap.cxx b/mfem/_par/mesh_operators_wrap.cxx index 3e9fb9df..4367167b 100644 --- a/mfem/_par/mesh_operators_wrap.cxx +++ b/mfem/_par/mesh_operators_wrap.cxx @@ -3064,31 +3064,32 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_mfem__MeshOperator_p_t swig_types[6] -#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[7] -#define SWIGTYPE_p_mfem__GridFunction swig_types[8] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[9] -#define SWIGTYPE_p_mfem__L2ZienkiewiczZhuEstimator swig_types[10] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[11] -#define SWIGTYPE_p_mfem__Mesh swig_types[12] -#define SWIGTYPE_p_mfem__MeshOperator swig_types[13] -#define SWIGTYPE_p_mfem__MeshOperatorSequence swig_types[14] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[15] -#define SWIGTYPE_p_mfem__Rebalancer swig_types[16] -#define SWIGTYPE_p_mfem__ThresholdDerefiner swig_types[17] -#define SWIGTYPE_p_mfem__ThresholdRefiner swig_types[18] -#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[19] -#define SWIGTYPE_p_pri_t swig_types[20] -#define SWIGTYPE_p_quad_t swig_types[21] -#define SWIGTYPE_p_seg_t swig_types[22] -#define SWIGTYPE_p_tet_t swig_types[23] -#define SWIGTYPE_p_tri_t swig_types[24] -static swig_type_info *swig_types[26]; -static swig_module_info swig_module = {swig_types, 25, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_mfem__MeshOperator_p_t swig_types[7] +#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[8] +#define SWIGTYPE_p_mfem__GridFunction swig_types[9] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[10] +#define SWIGTYPE_p_mfem__L2ZienkiewiczZhuEstimator swig_types[11] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[12] +#define SWIGTYPE_p_mfem__Mesh swig_types[13] +#define SWIGTYPE_p_mfem__MeshOperator swig_types[14] +#define SWIGTYPE_p_mfem__MeshOperatorSequence swig_types[15] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[16] +#define SWIGTYPE_p_mfem__Rebalancer swig_types[17] +#define SWIGTYPE_p_mfem__ThresholdDerefiner swig_types[18] +#define SWIGTYPE_p_mfem__ThresholdRefiner swig_types[19] +#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[20] +#define SWIGTYPE_p_pri_t swig_types[21] +#define SWIGTYPE_p_quad_t swig_types[22] +#define SWIGTYPE_p_seg_t swig_types[23] +#define SWIGTYPE_p_tet_t swig_types[24] +#define SWIGTYPE_p_tri_t swig_types[25] +static swig_type_info *swig_types[27]; +static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4643,6 +4644,7 @@ SWIGINTERN PyObject *Rebalancer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "MeshOperator_Apply(MeshOperator self, Mesh mesh) -> bool"}, { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "MeshOperator_Stop(MeshOperator self) -> bool"}, { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "MeshOperator_Repeat(MeshOperator self) -> bool"}, @@ -4693,6 +4695,54 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "Apply(MeshOperator self, Mesh mesh) -> bool"}, + { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "Stop(MeshOperator self) -> bool"}, + { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "Repeat(MeshOperator self) -> bool"}, + { "MeshOperator_Continue", _wrap_MeshOperator_Continue, METH_O, "Continue(MeshOperator self) -> bool"}, + { "MeshOperator_Refined", _wrap_MeshOperator_Refined, METH_O, "Refined(MeshOperator self) -> bool"}, + { "MeshOperator_Derefined", _wrap_MeshOperator_Derefined, METH_O, "Derefined(MeshOperator self) -> bool"}, + { "MeshOperator_Rebalanced", _wrap_MeshOperator_Rebalanced, METH_O, "Rebalanced(MeshOperator self) -> bool"}, + { "MeshOperator_GetActionInfo", _wrap_MeshOperator_GetActionInfo, METH_O, "GetActionInfo(MeshOperator self) -> int"}, + { "MeshOperator_Reset", _wrap_MeshOperator_Reset, METH_O, "Reset(MeshOperator self)"}, + { "delete_MeshOperator", _wrap_delete_MeshOperator, METH_O, "delete_MeshOperator(MeshOperator self)"}, + { "MeshOperator_swigregister", MeshOperator_swigregister, METH_O, NULL}, + { "new_MeshOperatorSequence", _wrap_new_MeshOperatorSequence, METH_VARARGS, NULL}, + { "delete_MeshOperatorSequence", _wrap_delete_MeshOperatorSequence, METH_O, "delete_MeshOperatorSequence(MeshOperatorSequence self)"}, + { "MeshOperatorSequence_Append", _wrap_MeshOperatorSequence_Append, METH_VARARGS, "Append(MeshOperatorSequence self, MeshOperator mc)"}, + { "MeshOperatorSequence_GetSequence", _wrap_MeshOperatorSequence_GetSequence, METH_O, "GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &"}, + { "MeshOperatorSequence_Reset", _wrap_MeshOperatorSequence_Reset, METH_O, "Reset(MeshOperatorSequence self)"}, + { "MeshOperatorSequence_swigregister", MeshOperatorSequence_swigregister, METH_O, NULL}, + { "MeshOperatorSequence_swiginit", MeshOperatorSequence_swiginit, METH_VARARGS, NULL}, + { "new_ThresholdRefiner", _wrap_new_ThresholdRefiner, METH_O, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, + { "ThresholdRefiner_SetTotalErrorNormP", _wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS, "SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, + { "ThresholdRefiner_SetTotalErrorGoal", _wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS, "SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetTotalErrorFraction", _wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS, "SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, + { "ThresholdRefiner_SetLocalErrorGoal", _wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS, "SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetMaxElements", _wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS, "SetMaxElements(ThresholdRefiner self, long max_elem)"}, + { "ThresholdRefiner_PreferNonconformingRefinement", _wrap_ThresholdRefiner_PreferNonconformingRefinement, METH_O, "PreferNonconformingRefinement(ThresholdRefiner self)"}, + { "ThresholdRefiner_PreferConformingRefinement", _wrap_ThresholdRefiner_PreferConformingRefinement, METH_O, "PreferConformingRefinement(ThresholdRefiner self)"}, + { "ThresholdRefiner_SetNCLimit", _wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdRefiner self, int nc_limit)"}, + { "ThresholdRefiner_GetNumMarkedElements", _wrap_ThresholdRefiner_GetNumMarkedElements, METH_O, "GetNumMarkedElements(ThresholdRefiner self) -> long"}, + { "ThresholdRefiner_GetThreshold", _wrap_ThresholdRefiner_GetThreshold, METH_O, "GetThreshold(ThresholdRefiner self) -> double"}, + { "ThresholdRefiner_Reset", _wrap_ThresholdRefiner_Reset, METH_O, "Reset(ThresholdRefiner self)"}, + { "delete_ThresholdRefiner", _wrap_delete_ThresholdRefiner, METH_O, "delete_ThresholdRefiner(ThresholdRefiner self)"}, + { "ThresholdRefiner_swigregister", ThresholdRefiner_swigregister, METH_O, NULL}, + { "ThresholdRefiner_swiginit", ThresholdRefiner_swiginit, METH_VARARGS, NULL}, + { "new_ThresholdDerefiner", _wrap_new_ThresholdDerefiner, METH_O, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, + { "ThresholdDerefiner_SetThreshold", _wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS, "SetThreshold(ThresholdDerefiner self, double thresh)"}, + { "ThresholdDerefiner_SetOp", _wrap_ThresholdDerefiner_SetOp, METH_VARARGS, "SetOp(ThresholdDerefiner self, int op)"}, + { "ThresholdDerefiner_SetNCLimit", _wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, + { "ThresholdDerefiner_Reset", _wrap_ThresholdDerefiner_Reset, METH_O, "Reset(ThresholdDerefiner self)"}, + { "delete_ThresholdDerefiner", _wrap_delete_ThresholdDerefiner, METH_O, "delete_ThresholdDerefiner(ThresholdDerefiner self)"}, + { "ThresholdDerefiner_swigregister", ThresholdDerefiner_swigregister, METH_O, NULL}, + { "ThresholdDerefiner_swiginit", ThresholdDerefiner_swiginit, METH_VARARGS, NULL}, + { "Rebalancer_Reset", _wrap_Rebalancer_Reset, METH_O, "Reset(Rebalancer self)"}, + { "new_Rebalancer", _wrap_new_Rebalancer, METH_NOARGS, "new_Rebalancer() -> Rebalancer"}, + { "delete_Rebalancer", _wrap_delete_Rebalancer, METH_O, "delete_Rebalancer(Rebalancer self)"}, + { "Rebalancer_swigregister", Rebalancer_swigregister, METH_O, NULL}, + { "Rebalancer_swiginit", Rebalancer_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4722,6 +4772,7 @@ static void *_p_mfem__RebalancerTo_p_mfem__MeshOperator(void *x, int *SWIGUNUSED } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -4749,6 +4800,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -4776,6 +4828,7 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -4803,6 +4856,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, diff --git a/mfem/_par/mesh_wrap.cxx b/mfem/_par/mesh_wrap.cxx index c53ac775..e81f0683 100644 --- a/mfem/_par/mesh_wrap.cxx +++ b/mfem/_par/mesh_wrap.cxx @@ -3067,168 +3067,174 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_double swig_types[3] -#define SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void swig_types[4] -#define SWIGTYPE_p_hex_t swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_mfem__GeometricFactors_p_t swig_types[9] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[10] -#define SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t swig_types[11] -#define SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t swig_types[12] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[13] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[14] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[15] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[16] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[17] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[18] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[21] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[22] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[23] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[24] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[25] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[26] -#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[27] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[28] -#define SWIGTYPE_p_mfem__Element swig_types[29] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[30] -#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[31] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[32] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[33] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[34] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[35] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[36] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[37] -#define SWIGTYPE_p_mfem__GeometricFactors swig_types[38] -#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[39] -#define SWIGTYPE_p_mfem__GridFunction swig_types[40] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[41] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[42] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[43] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[44] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[45] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[46] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[47] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[48] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[49] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[50] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[51] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[52] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[53] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[54] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[55] -#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[56] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[57] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[59] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[60] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[62] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[63] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[64] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[65] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[66] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[67] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[68] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[69] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[70] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__LinearForm swig_types[76] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[77] -#define SWIGTYPE_p_mfem__Mesh swig_types[78] -#define SWIGTYPE_p_mfem__NCMesh swig_types[79] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[80] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[81] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[82] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[83] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[84] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__NURBSExtension swig_types[88] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[94] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[95] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[109] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[110] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[111] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[113] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[114] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[118] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[119] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[123] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[124] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[125] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[126] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[127] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[128] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[129] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[130] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[131] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[132] -#define SWIGTYPE_p_mfem__STable swig_types[133] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[134] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[135] -#define SWIGTYPE_p_mfem__Table swig_types[136] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[137] -#define SWIGTYPE_p_mfem__Vector swig_types[138] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[139] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[140] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[141] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[142] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[143] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[144] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[145] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[146] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[147] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[148] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[149] -#define SWIGTYPE_p_mfem__Vertex swig_types[150] -#define SWIGTYPE_p_mfem__named_ifgzstream swig_types[151] -#define SWIGTYPE_p_p_mfem__Element swig_types[152] -#define SWIGTYPE_p_p_mfem__GridFunction swig_types[153] -#define SWIGTYPE_p_p_mfem__Mesh swig_types[154] -#define SWIGTYPE_p_pri_t swig_types[155] -#define SWIGTYPE_p_quad_t swig_types[156] -#define SWIGTYPE_p_seg_t swig_types[157] -#define SWIGTYPE_p_std__istream swig_types[158] -#define SWIGTYPE_p_std__ostream swig_types[159] -#define SWIGTYPE_p_tet_t swig_types[160] -#define SWIGTYPE_p_tri_t swig_types[161] -static swig_type_info *swig_types[163]; -static swig_module_info swig_module = {swig_types, 162, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_double swig_types[4] +#define SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void swig_types[5] +#define SWIGTYPE_p_hex_t swig_types[6] +#define SWIGTYPE_p_int swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t swig_types[10] +#define SWIGTYPE_p_mfem__ArrayT_mfem__GeometricFactors_p_t swig_types[11] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[12] +#define SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t swig_types[13] +#define SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t swig_types[14] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[15] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t swig_types[16] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[17] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[18] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[19] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[24] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[25] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[26] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[27] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[28] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[29] +#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[30] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[31] +#define SWIGTYPE_p_mfem__Element swig_types[32] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[33] +#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[34] +#define SWIGTYPE_p_mfem__FaceGeometricFactors swig_types[35] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[36] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[37] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[38] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[39] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[40] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[41] +#define SWIGTYPE_p_mfem__GeometricFactors swig_types[42] +#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[43] +#define SWIGTYPE_p_mfem__GridFunction swig_types[44] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[45] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[46] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[47] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[49] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[50] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[51] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[52] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[53] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[54] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[55] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[56] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[57] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[58] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[59] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[60] +#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[61] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[62] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[63] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[64] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[65] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[66] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[67] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[68] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[69] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[70] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[71] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[72] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[73] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[74] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[75] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[79] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[80] +#define SWIGTYPE_p_mfem__LinearForm swig_types[81] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[82] +#define SWIGTYPE_p_mfem__Mesh swig_types[83] +#define SWIGTYPE_p_mfem__NCMesh swig_types[84] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[85] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[86] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[87] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[88] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[89] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__NURBSExtension swig_types[93] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[99] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[100] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[106] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[110] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[111] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[112] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[117] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[118] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[125] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[126] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[127] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[128] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[129] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[130] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[131] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[132] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[133] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[134] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[135] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[136] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[137] +#define SWIGTYPE_p_mfem__STable swig_types[138] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[139] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__Table swig_types[141] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[142] +#define SWIGTYPE_p_mfem__Vector swig_types[143] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[144] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[145] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[146] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[147] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[148] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[149] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[150] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[151] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[152] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[153] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[154] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[155] +#define SWIGTYPE_p_mfem__Vertex swig_types[156] +#define SWIGTYPE_p_p_mfem__Element swig_types[157] +#define SWIGTYPE_p_p_mfem__GridFunction swig_types[158] +#define SWIGTYPE_p_p_mfem__Mesh swig_types[159] +#define SWIGTYPE_p_pri_t swig_types[160] +#define SWIGTYPE_p_quad_t swig_types[161] +#define SWIGTYPE_p_seg_t swig_types[162] +#define SWIGTYPE_p_std__istream swig_types[163] +#define SWIGTYPE_p_std__ostream swig_types[164] +#define SWIGTYPE_p_std__string swig_types[165] +#define SWIGTYPE_p_tet_t swig_types[166] +#define SWIGTYPE_p_tri_t swig_types[167] +static swig_type_info *swig_types[169]; +static swig_module_info swig_module = {swig_types, 168, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3864,38 +3870,6 @@ SWIGINTERN void mfem_Mesh_PrintVTK__SWIG_3(mfem::Mesh *self,char const *file,int ofile.close(); } -SWIGINTERNINLINE PyObject * -SWIG_FromCharPtrAndSize(const char* carray, size_t size) -{ - if (carray) { - if (size > INT_MAX) { - swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); - return pchar_descriptor ? - SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); - } else { -#if PY_VERSION_HEX >= 0x03000000 -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#else - return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); -#endif -#else - return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#endif - } - } else { - return SWIG_Py_Void(); - } -} - - -SWIGINTERNINLINE PyObject * -SWIG_FromCharPtr(const char *cptr) -{ - return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); -} - - /* --------------------------------------------------- * C++ director class methods @@ -4108,6 +4082,58 @@ SWIGINTERN PyObject *_wrap_Mesh_geom_factors_get(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_Mesh_face_geom_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Array< mfem::FaceGeometricFactors * > *arg2 = (mfem::Array< mfem::FaceGeometricFactors * > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_face_geom_factors_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_face_geom_factors_set" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_face_geom_factors_set" "', argument " "2"" of type '" "mfem::Array< mfem::FaceGeometricFactors * > *""'"); + } + arg2 = reinterpret_cast< mfem::Array< mfem::FaceGeometricFactors * > * >(argp2); + if (arg1) (arg1)->face_geom_factors = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_face_geom_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::FaceGeometricFactors * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_face_geom_factors_get" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + result = (mfem::Array< mfem::FaceGeometricFactors * > *)& ((arg1)->face_geom_factors); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN int Swig_var_Mesh_remove_unused_vertices_set(PyObject *_val) { { bool val; @@ -4679,6 +4705,167 @@ SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObje } +SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + int i; + if (!PyList_Check(swig_obj[1])) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(swig_obj[1]); + arg2 = (int *) malloc((l)*sizeof(int)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(swig_obj[1],i); + if (PyInt_Check(s)) { + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); + return NULL; + } + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->AddSegment((int const *)arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + int i; + if (!PyList_Check(swig_obj[1])) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(swig_obj[1]); + arg2 = (int *) malloc((l)*sizeof(int)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(swig_obj[1],i); + if (PyInt_Check(s)) { + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); + return NULL; + } + } + } + { + try { + (arg1)->AddSegment((int const *)arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_AddSegment(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddSegment", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + return _wrap_Mesh_AddSegment__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_AddSegment__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddSegment'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::AddSegment(int const *,int)\n" + " mfem::Mesh::AddSegment(int const *)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -8202,23 +8389,29 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_FinalizeTopology" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - (arg1)->FinalizeTopology(); + (arg1)->FinalizeTopology(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8231,37 +8424,21 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_Finalize" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); { try { - (arg1)->Finalize(arg2,arg3); + (arg1)->FinalizeTopology(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8274,19 +8451,104 @@ SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTopology", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_FinalizeTopology__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_FinalizeTopology__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTopology'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::FinalizeTopology(bool)\n" + " mfem::Mesh::FinalizeTopology()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_Finalize" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + { + try { + (arg1)->Finalize(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); @@ -8429,6 +8691,45 @@ SWIGINTERN PyObject *_wrap_Mesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), Py } +SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetHilbertElementOrdering", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + (arg1)->GetHilbertElementOrdering(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -10306,6 +10607,43 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNumFaces(PyObject *SWIGUNUSEDPARM(self), PyOb } +SWIGINTERN PyObject *_wrap_Mesh_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::FaceType arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFbyType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); + { + try { + result = (int)((mfem::Mesh const *)arg1)->GetNFbyType(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Mesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -10419,6 +10757,61 @@ SWIGINTERN PyObject *_wrap_Mesh_GetGeometricFactors(PyObject *SWIGUNUSEDPARM(sel } +SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + int arg3 ; + mfem::FaceType arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + mfem::FaceGeometricFactors *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); + } + arg4 = static_cast< mfem::FaceType >(val4); + { + try { + result = (mfem::FaceGeometricFactors *)(arg1)->GetFaceGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Mesh_DeleteGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -14347,7 +14740,7 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNode", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -14363,7 +14756,7 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject arg3 = reinterpret_cast< double * >(argp3); { try { - (arg1)->GetNode(arg2,arg3); + ((mfem::Mesh const *)arg1)->GetNode(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17568,7 +17961,7 @@ SWIGINTERN PyObject *_wrap_Mesh_DerefineByError(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::Array< mfem::KnotVector * > *arg2 = 0 ; @@ -17576,9 +17969,8 @@ SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -17607,69 +17999,32 @@ SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->DegreeElevate(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Array< mfem::Vector * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp2); { try { - (arg1)->DegreeElevate(arg2); + (arg1)->KnotInsert(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17682,13 +18037,134 @@ SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DegreeElevate", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_KnotInsert'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::KnotVector * > &)\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::Vector * > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->DegreeElevate(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + (arg1)->DegreeElevate(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DegreeElevate", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -18352,193 +18828,217 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + std::ostream *arg2 = 0 ; int arg3 ; + mfem::VTKFormat arg4 ; + bool arg5 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } { try { - (arg1)->GetElementColoring(*arg2,arg3); + (arg1)->PrintVTU(*arg2,arg3,arg4,arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; + mfem::VTKFormat arg4 ; + bool arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); { try { - (arg1)->GetElementColoring(*arg2); + (arg1)->PrintVTU(*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementColoring", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementColoring'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &,int)\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; + mfem::VTKFormat arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); { try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); + (arg1)->PrintVTU(*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18546,62 +19046,61 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUS } resultobj = SWIG_Py_Void(); { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return resultobj; fail: { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } { try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3); + (arg1)->PrintVTU(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18609,147 +19108,54 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUS } resultobj = SWIG_Py_Void(); { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return resultobj; fail: { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &,int) const\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); + (arg1)->PrintVTU(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18757,289 +19163,185 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject * } resultobj = SWIG_Py_Void(); { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return resultobj; fail: { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; + std::string arg2 ; + mfem::VTKFormat arg3 ; + bool arg4 ; + int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); + } + arg3 = static_cast< mfem::VTKFormat >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } { try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3); + (arg1)->PrintVTU(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return resultobj; fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintElementsWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &,int)\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Table *arg2 = 0 ; - std::ostream *arg3 = 0 ; + std::string arg2 ; + mfem::VTKFormat arg3 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - PyObject *swig_obj[3] ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintSurfaces", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); + } + arg3 = static_cast< mfem::VTKFormat >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { try { - ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); + (arg1)->PrintVTU(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return resultobj; fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; + std::string arg2 ; + mfem::VTKFormat arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleSubdomains", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); { - try { - (arg1)->ScaleSubdomains(arg2); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); } - arg2 = static_cast< double >(val2); + arg3 = static_cast< mfem::VTKFormat >(val3); { try { - (arg1)->ScaleElements(arg2); + (arg1)->PrintVTU(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -19052,28 +19354,37 @@ SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; + std::string arg2 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } } { try { - (arg1)->Transform(arg2); + (arg1)->PrintVTU(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -19086,51 +19397,13 @@ SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - (arg1)->Transform(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTU", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -19138,11 +19411,10 @@ SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); + return _wrap_Mesh_PrintVTU__SWIG_8(self, argc, argv); } } } @@ -19152,240 +19424,174 @@ SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); + return _wrap_Mesh_PrintVTU__SWIG_4(self, argc, argv); } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" - " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveUnusedVertices(); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_7(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveInternalBoundaries(); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_3(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_6(self, argc, argv); + } + } + } + } } - { - try { - result = (double)(arg1)->GetElementSize(arg2,arg3); + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_2(self, argc, argv); + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double)(arg1)->GetElementSize(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { + if (argc == 5) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_5(self, argc, argv); + } + } + } } } } - if (argc == 3) { + if (argc == 5) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { PyErr_Clear(); _v = 0; } else { @@ -19393,22 +19599,41 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_2(self, argc, argv); + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + } } } } } - if (argc == 3) { + if (argc == 6) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { PyErr_Clear(); _v = 0; } else { @@ -19425,102 +19650,121 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + } + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTU'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementSize(int,int)\n" - " mfem::Mesh::GetElementSize(int)\n" - " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool,int)\n" + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool)\n" + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat)\n" + " mfem::Mesh::PrintVTU(std::ostream &,int)\n" + " mfem::Mesh::PrintVTU(std::ostream &)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool,int)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat)\n" + " mfem::Mesh::PrintVTU(std::string)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - double result; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVolume", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (double)(arg1)->GetElementVolume(arg2); + (arg1)->GetElementColoring(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->GetBoundingBox(*arg2,*arg3,arg4); + (arg1)->GetElementColoring(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -19533,62 +19777,202 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementColoring", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetElementColoring__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetElementColoring__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementColoring'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetElementColoring(mfem::Array< int > &,int)\n" + " mfem::Mesh::GetElementColoring(mfem::Array< int > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + try { + ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } + return resultobj; +fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->GetBoundingBox(*arg2,*arg3); + ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBoundingBox", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintWithPartitioning", 0, 4, argv))) SWIG_fail; --argc; if (argc == 3) { int _v; @@ -19597,14 +19981,20 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_1(self, argc, argv); + return _wrap_Mesh_PrintWithPartitioning__SWIG_1(self, argc, argv); } } } @@ -19616,12 +20006,18 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { @@ -19632,7 +20028,7 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_0(self, argc, argv); + return _wrap_Mesh_PrintWithPartitioning__SWIG_0(self, argc, argv); } } } @@ -19640,398 +20036,252 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBoundingBox'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintWithPartitioning'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &)\n"); + " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &,int) const\n" + " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - mfem::Vector *arg7 = (mfem::Vector *) 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); + (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6); + if (temp3->isSTDOUT() != 1) { + out3.close(); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg5 = reinterpret_cast< double * >(argp5); { try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); + (arg1)->PrintElementsWithPartitioning(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetCharacteristics", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsWithPartitioning", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_2(self, argc, argv); - } + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(self, argc, argv); + } } } } - if (argc == 6) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_1(self, argc, argv); - } - } + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_0(self, argc, argv); - } - } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(self, argc, argv); + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetCharacteristics'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintElementsWithPartitioning'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &)\n"); + " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &,int)\n" + " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - mfem::Array< int > *arg2 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Table *arg2 = 0 ; std::ostream *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyMFEM::wFILE *temp3 = 0 ; std::ofstream out3 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsByGeometry", 3, 3, swig_obj)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintSurfaces", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + arg2 = reinterpret_cast< mfem::Table * >(argp2); { if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); @@ -20049,7 +20299,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM } { try { - mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); + ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20072,108 +20322,66 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - std::ostream *arg4 = 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyMFEM::wFILE *temp4 = 0 ; - std::ofstream out4 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleSubdomains", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if (SWIG_ConvertPtr(swig_obj[3], (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp4->isSTDOUT() == 1) { - arg4 = &std::cout; - } - else { - out4.open(temp4->getFilename()); - out4.precision(temp4->getPrecision()); - arg4 = &out4; - } - } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - (arg1)->PrintCharacteristics(arg2,arg3,*arg4); + (arg1)->ScaleSubdomains(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } return resultobj; fail: - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleElements", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - (arg1)->PrintCharacteristics(arg2,arg3); + (arg1)->ScaleElements(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20186,29 +20394,28 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); + { + int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); + } } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->PrintCharacteristics(arg2); + (arg1)->Transform(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20221,21 +20428,32 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - (arg1)->PrintCharacteristics(); + (arg1)->Transform(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20248,21 +20466,26 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintCharacteristics", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_3(self, argc, argv); + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); + } } } if (argc == 2) { @@ -20272,144 +20495,69 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *self, PyObject *a _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[3], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintCharacteristics'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *,std::ostream &)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics()\n"); + " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" + " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } { try { - (arg1)->PrintInfo(*arg2); + (arg1)->RemoveUnusedVertices(); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->PrintInfo(); + (arg1)->RemoveInternalBoundaries(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -20422,1039 +20570,2233 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) 0 ; + int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; + double result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); { try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); + result = (double)(arg1)->GetElementSize(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - int result; + double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); { try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5); + result = (double)(arg1)->GetElementSize(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int result; + double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4); + result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FindPoints", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_2(self, argc, argv); - } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); + } } } - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_1(self, argc, argv); - } - } + return _wrap_Mesh_GetElementSize__SWIG_2(self, argc, argv); } } } } - if (argc == 6) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__InverseElementTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_0(self, argc, argv); - } - } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FindPoints'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool,mfem::InverseElementTransformation *)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &)\n"); + " mfem::Mesh::GetElementSize(int,int)\n" + " mfem::Mesh::GetElementSize(int)\n" + " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject *swig_obj[2] ; + double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVolume", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - delete arg1; + result = (double)(arg1)->GetElementVolume(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_32(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< char * >(buf4); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); + (arg1)->GetBoundingBox(*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_33(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7); + (arg1)->GetBoundingBox(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_34(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBoundingBox", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetBoundingBox__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetBoundingBox__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBoundingBox'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &,int)\n" + " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + mfem::Vector *arg6 = (mfem::Vector *) 0 ; + mfem::Vector *arg7 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_35(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + mfem::Vector *arg6 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_36(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + arg5 = reinterpret_cast< double * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); } - arg4 = reinterpret_cast< char * >(buf4); + arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_37(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - double arg6 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_38(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetCharacteristics", 0, 7, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetCharacteristics__SWIG_2(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetCharacteristics__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetCharacteristics__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetCharacteristics'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *,mfem::Vector *)\n" + " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *)\n" + " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + mfem::Array< int > *arg2 = 0 ; + std::ostream *arg3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsByGeometry", 3, 3, swig_obj)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< char * >(buf3); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5); + mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_39(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = (mfem::Vector *) 0 ; + std::ostream *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyMFEM::wFILE *temp4 = 0 ; + std::ofstream out4 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); } - arg3 = reinterpret_cast< char * >(buf3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (SWIG_ConvertPtr(swig_obj[3], (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp4->isSTDOUT() == 1) { + arg4 = &std::cout; + } + else { + out4.open(temp4->getFilename()); + out4.precision(temp4->getPrecision()); + arg4 = &out4; + } } { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4); + (arg1)->PrintCharacteristics(arg2,arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + resultobj = SWIG_Py_Void(); + { + if (temp4->isSTDOUT() != 1) { + out4.close(); + } + } + return resultobj; +fail: + { + if (temp4->isSTDOUT() != 1) { + out4.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_40(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); } - arg3 = reinterpret_cast< char * >(buf3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3); + (arg1)->PrintCharacteristics(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[13] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_Mesh__SWIG_1(self, argc, argv); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_3(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_29(self, argc, argv); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + (arg1)->PrintCharacteristics(arg2); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_21(self, argc, argv); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + (arg1)->PrintCharacteristics(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintCharacteristics", 0, 4, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_25(self, argc, argv); + return _wrap_Mesh_PrintCharacteristics__SWIG_3(self, argc, argv); } } if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_28(self, argc, argv); + return _wrap_Mesh_PrintCharacteristics__SWIG_2(self, argc, argv); } } } - if (argc == 2) { + if (argc == 3) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintCharacteristics__SWIG_1(self, argc, argv); + } } } } - if (argc == 2) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_30(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_20(self, argc, argv); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[3], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintCharacteristics__SWIG_0(self, argc, argv); + } + } } } } - if (argc == 2) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintCharacteristics'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *,std::ostream &)\n" + " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *)\n" + " mfem::Mesh::PrintCharacteristics(mfem::Vector *)\n" + " mfem::Mesh::PrintCharacteristics()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + try { + (arg1)->PrintInfo(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + (arg1)->PrintInfo(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + bool arg5 ; + mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + int result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); + } + arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); + { + try { + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + int result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + { + try { + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + { + try { + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FindPoints", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_FindPoints__SWIG_2(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_FindPoints__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__InverseElementTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_FindPoints__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FindPoints'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool,mfem::InverseElementTransformation *)\n" + " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool)\n" + " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_32(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + double arg6 ; + double arg7 ; + double arg8 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_33(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + double arg6 ; + double arg7 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_34(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + double arg6 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_35(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_36(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_37(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + double arg5 ; + double arg6 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_38(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + double arg5 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + double val5 ; + int ecode5 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_39(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_40(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[13] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_Mesh__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Mesh__SWIG_3(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Mesh__SWIG_29(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_21(self, argc, argv); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Mesh__SWIG_25(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_28(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_2(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_30(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_20(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); _v = 0; @@ -22311,43 +23653,287 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_32(self, argc, argv); + } + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + { + _v = 0; // ignore this pattern + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_10(self, argc, argv); + } + } + } + } + } + } + if (argc == 9) { + int _v; + { + _v = 0; // ignore this pattern + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 11) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } + } + } + } + } + } + } + } + } + } + } + } + if (argc == 12) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_double(argv[7], NULL); + int res = SWIG_AsVal_int(argv[7], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Mesh__SWIG_32(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[11]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_4(self, argc, argv); + } + } + } + } } } } @@ -22357,82 +23943,213 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 8) { - int _v; - { - _v = 0; // ignore this pattern + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Mesh'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::Mesh()\n" + " mfem::Mesh::Mesh(mfem::Mesh const &,bool)\n" + " mfem::Mesh::Mesh(mfem::Mesh const &)\n" + " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int,int)\n" + " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,int)\n" + " mfem::Mesh::Mesh(int,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double,bool)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double,bool)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type)\n" + " mfem::Mesh::Mesh(int,double)\n" + " mfem::Mesh::Mesh(int)\n" + " mfem::Mesh::Mesh(char const *,int,int,bool)\n" + " mfem::Mesh::Mesh(char const *,int,int)\n" + " mfem::Mesh::Mesh(char const *,int)\n" + " mfem::Mesh::Mesh(char const *)\n" + " mfem::Mesh::Mesh(std::istream &,int,int,bool)\n" + " mfem::Mesh::Mesh(std::istream &,int,int)\n" + " mfem::Mesh::Mesh(std::istream &,int)\n" + " mfem::Mesh::Mesh(std::istream &)\n" + " mfem::Mesh::Mesh(mfem::Mesh *[],int)\n" + " mfem::Mesh::Mesh(mfem::Mesh *,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int,double)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int)\n" + " mfem::Mesh::Mesh(int,int,int,char const *)\n" + " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n" + " mfem::Mesh::Mesh(int,int,char const *,int,double)\n" + " mfem::Mesh::Mesh(int,int,char const *,int)\n" + " mfem::Mesh::Mesh(int,int,char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintToFile", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintToFile" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintToFile" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + mfem_Mesh_PrintToFile((mfem::Mesh const *)arg1,(char const *)arg2,arg3); } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_10(self, argc, argv); - } - } - } - } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (PyObject *)mfem_Mesh_GetAttributeArray((mfem::Mesh const *)arg1); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + PyObject *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertexArray", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (argc == 9) { - int _v; - { - _v = 0; // ignore this pattern + { + try { + result = (PyObject *)mfem_Mesh_GetVertexArray((mfem::Mesh const *)arg1,arg2); } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[8], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_9(self, argc, argv); - } - } - } - } - } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (PyObject *)mfem_Mesh_GetBdrElementFace__SWIG_1((mfem::Mesh const *)arg1,arg2); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (argc == 11) { + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementFace", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { @@ -22444,76 +24161,14 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - } + return _wrap_Mesh_GetBdrElementFace__SWIG_1(self, argc, argv); } } } - if (argc == 12) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { @@ -22529,73 +24184,11 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[11]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_4(self, argc, argv); - } - } - } - } - } - } - } - } + return _wrap_Mesh_GetBdrElementFace__SWIG_0(self, argc, argv); } } } @@ -22603,53 +24196,117 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Mesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Mesh()\n" - " mfem::Mesh::Mesh(mfem::Mesh const &,bool)\n" - " mfem::Mesh::Mesh(mfem::Mesh const &)\n" - " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int,int)\n" - " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type)\n" - " mfem::Mesh::Mesh(int,double)\n" - " mfem::Mesh::Mesh(int)\n" - " mfem::Mesh::Mesh(char const *,int,int,bool)\n" - " mfem::Mesh::Mesh(char const *,int,int)\n" - " mfem::Mesh::Mesh(char const *,int)\n" - " mfem::Mesh::Mesh(char const *)\n" - " mfem::Mesh::Mesh(std::istream &,int,int,bool)\n" - " mfem::Mesh::Mesh(std::istream &,int,int)\n" - " mfem::Mesh::Mesh(std::istream &,int)\n" - " mfem::Mesh::Mesh(std::istream &)\n" - " mfem::Mesh::Mesh(mfem::Mesh *[],int)\n" - " mfem::Mesh::Mesh(mfem::Mesh *,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,int,char const *)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,char const *)\n"); - return 0; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementFace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetBdrElementFace(int,int *,int *) const\n" + " mfem::Mesh::GetBdrElementFace(int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (PyObject *)mfem_Mesh_GetBdrAttributeArray((mfem::Mesh const *)arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + PyObject *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrArray", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (PyObject *)mfem_Mesh_GetBdrArray((mfem::Mesh const *)arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + PyObject *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetDomainArray", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetDomainArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (PyObject *)mfem_Mesh_GetDomainArray((mfem::Mesh const *)arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; @@ -22659,17 +24316,16 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintToFile", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintToFile" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintToFile" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { @@ -22680,7 +24336,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb } { try { - mfem_Mesh_PrintToFile((mfem::Mesh const *)arg1,(char const *)arg2,arg3); + mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -22695,142 +24351,251 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Mesh_GetAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); { try { - result = (PyObject *)mfem_Mesh_GetAttributeArray((mfem::Mesh const *)arg1); + mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintInfo", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_3(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintInfo'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintInfo(std::ostream &)\n" + " mfem::Mesh::PrintInfo()\n" + " mfem::Mesh::PrintInfo(char const *,int)\n" + " mfem::Mesh::PrintInfo(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + char *arg2 = (char *) 0 ; + int arg3 ; void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - PyObject *result = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertexArray", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (PyObject *)mfem_Mesh_GetVertexArray((mfem::Mesh const *)arg1,arg2); + mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); } + arg2 = reinterpret_cast< char * >(buf2); { try { - result = (PyObject *)mfem_Mesh_GetBdrElementFace__SWIG_1((mfem::Mesh const *)arg1,arg2); + mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementFace", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Print", 0, 3, argv))) SWIG_fail; --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_Print__SWIG_1(self, argc, argv); + } + } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetBdrElementFace__SWIG_1(self, argc, argv); + return _wrap_Mesh_Print__SWIG_3(self, argc, argv); } } } - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { PyErr_Clear(); _v = 0; } else { @@ -22838,163 +24603,282 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace(PyObject *self, PyObject *args } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetBdrElementFace__SWIG_0(self, argc, argv); + return _wrap_Mesh_Print__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_Print__SWIG_2(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementFace'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Print'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBdrElementFace(int,int *,int *) const\n" - " mfem::Mesh::GetBdrElementFace(int) const\n"); + " mfem::Mesh::Print(std::ostream &) const\n" + " mfem::Mesh::Print() const\n" + " mfem::Mesh::Print(char const *,int)\n" + " mfem::Mesh::Print(char const *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } { try { - result = (PyObject *)mfem_Mesh_GetBdrAttributeArray((mfem::Mesh const *)arg1); + mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrArray", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); } + arg2 = reinterpret_cast< char * >(buf2); { try { - result = (PyObject *)mfem_Mesh_GetBdrArray((mfem::Mesh const *)arg1,arg2); + mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintXG", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_3(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_2(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = result; - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintXG'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintXG(std::ostream &) const\n" + " mfem::Mesh::PrintXG() const\n" + " mfem::Mesh::PrintXG(char const *,int)\n" + " mfem::Mesh::PrintXG(char const *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + char *arg2 = (char *) 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetDomainArray", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetDomainArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (PyObject *)mfem_Mesh_GetDomainArray((mfem::Mesh const *)arg1,arg2); + mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); + mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23009,319 +24893,440 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTK", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_4(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_3(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTK'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintVTK(std::ostream &)\n" + " mfem::Mesh::PrintVTK(std::ostream &,int,int)\n" + " mfem::Mesh::PrintVTK(std::ostream &,int)\n" + " mfem::Mesh::PrintVTK(char const *,int)\n" + " mfem::Mesh::PrintVTK(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *Mesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__Mesh, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *Mesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + std::ostream *arg1 = 0 ; + mfem::Mesh *arg2 = 0 ; + PyMFEM::wFILE *temp1 = 0 ; + std::ofstream out1 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::ostream *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + { + if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp1->isSTDOUT() == 1) { + arg1 = &std::cout; + } + else { + out1.open(temp1->getFilename()); + out1.precision(temp1->getPrecision()); + arg1 = &out1; + } } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } - arg2 = reinterpret_cast< char * >(buf2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); + } + arg2 = reinterpret_cast< mfem::Mesh * >(argp2); { try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2); + result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::Mesh const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintInfo", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_3(self, argc, argv); - } - } - } if (argc == 2) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_0(self, argc, argv); + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_2(self, argc, argv); - } + return _wrap___lshift____SWIG_2(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintInfo'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintInfo(std::ostream &)\n" - " mfem::Mesh::PrintInfo()\n" - " mfem::Mesh::PrintInfo(char const *,int)\n" - " mfem::Mesh::PrintInfo(char const *)\n"); - return 0; + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_mesh_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_mesh_set" "', argument " "2"" of type '" "mfem::Mesh const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = reinterpret_cast< mfem::Mesh * >(argp2); + if (arg1) (arg1)->mesh = (mfem::Mesh const *)arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Mesh *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - { - try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Mesh *) ((arg1)->mesh); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_IntRule_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_IntRule_set" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + if (arg1) (arg1)->IntRule = (mfem::IntegrationRule const *)arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + PyObject *swig_obj[1] ; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::IntegrationRule *) ((arg1)->IntRule); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_computed_factors_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg2 = reinterpret_cast< char * >(buf2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); { - try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + if (arg1) (arg1)->computed_factors = arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Print", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Print__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Print__SWIG_2(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (int) ((arg1)->computed_factors); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Print'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Print(std::ostream &) const\n" - " mfem::Mesh::Print() const\n" - " mfem::Mesh::Print(char const *,int)\n" - " mfem::Mesh::Print(char const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[3] ; + mfem::GeometricFactors *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_GeometricFactors", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } - arg2 = reinterpret_cast< char * >(buf2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -23330,483 +25335,218 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } { try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2,arg3); + result = (mfem::GeometricFactors *)new mfem::GeometricFactors((mfem::Mesh const *)arg1,(mfem::IntegrationRule const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_NEW | 0 ); return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_X_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_X_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->X = *arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintXG", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_2(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintXG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintXG(std::ostream &) const\n" - " mfem::Mesh::PrintXG() const\n" - " mfem::Mesh::PrintXG(char const *,int)\n" - " mfem::Mesh::PrintXG(char const *)\n"); - return 0; + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->X); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_J_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_J_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->J = *arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->J); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTK", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); - } - } - } + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_detJ_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_1(self, argc, argv); - } - } - } - } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_detJ_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } - + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->detJ = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTK'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintVTK(std::ostream &)\n" - " mfem::Mesh::PrintVTK(std::ostream &,int,int)\n" - " mfem::Mesh::PrintVTK(std::ostream &,int)\n" - " mfem::Mesh::PrintVTK(char const *,int)\n" - " mfem::Mesh::PrintVTK(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *Mesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__Mesh, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); + return NULL; } -SWIGINTERN PyObject *Mesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - std::ostream *arg1 = 0 ; - mfem::Mesh *arg2 = 0 ; - PyMFEM::wFILE *temp1 = 0 ; - std::ofstream out1 ; - void *argp2 = 0 ; - int res2 = 0 ; - std::ostream *result = 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp1->isSTDOUT() == 1) { - arg1 = &std::cout; - } - else { - out1.open(temp1->getFilename()); - out1.precision(temp1->getPrecision()); - arg1 = &out1; - } - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->detJ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeometricFactors" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); { try { - result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::Mesh const &)*arg2); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } + resultobj = SWIG_Py_Void(); return resultobj; fail: - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } - PyErr_Clear(); - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + return NULL; } -SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap___lshift____SWIG_2(self, argc, argv); - } - } - } - -fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; +SWIGINTERN PyObject *GeometricFactors_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeometricFactors, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } +SWIGINTERN PyObject *GeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} -SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -23814,15 +25554,15 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_mesh_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_mesh_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_mesh_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_mesh_set" "', argument " "2"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_mesh_set" "', argument " "2"" of type '" "mfem::Mesh const *""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); if (arg1) (arg1)->mesh = (mfem::Mesh const *)arg2; @@ -23833,9 +25573,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -23843,11 +25583,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(se if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_mesh_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (mfem::Mesh *) ((arg1)->mesh); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); return resultobj; @@ -23856,9 +25596,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -23866,15 +25606,15 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_IntRule_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_IntRule_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_IntRule_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_IntRule_set" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_IntRule_set" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); if (arg1) (arg1)->IntRule = (mfem::IntegrationRule const *)arg2; @@ -23885,9 +25625,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -23895,11 +25635,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_IntRule_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (mfem::IntegrationRule *) ((arg1)->IntRule); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; @@ -23908,20 +25648,20 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_computed_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_computed_factors_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_computed_factors_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_computed_factors_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -23936,9 +25676,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_set(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_computed_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -23946,11 +25686,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGU if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_computed_factors_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (int) ((arg1)->computed_factors); resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; @@ -23959,30 +25699,85 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + mfem::FaceType arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_type_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_type_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FaceGeometricFactors_type_set" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); + if (arg1) (arg1)->type = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::FaceType result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_type_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::FaceType) ((arg1)->type); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::IntegrationRule *arg2 = 0 ; int arg3 ; + mfem::FaceType arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; - mfem::GeometricFactors *result = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + mfem::FaceGeometricFactors *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_GeometricFactors", 3, 3, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_FaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { @@ -23991,24 +25786,29 @@ SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); + } + arg4 = static_cast< mfem::FaceType >(val4); { try { - result = (mfem::GeometricFactors *)new mfem::GeometricFactors((mfem::Mesh const *)arg1,(mfem::IntegrationRule const &)*arg2,arg3); + result = (mfem::FaceGeometricFactors *)new mfem::FaceGeometricFactors((mfem::Mesh const *)arg1,(mfem::IntegrationRule const &)*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24016,15 +25816,15 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_X_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_X_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_X_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_X_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_X_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); if (arg1) (arg1)->X = *arg2; @@ -24035,9 +25835,61 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_X_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->X); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_J_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_J_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_J_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->J = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -24045,12 +25897,12 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self) if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_J_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); - result = (mfem::Vector *)& ((arg1)->X); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->J); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: @@ -24058,9 +25910,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24068,18 +25920,18 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_J_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_detJ_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_detJ_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_J_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_detJ_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - if (arg1) (arg1)->J = *arg2; + if (arg1) (arg1)->detJ = *arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -24087,9 +25939,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -24097,12 +25949,12 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self) if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_detJ_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); - result = (mfem::Vector *)& ((arg1)->J); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->detJ); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: @@ -24110,9 +25962,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_normal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24120,18 +25972,18 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_detJ_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_normal_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_normal_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_detJ_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_normal_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - if (arg1) (arg1)->detJ = *arg2; + if (arg1) (arg1)->normal = *arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -24139,9 +25991,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_normal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -24149,12 +26001,12 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(se if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_normal_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); - result = (mfem::Vector *)& ((arg1)->detJ); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->normal); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: @@ -24162,20 +26014,20 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_delete_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeometricFactors" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FaceGeometricFactors" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); { try { delete arg1; @@ -24191,14 +26043,14 @@ SWIGINTERN PyObject *_wrap_delete_GeometricFactors(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *GeometricFactors_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FaceGeometricFactors_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeometricFactors, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FaceGeometricFactors, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *GeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FaceGeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } @@ -24763,116 +26615,47 @@ SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_named_ifgzstream_filename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::named_ifgzstream *arg1 = (mfem::named_ifgzstream *) 0 ; - char *arg2 = (char *) 0 ; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "named_ifgzstream_filename_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__named_ifgzstream, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ShiftRight", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "named_ifgzstream_filename_set" "', argument " "1"" of type '" "mfem::named_ifgzstream *""'"); - } - arg1 = reinterpret_cast< mfem::named_ifgzstream * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "named_ifgzstream_filename_set" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } - arg2 = reinterpret_cast< char * >(buf2); - if (arg2) { - size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1; - arg1->filename = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size))); - } else { - arg1->filename = 0; + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_named_ifgzstream_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::named_ifgzstream *arg1 = (mfem::named_ifgzstream *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - char *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__named_ifgzstream, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "named_ifgzstream_filename_get" "', argument " "1"" of type '" "mfem::named_ifgzstream *""'"); + arg1 = reinterpret_cast< int * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } - arg1 = reinterpret_cast< mfem::named_ifgzstream * >(argp1); - result = (char *) ((arg1)->filename); - resultobj = SWIG_FromCharPtr((const char *)result); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_named_ifgzstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - PyObject *swig_obj[1] ; - mfem::named_ifgzstream *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_named_ifgzstream" "', argument " "1"" of type '" "char const *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } - arg1 = reinterpret_cast< char * >(buf1); - { - try { - result = (mfem::named_ifgzstream *)new mfem::named_ifgzstream((char const *)arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg2 = reinterpret_cast< int * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShiftRight" "', argument " "3"" of type '" "int &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__named_ifgzstream, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return resultobj; -fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_named_ifgzstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::named_ifgzstream *arg1 = (mfem::named_ifgzstream *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__named_ifgzstream, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_named_ifgzstream" "', argument " "1"" of type '" "mfem::named_ifgzstream *""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "3"" of type '" "int &""'"); } - arg1 = reinterpret_cast< mfem::named_ifgzstream * >(argp1); + arg3 = reinterpret_cast< int * >(argp3); { try { - delete arg1; + mfem::ShiftRight(*arg1,*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24885,19 +26668,9 @@ SWIGINTERN PyObject *_wrap_delete_named_ifgzstream(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *named_ifgzstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__named_ifgzstream, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *named_ifgzstream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Mesh_attributes_get", _wrap_Mesh_attributes_get, METH_O, "Mesh_attributes_get(Mesh self) -> intArray"}, { "Mesh_bdr_attributes_get", _wrap_Mesh_bdr_attributes_get, METH_O, "Mesh_bdr_attributes_get(Mesh self) -> intArray"}, { "Mesh_NURBSext_set", _wrap_Mesh_NURBSext_set, METH_VARARGS, "Mesh_NURBSext_set(Mesh self, mfem::NURBSExtension * NURBSext)"}, @@ -24906,10 +26679,13 @@ static PyMethodDef SwigMethods[] = { { "Mesh_ncmesh_get", _wrap_Mesh_ncmesh_get, METH_O, "Mesh_ncmesh_get(Mesh self) -> NCMesh"}, { "Mesh_geom_factors_set", _wrap_Mesh_geom_factors_set, METH_VARARGS, "Mesh_geom_factors_set(Mesh self, mfem::Array< mfem::GeometricFactors * > * geom_factors)"}, { "Mesh_geom_factors_get", _wrap_Mesh_geom_factors_get, METH_O, "Mesh_geom_factors_get(Mesh self) -> mfem::Array< mfem::GeometricFactors * > *"}, + { "Mesh_face_geom_factors_set", _wrap_Mesh_face_geom_factors_set, METH_VARARGS, "Mesh_face_geom_factors_set(Mesh self, mfem::Array< mfem::FaceGeometricFactors * > * face_geom_factors)"}, + { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "Mesh_NewElement(Mesh self, int geom) -> Element"}, { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "Mesh_AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "Mesh_AddSegment(Mesh self, int const * vi, int attr=1)"}, { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "Mesh_AddTri(Mesh self, int const * vi, int attr=1)"}, { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "Mesh_AddTriangle(Mesh self, int const * vi, int attr=1)"}, { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "Mesh_AddQuad(Mesh self, int const * vi, int attr=1)"}, @@ -24931,9 +26707,10 @@ static PyMethodDef SwigMethods[] = { { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "Mesh_FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "Mesh_FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "Mesh_FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_O, "Mesh_FinalizeTopology(Mesh self)"}, + { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "Mesh_FinalizeTopology(Mesh self, bool generate_bdr=True)"}, { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Mesh_Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "Mesh_SetAttributes(Mesh self)"}, + { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "Mesh_GetHilbertElementOrdering(Mesh self, intArray ordering)"}, { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "Mesh_ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Mesh_Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Mesh_Clear(Mesh self)"}, @@ -24944,9 +26721,11 @@ static PyMethodDef SwigMethods[] = { { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "Mesh_GetNEdges(Mesh self) -> int"}, { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "Mesh_GetNFaces(Mesh self) -> int"}, { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "Mesh_GetNumFaces(Mesh self) -> int"}, + { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "Mesh_GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "Mesh_ReduceInt(Mesh self, int value) -> long"}, { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "Mesh_GetGlobalNE(Mesh self) -> long"}, { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "Mesh_GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "Mesh_GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "Mesh_DeleteGeometricFactors(Mesh self)"}, { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "Mesh_EulerNumber(Mesh self) -> int"}, { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "Mesh_EulerNumber2D(Mesh self) -> int"}, @@ -25070,14 +26849,21 @@ static PyMethodDef SwigMethods[] = { "Mesh_DerefineByError(Mesh self, doubleArray elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" "Mesh_DerefineByError(Mesh self, Vector elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" ""}, - { "Mesh_KnotInsert", _wrap_Mesh_KnotInsert, METH_VARARGS, "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)"}, + { "Mesh_KnotInsert", _wrap_Mesh_KnotInsert, METH_VARARGS, "\n" + "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" + "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" + ""}, { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "Mesh_DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, - { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "Mesh_EnsureNCMesh(Mesh self, bool triangles_nonconforming=False)"}, + { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "Mesh_EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Mesh_Conforming(Mesh self) -> bool"}, { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Mesh_Nonconforming(Mesh self) -> bool"}, { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "Mesh_GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, { "Mesh_GetLastOperation", _wrap_Mesh_GetLastOperation, METH_O, "Mesh_GetLastOperation(Mesh self) -> mfem::Mesh::Operation"}, { "Mesh_GetSequence", _wrap_Mesh_GetSequence, METH_O, "Mesh_GetSequence(Mesh self) -> long"}, + { "Mesh_PrintVTU", _wrap_Mesh_PrintVTU, METH_VARARGS, "\n" + "Mesh_PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + "Mesh_PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + ""}, { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "Mesh_GetElementColoring(Mesh self, intArray colors, int el0=0)"}, { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "Mesh_PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "Mesh_PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, @@ -25166,6 +26952,26 @@ static PyMethodDef SwigMethods[] = { { "delete_GeometricFactors", _wrap_delete_GeometricFactors, METH_O, "delete_GeometricFactors(GeometricFactors self)"}, { "GeometricFactors_swigregister", GeometricFactors_swigregister, METH_O, NULL}, { "GeometricFactors_swiginit", GeometricFactors_swiginit, METH_VARARGS, NULL}, + { "FaceGeometricFactors_mesh_set", _wrap_FaceGeometricFactors_mesh_set, METH_VARARGS, "FaceGeometricFactors_mesh_set(FaceGeometricFactors self, Mesh mesh)"}, + { "FaceGeometricFactors_mesh_get", _wrap_FaceGeometricFactors_mesh_get, METH_O, "FaceGeometricFactors_mesh_get(FaceGeometricFactors self) -> Mesh"}, + { "FaceGeometricFactors_IntRule_set", _wrap_FaceGeometricFactors_IntRule_set, METH_VARARGS, "FaceGeometricFactors_IntRule_set(FaceGeometricFactors self, IntegrationRule IntRule)"}, + { "FaceGeometricFactors_IntRule_get", _wrap_FaceGeometricFactors_IntRule_get, METH_O, "FaceGeometricFactors_IntRule_get(FaceGeometricFactors self) -> IntegrationRule"}, + { "FaceGeometricFactors_computed_factors_set", _wrap_FaceGeometricFactors_computed_factors_set, METH_VARARGS, "FaceGeometricFactors_computed_factors_set(FaceGeometricFactors self, int computed_factors)"}, + { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, + { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, + { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, + { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, + { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, + { "FaceGeometricFactors_J_get", _wrap_FaceGeometricFactors_J_get, METH_O, "FaceGeometricFactors_J_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_detJ_set", _wrap_FaceGeometricFactors_detJ_set, METH_VARARGS, "FaceGeometricFactors_detJ_set(FaceGeometricFactors self, Vector detJ)"}, + { "FaceGeometricFactors_detJ_get", _wrap_FaceGeometricFactors_detJ_get, METH_O, "FaceGeometricFactors_detJ_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_normal_set", _wrap_FaceGeometricFactors_normal_set, METH_VARARGS, "FaceGeometricFactors_normal_set(FaceGeometricFactors self, Vector normal)"}, + { "FaceGeometricFactors_normal_get", _wrap_FaceGeometricFactors_normal_get, METH_O, "FaceGeometricFactors_normal_get(FaceGeometricFactors self) -> Vector"}, + { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, + { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, + { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "NodeExtrudeCoefficient_SetLayer(NodeExtrudeCoefficient self, int const l)"}, { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" "NodeExtrudeCoefficient_Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -25176,16 +26982,325 @@ static PyMethodDef SwigMethods[] = { { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, - { "named_ifgzstream_filename_set", _wrap_named_ifgzstream_filename_set, METH_VARARGS, "named_ifgzstream_filename_set(named_ifgzstream self, char const * filename)"}, - { "named_ifgzstream_filename_get", _wrap_named_ifgzstream_filename_get, METH_O, "named_ifgzstream_filename_get(named_ifgzstream self) -> char const *"}, - { "new_named_ifgzstream", _wrap_new_named_ifgzstream, METH_O, "new_named_ifgzstream(char const * mesh_name) -> named_ifgzstream"}, - { "delete_named_ifgzstream", _wrap_delete_named_ifgzstream, METH_O, "delete_named_ifgzstream(named_ifgzstream self)"}, - { "named_ifgzstream_swigregister", named_ifgzstream_swigregister, METH_O, NULL}, - { "named_ifgzstream_swiginit", named_ifgzstream_swiginit, METH_VARARGS, NULL}, + { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Mesh_attributes_get", _wrap_Mesh_attributes_get, METH_O, "Mesh_attributes_get(Mesh self) -> intArray"}, + { "Mesh_bdr_attributes_get", _wrap_Mesh_bdr_attributes_get, METH_O, "Mesh_bdr_attributes_get(Mesh self) -> intArray"}, + { "Mesh_NURBSext_set", _wrap_Mesh_NURBSext_set, METH_VARARGS, "Mesh_NURBSext_set(Mesh self, mfem::NURBSExtension * NURBSext)"}, + { "Mesh_NURBSext_get", _wrap_Mesh_NURBSext_get, METH_O, "Mesh_NURBSext_get(Mesh self) -> mfem::NURBSExtension *"}, + { "Mesh_ncmesh_set", _wrap_Mesh_ncmesh_set, METH_VARARGS, "Mesh_ncmesh_set(Mesh self, NCMesh ncmesh)"}, + { "Mesh_ncmesh_get", _wrap_Mesh_ncmesh_get, METH_O, "Mesh_ncmesh_get(Mesh self) -> NCMesh"}, + { "Mesh_geom_factors_set", _wrap_Mesh_geom_factors_set, METH_VARARGS, "Mesh_geom_factors_set(Mesh self, mfem::Array< mfem::GeometricFactors * > * geom_factors)"}, + { "Mesh_geom_factors_get", _wrap_Mesh_geom_factors_get, METH_O, "Mesh_geom_factors_get(Mesh self) -> mfem::Array< mfem::GeometricFactors * > *"}, + { "Mesh_face_geom_factors_set", _wrap_Mesh_face_geom_factors_set, METH_VARARGS, "Mesh_face_geom_factors_set(Mesh self, mfem::Array< mfem::FaceGeometricFactors * > * face_geom_factors)"}, + { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, + { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, + { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, + { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "NewElement(Mesh self, int geom) -> Element"}, + { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "AddSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "AddTri(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "AddTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "AddQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTet", _wrap_Mesh_AddTet, METH_VARARGS, "AddTet(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddWedge", _wrap_Mesh_AddWedge, METH_VARARGS, "AddWedge(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHex", _wrap_Mesh_AddHex, METH_VARARGS, "AddHex(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsTets", _wrap_Mesh_AddHexAsTets, METH_VARARGS, "AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsWedges", _wrap_Mesh_AddHexAsWedges, METH_VARARGS, "AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddElement", _wrap_Mesh_AddElement, METH_VARARGS, "AddElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrElement", _wrap_Mesh_AddBdrElement, METH_VARARGS, "AddBdrElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrSegment", _wrap_Mesh_AddBdrSegment, METH_VARARGS, "AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrTriangle", _wrap_Mesh_AddBdrTriangle, METH_VARARGS, "AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuad", _wrap_Mesh_AddBdrQuad, METH_VARARGS, "AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuadAsTriangles", _wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS, "AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_GenerateBoundaryElements", _wrap_Mesh_GenerateBoundaryElements, METH_O, "GenerateBoundaryElements(Mesh self)"}, + { "Mesh_FinalizeTriMesh", _wrap_Mesh_FinalizeTriMesh, METH_VARARGS, "FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeQuadMesh", _wrap_Mesh_FinalizeQuadMesh, METH_VARARGS, "FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTetMesh", _wrap_Mesh_FinalizeTetMesh, METH_VARARGS, "FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "FinalizeTopology(Mesh self, bool generate_bdr=True)"}, + { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, + { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "SetAttributes(Mesh self)"}, + { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "GetHilbertElementOrdering(Mesh self, intArray ordering)"}, + { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, + { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Clear(Mesh self)"}, + { "Mesh_MeshGenerator", _wrap_Mesh_MeshGenerator, METH_O, "MeshGenerator(Mesh self) -> int"}, + { "Mesh_GetNV", _wrap_Mesh_GetNV, METH_O, "GetNV(Mesh self) -> int"}, + { "Mesh_GetNE", _wrap_Mesh_GetNE, METH_O, "GetNE(Mesh self) -> int"}, + { "Mesh_GetNBE", _wrap_Mesh_GetNBE, METH_O, "GetNBE(Mesh self) -> int"}, + { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "GetNEdges(Mesh self) -> int"}, + { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "GetNFaces(Mesh self) -> int"}, + { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "GetNumFaces(Mesh self) -> int"}, + { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, + { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "ReduceInt(Mesh self, int value) -> long"}, + { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "GetGlobalNE(Mesh self) -> long"}, + { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "DeleteGeometricFactors(Mesh self)"}, + { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "EulerNumber(Mesh self) -> int"}, + { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "EulerNumber2D(Mesh self) -> int"}, + { "Mesh_Dimension", _wrap_Mesh_Dimension, METH_O, "Dimension(Mesh self) -> int"}, + { "Mesh_SpaceDimension", _wrap_Mesh_SpaceDimension, METH_O, "SpaceDimension(Mesh self) -> int"}, + { "Mesh_GetVertex", _wrap_Mesh_GetVertex, METH_VARARGS, "\n" + "GetVertex(Mesh self, int i) -> double const\n" + "GetVertex(Mesh self, int i) -> double *\n" + ""}, + { "Mesh_GetElementData", _wrap_Mesh_GetElementData, METH_VARARGS, "GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, + { "Mesh_GetBdrElementData", _wrap_Mesh_GetBdrElementData, METH_VARARGS, "GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, + { "Mesh_ChangeVertexDataOwnership", _wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS, "ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, + { "Mesh_GetElementsArray", _wrap_Mesh_GetElementsArray, METH_O, "GetElementsArray(Mesh self) -> mfem::Element const *const *"}, + { "Mesh_GetElement", _wrap_Mesh_GetElement, METH_VARARGS, "\n" + "GetElement(Mesh self, int i) -> Element\n" + "GetElement(Mesh self, int i) -> Element\n" + ""}, + { "Mesh_GetBdrElement", _wrap_Mesh_GetBdrElement, METH_VARARGS, "\n" + "GetBdrElement(Mesh self, int i) -> Element\n" + "GetBdrElement(Mesh self, int i) -> Element\n" + ""}, + { "Mesh_GetFace", _wrap_Mesh_GetFace, METH_VARARGS, "GetFace(Mesh self, int i) -> Element"}, + { "Mesh_GetFaceBaseGeometry", _wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS, "GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetElementBaseGeometry", _wrap_Mesh_GetElementBaseGeometry, METH_VARARGS, "GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetBdrElementBaseGeometry", _wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS, "GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_HasGeometry", _wrap_Mesh_HasGeometry, METH_VARARGS, "HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, + { "Mesh_GetNumGeometries", _wrap_Mesh_GetNumGeometries, METH_VARARGS, "GetNumGeometries(Mesh self, int dim) -> int"}, + { "Mesh_GetGeometries", _wrap_Mesh_GetGeometries, METH_VARARGS, "GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, + { "Mesh_GetElementVertices", _wrap_Mesh_GetElementVertices, METH_VARARGS, "GetElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetBdrElementVertices", _wrap_Mesh_GetBdrElementVertices, METH_VARARGS, "GetBdrElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetElementEdges", _wrap_Mesh_GetElementEdges, METH_VARARGS, "GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetBdrElementEdges", _wrap_Mesh_GetBdrElementEdges, METH_VARARGS, "GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetFaceEdges", _wrap_Mesh_GetFaceEdges, METH_VARARGS, "GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetFaceVertices", _wrap_Mesh_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetEdgeVertices", _wrap_Mesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetFaceEdgeTable", _wrap_Mesh_GetFaceEdgeTable, METH_O, "GetFaceEdgeTable(Mesh self) -> Table"}, + { "Mesh_GetEdgeVertexTable", _wrap_Mesh_GetEdgeVertexTable, METH_O, "GetEdgeVertexTable(Mesh self) -> Table"}, + { "Mesh_GetElementFaces", _wrap_Mesh_GetElementFaces, METH_VARARGS, "GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetBdrElementEdgeIndex", _wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS, "GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, + { "Mesh_GetBdrElementAdjacentElement", _wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS, "GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, + { "Mesh_GetElementType", _wrap_Mesh_GetElementType, METH_VARARGS, "GetElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetBdrElementType", _wrap_Mesh_GetBdrElementType, METH_VARARGS, "GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetPointMatrix", _wrap_Mesh_GetPointMatrix, METH_VARARGS, "GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetBdrPointMatrix", _wrap_Mesh_GetBdrPointMatrix, METH_VARARGS, "GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetTransformationFEforElementType", _wrap_Mesh_GetTransformationFEforElementType, METH_O, "GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, + { "Mesh_GetElementTransformation", _wrap_Mesh_GetElementTransformation, METH_VARARGS, "\n" + "GetElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" + "GetElementTransformation(Mesh self, int i) -> ElementTransformation\n" + "GetElementTransformation(Mesh self, int i, Vector nodes, IsoparametricTransformation ElTr)\n" + ""}, + { "Mesh_GetBdrElementTransformation", _wrap_Mesh_GetBdrElementTransformation, METH_VARARGS, "\n" + "GetBdrElementTransformation(Mesh self, int i) -> ElementTransformation\n" + "GetBdrElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" + ""}, + { "Mesh_GetLocalFaceTransformation", _wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS, "GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, + { "Mesh_GetFaceTransformation", _wrap_Mesh_GetFaceTransformation, METH_VARARGS, "\n" + "GetFaceTransformation(Mesh self, int i, IsoparametricTransformation FTr)\n" + "GetFaceTransformation(Mesh self, int FaceNo) -> ElementTransformation\n" + ""}, + { "Mesh_GetEdgeTransformation", _wrap_Mesh_GetEdgeTransformation, METH_VARARGS, "\n" + "GetEdgeTransformation(Mesh self, int i, IsoparametricTransformation EdTr)\n" + "GetEdgeTransformation(Mesh self, int EdgeNo) -> ElementTransformation\n" + ""}, + { "Mesh_GetFaceElementTransformations", _wrap_Mesh_GetFaceElementTransformations, METH_VARARGS, "GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, + { "Mesh_GetInteriorFaceTransformations", _wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS, "GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, + { "Mesh_GetBdrFaceTransformations", _wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS, "GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, + { "Mesh_FaceIsInterior", _wrap_Mesh_FaceIsInterior, METH_VARARGS, "FaceIsInterior(Mesh self, int FaceNo) -> bool"}, + { "Mesh_GetFaceElements", _wrap_Mesh_GetFaceElements, METH_VARARGS, "GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, + { "Mesh_GetFaceInfos", _wrap_Mesh_GetFaceInfos, METH_VARARGS, "GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, + { "Mesh_GetFaceGeometryType", _wrap_Mesh_GetFaceGeometryType, METH_VARARGS, "GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, + { "Mesh_GetFaceElementType", _wrap_Mesh_GetFaceElementType, METH_VARARGS, "GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, + { "Mesh_CheckElementOrientation", _wrap_Mesh_CheckElementOrientation, METH_VARARGS, "CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_CheckBdrElementOrientation", _wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS, "CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_GetAttribute", _wrap_Mesh_GetAttribute, METH_VARARGS, "GetAttribute(Mesh self, int i) -> int"}, + { "Mesh_SetAttribute", _wrap_Mesh_SetAttribute, METH_VARARGS, "SetAttribute(Mesh self, int i, int attr)"}, + { "Mesh_GetBdrAttribute", _wrap_Mesh_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(Mesh self, int i) -> int"}, + { "Mesh_ElementToElementTable", _wrap_Mesh_ElementToElementTable, METH_O, "ElementToElementTable(Mesh self) -> Table"}, + { "Mesh_ElementToFaceTable", _wrap_Mesh_ElementToFaceTable, METH_O, "ElementToFaceTable(Mesh self) -> Table"}, + { "Mesh_ElementToEdgeTable", _wrap_Mesh_ElementToEdgeTable, METH_O, "ElementToEdgeTable(Mesh self) -> Table"}, + { "Mesh_GetVertexToElementTable", _wrap_Mesh_GetVertexToElementTable, METH_O, "GetVertexToElementTable(Mesh self) -> Table"}, + { "Mesh_GetFaceToElementTable", _wrap_Mesh_GetFaceToElementTable, METH_O, "GetFaceToElementTable(Mesh self) -> Table"}, + { "Mesh_ReorientTetMesh", _wrap_Mesh_ReorientTetMesh, METH_O, "ReorientTetMesh(Mesh self)"}, + { "Mesh_CartesianPartitioning", _wrap_Mesh_CartesianPartitioning, METH_VARARGS, "CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, + { "Mesh_GeneratePartitioning", _wrap_Mesh_GeneratePartitioning, METH_VARARGS, "GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int"}, + { "Mesh_CheckPartitioning", _wrap_Mesh_CheckPartitioning, METH_VARARGS, "CheckPartitioning(Mesh self, int * partitioning)"}, + { "Mesh_CheckDisplacements", _wrap_Mesh_CheckDisplacements, METH_VARARGS, "CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, + { "Mesh_MoveVertices", _wrap_Mesh_MoveVertices, METH_VARARGS, "MoveVertices(Mesh self, Vector displacements)"}, + { "Mesh_GetVertices", _wrap_Mesh_GetVertices, METH_VARARGS, "GetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_SetVertices", _wrap_Mesh_SetVertices, METH_VARARGS, "SetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_GetNode", _wrap_Mesh_GetNode, METH_VARARGS, "GetNode(Mesh self, int i, double * coord)"}, + { "Mesh_SetNode", _wrap_Mesh_SetNode, METH_VARARGS, "SetNode(Mesh self, int i, double const * coord)"}, + { "Mesh_MoveNodes", _wrap_Mesh_MoveNodes, METH_VARARGS, "MoveNodes(Mesh self, Vector displacements)"}, + { "Mesh_SetNodes", _wrap_Mesh_SetNodes, METH_VARARGS, "SetNodes(Mesh self, Vector node_coord)"}, + { "Mesh_OwnsNodes", _wrap_Mesh_OwnsNodes, METH_O, "OwnsNodes(Mesh self) -> bool"}, + { "Mesh_SetNodesOwner", _wrap_Mesh_SetNodesOwner, METH_VARARGS, "SetNodesOwner(Mesh self, bool nodes_owner)"}, + { "Mesh_NewNodes", _wrap_Mesh_NewNodes, METH_VARARGS, "NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SwapNodes", _wrap_Mesh_SwapNodes, METH_VARARGS, "SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, + { "Mesh_GetNodes", _wrap_Mesh_GetNodes, METH_VARARGS, "\n" + "GetNodes(Mesh self, Vector node_coord)\n" + "GetNodes(Mesh self) -> GridFunction\n" + "GetNodes(Mesh self) -> GridFunction\n" + "GetNodes(Mesh self, GridFunction nodes)\n" + ""}, + { "Mesh_SetNodalFESpace", _wrap_Mesh_SetNodalFESpace, METH_VARARGS, "SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, + { "Mesh_SetNodalGridFunction", _wrap_Mesh_SetNodalGridFunction, METH_VARARGS, "SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_GetNodalFESpace", _wrap_Mesh_GetNodalFESpace, METH_O, "GetNodalFESpace(Mesh self) -> FiniteElementSpace"}, + { "Mesh_EnsureNodes", _wrap_Mesh_EnsureNodes, METH_O, "EnsureNodes(Mesh self)"}, + { "Mesh_SetCurvature", _wrap_Mesh_SetCurvature, METH_VARARGS, "SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "Mesh_UniformRefinement", _wrap_Mesh_UniformRefinement, METH_VARARGS, "UniformRefinement(Mesh self, int ref_algo=0)"}, + { "Mesh_GeneralRefinement", _wrap_Mesh_GeneralRefinement, METH_VARARGS, "\n" + "GeneralRefinement(Mesh self, mfem::Array< mfem::Refinement > const & refinements, int nonconforming=-1, int nc_limit=0)\n" + "GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0)\n" + ""}, + { "Mesh_RandomRefinement", _wrap_Mesh_RandomRefinement, METH_VARARGS, "RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, + { "Mesh_RefineAtVertex", _wrap_Mesh_RefineAtVertex, METH_VARARGS, "RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, + { "Mesh_RefineByError", _wrap_Mesh_RefineByError, METH_VARARGS, "\n" + "RefineByError(Mesh self, doubleArray elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" + "RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" + ""}, + { "Mesh_DerefineByError", _wrap_Mesh_DerefineByError, METH_VARARGS, "\n" + "DerefineByError(Mesh self, doubleArray elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" + "DerefineByError(Mesh self, Vector elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" + ""}, + { "Mesh_KnotInsert", _wrap_Mesh_KnotInsert, METH_VARARGS, "\n" + "KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" + "KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" + ""}, + { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, + { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, + { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Conforming(Mesh self) -> bool"}, + { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Nonconforming(Mesh self) -> bool"}, + { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, + { "Mesh_GetLastOperation", _wrap_Mesh_GetLastOperation, METH_O, "GetLastOperation(Mesh self) -> mfem::Mesh::Operation"}, + { "Mesh_GetSequence", _wrap_Mesh_GetSequence, METH_O, "GetSequence(Mesh self) -> long"}, + { "Mesh_PrintVTU", _wrap_Mesh_PrintVTU, METH_VARARGS, "\n" + "PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + "PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + ""}, + { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "GetElementColoring(Mesh self, intArray colors, int el0=0)"}, + { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, + { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, + { "Mesh_PrintSurfaces", _wrap_Mesh_PrintSurfaces, METH_VARARGS, "PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, + { "Mesh_ScaleSubdomains", _wrap_Mesh_ScaleSubdomains, METH_VARARGS, "ScaleSubdomains(Mesh self, double sf)"}, + { "Mesh_ScaleElements", _wrap_Mesh_ScaleElements, METH_VARARGS, "ScaleElements(Mesh self, double sf)"}, + { "Mesh_Transform", _wrap_Mesh_Transform, METH_VARARGS, "\n" + "Transform(Mesh self, void (*)(mfem::Vector const &,mfem::Vector &) f)\n" + "Transform(Mesh self, VectorCoefficient deformation)\n" + ""}, + { "Mesh_RemoveUnusedVertices", _wrap_Mesh_RemoveUnusedVertices, METH_O, "RemoveUnusedVertices(Mesh self)"}, + { "Mesh_RemoveInternalBoundaries", _wrap_Mesh_RemoveInternalBoundaries, METH_O, "RemoveInternalBoundaries(Mesh self)"}, + { "Mesh_GetElementSize", _wrap_Mesh_GetElementSize, METH_VARARGS, "\n" + "GetElementSize(Mesh self, int i, int type=0) -> double\n" + "GetElementSize(Mesh self, int i, Vector dir) -> double\n" + ""}, + { "Mesh_GetElementVolume", _wrap_Mesh_GetElementVolume, METH_VARARGS, "GetElementVolume(Mesh self, int i) -> double"}, + { "Mesh_GetBoundingBox", _wrap_Mesh_GetBoundingBox, METH_VARARGS, "GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, + { "Mesh_GetCharacteristics", _wrap_Mesh_GetCharacteristics, METH_VARARGS, "GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, + { "Mesh_PrintElementsByGeometry", _wrap_Mesh_PrintElementsByGeometry, METH_VARARGS, "PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, + { "Mesh_PrintCharacteristics", _wrap_Mesh_PrintCharacteristics, METH_VARARGS, "PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, + { "Mesh_FindPoints", _wrap_Mesh_FindPoints, METH_VARARGS, "FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "delete_Mesh", _wrap_delete_Mesh, METH_O, "delete_Mesh(Mesh self)"}, + { "new_Mesh", _wrap_new_Mesh, METH_VARARGS, "\n" + "Mesh()\n" + "Mesh(Mesh mesh, bool copy_nodes=True)\n" + "Mesh(double * vertices, int num_vertices, int * element_indices, mfem::Geometry::Type element_type, int * element_attributes, int num_elements, int * boundary_indices, mfem::Geometry::Type boundary_type, int * boundary_attributes, int num_boundary_elements, int dimension, int space_dimension=-1)\n" + "Mesh(int _Dim, int NVert, int NElem, int NBdrElem=0, int _spaceDim=-1)\n" + "Mesh(int nx, int ny, int nz, mfem::Element::Type type, bool generate_edges=False, double sx=1.0, double sy=1.0, double sz=1.0, bool sfc_ordering=True)\n" + "Mesh(int nx, int ny, mfem::Element::Type type, bool generate_edges=False, double sx=1.0, double sy=1.0, bool sfc_ordering=True)\n" + "Mesh(int n, double sx=1.0)\n" + "Mesh(char const * filename, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + "Mesh(std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + "Mesh(mfem::Mesh *[] mesh_array, int num_pieces)\n" + "Mesh(Mesh orig_mesh, int ref_factor, int ref_type)\n" + "Mesh(int nx, int ny, int nz, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0, double sz=1.0)\n" + "Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0)\n" + ""}, + { "Mesh_PrintToFile", _wrap_Mesh_PrintToFile, METH_VARARGS, "PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, + { "Mesh_GetAttributeArray", _wrap_Mesh_GetAttributeArray, METH_O, "GetAttributeArray(Mesh self) -> PyObject *"}, + { "Mesh_GetVertexArray", _wrap_Mesh_GetVertexArray, METH_VARARGS, "GetVertexArray(Mesh self, int i) -> PyObject *"}, + { "Mesh_GetBdrElementFace", _wrap_Mesh_GetBdrElementFace, METH_VARARGS, "\n" + "GetBdrElementFace(Mesh self, int i, int * arg3, int * arg4)\n" + "GetBdrElementFace(Mesh self, int i) -> PyObject *\n" + ""}, + { "Mesh_GetBdrAttributeArray", _wrap_Mesh_GetBdrAttributeArray, METH_O, "GetBdrAttributeArray(Mesh self) -> PyObject *"}, + { "Mesh_GetBdrArray", _wrap_Mesh_GetBdrArray, METH_VARARGS, "GetBdrArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetDomainArray", _wrap_Mesh_GetDomainArray, METH_VARARGS, "GetDomainArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_PrintInfo", _wrap_Mesh_PrintInfo, METH_VARARGS, "\n" + "PrintInfo(Mesh self, std::ostream & out=mfem::out)\n" + "PrintInfo(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_Print", _wrap_Mesh_Print, METH_VARARGS, "\n" + "Print(Mesh self, std::ostream & out=mfem::out)\n" + "Print(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_PrintXG", _wrap_Mesh_PrintXG, METH_VARARGS, "\n" + "PrintXG(Mesh self, std::ostream & out=mfem::out)\n" + "PrintXG(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_PrintVTK", _wrap_Mesh_PrintVTK, METH_VARARGS, "\n" + "PrintVTK(Mesh self, std::ostream & out)\n" + "PrintVTK(Mesh self, std::ostream & out, int ref, int field_data=0)\n" + "PrintVTK(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_swigregister", Mesh_swigregister, METH_O, NULL}, + { "Mesh_swiginit", Mesh_swiginit, METH_VARARGS, NULL}, + { "__lshift__", _wrap___lshift__, METH_VARARGS, "\n" + "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" + "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream\n" + "__lshift__(std::ostream & out, Mesh mesh) -> std::ostream &\n" + ""}, + { "GeometricFactors_mesh_set", _wrap_GeometricFactors_mesh_set, METH_VARARGS, "GeometricFactors_mesh_set(GeometricFactors self, Mesh mesh)"}, + { "GeometricFactors_mesh_get", _wrap_GeometricFactors_mesh_get, METH_O, "GeometricFactors_mesh_get(GeometricFactors self) -> Mesh"}, + { "GeometricFactors_IntRule_set", _wrap_GeometricFactors_IntRule_set, METH_VARARGS, "GeometricFactors_IntRule_set(GeometricFactors self, IntegrationRule IntRule)"}, + { "GeometricFactors_IntRule_get", _wrap_GeometricFactors_IntRule_get, METH_O, "GeometricFactors_IntRule_get(GeometricFactors self) -> IntegrationRule"}, + { "GeometricFactors_computed_factors_set", _wrap_GeometricFactors_computed_factors_set, METH_VARARGS, "GeometricFactors_computed_factors_set(GeometricFactors self, int computed_factors)"}, + { "GeometricFactors_computed_factors_get", _wrap_GeometricFactors_computed_factors_get, METH_O, "GeometricFactors_computed_factors_get(GeometricFactors self) -> int"}, + { "new_GeometricFactors", _wrap_new_GeometricFactors, METH_VARARGS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, + { "GeometricFactors_X_set", _wrap_GeometricFactors_X_set, METH_VARARGS, "GeometricFactors_X_set(GeometricFactors self, Vector X)"}, + { "GeometricFactors_X_get", _wrap_GeometricFactors_X_get, METH_O, "GeometricFactors_X_get(GeometricFactors self) -> Vector"}, + { "GeometricFactors_J_set", _wrap_GeometricFactors_J_set, METH_VARARGS, "GeometricFactors_J_set(GeometricFactors self, Vector J)"}, + { "GeometricFactors_J_get", _wrap_GeometricFactors_J_get, METH_O, "GeometricFactors_J_get(GeometricFactors self) -> Vector"}, + { "GeometricFactors_detJ_set", _wrap_GeometricFactors_detJ_set, METH_VARARGS, "GeometricFactors_detJ_set(GeometricFactors self, Vector detJ)"}, + { "GeometricFactors_detJ_get", _wrap_GeometricFactors_detJ_get, METH_O, "GeometricFactors_detJ_get(GeometricFactors self) -> Vector"}, + { "delete_GeometricFactors", _wrap_delete_GeometricFactors, METH_O, "delete_GeometricFactors(GeometricFactors self)"}, + { "GeometricFactors_swigregister", GeometricFactors_swigregister, METH_O, NULL}, + { "GeometricFactors_swiginit", GeometricFactors_swiginit, METH_VARARGS, NULL}, + { "FaceGeometricFactors_mesh_set", _wrap_FaceGeometricFactors_mesh_set, METH_VARARGS, "FaceGeometricFactors_mesh_set(FaceGeometricFactors self, Mesh mesh)"}, + { "FaceGeometricFactors_mesh_get", _wrap_FaceGeometricFactors_mesh_get, METH_O, "FaceGeometricFactors_mesh_get(FaceGeometricFactors self) -> Mesh"}, + { "FaceGeometricFactors_IntRule_set", _wrap_FaceGeometricFactors_IntRule_set, METH_VARARGS, "FaceGeometricFactors_IntRule_set(FaceGeometricFactors self, IntegrationRule IntRule)"}, + { "FaceGeometricFactors_IntRule_get", _wrap_FaceGeometricFactors_IntRule_get, METH_O, "FaceGeometricFactors_IntRule_get(FaceGeometricFactors self) -> IntegrationRule"}, + { "FaceGeometricFactors_computed_factors_set", _wrap_FaceGeometricFactors_computed_factors_set, METH_VARARGS, "FaceGeometricFactors_computed_factors_set(FaceGeometricFactors self, int computed_factors)"}, + { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, + { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, + { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, + { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, + { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, + { "FaceGeometricFactors_J_get", _wrap_FaceGeometricFactors_J_get, METH_O, "FaceGeometricFactors_J_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_detJ_set", _wrap_FaceGeometricFactors_detJ_set, METH_VARARGS, "FaceGeometricFactors_detJ_set(FaceGeometricFactors self, Vector detJ)"}, + { "FaceGeometricFactors_detJ_get", _wrap_FaceGeometricFactors_detJ_get, METH_O, "FaceGeometricFactors_detJ_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_normal_set", _wrap_FaceGeometricFactors_normal_set, METH_VARARGS, "FaceGeometricFactors_normal_set(FaceGeometricFactors self, Vector normal)"}, + { "FaceGeometricFactors_normal_get", _wrap_FaceGeometricFactors_normal_get, METH_O, "FaceGeometricFactors_normal_get(FaceGeometricFactors self) -> Vector"}, + { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, + { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, + { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, + { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "SetLayer(NodeExtrudeCoefficient self, int const l)"}, + { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" + "Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(NodeExtrudeCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_NodeExtrudeCoefficient", _wrap_delete_NodeExtrudeCoefficient, METH_O, "delete_NodeExtrudeCoefficient(NodeExtrudeCoefficient self)"}, + { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, + { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, + { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, + { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; @@ -25255,12 +27370,6 @@ static void *_p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformatio static void *_p_mfem__IntegrationRuleTo_p_mfem__ArrayT_mfem__IntegrationPoint_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Array< mfem::IntegrationPoint > *) ((mfem::IntegrationRule *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -25294,6 +27403,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -25309,6 +27421,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -25477,6 +27592,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -25520,10 +27641,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -25548,6 +27669,7 @@ static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement(void *x, int } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_f_r_q_const__mfem__Vector_r_mfem__Vector__void = {"_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void", "void (*)(mfem::Vector const &,mfem::Vector &)", 0, 0, (void*)0, 0}; @@ -25555,16 +27677,19 @@ static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_double_t = {"_p_mfem__ArrayT_double_t", "mfem::Array< double > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t = {"_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t", "mfem::Array< mfem::FaceGeometricFactors * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__GeometricFactors_p_t = {"_p_mfem__ArrayT_mfem__GeometricFactors_p_t", "mfem::Array< mfem::GeometricFactors * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__Geometry__Type_t = {"_p_mfem__ArrayT_mfem__Geometry__Type_t", "mfem::Array< enum mfem::Geometry::Type > *|mfem::Array< mfem::Geometry::Type > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__IntegrationPoint_t = {"_p_mfem__ArrayT_mfem__IntegrationPoint_t", "mfem::Array< mfem::IntegrationPoint > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__KnotVector_p_t = {"_p_mfem__ArrayT_mfem__KnotVector_p_t", "mfem::Array< mfem::KnotVector * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__Refinement_t = {"_p_mfem__ArrayT_mfem__Refinement_t", "mfem::Array< mfem::Refinement > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_mfem__Vector_p_t = {"_p_mfem__ArrayT_mfem__Vector_p_t", "mfem::Array< mfem::Vector * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__CoarseFineTransformations = {"_p_mfem__CoarseFineTransformations", "mfem::CoarseFineTransformations *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mfem::DenseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Element = {"_p_mfem__Element", "mfem::Element *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ElementTransformation = {"_p_mfem__ElementTransformation", "mfem::ElementTransformation *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FaceElementTransformations = {"_p_mfem__FaceElementTransformations", "mfem::FaceElementTransformations *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FaceGeometricFactors = {"_p_mfem__FaceGeometricFactors", "mfem::FaceGeometricFactors *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FiniteElement = {"_p_mfem__FiniteElement", "mfem::FiniteElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__P0HexFiniteElement = {"_p_mfem__P0HexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LagrangeHexFiniteElement = {"_p_mfem__LagrangeHexFiniteElement", 0, 0, 0, 0, 0}; @@ -25581,13 +27706,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -25599,6 +27722,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -25640,6 +27765,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -25697,7 +27824,6 @@ static swig_type_info _swigt__p_mfem__VectorArrayCoefficient = {"_p_mfem__Vector static swig_type_info _swigt__p_mfem__VectorFunctionCoefficient = {"_p_mfem__VectorFunctionCoefficient", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorConstantCoefficient = {"_p_mfem__VectorConstantCoefficient", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Vertex = {"_p_mfem__Vertex", "mfem::Vertex *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__named_ifgzstream = {"_p_mfem__named_ifgzstream", "mfem::named_ifgzstream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__Element = {"_p_p_mfem__Element", "mfem::Element **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__GridFunction = {"_p_p_mfem__GridFunction", "mfem::GridFunction **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__Mesh = {"_p_p_mfem__Mesh", "mfem::Mesh **", 0, 0, (void*)0, 0}; @@ -25706,12 +27832,14 @@ static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*) static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_f_r_q_const__mfem__Vector_r_mfem__Vector__void, @@ -25719,11 +27847,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_int, &_swigt__p_mfem__ArrayT_double_t, &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, &_swigt__p_mfem__ArrayT_mfem__GeometricFactors_p_t, &_swigt__p_mfem__ArrayT_mfem__Geometry__Type_t, &_swigt__p_mfem__ArrayT_mfem__IntegrationPoint_t, &_swigt__p_mfem__ArrayT_mfem__KnotVector_p_t, &_swigt__p_mfem__ArrayT_mfem__Refinement_t, + &_swigt__p_mfem__ArrayT_mfem__Vector_p_t, &_swigt__p_mfem__BiCubic2DFiniteElement, &_swigt__p_mfem__BiCubic3DFiniteElement, &_swigt__p_mfem__BiLinear2DFiniteElement, @@ -25742,6 +27872,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__Element, &_swigt__p_mfem__ElementTransformation, &_swigt__p_mfem__FaceElementTransformations, + &_swigt__p_mfem__FaceGeometricFactors, &_swigt__p_mfem__FiniteElement, &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__GaussBiLinear2DFiniteElement, @@ -25757,6 +27888,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -25860,8 +27992,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorPyCoefficientBase, &_swigt__p_mfem__VectorRestrictedCoefficient, &_swigt__p_mfem__VectorSumCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_mfem__Vertex, - &_swigt__p_mfem__named_ifgzstream, &_swigt__p_p_mfem__Element, &_swigt__p_p_mfem__GridFunction, &_swigt__p_p_mfem__Mesh, @@ -25870,12 +28002,14 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_seg_t, &_swigt__p_std__istream, &_swigt__p_std__ostream, + &_swigt__p_std__string, &_swigt__p_tet_t, &_swigt__p_tri_t, }; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_f_r_q_const__mfem__Vector_r_mfem__Vector__void[] = { {&_swigt__p_f_r_q_const__mfem__Vector_r_mfem__Vector__void, 0, 0, 0},{0, 0, 0, 0}}; @@ -25883,16 +28017,19 @@ static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_double_t[] = { {&_swigt__p_mfem__ArrayT_double_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__GeometricFactors_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__GeometricFactors_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__Geometry__Type_t[] = { {&_swigt__p_mfem__ArrayT_mfem__Geometry__Type_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__IntegrationPoint_t[] = { {&_swigt__p_mfem__ArrayT_mfem__IntegrationPoint_t, 0, 0, 0}, {&_swigt__p_mfem__IntegrationRule, _p_mfem__IntegrationRuleTo_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__KnotVector_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__KnotVector_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__Refinement_t[] = { {&_swigt__p_mfem__ArrayT_mfem__Refinement_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_mfem__Vector_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__Vector_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CoarseFineTransformations[] = { {&_swigt__p_mfem__CoarseFineTransformations, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Element[] = { {&_swigt__p_mfem__Element, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0}, {&_swigt__p_mfem__IsoparametricTransformation, _p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FaceElementTransformations[] = { {&_swigt__p_mfem__FaceElementTransformations, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FaceGeometricFactors[] = { {&_swigt__p_mfem__FaceGeometricFactors, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0HexFiniteElement[] = {{&_swigt__p_mfem__P0HexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LagrangeHexFiniteElement[] = {{&_swigt__p_mfem__LagrangeHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RefinedLinear1DFiniteElement[] = {{&_swigt__p_mfem__RefinedLinear1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -25908,13 +28045,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -25926,6 +28061,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -25967,6 +28104,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -25990,7 +28129,7 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GeometricFactors[] = { {&_swigt__p_mfem__GeometricFactors, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -26025,7 +28164,6 @@ static swig_cast_info _swigc__p_mfem__VectorFunctionCoefficient[] = {{&_swigt__p static swig_cast_info _swigc__p_mfem__VectorConstantCoefficient[] = {{&_swigt__p_mfem__VectorConstantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCoefficient[] = { {&_swigt__p_mfem__VectorPyCoefficientBase, _p_mfem__VectorPyCoefficientBaseTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__NodeExtrudeCoefficient, _p_mfem__NodeExtrudeCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__MatVecCoefficient, _p_mfem__MatVecCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorCrossProductCoefficient, _p_mfem__VectorCrossProductCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductCoefficient, _p_mfem__ScalarVectorProductCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorSumCoefficient, _p_mfem__VectorSumCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorRestrictedCoefficient, _p_mfem__VectorRestrictedCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorDeltaCoefficient, _p_mfem__VectorDeltaCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__CurlGridFunctionCoefficient, _p_mfem__CurlGridFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__GradientGridFunctionCoefficient, _p_mfem__GradientGridFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorGridFunctionCoefficient, _p_mfem__VectorGridFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorArrayCoefficient, _p_mfem__VectorArrayCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorFunctionCoefficient, _p_mfem__VectorFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorCoefficient, 0, 0, 0}, {&_swigt__p_mfem__VectorConstantCoefficient, _p_mfem__VectorConstantCoefficientTo_p_mfem__VectorCoefficient, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vertex[] = { {&_swigt__p_mfem__Vertex, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__named_ifgzstream[] = { {&_swigt__p_mfem__named_ifgzstream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Element[] = { {&_swigt__p_p_mfem__Element, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__GridFunction[] = { {&_swigt__p_p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Mesh[] = { {&_swigt__p_p_mfem__Mesh, 0, 0, 0},{0, 0, 0, 0}}; @@ -26034,12 +28172,14 @@ static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0 static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_f_r_q_const__mfem__Vector_r_mfem__Vector__void, @@ -26047,11 +28187,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_int, _swigc__p_mfem__ArrayT_double_t, _swigc__p_mfem__ArrayT_int_t, + _swigc__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, _swigc__p_mfem__ArrayT_mfem__GeometricFactors_p_t, _swigc__p_mfem__ArrayT_mfem__Geometry__Type_t, _swigc__p_mfem__ArrayT_mfem__IntegrationPoint_t, _swigc__p_mfem__ArrayT_mfem__KnotVector_p_t, _swigc__p_mfem__ArrayT_mfem__Refinement_t, + _swigc__p_mfem__ArrayT_mfem__Vector_p_t, _swigc__p_mfem__BiCubic2DFiniteElement, _swigc__p_mfem__BiCubic3DFiniteElement, _swigc__p_mfem__BiLinear2DFiniteElement, @@ -26070,6 +28212,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__Element, _swigc__p_mfem__ElementTransformation, _swigc__p_mfem__FaceElementTransformations, + _swigc__p_mfem__FaceGeometricFactors, _swigc__p_mfem__FiniteElement, _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__GaussBiLinear2DFiniteElement, @@ -26085,6 +28228,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -26188,8 +28332,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorPyCoefficientBase, _swigc__p_mfem__VectorRestrictedCoefficient, _swigc__p_mfem__VectorSumCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_mfem__Vertex, - _swigc__p_mfem__named_ifgzstream, _swigc__p_p_mfem__Element, _swigc__p_p_mfem__GridFunction, _swigc__p_p_mfem__Mesh, @@ -26198,6 +28342,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_seg_t, _swigc__p_std__istream, _swigc__p_std__ostream, + _swigc__p_std__string, _swigc__p_tet_t, _swigc__p_tri_t, }; @@ -26932,6 +29077,8 @@ SWIG_init(void) { import_array(); + SWIG_Python_SetConstant(d, "FaceType_Interior",SWIG_From_int(static_cast< int >(mfem::FaceType::Interior))); + SWIG_Python_SetConstant(d, "FaceType_Boundary",SWIG_From_int(static_cast< int >(mfem::FaceType::Boundary))); SWIG_Python_SetConstant(d, "Mesh_NONE",SWIG_From_int(static_cast< int >(mfem::Mesh::NONE))); SWIG_Python_SetConstant(d, "Mesh_REFINE",SWIG_From_int(static_cast< int >(mfem::Mesh::REFINE))); SWIG_Python_SetConstant(d, "Mesh_DEREFINE",SWIG_From_int(static_cast< int >(mfem::Mesh::DEREFINE))); @@ -26951,6 +29098,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "GeometricFactors_COORDINATES",SWIG_From_int(static_cast< int >(mfem::GeometricFactors::COORDINATES))); SWIG_Python_SetConstant(d, "GeometricFactors_JACOBIANS",SWIG_From_int(static_cast< int >(mfem::GeometricFactors::JACOBIANS))); SWIG_Python_SetConstant(d, "GeometricFactors_DETERMINANTS",SWIG_From_int(static_cast< int >(mfem::GeometricFactors::DETERMINANTS))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_COORDINATES",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::COORDINATES))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_JACOBIANS",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::JACOBIANS))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_DETERMINANTS",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::DETERMINANTS))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_NORMALS",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::NORMALS))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/ncmesh.py b/mfem/_par/ncmesh.py index 53da65f4..59f06789 100644 --- a/mfem/_par/ncmesh.py +++ b/mfem/_par/ncmesh.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _ncmesh.SWIG_PyInstanceMethod_New +_swig_new_static_method = _ncmesh.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -69,6 +72,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.array import mfem._par.mem_manager import mfem._par.operators +import mfem._par.vtk import mfem._par.element import mfem._par.densemat import mfem._par.geom @@ -86,6 +90,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform class Refinement(object): @@ -131,24 +136,28 @@ class CoarseFineTransformations(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - point_matrices = property(_ncmesh.CoarseFineTransformations_point_matrices_get, _ncmesh.CoarseFineTransformations_point_matrices_set, doc=r"""point_matrices : std::map<(mfem::Geometry::Type,mfem::DenseTensor)>""") + point_matrices = property(_ncmesh.CoarseFineTransformations_point_matrices_get, _ncmesh.CoarseFineTransformations_point_matrices_set, doc=r"""point_matrices : a(mfem::Geometry::NumGeom).mfem::DenseTensor""") embeddings = property(_ncmesh.CoarseFineTransformations_embeddings_get, doc=r"""embeddings : mfem::Array<(mfem::Embedding)>""") - def GetPointMatrices(self, geom): - r"""GetPointMatrices(CoarseFineTransformations self, mfem::Geometry::Type geom) -> DenseTensor""" - return _ncmesh.CoarseFineTransformations_GetPointMatrices(self, geom) - def GetCoarseToFineMap(self, fine_mesh, coarse_to_fine, coarse_to_ref_type, ref_type_to_matrix, ref_type_to_geom): r"""GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)""" return _ncmesh.CoarseFineTransformations_GetCoarseToFineMap(self, fine_mesh, coarse_to_fine, coarse_to_ref_type, ref_type_to_matrix, ref_type_to_geom) + GetCoarseToFineMap = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_GetCoarseToFineMap) def Clear(self): r"""Clear(CoarseFineTransformations self)""" return _ncmesh.CoarseFineTransformations_Clear(self) + Clear = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_Clear) + + def IsInitialized(self): + r"""IsInitialized(CoarseFineTransformations self) -> bool""" + return _ncmesh.CoarseFineTransformations_IsInitialized(self) + IsInitialized = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_IsInitialized) def MemoryUsage(self): r"""MemoryUsage(CoarseFineTransformations self) -> long""" return _ncmesh.CoarseFineTransformations_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_MemoryUsage) def __init__(self): r"""__init__(CoarseFineTransformations self) -> CoarseFineTransformations""" @@ -175,140 +184,189 @@ def __init__(self, *args): def Dimension(self): r"""Dimension(NCMesh self) -> int""" return _ncmesh.NCMesh_Dimension(self) + Dimension = _swig_new_instance_method(_ncmesh.NCMesh_Dimension) def SpaceDimension(self): r"""SpaceDimension(NCMesh self) -> int""" return _ncmesh.NCMesh_SpaceDimension(self) + SpaceDimension = _swig_new_instance_method(_ncmesh.NCMesh_SpaceDimension) def GetNVertices(self): r"""GetNVertices(NCMesh self) -> int""" return _ncmesh.NCMesh_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_ncmesh.NCMesh_GetNVertices) def GetNEdges(self): r"""GetNEdges(NCMesh self) -> int""" return _ncmesh.NCMesh_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_ncmesh.NCMesh_GetNEdges) def GetNFaces(self): r"""GetNFaces(NCMesh self) -> int""" return _ncmesh.NCMesh_GetNFaces(self) + GetNFaces = _swig_new_instance_method(_ncmesh.NCMesh_GetNFaces) def Refine(self, refinements): r"""Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)""" return _ncmesh.NCMesh_Refine(self, refinements) + Refine = _swig_new_instance_method(_ncmesh.NCMesh_Refine) def LimitNCLevel(self, max_nc_level): r"""LimitNCLevel(NCMesh self, int max_nc_level)""" return _ncmesh.NCMesh_LimitNCLevel(self, max_nc_level) + LimitNCLevel = _swig_new_instance_method(_ncmesh.NCMesh_LimitNCLevel) def GetDerefinementTable(self): r"""GetDerefinementTable(NCMesh self) -> Table""" return _ncmesh.NCMesh_GetDerefinementTable(self) + GetDerefinementTable = _swig_new_instance_method(_ncmesh.NCMesh_GetDerefinementTable) def CheckDerefinementNCLevel(self, deref_table, level_ok, max_nc_level): r"""CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)""" return _ncmesh.NCMesh_CheckDerefinementNCLevel(self, deref_table, level_ok, max_nc_level) + CheckDerefinementNCLevel = _swig_new_instance_method(_ncmesh.NCMesh_CheckDerefinementNCLevel) def Derefine(self, derefs): r"""Derefine(NCMesh self, intArray derefs)""" return _ncmesh.NCMesh_Derefine(self, derefs) + Derefine = _swig_new_instance_method(_ncmesh.NCMesh_Derefine) def GetFaceList(self): r"""GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetFaceList(self) + GetFaceList = _swig_new_instance_method(_ncmesh.NCMesh_GetFaceList) def GetEdgeList(self): r"""GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetEdgeList(self) + GetEdgeList = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeList) def GetVertexList(self): r"""GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetVertexList(self) + GetVertexList = _swig_new_instance_method(_ncmesh.NCMesh_GetVertexList) def GetNCList(self, entity): r"""GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetNCList(self, entity) + GetNCList = _swig_new_instance_method(_ncmesh.NCMesh_GetNCList) def MarkCoarseLevel(self): r"""MarkCoarseLevel(NCMesh self)""" return _ncmesh.NCMesh_MarkCoarseLevel(self) + MarkCoarseLevel = _swig_new_instance_method(_ncmesh.NCMesh_MarkCoarseLevel) def GetRefinementTransforms(self): r"""GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations""" return _ncmesh.NCMesh_GetRefinementTransforms(self) + GetRefinementTransforms = _swig_new_instance_method(_ncmesh.NCMesh_GetRefinementTransforms) def GetDerefinementTransforms(self): r"""GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations""" return _ncmesh.NCMesh_GetDerefinementTransforms(self) + GetDerefinementTransforms = _swig_new_instance_method(_ncmesh.NCMesh_GetDerefinementTransforms) def ClearTransforms(self): r"""ClearTransforms(NCMesh self)""" return _ncmesh.NCMesh_ClearTransforms(self) + ClearTransforms = _swig_new_instance_method(_ncmesh.NCMesh_ClearTransforms) @staticmethod def GridSfcOrdering2D(width, height, coords): r"""GridSfcOrdering2D(int width, int height, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering2D(width, height, coords) + GridSfcOrdering2D = _swig_new_static_method(_ncmesh.NCMesh_GridSfcOrdering2D) @staticmethod def GridSfcOrdering3D(width, height, depth, coords): r"""GridSfcOrdering3D(int width, int height, int depth, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering3D(width, height, depth, coords) + GridSfcOrdering3D = _swig_new_static_method(_ncmesh.NCMesh_GridSfcOrdering3D) def GetEdgeVertices(self, edge_id, vert_index, oriented=True): r"""GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)""" return _ncmesh.NCMesh_GetEdgeVertices(self, edge_id, vert_index, oriented) + GetEdgeVertices = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeVertices) def GetEdgeNCOrientation(self, edge_id): r"""GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int""" return _ncmesh.NCMesh_GetEdgeNCOrientation(self, edge_id) + GetEdgeNCOrientation = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeNCOrientation) def GetFaceVerticesEdges(self, face_id, vert_index, edge_index, edge_orientation): - r"""GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation)""" + r"""GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int""" return _ncmesh.NCMesh_GetFaceVerticesEdges(self, face_id, vert_index, edge_index, edge_orientation) + GetFaceVerticesEdges = _swig_new_instance_method(_ncmesh.NCMesh_GetFaceVerticesEdges) def GetEdgeMaster(self, v1, v2): r"""GetEdgeMaster(NCMesh self, int v1, int v2) -> int""" return _ncmesh.NCMesh_GetEdgeMaster(self, v1, v2) + GetEdgeMaster = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeMaster) def GetBoundaryClosure(self, bdr_attr_is_ess, bdr_vertices, bdr_edges): r"""GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)""" return _ncmesh.NCMesh_GetBoundaryClosure(self, bdr_attr_is_ess, bdr_vertices, bdr_edges) + GetBoundaryClosure = _swig_new_instance_method(_ncmesh.NCMesh_GetBoundaryClosure) - def GetElementGeometry(self): - r"""GetElementGeometry(NCMesh self) -> mfem::Geometry::Type""" - return _ncmesh.NCMesh_GetElementGeometry(self) + def GetElementGeometry(self, index): + r"""GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type""" + return _ncmesh.NCMesh_GetElementGeometry(self, index) + GetElementGeometry = _swig_new_instance_method(_ncmesh.NCMesh_GetElementGeometry) - def GetFaceGeometry(self): - r"""GetFaceGeometry(NCMesh self) -> mfem::Geometry::Type""" - return _ncmesh.NCMesh_GetFaceGeometry(self) + def GetFaceGeometry(self, index): + r"""GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type""" + return _ncmesh.NCMesh_GetFaceGeometry(self, index) + GetFaceGeometry = _swig_new_instance_method(_ncmesh.NCMesh_GetFaceGeometry) + + def GetNumRootElements(self): + r"""GetNumRootElements(NCMesh self) -> int""" + return _ncmesh.NCMesh_GetNumRootElements(self) + GetNumRootElements = _swig_new_instance_method(_ncmesh.NCMesh_GetNumRootElements) def GetElementDepth(self, i): r"""GetElementDepth(NCMesh self, int i) -> int""" return _ncmesh.NCMesh_GetElementDepth(self, i) + GetElementDepth = _swig_new_instance_method(_ncmesh.NCMesh_GetElementDepth) + + def GetElementSizeReduction(self, i): + r"""GetElementSizeReduction(NCMesh self, int i) -> int""" + return _ncmesh.NCMesh_GetElementSizeReduction(self, i) + GetElementSizeReduction = _swig_new_instance_method(_ncmesh.NCMesh_GetElementSizeReduction) + + def GetElementFacesAttributes(self, i, faces, fattr): + r"""GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)""" + return _ncmesh.NCMesh_GetElementFacesAttributes(self, i, faces, fattr) + GetElementFacesAttributes = _swig_new_instance_method(_ncmesh.NCMesh_GetElementFacesAttributes) def LoadVertexParents(self, input): r"""LoadVertexParents(NCMesh self, std::istream & input)""" return _ncmesh.NCMesh_LoadVertexParents(self, input) + LoadVertexParents = _swig_new_instance_method(_ncmesh.NCMesh_LoadVertexParents) def LoadCoarseElements(self, input): r"""LoadCoarseElements(NCMesh self, std::istream & input)""" return _ncmesh.NCMesh_LoadCoarseElements(self, input) + LoadCoarseElements = _swig_new_instance_method(_ncmesh.NCMesh_LoadCoarseElements) def SetVertexPositions(self, vertices): r"""SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)""" return _ncmesh.NCMesh_SetVertexPositions(self, vertices) + SetVertexPositions = _swig_new_instance_method(_ncmesh.NCMesh_SetVertexPositions) def Trim(self): r"""Trim(NCMesh self)""" return _ncmesh.NCMesh_Trim(self) + Trim = _swig_new_instance_method(_ncmesh.NCMesh_Trim) def MemoryUsage(self): r"""MemoryUsage(NCMesh self) -> long""" return _ncmesh.NCMesh_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_ncmesh.NCMesh_MemoryUsage) def PrintMemoryDetail(self): r"""PrintMemoryDetail(NCMesh self) -> int""" return _ncmesh.NCMesh_PrintMemoryDetail(self) + PrintMemoryDetail = _swig_new_instance_method(_ncmesh.NCMesh_PrintMemoryDetail) def PrintVertexParents(self, *args): r""" @@ -317,6 +375,7 @@ def PrintVertexParents(self, *args): PrintVertexParents(NCMesh self) """ return _ncmesh.NCMesh_PrintVertexParents(self, *args) + PrintVertexParents = _swig_new_instance_method(_ncmesh.NCMesh_PrintVertexParents) def PrintCoarseElements(self, *args): r""" @@ -325,6 +384,7 @@ def PrintCoarseElements(self, *args): PrintCoarseElements(NCMesh self) """ return _ncmesh.NCMesh_PrintCoarseElements(self, *args) + PrintCoarseElements = _swig_new_instance_method(_ncmesh.NCMesh_PrintCoarseElements) def PrintStats(self, *args): r""" @@ -332,6 +392,7 @@ def PrintStats(self, *args): PrintStats(NCMesh self, char const * file, int precision=8) """ return _ncmesh.NCMesh_PrintStats(self, *args) + PrintStats = _swig_new_instance_method(_ncmesh.NCMesh_PrintStats) # Register NCMesh in _ncmesh: _ncmesh.NCMesh_swigregister(NCMesh) @@ -339,10 +400,12 @@ def PrintStats(self, *args): def NCMesh_GridSfcOrdering2D(width, height, coords): r"""NCMesh_GridSfcOrdering2D(int width, int height, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering2D(width, height, coords) +NCMesh_GridSfcOrdering2D = _ncmesh.NCMesh_GridSfcOrdering2D def NCMesh_GridSfcOrdering3D(width, height, depth, coords): r"""NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering3D(width, height, depth, coords) +NCMesh_GridSfcOrdering3D = _ncmesh.NCMesh_GridSfcOrdering3D diff --git a/mfem/_par/ncmesh_wrap.cxx b/mfem/_par/ncmesh_wrap.cxx index 2f3e6c81..21f56cb5 100644 --- a/mfem/_par/ncmesh_wrap.cxx +++ b/mfem/_par/ncmesh_wrap.cxx @@ -3067,33 +3067,33 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Embedding_t swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t swig_types[9] -#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[10] -#define SWIGTYPE_p_mfem__DenseTensor swig_types[11] -#define SWIGTYPE_p_mfem__Embedding swig_types[12] -#define SWIGTYPE_p_mfem__GridFunction swig_types[13] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[14] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[15] -#define SWIGTYPE_p_mfem__Mesh swig_types[16] -#define SWIGTYPE_p_mfem__NCMesh swig_types[17] -#define SWIGTYPE_p_mfem__NCMesh__MeshId swig_types[18] -#define SWIGTYPE_p_mfem__NCMesh__NCList swig_types[19] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[20] -#define SWIGTYPE_p_mfem__Refinement swig_types[21] -#define SWIGTYPE_p_mfem__STable swig_types[22] -#define SWIGTYPE_p_mfem__Table swig_types[23] -#define SWIGTYPE_p_pri_t swig_types[24] -#define SWIGTYPE_p_quad_t swig_types[25] -#define SWIGTYPE_p_seg_t swig_types[26] -#define SWIGTYPE_p_std__istream swig_types[27] -#define SWIGTYPE_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t swig_types[28] +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Embedding_t swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t swig_types[10] +#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[11] +#define SWIGTYPE_p_mfem__DenseTensor swig_types[12] +#define SWIGTYPE_p_mfem__Embedding swig_types[13] +#define SWIGTYPE_p_mfem__GridFunction swig_types[14] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[15] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[16] +#define SWIGTYPE_p_mfem__Mesh swig_types[17] +#define SWIGTYPE_p_mfem__NCMesh swig_types[18] +#define SWIGTYPE_p_mfem__NCMesh__MeshId swig_types[19] +#define SWIGTYPE_p_mfem__NCMesh__NCList swig_types[20] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[21] +#define SWIGTYPE_p_mfem__Refinement swig_types[22] +#define SWIGTYPE_p_mfem__STable swig_types[23] +#define SWIGTYPE_p_mfem__Table swig_types[24] +#define SWIGTYPE_p_pri_t swig_types[25] +#define SWIGTYPE_p_quad_t swig_types[26] +#define SWIGTYPE_p_seg_t swig_types[27] +#define SWIGTYPE_p_std__istream swig_types[28] #define SWIGTYPE_p_tet_t swig_types[29] #define SWIGTYPE_p_tri_t swig_types[30] #define SWIGTYPE_p_void swig_types[31] @@ -3548,19 +3548,10 @@ SWIG_From_char (char c) } -SWIGINTERN int -SWIG_AsVal_int (PyObject * obj, int *val) +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) { - long v; - int res = SWIG_AsVal_long (obj, &v); - if (SWIG_IsOK(res)) { - if ((v < INT_MIN || v > INT_MAX)) { - return SWIG_OverflowError; - } else { - if (val) *val = static_cast< int >(v); - } - } - return res; + return PyBool_FromLong(value ? 1 : 0); } @@ -4203,7 +4194,7 @@ SWIGINTERN PyObject *Embedding_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; - std::map< mfem::Geometry::Type,mfem::DenseTensor > *arg2 = (std::map< mfem::Geometry::Type,mfem::DenseTensor > *) 0 ; + mfem::DenseTensor *arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4216,12 +4207,19 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_set(PyObject SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_point_matrices_set" "', argument " "1"" of type '" "mfem::CoarseFineTransformations *""'"); } arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoarseFineTransformations_point_matrices_set" "', argument " "2"" of type '" "std::map< mfem::Geometry::Type,mfem::DenseTensor > *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoarseFineTransformations_point_matrices_set" "', argument " "2"" of type '" "mfem::DenseTensor [mfem::Geometry::NumGeom]""'"); + } + arg2 = reinterpret_cast< mfem::DenseTensor * >(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)mfem::Geometry::NumGeom; ++ii) *(mfem::DenseTensor *)&arg1->point_matrices[ii] = *((mfem::DenseTensor *)arg2 + ii); + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""point_matrices""' of type '""mfem::DenseTensor [mfem::Geometry::NumGeom]""'"); + } } - arg2 = reinterpret_cast< std::map< mfem::Geometry::Type,mfem::DenseTensor > * >(argp2); - if (arg1) (arg1)->point_matrices = *arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -4235,7 +4233,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_get(PyObject void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - std::map< mfem::Geometry::Type,mfem::DenseTensor > *result = 0 ; + mfem::DenseTensor *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; @@ -4244,8 +4242,8 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_get(PyObject SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_point_matrices_get" "', argument " "1"" of type '" "mfem::CoarseFineTransformations *""'"); } arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - result = (std::map< mfem::Geometry::Type,mfem::DenseTensor > *)& ((arg1)->point_matrices); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, 0 | 0 ); + result = (mfem::DenseTensor *)(mfem::DenseTensor *) ((arg1)->point_matrices); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); return resultobj; fail: return NULL; @@ -4275,43 +4273,6 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_embeddings_get(PyObject *SW } -SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetPointMatrices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::DenseTensor *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "CoarseFineTransformations_GetPointMatrices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_GetPointMatrices" "', argument " "1"" of type '" "mfem::CoarseFineTransformations const *""'"); - } - arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoarseFineTransformations_GetPointMatrices" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (mfem::DenseTensor *) &((mfem::CoarseFineTransformations const *)arg1)->GetPointMatrices(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; @@ -4424,6 +4385,36 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_Clear(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_CoarseFineTransformations_IsInitialized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_IsInitialized" "', argument " "1"" of type '" "mfem::CoarseFineTransformations const *""'"); + } + arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); + { + try { + result = (bool)((mfem::CoarseFineTransformations const *)arg1)->IsInitialized(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_CoarseFineTransformations_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; @@ -5597,6 +5588,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( void *argp5 = 0 ; int res5 = 0 ; PyObject *swig_obj[5] ; + int result; if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceVerticesEdges", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); @@ -5629,13 +5621,13 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( arg5 = reinterpret_cast< int * >(argp5); { try { - ((mfem::NCMesh const *)arg1)->GetFaceVerticesEdges((mfem::NCMesh::MeshId const &)*arg2,arg3,arg4,arg5); + result = (int)((mfem::NCMesh const *)arg1)->GetFaceVerticesEdges((mfem::NCMesh::MeshId const &)*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; @@ -5749,21 +5741,27 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject *swig_obj[2] ; mfem::Geometry::Type result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementGeometry", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetElementGeometry(); + result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetElementGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5779,21 +5777,57 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *_wrap_NCMesh_GetFaceGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject *swig_obj[2] ; mfem::Geometry::Type result; + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceGeometry", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + } + arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetFaceGeometry(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NCMesh_GetNumRootElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetNumRootElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { try { - result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetFaceGeometry(); + result = (int)(arg1)->GetNumRootElements(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5842,6 +5876,99 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self) } +SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementSizeReduction", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementSizeReduction" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + } + arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::NCMesh const *)arg1)->GetElementSizeReduction(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementFacesAttributes", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + } + arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + try { + ((mfem::NCMesh const *)arg1)->GetElementFacesAttributes(arg2,*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; @@ -6811,6 +6938,7 @@ SWIGINTERN PyObject *NCMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Refinement_index_set", _wrap_Refinement_index_set, METH_VARARGS, "Refinement_index_set(Refinement self, int index)"}, { "Refinement_index_get", _wrap_Refinement_index_get, METH_O, "Refinement_index_get(Refinement self) -> int"}, { "Refinement_ref_type_set", _wrap_Refinement_ref_type_set, METH_VARARGS, "Refinement_ref_type_set(Refinement self, char ref_type)"}, @@ -6833,12 +6961,12 @@ static PyMethodDef SwigMethods[] = { { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, { "Embedding_swiginit", Embedding_swiginit, METH_VARARGS, NULL}, - { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, std::map< mfem::Geometry::Type,mfem::DenseTensor > * point_matrices)"}, - { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> std::map< mfem::Geometry::Type,mfem::DenseTensor > *"}, + { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, + { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, - { "CoarseFineTransformations_GetPointMatrices", _wrap_CoarseFineTransformations_GetPointMatrices, METH_VARARGS, "CoarseFineTransformations_GetPointMatrices(CoarseFineTransformations self, mfem::Geometry::Type geom) -> DenseTensor"}, { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "CoarseFineTransformations_GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "CoarseFineTransformations_Clear(CoarseFineTransformations self)"}, + { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "CoarseFineTransformations_IsInitialized(CoarseFineTransformations self) -> bool"}, { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "CoarseFineTransformations_MemoryUsage(CoarseFineTransformations self) -> long"}, { "new_CoarseFineTransformations", _wrap_new_CoarseFineTransformations, METH_NOARGS, "new_CoarseFineTransformations() -> CoarseFineTransformations"}, { "delete_CoarseFineTransformations", _wrap_delete_CoarseFineTransformations, METH_O, "delete_CoarseFineTransformations(CoarseFineTransformations self)"}, @@ -6871,12 +6999,15 @@ static PyMethodDef SwigMethods[] = { { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "NCMesh_GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "NCMesh_GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, - { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation)"}, + { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "NCMesh_GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "NCMesh_GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, - { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_O, "NCMesh_GetElementGeometry(NCMesh self) -> mfem::Geometry::Type"}, - { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_O, "NCMesh_GetFaceGeometry(NCMesh self) -> mfem::Geometry::Type"}, + { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "NCMesh_GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "NCMesh_GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "NCMesh_GetNumRootElements(NCMesh self) -> int"}, { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "NCMesh_GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "NCMesh_GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "NCMesh_GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "NCMesh_LoadVertexParents(NCMesh self, std::istream & input)"}, { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "NCMesh_LoadCoarseElements(NCMesh self, std::istream & input)"}, { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "NCMesh_SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, @@ -6903,6 +7034,99 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Refinement_index_set", _wrap_Refinement_index_set, METH_VARARGS, "Refinement_index_set(Refinement self, int index)"}, + { "Refinement_index_get", _wrap_Refinement_index_get, METH_O, "Refinement_index_get(Refinement self) -> int"}, + { "Refinement_ref_type_set", _wrap_Refinement_ref_type_set, METH_VARARGS, "Refinement_ref_type_set(Refinement self, char ref_type)"}, + { "Refinement_ref_type_get", _wrap_Refinement_ref_type_get, METH_O, "Refinement_ref_type_get(Refinement self) -> char"}, + { "new_Refinement", _wrap_new_Refinement, METH_VARARGS, "\n" + "Refinement()\n" + "Refinement(int index, int type=7)\n" + ""}, + { "delete_Refinement", _wrap_delete_Refinement, METH_O, "delete_Refinement(Refinement self)"}, + { "Refinement_swigregister", Refinement_swigregister, METH_O, NULL}, + { "Refinement_swiginit", Refinement_swiginit, METH_VARARGS, NULL}, + { "Embedding_parent_set", _wrap_Embedding_parent_set, METH_VARARGS, "Embedding_parent_set(Embedding self, int parent)"}, + { "Embedding_parent_get", _wrap_Embedding_parent_get, METH_O, "Embedding_parent_get(Embedding self) -> int"}, + { "Embedding_matrix_set", _wrap_Embedding_matrix_set, METH_VARARGS, "Embedding_matrix_set(Embedding self, int matrix)"}, + { "Embedding_matrix_get", _wrap_Embedding_matrix_get, METH_O, "Embedding_matrix_get(Embedding self) -> int"}, + { "new_Embedding", _wrap_new_Embedding, METH_VARARGS, "\n" + "Embedding()\n" + "Embedding(int elem, int matrix=0)\n" + ""}, + { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, + { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, + { "Embedding_swiginit", Embedding_swiginit, METH_VARARGS, NULL}, + { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, + { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, + { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, + { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, + { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "Clear(CoarseFineTransformations self)"}, + { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "IsInitialized(CoarseFineTransformations self) -> bool"}, + { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "MemoryUsage(CoarseFineTransformations self) -> long"}, + { "new_CoarseFineTransformations", _wrap_new_CoarseFineTransformations, METH_NOARGS, "new_CoarseFineTransformations() -> CoarseFineTransformations"}, + { "delete_CoarseFineTransformations", _wrap_delete_CoarseFineTransformations, METH_O, "delete_CoarseFineTransformations(CoarseFineTransformations self)"}, + { "CoarseFineTransformations_swigregister", CoarseFineTransformations_swigregister, METH_O, NULL}, + { "CoarseFineTransformations_swiginit", CoarseFineTransformations_swiginit, METH_VARARGS, NULL}, + { "new_NCMesh", _wrap_new_NCMesh, METH_VARARGS, "\n" + "NCMesh(Mesh mesh, std::istream * vertex_parents=None)\n" + "new_NCMesh(NCMesh other) -> NCMesh\n" + ""}, + { "delete_NCMesh", _wrap_delete_NCMesh, METH_O, "delete_NCMesh(NCMesh self)"}, + { "NCMesh_Dimension", _wrap_NCMesh_Dimension, METH_O, "Dimension(NCMesh self) -> int"}, + { "NCMesh_SpaceDimension", _wrap_NCMesh_SpaceDimension, METH_O, "SpaceDimension(NCMesh self) -> int"}, + { "NCMesh_GetNVertices", _wrap_NCMesh_GetNVertices, METH_O, "GetNVertices(NCMesh self) -> int"}, + { "NCMesh_GetNEdges", _wrap_NCMesh_GetNEdges, METH_O, "GetNEdges(NCMesh self) -> int"}, + { "NCMesh_GetNFaces", _wrap_NCMesh_GetNFaces, METH_O, "GetNFaces(NCMesh self) -> int"}, + { "NCMesh_Refine", _wrap_NCMesh_Refine, METH_VARARGS, "Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "NCMesh_LimitNCLevel", _wrap_NCMesh_LimitNCLevel, METH_VARARGS, "LimitNCLevel(NCMesh self, int max_nc_level)"}, + { "NCMesh_GetDerefinementTable", _wrap_NCMesh_GetDerefinementTable, METH_O, "GetDerefinementTable(NCMesh self) -> Table"}, + { "NCMesh_CheckDerefinementNCLevel", _wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS, "CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "NCMesh_Derefine", _wrap_NCMesh_Derefine, METH_VARARGS, "Derefine(NCMesh self, intArray derefs)"}, + { "NCMesh_GetFaceList", _wrap_NCMesh_GetFaceList, METH_O, "GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetEdgeList", _wrap_NCMesh_GetEdgeList, METH_O, "GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetVertexList", _wrap_NCMesh_GetVertexList, METH_O, "GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetNCList", _wrap_NCMesh_GetNCList, METH_VARARGS, "GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_MarkCoarseLevel", _wrap_NCMesh_MarkCoarseLevel, METH_O, "MarkCoarseLevel(NCMesh self)"}, + { "NCMesh_GetRefinementTransforms", _wrap_NCMesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, + { "NCMesh_GetDerefinementTransforms", _wrap_NCMesh_GetDerefinementTransforms, METH_O, "GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, + { "NCMesh_ClearTransforms", _wrap_NCMesh_ClearTransforms, METH_O, "ClearTransforms(NCMesh self)"}, + { "NCMesh_GridSfcOrdering2D", _wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS, "GridSfcOrdering2D(int width, int height, intArray coords)"}, + { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, + { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, + { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, + { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, + { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, + { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "GetNumRootElements(NCMesh self) -> int"}, + { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, + { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "LoadVertexParents(NCMesh self, std::istream & input)"}, + { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "LoadCoarseElements(NCMesh self, std::istream & input)"}, + { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, + { "NCMesh_Trim", _wrap_NCMesh_Trim, METH_O, "Trim(NCMesh self)"}, + { "NCMesh_MemoryUsage", _wrap_NCMesh_MemoryUsage, METH_O, "MemoryUsage(NCMesh self) -> long"}, + { "NCMesh_PrintMemoryDetail", _wrap_NCMesh_PrintMemoryDetail, METH_O, "PrintMemoryDetail(NCMesh self) -> int"}, + { "NCMesh_PrintVertexParents", _wrap_NCMesh_PrintVertexParents, METH_VARARGS, "\n" + "PrintVertexParents(NCMesh self, std::ostream & out)\n" + "PrintVertexParents(NCMesh self, char const * file, int precision=8)\n" + "PrintVertexParents(NCMesh self)\n" + ""}, + { "NCMesh_PrintCoarseElements", _wrap_NCMesh_PrintCoarseElements, METH_VARARGS, "\n" + "PrintCoarseElements(NCMesh self, std::ostream & out)\n" + "PrintCoarseElements(NCMesh self, char const * file, int precision=8)\n" + "PrintCoarseElements(NCMesh self)\n" + ""}, + { "NCMesh_PrintStats", _wrap_NCMesh_PrintStats, METH_VARARGS, "\n" + "PrintStats(NCMesh self, std::ostream & out=mfem::out)\n" + "PrintStats(NCMesh self, char const * file, int precision=8)\n" + ""}, + { "NCMesh_swigregister", NCMesh_swigregister, METH_O, NULL}, + { "NCMesh_swiginit", NCMesh_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6914,6 +7138,7 @@ static void *_p_mfem__STableTo_p_mfem__Table(void *x, int *SWIGUNUSEDPARM(newmem } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -6940,7 +7165,6 @@ static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t = {"_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t", "std::map< mfem::Geometry::Type,mfem::DenseTensor > *|std::map< enum mfem::Geometry::Type,mfem::DenseTensor > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; @@ -6948,6 +7172,7 @@ static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -6974,7 +7199,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_quad_t, &_swigt__p_seg_t, &_swigt__p_std__istream, - &_swigt__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, &_swigt__p_tet_t, &_swigt__p_tri_t, &_swigt__p_void, @@ -6982,6 +7206,7 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -7008,7 +7233,6 @@ static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t[] = { {&_swigt__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; @@ -7016,6 +7240,7 @@ static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -7042,7 +7267,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_quad_t, _swigc__p_seg_t, _swigc__p_std__istream, - _swigc__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, _swigc__p_tet_t, _swigc__p_tri_t, _swigc__p_void, diff --git a/mfem/_par/nonlinearform.i b/mfem/_par/nonlinearform.i index e2822f1b..949afd36 100644 --- a/mfem/_par/nonlinearform.i +++ b/mfem/_par/nonlinearform.i @@ -17,6 +17,7 @@ import_array(); %include "exception.i" %import "operators.i" %import "fespace.i" +%import "bilinearform.i" %import "nonlininteg.i" %import "../common/exception.i" %include "../common/typemap_macros.i" diff --git a/mfem/_par/nonlinearform.py b/mfem/_par/nonlinearform.py index b34a8815..135bc101 100644 --- a/mfem/_par/nonlinearform.py +++ b/mfem/_par/nonlinearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _nonlinearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _nonlinearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -78,6 +81,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -89,6 +93,8 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction +import mfem._par.bilinearform import mfem._par.nonlininteg class NonlinearForm(mfem._par.operators.Operator): r"""Proxy of C++ mfem::NonlinearForm class.""" @@ -100,12 +106,18 @@ def __init__(self, f): r"""__init__(NonlinearForm self, FiniteElementSpace f) -> NonlinearForm""" _nonlinearform.NonlinearForm_swiginit(self, _nonlinearform.new_NonlinearForm(f)) + def SetAssemblyLevel(self, assembly_level): + r"""SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)""" + return _nonlinearform.NonlinearForm_SetAssemblyLevel(self, assembly_level) + SetAssemblyLevel = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetAssemblyLevel) + def FESpace(self, *args): r""" FESpace(NonlinearForm self) -> FiniteElementSpace FESpace(NonlinearForm self) -> FiniteElementSpace """ return _nonlinearform.NonlinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_nonlinearform.NonlinearForm_FESpace) def AddDomainIntegrator(self, nlfi): r"""AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)""" @@ -118,6 +130,11 @@ def AddDomainIntegrator(self, nlfi): return _nonlinearform.NonlinearForm_AddDomainIntegrator(self, nlfi) + def GetDNFI(self): + r"""GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *""" + return _nonlinearform.NonlinearForm_GetDNFI(self) + GetDNFI = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetDNFI) + def AddInteriorFaceIntegrator(self, nlfi): r"""AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)""" @@ -147,51 +164,68 @@ def AddBdrFaceIntegrator(self, *args): def SetEssentialBC(self, bdr_attr_is_ess, rhs=None): r"""SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)""" return _nonlinearform.NonlinearForm_SetEssentialBC(self, bdr_attr_is_ess, rhs) + SetEssentialBC = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetEssentialBC) def SetEssentialVDofs(self, ess_vdofs_list): r"""SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)""" return _nonlinearform.NonlinearForm_SetEssentialVDofs(self, ess_vdofs_list) + SetEssentialVDofs = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetEssentialVDofs) def SetEssentialTrueDofs(self, ess_tdof_list): r"""SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)""" return _nonlinearform.NonlinearForm_SetEssentialTrueDofs(self, ess_tdof_list) + SetEssentialTrueDofs = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetEssentialTrueDofs) def GetEssentialTrueDofs(self): r"""GetEssentialTrueDofs(NonlinearForm self) -> intArray""" return _nonlinearform.NonlinearForm_GetEssentialTrueDofs(self) + GetEssentialTrueDofs = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetEssentialTrueDofs) def GetGridFunctionEnergy(self, x): r"""GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double""" return _nonlinearform.NonlinearForm_GetGridFunctionEnergy(self, x) + GetGridFunctionEnergy = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetGridFunctionEnergy) def GetEnergy(self, x): r"""GetEnergy(NonlinearForm self, Vector x) -> double""" return _nonlinearform.NonlinearForm_GetEnergy(self, x) + GetEnergy = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetEnergy) def Mult(self, x, y): r"""Mult(NonlinearForm self, Vector x, Vector y)""" return _nonlinearform.NonlinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_nonlinearform.NonlinearForm_Mult) def GetGradient(self, x): r"""GetGradient(NonlinearForm self, Vector x) -> Operator""" return _nonlinearform.NonlinearForm_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetGradient) def Update(self): r"""Update(NonlinearForm self)""" return _nonlinearform.NonlinearForm_Update(self) + Update = _swig_new_instance_method(_nonlinearform.NonlinearForm_Update) + + def Setup(self): + r"""Setup(NonlinearForm self)""" + return _nonlinearform.NonlinearForm_Setup(self) + Setup = _swig_new_instance_method(_nonlinearform.NonlinearForm_Setup) def GetProlongation(self): r"""GetProlongation(NonlinearForm self) -> Operator""" return _nonlinearform.NonlinearForm_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetProlongation) def GetRestriction(self): r"""GetRestriction(NonlinearForm self) -> Operator""" return _nonlinearform.NonlinearForm_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetRestriction) __swig_destroy__ = _nonlinearform.delete_NonlinearForm def GetGradientMatrix(self, x): r"""GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix""" return _nonlinearform.NonlinearForm_GetGradientMatrix(self, x) + GetGradientMatrix = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetGradientMatrix) # Register NonlinearForm in _nonlinearform: _nonlinearform.NonlinearForm_swigregister(NonlinearForm) @@ -215,18 +249,22 @@ def FESpace(self, *args): FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace """ return _nonlinearform.BlockNonlinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_FESpace) def SetSpaces(self, f): r"""SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)""" return _nonlinearform.BlockNonlinearForm_SetSpaces(self, f) + SetSpaces = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_SetSpaces) def GetBlockOffsets(self): r"""GetBlockOffsets(BlockNonlinearForm self) -> intArray""" return _nonlinearform.BlockNonlinearForm_GetBlockOffsets(self) + GetBlockOffsets = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetBlockOffsets) def GetBlockTrueOffsets(self): r"""GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray""" return _nonlinearform.BlockNonlinearForm_GetBlockTrueOffsets(self) + GetBlockTrueOffsets = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetBlockTrueOffsets) def AddDomainIntegrator(self, nlfi): r"""AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)""" @@ -268,18 +306,22 @@ def AddBdrFaceIntegrator(self, *args): def SetEssentialBC(self, bdr_attr_is_ess, rhs): r"""SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)""" return _nonlinearform.BlockNonlinearForm_SetEssentialBC(self, bdr_attr_is_ess, rhs) + SetEssentialBC = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_SetEssentialBC) def GetEnergy(self, x): r"""GetEnergy(BlockNonlinearForm self, Vector x) -> double""" return _nonlinearform.BlockNonlinearForm_GetEnergy(self, x) + GetEnergy = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetEnergy) def Mult(self, x, y): r"""Mult(BlockNonlinearForm self, Vector x, Vector y)""" return _nonlinearform.BlockNonlinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_Mult) def GetGradient(self, x): r"""GetGradient(BlockNonlinearForm self, Vector x) -> Operator""" return _nonlinearform.BlockNonlinearForm_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetGradient) __swig_destroy__ = _nonlinearform.delete_BlockNonlinearForm # Register BlockNonlinearForm in _nonlinearform: diff --git a/mfem/_par/nonlinearform_wrap.cxx b/mfem/_par/nonlinearform_wrap.cxx index 4d3908c3..6d367b17 100644 --- a/mfem/_par/nonlinearform_wrap.cxx +++ b/mfem/_par/nonlinearform_wrap.cxx @@ -3067,62 +3067,74 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] -#define SWIGTYPE_p_mfem__BlockNonlinearForm swig_types[7] -#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[8] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[9] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[10] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[11] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[12] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[13] -#define SWIGTYPE_p_mfem__GridFunction swig_types[14] -#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__HypreADS swig_types[16] -#define SWIGTYPE_p_mfem__HypreAMS swig_types[17] -#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[18] -#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[19] -#define SWIGTYPE_p_mfem__HypreEuclid swig_types[20] -#define SWIGTYPE_p_mfem__HypreGMRES swig_types[21] -#define SWIGTYPE_p_mfem__HypreIdentity swig_types[22] -#define SWIGTYPE_p_mfem__HyprePCG swig_types[23] -#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[24] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[25] -#define SWIGTYPE_p_mfem__HypreParaSails swig_types[26] -#define SWIGTYPE_p_mfem__HypreSmoother swig_types[27] -#define SWIGTYPE_p_mfem__HypreSolver swig_types[28] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[29] -#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[31] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[32] -#define SWIGTYPE_p_mfem__LinearForm swig_types[33] -#define SWIGTYPE_p_mfem__Matrix swig_types[34] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[35] -#define SWIGTYPE_p_mfem__NonlinearForm swig_types[36] -#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__Operator swig_types[38] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[39] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[40] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[41] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[42] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[43] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[44] -#define SWIGTYPE_p_mfem__Solver swig_types[45] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[46] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[47] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[48] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[49] -#define SWIGTYPE_p_mfem__Vector swig_types[50] -#define SWIGTYPE_p_pri_t swig_types[51] -#define SWIGTYPE_p_quad_t swig_types[52] -#define SWIGTYPE_p_seg_t swig_types[53] -#define SWIGTYPE_p_tet_t swig_types[54] -#define SWIGTYPE_p_tri_t swig_types[55] -static swig_type_info *swig_types[57]; -static swig_module_info swig_module = {swig_types, 56, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t swig_types[8] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[9] +#define SWIGTYPE_p_mfem__BlockNonlinearForm swig_types[10] +#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[11] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[12] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[13] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[14] +#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[15] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[16] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[17] +#define SWIGTYPE_p_mfem__GridFunction swig_types[18] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[19] +#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__HypreADS swig_types[21] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[22] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[23] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[24] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[25] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[26] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[27] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[28] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[29] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[30] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[31] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[32] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[33] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[34] +#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[36] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[37] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[38] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[39] +#define SWIGTYPE_p_mfem__LinearForm swig_types[40] +#define SWIGTYPE_p_mfem__Matrix swig_types[41] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[42] +#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[43] +#define SWIGTYPE_p_mfem__NonlinearForm swig_types[44] +#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[45] +#define SWIGTYPE_p_mfem__Operator swig_types[46] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[47] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[48] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[49] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[50] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[51] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[52] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[53] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[54] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[55] +#define SWIGTYPE_p_mfem__Solver swig_types[56] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[57] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[58] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[59] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[60] +#define SWIGTYPE_p_mfem__Vector swig_types[61] +#define SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator swig_types[62] +#define SWIGTYPE_p_pri_t swig_types[63] +#define SWIGTYPE_p_quad_t swig_types[64] +#define SWIGTYPE_p_seg_t swig_types[65] +#define SWIGTYPE_p_tet_t swig_types[66] +#define SWIGTYPE_p_tri_t swig_types[67] +static swig_type_info *swig_types[69]; +static swig_module_info swig_module = {swig_types, 68, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3235,6 +3247,157 @@ namespace swig { #include "pyoperator.hpp" +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + #define SWIG_From_double PyFloat_FromDouble SWIGINTERN mfem::SparseMatrix *mfem_NonlinearForm_GetGradientMatrix(mfem::NonlinearForm const *self,mfem::Vector const &x){ @@ -3286,6 +3449,47 @@ SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyO } +SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; + mfem::AssemblyLevel arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); + } + arg2 = static_cast< mfem::AssemblyLevel >(val2); + { + try { + (arg1)->SetAssemblyLevel(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NonlinearForm_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; @@ -3429,6 +3633,41 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSE } +SWIGINTERN PyObject *_wrap_NonlinearForm_GetDNFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::NonlinearFormIntegrator * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetDNFI" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); + { + try { + result = (mfem::Array< mfem::NonlinearFormIntegrator * > *)(arg1)->GetDNFI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; @@ -4102,6 +4341,40 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Update(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_NonlinearForm_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_Setup" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); + { + try { + (arg1)->Setup(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NonlinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; @@ -5260,12 +5533,15 @@ SWIGINTERN PyObject *BlockNonlinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "NonlinearForm_SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" ""}, { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "NonlinearForm_AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "NonlinearForm_GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "NonlinearForm_AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "NonlinearForm_AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" @@ -5280,6 +5556,7 @@ static PyMethodDef SwigMethods[] = { { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "NonlinearForm_Mult(NonlinearForm self, Vector x, Vector y)"}, { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "NonlinearForm_GetGradient(NonlinearForm self, Vector x) -> Operator"}, { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "NonlinearForm_Update(NonlinearForm self)"}, + { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "NonlinearForm_Setup(NonlinearForm self)"}, { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "NonlinearForm_GetProlongation(NonlinearForm self) -> Operator"}, { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "NonlinearForm_GetRestriction(NonlinearForm self) -> Operator"}, { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, @@ -5314,6 +5591,61 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(NonlinearForm self) -> FiniteElementSpace\n" + "FESpace(NonlinearForm self) -> FiniteElementSpace\n" + ""}, + { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, + { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" + "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nfi, intArray bdr_marker)\n" + ""}, + { "NonlinearForm_SetEssentialBC", _wrap_NonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, + { "NonlinearForm_SetEssentialVDofs", _wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS, "SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, + { "NonlinearForm_SetEssentialTrueDofs", _wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS, "SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, + { "NonlinearForm_GetEssentialTrueDofs", _wrap_NonlinearForm_GetEssentialTrueDofs, METH_O, "GetEssentialTrueDofs(NonlinearForm self) -> intArray"}, + { "NonlinearForm_GetGridFunctionEnergy", _wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS, "GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_GetEnergy", _wrap_NonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "Mult(NonlinearForm self, Vector x, Vector y)"}, + { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "GetGradient(NonlinearForm self, Vector x) -> Operator"}, + { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "Update(NonlinearForm self)"}, + { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "Setup(NonlinearForm self)"}, + { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "GetProlongation(NonlinearForm self) -> Operator"}, + { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "GetRestriction(NonlinearForm self) -> Operator"}, + { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, + { "NonlinearForm_GetGradientMatrix", _wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS, "GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, + { "NonlinearForm_swigregister", NonlinearForm_swigregister, METH_O, NULL}, + { "NonlinearForm_swiginit", NonlinearForm_swiginit, METH_VARARGS, NULL}, + { "new_BlockNonlinearForm", _wrap_new_BlockNonlinearForm, METH_VARARGS, "\n" + "BlockNonlinearForm()\n" + "new_BlockNonlinearForm(mfem::Array< mfem::FiniteElementSpace * > & f) -> BlockNonlinearForm\n" + ""}, + { "BlockNonlinearForm_FESpace", _wrap_BlockNonlinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" + "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" + ""}, + { "BlockNonlinearForm_SetSpaces", _wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS, "SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, + { "BlockNonlinearForm_GetBlockOffsets", _wrap_BlockNonlinearForm_GetBlockOffsets, METH_O, "GetBlockOffsets(BlockNonlinearForm self) -> intArray"}, + { "BlockNonlinearForm_GetBlockTrueOffsets", _wrap_BlockNonlinearForm_GetBlockTrueOffsets, METH_O, "GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray"}, + { "BlockNonlinearForm_AddDomainIntegrator", _wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddInteriorFaceIntegrator", _wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddBdrFaceIntegrator", _wrap_BlockNonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)\n" + "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi, intArray bdr_marker)\n" + ""}, + { "BlockNonlinearForm_SetEssentialBC", _wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "BlockNonlinearForm_GetEnergy", _wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, + { "BlockNonlinearForm_Mult", _wrap_BlockNonlinearForm_Mult, METH_VARARGS, "Mult(BlockNonlinearForm self, Vector x, Vector y)"}, + { "BlockNonlinearForm_GetGradient", _wrap_BlockNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, + { "delete_BlockNonlinearForm", _wrap_delete_BlockNonlinearForm, METH_O, "delete_BlockNonlinearForm(BlockNonlinearForm self)"}, + { "BlockNonlinearForm_swigregister", BlockNonlinearForm_swigregister, METH_O, NULL}, + { "BlockNonlinearForm_swiginit", BlockNonlinearForm_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5335,108 +5667,140 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n static void *_p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::HyperelasticNLFIntegrator *) x)); } +static void *_p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::VectorConvectionNLFIntegrator *) x)); +} static void *_p_mfem__IncompressibleNeoHookeanIntegratorTo_p_mfem__BlockNonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BlockNonlinearFormIntegrator *) ((mfem::IncompressibleNeoHookeanIntegrator *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } -static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); } -static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } -static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); +static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +} +static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +} +static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); +} +static void *_p_mfem__MixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::MixedBilinearForm *) x)); +} +static void *_p_mfem__NonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::NonlinearForm *) x)); +} +static void *_p_mfem__BlockNonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::BlockNonlinearForm *) x)); +} +static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); } static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); } -static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } -static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +} +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +} +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); } static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } -static void *_p_mfem__NonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::NonlinearForm *) x)); +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); } -static void *_p_mfem__BlockNonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::BlockNonlinearForm *) x)); +static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); } -static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +} +static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); } static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); } -static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); -} -static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); -} -static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); -} -static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); } static void *_p_mfem__HypreSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSmoother *) x)); } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t = {"_p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t", "mfem::Array< mfem::NonlinearFormIntegrator * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BlockNonlinearForm = {"_p_mfem__BlockNonlinearForm", "mfem::BlockNonlinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BlockNonlinearFormIntegrator = {"_p_mfem__BlockNonlinearFormIntegrator", "mfem::BlockNonlinearFormIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__IncompressibleNeoHookeanIntegrator = {"_p_mfem__IncompressibleNeoHookeanIntegrator", 0, 0, 0, 0, 0}; @@ -5447,34 +5811,44 @@ static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollecti static swig_type_info _swigt__p_mfem__NonlinearForm = {"_p_mfem__NonlinearForm", "mfem::NonlinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__NonlinearFormIntegrator = {"_p_mfem__NonlinearFormIntegrator", "mfem::NonlinearFormIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HyperelasticNLFIntegrator = {"_p_mfem__HyperelasticNLFIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorConvectionNLFIntegrator = {"_p_mfem__VectorConvectionNLFIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__BilinearForm = {"_p_mfem__BilinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedBilinearForm = {"_p_mfem__MixedBilinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DiscreteLinearOperator = {"_p_mfem__DiscreteLinearOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreParMatrix = {"_p_mfem__HypreParMatrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreSmoother = {"_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; @@ -5491,19 +5865,24 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, &_swigt__p_mfem__AbstractSparseMatrix, &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, + &_swigt__p_mfem__BilinearForm, &_swigt__p_mfem__BlockNonlinearForm, &_swigt__p_mfem__BlockNonlinearFormIntegrator, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__DenseMatrix, &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__DiscreteLinearOperator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__HyperelasticNLFIntegrator, &_swigt__p_mfem__HypreADS, &_swigt__p_mfem__HypreAMS, @@ -5521,10 +5900,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__IncompressibleNeoHookeanIntegrator, &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2_FECollection, &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__Matrix, &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__MixedBilinearForm, &_swigt__p_mfem__NonlinearForm, &_swigt__p_mfem__NonlinearFormIntegrator, &_swigt__p_mfem__Operator, @@ -5534,12 +5916,16 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, &_swigt__p_mfem__TripleProductOperator, &_swigt__p_mfem__Vector, + &_swigt__p_mfem__VectorConvectionNLFIntegrator, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -5549,10 +5935,12 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockNonlinearForm[] = { {&_swigt__p_mfem__BlockNonlinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IncompressibleNeoHookeanIntegrator[] = {{&_swigt__p_mfem__IncompressibleNeoHookeanIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockNonlinearFormIntegrator[] = { {&_swigt__p_mfem__BlockNonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__IncompressibleNeoHookeanIntegrator, _p_mfem__IncompressibleNeoHookeanIntegratorTo_p_mfem__BlockNonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; @@ -5562,36 +5950,46 @@ static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__I static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NonlinearForm[] = { {&_swigt__p_mfem__NonlinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyperelasticNLFIntegrator[] = {{&_swigt__p_mfem__HyperelasticNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorConvectionNLFIntegrator[] = {{&_swigt__p_mfem__VectorConvectionNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorConvectionNLFIntegrator, _p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearForm[] = {{&_swigt__p_mfem__BilinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedBilinearForm[] = {{&_swigt__p_mfem__MixedBilinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DiscreteLinearOperator[] = {{&_swigt__p_mfem__DiscreteLinearOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParMatrix[] = {{&_swigt__p_mfem__HypreParMatrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NonlinearForm, _p_mfem__NonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockNonlinearForm, _p_mfem__BlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NonlinearForm, _p_mfem__NonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockNonlinearForm, _p_mfem__BlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; @@ -5607,19 +6005,24 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, _swigc__p_mfem__AbstractSparseMatrix, _swigc__p_mfem__ArrayT_int_t, + _swigc__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, + _swigc__p_mfem__BilinearForm, _swigc__p_mfem__BlockNonlinearForm, _swigc__p_mfem__BlockNonlinearFormIntegrator, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__DenseMatrix, _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__DiscreteLinearOperator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__GridFunction, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__HyperelasticNLFIntegrator, _swigc__p_mfem__HypreADS, _swigc__p_mfem__HypreAMS, @@ -5637,10 +6040,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__IncompressibleNeoHookeanIntegrator, _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2_FECollection, _swigc__p_mfem__LinearForm, _swigc__p_mfem__Matrix, _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__MixedBilinearForm, _swigc__p_mfem__NonlinearForm, _swigc__p_mfem__NonlinearFormIntegrator, _swigc__p_mfem__Operator, @@ -5650,12 +6056,16 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, _swigc__p_mfem__TripleProductOperator, _swigc__p_mfem__Vector, + _swigc__p_mfem__VectorConvectionNLFIntegrator, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_par/nonlininteg.py b/mfem/_par/nonlininteg.py index 9dd2daed..b7a56a6c 100644 --- a/mfem/_par/nonlininteg.py +++ b/mfem/_par/nonlininteg.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _nonlininteg.SWIG_PyInstanceMethod_New +_swig_new_static_method = _nonlininteg.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -78,6 +81,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -89,6 +93,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction class NonlinearFormIntegrator(object): r"""Proxy of C++ mfem::NonlinearFormIntegrator class.""" @@ -106,30 +111,50 @@ def __init__(self, ir=None): def SetIntRule(self, ir): r"""SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)""" return _nonlininteg.NonlinearFormIntegrator_SetIntRule(self, ir) + SetIntRule = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_SetIntRule) def SetIntegrationRule(self, irule): r"""SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)""" return _nonlininteg.NonlinearFormIntegrator_SetIntegrationRule(self, irule) + SetIntegrationRule = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_SetIntegrationRule) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _nonlininteg.NonlinearFormIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleElementVector) def AssembleFaceVector(self, el1, el2, Tr, elfun, elvect): r"""AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)""" return _nonlininteg.NonlinearFormIntegrator_AssembleFaceVector(self, el1, el2, Tr, elfun, elvect) + AssembleFaceVector = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleFaceVector) def AssembleElementGrad(self, el, Tr, elfun, elmat): r"""AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)""" return _nonlininteg.NonlinearFormIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleElementGrad) def AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat): r"""AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)""" return _nonlininteg.NonlinearFormIntegrator_AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat) + AssembleFaceGrad = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleFaceGrad) def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double""" return _nonlininteg.NonlinearFormIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_GetElementEnergy) + + def AssemblePA(self, *args): + r""" + AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes) + AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _nonlininteg.NonlinearFormIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)""" + return _nonlininteg.NonlinearFormIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AddMultPA) __swig_destroy__ = _nonlininteg.delete_NonlinearFormIntegrator def __disown__(self): self.this.disown() @@ -148,22 +173,27 @@ class BlockNonlinearFormIntegrator(object): def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double""" return _nonlininteg.BlockNonlinearFormIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_GetElementEnergy) def AssembleElementVector(self, el, Tr, elfun, elvec): r"""AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleElementVector(self, el, Tr, elfun, elvec) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleElementVector) def AssembleFaceVector(self, el1, el2, Tr, elfun, elvect): r"""AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceVector(self, el1, el2, Tr, elfun, elvect) + AssembleFaceVector = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceVector) def AssembleElementGrad(self, el, Tr, elfun, elmats): r"""AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmats) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleElementGrad) def AssembleFaceGrad(self, el1, el2, Tr, elfun, elmats): r"""AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceGrad(self, el1, el2, Tr, elfun, elmats) + AssembleFaceGrad = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceGrad) __swig_destroy__ = _nonlininteg.delete_BlockNonlinearFormIntegrator def __init__(self): @@ -186,18 +216,22 @@ def __init__(self, *args, **kwargs): def SetTransformation(self, _Ttr): r"""SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)""" return _nonlininteg.HyperelasticModel_SetTransformation(self, _Ttr) + SetTransformation = _swig_new_instance_method(_nonlininteg.HyperelasticModel_SetTransformation) def EvalW(self, Jpt): r"""EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double""" return _nonlininteg.HyperelasticModel_EvalW(self, Jpt) + EvalW = _swig_new_instance_method(_nonlininteg.HyperelasticModel_EvalW) def EvalP(self, Jpt, P): r"""EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)""" return _nonlininteg.HyperelasticModel_EvalP(self, Jpt, P) + EvalP = _swig_new_instance_method(_nonlininteg.HyperelasticModel_EvalP) def AssembleH(self, Jpt, DS, weight, A): r"""AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)""" return _nonlininteg.HyperelasticModel_AssembleH(self, Jpt, DS, weight, A) + AssembleH = _swig_new_instance_method(_nonlininteg.HyperelasticModel_AssembleH) # Register HyperelasticModel in _nonlininteg: _nonlininteg.HyperelasticModel_swigregister(HyperelasticModel) @@ -211,14 +245,17 @@ class InverseHarmonicModel(HyperelasticModel): def EvalW(self, J): r"""EvalW(InverseHarmonicModel self, DenseMatrix J) -> double""" return _nonlininteg.InverseHarmonicModel_EvalW(self, J) + EvalW = _swig_new_instance_method(_nonlininteg.InverseHarmonicModel_EvalW) def EvalP(self, J, P): r"""EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)""" return _nonlininteg.InverseHarmonicModel_EvalP(self, J, P) + EvalP = _swig_new_instance_method(_nonlininteg.InverseHarmonicModel_EvalP) def AssembleH(self, J, DS, weight, A): r"""AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)""" return _nonlininteg.InverseHarmonicModel_AssembleH(self, J, DS, weight, A) + AssembleH = _swig_new_instance_method(_nonlininteg.InverseHarmonicModel_AssembleH) def __init__(self): r"""__init__(InverseHarmonicModel self) -> InverseHarmonicModel""" @@ -244,14 +281,17 @@ def __init__(self, *args): def EvalW(self, J): r"""EvalW(NeoHookeanModel self, DenseMatrix J) -> double""" return _nonlininteg.NeoHookeanModel_EvalW(self, J) + EvalW = _swig_new_instance_method(_nonlininteg.NeoHookeanModel_EvalW) def EvalP(self, J, P): r"""EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)""" return _nonlininteg.NeoHookeanModel_EvalP(self, J, P) + EvalP = _swig_new_instance_method(_nonlininteg.NeoHookeanModel_EvalP) def AssembleH(self, J, DS, weight, A): r"""AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)""" return _nonlininteg.NeoHookeanModel_AssembleH(self, J, DS, weight, A) + AssembleH = _swig_new_instance_method(_nonlininteg.NeoHookeanModel_AssembleH) __swig_destroy__ = _nonlininteg.delete_NeoHookeanModel # Register NeoHookeanModel in _nonlininteg: @@ -270,14 +310,17 @@ def __init__(self, m): def GetElementEnergy(self, el, Ttr, elfun): r"""GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double""" return _nonlininteg.HyperelasticNLFIntegrator_GetElementEnergy(self, el, Ttr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.HyperelasticNLFIntegrator_GetElementEnergy) def AssembleElementVector(self, el, Ttr, elfun, elvect): r"""AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)""" return _nonlininteg.HyperelasticNLFIntegrator_AssembleElementVector(self, el, Ttr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.HyperelasticNLFIntegrator_AssembleElementVector) def AssembleElementGrad(self, el, Ttr, elfun, elmat): r"""AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)""" return _nonlininteg.HyperelasticNLFIntegrator_AssembleElementGrad(self, el, Ttr, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.HyperelasticNLFIntegrator_AssembleElementGrad) __swig_destroy__ = _nonlininteg.delete_HyperelasticNLFIntegrator # Register HyperelasticNLFIntegrator in _nonlininteg: @@ -296,18 +339,73 @@ def __init__(self, _mu): def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double""" return _nonlininteg.IncompressibleNeoHookeanIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.IncompressibleNeoHookeanIntegrator_GetElementEnergy) def AssembleElementVector(self, el, Tr, elfun, elvec): r"""AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)""" return _nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementVector(self, el, Tr, elfun, elvec) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementVector) def AssembleElementGrad(self, el, Tr, elfun, elmats): r"""AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)""" return _nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmats) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementGrad) __swig_destroy__ = _nonlininteg.delete_IncompressibleNeoHookeanIntegrator # Register IncompressibleNeoHookeanIntegrator in _nonlininteg: _nonlininteg.IncompressibleNeoHookeanIntegrator_swigregister(IncompressibleNeoHookeanIntegrator) +class VectorConvectionNLFIntegrator(NonlinearFormIntegrator): + r"""Proxy of C++ mfem::VectorConvectionNLFIntegrator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(VectorConvectionNLFIntegrator self, Coefficient q) -> VectorConvectionNLFIntegrator + __init__(VectorConvectionNLFIntegrator self) -> VectorConvectionNLFIntegrator + """ + _nonlininteg.VectorConvectionNLFIntegrator_swiginit(self, _nonlininteg.new_VectorConvectionNLFIntegrator(*args)) + + @staticmethod + def GetRule(fe, T): + r"""GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule""" + return _nonlininteg.VectorConvectionNLFIntegrator_GetRule(fe, T) + GetRule = _swig_new_static_method(_nonlininteg.VectorConvectionNLFIntegrator_GetRule) + + def AssembleElementVector(self, el, trans, elfun, elvect): + r"""AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)""" + return _nonlininteg.VectorConvectionNLFIntegrator_AssembleElementVector(self, el, trans, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AssembleElementVector) + + def AssembleElementGrad(self, el, trans, elfun, elmat): + r"""AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)""" + return _nonlininteg.VectorConvectionNLFIntegrator_AssembleElementGrad(self, el, trans, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AssembleElementGrad) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes) + AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes) + """ + return _nonlininteg.VectorConvectionNLFIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)""" + return _nonlininteg.VectorConvectionNLFIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AddMultPA) + __swig_destroy__ = _nonlininteg.delete_VectorConvectionNLFIntegrator + +# Register VectorConvectionNLFIntegrator in _nonlininteg: +_nonlininteg.VectorConvectionNLFIntegrator_swigregister(VectorConvectionNLFIntegrator) + +def VectorConvectionNLFIntegrator_GetRule(fe, T): + r"""VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule""" + return _nonlininteg.VectorConvectionNLFIntegrator_GetRule(fe, T) +VectorConvectionNLFIntegrator_GetRule = _nonlininteg.VectorConvectionNLFIntegrator_GetRule + diff --git a/mfem/_par/nonlininteg_wrap.cxx b/mfem/_par/nonlininteg_wrap.cxx index d364583b..2d0578c8 100644 --- a/mfem/_par/nonlininteg_wrap.cxx +++ b/mfem/_par/nonlininteg_wrap.cxx @@ -3064,154 +3064,159 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t swig_types[8] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[12] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[13] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[14] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[15] -#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__Coefficient swig_types[17] -#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[18] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[22] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[23] -#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[24] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[25] -#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[26] -#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[27] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[28] -#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[29] -#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[30] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[31] -#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[32] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[33] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[34] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[35] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[36] -#define SWIGTYPE_p_mfem__GridFunction swig_types[37] -#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[38] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[39] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[40] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[41] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[42] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[43] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[44] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[45] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[46] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[47] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[48] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[49] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[50] -#define SWIGTYPE_p_mfem__HyperelasticModel swig_types[51] -#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[53] -#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[55] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[56] -#define SWIGTYPE_p_mfem__InverseHarmonicModel swig_types[57] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[58] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[59] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[60] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[61] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[62] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[63] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[64] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[65] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[66] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[67] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[68] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[69] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[70] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[71] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[76] -#define SWIGTYPE_p_mfem__LinearForm swig_types[77] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[78] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[79] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[80] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[81] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[82] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[83] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__NeoHookeanModel swig_types[89] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[93] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[104] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[108] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[109] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[110] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[111] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[114] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[115] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[118] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[119] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[123] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[124] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[125] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[126] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[127] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[128] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[129] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[130] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[131] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[132] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[133] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[134] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[135] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[136] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[137] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[138] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[139] -#define SWIGTYPE_p_mfem__Vector swig_types[140] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[141] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[142] -#define SWIGTYPE_p_pri_t swig_types[143] -#define SWIGTYPE_p_quad_t swig_types[144] -#define SWIGTYPE_p_seg_t swig_types[145] -#define SWIGTYPE_p_tet_t swig_types[146] -#define SWIGTYPE_p_tri_t swig_types[147] -static swig_type_info *swig_types[149]; -static swig_module_info swig_module = {swig_types, 148, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t swig_types[9] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[13] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[14] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[15] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[16] +#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__Coefficient swig_types[18] +#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[19] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[24] +#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[25] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[26] +#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[27] +#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[28] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[29] +#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[30] +#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[31] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[32] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[33] +#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[34] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[35] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[36] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[37] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[38] +#define SWIGTYPE_p_mfem__GridFunction swig_types[39] +#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[40] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[41] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[42] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[43] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[44] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[45] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[46] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[47] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[49] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[50] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[51] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[52] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[53] +#define SWIGTYPE_p_mfem__HyperelasticModel swig_types[54] +#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[56] +#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[57] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[58] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[59] +#define SWIGTYPE_p_mfem__InverseHarmonicModel swig_types[60] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[61] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[63] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[64] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[65] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[66] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[67] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[68] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[69] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[70] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[71] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[72] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[73] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[74] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[75] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[79] +#define SWIGTYPE_p_mfem__LinearForm swig_types[80] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[81] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[82] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[83] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[84] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[85] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[86] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__NeoHookeanModel swig_types[92] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[95] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[96] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[99] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[106] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[107] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[110] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[111] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[112] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[113] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[117] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[118] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[125] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[126] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[127] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[128] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[129] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[130] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[131] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[132] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[133] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[134] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[135] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[136] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[137] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[138] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[139] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[141] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[142] +#define SWIGTYPE_p_mfem__Vector swig_types[143] +#define SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator swig_types[144] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[145] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[146] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[147] +#define SWIGTYPE_p_pri_t swig_types[148] +#define SWIGTYPE_p_quad_t swig_types[149] +#define SWIGTYPE_p_seg_t swig_types[150] +#define SWIGTYPE_p_tet_t swig_types[151] +#define SWIGTYPE_p_tri_t swig_types[152] +static swig_type_info *swig_types[154]; +static swig_module_info swig_module = {swig_types, 153, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3555,6 +3560,88 @@ double SwigDirector_NonlinearFormIntegrator::GetElementEnergy(mfem::FiniteElemen } +void SwigDirector_NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call NonlinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 5; + const char *const swig_method_name = "AssemblePA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&trial_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&test_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call NonlinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "AssemblePA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_NonlinearFormIntegrator::AddMultPA(mfem::Vector const &x, mfem::Vector &y) const { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call NonlinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "AddMultPA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AddMultPA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + SwigDirector_NonlinearFormIntegrator::~SwigDirector_NonlinearFormIntegrator() { } @@ -4169,6 +4256,227 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW } +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + Swig::Director *director = 0; + bool upcall = false; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::NonlinearFormIntegrator::AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } else { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + Swig::Director *director = 0; + bool upcall = false; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::NonlinearFormIntegrator::AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); + } else { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NonlinearFormIntegrator_AssemblePA__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NonlinearFormIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NonlinearFormIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n" + " mfem::NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + ((mfem::NonlinearFormIntegrator const *)arg1)->mfem::NonlinearFormIntegrator::AddMultPA((mfem::Vector const &)*arg2,*arg3); + } else { + ((mfem::NonlinearFormIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; @@ -6137,32 +6445,583 @@ SWIGINTERN PyObject *IncompressibleNeoHookeanIntegrator_swiginit(PyObject *SWIGU return SWIG_Python_InitShadowInstance(args); } -static PyMethodDef SwigMethods[] = { - { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, - { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, - { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, - { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, - { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "NonlinearFormIntegrator_GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, - { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, - { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, - { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, - { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "BlockNonlinearFormIntegrator_GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, - { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, - { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, - { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, - { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, - { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, - { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "HyperelasticModel_SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, - { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "HyperelasticModel_EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, +SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorConvectionNLFIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorConvectionNLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorConvectionNLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorConvectionNLFIntegrator *)new mfem::VectorConvectionNLFIntegrator(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorConvectionNLFIntegrator *)new mfem::VectorConvectionNLFIntegrator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorConvectionNLFIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorConvectionNLFIntegrator__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorConvectionNLFIntegrator__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorConvectionNLFIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorConvectionNLFIntegrator::VectorConvectionNLFIntegrator(mfem::Coefficient &)\n" + " mfem::VectorConvectionNLFIntegrator::VectorConvectionNLFIntegrator()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::IntegrationRule *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + { + try { + result = (mfem::IntegrationRule *) &mfem::VectorConvectionNLFIntegrator::GetRule((mfem::FiniteElement const &)*arg1,*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + { + try { + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementGrad((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorConvectionNLFIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " AssemblePA(mfem::FiniteElementSpace const &)\n" + " AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n" + " mfem::VectorConvectionNLFIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::VectorConvectionNLFIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorConvectionNLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorConvectionNLFIntegrator" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorConvectionNLFIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorConvectionNLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, + { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, + { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, + { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "NonlinearFormIntegrator_GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" + "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "NonlinearFormIntegrator_AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, + { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, + { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, + { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, + { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "BlockNonlinearFormIntegrator_GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, + { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, + { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, + { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, + { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, + { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "HyperelasticModel_SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, + { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "HyperelasticModel_EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, { "HyperelasticModel_EvalP", _wrap_HyperelasticModel_EvalP, METH_VARARGS, "HyperelasticModel_EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, { "HyperelasticModel_AssembleH", _wrap_HyperelasticModel_AssembleH, METH_VARARGS, "HyperelasticModel_AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "HyperelasticModel_swigregister", HyperelasticModel_swigregister, METH_O, NULL}, @@ -6197,10 +7056,107 @@ static PyMethodDef SwigMethods[] = { { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorConvectionNLFIntegrator", _wrap_new_VectorConvectionNLFIntegrator, METH_VARARGS, "\n" + "VectorConvectionNLFIntegrator(Coefficient q)\n" + "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" + ""}, + { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" + "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + ""}, + { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "VectorConvectionNLFIntegrator_AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, + { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, + { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, + { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, + { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, + { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" + "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, + { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, + { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, + { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, + { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, + { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, + { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, + { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, + { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, + { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, + { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, + { "HyperelasticModel_EvalP", _wrap_HyperelasticModel_EvalP, METH_VARARGS, "EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, + { "HyperelasticModel_AssembleH", _wrap_HyperelasticModel_AssembleH, METH_VARARGS, "AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "HyperelasticModel_swigregister", HyperelasticModel_swigregister, METH_O, NULL}, + { "InverseHarmonicModel_EvalW", _wrap_InverseHarmonicModel_EvalW, METH_VARARGS, "EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, + { "InverseHarmonicModel_EvalP", _wrap_InverseHarmonicModel_EvalP, METH_VARARGS, "EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, + { "InverseHarmonicModel_AssembleH", _wrap_InverseHarmonicModel_AssembleH, METH_VARARGS, "AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "new_InverseHarmonicModel", _wrap_new_InverseHarmonicModel, METH_NOARGS, "new_InverseHarmonicModel() -> InverseHarmonicModel"}, + { "delete_InverseHarmonicModel", _wrap_delete_InverseHarmonicModel, METH_O, "delete_InverseHarmonicModel(InverseHarmonicModel self)"}, + { "InverseHarmonicModel_swigregister", InverseHarmonicModel_swigregister, METH_O, NULL}, + { "InverseHarmonicModel_swiginit", InverseHarmonicModel_swiginit, METH_VARARGS, NULL}, + { "new_NeoHookeanModel", _wrap_new_NeoHookeanModel, METH_VARARGS, "\n" + "NeoHookeanModel(double _mu, double _K, double _g=1.0)\n" + "NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None)\n" + ""}, + { "NeoHookeanModel_EvalW", _wrap_NeoHookeanModel_EvalW, METH_VARARGS, "EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, + { "NeoHookeanModel_EvalP", _wrap_NeoHookeanModel_EvalP, METH_VARARGS, "EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, + { "NeoHookeanModel_AssembleH", _wrap_NeoHookeanModel_AssembleH, METH_VARARGS, "AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "delete_NeoHookeanModel", _wrap_delete_NeoHookeanModel, METH_O, "delete_NeoHookeanModel(NeoHookeanModel self)"}, + { "NeoHookeanModel_swigregister", NeoHookeanModel_swigregister, METH_O, NULL}, + { "NeoHookeanModel_swiginit", NeoHookeanModel_swiginit, METH_VARARGS, NULL}, + { "new_HyperelasticNLFIntegrator", _wrap_new_HyperelasticNLFIntegrator, METH_O, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, + { "HyperelasticNLFIntegrator_GetElementEnergy", _wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, + { "HyperelasticNLFIntegrator_AssembleElementVector", _wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, + { "HyperelasticNLFIntegrator_AssembleElementGrad", _wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, + { "delete_HyperelasticNLFIntegrator", _wrap_delete_HyperelasticNLFIntegrator, METH_O, "delete_HyperelasticNLFIntegrator(HyperelasticNLFIntegrator self)"}, + { "HyperelasticNLFIntegrator_swigregister", HyperelasticNLFIntegrator_swigregister, METH_O, NULL}, + { "HyperelasticNLFIntegrator_swiginit", HyperelasticNLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_IncompressibleNeoHookeanIntegrator", _wrap_new_IncompressibleNeoHookeanIntegrator, METH_O, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, + { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", _wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, + { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, + { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorConvectionNLFIntegrator", _wrap_new_VectorConvectionNLFIntegrator, METH_VARARGS, "\n" + "VectorConvectionNLFIntegrator(Coefficient q)\n" + "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" + ""}, + { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + ""}, + { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, + { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, + { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6216,6 +7172,9 @@ static void *_p_mfem__NeoHookeanModelTo_p_mfem__HyperelasticModel(void *x, int * static void *_p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::HyperelasticNLFIntegrator *) x)); } +static void *_p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::VectorConvectionNLFIntegrator *) x)); +} static void *_p_mfem__IncompressibleNeoHookeanIntegratorTo_p_mfem__BlockNonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BlockNonlinearFormIntegrator *) ((mfem::IncompressibleNeoHookeanIntegrator *) x)); } @@ -6267,12 +7226,6 @@ static void *_p_mfem__ConstantCoefficientTo_p_mfem__Coefficient(void *x, int *SW static void *_p_mfem__ExtrudeCoefficientTo_p_mfem__Coefficient(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Coefficient *) ((mfem::ExtrudeCoefficient *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -6306,6 +7259,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -6321,6 +7277,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -6489,6 +7448,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -6532,10 +7497,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -6575,6 +7540,7 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n } static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -6620,13 +7586,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -6638,6 +7602,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -6679,6 +7645,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -6702,6 +7670,7 @@ static swig_type_info _swigt__p_mfem__NURBSFiniteElement = {"_p_mfem__NURBSFinit static swig_type_info _swigt__p_mfem__NURBS1DFiniteElement = {"_p_mfem__NURBS1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS2DFiniteElement = {"_p_mfem__NURBS2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS3DFiniteElement = {"_p_mfem__NURBS3DFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HyperelasticModel = {"_p_mfem__HyperelasticModel", "mfem::HyperelasticModel *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HyperelasticNLFIntegrator = {"_p_mfem__HyperelasticNLFIntegrator", "mfem::HyperelasticNLFIntegrator *", 0, 0, (void*)0, 0}; @@ -6716,6 +7685,7 @@ static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector static swig_type_info _swigt__p_mfem__HypreParVector = {"_p_mfem__HypreParVector", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorConvectionNLFIntegrator = {"_p_mfem__VectorConvectionNLFIntegrator", "mfem::VectorConvectionNLFIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; @@ -6725,6 +7695,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -6755,6 +7726,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ExtrudeCoefficient, &_swigt__p_mfem__FaceElementTransformations, &_swigt__p_mfem__FiniteElement, + &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__FunctionCoefficient, &_swigt__p_mfem__GaussBiLinear2DFiniteElement, &_swigt__p_mfem__GaussBiQuad2DFiniteElement, @@ -6768,6 +7740,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -6864,8 +7837,10 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__TransformedCoefficient, &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__Vector, + &_swigt__p_mfem__VectorConvectionNLFIntegrator, &_swigt__p_mfem__VectorFiniteElement, &_swigt__p_mfem__VectorRotProductCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -6875,6 +7850,7 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -6919,13 +7895,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -6937,6 +7911,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -6978,6 +7954,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7001,7 +7979,8 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyperelasticModel[] = { {&_swigt__p_mfem__HyperelasticModel, 0, 0, 0}, {&_swigt__p_mfem__InverseHarmonicModel, _p_mfem__InverseHarmonicModelTo_p_mfem__HyperelasticModel, 0, 0}, {&_swigt__p_mfem__NeoHookeanModel, _p_mfem__NeoHookeanModelTo_p_mfem__HyperelasticModel, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyperelasticNLFIntegrator[] = { {&_swigt__p_mfem__HyperelasticNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -7010,12 +7989,13 @@ static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__I static swig_cast_info _swigc__p_mfem__InverseHarmonicModel[] = { {&_swigt__p_mfem__InverseHarmonicModel, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NeoHookeanModel[] = { {&_swigt__p_mfem__NeoHookeanModel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorConvectionNLFIntegrator, _p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__HypreParVector, _p_mfem__HypreParVectorTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorConvectionNLFIntegrator[] = { {&_swigt__p_mfem__VectorConvectionNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -7025,6 +8005,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -7055,6 +8036,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ExtrudeCoefficient, _swigc__p_mfem__FaceElementTransformations, _swigc__p_mfem__FiniteElement, + _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__FunctionCoefficient, _swigc__p_mfem__GaussBiLinear2DFiniteElement, _swigc__p_mfem__GaussBiQuad2DFiniteElement, @@ -7068,6 +8050,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -7164,8 +8147,10 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__TransformedCoefficient, _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__Vector, + _swigc__p_mfem__VectorConvectionNLFIntegrator, _swigc__p_mfem__VectorFiniteElement, _swigc__p_mfem__VectorRotProductCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_par/nonlininteg_wrap.h b/mfem/_par/nonlininteg_wrap.h index 3d3e67f9..9d048bb4 100644 --- a/mfem/_par/nonlininteg_wrap.h +++ b/mfem/_par/nonlininteg_wrap.h @@ -24,6 +24,9 @@ class SwigDirector_NonlinearFormIntegrator : public mfem::NonlinearFormIntegrato virtual void AssembleElementGrad(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); virtual void AssembleFaceGrad(mfem::FiniteElement const &el1, mfem::FiniteElement const &el2, mfem::FaceElementTransformations &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); virtual double GetElementEnergy(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun); + virtual void AssemblePA(mfem::FiniteElementSpace const &fes); + virtual void AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes); + virtual void AddMultPA(mfem::Vector const &x, mfem::Vector &y) const; virtual ~SwigDirector_NonlinearFormIntegrator(); /* Internal director utilities */ @@ -55,7 +58,7 @@ class SwigDirector_NonlinearFormIntegrator : public mfem::NonlinearFormIntegrato return method; } private: - mutable swig::SwigVar_PyObject vtable[5]; + mutable swig::SwigVar_PyObject vtable[8]; #endif }; diff --git a/mfem/_par/ode.i b/mfem/_par/ode.i index 44ac3b3c..ff3b9420 100644 --- a/mfem/_par/ode.i +++ b/mfem/_par/ode.i @@ -1,8 +1,10 @@ %module(package="mfem._par") ode %{ +#include "mfem.hpp" #include "linalg/ode.hpp" #include "pyoperator.hpp" #include "numpy/arrayobject.h" +#include "io_stream.hpp" %} %init %{ @@ -13,6 +15,8 @@ import_array(); %import "array.i" %import "operators.i" %import "../common/exception.i" +%import "../common/io_stream_typemap.i" +OSTREAM_TYPEMAP(std::ostream&) %typemap(in) double &t (double temp){ temp = PyFloat_AsDouble($input); diff --git a/mfem/_par/ode.py b/mfem/_par/ode.py index 1b3e92b0..d9116287 100644 --- a/mfem/_par/ode.py +++ b/mfem/_par/ode.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _ode.SWIG_PyInstanceMethod_New +_swig_new_static_method = _ode.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -79,14 +82,17 @@ def __init__(self, *args, **kwargs): def Init(self, f): r"""Init(ODESolver self, TimeDependentOperator f)""" return _ode.ODESolver_Init(self, f) + Init = _swig_new_instance_method(_ode.ODESolver_Init) def Step(self, x, t, dt): r"""Step(ODESolver self, Vector x, double & t, double & dt)""" return _ode.ODESolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ODESolver_Step) def Run(self, x, t, dt, tf): r"""Run(ODESolver self, Vector x, double & t, double & dt, double tf)""" return _ode.ODESolver_Run(self, x, t, dt, tf) + Run = _swig_new_instance_method(_ode.ODESolver_Run) __swig_destroy__ = _ode.delete_ODESolver # Register ODESolver in _ode: @@ -101,10 +107,12 @@ class ForwardEulerSolver(ODESolver): def Init(self, _f): r"""Init(ForwardEulerSolver self, TimeDependentOperator _f)""" return _ode.ForwardEulerSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.ForwardEulerSolver_Init) def Step(self, x, t, dt): r"""Step(ForwardEulerSolver self, Vector x, double & t, double & dt)""" return _ode.ForwardEulerSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ForwardEulerSolver_Step) def __init__(self): r"""__init__(ForwardEulerSolver self) -> ForwardEulerSolver""" @@ -127,10 +135,12 @@ def __init__(self, *args): def Init(self, _f): r"""Init(RK2Solver self, TimeDependentOperator _f)""" return _ode.RK2Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.RK2Solver_Init) def Step(self, x, t, dt): r"""Step(RK2Solver self, Vector x, double & t, double & dt)""" return _ode.RK2Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.RK2Solver_Step) __swig_destroy__ = _ode.delete_RK2Solver # Register RK2Solver in _ode: @@ -145,10 +155,12 @@ class RK3SSPSolver(ODESolver): def Init(self, _f): r"""Init(RK3SSPSolver self, TimeDependentOperator _f)""" return _ode.RK3SSPSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.RK3SSPSolver_Init) def Step(self, x, t, dt): r"""Step(RK3SSPSolver self, Vector x, double & t, double & dt)""" return _ode.RK3SSPSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.RK3SSPSolver_Step) def __init__(self): r"""__init__(RK3SSPSolver self) -> RK3SSPSolver""" @@ -167,10 +179,12 @@ class RK4Solver(ODESolver): def Init(self, _f): r"""Init(RK4Solver self, TimeDependentOperator _f)""" return _ode.RK4Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.RK4Solver_Init) def Step(self, x, t, dt): r"""Step(RK4Solver self, Vector x, double & t, double & dt)""" return _ode.RK4Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.RK4Solver_Step) def __init__(self): r"""__init__(RK4Solver self) -> RK4Solver""" @@ -193,10 +207,12 @@ def __init__(self, _s, _a, _b, _c): def Init(self, _f): r"""Init(ExplicitRKSolver self, TimeDependentOperator _f)""" return _ode.ExplicitRKSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.ExplicitRKSolver_Init) def Step(self, x, t, dt): r"""Step(ExplicitRKSolver self, Vector x, double & t, double & dt)""" return _ode.ExplicitRKSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ExplicitRKSolver_Step) __swig_destroy__ = _ode.delete_ExplicitRKSolver # Register ExplicitRKSolver in _ode: @@ -230,6 +246,194 @@ def __init__(self): # Register RK8Solver in _ode: _ode.RK8Solver_swigregister(RK8Solver) +class AdamsBashforthSolver(ODESolver): + r"""Proxy of C++ mfem::AdamsBashforthSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, _s, _a): + r"""__init__(AdamsBashforthSolver self, int _s, double const * _a) -> AdamsBashforthSolver""" + _ode.AdamsBashforthSolver_swiginit(self, _ode.new_AdamsBashforthSolver(_s, _a)) + + def Init(self, _f): + r"""Init(AdamsBashforthSolver self, TimeDependentOperator _f)""" + return _ode.AdamsBashforthSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.AdamsBashforthSolver_Init) + + def Step(self, x, t, dt): + r"""Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)""" + return _ode.AdamsBashforthSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.AdamsBashforthSolver_Step) + __swig_destroy__ = _ode.delete_AdamsBashforthSolver + +# Register AdamsBashforthSolver in _ode: +_ode.AdamsBashforthSolver_swigregister(AdamsBashforthSolver) + +class AB1Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB1Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB1Solver self) -> AB1Solver""" + _ode.AB1Solver_swiginit(self, _ode.new_AB1Solver()) + __swig_destroy__ = _ode.delete_AB1Solver + +# Register AB1Solver in _ode: +_ode.AB1Solver_swigregister(AB1Solver) + +class AB2Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB2Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB2Solver self) -> AB2Solver""" + _ode.AB2Solver_swiginit(self, _ode.new_AB2Solver()) + __swig_destroy__ = _ode.delete_AB2Solver + +# Register AB2Solver in _ode: +_ode.AB2Solver_swigregister(AB2Solver) + +class AB3Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB3Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB3Solver self) -> AB3Solver""" + _ode.AB3Solver_swiginit(self, _ode.new_AB3Solver()) + __swig_destroy__ = _ode.delete_AB3Solver + +# Register AB3Solver in _ode: +_ode.AB3Solver_swigregister(AB3Solver) + +class AB4Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB4Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB4Solver self) -> AB4Solver""" + _ode.AB4Solver_swiginit(self, _ode.new_AB4Solver()) + __swig_destroy__ = _ode.delete_AB4Solver + +# Register AB4Solver in _ode: +_ode.AB4Solver_swigregister(AB4Solver) + +class AB5Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB5Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB5Solver self) -> AB5Solver""" + _ode.AB5Solver_swiginit(self, _ode.new_AB5Solver()) + __swig_destroy__ = _ode.delete_AB5Solver + +# Register AB5Solver in _ode: +_ode.AB5Solver_swigregister(AB5Solver) + +class AdamsMoultonSolver(ODESolver): + r"""Proxy of C++ mfem::AdamsMoultonSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, _s, _a): + r"""__init__(AdamsMoultonSolver self, int _s, double const * _a) -> AdamsMoultonSolver""" + _ode.AdamsMoultonSolver_swiginit(self, _ode.new_AdamsMoultonSolver(_s, _a)) + + def Init(self, _f): + r"""Init(AdamsMoultonSolver self, TimeDependentOperator _f)""" + return _ode.AdamsMoultonSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.AdamsMoultonSolver_Init) + + def Step(self, x, t, dt): + r"""Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)""" + return _ode.AdamsMoultonSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.AdamsMoultonSolver_Step) + __swig_destroy__ = _ode.delete_AdamsMoultonSolver + +# Register AdamsMoultonSolver in _ode: +_ode.AdamsMoultonSolver_swigregister(AdamsMoultonSolver) + +class AM0Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM0Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM0Solver self) -> AM0Solver""" + _ode.AM0Solver_swiginit(self, _ode.new_AM0Solver()) + __swig_destroy__ = _ode.delete_AM0Solver + +# Register AM0Solver in _ode: +_ode.AM0Solver_swigregister(AM0Solver) + +class AM1Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM1Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM1Solver self) -> AM1Solver""" + _ode.AM1Solver_swiginit(self, _ode.new_AM1Solver()) + __swig_destroy__ = _ode.delete_AM1Solver + +# Register AM1Solver in _ode: +_ode.AM1Solver_swigregister(AM1Solver) + +class AM2Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM2Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM2Solver self) -> AM2Solver""" + _ode.AM2Solver_swiginit(self, _ode.new_AM2Solver()) + __swig_destroy__ = _ode.delete_AM2Solver + +# Register AM2Solver in _ode: +_ode.AM2Solver_swigregister(AM2Solver) + +class AM3Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM3Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM3Solver self) -> AM3Solver""" + _ode.AM3Solver_swiginit(self, _ode.new_AM3Solver()) + __swig_destroy__ = _ode.delete_AM3Solver + +# Register AM3Solver in _ode: +_ode.AM3Solver_swigregister(AM3Solver) + +class AM4Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM4Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM4Solver self) -> AM4Solver""" + _ode.AM4Solver_swiginit(self, _ode.new_AM4Solver()) + __swig_destroy__ = _ode.delete_AM4Solver + +# Register AM4Solver in _ode: +_ode.AM4Solver_swigregister(AM4Solver) + class BackwardEulerSolver(ODESolver): r"""Proxy of C++ mfem::BackwardEulerSolver class.""" @@ -239,10 +443,12 @@ class BackwardEulerSolver(ODESolver): def Init(self, _f): r"""Init(BackwardEulerSolver self, TimeDependentOperator _f)""" return _ode.BackwardEulerSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.BackwardEulerSolver_Init) def Step(self, x, t, dt): r"""Step(BackwardEulerSolver self, Vector x, double & t, double & dt)""" return _ode.BackwardEulerSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.BackwardEulerSolver_Step) def __init__(self): r"""__init__(BackwardEulerSolver self) -> BackwardEulerSolver""" @@ -261,10 +467,12 @@ class ImplicitMidpointSolver(ODESolver): def Init(self, _f): r"""Init(ImplicitMidpointSolver self, TimeDependentOperator _f)""" return _ode.ImplicitMidpointSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.ImplicitMidpointSolver_Init) def Step(self, x, t, dt): r"""Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)""" return _ode.ImplicitMidpointSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ImplicitMidpointSolver_Step) def __init__(self): r"""__init__(ImplicitMidpointSolver self) -> ImplicitMidpointSolver""" @@ -287,10 +495,12 @@ def __init__(self, gamma_opt=1): def Init(self, _f): r"""Init(SDIRK23Solver self, TimeDependentOperator _f)""" return _ode.SDIRK23Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.SDIRK23Solver_Init) def Step(self, x, t, dt): r"""Step(SDIRK23Solver self, Vector x, double & t, double & dt)""" return _ode.SDIRK23Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.SDIRK23Solver_Step) __swig_destroy__ = _ode.delete_SDIRK23Solver # Register SDIRK23Solver in _ode: @@ -305,10 +515,12 @@ class SDIRK34Solver(ODESolver): def Init(self, _f): r"""Init(SDIRK34Solver self, TimeDependentOperator _f)""" return _ode.SDIRK34Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.SDIRK34Solver_Init) def Step(self, x, t, dt): r"""Step(SDIRK34Solver self, Vector x, double & t, double & dt)""" return _ode.SDIRK34Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.SDIRK34Solver_Step) def __init__(self): r"""__init__(SDIRK34Solver self) -> SDIRK34Solver""" @@ -327,10 +539,12 @@ class SDIRK33Solver(ODESolver): def Init(self, _f): r"""Init(SDIRK33Solver self, TimeDependentOperator _f)""" return _ode.SDIRK33Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.SDIRK33Solver_Init) def Step(self, x, t, dt): r"""Step(SDIRK33Solver self, Vector x, double & t, double & dt)""" return _ode.SDIRK33Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.SDIRK33Solver_Step) def __init__(self): r"""__init__(SDIRK33Solver self) -> SDIRK33Solver""" @@ -353,10 +567,12 @@ def __init__(self, rho=1.0): def Init(self, _f): r"""Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)""" return _ode.GeneralizedAlphaSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.GeneralizedAlphaSolver_Init) def Step(self, x, t, dt): r"""Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)""" return _ode.GeneralizedAlphaSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.GeneralizedAlphaSolver_Step) __swig_destroy__ = _ode.delete_GeneralizedAlphaSolver # Register GeneralizedAlphaSolver in _ode: @@ -374,14 +590,17 @@ def __init__(self, *args, **kwargs): def Init(self, P, F): r"""Init(SIASolver self, Operator P, TimeDependentOperator F)""" return _ode.SIASolver_Init(self, P, F) + Init = _swig_new_instance_method(_ode.SIASolver_Init) def Step(self, q, p, t, dt): r"""Step(SIASolver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIASolver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIASolver_Step) def Run(self, q, p, t, dt, tf): r"""Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)""" return _ode.SIASolver_Run(self, q, p, t, dt, tf) + Run = _swig_new_instance_method(_ode.SIASolver_Run) __swig_destroy__ = _ode.delete_SIASolver # Register SIASolver in _ode: @@ -400,6 +619,7 @@ def __init__(self): def Step(self, q, p, t, dt): r"""Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIA1Solver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIA1Solver_Step) __swig_destroy__ = _ode.delete_SIA1Solver # Register SIA1Solver in _ode: @@ -418,6 +638,7 @@ def __init__(self): def Step(self, q, p, t, dt): r"""Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIA2Solver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIA2Solver_Step) __swig_destroy__ = _ode.delete_SIA2Solver # Register SIA2Solver in _ode: @@ -436,10 +657,181 @@ def __init__(self, order): def Step(self, q, p, t, dt): r"""Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIAVSolver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIAVSolver_Step) __swig_destroy__ = _ode.delete_SIAVSolver # Register SIAVSolver in _ode: _ode.SIAVSolver_swigregister(SIAVSolver) +class SecondOrderODESolver(object): + r"""Proxy of C++ mfem::SecondOrderODESolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + + def Init(self, f): + r"""Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)""" + return _ode.SecondOrderODESolver_Init(self, f) + Init = _swig_new_instance_method(_ode.SecondOrderODESolver_Init) + + def Step(self, x, dxdt, t, dt): + r"""Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)""" + return _ode.SecondOrderODESolver_Step(self, x, dxdt, t, dt) + Step = _swig_new_instance_method(_ode.SecondOrderODESolver_Step) + + def Run(self, x, dxdt, t, dt, tf): + r"""Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)""" + return _ode.SecondOrderODESolver_Run(self, x, dxdt, t, dt, tf) + Run = _swig_new_instance_method(_ode.SecondOrderODESolver_Run) + __swig_destroy__ = _ode.delete_SecondOrderODESolver + +# Register SecondOrderODESolver in _ode: +_ode.SecondOrderODESolver_swigregister(SecondOrderODESolver) + +class NewmarkSolver(SecondOrderODESolver): + r"""Proxy of C++ mfem::NewmarkSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, beta_=0.25, gamma_=0.5): + r"""__init__(NewmarkSolver self, double beta_=0.25, double gamma_=0.5) -> NewmarkSolver""" + _ode.NewmarkSolver_swiginit(self, _ode.new_NewmarkSolver(beta_, gamma_)) + + def PrintProperties(self, *args): + r"""PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)""" + return _ode.NewmarkSolver_PrintProperties(self, *args) + PrintProperties = _swig_new_instance_method(_ode.NewmarkSolver_PrintProperties) + + def Init(self, _f): + r"""Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)""" + return _ode.NewmarkSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.NewmarkSolver_Init) + + def Step(self, x, dxdt, t, dt): + r"""Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)""" + return _ode.NewmarkSolver_Step(self, x, dxdt, t, dt) + Step = _swig_new_instance_method(_ode.NewmarkSolver_Step) + __swig_destroy__ = _ode.delete_NewmarkSolver + +# Register NewmarkSolver in _ode: +_ode.NewmarkSolver_swigregister(NewmarkSolver) + +class LinearAccelerationSolver(NewmarkSolver): + r"""Proxy of C++ mfem::LinearAccelerationSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(LinearAccelerationSolver self) -> LinearAccelerationSolver""" + _ode.LinearAccelerationSolver_swiginit(self, _ode.new_LinearAccelerationSolver()) + __swig_destroy__ = _ode.delete_LinearAccelerationSolver + +# Register LinearAccelerationSolver in _ode: +_ode.LinearAccelerationSolver_swigregister(LinearAccelerationSolver) + +class CentralDifferenceSolver(NewmarkSolver): + r"""Proxy of C++ mfem::CentralDifferenceSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(CentralDifferenceSolver self) -> CentralDifferenceSolver""" + _ode.CentralDifferenceSolver_swiginit(self, _ode.new_CentralDifferenceSolver()) + __swig_destroy__ = _ode.delete_CentralDifferenceSolver + +# Register CentralDifferenceSolver in _ode: +_ode.CentralDifferenceSolver_swigregister(CentralDifferenceSolver) + +class FoxGoodwinSolver(NewmarkSolver): + r"""Proxy of C++ mfem::FoxGoodwinSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(FoxGoodwinSolver self) -> FoxGoodwinSolver""" + _ode.FoxGoodwinSolver_swiginit(self, _ode.new_FoxGoodwinSolver()) + __swig_destroy__ = _ode.delete_FoxGoodwinSolver + +# Register FoxGoodwinSolver in _ode: +_ode.FoxGoodwinSolver_swigregister(FoxGoodwinSolver) + +class GeneralizedAlpha2Solver(SecondOrderODESolver): + r"""Proxy of C++ mfem::GeneralizedAlpha2Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, rho_inf=1.0): + r"""__init__(GeneralizedAlpha2Solver self, double rho_inf=1.0) -> GeneralizedAlpha2Solver""" + _ode.GeneralizedAlpha2Solver_swiginit(self, _ode.new_GeneralizedAlpha2Solver(rho_inf)) + + def PrintProperties(self, *args): + r"""PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)""" + return _ode.GeneralizedAlpha2Solver_PrintProperties(self, *args) + PrintProperties = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_PrintProperties) + + def Init(self, _f): + r"""Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)""" + return _ode.GeneralizedAlpha2Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_Init) + + def Step(self, x, dxdt, t, dt): + r"""Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)""" + return _ode.GeneralizedAlpha2Solver_Step(self, x, dxdt, t, dt) + Step = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_Step) + __swig_destroy__ = _ode.delete_GeneralizedAlpha2Solver + +# Register GeneralizedAlpha2Solver in _ode: +_ode.GeneralizedAlpha2Solver_swigregister(GeneralizedAlpha2Solver) + +class AverageAccelerationSolver(GeneralizedAlpha2Solver): + r"""Proxy of C++ mfem::AverageAccelerationSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AverageAccelerationSolver self) -> AverageAccelerationSolver""" + _ode.AverageAccelerationSolver_swiginit(self, _ode.new_AverageAccelerationSolver()) + __swig_destroy__ = _ode.delete_AverageAccelerationSolver + +# Register AverageAccelerationSolver in _ode: +_ode.AverageAccelerationSolver_swigregister(AverageAccelerationSolver) + +class HHTAlphaSolver(GeneralizedAlpha2Solver): + r"""Proxy of C++ mfem::HHTAlphaSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, alpha=1.0): + r"""__init__(HHTAlphaSolver self, double alpha=1.0) -> HHTAlphaSolver""" + _ode.HHTAlphaSolver_swiginit(self, _ode.new_HHTAlphaSolver(alpha)) + __swig_destroy__ = _ode.delete_HHTAlphaSolver + +# Register HHTAlphaSolver in _ode: +_ode.HHTAlphaSolver_swigregister(HHTAlphaSolver) + +class WBZAlphaSolver(GeneralizedAlpha2Solver): + r"""Proxy of C++ mfem::WBZAlphaSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, rho_inf=1.0): + r"""__init__(WBZAlphaSolver self, double rho_inf=1.0) -> WBZAlphaSolver""" + _ode.WBZAlphaSolver_swiginit(self, _ode.new_WBZAlphaSolver(rho_inf)) + __swig_destroy__ = _ode.delete_WBZAlphaSolver + +# Register WBZAlphaSolver in _ode: +_ode.WBZAlphaSolver_swigregister(WBZAlphaSolver) + diff --git a/mfem/_par/ode_wrap.cxx b/mfem/_par/ode_wrap.cxx index 076f839c..b79f50f8 100644 --- a/mfem/_par/ode_wrap.cxx +++ b/mfem/_par/ode_wrap.cxx @@ -3068,38 +3068,62 @@ namespace Swig { #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] #define SWIGTYPE_p_char swig_types[1] #define SWIGTYPE_p_double swig_types[2] -#define SWIGTYPE_p_mfem__BackwardEulerSolver swig_types[3] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[4] -#define SWIGTYPE_p_mfem__ExplicitRKSolver swig_types[5] -#define SWIGTYPE_p_mfem__ForwardEulerSolver swig_types[6] -#define SWIGTYPE_p_mfem__GeneralizedAlphaSolver swig_types[7] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[8] -#define SWIGTYPE_p_mfem__ImplicitMidpointSolver swig_types[9] -#define SWIGTYPE_p_mfem__ODESolver swig_types[10] -#define SWIGTYPE_p_mfem__Operator swig_types[11] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[12] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[13] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[14] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[15] -#define SWIGTYPE_p_mfem__RK2Solver swig_types[16] -#define SWIGTYPE_p_mfem__RK3SSPSolver swig_types[17] -#define SWIGTYPE_p_mfem__RK4Solver swig_types[18] -#define SWIGTYPE_p_mfem__RK6Solver swig_types[19] -#define SWIGTYPE_p_mfem__RK8Solver swig_types[20] -#define SWIGTYPE_p_mfem__SDIRK23Solver swig_types[21] -#define SWIGTYPE_p_mfem__SDIRK33Solver swig_types[22] -#define SWIGTYPE_p_mfem__SDIRK34Solver swig_types[23] -#define SWIGTYPE_p_mfem__SIA1Solver swig_types[24] -#define SWIGTYPE_p_mfem__SIA2Solver swig_types[25] -#define SWIGTYPE_p_mfem__SIASolver swig_types[26] -#define SWIGTYPE_p_mfem__SIAVSolver swig_types[27] -#define SWIGTYPE_p_mfem__Solver swig_types[28] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[29] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[30] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[31] -#define SWIGTYPE_p_mfem__Vector swig_types[32] -static swig_type_info *swig_types[34]; -static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__AB1Solver swig_types[3] +#define SWIGTYPE_p_mfem__AB2Solver swig_types[4] +#define SWIGTYPE_p_mfem__AB3Solver swig_types[5] +#define SWIGTYPE_p_mfem__AB4Solver swig_types[6] +#define SWIGTYPE_p_mfem__AB5Solver swig_types[7] +#define SWIGTYPE_p_mfem__AM0Solver swig_types[8] +#define SWIGTYPE_p_mfem__AM1Solver swig_types[9] +#define SWIGTYPE_p_mfem__AM2Solver swig_types[10] +#define SWIGTYPE_p_mfem__AM3Solver swig_types[11] +#define SWIGTYPE_p_mfem__AM4Solver swig_types[12] +#define SWIGTYPE_p_mfem__AdamsBashforthSolver swig_types[13] +#define SWIGTYPE_p_mfem__AdamsMoultonSolver swig_types[14] +#define SWIGTYPE_p_mfem__AverageAccelerationSolver swig_types[15] +#define SWIGTYPE_p_mfem__BackwardEulerSolver swig_types[16] +#define SWIGTYPE_p_mfem__CentralDifferenceSolver swig_types[17] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[18] +#define SWIGTYPE_p_mfem__ExplicitRKSolver swig_types[19] +#define SWIGTYPE_p_mfem__ForwardEulerSolver swig_types[20] +#define SWIGTYPE_p_mfem__FoxGoodwinSolver swig_types[21] +#define SWIGTYPE_p_mfem__GeneralizedAlpha2Solver swig_types[22] +#define SWIGTYPE_p_mfem__GeneralizedAlphaSolver swig_types[23] +#define SWIGTYPE_p_mfem__HHTAlphaSolver swig_types[24] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[25] +#define SWIGTYPE_p_mfem__ImplicitMidpointSolver swig_types[26] +#define SWIGTYPE_p_mfem__LinearAccelerationSolver swig_types[27] +#define SWIGTYPE_p_mfem__NewmarkSolver swig_types[28] +#define SWIGTYPE_p_mfem__ODESolver swig_types[29] +#define SWIGTYPE_p_mfem__Operator swig_types[30] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[31] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[32] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[33] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[34] +#define SWIGTYPE_p_mfem__RK2Solver swig_types[35] +#define SWIGTYPE_p_mfem__RK3SSPSolver swig_types[36] +#define SWIGTYPE_p_mfem__RK4Solver swig_types[37] +#define SWIGTYPE_p_mfem__RK6Solver swig_types[38] +#define SWIGTYPE_p_mfem__RK8Solver swig_types[39] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[40] +#define SWIGTYPE_p_mfem__SDIRK23Solver swig_types[41] +#define SWIGTYPE_p_mfem__SDIRK33Solver swig_types[42] +#define SWIGTYPE_p_mfem__SDIRK34Solver swig_types[43] +#define SWIGTYPE_p_mfem__SIA1Solver swig_types[44] +#define SWIGTYPE_p_mfem__SIA2Solver swig_types[45] +#define SWIGTYPE_p_mfem__SIASolver swig_types[46] +#define SWIGTYPE_p_mfem__SIAVSolver swig_types[47] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[48] +#define SWIGTYPE_p_mfem__SecondOrderODESolver swig_types[49] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[50] +#define SWIGTYPE_p_mfem__Solver swig_types[51] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[52] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[53] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[54] +#define SWIGTYPE_p_mfem__Vector swig_types[55] +#define SWIGTYPE_p_mfem__WBZAlphaSolver swig_types[56] +static swig_type_info *swig_types[58]; +static swig_module_info swig_module = {swig_types, 57, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3203,9 +3227,11 @@ namespace swig { } +#include "mfem.hpp" #include "linalg/ode.hpp" #include "pyoperator.hpp" #include "numpy/arrayobject.h" +#include "io_stream.hpp" SWIGINTERN int @@ -4597,9 +4623,50 @@ SWIGINTERN PyObject *RK8Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; + int arg1 ; + double *arg2 = (double *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::AdamsBashforthSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_AdamsBashforthSolver", 2, 2, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsBashforthSolver" "', argument " "2"" of type '" "double const *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (mfem::AdamsBashforthSolver *)new mfem::AdamsBashforthSolver(arg1,(double const *)arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AdamsBashforthSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4607,18 +4674,18 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Init" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } - arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsBashforthSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { @@ -4641,9 +4708,9 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; + mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::Vector *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; @@ -4655,18 +4722,18 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel double dtemp4 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Step" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } - arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsBashforthSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { @@ -4703,14 +4770,23 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *result = 0 ; + mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "new_BackwardEulerSolver", 0, 0, 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdamsBashforthSolver" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); + } + arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); { try { - result = (mfem::BackwardEulerSolver *)new mfem::BackwardEulerSolver(); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4721,27 +4797,63 @@ SWIGINTERN PyObject *_wrap_new_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AdamsBashforthSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AdamsBashforthSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AdamsBashforthSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AB1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; + mfem::AB1Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_AB1Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::AB1Solver *)new mfem::AB1Solver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB1Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_AB1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AB1Solver *arg1 = (mfem::AB1Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB1Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BackwardEulerSolver" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB1Solver" "', argument " "1"" of type '" "mfem::AB1Solver *""'"); } - arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AB1Solver * >(argp1); { try { delete arg1; @@ -4762,44 +4874,25 @@ SWIGINTERN PyObject *_wrap_delete_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *BackwardEulerSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB1Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *BackwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AB2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; - mfem::TimeDependentOperator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::AB2Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Init" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); - } - arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + if (!SWIG_Python_UnpackTuple(args, "new_AB2Solver", 0, 0, 0)) SWIG_fail; { try { - (arg1)->Init(*arg2); + result = (mfem::AB2Solver *)new mfem::AB2Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4810,52 +4903,30 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM( // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB2Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AB2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; + mfem::AB2Solver *arg1 = (mfem::AB2Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double temp3 ; - double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB2Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Step" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); - } - arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - temp3 = PyFloat_AsDouble(swig_obj[2]); - arg3 = &temp3; - } - { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &dtemp4; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB2Solver" "', argument " "1"" of type '" "mfem::AB2Solver *""'"); } + arg1 = reinterpret_cast< mfem::AB2Solver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4867,26 +4938,31 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM( // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB2Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AB2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AB3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *result = 0 ; + mfem::AB3Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ImplicitMidpointSolver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AB3Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::ImplicitMidpointSolver *)new mfem::ImplicitMidpointSolver(); + result = (mfem::AB3Solver *)new mfem::AB3Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4897,27 +4973,27 @@ SWIGINTERN PyObject *_wrap_new_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB3Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AB3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; + mfem::AB3Solver *arg1 = (mfem::AB3Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB3Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImplicitMidpointSolver" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB3Solver" "', argument " "1"" of type '" "mfem::AB3Solver *""'"); } - arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AB3Solver * >(argp1); { try { delete arg1; @@ -4938,32 +5014,25 @@ SWIGINTERN PyObject *_wrap_delete_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *ImplicitMidpointSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB3Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB3Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ImplicitMidpointSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB3Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_AB4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - mfem::SDIRK23Solver *result = 0 ; + mfem::AB4Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!SWIG_Python_UnpackTuple(args, "new_AB4Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); + result = (mfem::AB4Solver *)new mfem::AB4Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4974,21 +5043,30 @@ SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(se // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB4Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_delete_AB4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *result = 0 ; + mfem::AB4Solver *arg1 = (mfem::AB4Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB4Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB4Solver" "', argument " "1"" of type '" "mfem::AB4Solver *""'"); + } + arg1 = reinterpret_cast< mfem::AB4Solver * >(argp1); { try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4999,75 +5077,32 @@ SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(se // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SDIRK23Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SDIRK23Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SDIRK23Solver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SDIRK23Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SDIRK23Solver::SDIRK23Solver(int)\n" - " mfem::SDIRK23Solver::SDIRK23Solver()\n"); - return 0; +SWIGINTERN PyObject *AB4Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB4Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } +SWIGINTERN PyObject *AB4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AB5Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; - mfem::TimeDependentOperator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::AB5Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + if (!SWIG_Python_UnpackTuple(args, "new_AB5Solver", 0, 0, 0)) SWIG_fail; { try { - (arg1)->Init(*arg2); + result = (mfem::AB5Solver *)new mfem::AB5Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5078,52 +5113,30 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB5Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AB5Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; + mfem::AB5Solver *arg1 = (mfem::AB5Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double temp3 ; - double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB5Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - temp3 = PyFloat_AsDouble(swig_obj[2]); - arg3 = &temp3; - } - { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &dtemp4; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB5Solver" "', argument " "1"" of type '" "mfem::AB5Solver *""'"); } + arg1 = reinterpret_cast< mfem::AB5Solver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5135,35 +5148,47 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB5Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB5Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AB5Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; + int arg1 ; + double *arg2 = (double *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::AdamsMoultonSolver *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK23Solver" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + if (!SWIG_Python_UnpackTuple(args, "new_AdamsMoultonSolver", 2, 2, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsMoultonSolver" "', argument " "2"" of type '" "double const *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); { try { - delete arg1; + result = (mfem::AdamsMoultonSolver *)new mfem::AdamsMoultonSolver(arg1,(double const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5174,27 +5199,16 @@ SWIGINTERN PyObject *_wrap_delete_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AdamsMoultonSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *SDIRK23Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *SDIRK23Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -5202,18 +5216,18 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Init" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsMoultonSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { @@ -5236,9 +5250,9 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::Vector *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; @@ -5250,18 +5264,18 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py double dtemp4 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Step" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsMoultonSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { @@ -5298,45 +5312,20 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SDIRK34Solver *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_SDIRK34Solver", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::SDIRK34Solver *)new mfem::SDIRK34Solver(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK34Solver" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdamsMoultonSolver" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); { try { delete arg1; @@ -5357,44 +5346,25 @@ SWIGINTERN PyObject *_wrap_delete_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SDIRK34Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AdamsMoultonSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AdamsMoultonSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SDIRK34Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AdamsMoultonSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AM0Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; - mfem::TimeDependentOperator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::AM0Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + if (!SWIG_Python_UnpackTuple(args, "new_AM0Solver", 0, 0, 0)) SWIG_fail; { try { - (arg1)->Init(*arg2); + result = (mfem::AM0Solver *)new mfem::AM0Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5405,52 +5375,30 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM0Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AM0Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; + mfem::AM0Solver *arg1 = (mfem::AM0Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double temp3 ; - double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM0Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - temp3 = PyFloat_AsDouble(swig_obj[2]); - arg3 = &temp3; - } - { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &dtemp4; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM0Solver" "', argument " "1"" of type '" "mfem::AM0Solver *""'"); } + arg1 = reinterpret_cast< mfem::AM0Solver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5462,26 +5410,31 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM0Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM0Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AM0Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AM1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *result = 0 ; + mfem::AM1Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_SDIRK33Solver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AM1Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::SDIRK33Solver *)new mfem::SDIRK33Solver(); + result = (mfem::AM1Solver *)new mfem::AM1Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5492,27 +5445,27 @@ SWIGINTERN PyObject *_wrap_new_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyO // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM1Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AM1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + mfem::AM1Solver *arg1 = (mfem::AM1Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM1Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK33Solver" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM1Solver" "', argument " "1"" of type '" "mfem::AM1Solver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AM1Solver * >(argp1); { try { delete arg1; @@ -5533,33 +5486,25 @@ SWIGINTERN PyObject *_wrap_delete_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SDIRK33Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM1Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SDIRK33Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_AM2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - double arg1 ; - double val1 ; - int ecode1 = 0 ; - mfem::GeneralizedAlphaSolver *result = 0 ; + mfem::AM2Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); + if (!SWIG_Python_UnpackTuple(args, "new_AM2Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); + result = (mfem::AM2Solver *)new mfem::AM2Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5570,21 +5515,30 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM2Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_delete_AM2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + mfem::AM2Solver *arg1 = (mfem::AM2Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM2Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM2Solver" "', argument " "1"" of type '" "mfem::AM2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::AM2Solver * >(argp1); { try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5595,47 +5549,167 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; +SWIGINTERN PyObject *AM2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM2Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AM2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AM3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AM3Solver *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_1(self, argc, argv); + if (!SWIG_Python_UnpackTuple(args, "new_AM3Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::AM3Solver *)new mfem::AM3Solver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM3Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_AM3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AM3Solver *arg1 = (mfem::AM3Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM3Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM3Solver" "', argument " "1"" of type '" "mfem::AM3Solver *""'"); + } + arg1 = reinterpret_cast< mfem::AM3Solver * >(argp1); + { + try { + delete arg1; } - if (_v) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_0(self, argc, argv); + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *AM3Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM3Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AM3Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AM4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AM4Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_AM4Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::AM4Solver *)new mfem::AM4Solver(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM4Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_AM4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AM4Solver *arg1 = (mfem::AM4Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM4Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM4Solver" "', argument " "1"" of type '" "mfem::AM4Solver *""'"); + } + arg1 = reinterpret_cast< mfem::AM4Solver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver(double)\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM4Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM4Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AM4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -5643,18 +5717,18 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } - arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { @@ -5677,9 +5751,9 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::Vector *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; @@ -5691,18 +5765,18 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( double dtemp4 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } - arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { @@ -5739,20 +5813,45 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_delete_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::BackwardEulerSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_BackwardEulerSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::BackwardEulerSolver *)new mfem::BackwardEulerSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeneralizedAlphaSolver" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BackwardEulerSolver" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } - arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); { try { delete arg1; @@ -5773,55 +5872,44 @@ SWIGINTERN PyObject *_wrap_delete_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *GeneralizedAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BackwardEulerSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *GeneralizedAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BackwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; - mfem::Operator *arg2 = 0 ; - mfem::TimeDependentOperator *arg3 = 0 ; + mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Init", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Init" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Init" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } - arg3 = reinterpret_cast< mfem::TimeDependentOperator * >(argp3); + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { try { - (arg1)->Init(*arg2,*arg3); + (arg1)->Init(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5839,56 +5927,45 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + double *arg3 = 0 ; double *arg4 = 0 ; - double *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - PyObject *swig_obj[5] ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Step" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Step" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; } { try { - (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + (arg1)->Step(*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5900,76 +5977,60 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } { resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ImplicitMidpointSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ImplicitMidpointSolver", 0, 0, 0)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + try { + result = (mfem::ImplicitMidpointSolver *)new mfem::ImplicitMidpointSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - double arg6 ; + mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - double val6 ; - int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Run", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Run" "', argument " "1"" of type '" "mfem::SIASolver *""'"); - } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; - } - { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImplicitMidpointSolver" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SIASolver_Run" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); { try { - (arg1)->Run(*arg2,*arg3,*arg4,*arg5,arg6); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5981,35 +6042,63 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ImplicitMidpointSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ImplicitMidpointSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::SDIRK23Solver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + try { + result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SIASolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::SDIRK23Solver *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIASolver" "', argument " "1"" of type '" "mfem::SIASolver *""'"); - } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - delete arg1; + result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6020,28 +6109,2631 @@ SWIGINTERN PyObject *_wrap_delete_SIASolver(PyObject *SWIGUNUSEDPARM(self), PyOb // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - return resultobj; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SDIRK23Solver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SDIRK23Solver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SDIRK23Solver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SDIRK23Solver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SDIRK23Solver::SDIRK23Solver(int)\n" + " mfem::SDIRK23Solver::SDIRK23Solver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK23Solver" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SDIRK23Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SDIRK23Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SDIRK34Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SDIRK34Solver *)new mfem::SDIRK34Solver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK34Solver" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SDIRK34Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SDIRK34Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SDIRK33Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SDIRK33Solver *)new mfem::SDIRK33Solver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK33Solver" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SDIRK33Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SDIRK33Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::GeneralizedAlphaSolver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + { + try { + result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlphaSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_GeneralizedAlphaSolver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_GeneralizedAlphaSolver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlphaSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver(double)\n" + " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeneralizedAlphaSolver" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GeneralizedAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GeneralizedAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::Operator *arg2 = 0 ; + mfem::TimeDependentOperator *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "SIASolver_Init", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Init" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg3 = reinterpret_cast< mfem::TimeDependentOperator * >(argp3); + { + try { + (arg1)->Init(*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIASolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Step" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + double val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + + if (!SWIG_Python_UnpackTuple(args, "SIASolver_Run", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Run" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SIASolver_Run" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + (arg1)->Run(*arg2,*arg3,*arg4,*arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIASolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIASolver" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIASolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIASolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA1Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SIA1Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SIA1Solver *)new mfem::SIA1Solver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIA1Solver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA1Solver_Step" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA1Solver" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIA1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA1Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SIA1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA2Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SIA2Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SIA2Solver *)new mfem::SIA2Solver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIA2Solver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA2Solver_Step" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA2Solver" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIA2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA2Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SIA2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + PyObject *swig_obj[1] ; + mfem::SIAVSolver *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::SIAVSolver *)new mfem::SIAVSolver(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIAVSolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIAVSolver_Step" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIAVSolver" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIAVSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIAVSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SIAVSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Init" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Step" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + double val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + + if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Run", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Run" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SecondOrderODESolver_Run" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + (arg1)->Run(*arg2,*arg3,*arg4,*arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SecondOrderODESolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondOrderODESolver" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SecondOrderODESolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SecondOrderODESolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::NewmarkSolver *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewmarkSolver" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::NewmarkSolver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + { + try { + result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_NewmarkSolver", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_NewmarkSolver__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_NewmarkSolver__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_NewmarkSolver__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NewmarkSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::NewmarkSolver::NewmarkSolver(double,double)\n" + " mfem::NewmarkSolver::NewmarkSolver(double)\n" + " mfem::NewmarkSolver::NewmarkSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + try { + (arg1)->PrintProperties(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + { + try { + (arg1)->PrintProperties(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "NewmarkSolver_PrintProperties", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NewmarkSolver_PrintProperties__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_NewmarkSolver_PrintProperties__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NewmarkSolver_PrintProperties'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::NewmarkSolver::PrintProperties(std::ostream &)\n" + " mfem::NewmarkSolver::PrintProperties()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Init" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Step" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewmarkSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_NewmarkSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewmarkSolver" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *NewmarkSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NewmarkSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NewmarkSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_LinearAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::LinearAccelerationSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_LinearAccelerationSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::LinearAccelerationSolver *)new mfem::LinearAccelerationSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LinearAccelerationSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_LinearAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::LinearAccelerationSolver *arg1 = (mfem::LinearAccelerationSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearAccelerationSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearAccelerationSolver" "', argument " "1"" of type '" "mfem::LinearAccelerationSolver *""'"); + } + arg1 = reinterpret_cast< mfem::LinearAccelerationSolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *LinearAccelerationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__LinearAccelerationSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *LinearAccelerationSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_CentralDifferenceSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CentralDifferenceSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_CentralDifferenceSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::CentralDifferenceSolver *)new mfem::CentralDifferenceSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CentralDifferenceSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CentralDifferenceSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CentralDifferenceSolver *arg1 = (mfem::CentralDifferenceSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CentralDifferenceSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CentralDifferenceSolver" "', argument " "1"" of type '" "mfem::CentralDifferenceSolver *""'"); + } + arg1 = reinterpret_cast< mfem::CentralDifferenceSolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CentralDifferenceSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CentralDifferenceSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CentralDifferenceSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_FoxGoodwinSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FoxGoodwinSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_FoxGoodwinSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::FoxGoodwinSolver *)new mfem::FoxGoodwinSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FoxGoodwinSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_FoxGoodwinSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FoxGoodwinSolver *arg1 = (mfem::FoxGoodwinSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FoxGoodwinSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FoxGoodwinSolver" "', argument " "1"" of type '" "mfem::FoxGoodwinSolver *""'"); + } + arg1 = reinterpret_cast< mfem::FoxGoodwinSolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *FoxGoodwinSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FoxGoodwinSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *FoxGoodwinSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::GeneralizedAlpha2Solver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + { + try { + result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::GeneralizedAlpha2Solver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlpha2Solver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_GeneralizedAlpha2Solver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_GeneralizedAlpha2Solver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlpha2Solver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver(double)\n" + " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + try { + (arg1)->PrintProperties(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); + { + try { + (arg1)->PrintProperties(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_PrintProperties", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(self, argc, argv); + } + } + } + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GeneralizedAlpha2Solver_PrintProperties'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GeneralizedAlpha2Solver::PrintProperties(std::ostream &)\n" + " mfem::GeneralizedAlpha2Solver::PrintProperties()\n"); + return 0; } -SWIGINTERN PyObject *SIASolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIASolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA1Solver *result = 0 ; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "new_SIA1Solver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); { try { - result = (mfem::SIA1Solver *)new mfem::SIA1Solver(); + (arg1)->Init(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6052,16 +8744,16 @@ SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObje // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; double *arg4 = 0 ; @@ -6076,26 +8768,26 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj double dtemp5 ; PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "SIA1Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA1Solver_Step" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } - arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { @@ -6132,20 +8824,20 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_delete_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_GeneralizedAlpha2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA1Solver" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } - arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); { try { delete arg1; @@ -6166,25 +8858,25 @@ SWIGINTERN PyObject *_wrap_delete_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *SIA1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GeneralizedAlpha2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA1Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SIA1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GeneralizedAlpha2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AverageAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA2Solver *result = 0 ; + mfem::AverageAccelerationSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_SIA2Solver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AverageAccelerationSolver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::SIA2Solver *)new mfem::SIA2Solver(); + result = (mfem::AverageAccelerationSolver *)new mfem::AverageAccelerationSolver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6195,63 +8887,30 @@ SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObje // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AverageAccelerationSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AverageAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; + mfem::AverageAccelerationSolver *arg1 = (mfem::AverageAccelerationSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SIA2Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AverageAccelerationSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA2Solver_Step" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; - } - { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AverageAccelerationSolver" "', argument " "1"" of type '" "mfem::AverageAccelerationSolver *""'"); } + arg1 = reinterpret_cast< mfem::AverageAccelerationSolver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6263,32 +8922,126 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *AverageAccelerationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AverageAccelerationSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AverageAccelerationSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::HHTAlphaSolver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HHTAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + try { + result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::HHTAlphaSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + try { + result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HHTAlphaSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_HHTAlphaSolver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_HHTAlphaSolver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HHTAlphaSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HHTAlphaSolver::HHTAlphaSolver(double)\n" + " mfem::HHTAlphaSolver::HHTAlphaSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_HHTAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; + mfem::HHTAlphaSolver *arg1 = (mfem::HHTAlphaSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA2Solver" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HHTAlphaSolver" "', argument " "1"" of type '" "mfem::HHTAlphaSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); + arg1 = reinterpret_cast< mfem::HHTAlphaSolver * >(argp1); { try { delete arg1; @@ -6309,34 +9062,33 @@ SWIGINTERN PyObject *_wrap_delete_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *SIA2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *HHTAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA2Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SIA2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *HHTAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - PyObject *swig_obj[1] ; - mfem::SIAVSolver *result = 0 ; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::WBZAlphaSolver *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WBZAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); { try { - result = (mfem::SIAVSolver *)new mfem::SIAVSolver(arg1); + result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6347,63 +9099,21 @@ SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObje // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - PyObject *swig_obj[5] ; + mfem::WBZAlphaSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SIAVSolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIAVSolver_Step" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); - } - arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; - } - { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; - } + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6414,33 +9124,58 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); - } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_WBZAlphaSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_WBZAlphaSolver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_WBZAlphaSolver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WBZAlphaSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::WBZAlphaSolver::WBZAlphaSolver(double)\n" + " mfem::WBZAlphaSolver::WBZAlphaSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_WBZAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; + mfem::WBZAlphaSolver *arg1 = (mfem::WBZAlphaSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIAVSolver" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WBZAlphaSolver" "', argument " "1"" of type '" "mfem::WBZAlphaSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); + arg1 = reinterpret_cast< mfem::WBZAlphaSolver * >(argp1); { try { delete arg1; @@ -6461,19 +9196,20 @@ SWIGINTERN PyObject *_wrap_delete_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *SIAVSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *WBZAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIAVSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SIAVSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *WBZAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "ODESolver_Init(ODESolver self, TimeDependentOperator f)"}, { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "ODESolver_Step(ODESolver self, Vector x, double & t, double & dt)"}, { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "ODESolver_Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, @@ -6517,6 +9253,58 @@ static PyMethodDef SwigMethods[] = { { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "AdamsBashforthSolver_Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "AdamsBashforthSolver_Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, + { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, + { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, + { "new_AB1Solver", _wrap_new_AB1Solver, METH_NOARGS, "new_AB1Solver() -> AB1Solver"}, + { "delete_AB1Solver", _wrap_delete_AB1Solver, METH_O, "delete_AB1Solver(AB1Solver self)"}, + { "AB1Solver_swigregister", AB1Solver_swigregister, METH_O, NULL}, + { "AB1Solver_swiginit", AB1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB2Solver", _wrap_new_AB2Solver, METH_NOARGS, "new_AB2Solver() -> AB2Solver"}, + { "delete_AB2Solver", _wrap_delete_AB2Solver, METH_O, "delete_AB2Solver(AB2Solver self)"}, + { "AB2Solver_swigregister", AB2Solver_swigregister, METH_O, NULL}, + { "AB2Solver_swiginit", AB2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB3Solver", _wrap_new_AB3Solver, METH_NOARGS, "new_AB3Solver() -> AB3Solver"}, + { "delete_AB3Solver", _wrap_delete_AB3Solver, METH_O, "delete_AB3Solver(AB3Solver self)"}, + { "AB3Solver_swigregister", AB3Solver_swigregister, METH_O, NULL}, + { "AB3Solver_swiginit", AB3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB4Solver", _wrap_new_AB4Solver, METH_NOARGS, "new_AB4Solver() -> AB4Solver"}, + { "delete_AB4Solver", _wrap_delete_AB4Solver, METH_O, "delete_AB4Solver(AB4Solver self)"}, + { "AB4Solver_swigregister", AB4Solver_swigregister, METH_O, NULL}, + { "AB4Solver_swiginit", AB4Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB5Solver", _wrap_new_AB5Solver, METH_NOARGS, "new_AB5Solver() -> AB5Solver"}, + { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, + { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, + { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "AdamsMoultonSolver_Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "AdamsMoultonSolver_Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, + { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, + { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, + { "new_AM0Solver", _wrap_new_AM0Solver, METH_NOARGS, "new_AM0Solver() -> AM0Solver"}, + { "delete_AM0Solver", _wrap_delete_AM0Solver, METH_O, "delete_AM0Solver(AM0Solver self)"}, + { "AM0Solver_swigregister", AM0Solver_swigregister, METH_O, NULL}, + { "AM0Solver_swiginit", AM0Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM1Solver", _wrap_new_AM1Solver, METH_NOARGS, "new_AM1Solver() -> AM1Solver"}, + { "delete_AM1Solver", _wrap_delete_AM1Solver, METH_O, "delete_AM1Solver(AM1Solver self)"}, + { "AM1Solver_swigregister", AM1Solver_swigregister, METH_O, NULL}, + { "AM1Solver_swiginit", AM1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM2Solver", _wrap_new_AM2Solver, METH_NOARGS, "new_AM2Solver() -> AM2Solver"}, + { "delete_AM2Solver", _wrap_delete_AM2Solver, METH_O, "delete_AM2Solver(AM2Solver self)"}, + { "AM2Solver_swigregister", AM2Solver_swigregister, METH_O, NULL}, + { "AM2Solver_swiginit", AM2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM3Solver", _wrap_new_AM3Solver, METH_NOARGS, "new_AM3Solver() -> AM3Solver"}, + { "delete_AM3Solver", _wrap_delete_AM3Solver, METH_O, "delete_AM3Solver(AM3Solver self)"}, + { "AM3Solver_swigregister", AM3Solver_swigregister, METH_O, NULL}, + { "AM3Solver_swiginit", AM3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM4Solver", _wrap_new_AM4Solver, METH_NOARGS, "new_AM4Solver() -> AM4Solver"}, + { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, + { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, + { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "BackwardEulerSolver_Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "BackwardEulerSolver_Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, @@ -6573,61 +9361,357 @@ static PyMethodDef SwigMethods[] = { { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, + { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "SecondOrderODESolver_Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "SecondOrderODESolver_Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "SecondOrderODESolver_Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, + { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, + { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, + { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "NewmarkSolver_PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "NewmarkSolver_Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "NewmarkSolver_Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, + { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, + { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, + { "new_LinearAccelerationSolver", _wrap_new_LinearAccelerationSolver, METH_NOARGS, "new_LinearAccelerationSolver() -> LinearAccelerationSolver"}, + { "delete_LinearAccelerationSolver", _wrap_delete_LinearAccelerationSolver, METH_O, "delete_LinearAccelerationSolver(LinearAccelerationSolver self)"}, + { "LinearAccelerationSolver_swigregister", LinearAccelerationSolver_swigregister, METH_O, NULL}, + { "LinearAccelerationSolver_swiginit", LinearAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_CentralDifferenceSolver", _wrap_new_CentralDifferenceSolver, METH_NOARGS, "new_CentralDifferenceSolver() -> CentralDifferenceSolver"}, + { "delete_CentralDifferenceSolver", _wrap_delete_CentralDifferenceSolver, METH_O, "delete_CentralDifferenceSolver(CentralDifferenceSolver self)"}, + { "CentralDifferenceSolver_swigregister", CentralDifferenceSolver_swigregister, METH_O, NULL}, + { "CentralDifferenceSolver_swiginit", CentralDifferenceSolver_swiginit, METH_VARARGS, NULL}, + { "new_FoxGoodwinSolver", _wrap_new_FoxGoodwinSolver, METH_NOARGS, "new_FoxGoodwinSolver() -> FoxGoodwinSolver"}, + { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, + { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, + { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, + { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, + { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "GeneralizedAlpha2Solver_PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "GeneralizedAlpha2Solver_Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "GeneralizedAlpha2Solver_Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, + { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, + { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AverageAccelerationSolver", _wrap_new_AverageAccelerationSolver, METH_NOARGS, "new_AverageAccelerationSolver() -> AverageAccelerationSolver"}, + { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, + { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, + { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, + { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, + { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, + { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, + { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, + { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "Init(ODESolver self, TimeDependentOperator f)"}, + { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "Step(ODESolver self, Vector x, double & t, double & dt)"}, + { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, + { "delete_ODESolver", _wrap_delete_ODESolver, METH_O, "delete_ODESolver(ODESolver self)"}, + { "ODESolver_swigregister", ODESolver_swigregister, METH_O, NULL}, + { "ForwardEulerSolver_Init", _wrap_ForwardEulerSolver_Init, METH_VARARGS, "Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, + { "ForwardEulerSolver_Step", _wrap_ForwardEulerSolver_Step, METH_VARARGS, "Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "new_ForwardEulerSolver", _wrap_new_ForwardEulerSolver, METH_NOARGS, "new_ForwardEulerSolver() -> ForwardEulerSolver"}, + { "delete_ForwardEulerSolver", _wrap_delete_ForwardEulerSolver, METH_O, "delete_ForwardEulerSolver(ForwardEulerSolver self)"}, + { "ForwardEulerSolver_swigregister", ForwardEulerSolver_swigregister, METH_O, NULL}, + { "ForwardEulerSolver_swiginit", ForwardEulerSolver_swiginit, METH_VARARGS, NULL}, + { "new_RK2Solver", _wrap_new_RK2Solver, METH_VARARGS, "RK2Solver(double const _a=2./3.)"}, + { "RK2Solver_Init", _wrap_RK2Solver_Init, METH_VARARGS, "Init(RK2Solver self, TimeDependentOperator _f)"}, + { "RK2Solver_Step", _wrap_RK2Solver_Step, METH_VARARGS, "Step(RK2Solver self, Vector x, double & t, double & dt)"}, + { "delete_RK2Solver", _wrap_delete_RK2Solver, METH_O, "delete_RK2Solver(RK2Solver self)"}, + { "RK2Solver_swigregister", RK2Solver_swigregister, METH_O, NULL}, + { "RK2Solver_swiginit", RK2Solver_swiginit, METH_VARARGS, NULL}, + { "RK3SSPSolver_Init", _wrap_RK3SSPSolver_Init, METH_VARARGS, "Init(RK3SSPSolver self, TimeDependentOperator _f)"}, + { "RK3SSPSolver_Step", _wrap_RK3SSPSolver_Step, METH_VARARGS, "Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, + { "new_RK3SSPSolver", _wrap_new_RK3SSPSolver, METH_NOARGS, "new_RK3SSPSolver() -> RK3SSPSolver"}, + { "delete_RK3SSPSolver", _wrap_delete_RK3SSPSolver, METH_O, "delete_RK3SSPSolver(RK3SSPSolver self)"}, + { "RK3SSPSolver_swigregister", RK3SSPSolver_swigregister, METH_O, NULL}, + { "RK3SSPSolver_swiginit", RK3SSPSolver_swiginit, METH_VARARGS, NULL}, + { "RK4Solver_Init", _wrap_RK4Solver_Init, METH_VARARGS, "Init(RK4Solver self, TimeDependentOperator _f)"}, + { "RK4Solver_Step", _wrap_RK4Solver_Step, METH_VARARGS, "Step(RK4Solver self, Vector x, double & t, double & dt)"}, + { "new_RK4Solver", _wrap_new_RK4Solver, METH_NOARGS, "new_RK4Solver() -> RK4Solver"}, + { "delete_RK4Solver", _wrap_delete_RK4Solver, METH_O, "delete_RK4Solver(RK4Solver self)"}, + { "RK4Solver_swigregister", RK4Solver_swigregister, METH_O, NULL}, + { "RK4Solver_swiginit", RK4Solver_swiginit, METH_VARARGS, NULL}, + { "new_ExplicitRKSolver", _wrap_new_ExplicitRKSolver, METH_VARARGS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, + { "ExplicitRKSolver_Init", _wrap_ExplicitRKSolver_Init, METH_VARARGS, "Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, + { "ExplicitRKSolver_Step", _wrap_ExplicitRKSolver_Step, METH_VARARGS, "Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, + { "delete_ExplicitRKSolver", _wrap_delete_ExplicitRKSolver, METH_O, "delete_ExplicitRKSolver(ExplicitRKSolver self)"}, + { "ExplicitRKSolver_swigregister", ExplicitRKSolver_swigregister, METH_O, NULL}, + { "ExplicitRKSolver_swiginit", ExplicitRKSolver_swiginit, METH_VARARGS, NULL}, + { "new_RK6Solver", _wrap_new_RK6Solver, METH_NOARGS, "new_RK6Solver() -> RK6Solver"}, + { "delete_RK6Solver", _wrap_delete_RK6Solver, METH_O, "delete_RK6Solver(RK6Solver self)"}, + { "RK6Solver_swigregister", RK6Solver_swigregister, METH_O, NULL}, + { "RK6Solver_swiginit", RK6Solver_swiginit, METH_VARARGS, NULL}, + { "new_RK8Solver", _wrap_new_RK8Solver, METH_NOARGS, "new_RK8Solver() -> RK8Solver"}, + { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, + { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, + { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, + { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, + { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, + { "new_AB1Solver", _wrap_new_AB1Solver, METH_NOARGS, "new_AB1Solver() -> AB1Solver"}, + { "delete_AB1Solver", _wrap_delete_AB1Solver, METH_O, "delete_AB1Solver(AB1Solver self)"}, + { "AB1Solver_swigregister", AB1Solver_swigregister, METH_O, NULL}, + { "AB1Solver_swiginit", AB1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB2Solver", _wrap_new_AB2Solver, METH_NOARGS, "new_AB2Solver() -> AB2Solver"}, + { "delete_AB2Solver", _wrap_delete_AB2Solver, METH_O, "delete_AB2Solver(AB2Solver self)"}, + { "AB2Solver_swigregister", AB2Solver_swigregister, METH_O, NULL}, + { "AB2Solver_swiginit", AB2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB3Solver", _wrap_new_AB3Solver, METH_NOARGS, "new_AB3Solver() -> AB3Solver"}, + { "delete_AB3Solver", _wrap_delete_AB3Solver, METH_O, "delete_AB3Solver(AB3Solver self)"}, + { "AB3Solver_swigregister", AB3Solver_swigregister, METH_O, NULL}, + { "AB3Solver_swiginit", AB3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB4Solver", _wrap_new_AB4Solver, METH_NOARGS, "new_AB4Solver() -> AB4Solver"}, + { "delete_AB4Solver", _wrap_delete_AB4Solver, METH_O, "delete_AB4Solver(AB4Solver self)"}, + { "AB4Solver_swigregister", AB4Solver_swigregister, METH_O, NULL}, + { "AB4Solver_swiginit", AB4Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB5Solver", _wrap_new_AB5Solver, METH_NOARGS, "new_AB5Solver() -> AB5Solver"}, + { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, + { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, + { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, + { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, + { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, + { "new_AM0Solver", _wrap_new_AM0Solver, METH_NOARGS, "new_AM0Solver() -> AM0Solver"}, + { "delete_AM0Solver", _wrap_delete_AM0Solver, METH_O, "delete_AM0Solver(AM0Solver self)"}, + { "AM0Solver_swigregister", AM0Solver_swigregister, METH_O, NULL}, + { "AM0Solver_swiginit", AM0Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM1Solver", _wrap_new_AM1Solver, METH_NOARGS, "new_AM1Solver() -> AM1Solver"}, + { "delete_AM1Solver", _wrap_delete_AM1Solver, METH_O, "delete_AM1Solver(AM1Solver self)"}, + { "AM1Solver_swigregister", AM1Solver_swigregister, METH_O, NULL}, + { "AM1Solver_swiginit", AM1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM2Solver", _wrap_new_AM2Solver, METH_NOARGS, "new_AM2Solver() -> AM2Solver"}, + { "delete_AM2Solver", _wrap_delete_AM2Solver, METH_O, "delete_AM2Solver(AM2Solver self)"}, + { "AM2Solver_swigregister", AM2Solver_swigregister, METH_O, NULL}, + { "AM2Solver_swiginit", AM2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM3Solver", _wrap_new_AM3Solver, METH_NOARGS, "new_AM3Solver() -> AM3Solver"}, + { "delete_AM3Solver", _wrap_delete_AM3Solver, METH_O, "delete_AM3Solver(AM3Solver self)"}, + { "AM3Solver_swigregister", AM3Solver_swigregister, METH_O, NULL}, + { "AM3Solver_swiginit", AM3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM4Solver", _wrap_new_AM4Solver, METH_NOARGS, "new_AM4Solver() -> AM4Solver"}, + { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, + { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, + { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, + { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, + { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, + { "delete_BackwardEulerSolver", _wrap_delete_BackwardEulerSolver, METH_O, "delete_BackwardEulerSolver(BackwardEulerSolver self)"}, + { "BackwardEulerSolver_swigregister", BackwardEulerSolver_swigregister, METH_O, NULL}, + { "BackwardEulerSolver_swiginit", BackwardEulerSolver_swiginit, METH_VARARGS, NULL}, + { "ImplicitMidpointSolver_Init", _wrap_ImplicitMidpointSolver_Init, METH_VARARGS, "Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, + { "ImplicitMidpointSolver_Step", _wrap_ImplicitMidpointSolver_Step, METH_VARARGS, "Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, + { "new_ImplicitMidpointSolver", _wrap_new_ImplicitMidpointSolver, METH_NOARGS, "new_ImplicitMidpointSolver() -> ImplicitMidpointSolver"}, + { "delete_ImplicitMidpointSolver", _wrap_delete_ImplicitMidpointSolver, METH_O, "delete_ImplicitMidpointSolver(ImplicitMidpointSolver self)"}, + { "ImplicitMidpointSolver_swigregister", ImplicitMidpointSolver_swigregister, METH_O, NULL}, + { "ImplicitMidpointSolver_swiginit", ImplicitMidpointSolver_swiginit, METH_VARARGS, NULL}, + { "new_SDIRK23Solver", _wrap_new_SDIRK23Solver, METH_VARARGS, "SDIRK23Solver(int gamma_opt=1)"}, + { "SDIRK23Solver_Init", _wrap_SDIRK23Solver_Init, METH_VARARGS, "Init(SDIRK23Solver self, TimeDependentOperator _f)"}, + { "SDIRK23Solver_Step", _wrap_SDIRK23Solver_Step, METH_VARARGS, "Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, + { "delete_SDIRK23Solver", _wrap_delete_SDIRK23Solver, METH_O, "delete_SDIRK23Solver(SDIRK23Solver self)"}, + { "SDIRK23Solver_swigregister", SDIRK23Solver_swigregister, METH_O, NULL}, + { "SDIRK23Solver_swiginit", SDIRK23Solver_swiginit, METH_VARARGS, NULL}, + { "SDIRK34Solver_Init", _wrap_SDIRK34Solver_Init, METH_VARARGS, "Init(SDIRK34Solver self, TimeDependentOperator _f)"}, + { "SDIRK34Solver_Step", _wrap_SDIRK34Solver_Step, METH_VARARGS, "Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK34Solver", _wrap_new_SDIRK34Solver, METH_NOARGS, "new_SDIRK34Solver() -> SDIRK34Solver"}, + { "delete_SDIRK34Solver", _wrap_delete_SDIRK34Solver, METH_O, "delete_SDIRK34Solver(SDIRK34Solver self)"}, + { "SDIRK34Solver_swigregister", SDIRK34Solver_swigregister, METH_O, NULL}, + { "SDIRK34Solver_swiginit", SDIRK34Solver_swiginit, METH_VARARGS, NULL}, + { "SDIRK33Solver_Init", _wrap_SDIRK33Solver_Init, METH_VARARGS, "Init(SDIRK33Solver self, TimeDependentOperator _f)"}, + { "SDIRK33Solver_Step", _wrap_SDIRK33Solver_Step, METH_VARARGS, "Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK33Solver", _wrap_new_SDIRK33Solver, METH_NOARGS, "new_SDIRK33Solver() -> SDIRK33Solver"}, + { "delete_SDIRK33Solver", _wrap_delete_SDIRK33Solver, METH_O, "delete_SDIRK33Solver(SDIRK33Solver self)"}, + { "SDIRK33Solver_swigregister", SDIRK33Solver_swigregister, METH_O, NULL}, + { "SDIRK33Solver_swiginit", SDIRK33Solver_swiginit, METH_VARARGS, NULL}, + { "new_GeneralizedAlphaSolver", _wrap_new_GeneralizedAlphaSolver, METH_VARARGS, "GeneralizedAlphaSolver(double rho=1.0)"}, + { "GeneralizedAlphaSolver_Init", _wrap_GeneralizedAlphaSolver_Init, METH_VARARGS, "Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, + { "GeneralizedAlphaSolver_Step", _wrap_GeneralizedAlphaSolver_Step, METH_VARARGS, "Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, + { "delete_GeneralizedAlphaSolver", _wrap_delete_GeneralizedAlphaSolver, METH_O, "delete_GeneralizedAlphaSolver(GeneralizedAlphaSolver self)"}, + { "GeneralizedAlphaSolver_swigregister", GeneralizedAlphaSolver_swigregister, METH_O, NULL}, + { "GeneralizedAlphaSolver_swiginit", GeneralizedAlphaSolver_swiginit, METH_VARARGS, NULL}, + { "SIASolver_Init", _wrap_SIASolver_Init, METH_VARARGS, "Init(SIASolver self, Operator P, TimeDependentOperator F)"}, + { "SIASolver_Step", _wrap_SIASolver_Step, METH_VARARGS, "Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIASolver_Run", _wrap_SIASolver_Run, METH_VARARGS, "Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, + { "delete_SIASolver", _wrap_delete_SIASolver, METH_O, "delete_SIASolver(SIASolver self)"}, + { "SIASolver_swigregister", SIASolver_swigregister, METH_O, NULL}, + { "new_SIA1Solver", _wrap_new_SIA1Solver, METH_NOARGS, "new_SIA1Solver() -> SIA1Solver"}, + { "SIA1Solver_Step", _wrap_SIA1Solver_Step, METH_VARARGS, "Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "delete_SIA1Solver", _wrap_delete_SIA1Solver, METH_O, "delete_SIA1Solver(SIA1Solver self)"}, + { "SIA1Solver_swigregister", SIA1Solver_swigregister, METH_O, NULL}, + { "SIA1Solver_swiginit", SIA1Solver_swiginit, METH_VARARGS, NULL}, + { "new_SIA2Solver", _wrap_new_SIA2Solver, METH_NOARGS, "new_SIA2Solver() -> SIA2Solver"}, + { "SIA2Solver_Step", _wrap_SIA2Solver_Step, METH_VARARGS, "Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "delete_SIA2Solver", _wrap_delete_SIA2Solver, METH_O, "delete_SIA2Solver(SIA2Solver self)"}, + { "SIA2Solver_swigregister", SIA2Solver_swigregister, METH_O, NULL}, + { "SIA2Solver_swiginit", SIA2Solver_swiginit, METH_VARARGS, NULL}, + { "new_SIAVSolver", _wrap_new_SIAVSolver, METH_O, "new_SIAVSolver(int order) -> SIAVSolver"}, + { "SIAVSolver_Step", _wrap_SIAVSolver_Step, METH_VARARGS, "Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, + { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, + { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, + { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, + { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, + { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, + { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, + { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, + { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, + { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, + { "new_LinearAccelerationSolver", _wrap_new_LinearAccelerationSolver, METH_NOARGS, "new_LinearAccelerationSolver() -> LinearAccelerationSolver"}, + { "delete_LinearAccelerationSolver", _wrap_delete_LinearAccelerationSolver, METH_O, "delete_LinearAccelerationSolver(LinearAccelerationSolver self)"}, + { "LinearAccelerationSolver_swigregister", LinearAccelerationSolver_swigregister, METH_O, NULL}, + { "LinearAccelerationSolver_swiginit", LinearAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_CentralDifferenceSolver", _wrap_new_CentralDifferenceSolver, METH_NOARGS, "new_CentralDifferenceSolver() -> CentralDifferenceSolver"}, + { "delete_CentralDifferenceSolver", _wrap_delete_CentralDifferenceSolver, METH_O, "delete_CentralDifferenceSolver(CentralDifferenceSolver self)"}, + { "CentralDifferenceSolver_swigregister", CentralDifferenceSolver_swigregister, METH_O, NULL}, + { "CentralDifferenceSolver_swiginit", CentralDifferenceSolver_swiginit, METH_VARARGS, NULL}, + { "new_FoxGoodwinSolver", _wrap_new_FoxGoodwinSolver, METH_NOARGS, "new_FoxGoodwinSolver() -> FoxGoodwinSolver"}, + { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, + { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, + { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, + { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, + { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, + { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, + { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AverageAccelerationSolver", _wrap_new_AverageAccelerationSolver, METH_NOARGS, "new_AverageAccelerationSolver() -> AverageAccelerationSolver"}, + { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, + { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, + { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, + { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, + { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, + { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, + { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, + { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__SIA2SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::SIASolver *) ((mfem::SIA2Solver *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__SIAVSolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::SIASolver *) ((mfem::SIAVSolver *) x)); +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } -static void *_p_mfem__SIA1SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::SIASolver *) ((mfem::SIA1Solver *) x)); +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__RK6SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } -static void *_p_mfem__RK8SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::ForwardEulerSolver *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__RK2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::RK2Solver *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__RK3SSPSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::RK3SSPSolver *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__RK4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::RK4Solver *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__RK6SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__RK8SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); } -static void *_p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::BackwardEulerSolver *) x)); +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } -static void *_p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::ImplicitMidpointSolver *) x)); +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); } -static void *_p_mfem__SDIRK34SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::SDIRK34Solver *) x)); +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__AB2SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB2Solver *) x)); +} +static void *_p_mfem__AB4SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB4Solver *) x)); +} +static void *_p_mfem__AB1SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB1Solver *) x)); +} +static void *_p_mfem__AB3SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB3Solver *) x)); +} +static void *_p_mfem__AB5SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB5Solver *) x)); +} +static void *_p_mfem__AM0SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM0Solver *) x)); +} +static void *_p_mfem__AM2SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM2Solver *) x)); +} +static void *_p_mfem__AM4SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM4Solver *) x)); +} +static void *_p_mfem__AM1SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM1Solver *) x)); +} +static void *_p_mfem__AM3SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM3Solver *) x)); +} +static void *_p_mfem__AverageAccelerationSolverTo_p_mfem__GeneralizedAlpha2Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GeneralizedAlpha2Solver *) ((mfem::AverageAccelerationSolver *) x)); +} +static void *_p_mfem__HHTAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GeneralizedAlpha2Solver *) ((mfem::HHTAlphaSolver *) x)); +} +static void *_p_mfem__WBZAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GeneralizedAlpha2Solver *) ((mfem::WBZAlphaSolver *) x)); +} +static void *_p_mfem__AB5SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB5Solver *) x)); +} +static void *_p_mfem__AB3SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB3Solver *) x)); +} +static void *_p_mfem__AB1SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB1Solver *) x)); } static void *_p_mfem__ExplicitRKSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ODESolver *) ((mfem::ExplicitRKSolver *) x)); } +static void *_p_mfem__AM1SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM1Solver *) x)); +} +static void *_p_mfem__AM3SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM3Solver *) x)); +} static void *_p_mfem__SDIRK23SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ODESolver *) ((mfem::SDIRK23Solver *) x)); } @@ -6637,58 +9721,142 @@ static void *_p_mfem__SDIRK33SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSED static void *_p_mfem__GeneralizedAlphaSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ODESolver *) ((mfem::GeneralizedAlphaSolver *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__AdamsMoultonSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::AdamsMoultonSolver *) x)); } -static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +static void *_p_mfem__AB4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB4Solver *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__AB2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB2Solver *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__AdamsBashforthSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::AdamsBashforthSolver *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__RK8SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__RK6SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__RK4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::RK4Solver *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__RK3SSPSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::RK3SSPSolver *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__RK2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::RK2Solver *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::ForwardEulerSolver *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__AM0SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM0Solver *) x)); +} +static void *_p_mfem__AM2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM2Solver *) x)); +} +static void *_p_mfem__AM4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM4Solver *) x)); +} +static void *_p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::BackwardEulerSolver *) x)); +} +static void *_p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::ImplicitMidpointSolver *) x)); +} +static void *_p_mfem__SDIRK34SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::SDIRK34Solver *) x)); +} +static void *_p_mfem__RK6SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); +} +static void *_p_mfem__RK8SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); +} +static void *_p_mfem__SIA2SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SIASolver *) ((mfem::SIA2Solver *) x)); +} +static void *_p_mfem__SIAVSolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SIASolver *) ((mfem::SIAVSolver *) x)); +} +static void *_p_mfem__SIA1SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SIASolver *) ((mfem::SIA1Solver *) x)); +} +static void *_p_mfem__LinearAccelerationSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::NewmarkSolver *) ((mfem::LinearAccelerationSolver *) x)); +} +static void *_p_mfem__FoxGoodwinSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::NewmarkSolver *) ((mfem::FoxGoodwinSolver *) x)); +} +static void *_p_mfem__GeneralizedAlpha2SolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) ((mfem::GeneralizedAlpha2Solver *) x)); +} +static void *_p_mfem__AverageAccelerationSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::GeneralizedAlpha2Solver *) ((mfem::AverageAccelerationSolver *) x)); +} +static void *_p_mfem__NewmarkSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) ((mfem::NewmarkSolver *) x)); +} +static void *_p_mfem__CentralDifferenceSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::NewmarkSolver *) ((mfem::CentralDifferenceSolver *) x)); +} +static void *_p_mfem__HHTAlphaSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::GeneralizedAlpha2Solver *) ((mfem::HHTAlphaSolver *) x)); +} +static void *_p_mfem__WBZAlphaSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::GeneralizedAlpha2Solver *) ((mfem::WBZAlphaSolver *) x)); +} +static void *_p_mfem__LinearAccelerationSolverTo_p_mfem__NewmarkSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NewmarkSolver *) ((mfem::LinearAccelerationSolver *) x)); +} +static void *_p_mfem__FoxGoodwinSolverTo_p_mfem__NewmarkSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NewmarkSolver *) ((mfem::FoxGoodwinSolver *) x)); +} +static void *_p_mfem__CentralDifferenceSolverTo_p_mfem__NewmarkSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NewmarkSolver *) ((mfem::CentralDifferenceSolver *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB1Solver = {"_p_mfem__AB1Solver", "mfem::AB1Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB2Solver = {"_p_mfem__AB2Solver", "mfem::AB2Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB3Solver = {"_p_mfem__AB3Solver", "mfem::AB3Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB4Solver = {"_p_mfem__AB4Solver", "mfem::AB4Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB5Solver = {"_p_mfem__AB5Solver", "mfem::AB5Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM0Solver = {"_p_mfem__AM0Solver", "mfem::AM0Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM1Solver = {"_p_mfem__AM1Solver", "mfem::AM1Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM2Solver = {"_p_mfem__AM2Solver", "mfem::AM2Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM3Solver = {"_p_mfem__AM3Solver", "mfem::AM3Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM4Solver = {"_p_mfem__AM4Solver", "mfem::AM4Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AdamsBashforthSolver = {"_p_mfem__AdamsBashforthSolver", "mfem::AdamsBashforthSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AdamsMoultonSolver = {"_p_mfem__AdamsMoultonSolver", "mfem::AdamsMoultonSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AverageAccelerationSolver = {"_p_mfem__AverageAccelerationSolver", "mfem::AverageAccelerationSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BackwardEulerSolver = {"_p_mfem__BackwardEulerSolver", "mfem::BackwardEulerSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__CentralDifferenceSolver = {"_p_mfem__CentralDifferenceSolver", "mfem::CentralDifferenceSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ExplicitRKSolver = {"_p_mfem__ExplicitRKSolver", "mfem::ExplicitRKSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ForwardEulerSolver = {"_p_mfem__ForwardEulerSolver", "mfem::ForwardEulerSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FoxGoodwinSolver = {"_p_mfem__FoxGoodwinSolver", "mfem::FoxGoodwinSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__GeneralizedAlpha2Solver = {"_p_mfem__GeneralizedAlpha2Solver", "mfem::GeneralizedAlpha2Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GeneralizedAlphaSolver = {"_p_mfem__GeneralizedAlphaSolver", "mfem::GeneralizedAlphaSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__HHTAlphaSolver = {"_p_mfem__HHTAlphaSolver", "mfem::HHTAlphaSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ImplicitMidpointSolver = {"_p_mfem__ImplicitMidpointSolver", "mfem::ImplicitMidpointSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__LinearAccelerationSolver = {"_p_mfem__LinearAccelerationSolver", "mfem::LinearAccelerationSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__NewmarkSolver = {"_p_mfem__NewmarkSolver", "mfem::NewmarkSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ODESolver = {"_p_mfem__ODESolver", "mfem::ODESolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RK2Solver = {"_p_mfem__RK2Solver", "mfem::RK2Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__RK3SSPSolver = {"_p_mfem__RK3SSPSolver", "mfem::RK3SSPSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__RK4Solver = {"_p_mfem__RK4Solver", "mfem::RK4Solver *", 0, 0, (void*)0, 0}; @@ -6701,20 +9869,42 @@ static swig_type_info _swigt__p_mfem__SIA1Solver = {"_p_mfem__SIA1Solver", "mfem static swig_type_info _swigt__p_mfem__SIA2Solver = {"_p_mfem__SIA2Solver", "mfem::SIA2Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SIASolver = {"_p_mfem__SIASolver", "mfem::SIASolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SIAVSolver = {"_p_mfem__SIAVSolver", "mfem::SIAVSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderODESolver = {"_p_mfem__SecondOrderODESolver", "mfem::SecondOrderODESolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", "mfem::SecondOrderTimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", "mfem::TimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__WBZAlphaSolver = {"_p_mfem__WBZAlphaSolver", "mfem::WBZAlphaSolver *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, &_swigt__p_char, &_swigt__p_double, + &_swigt__p_mfem__AB1Solver, + &_swigt__p_mfem__AB2Solver, + &_swigt__p_mfem__AB3Solver, + &_swigt__p_mfem__AB4Solver, + &_swigt__p_mfem__AB5Solver, + &_swigt__p_mfem__AM0Solver, + &_swigt__p_mfem__AM1Solver, + &_swigt__p_mfem__AM2Solver, + &_swigt__p_mfem__AM3Solver, + &_swigt__p_mfem__AM4Solver, + &_swigt__p_mfem__AdamsBashforthSolver, + &_swigt__p_mfem__AdamsMoultonSolver, + &_swigt__p_mfem__AverageAccelerationSolver, &_swigt__p_mfem__BackwardEulerSolver, + &_swigt__p_mfem__CentralDifferenceSolver, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__ExplicitRKSolver, &_swigt__p_mfem__ForwardEulerSolver, + &_swigt__p_mfem__FoxGoodwinSolver, + &_swigt__p_mfem__GeneralizedAlpha2Solver, &_swigt__p_mfem__GeneralizedAlphaSolver, + &_swigt__p_mfem__HHTAlphaSolver, &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__ImplicitMidpointSolver, + &_swigt__p_mfem__LinearAccelerationSolver, + &_swigt__p_mfem__NewmarkSolver, &_swigt__p_mfem__ODESolver, &_swigt__p_mfem__Operator, &_swigt__p_mfem__ProductOperator, @@ -6726,6 +9916,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__RK4Solver, &_swigt__p_mfem__RK6Solver, &_swigt__p_mfem__RK8Solver, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__SDIRK23Solver, &_swigt__p_mfem__SDIRK33Solver, &_swigt__p_mfem__SDIRK34Solver, @@ -6733,32 +9924,57 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__SIA2Solver, &_swigt__p_mfem__SIASolver, &_swigt__p_mfem__SIAVSolver, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderODESolver, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, &_swigt__p_mfem__TripleProductOperator, &_swigt__p_mfem__Vector, + &_swigt__p_mfem__WBZAlphaSolver, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB1Solver[] = { {&_swigt__p_mfem__AB1Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB2Solver[] = { {&_swigt__p_mfem__AB2Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB3Solver[] = { {&_swigt__p_mfem__AB3Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB4Solver[] = { {&_swigt__p_mfem__AB4Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB5Solver[] = { {&_swigt__p_mfem__AB5Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM0Solver[] = { {&_swigt__p_mfem__AM0Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM1Solver[] = { {&_swigt__p_mfem__AM1Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM2Solver[] = { {&_swigt__p_mfem__AM2Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM3Solver[] = { {&_swigt__p_mfem__AM3Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM4Solver[] = { {&_swigt__p_mfem__AM4Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AdamsBashforthSolver[] = { {&_swigt__p_mfem__AdamsBashforthSolver, 0, 0, 0}, {&_swigt__p_mfem__AB2Solver, _p_mfem__AB2SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB4Solver, _p_mfem__AB4SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB1Solver, _p_mfem__AB1SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB3Solver, _p_mfem__AB3SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB5Solver, _p_mfem__AB5SolverTo_p_mfem__AdamsBashforthSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AdamsMoultonSolver[] = { {&_swigt__p_mfem__AdamsMoultonSolver, 0, 0, 0}, {&_swigt__p_mfem__AM0Solver, _p_mfem__AM0SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM2Solver, _p_mfem__AM2SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM4Solver, _p_mfem__AM4SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM1Solver, _p_mfem__AM1SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM3Solver, _p_mfem__AM3SolverTo_p_mfem__AdamsMoultonSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AverageAccelerationSolver[] = { {&_swigt__p_mfem__AverageAccelerationSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BackwardEulerSolver[] = { {&_swigt__p_mfem__BackwardEulerSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__CentralDifferenceSolver[] = { {&_swigt__p_mfem__CentralDifferenceSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ExplicitRKSolver[] = { {&_swigt__p_mfem__RK6Solver, _p_mfem__RK6SolverTo_p_mfem__ExplicitRKSolver, 0, 0}, {&_swigt__p_mfem__RK8Solver, _p_mfem__RK8SolverTo_p_mfem__ExplicitRKSolver, 0, 0}, {&_swigt__p_mfem__ExplicitRKSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ForwardEulerSolver[] = { {&_swigt__p_mfem__ForwardEulerSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FoxGoodwinSolver[] = { {&_swigt__p_mfem__FoxGoodwinSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GeneralizedAlpha2Solver[] = { {&_swigt__p_mfem__GeneralizedAlpha2Solver, 0, 0, 0}, {&_swigt__p_mfem__AverageAccelerationSolver, _p_mfem__AverageAccelerationSolverTo_p_mfem__GeneralizedAlpha2Solver, 0, 0}, {&_swigt__p_mfem__HHTAlphaSolver, _p_mfem__HHTAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver, 0, 0}, {&_swigt__p_mfem__WBZAlphaSolver, _p_mfem__WBZAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GeneralizedAlphaSolver[] = { {&_swigt__p_mfem__GeneralizedAlphaSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HHTAlphaSolver[] = { {&_swigt__p_mfem__HHTAlphaSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ImplicitMidpointSolver[] = { {&_swigt__p_mfem__ImplicitMidpointSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ODESolver[] = { {&_swigt__p_mfem__ExplicitRKSolver, _p_mfem__ExplicitRKSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK23Solver, _p_mfem__SDIRK23SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK33Solver, _p_mfem__SDIRK33SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__GeneralizedAlphaSolver, _p_mfem__GeneralizedAlphaSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ODESolver, 0, 0, 0}, {&_swigt__p_mfem__ForwardEulerSolver, _p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK2Solver, _p_mfem__RK2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK3SSPSolver, _p_mfem__RK3SSPSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK4Solver, _p_mfem__RK4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__BackwardEulerSolver, _p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ImplicitMidpointSolver, _p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK34Solver, _p_mfem__SDIRK34SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK8Solver, _p_mfem__RK8SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK6Solver, _p_mfem__RK6SolverTo_p_mfem__ODESolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearAccelerationSolver[] = { {&_swigt__p_mfem__LinearAccelerationSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__NewmarkSolver[] = { {&_swigt__p_mfem__LinearAccelerationSolver, _p_mfem__LinearAccelerationSolverTo_p_mfem__NewmarkSolver, 0, 0}, {&_swigt__p_mfem__FoxGoodwinSolver, _p_mfem__FoxGoodwinSolverTo_p_mfem__NewmarkSolver, 0, 0}, {&_swigt__p_mfem__NewmarkSolver, 0, 0, 0}, {&_swigt__p_mfem__CentralDifferenceSolver, _p_mfem__CentralDifferenceSolverTo_p_mfem__NewmarkSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ODESolver[] = { {&_swigt__p_mfem__AB5Solver, _p_mfem__AB5SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AB3Solver, _p_mfem__AB3SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AB1Solver, _p_mfem__AB1SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ExplicitRKSolver, _p_mfem__ExplicitRKSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM1Solver, _p_mfem__AM1SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM3Solver, _p_mfem__AM3SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK23Solver, _p_mfem__SDIRK23SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK33Solver, _p_mfem__SDIRK33SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__GeneralizedAlphaSolver, _p_mfem__GeneralizedAlphaSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ODESolver, 0, 0, 0}, {&_swigt__p_mfem__AB2Solver, _p_mfem__AB2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AdamsBashforthSolver, _p_mfem__AdamsBashforthSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK8Solver, _p_mfem__RK8SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK6Solver, _p_mfem__RK6SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AB4Solver, _p_mfem__AB4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AdamsMoultonSolver, _p_mfem__AdamsMoultonSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM0Solver, _p_mfem__AM0SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM2Solver, _p_mfem__AM2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM4Solver, _p_mfem__AM4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK4Solver, _p_mfem__RK4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK3SSPSolver, _p_mfem__RK3SSPSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK2Solver, _p_mfem__RK2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ForwardEulerSolver, _p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__BackwardEulerSolver, _p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ImplicitMidpointSolver, _p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK34Solver, _p_mfem__SDIRK34SolverTo_p_mfem__ODESolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RK2Solver[] = { {&_swigt__p_mfem__RK2Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RK3SSPSolver[] = { {&_swigt__p_mfem__RK3SSPSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RK4Solver[] = { {&_swigt__p_mfem__RK4Solver, 0, 0, 0},{0, 0, 0, 0}}; @@ -6771,20 +9987,42 @@ static swig_cast_info _swigc__p_mfem__SIA1Solver[] = { {&_swigt__p_mfem__SIA1So static swig_cast_info _swigc__p_mfem__SIA2Solver[] = { {&_swigt__p_mfem__SIA2Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SIASolver[] = { {&_swigt__p_mfem__SIA2Solver, _p_mfem__SIA2SolverTo_p_mfem__SIASolver, 0, 0}, {&_swigt__p_mfem__SIAVSolver, _p_mfem__SIAVSolverTo_p_mfem__SIASolver, 0, 0}, {&_swigt__p_mfem__SIASolver, 0, 0, 0}, {&_swigt__p_mfem__SIA1Solver, _p_mfem__SIA1SolverTo_p_mfem__SIASolver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SIAVSolver[] = { {&_swigt__p_mfem__SIAVSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderODESolver[] = { {&_swigt__p_mfem__LinearAccelerationSolver, _p_mfem__LinearAccelerationSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__FoxGoodwinSolver, _p_mfem__FoxGoodwinSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__GeneralizedAlpha2Solver, _p_mfem__GeneralizedAlpha2SolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__AverageAccelerationSolver, _p_mfem__AverageAccelerationSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__SecondOrderODESolver, 0, 0, 0}, {&_swigt__p_mfem__HHTAlphaSolver, _p_mfem__HHTAlphaSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__WBZAlphaSolver, _p_mfem__WBZAlphaSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__NewmarkSolver, _p_mfem__NewmarkSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__CentralDifferenceSolver, _p_mfem__CentralDifferenceSolverTo_p_mfem__SecondOrderODESolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = { {&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__WBZAlphaSolver[] = { {&_swigt__p_mfem__WBZAlphaSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, _swigc__p_char, _swigc__p_double, + _swigc__p_mfem__AB1Solver, + _swigc__p_mfem__AB2Solver, + _swigc__p_mfem__AB3Solver, + _swigc__p_mfem__AB4Solver, + _swigc__p_mfem__AB5Solver, + _swigc__p_mfem__AM0Solver, + _swigc__p_mfem__AM1Solver, + _swigc__p_mfem__AM2Solver, + _swigc__p_mfem__AM3Solver, + _swigc__p_mfem__AM4Solver, + _swigc__p_mfem__AdamsBashforthSolver, + _swigc__p_mfem__AdamsMoultonSolver, + _swigc__p_mfem__AverageAccelerationSolver, _swigc__p_mfem__BackwardEulerSolver, + _swigc__p_mfem__CentralDifferenceSolver, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__ExplicitRKSolver, _swigc__p_mfem__ForwardEulerSolver, + _swigc__p_mfem__FoxGoodwinSolver, + _swigc__p_mfem__GeneralizedAlpha2Solver, _swigc__p_mfem__GeneralizedAlphaSolver, + _swigc__p_mfem__HHTAlphaSolver, _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__ImplicitMidpointSolver, + _swigc__p_mfem__LinearAccelerationSolver, + _swigc__p_mfem__NewmarkSolver, _swigc__p_mfem__ODESolver, _swigc__p_mfem__Operator, _swigc__p_mfem__ProductOperator, @@ -6796,6 +10034,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__RK4Solver, _swigc__p_mfem__RK6Solver, _swigc__p_mfem__RK8Solver, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__SDIRK23Solver, _swigc__p_mfem__SDIRK33Solver, _swigc__p_mfem__SDIRK34Solver, @@ -6803,11 +10042,15 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__SIA2Solver, _swigc__p_mfem__SIASolver, _swigc__p_mfem__SIAVSolver, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderODESolver, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, _swigc__p_mfem__TripleProductOperator, _swigc__p_mfem__Vector, + _swigc__p_mfem__WBZAlphaSolver, }; diff --git a/mfem/_par/operators.py b/mfem/_par/operators.py index a23529f1..9da69179 100644 --- a/mfem/_par/operators.py +++ b/mfem/_par/operators.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _operators.SWIG_PyInstanceMethod_New +_swig_new_static_method = _operators.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -72,6 +75,11 @@ class Operator(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr + def InitTVectors(self, Po, Ri, Pi, x, b, X, B): + r"""InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)""" + return _operators.Operator_InitTVectors(self, Po, Ri, Pi, x, b, X, B) + InitTVectors = _swig_new_instance_method(_operators.Operator_InitTVectors) + def __init__(self, *args): r""" __init__(Operator self, int s=0) -> Operator @@ -86,50 +94,92 @@ def __init__(self, *args): def Height(self): r"""Height(Operator self) -> int""" return _operators.Operator_Height(self) + Height = _swig_new_instance_method(_operators.Operator_Height) def NumRows(self): r"""NumRows(Operator self) -> int""" return _operators.Operator_NumRows(self) + NumRows = _swig_new_instance_method(_operators.Operator_NumRows) def Width(self): r"""Width(Operator self) -> int""" return _operators.Operator_Width(self) + Width = _swig_new_instance_method(_operators.Operator_Width) def NumCols(self): r"""NumCols(Operator self) -> int""" return _operators.Operator_NumCols(self) + NumCols = _swig_new_instance_method(_operators.Operator_NumCols) def GetMemoryClass(self): r"""GetMemoryClass(Operator self) -> mfem::MemoryClass""" return _operators.Operator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.Operator_GetMemoryClass) def Mult(self, x, y): r"""Mult(Operator self, Vector x, Vector y)""" return _operators.Operator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.Operator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(Operator self, Vector x, Vector y)""" return _operators.Operator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.Operator_MultTranspose) def GetGradient(self, x): r"""GetGradient(Operator self, Vector x) -> Operator""" return _operators.Operator_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_operators.Operator_GetGradient) def GetProlongation(self): r"""GetProlongation(Operator self) -> Operator""" return _operators.Operator_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_operators.Operator_GetProlongation) def GetRestriction(self): r"""GetRestriction(Operator self) -> Operator""" return _operators.Operator_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_operators.Operator_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(Operator self) -> Operator""" + return _operators.Operator_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_operators.Operator_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(Operator self) -> Operator""" + return _operators.Operator_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_operators.Operator_GetOutputRestriction) def FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior=0): r"""FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)""" return _operators.Operator_FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior) + FormLinearSystem = _swig_new_instance_method(_operators.Operator_FormLinearSystem) + + def FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B): + r"""FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)""" + return _operators.Operator_FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B) + FormRectangularLinearSystem = _swig_new_instance_method(_operators.Operator_FormRectangularLinearSystem) def RecoverFEMSolution(self, X, b, x): r"""RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)""" return _operators.Operator_RecoverFEMSolution(self, X, b, x) + RecoverFEMSolution = _swig_new_instance_method(_operators.Operator_RecoverFEMSolution) + + def FormSystemOperator(self, ess_tdof_list, A): + r"""FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)""" + return _operators.Operator_FormSystemOperator(self, ess_tdof_list, A) + FormSystemOperator = _swig_new_instance_method(_operators.Operator_FormSystemOperator) + + def FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A): + r"""FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)""" + return _operators.Operator_FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A) + FormRectangularSystemOperator = _swig_new_instance_method(_operators.Operator_FormRectangularSystemOperator) + + def FormDiscreteOperator(self, A): + r"""FormDiscreteOperator(Operator self, mfem::Operator *& A)""" + return _operators.Operator_FormDiscreteOperator(self, A) + FormDiscreteOperator = _swig_new_instance_method(_operators.Operator_FormDiscreteOperator) __swig_destroy__ = _operators.delete_Operator ANY_TYPE = _operators.Operator_ANY_TYPE @@ -149,10 +199,17 @@ def RecoverFEMSolution(self, X, b, x): PETSC_MATGENERIC = _operators.Operator_PETSC_MATGENERIC + Complex_Operator = _operators.Operator_Complex_Operator + + MFEM_ComplexSparseMat = _operators.Operator_MFEM_ComplexSparseMat + + Complex_Hypre_ParCSR = _operators.Operator_Complex_Hypre_ParCSR + def GetType(self): r"""GetType(Operator self) -> mfem::Operator::Type""" return _operators.Operator_GetType(self) + GetType = _swig_new_instance_method(_operators.Operator_GetType) def PrintMatlab(self, *args): r""" @@ -160,6 +217,7 @@ def PrintMatlab(self, *args): PrintMatlab(Operator self, char const * file, int precision=8) """ return _operators.Operator_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_operators.Operator_PrintMatlab) def __disown__(self): self.this.disown() _operators.disown_Operator(self) @@ -179,6 +237,12 @@ class TimeDependentOperator(Operator): HOMOGENEOUS = _operators.TimeDependentOperator_HOMOGENEOUS + NORMAL = _operators.TimeDependentOperator_NORMAL + + ADDITIVE_TERM_1 = _operators.TimeDependentOperator_ADDITIVE_TERM_1 + + ADDITIVE_TERM_2 = _operators.TimeDependentOperator_ADDITIVE_TERM_2 + def __init__(self, *args): r""" @@ -194,46 +258,92 @@ def __init__(self, *args): def GetTime(self): r"""GetTime(TimeDependentOperator self) -> double""" return _operators.TimeDependentOperator_GetTime(self) + GetTime = _swig_new_instance_method(_operators.TimeDependentOperator_GetTime) def SetTime(self, _t): r"""SetTime(TimeDependentOperator self, double const _t)""" return _operators.TimeDependentOperator_SetTime(self, _t) + SetTime = _swig_new_instance_method(_operators.TimeDependentOperator_SetTime) def isExplicit(self): r"""isExplicit(TimeDependentOperator self) -> bool""" return _operators.TimeDependentOperator_isExplicit(self) + isExplicit = _swig_new_instance_method(_operators.TimeDependentOperator_isExplicit) def isImplicit(self): r"""isImplicit(TimeDependentOperator self) -> bool""" return _operators.TimeDependentOperator_isImplicit(self) + isImplicit = _swig_new_instance_method(_operators.TimeDependentOperator_isImplicit) def isHomogeneous(self): r"""isHomogeneous(TimeDependentOperator self) -> bool""" return _operators.TimeDependentOperator_isHomogeneous(self) + isHomogeneous = _swig_new_instance_method(_operators.TimeDependentOperator_isHomogeneous) + + def GetEvalMode(self): + r"""GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode""" + return _operators.TimeDependentOperator_GetEvalMode(self) + GetEvalMode = _swig_new_instance_method(_operators.TimeDependentOperator_GetEvalMode) + + def SetEvalMode(self, new_eval_mode): + r"""SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)""" + return _operators.TimeDependentOperator_SetEvalMode(self, new_eval_mode) + SetEvalMode = _swig_new_instance_method(_operators.TimeDependentOperator_SetEvalMode) def ExplicitMult(self, x, y): r"""ExplicitMult(TimeDependentOperator self, Vector x, Vector y)""" return _operators.TimeDependentOperator_ExplicitMult(self, x, y) + ExplicitMult = _swig_new_instance_method(_operators.TimeDependentOperator_ExplicitMult) def ImplicitMult(self, x, k, y): r"""ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)""" return _operators.TimeDependentOperator_ImplicitMult(self, x, k, y) + ImplicitMult = _swig_new_instance_method(_operators.TimeDependentOperator_ImplicitMult) def Mult(self, x, y): r"""Mult(TimeDependentOperator self, Vector x, Vector y)""" return _operators.TimeDependentOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.TimeDependentOperator_Mult) def ImplicitSolve(self, dt, x, k): r"""ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)""" return _operators.TimeDependentOperator_ImplicitSolve(self, dt, x, k) + ImplicitSolve = _swig_new_instance_method(_operators.TimeDependentOperator_ImplicitSolve) def GetImplicitGradient(self, x, k, shift): r"""GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator""" return _operators.TimeDependentOperator_GetImplicitGradient(self, x, k, shift) + GetImplicitGradient = _swig_new_instance_method(_operators.TimeDependentOperator_GetImplicitGradient) def GetExplicitGradient(self, x): r"""GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator""" return _operators.TimeDependentOperator_GetExplicitGradient(self, x) + GetExplicitGradient = _swig_new_instance_method(_operators.TimeDependentOperator_GetExplicitGradient) + + def SUNImplicitSetup(self, x, fx, jok, jcur, gamma): + r"""SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int""" + return _operators.TimeDependentOperator_SUNImplicitSetup(self, x, fx, jok, jcur, gamma) + SUNImplicitSetup = _swig_new_instance_method(_operators.TimeDependentOperator_SUNImplicitSetup) + + def SUNImplicitSolve(self, b, x, tol): + r"""SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int""" + return _operators.TimeDependentOperator_SUNImplicitSolve(self, b, x, tol) + SUNImplicitSolve = _swig_new_instance_method(_operators.TimeDependentOperator_SUNImplicitSolve) + + def SUNMassSetup(self): + r"""SUNMassSetup(TimeDependentOperator self) -> int""" + return _operators.TimeDependentOperator_SUNMassSetup(self) + SUNMassSetup = _swig_new_instance_method(_operators.TimeDependentOperator_SUNMassSetup) + + def SUNMassSolve(self, b, x, tol): + r"""SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int""" + return _operators.TimeDependentOperator_SUNMassSolve(self, b, x, tol) + SUNMassSolve = _swig_new_instance_method(_operators.TimeDependentOperator_SUNMassSolve) + + def SUNMassMult(self, x, v): + r"""SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int""" + return _operators.TimeDependentOperator_SUNMassMult(self, x, v) + SUNMassMult = _swig_new_instance_method(_operators.TimeDependentOperator_SUNMassMult) __swig_destroy__ = _operators.delete_TimeDependentOperator def __disown__(self): self.this.disown() @@ -243,6 +353,39 @@ def __disown__(self): # Register TimeDependentOperator in _operators: _operators.TimeDependentOperator_swigregister(TimeDependentOperator) +class SecondOrderTimeDependentOperator(TimeDependentOperator): + r"""Proxy of C++ mfem::SecondOrderTimeDependentOperator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(SecondOrderTimeDependentOperator self, int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator + __init__(SecondOrderTimeDependentOperator self, int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator + """ + _operators.SecondOrderTimeDependentOperator_swiginit(self, _operators.new_SecondOrderTimeDependentOperator(*args)) + + def Mult(self, *args): + r""" + Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y) + Mult(SecondOrderTimeDependentOperator self, Vector x, Vector dxdt, Vector y) + """ + return _operators.SecondOrderTimeDependentOperator_Mult(self, *args) + Mult = _swig_new_instance_method(_operators.SecondOrderTimeDependentOperator_Mult) + + def ImplicitSolve(self, *args): + r""" + ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt, Vector x, Vector k) + ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt0, double const dt1, Vector x, Vector dxdt, Vector k) + """ + return _operators.SecondOrderTimeDependentOperator_ImplicitSolve(self, *args) + ImplicitSolve = _swig_new_instance_method(_operators.SecondOrderTimeDependentOperator_ImplicitSolve) + __swig_destroy__ = _operators.delete_SecondOrderTimeDependentOperator + +# Register SecondOrderTimeDependentOperator in _operators: +_operators.SecondOrderTimeDependentOperator_swigregister(SecondOrderTimeDependentOperator) + class Solver(Operator): r"""Proxy of C++ mfem::Solver class.""" @@ -264,6 +407,7 @@ def __init__(self, *args): def SetOperator(self, op): r"""SetOperator(Solver self, Operator op)""" return _operators.Solver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_operators.Solver_SetOperator) __swig_destroy__ = _operators.delete_Solver def __disown__(self): self.this.disown() @@ -286,15 +430,41 @@ def __init__(self, n): def Mult(self, x, y): r"""Mult(IdentityOperator self, Vector x, Vector y)""" return _operators.IdentityOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.IdentityOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(IdentityOperator self, Vector x, Vector y)""" return _operators.IdentityOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.IdentityOperator_MultTranspose) __swig_destroy__ = _operators.delete_IdentityOperator # Register IdentityOperator in _operators: _operators.IdentityOperator_swigregister(IdentityOperator) + +def IsIdentityProlongation(P): + r"""IsIdentityProlongation(Operator P) -> bool""" + return _operators.IsIdentityProlongation(P) +IsIdentityProlongation = _operators.IsIdentityProlongation +class ScaledOperator(Operator): + r"""Proxy of C++ mfem::ScaledOperator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, A, a): + r"""__init__(ScaledOperator self, Operator A, double a) -> ScaledOperator""" + _operators.ScaledOperator_swiginit(self, _operators.new_ScaledOperator(A, a)) + + def Mult(self, x, y): + r"""Mult(ScaledOperator self, Vector x, Vector y)""" + return _operators.ScaledOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.ScaledOperator_Mult) + __swig_destroy__ = _operators.delete_ScaledOperator + +# Register ScaledOperator in _operators: +_operators.ScaledOperator_swigregister(ScaledOperator) + class TransposeOperator(Operator): r"""Proxy of C++ mfem::TransposeOperator class.""" @@ -311,10 +481,12 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(TransposeOperator self, Vector x, Vector y)""" return _operators.TransposeOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.TransposeOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(TransposeOperator self, Vector x, Vector y)""" return _operators.TransposeOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.TransposeOperator_MultTranspose) __swig_destroy__ = _operators.delete_TransposeOperator # Register TransposeOperator in _operators: @@ -333,10 +505,12 @@ def __init__(self, A, B, ownA, ownB): def Mult(self, x, y): r"""Mult(ProductOperator self, Vector x, Vector y)""" return _operators.ProductOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.ProductOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(ProductOperator self, Vector x, Vector y)""" return _operators.ProductOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.ProductOperator_MultTranspose) __swig_destroy__ = _operators.delete_ProductOperator # Register ProductOperator in _operators: @@ -355,14 +529,17 @@ def __init__(self, Rt_, A_, P_): def GetMemoryClass(self): r"""GetMemoryClass(RAPOperator self) -> mfem::MemoryClass""" return _operators.RAPOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.RAPOperator_GetMemoryClass) def Mult(self, x, y): r"""Mult(RAPOperator self, Vector x, Vector y)""" return _operators.RAPOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.RAPOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(RAPOperator self, Vector x, Vector y)""" return _operators.RAPOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.RAPOperator_MultTranspose) __swig_destroy__ = _operators.delete_RAPOperator # Register RAPOperator in _operators: @@ -381,14 +558,17 @@ def __init__(self, A, B, C, ownA, ownB, ownC): def GetMemoryClass(self): r"""GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass""" return _operators.TripleProductOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.TripleProductOperator_GetMemoryClass) def Mult(self, x, y): r"""Mult(TripleProductOperator self, Vector x, Vector y)""" return _operators.TripleProductOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.TripleProductOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(TripleProductOperator self, Vector x, Vector y)""" return _operators.TripleProductOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.TripleProductOperator_MultTranspose) __swig_destroy__ = _operators.delete_TripleProductOperator # Register TripleProductOperator in _operators: @@ -407,19 +587,51 @@ def __init__(self, A, list, own_A=False): def GetMemoryClass(self): r"""GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass""" return _operators.ConstrainedOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.ConstrainedOperator_GetMemoryClass) def EliminateRHS(self, x, b): r"""EliminateRHS(ConstrainedOperator self, Vector x, Vector b)""" return _operators.ConstrainedOperator_EliminateRHS(self, x, b) + EliminateRHS = _swig_new_instance_method(_operators.ConstrainedOperator_EliminateRHS) def Mult(self, x, y): r"""Mult(ConstrainedOperator self, Vector x, Vector y)""" return _operators.ConstrainedOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.ConstrainedOperator_Mult) __swig_destroy__ = _operators.delete_ConstrainedOperator # Register ConstrainedOperator in _operators: _operators.ConstrainedOperator_swigregister(ConstrainedOperator) +class RectangularConstrainedOperator(Operator): + r"""Proxy of C++ mfem::RectangularConstrainedOperator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, A, trial_list, test_list, own_A=False): + r"""__init__(RectangularConstrainedOperator self, Operator A, intArray trial_list, intArray test_list, bool own_A=False) -> RectangularConstrainedOperator""" + _operators.RectangularConstrainedOperator_swiginit(self, _operators.new_RectangularConstrainedOperator(A, trial_list, test_list, own_A)) + + def GetMemoryClass(self): + r"""GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass""" + return _operators.RectangularConstrainedOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.RectangularConstrainedOperator_GetMemoryClass) + + def EliminateRHS(self, x, b): + r"""EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)""" + return _operators.RectangularConstrainedOperator_EliminateRHS(self, x, b) + EliminateRHS = _swig_new_instance_method(_operators.RectangularConstrainedOperator_EliminateRHS) + + def Mult(self, x, y): + r"""Mult(RectangularConstrainedOperator self, Vector x, Vector y)""" + return _operators.RectangularConstrainedOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.RectangularConstrainedOperator_Mult) + __swig_destroy__ = _operators.delete_RectangularConstrainedOperator + +# Register RectangularConstrainedOperator in _operators: +_operators.RectangularConstrainedOperator_swigregister(RectangularConstrainedOperator) + class PyOperatorBase(Operator): r"""Proxy of C++ mfem::PyOperatorBase class.""" @@ -440,10 +652,12 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(PyOperatorBase self, Vector x, Vector y)""" return _operators.PyOperatorBase_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.PyOperatorBase_Mult) def _EvalMult(self, arg0): r"""_EvalMult(PyOperatorBase self, Vector arg0) -> Vector""" return _operators.PyOperatorBase__EvalMult(self, arg0) + _EvalMult = _swig_new_instance_method(_operators.PyOperatorBase__EvalMult) __swig_destroy__ = _operators.delete_PyOperatorBase def __disown__(self): self.this.disown() @@ -473,10 +687,12 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)""" return _operators.PyTimeDependentOperatorBase_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.PyTimeDependentOperatorBase_Mult) def _EvalMult(self, arg0): r"""_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector""" return _operators.PyTimeDependentOperatorBase__EvalMult(self, arg0) + _EvalMult = _swig_new_instance_method(_operators.PyTimeDependentOperatorBase__EvalMult) __swig_destroy__ = _operators.delete_PyTimeDependentOperatorBase def __disown__(self): self.this.disown() diff --git a/mfem/_par/operators_wrap.cxx b/mfem/_par/operators_wrap.cxx index 7b9e7fc3..f853d94c 100644 --- a/mfem/_par/operators_wrap.cxx +++ b/mfem/_par/operators_wrap.cxx @@ -3067,32 +3067,39 @@ namespace Swig { #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] #define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[2] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[3] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[4] -#define SWIGTYPE_p_mfem__Operator swig_types[5] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[6] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[7] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[8] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[9] -#define SWIGTYPE_p_mfem__Solver swig_types[10] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[11] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[12] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[13] -#define SWIGTYPE_p_mfem__Vector swig_types[14] -#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[15] -#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[16] -#define SWIGTYPE_p_p_mfem__Operator swig_types[17] -#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[18] -#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[19] -#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[20] -#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[21] -#define SWIGTYPE_p_p_mfem__Solver swig_types[22] -#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[23] -#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[24] -#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[25] -static swig_type_info *swig_types[27]; -static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0}; +#define SWIGTYPE_p_int swig_types[2] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[3] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[4] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[5] +#define SWIGTYPE_p_mfem__Operator swig_types[6] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[7] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[8] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[9] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[10] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[11] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[12] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[13] +#define SWIGTYPE_p_mfem__Solver swig_types[14] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[15] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[16] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[17] +#define SWIGTYPE_p_mfem__Vector swig_types[18] +#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[19] +#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[20] +#define SWIGTYPE_p_p_mfem__Operator swig_types[21] +#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[22] +#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[23] +#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[24] +#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[25] +#define SWIGTYPE_p_p_mfem__RectangularConstrainedOperator swig_types[26] +#define SWIGTYPE_p_p_mfem__ScaledOperator swig_types[27] +#define SWIGTYPE_p_p_mfem__SecondOrderTimeDependentOperator swig_types[28] +#define SWIGTYPE_p_p_mfem__Solver swig_types[29] +#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[30] +#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[31] +#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[32] +static swig_type_info *swig_types[34]; +static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3757,6 +3764,80 @@ mfem::Operator const *SwigDirector_Operator::GetRestriction() const { } +mfem::Operator const *SwigDirector_Operator::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Operator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_Operator::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Operator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_Operator::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -3768,7 +3849,7 @@ void SwigDirector_Operator::RecoverFEMSolution(mfem::Vector const &X, mfem::Vect Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Operator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4009,6 +4090,80 @@ mfem::Operator const *SwigDirector_TimeDependentOperator::GetRestriction() const } +mfem::Operator const *SwigDirector_TimeDependentOperator::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_TimeDependentOperator::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_TimeDependentOperator::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -4020,7 +4175,7 @@ void SwigDirector_TimeDependentOperator::RecoverFEMSolution(mfem::Vector const & Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4049,7 +4204,7 @@ double SwigDirector_TimeDependentOperator::GetTime() const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "GetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject args = PyTuple_New(0); @@ -4083,7 +4238,7 @@ void SwigDirector_TimeDependentOperator::SetTime(double const _t) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 10; const char *const swig_method_name = "SetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4102,6 +4257,32 @@ void SwigDirector_TimeDependentOperator::SetTime(double const _t) { } +void SwigDirector_TimeDependentOperator::SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_From_int(static_cast< int >(new_eval_mode)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 11; + const char *const swig_method_name = "SetEvalMode"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SetEvalMode"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + void SwigDirector_TimeDependentOperator::ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); @@ -4111,7 +4292,7 @@ void SwigDirector_TimeDependentOperator::ExplicitMult(mfem::Vector const &x, mfe Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 12; const char *const swig_method_name = "ExplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -4141,7 +4322,7 @@ void SwigDirector_TimeDependentOperator::ImplicitMult(mfem::Vector const &x, mfe Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 13; const char *const swig_method_name = "ImplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4171,7 +4352,7 @@ void SwigDirector_TimeDependentOperator::ImplicitSolve(double const dt, mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 11; + const size_t swig_method_index = 14; const char *const swig_method_name = "ImplicitSolve"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4206,7 +4387,7 @@ mfem::Operator &SwigDirector_TimeDependentOperator::GetImplicitGradient(mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 12; + const size_t swig_method_index = 15; const char *const swig_method_name = "GetImplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4247,7 +4428,7 @@ mfem::Operator &SwigDirector_TimeDependentOperator::GetExplicitGradient(mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 13; + const size_t swig_method_index = 16; const char *const swig_method_name = "GetExplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4276,35 +4457,30 @@ mfem::Operator &SwigDirector_TimeDependentOperator::GetExplicitGradient(mfem::Ve } -SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int s, bool iter_mode): mfem::Solver(s, iter_mode), Swig::Director(self) { - SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); -} - - - - -SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int h, int w, bool iter_mode): mfem::Solver(h, w, iter_mode), Swig::Director(self) { - SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); -} - - - - -mfem::MemoryClass SwigDirector_Solver::GetMemoryClass() const { - mfem::MemoryClass c_result = SwigValueInit< mfem::MemoryClass >() ; +int SwigDirector_TimeDependentOperator::SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma) { + int c_result = SwigValueInit< int >() ; + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&fx), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_int(static_cast< int >(jok)); + swig::SwigVar_PyObject obj3; + obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(jcur), SWIGTYPE_p_int, 0 ); + swig::SwigVar_PyObject obj4; + obj4 = SWIG_From_double(static_cast< double >(gamma)); if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 0; - const char *const swig_method_name = "GetMemoryClass"; + const size_t swig_method_index = 17; + const char *const swig_method_name = "SUNImplicitSetup"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject args = PyTuple_New(0); - swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetMemoryClass"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4317,29 +4493,33 @@ mfem::MemoryClass SwigDirector_Solver::GetMemoryClass() const { int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) { - Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::MemoryClass""'"); + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); } - c_result = static_cast< mfem::MemoryClass >(swig_val); - return (mfem::MemoryClass) c_result; + c_result = static_cast< int >(swig_val); + return (int) c_result; } -void SwigDirector_Solver::Mult(mfem::Vector const &x, mfem::Vector &y) const { +int SwigDirector_TimeDependentOperator::SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; + swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); swig::SwigVar_PyObject obj1; - obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 1; - const char *const swig_method_name = "Mult"; + const size_t swig_method_index = 18; + const char *const swig_method_name = "SUNImplicitSolve"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("Mult"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4349,25 +4529,31 @@ void SwigDirector_Solver::Mult(mfem::Vector const &x, mfem::Vector &y) const { } } } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; } -void SwigDirector_Solver::MultTranspose(mfem::Vector const &x, mfem::Vector &y) const { - swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); - swig::SwigVar_PyObject obj1; - obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); +int SwigDirector_TimeDependentOperator::SUNMassSetup() { + int c_result = SwigValueInit< int >() ; + if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 2; - const char *const swig_method_name = "MultTranspose"; + const size_t swig_method_index = 19; + const char *const swig_method_name = "SUNMassSetup"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("MultTranspose"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4377,22 +4563,209 @@ void SwigDirector_Solver::MultTranspose(mfem::Vector const &x, mfem::Vector &y) } } } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; } -mfem::Operator &SwigDirector_Solver::GetGradient(mfem::Vector const &x) const { - mfem::Operator *c_result = 0 ; - void *swig_argp ; - int swig_res ; - swig_owntype own ; +int SwigDirector_TimeDependentOperator::SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 3; + const size_t swig_method_index = 20; + const char *const swig_method_name = "SUNMassSolve"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_TimeDependentOperator::SUNMassMult(mfem::Vector const &x, mfem::Vector &v) { + int c_result = SwigValueInit< int >() ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&v), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 21; + const char *const swig_method_name = "SUNMassMult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassMult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int s, bool iter_mode): mfem::Solver(s, iter_mode), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); +} + + + + +SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int h, int w, bool iter_mode): mfem::Solver(h, w, iter_mode), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); +} + + + + +mfem::MemoryClass SwigDirector_Solver::GetMemoryClass() const { + mfem::MemoryClass c_result = SwigValueInit< mfem::MemoryClass >() ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 0; + const char *const swig_method_name = "GetMemoryClass"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetMemoryClass"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::MemoryClass""'"); + } + c_result = static_cast< mfem::MemoryClass >(swig_val); + return (mfem::MemoryClass) c_result; +} + + +void SwigDirector_Solver::Mult(mfem::Vector const &x, mfem::Vector &y) const { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 1; + const char *const swig_method_name = "Mult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("Mult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_Solver::MultTranspose(mfem::Vector const &x, mfem::Vector &y) const { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 2; + const char *const swig_method_name = "MultTranspose"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("MultTranspose"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +mfem::Operator &SwigDirector_Solver::GetGradient(mfem::Vector const &x) const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 3; const char *const swig_method_name = "GetGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4495,6 +4868,80 @@ mfem::Operator const *SwigDirector_Solver::GetRestriction() const { } +mfem::Operator const *SwigDirector_Solver::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_Solver::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_Solver::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -4506,7 +4953,7 @@ void SwigDirector_Solver::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4535,7 +4982,7 @@ void SwigDirector_Solver::SetOperator(mfem::Operator const &op) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "SetOperator"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4773,24 +5220,98 @@ mfem::Operator const *SwigDirector_PyOperatorBase::GetRestriction() const { } -void SwigDirector_PyOperatorBase::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { - swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); - swig::SwigVar_PyObject obj1; - obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); - swig::SwigVar_PyObject obj2; - obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); +mfem::Operator const *SwigDirector_PyOperatorBase::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + if (!swig_get_self()) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) const size_t swig_method_index = 6; - const char *const swig_method_name = "RecoverFEMSolution"; + const char *const swig_method_name = "GetOutputProlongation"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("RecoverFEMSolution"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_PyOperatorBase::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +void SwigDirector_PyOperatorBase::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 8; + const char *const swig_method_name = "RecoverFEMSolution"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("RecoverFEMSolution"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4818,7 +5339,7 @@ mfem::Vector &SwigDirector_PyOperatorBase::_EvalMult(mfem::Vector const &arg0) c Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "_EvalMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -5066,6 +5587,80 @@ mfem::Operator const *SwigDirector_PyTimeDependentOperatorBase::GetRestriction() } +mfem::Operator const *SwigDirector_PyTimeDependentOperatorBase::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_PyTimeDependentOperatorBase::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_PyTimeDependentOperatorBase::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -5077,7 +5672,7 @@ void SwigDirector_PyTimeDependentOperatorBase::RecoverFEMSolution(mfem::Vector c Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5106,7 +5701,7 @@ double SwigDirector_PyTimeDependentOperatorBase::GetTime() const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "GetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject args = PyTuple_New(0); @@ -5140,7 +5735,7 @@ void SwigDirector_PyTimeDependentOperatorBase::SetTime(double const _t) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 10; const char *const swig_method_name = "SetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -5159,6 +5754,32 @@ void SwigDirector_PyTimeDependentOperatorBase::SetTime(double const _t) { } +void SwigDirector_PyTimeDependentOperatorBase::SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_From_int(static_cast< int >(new_eval_mode)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 11; + const char *const swig_method_name = "SetEvalMode"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SetEvalMode"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + void SwigDirector_PyTimeDependentOperatorBase::ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); @@ -5168,7 +5789,7 @@ void SwigDirector_PyTimeDependentOperatorBase::ExplicitMult(mfem::Vector const & Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 12; const char *const swig_method_name = "ExplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -5198,7 +5819,7 @@ void SwigDirector_PyTimeDependentOperatorBase::ImplicitMult(mfem::Vector const & Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 13; const char *const swig_method_name = "ImplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5228,7 +5849,7 @@ void SwigDirector_PyTimeDependentOperatorBase::ImplicitSolve(double const dt, mf Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 11; + const size_t swig_method_index = 14; const char *const swig_method_name = "ImplicitSolve"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5263,7 +5884,7 @@ mfem::Operator &SwigDirector_PyTimeDependentOperatorBase::GetImplicitGradient(mf Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 12; + const size_t swig_method_index = 15; const char *const swig_method_name = "GetImplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5304,7 +5925,7 @@ mfem::Operator &SwigDirector_PyTimeDependentOperatorBase::GetExplicitGradient(mf Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 13; + const size_t swig_method_index = 16; const char *const swig_method_name = "GetExplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -5333,25 +5954,30 @@ mfem::Operator &SwigDirector_PyTimeDependentOperatorBase::GetExplicitGradient(mf } -mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector const &arg0) const { - mfem::Vector *c_result = 0 ; - void *swig_argp ; - int swig_res ; - swig_owntype own ; +int SwigDirector_PyTimeDependentOperatorBase::SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma) { + int c_result = SwigValueInit< int >() ; swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_mfem__Vector, 0 ); + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&fx), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_int(static_cast< int >(jok)); + swig::SwigVar_PyObject obj3; + obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(jcur), SWIGTYPE_p_int, 0 ); + swig::SwigVar_PyObject obj4; + obj4 = SWIG_From_double(static_cast< double >(gamma)); if (!swig_get_self()) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 14; - const char *const swig_method_name = "_EvalMult"; + const size_t swig_method_index = 17; + const char *const swig_method_name = "SUNImplicitSetup"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("_EvalMult"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -5361,62 +5987,350 @@ mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector c } } } - swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Vector, 0 | SWIG_POINTER_DISOWN, &own); + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) { - Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Vector &""'"); - } - if (!swig_argp) { - Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ValueError), "invalid null reference " "in output value of type '""mfem::Vector &""'"); + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); } - c_result = reinterpret_cast< mfem::Vector * >(swig_argp); - swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); - return (mfem::Vector &) *c_result; + c_result = static_cast< int >(swig_val); + return (int) c_result; } -#ifdef __cplusplus -extern "C" { -#endif -SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::Operator *result = 0 ; +int SwigDirector_PyTimeDependentOperatorBase::SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Operator *)new SwigDirector_Operator(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 18; + const char *const swig_method_name = "SUNImplicitSolve"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_PyTimeDependentOperatorBase::SUNMassSetup() { + int c_result = SwigValueInit< int >() ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 19; + const char *const swig_method_name = "SUNMassSetup"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_PyTimeDependentOperatorBase::SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 20; + const char *const swig_method_name = "SUNMassSolve"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_PyTimeDependentOperatorBase::SUNMassMult(mfem::Vector const &x, mfem::Vector &v) { + int c_result = SwigValueInit< int >() ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&v), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 21; + const char *const swig_method_name = "SUNMassMult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassMult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector const &arg0) const { + mfem::Vector *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 22; + const char *const swig_method_name = "_EvalMult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("_EvalMult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Vector, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Vector &""'"); + } + if (!swig_argp) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ValueError), "invalid null reference " "in output value of type '""mfem::Vector &""'"); + } + c_result = reinterpret_cast< mfem::Vector * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Vector &) *c_result; +} + + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Operator *arg2 = (mfem::Operator *) 0 ; + mfem::Operator *arg3 = (mfem::Operator *) 0 ; + mfem::Operator *arg4 = (mfem::Operator *) 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_InitTVectors", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_InitTVectors" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); + } + arg3 = reinterpret_cast< mfem::Operator * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); + } + arg4 = reinterpret_cast< mfem::Operator * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + ((mfem::Operator const *)arg1)->InitTVectors((mfem::Operator const *)arg2,(mfem::Operator const *)arg3,(mfem::Operator const *)arg4,*arg5,*arg6,*arg7,*arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PyObject *arg1 = (PyObject *) 0 ; + int arg2 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + arg1 = swig_obj[0]; + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + if ( arg1 != Py_None ) { + /* subclassed */ + result = (mfem::Operator *)new SwigDirector_Operator(arg1,arg2); + } else { + SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); + SWIG_fail; + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_new_Operator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; @@ -6066,21 +6980,133 @@ SWIGINTERN PyObject *_wrap_Operator_GetRestriction(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Operator **arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_GetOutputProlongation" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->mfem::Operator::GetOutputProlongation(); + } else { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->GetOutputProlongation(); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + director = SWIG_DIRECTOR_CAST(result); + if (director) { + resultobj = director->swig_get_self(); + Py_INCREF(resultobj); + } else { + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + } + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_GetOutputRestriction" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->mfem::Operator::GetOutputRestriction(); + } else { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->GetOutputRestriction(); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + director = SWIG_DIRECTOR_CAST(result); + if (director) { + resultobj = director->swig_get_self(); + Py_INCREF(resultobj); + } else { + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + } + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Operator **arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + int arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; @@ -6373,6 +7399,116 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem(PyObject *self, PyObject *a } +SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Operator **arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + arg6 = reinterpret_cast< mfem::Operator ** >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + (arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; @@ -6451,53 +7587,44 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Operator **arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Operator_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); } + arg3 = reinterpret_cast< mfem::Operator ** >(argp3); { try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); + (arg1)->FormSystemOperator((mfem::Array< int > const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6509,35 +7636,209 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Operator **arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + arg4 = reinterpret_cast< mfem::Operator ** >(argp4); + { + try { + (arg1)->FormRectangularSystemOperator((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Operator **arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + arg2 = reinterpret_cast< mfem::Operator ** >(argp2); + { + try { + (arg1)->FormDiscreteOperator(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); @@ -7736,6 +9037,94 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_isHomogeneous(PyObject *SWIGUNU } +SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::TimeDependentOperator::EvalMode result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_GetEvalMode" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + { + try { + result = (mfem::TimeDependentOperator::EvalMode)((mfem::TimeDependentOperator const *)arg1)->GetEvalMode(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::TimeDependentOperator::EvalMode arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SetEvalMode", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "2"" of type '" "mfem::TimeDependentOperator::EvalMode""'"); + } + arg2 = static_cast< mfem::TimeDependentOperator::EvalMode >(val2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::TimeDependentOperator::SetEvalMode(arg2); + } else { + (arg1)->SetEvalMode(arg2); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; @@ -8174,22 +9563,380 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S } -SWIGINTERN PyObject *_wrap_delete_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int *arg5 = (int *) 0 ; + double arg6 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); - } - arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - { - try { + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + Swig::Director *director = 0; + bool upcall = false; + int result; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSetup", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "5"" of type '" "int *""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNImplicitSetup((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,arg4,arg5,arg6); + } else { + result = (int)(arg1)->SUNImplicitSetup((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,arg4,arg5,arg6); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + Swig::Director *director = 0; + bool upcall = false; + int result; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSolve", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNImplicitSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } else { + result = (int)(arg1)->SUNImplicitSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassSetup" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNMassSetup(); + } else { + result = (int)(arg1)->SUNMassSetup(); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + Swig::Director *director = 0; + bool upcall = false; + int result; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassSolve", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNMassSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } else { + result = (int)(arg1)->SUNMassSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + Swig::Director *director = 0; + bool upcall = false; + int result; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassMult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNMassMult((mfem::Vector const &)*arg2,*arg3); + } else { + result = (int)(arg1)->SUNMassMult((mfem::Vector const &)*arg2,*arg3); + } + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + { + try { delete arg1; } catch (Swig::DirectorException &e) { @@ -8208,25 +9955,928 @@ SWIGINTERN PyObject *_wrap_delete_TimeDependentOperator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + mfem::TimeDependentOperator::Type arg3 ; + double val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg3 = static_cast< mfem::TimeDependentOperator::Type >(val3); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + double val2 ; + int ecode2 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + double arg3 ; + mfem::TimeDependentOperator::Type arg4 ; + double val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + double arg3 ; + double val3 ; + int ecode3 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SecondOrderTimeDependentOperator", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_3(self, argc, argv); + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_2(self, argc, argv); + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_6(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_5(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_4(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SecondOrderTimeDependentOperator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double,mfem::TimeDependentOperator::Type)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator()\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_Mult__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::SecondOrderTimeDependentOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_Mult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::SecondOrderTimeDependentOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_Mult(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SecondOrderTimeDependentOperator_Mult", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_Mult__SWIG_0_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_Mult__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SecondOrderTimeDependentOperator_Mult'.\n" + " Possible C/C++ prototypes are:\n" + " Mult(mfem::Vector const &,mfem::Vector &) const\n" + " mfem::SecondOrderTimeDependentOperator::Mult(mfem::Vector const &,mfem::Vector const &,mfem::Vector &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + double arg2 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + (arg1)->ImplicitSolve(arg2,(mfem::Vector const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + double arg2 ; + double arg3 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + { + try { + (arg1)->ImplicitSolve(arg2,arg3,(mfem::Vector const &)*arg4,(mfem::Vector const &)*arg5,*arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_ImplicitSolve(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SecondOrderTimeDependentOperator_ImplicitSolve", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_0_0(self, argc, argv); + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SecondOrderTimeDependentOperator_ImplicitSolve'.\n" + " Possible C/C++ prototypes are:\n" + " ImplicitSolve(double const,mfem::Vector const &,mfem::Vector &)\n" + " mfem::SecondOrderTimeDependentOperator::ImplicitSolve(double const,double const,mfem::Vector const &,mfem::Vector const &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_SecondOrderTimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondOrderTimeDependentOperator" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator *""'"); } - arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); { - Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); - if (director) director->swig_disown(); + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -8234,14 +10884,14 @@ SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *SecondOrderTimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *SecondOrderTimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } @@ -8953,14 +11603,191 @@ SWIGINTERN PyObject *_wrap_delete_IdentityOperator(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *IdentityOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *IdentityOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *IdentityOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsIdentityProlongation" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + try { + result = (bool)mfem::IsIdentityProlongation((mfem::Operator const *)arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + mfem::ScaledOperator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ScaledOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScaledOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScaledOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (mfem::ScaledOperator *)new mfem::ScaledOperator((mfem::Operator const *)arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScaledOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScaledOperator *arg1 = (mfem::ScaledOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ScaledOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScaledOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScaledOperator_Mult" "', argument " "1"" of type '" "mfem::ScaledOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ScaledOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScaledOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScaledOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ScaledOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScaledOperator *arg1 = (mfem::ScaledOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScaledOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScaledOperator" "', argument " "1"" of type '" "mfem::ScaledOperator *""'"); + } + arg1 = reinterpret_cast< mfem::ScaledOperator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScaledOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScaledOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *IdentityOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ScaledOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } @@ -9477,7 +12304,271 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj arg3 = reinterpret_cast< mfem::Operator * >(argp3); { try { - result = (mfem::RAPOperator *)new mfem::RAPOperator((mfem::Operator const &)*arg1,(mfem::Operator const &)*arg2,(mfem::Operator const &)*arg3); + result = (mfem::RAPOperator *)new mfem::RAPOperator((mfem::Operator const &)*arg1,(mfem::Operator const &)*arg2,(mfem::Operator const &)*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MemoryClass result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + { + try { + result = (mfem::MemoryClass)((mfem::RAPOperator const *)arg1)->GetMemoryClass(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "RAPOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_Mult" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::RAPOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "RAPOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_MultTranspose" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::RAPOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RAPOperator" "', argument " "1"" of type '" "mfem::RAPOperator *""'"); + } + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *RAPOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RAPOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *RAPOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Operator *arg2 = (mfem::Operator *) 0 ; + mfem::Operator *arg3 = (mfem::Operator *) 0 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + bool val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + mfem::TripleProductOperator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_TripleProductOperator", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TripleProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TripleProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TripleProductOperator" "', argument " "3"" of type '" "mfem::Operator const *""'"); + } + arg3 = reinterpret_cast< mfem::Operator * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TripleProductOperator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TripleProductOperator" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TripleProductOperator" "', argument " "6"" of type '" "bool""'"); + } + arg6 = static_cast< bool >(val6); + { + try { + result = (mfem::TripleProductOperator *)new mfem::TripleProductOperator((mfem::Operator const *)arg1,(mfem::Operator const *)arg2,(mfem::Operator const *)arg3,arg4,arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9488,16 +12579,16 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9505,14 +12596,14 @@ SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(s if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); { try { - result = (mfem::MemoryClass)((mfem::RAPOperator const *)arg1)->GetMemoryClass(); + result = (mfem::MemoryClass)((mfem::TripleProductOperator const *)arg1)->GetMemoryClass(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9530,9 +12621,9 @@ SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9543,31 +12634,31 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_Mult" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_Mult" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::RAPOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::TripleProductOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9585,9 +12676,9 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9598,31 +12689,31 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_MultTranspose" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::RAPOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::TripleProductOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9640,20 +12731,20 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_delete_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RAPOperator" "', argument " "1"" of type '" "mfem::RAPOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); { try { delete arg1; @@ -9674,74 +12765,52 @@ SWIGINTERN PyObject *_wrap_delete_RAPOperator(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *RAPOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RAPOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *RAPOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - mfem::Operator *arg3 = (mfem::Operator *) 0 ; - bool arg4 ; - bool arg5 ; - bool arg6 ; + mfem::Array< int > *arg2 = 0 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - bool val6 ; - int ecode6 = 0 ; - PyObject *swig_obj[6] ; - mfem::TripleProductOperator *result = 0 ; + bool val3 ; + int ecode3 = 0 ; + mfem::ConstrainedOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_TripleProductOperator", 6, 6, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TripleProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TripleProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TripleProductOperator" "', argument " "3"" of type '" "mfem::Operator const *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< mfem::Operator * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TripleProductOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TripleProductOperator" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TripleProductOperator" "', argument " "6"" of type '" "bool""'"); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); } - arg6 = static_cast< bool >(val6); + arg3 = static_cast< bool >(val3); { try { - result = (mfem::TripleProductOperator *)new mfem::TripleProductOperator((mfem::Operator const *)arg1,(mfem::Operator const *)arg2,(mfem::Operator const *)arg3,arg4,arg5,arg6); + result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9752,16 +12821,110 @@ SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(se // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::ConstrainedOperator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstrainedOperator", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ConstrainedOperator__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ConstrainedOperator__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstrainedOperator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,bool)\n" + " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9769,14 +12932,14 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUN if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); { try { - result = (mfem::MemoryClass)((mfem::TripleProductOperator const *)arg1)->GetMemoryClass(); + result = (mfem::MemoryClass)((mfem::ConstrainedOperator const *)arg1)->GetMemoryClass(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9794,9 +12957,9 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9807,31 +12970,31 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_Mult" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::TripleProductOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::ConstrainedOperator const *)arg1)->EliminateRHS((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9849,9 +13012,9 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9862,31 +13025,31 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::TripleProductOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::ConstrainedOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9904,20 +13067,20 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstrainedOperator" "', argument " "1"" of type '" "mfem::ConstrainedOperator *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); { try { delete arg1; @@ -9938,52 +13101,63 @@ SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; - bool arg3 ; + mfem::Array< int > *arg3 = 0 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - mfem::ConstrainedOperator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + mfem::RectangularConstrainedOperator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RectangularConstrainedOperator" "', argument " "4"" of type '" "bool""'"); } - arg3 = static_cast< bool >(val3); + arg4 = static_cast< bool >(val4); { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); + result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9994,40 +13168,51 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::ConstrainedOperator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + mfem::RectangularConstrainedOperator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2); + result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10038,22 +13223,22 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstrainedOperator", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_RectangularConstrainedOperator", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -10062,11 +13247,15 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_RectangularConstrainedOperator__SWIG_1(self, argc, argv); + } } } } - if (argc == 3) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -10075,29 +13264,33 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_0(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_RectangularConstrainedOperator__SWIG_0(self, argc, argv); + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstrainedOperator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RectangularConstrainedOperator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,bool)\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &)\n"); + " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &,bool)\n" + " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10105,14 +13298,14 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUS if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); { try { - result = (mfem::MemoryClass)((mfem::ConstrainedOperator const *)arg1)->GetMemoryClass(); + result = (mfem::MemoryClass)((mfem::RectangularConstrainedOperator const *)arg1)->GetMemoryClass(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10130,9 +13323,9 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -10143,31 +13336,31 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ConstrainedOperator const *)arg1)->EliminateRHS((mfem::Vector const &)*arg2,*arg3); + ((mfem::RectangularConstrainedOperator const *)arg1)->EliminateRHS((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10185,9 +13378,9 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -10198,31 +13391,31 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ConstrainedOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::RectangularConstrainedOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10240,20 +13433,20 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_delete_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_RectangularConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstrainedOperator" "', argument " "1"" of type '" "mfem::ConstrainedOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); { try { delete arg1; @@ -10274,14 +13467,14 @@ SWIGINTERN PyObject *_wrap_delete_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *ConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *RectangularConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *RectangularConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } @@ -11224,6 +14417,8 @@ SWIGINTERN PyObject *PyTimeDependentOperatorBase_swiginit(PyObject *SWIGUNUSEDPA static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "Operator_InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" "Operator(int s=0)\n" "new_Operator(PyObject * _self, int h, int w) -> Operator\n" @@ -11238,8 +14433,14 @@ static PyMethodDef SwigMethods[] = { { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "Operator_GetGradient(Operator self, Vector x) -> Operator"}, { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "Operator_GetProlongation(Operator self) -> Operator"}, { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "Operator_GetRestriction(Operator self) -> Operator"}, + { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "Operator_GetOutputProlongation(Operator self) -> Operator"}, + { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "Operator_GetOutputRestriction(Operator self) -> Operator"}, { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "Operator_FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "Operator_FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "Operator_RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "Operator_FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "Operator_FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "Operator_FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, { "Operator_GetType", _wrap_Operator_GetType, METH_O, "Operator_GetType(Operator self) -> mfem::Operator::Type"}, { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" @@ -11258,16 +14459,38 @@ static PyMethodDef SwigMethods[] = { { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "TimeDependentOperator_isExplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "TimeDependentOperator_isImplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "TimeDependentOperator_isHomogeneous(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "TimeDependentOperator_GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, + { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "TimeDependentOperator_SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "TimeDependentOperator_ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "TimeDependentOperator_ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "TimeDependentOperator_Mult(TimeDependentOperator self, Vector x, Vector y)"}, { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "TimeDependentOperator_ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "TimeDependentOperator_GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "TimeDependentOperator_GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "TimeDependentOperator_SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "TimeDependentOperator_SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "TimeDependentOperator_SUNMassSetup(TimeDependentOperator self) -> int"}, + { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "TimeDependentOperator_SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "TimeDependentOperator_SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, + { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + ""}, + { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator_Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" + "SecondOrderTimeDependentOperator_Mult(SecondOrderTimeDependentOperator self, Vector x, Vector dxdt, Vector y)\n" + ""}, + { "SecondOrderTimeDependentOperator_ImplicitSolve", _wrap_SecondOrderTimeDependentOperator_ImplicitSolve, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator_ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt, Vector x, Vector k)\n" + "SecondOrderTimeDependentOperator_ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt0, double const dt1, Vector x, Vector dxdt, Vector k)\n" + ""}, + { "delete_SecondOrderTimeDependentOperator", _wrap_delete_SecondOrderTimeDependentOperator, METH_O, "delete_SecondOrderTimeDependentOperator(SecondOrderTimeDependentOperator self)"}, + { "SecondOrderTimeDependentOperator_swigregister", SecondOrderTimeDependentOperator_swigregister, METH_O, NULL}, + { "SecondOrderTimeDependentOperator_swiginit", SecondOrderTimeDependentOperator_swiginit, METH_VARARGS, NULL}, { "Solver_iterative_mode_set", _wrap_Solver_iterative_mode_set, METH_VARARGS, "Solver_iterative_mode_set(Solver self, bool iterative_mode)"}, { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" @@ -11285,6 +14508,12 @@ static PyMethodDef SwigMethods[] = { { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, + { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "ScaledOperator_Mult(ScaledOperator self, Vector x, Vector y)"}, + { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, + { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, + { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, { "new_TransposeOperator", _wrap_new_TransposeOperator, METH_VARARGS, "\n" "TransposeOperator(Operator a)\n" "new_TransposeOperator(Operator a) -> TransposeOperator\n" @@ -11321,6 +14550,13 @@ static PyMethodDef SwigMethods[] = { { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, + { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "RectangularConstrainedOperator_GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, + { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "RectangularConstrainedOperator_EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "RectangularConstrainedOperator_Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, + { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, + { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, { "new_PyOperatorBase", _wrap_new_PyOperatorBase, METH_VARARGS, "\n" "PyOperatorBase(int s=0)\n" "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" @@ -11345,6 +14581,167 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" + "Operator(int s=0)\n" + "new_Operator(PyObject * _self, int h, int w) -> Operator\n" + ""}, + { "Operator_Height", _wrap_Operator_Height, METH_O, "Height(Operator self) -> int"}, + { "Operator_NumRows", _wrap_Operator_NumRows, METH_O, "NumRows(Operator self) -> int"}, + { "Operator_Width", _wrap_Operator_Width, METH_O, "Width(Operator self) -> int"}, + { "Operator_NumCols", _wrap_Operator_NumCols, METH_O, "NumCols(Operator self) -> int"}, + { "Operator_GetMemoryClass", _wrap_Operator_GetMemoryClass, METH_O, "GetMemoryClass(Operator self) -> mfem::MemoryClass"}, + { "Operator_Mult", _wrap_Operator_Mult, METH_VARARGS, "Mult(Operator self, Vector x, Vector y)"}, + { "Operator_MultTranspose", _wrap_Operator_MultTranspose, METH_VARARGS, "MultTranspose(Operator self, Vector x, Vector y)"}, + { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "GetGradient(Operator self, Vector x) -> Operator"}, + { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "GetProlongation(Operator self) -> Operator"}, + { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "GetRestriction(Operator self) -> Operator"}, + { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "GetOutputProlongation(Operator self) -> Operator"}, + { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "GetOutputRestriction(Operator self) -> Operator"}, + { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, + { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, + { "Operator_GetType", _wrap_Operator_GetType, METH_O, "GetType(Operator self) -> mfem::Operator::Type"}, + { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(Operator self, std::ostream & out, int n=0, int m=0)\n" + "PrintMatlab(Operator self, char const * file, int precision=8)\n" + ""}, + { "disown_Operator", _wrap_disown_Operator, METH_O, NULL}, + { "Operator_swigregister", Operator_swigregister, METH_O, NULL}, + { "Operator_swiginit", Operator_swiginit, METH_VARARGS, NULL}, + { "new_TimeDependentOperator", _wrap_new_TimeDependentOperator, METH_VARARGS, "\n" + "TimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "TimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + ""}, + { "TimeDependentOperator_GetTime", _wrap_TimeDependentOperator_GetTime, METH_O, "GetTime(TimeDependentOperator self) -> double"}, + { "TimeDependentOperator_SetTime", _wrap_TimeDependentOperator_SetTime, METH_VARARGS, "SetTime(TimeDependentOperator self, double const _t)"}, + { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "isExplicit(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "isImplicit(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "isHomogeneous(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, + { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, + { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, + { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "Mult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, + { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, + { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "SUNMassSetup(TimeDependentOperator self) -> int"}, + { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, + { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, + { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, + { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, + { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, + { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + ""}, + { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" + "Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" + "Mult(SecondOrderTimeDependentOperator self, Vector x, Vector dxdt, Vector y)\n" + ""}, + { "SecondOrderTimeDependentOperator_ImplicitSolve", _wrap_SecondOrderTimeDependentOperator_ImplicitSolve, METH_VARARGS, "\n" + "ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt, Vector x, Vector k)\n" + "ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt0, double const dt1, Vector x, Vector dxdt, Vector k)\n" + ""}, + { "delete_SecondOrderTimeDependentOperator", _wrap_delete_SecondOrderTimeDependentOperator, METH_O, "delete_SecondOrderTimeDependentOperator(SecondOrderTimeDependentOperator self)"}, + { "SecondOrderTimeDependentOperator_swigregister", SecondOrderTimeDependentOperator_swigregister, METH_O, NULL}, + { "SecondOrderTimeDependentOperator_swiginit", SecondOrderTimeDependentOperator_swiginit, METH_VARARGS, NULL}, + { "Solver_iterative_mode_set", _wrap_Solver_iterative_mode_set, METH_VARARGS, "Solver_iterative_mode_set(Solver self, bool iterative_mode)"}, + { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, + { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" + "Solver(int s=0, bool iter_mode=False)\n" + "Solver(int h, int w, bool iter_mode=False)\n" + ""}, + { "Solver_SetOperator", _wrap_Solver_SetOperator, METH_VARARGS, "SetOperator(Solver self, Operator op)"}, + { "delete_Solver", _wrap_delete_Solver, METH_O, "delete_Solver(Solver self)"}, + { "disown_Solver", _wrap_disown_Solver, METH_O, NULL}, + { "Solver_swigregister", Solver_swigregister, METH_O, NULL}, + { "Solver_swiginit", Solver_swiginit, METH_VARARGS, NULL}, + { "new_IdentityOperator", _wrap_new_IdentityOperator, METH_O, "new_IdentityOperator(int n) -> IdentityOperator"}, + { "IdentityOperator_Mult", _wrap_IdentityOperator_Mult, METH_VARARGS, "Mult(IdentityOperator self, Vector x, Vector y)"}, + { "IdentityOperator_MultTranspose", _wrap_IdentityOperator_MultTranspose, METH_VARARGS, "MultTranspose(IdentityOperator self, Vector x, Vector y)"}, + { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, + { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, + { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, + { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "Mult(ScaledOperator self, Vector x, Vector y)"}, + { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, + { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, + { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, + { "new_TransposeOperator", _wrap_new_TransposeOperator, METH_VARARGS, "\n" + "TransposeOperator(Operator a)\n" + "new_TransposeOperator(Operator a) -> TransposeOperator\n" + ""}, + { "TransposeOperator_Mult", _wrap_TransposeOperator_Mult, METH_VARARGS, "Mult(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_MultTranspose", _wrap_TransposeOperator_MultTranspose, METH_VARARGS, "MultTranspose(TransposeOperator self, Vector x, Vector y)"}, + { "delete_TransposeOperator", _wrap_delete_TransposeOperator, METH_O, "delete_TransposeOperator(TransposeOperator self)"}, + { "TransposeOperator_swigregister", TransposeOperator_swigregister, METH_O, NULL}, + { "TransposeOperator_swiginit", TransposeOperator_swiginit, METH_VARARGS, NULL}, + { "new_ProductOperator", _wrap_new_ProductOperator, METH_VARARGS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, + { "ProductOperator_Mult", _wrap_ProductOperator_Mult, METH_VARARGS, "Mult(ProductOperator self, Vector x, Vector y)"}, + { "ProductOperator_MultTranspose", _wrap_ProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(ProductOperator self, Vector x, Vector y)"}, + { "delete_ProductOperator", _wrap_delete_ProductOperator, METH_O, "delete_ProductOperator(ProductOperator self)"}, + { "ProductOperator_swigregister", ProductOperator_swigregister, METH_O, NULL}, + { "ProductOperator_swiginit", ProductOperator_swiginit, METH_VARARGS, NULL}, + { "new_RAPOperator", _wrap_new_RAPOperator, METH_VARARGS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, + { "RAPOperator_GetMemoryClass", _wrap_RAPOperator_GetMemoryClass, METH_O, "GetMemoryClass(RAPOperator self) -> mfem::MemoryClass"}, + { "RAPOperator_Mult", _wrap_RAPOperator_Mult, METH_VARARGS, "Mult(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_MultTranspose", _wrap_RAPOperator_MultTranspose, METH_VARARGS, "MultTranspose(RAPOperator self, Vector x, Vector y)"}, + { "delete_RAPOperator", _wrap_delete_RAPOperator, METH_O, "delete_RAPOperator(RAPOperator self)"}, + { "RAPOperator_swigregister", RAPOperator_swigregister, METH_O, NULL}, + { "RAPOperator_swiginit", RAPOperator_swiginit, METH_VARARGS, NULL}, + { "new_TripleProductOperator", _wrap_new_TripleProductOperator, METH_VARARGS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, + { "TripleProductOperator_GetMemoryClass", _wrap_TripleProductOperator_GetMemoryClass, METH_O, "GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass"}, + { "TripleProductOperator_Mult", _wrap_TripleProductOperator_Mult, METH_VARARGS, "Mult(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_MultTranspose", _wrap_TripleProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, + { "delete_TripleProductOperator", _wrap_delete_TripleProductOperator, METH_O, "delete_TripleProductOperator(TripleProductOperator self)"}, + { "TripleProductOperator_swigregister", TripleProductOperator_swigregister, METH_O, NULL}, + { "TripleProductOperator_swiginit", TripleProductOperator_swiginit, METH_VARARGS, NULL}, + { "new_ConstrainedOperator", _wrap_new_ConstrainedOperator, METH_VARARGS, "ConstrainedOperator(Operator A, intArray list, bool own_A=False)"}, + { "ConstrainedOperator_GetMemoryClass", _wrap_ConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass"}, + { "ConstrainedOperator_EliminateRHS", _wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, + { "ConstrainedOperator_Mult", _wrap_ConstrainedOperator_Mult, METH_VARARGS, "Mult(ConstrainedOperator self, Vector x, Vector y)"}, + { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, + { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, + { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, + { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, + { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, + { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, + { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, + { "new_PyOperatorBase", _wrap_new_PyOperatorBase, METH_VARARGS, "\n" + "PyOperatorBase(int s=0)\n" + "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" + ""}, + { "PyOperatorBase_Mult", _wrap_PyOperatorBase_Mult, METH_VARARGS, "Mult(PyOperatorBase self, Vector x, Vector y)"}, + { "PyOperatorBase__EvalMult", _wrap_PyOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, + { "delete_PyOperatorBase", _wrap_delete_PyOperatorBase, METH_O, "delete_PyOperatorBase(PyOperatorBase self)"}, + { "disown_PyOperatorBase", _wrap_disown_PyOperatorBase, METH_O, NULL}, + { "PyOperatorBase_swigregister", PyOperatorBase_swigregister, METH_O, NULL}, + { "PyOperatorBase_swiginit", PyOperatorBase_swiginit, METH_VARARGS, NULL}, + { "new_PyTimeDependentOperatorBase", _wrap_new_PyTimeDependentOperatorBase, METH_VARARGS, "\n" + "PyTimeDependentOperatorBase(int n=0, double _t=0.0)\n" + "PyTimeDependentOperatorBase(int h, int w, double _t=0.0)\n" + ""}, + { "PyTimeDependentOperatorBase_Mult", _wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS, "Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, + { "PyTimeDependentOperatorBase__EvalMult", _wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, + { "delete_PyTimeDependentOperatorBase", _wrap_delete_PyTimeDependentOperatorBase, METH_O, "delete_PyTimeDependentOperatorBase(PyTimeDependentOperatorBase self)"}, + { "disown_PyTimeDependentOperatorBase", _wrap_disown_PyTimeDependentOperatorBase, METH_O, NULL}, + { "PyTimeDependentOperatorBase_swigregister", PyTimeDependentOperatorBase_swigregister, METH_O, NULL}, + { "PyTimeDependentOperatorBase_swiginit", PyTimeDependentOperatorBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -11357,9 +14754,15 @@ static void *_p_p_mfem__SolverTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM static void *_p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TimeDependentOperator **) x)); } +static void *_p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator **) x)); +} static void *_p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::IdentityOperator **) x)); } +static void *_p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::ScaledOperator **) x)); +} static void *_p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TransposeOperator **) x)); } @@ -11375,6 +14778,9 @@ static void *_p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator(void *x, int static void *_p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::ConstrainedOperator **) x)); } +static void *_p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::RectangularConstrainedOperator **) x)); +} static void *_p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::PyOperatorBase **) x)); } @@ -11387,9 +14793,15 @@ static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(new static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } @@ -11405,17 +14817,24 @@ static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWI static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); } static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", "mfem::ConstrainedOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", "mfem::IdentityOperator *", 0, 0, (void*)0, 0}; @@ -11424,26 +14843,33 @@ static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperat static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", "mfem::PyOperatorBase *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", "mfem::PyTimeDependentOperatorBase *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", "mfem::RAPOperator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", "mfem::RectangularConstrainedOperator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", "mfem::ScaledOperator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", "mfem::SecondOrderTimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", "mfem::TimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", "mfem::TransposeOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", "mfem::TripleProductOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__Operator = {"_p_p_mfem__Operator", "mfem::Operator **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_mfem__PyOperatorBase = {"_p_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__PyTimeDependentOperatorBase = {"_p_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__Solver = {"_p_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TimeDependentOperator = {"_p_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__SecondOrderTimeDependentOperator = {"_p_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__IdentityOperator = {"_p_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__ScaledOperator = {"_p_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TransposeOperator = {"_p_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ProductOperator = {"_p_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__RAPOperator = {"_p_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TripleProductOperator = {"_p_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ConstrainedOperator = {"_p_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_p_mfem__PyOperatorBase = {"_p_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_p_mfem__PyTimeDependentOperatorBase = {"_p_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__RectangularConstrainedOperator = {"_p_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, &_swigt__p_char, + &_swigt__p_int, &_swigt__p_mfem__ArrayT_int_t, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__IdentityOperator, @@ -11452,6 +14878,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, @@ -11464,6 +14893,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_p_mfem__PyOperatorBase, &_swigt__p_p_mfem__PyTimeDependentOperatorBase, &_swigt__p_p_mfem__RAPOperator, + &_swigt__p_p_mfem__RectangularConstrainedOperator, + &_swigt__p_p_mfem__ScaledOperator, + &_swigt__p_p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_p_mfem__Solver, &_swigt__p_p_mfem__TimeDependentOperator, &_swigt__p_p_mfem__TransposeOperator, @@ -11472,34 +14904,42 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = { {&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = { {&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = { {&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = { {&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = { {&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = { {&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = { {&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = { {&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = { {&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = { {&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__PyOperatorBase[] = {{&_swigt__p_p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Solver[] = {{&_swigt__p_p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TimeDependentOperator[] = {{&_swigt__p_p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__IdentityOperator[] = {{&_swigt__p_p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__ScaledOperator[] = {{&_swigt__p_p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TransposeOperator[] = {{&_swigt__p_p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ProductOperator[] = {{&_swigt__p_p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__RAPOperator[] = {{&_swigt__p_p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TripleProductOperator[] = {{&_swigt__p_p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ConstrainedOperator[] = {{&_swigt__p_p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__PyOperatorBase[] = {{&_swigt__p_p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, _p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ScaledOperator, _p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RectangularConstrainedOperator, _p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, _swigc__p_char, + _swigc__p_int, _swigc__p_mfem__ArrayT_int_t, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__IdentityOperator, @@ -11508,6 +14948,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, @@ -11520,6 +14963,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_p_mfem__PyOperatorBase, _swigc__p_p_mfem__PyTimeDependentOperatorBase, _swigc__p_p_mfem__RAPOperator, + _swigc__p_p_mfem__RectangularConstrainedOperator, + _swigc__p_p_mfem__ScaledOperator, + _swigc__p_p_mfem__SecondOrderTimeDependentOperator, _swigc__p_p_mfem__Solver, _swigc__p_p_mfem__TimeDependentOperator, _swigc__p_p_mfem__TransposeOperator, @@ -12265,9 +15711,15 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Operator_PETSC_MATNEST",SWIG_From_int(static_cast< int >(mfem::Operator::PETSC_MATNEST))); SWIG_Python_SetConstant(d, "Operator_PETSC_MATHYPRE",SWIG_From_int(static_cast< int >(mfem::Operator::PETSC_MATHYPRE))); SWIG_Python_SetConstant(d, "Operator_PETSC_MATGENERIC",SWIG_From_int(static_cast< int >(mfem::Operator::PETSC_MATGENERIC))); + SWIG_Python_SetConstant(d, "Operator_Complex_Operator",SWIG_From_int(static_cast< int >(mfem::Operator::Complex_Operator))); + SWIG_Python_SetConstant(d, "Operator_MFEM_ComplexSparseMat",SWIG_From_int(static_cast< int >(mfem::Operator::MFEM_ComplexSparseMat))); + SWIG_Python_SetConstant(d, "Operator_Complex_Hypre_ParCSR",SWIG_From_int(static_cast< int >(mfem::Operator::Complex_Hypre_ParCSR))); SWIG_Python_SetConstant(d, "TimeDependentOperator_EXPLICIT",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::EXPLICIT))); SWIG_Python_SetConstant(d, "TimeDependentOperator_IMPLICIT",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::IMPLICIT))); SWIG_Python_SetConstant(d, "TimeDependentOperator_HOMOGENEOUS",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::HOMOGENEOUS))); + SWIG_Python_SetConstant(d, "TimeDependentOperator_NORMAL",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::NORMAL))); + SWIG_Python_SetConstant(d, "TimeDependentOperator_ADDITIVE_TERM_1",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::ADDITIVE_TERM_1))); + SWIG_Python_SetConstant(d, "TimeDependentOperator_ADDITIVE_TERM_2",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::ADDITIVE_TERM_2))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/operators_wrap.h b/mfem/_par/operators_wrap.h index ff187fbf..5ceff3f2 100644 --- a/mfem/_par/operators_wrap.h +++ b/mfem/_par/operators_wrap.h @@ -26,6 +26,8 @@ class SwigDirector_Operator : public mfem::Operator, public Swig::Director { virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_Operator(); @@ -58,7 +60,7 @@ class SwigDirector_Operator : public mfem::Operator, public Swig::Director { return method; } private: - mutable swig::SwigVar_PyObject vtable[7]; + mutable swig::SwigVar_PyObject vtable[9]; #endif }; @@ -75,15 +77,23 @@ class SwigDirector_TimeDependentOperator : public mfem::TimeDependentOperator, p virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_TimeDependentOperator(); virtual double GetTime() const; virtual void SetTime(double const _t); + virtual void SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode); virtual void ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const; virtual void ImplicitMult(mfem::Vector const &x, mfem::Vector const &k, mfem::Vector &y) const; virtual void ImplicitSolve(double const dt, mfem::Vector const &x, mfem::Vector &k); virtual mfem::Operator &GetImplicitGradient(mfem::Vector const &x, mfem::Vector const &k, double shift) const; virtual mfem::Operator &GetExplicitGradient(mfem::Vector const &x) const; + virtual int SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma); + virtual int SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassSetup(); + virtual int SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassMult(mfem::Vector const &x, mfem::Vector &v); /* Internal director utilities */ public: @@ -114,7 +124,7 @@ class SwigDirector_TimeDependentOperator : public mfem::TimeDependentOperator, p return method; } private: - mutable swig::SwigVar_PyObject vtable[14]; + mutable swig::SwigVar_PyObject vtable[22]; #endif }; @@ -131,6 +141,8 @@ class SwigDirector_Solver : public mfem::Solver, public Swig::Director { virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_Solver(); virtual void SetOperator(mfem::Operator const &op); @@ -164,7 +176,7 @@ class SwigDirector_Solver : public mfem::Solver, public Swig::Director { return method; } private: - mutable swig::SwigVar_PyObject vtable[8]; + mutable swig::SwigVar_PyObject vtable[10]; #endif }; @@ -181,6 +193,8 @@ class SwigDirector_PyOperatorBase : public mfem::PyOperatorBase, public Swig::Di virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_PyOperatorBase(); virtual mfem::Vector &_EvalMult(mfem::Vector const &arg0) const; @@ -214,7 +228,7 @@ class SwigDirector_PyOperatorBase : public mfem::PyOperatorBase, public Swig::Di return method; } private: - mutable swig::SwigVar_PyObject vtable[8]; + mutable swig::SwigVar_PyObject vtable[10]; #endif }; @@ -231,15 +245,23 @@ class SwigDirector_PyTimeDependentOperatorBase : public mfem::PyTimeDependentOpe virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_PyTimeDependentOperatorBase(); virtual double GetTime() const; virtual void SetTime(double const _t); + virtual void SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode); virtual void ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const; virtual void ImplicitMult(mfem::Vector const &x, mfem::Vector const &k, mfem::Vector &y) const; virtual void ImplicitSolve(double const dt, mfem::Vector const &x, mfem::Vector &k); virtual mfem::Operator &GetImplicitGradient(mfem::Vector const &x, mfem::Vector const &k, double shift) const; virtual mfem::Operator &GetExplicitGradient(mfem::Vector const &x) const; + virtual int SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma); + virtual int SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassSetup(); + virtual int SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassMult(mfem::Vector const &x, mfem::Vector &v); virtual mfem::Vector &_EvalMult(mfem::Vector const &arg0) const; /* Internal director utilities */ @@ -271,7 +293,7 @@ class SwigDirector_PyTimeDependentOperatorBase : public mfem::PyTimeDependentOpe return method; } private: - mutable swig::SwigVar_PyObject vtable[15]; + mutable swig::SwigVar_PyObject vtable[23]; #endif }; diff --git a/mfem/_par/ostream_typemap.py b/mfem/_par/ostream_typemap.py index b2139007..8aa920ec 100644 --- a/mfem/_par/ostream_typemap.py +++ b/mfem/_par/ostream_typemap.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _ostream_typemap.SWIG_PyInstanceMethod_New +_swig_new_static_method = _ostream_typemap.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() diff --git a/mfem/_par/ostream_typemap_wrap.cxx b/mfem/_par/ostream_typemap_wrap.cxx index a3a0709b..7641861b 100644 --- a/mfem/_par/ostream_typemap_wrap.cxx +++ b/mfem/_par/ostream_typemap_wrap.cxx @@ -2767,10 +2767,13 @@ extern "C" { #endif static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/pbilinearform.py b/mfem/_par/pbilinearform.py index c092c41f..0791742f 100644 --- a/mfem/_par/pbilinearform.py +++ b/mfem/_par/pbilinearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _pbilinearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _pbilinearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -93,6 +96,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -102,6 +106,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.fe_coll import mfem._par.lininteg import mfem._par.linearform +import mfem._par.restriction import mfem._par.pfespace import mfem._par.pmesh import mfem._par.pncmesh @@ -123,14 +128,17 @@ def __init__(self, *args): def KeepNbrBlock(self, knb=True): r"""KeepNbrBlock(ParBilinearForm self, bool knb=True)""" return _pbilinearform.ParBilinearForm_KeepNbrBlock(self, knb) + KeepNbrBlock = _swig_new_instance_method(_pbilinearform.ParBilinearForm_KeepNbrBlock) def SetOperatorType(self, tid): r"""SetOperatorType(ParBilinearForm self, mfem::Operator::Type tid)""" return _pbilinearform.ParBilinearForm_SetOperatorType(self, tid) + SetOperatorType = _swig_new_instance_method(_pbilinearform.ParBilinearForm_SetOperatorType) def Assemble(self, skip_zeros=1): r"""Assemble(ParBilinearForm self, int skip_zeros=1)""" return _pbilinearform.ParBilinearForm_Assemble(self, skip_zeros) + Assemble = _swig_new_instance_method(_pbilinearform.ParBilinearForm_Assemble) def ParallelAssembleElim(self, *args): r""" @@ -138,6 +146,7 @@ def ParallelAssembleElim(self, *args): ParallelAssembleElim(ParBilinearForm self, OperatorHandle A_elim) """ return _pbilinearform.ParBilinearForm_ParallelAssembleElim(self, *args) + ParallelAssembleElim = _swig_new_instance_method(_pbilinearform.ParBilinearForm_ParallelAssembleElim) def ParallelAssemble(self, *args): r""" @@ -147,6 +156,7 @@ def ParallelAssemble(self, *args): ParallelAssemble(ParBilinearForm self, OperatorHandle A, SparseMatrix A_local) """ return _pbilinearform.ParBilinearForm_ParallelAssemble(self, *args) + ParallelAssemble = _swig_new_instance_method(_pbilinearform.ParBilinearForm_ParallelAssemble) def ParallelEliminateEssentialBC(self, *args): r""" @@ -154,38 +164,47 @@ def ParallelEliminateEssentialBC(self, *args): ParallelEliminateEssentialBC(ParBilinearForm self, intArray bdr_attr_is_ess, HypreParMatrix A) -> HypreParMatrix """ return _pbilinearform.ParBilinearForm_ParallelEliminateEssentialBC(self, *args) + ParallelEliminateEssentialBC = _swig_new_instance_method(_pbilinearform.ParBilinearForm_ParallelEliminateEssentialBC) def ParallelEliminateTDofs(self, tdofs_list, A): r"""ParallelEliminateTDofs(ParBilinearForm self, intArray tdofs_list, HypreParMatrix A) -> HypreParMatrix""" return _pbilinearform.ParBilinearForm_ParallelEliminateTDofs(self, tdofs_list, A) + ParallelEliminateTDofs = _swig_new_instance_method(_pbilinearform.ParBilinearForm_ParallelEliminateTDofs) def TrueAddMult(self, x, y, a=1.0): r"""TrueAddMult(ParBilinearForm self, Vector x, Vector y, double const a=1.0)""" return _pbilinearform.ParBilinearForm_TrueAddMult(self, x, y, a) + TrueAddMult = _swig_new_instance_method(_pbilinearform.ParBilinearForm_TrueAddMult) def ParFESpace(self): r"""ParFESpace(ParBilinearForm self) -> ParFiniteElementSpace""" return _pbilinearform.ParBilinearForm_ParFESpace(self) + ParFESpace = _swig_new_instance_method(_pbilinearform.ParBilinearForm_ParFESpace) def SCParFESpace(self): r"""SCParFESpace(ParBilinearForm self) -> ParFiniteElementSpace""" return _pbilinearform.ParBilinearForm_SCParFESpace(self) + SCParFESpace = _swig_new_instance_method(_pbilinearform.ParBilinearForm_SCParFESpace) def GetProlongation(self): r"""GetProlongation(ParBilinearForm self) -> Operator""" return _pbilinearform.ParBilinearForm_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_pbilinearform.ParBilinearForm_GetProlongation) def GetRestriction(self): r"""GetRestriction(ParBilinearForm self) -> Operator""" return _pbilinearform.ParBilinearForm_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_pbilinearform.ParBilinearForm_GetRestriction) def RecoverFEMSolution(self, X, b, x): r"""RecoverFEMSolution(ParBilinearForm self, Vector X, Vector b, Vector x)""" return _pbilinearform.ParBilinearForm_RecoverFEMSolution(self, X, b, x) + RecoverFEMSolution = _swig_new_instance_method(_pbilinearform.ParBilinearForm_RecoverFEMSolution) def Update(self, nfes=None): r"""Update(ParBilinearForm self, FiniteElementSpace nfes=None)""" return _pbilinearform.ParBilinearForm_Update(self, nfes) + Update = _swig_new_instance_method(_pbilinearform.ParBilinearForm_Update) __swig_destroy__ = _pbilinearform.delete_ParBilinearForm def FormLinearSystem(self, *args): @@ -196,6 +215,7 @@ def FormLinearSystem(self, *args): FormLinearSystem(ParBilinearForm self, intArray ess_tdof_list, Vector x, Vector b, HypreParMatrix A, Vector X, Vector B, int copy_interior=0) """ return _pbilinearform.ParBilinearForm_FormLinearSystem(self, *args) + FormLinearSystem = _swig_new_instance_method(_pbilinearform.ParBilinearForm_FormLinearSystem) def FormSystemMatrix(self, *args): r""" @@ -205,6 +225,7 @@ def FormSystemMatrix(self, *args): FormSystemMatrix(ParBilinearForm self, intArray ess_tdof_list, HypreParMatrix A) """ return _pbilinearform.ParBilinearForm_FormSystemMatrix(self, *args) + FormSystemMatrix = _swig_new_instance_method(_pbilinearform.ParBilinearForm_FormSystemMatrix) # Register ParBilinearForm in _pbilinearform: _pbilinearform.ParBilinearForm_swigregister(ParBilinearForm) @@ -228,10 +249,22 @@ def ParallelAssemble(self, *args): ParallelAssemble(ParMixedBilinearForm self, OperatorHandle A) """ return _pbilinearform.ParMixedBilinearForm_ParallelAssemble(self, *args) + ParallelAssemble = _swig_new_instance_method(_pbilinearform.ParMixedBilinearForm_ParallelAssemble) + + def FormRectangularSystemMatrix(self, trial_tdof_list, test_tdof_list, A): + r"""FormRectangularSystemMatrix(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)""" + return _pbilinearform.ParMixedBilinearForm_FormRectangularSystemMatrix(self, trial_tdof_list, test_tdof_list, A) + FormRectangularSystemMatrix = _swig_new_instance_method(_pbilinearform.ParMixedBilinearForm_FormRectangularSystemMatrix) + + def FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B): + r"""FormRectangularLinearSystem(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)""" + return _pbilinearform.ParMixedBilinearForm_FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B) + FormRectangularLinearSystem = _swig_new_instance_method(_pbilinearform.ParMixedBilinearForm_FormRectangularLinearSystem) def TrueAddMult(self, x, y, a=1.0): r"""TrueAddMult(ParMixedBilinearForm self, Vector x, Vector y, double const a=1.0)""" return _pbilinearform.ParMixedBilinearForm_TrueAddMult(self, x, y, a) + TrueAddMult = _swig_new_instance_method(_pbilinearform.ParMixedBilinearForm_TrueAddMult) __swig_destroy__ = _pbilinearform.delete_ParMixedBilinearForm # Register ParMixedBilinearForm in _pbilinearform: @@ -250,10 +283,12 @@ def __init__(self, dfes, rfes): def ParallelAssemble(self): r"""ParallelAssemble(ParDiscreteLinearOperator self) -> HypreParMatrix""" return _pbilinearform.ParDiscreteLinearOperator_ParallelAssemble(self) + ParallelAssemble = _swig_new_instance_method(_pbilinearform.ParDiscreteLinearOperator_ParallelAssemble) def GetParBlocks(self, blocks): r"""GetParBlocks(ParDiscreteLinearOperator self, mfem::Array2D< mfem::HypreParMatrix * > & blocks)""" return _pbilinearform.ParDiscreteLinearOperator_GetParBlocks(self, blocks) + GetParBlocks = _swig_new_instance_method(_pbilinearform.ParDiscreteLinearOperator_GetParBlocks) __swig_destroy__ = _pbilinearform.delete_ParDiscreteLinearOperator # Register ParDiscreteLinearOperator in _pbilinearform: diff --git a/mfem/_par/pbilinearform_wrap.cxx b/mfem/_par/pbilinearform_wrap.cxx index 73945574..ba97e658 100644 --- a/mfem/_par/pbilinearform_wrap.cxx +++ b/mfem/_par/pbilinearform_wrap.cxx @@ -3069,65 +3069,73 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_hex_t swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[7] -#define SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] -#define SWIGTYPE_p_mfem__BilinearForm swig_types[10] -#define SWIGTYPE_p_mfem__ConformingProlongationOperator swig_types[11] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[12] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[13] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[14] -#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[15] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[16] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[17] -#define SWIGTYPE_p_mfem__GridFunction swig_types[18] -#define SWIGTYPE_p_mfem__HypreADS swig_types[19] -#define SWIGTYPE_p_mfem__HypreAMS swig_types[20] -#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[21] -#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[22] -#define SWIGTYPE_p_mfem__HypreEuclid swig_types[23] -#define SWIGTYPE_p_mfem__HypreGMRES swig_types[24] -#define SWIGTYPE_p_mfem__HypreIdentity swig_types[25] -#define SWIGTYPE_p_mfem__HyprePCG swig_types[26] -#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[27] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[28] -#define SWIGTYPE_p_mfem__HypreParaSails swig_types[29] -#define SWIGTYPE_p_mfem__HypreSmoother swig_types[30] -#define SWIGTYPE_p_mfem__HypreSolver swig_types[31] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[32] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[33] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[34] -#define SWIGTYPE_p_mfem__LinearForm swig_types[35] -#define SWIGTYPE_p_mfem__Matrix swig_types[36] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[37] -#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[38] -#define SWIGTYPE_p_mfem__Operator swig_types[39] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[40] -#define SWIGTYPE_p_mfem__ParBilinearForm swig_types[41] -#define SWIGTYPE_p_mfem__ParDiscreteLinearOperator swig_types[42] -#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[43] -#define SWIGTYPE_p_mfem__ParMixedBilinearForm swig_types[44] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[45] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[46] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[47] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[48] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[49] -#define SWIGTYPE_p_mfem__Solver swig_types[50] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[51] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[52] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[53] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[54] -#define SWIGTYPE_p_mfem__Vector swig_types[55] -#define SWIGTYPE_p_pri_t swig_types[56] -#define SWIGTYPE_p_quad_t swig_types[57] -#define SWIGTYPE_p_seg_t swig_types[58] -#define SWIGTYPE_p_tet_t swig_types[59] -#define SWIGTYPE_p_tri_t swig_types[60] -static swig_type_info *swig_types[62]; -static swig_module_info swig_module = {swig_types, 61, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_char swig_types[5] +#define SWIGTYPE_p_hex_t swig_types[6] +#define SWIGTYPE_p_int swig_types[7] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[8] +#define SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[10] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[11] +#define SWIGTYPE_p_mfem__ConformingProlongationOperator swig_types[12] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[13] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[14] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[15] +#define SWIGTYPE_p_mfem__DeviceConformingProlongationOperator swig_types[16] +#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[17] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[18] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[19] +#define SWIGTYPE_p_mfem__GridFunction swig_types[20] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[21] +#define SWIGTYPE_p_mfem__HypreADS swig_types[22] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[23] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[24] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[25] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[26] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[27] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[28] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[29] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[30] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[31] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[32] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[33] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[34] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[35] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[36] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[37] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[38] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[39] +#define SWIGTYPE_p_mfem__LinearForm swig_types[40] +#define SWIGTYPE_p_mfem__Matrix swig_types[41] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[42] +#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[43] +#define SWIGTYPE_p_mfem__Operator swig_types[44] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[45] +#define SWIGTYPE_p_mfem__ParBilinearForm swig_types[46] +#define SWIGTYPE_p_mfem__ParDiscreteLinearOperator swig_types[47] +#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[48] +#define SWIGTYPE_p_mfem__ParMixedBilinearForm swig_types[49] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[50] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[51] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[52] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[53] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[54] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[55] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[56] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[57] +#define SWIGTYPE_p_mfem__Solver swig_types[58] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[59] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[60] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[61] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[62] +#define SWIGTYPE_p_mfem__Vector swig_types[63] +#define SWIGTYPE_p_pri_t swig_types[64] +#define SWIGTYPE_p_quad_t swig_types[65] +#define SWIGTYPE_p_seg_t swig_types[66] +#define SWIGTYPE_p_tet_t swig_types[67] +#define SWIGTYPE_p_tri_t swig_types[68] +static swig_type_info *swig_types[70]; +static swig_module_info swig_module = {swig_types, 69, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -6207,6 +6215,172 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_ParallelAssemble(PyObject *self, } +SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::OperatorHandle *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "ParMixedBilinearForm_FormRectangularSystemMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "1"" of type '" "mfem::ParMixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::ParMixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); + } + arg4 = reinterpret_cast< mfem::OperatorHandle * >(argp4); + { + try { + (arg1)->FormRectangularSystemMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::OperatorHandle *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "ParMixedBilinearForm_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::ParMixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::ParMixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); + } + arg6 = reinterpret_cast< mfem::OperatorHandle * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + (arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; @@ -6561,6 +6735,7 @@ SWIGINTERN PyObject *ParDiscreteLinearOperator_swiginit(PyObject *SWIGUNUSEDPARM static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_ParBilinearForm", _wrap_new_ParBilinearForm, METH_VARARGS, "\n" "ParBilinearForm(ParFiniteElementSpace pf)\n" "new_ParBilinearForm(ParFiniteElementSpace pf, ParBilinearForm bf) -> ParBilinearForm\n" @@ -6613,6 +6788,8 @@ static PyMethodDef SwigMethods[] = { "ParMixedBilinearForm_ParallelAssemble(ParMixedBilinearForm self) -> HypreParMatrix\n" "ParMixedBilinearForm_ParallelAssemble(ParMixedBilinearForm self, OperatorHandle A)\n" ""}, + { "ParMixedBilinearForm_FormRectangularSystemMatrix", _wrap_ParMixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "ParMixedBilinearForm_FormRectangularSystemMatrix(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "ParMixedBilinearForm_FormRectangularLinearSystem", _wrap_ParMixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "ParMixedBilinearForm_FormRectangularLinearSystem(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, { "ParMixedBilinearForm_TrueAddMult", _wrap_ParMixedBilinearForm_TrueAddMult, METH_VARARGS, "ParMixedBilinearForm_TrueAddMult(ParMixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "delete_ParMixedBilinearForm", _wrap_delete_ParMixedBilinearForm, METH_O, "delete_ParMixedBilinearForm(ParMixedBilinearForm self)"}, { "ParMixedBilinearForm_swigregister", ParMixedBilinearForm_swigregister, METH_O, NULL}, @@ -6627,6 +6804,72 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ParBilinearForm", _wrap_new_ParBilinearForm, METH_VARARGS, "\n" + "ParBilinearForm(ParFiniteElementSpace pf)\n" + "new_ParBilinearForm(ParFiniteElementSpace pf, ParBilinearForm bf) -> ParBilinearForm\n" + ""}, + { "ParBilinearForm_KeepNbrBlock", _wrap_ParBilinearForm_KeepNbrBlock, METH_VARARGS, "KeepNbrBlock(ParBilinearForm self, bool knb=True)"}, + { "ParBilinearForm_SetOperatorType", _wrap_ParBilinearForm_SetOperatorType, METH_VARARGS, "SetOperatorType(ParBilinearForm self, mfem::Operator::Type tid)"}, + { "ParBilinearForm_Assemble", _wrap_ParBilinearForm_Assemble, METH_VARARGS, "Assemble(ParBilinearForm self, int skip_zeros=1)"}, + { "ParBilinearForm_ParallelAssembleElim", _wrap_ParBilinearForm_ParallelAssembleElim, METH_VARARGS, "\n" + "ParallelAssembleElim(ParBilinearForm self) -> HypreParMatrix\n" + "ParallelAssembleElim(ParBilinearForm self, OperatorHandle A_elim)\n" + ""}, + { "ParBilinearForm_ParallelAssemble", _wrap_ParBilinearForm_ParallelAssemble, METH_VARARGS, "\n" + "ParallelAssemble(ParBilinearForm self) -> HypreParMatrix\n" + "ParallelAssemble(ParBilinearForm self, SparseMatrix m) -> HypreParMatrix\n" + "ParallelAssemble(ParBilinearForm self, OperatorHandle A)\n" + "ParallelAssemble(ParBilinearForm self, OperatorHandle A, SparseMatrix A_local)\n" + ""}, + { "ParBilinearForm_ParallelEliminateEssentialBC", _wrap_ParBilinearForm_ParallelEliminateEssentialBC, METH_VARARGS, "\n" + "ParallelEliminateEssentialBC(ParBilinearForm self, intArray bdr_attr_is_ess, HypreParMatrix A, HypreParVector X, HypreParVector B)\n" + "ParallelEliminateEssentialBC(ParBilinearForm self, intArray bdr_attr_is_ess, HypreParMatrix A) -> HypreParMatrix\n" + ""}, + { "ParBilinearForm_ParallelEliminateTDofs", _wrap_ParBilinearForm_ParallelEliminateTDofs, METH_VARARGS, "ParallelEliminateTDofs(ParBilinearForm self, intArray tdofs_list, HypreParMatrix A) -> HypreParMatrix"}, + { "ParBilinearForm_TrueAddMult", _wrap_ParBilinearForm_TrueAddMult, METH_VARARGS, "TrueAddMult(ParBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "ParBilinearForm_ParFESpace", _wrap_ParBilinearForm_ParFESpace, METH_O, "ParFESpace(ParBilinearForm self) -> ParFiniteElementSpace"}, + { "ParBilinearForm_SCParFESpace", _wrap_ParBilinearForm_SCParFESpace, METH_O, "SCParFESpace(ParBilinearForm self) -> ParFiniteElementSpace"}, + { "ParBilinearForm_GetProlongation", _wrap_ParBilinearForm_GetProlongation, METH_O, "GetProlongation(ParBilinearForm self) -> Operator"}, + { "ParBilinearForm_GetRestriction", _wrap_ParBilinearForm_GetRestriction, METH_O, "GetRestriction(ParBilinearForm self) -> Operator"}, + { "ParBilinearForm_RecoverFEMSolution", _wrap_ParBilinearForm_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(ParBilinearForm self, Vector X, Vector b, Vector x)"}, + { "ParBilinearForm_Update", _wrap_ParBilinearForm_Update, METH_VARARGS, "Update(ParBilinearForm self, FiniteElementSpace nfes=None)"}, + { "delete_ParBilinearForm", _wrap_delete_ParBilinearForm, METH_O, "delete_ParBilinearForm(ParBilinearForm self)"}, + { "ParBilinearForm_FormLinearSystem", _wrap_ParBilinearForm_FormLinearSystem, METH_VARARGS, "\n" + "FormLinearSystem(ParBilinearForm self)\n" + "FormLinearSystem(ParBilinearForm self, intArray ess_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B, int copy_interior=0)\n" + "FormLinearSystem(ParBilinearForm self, intArray ess_tdof_list, Vector x, Vector b, SparseMatrix A, Vector X, Vector B, int copy_interior=0)\n" + "FormLinearSystem(ParBilinearForm self, intArray ess_tdof_list, Vector x, Vector b, HypreParMatrix A, Vector X, Vector B, int copy_interior=0)\n" + ""}, + { "ParBilinearForm_FormSystemMatrix", _wrap_ParBilinearForm_FormSystemMatrix, METH_VARARGS, "\n" + "FormSystemMatrix(ParBilinearForm self)\n" + "FormSystemMatrix(ParBilinearForm self, intArray ess_tdof_list, OperatorHandle A)\n" + "FormSystemMatrix(ParBilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" + "FormSystemMatrix(ParBilinearForm self, intArray ess_tdof_list, HypreParMatrix A)\n" + ""}, + { "ParBilinearForm_swigregister", ParBilinearForm_swigregister, METH_O, NULL}, + { "ParBilinearForm_swiginit", ParBilinearForm_swiginit, METH_VARARGS, NULL}, + { "new_ParMixedBilinearForm", _wrap_new_ParMixedBilinearForm, METH_VARARGS, "\n" + "ParMixedBilinearForm(ParFiniteElementSpace trial_fes, ParFiniteElementSpace test_fes)\n" + "new_ParMixedBilinearForm(ParFiniteElementSpace trial_fes, ParFiniteElementSpace test_fes, ParMixedBilinearForm mbf) -> ParMixedBilinearForm\n" + ""}, + { "ParMixedBilinearForm_ParallelAssemble", _wrap_ParMixedBilinearForm_ParallelAssemble, METH_VARARGS, "\n" + "ParallelAssemble(ParMixedBilinearForm self) -> HypreParMatrix\n" + "ParallelAssemble(ParMixedBilinearForm self, OperatorHandle A)\n" + ""}, + { "ParMixedBilinearForm_FormRectangularSystemMatrix", _wrap_ParMixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "FormRectangularSystemMatrix(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "ParMixedBilinearForm_FormRectangularLinearSystem", _wrap_ParMixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "ParMixedBilinearForm_TrueAddMult", _wrap_ParMixedBilinearForm_TrueAddMult, METH_VARARGS, "TrueAddMult(ParMixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "delete_ParMixedBilinearForm", _wrap_delete_ParMixedBilinearForm, METH_O, "delete_ParMixedBilinearForm(ParMixedBilinearForm self)"}, + { "ParMixedBilinearForm_swigregister", ParMixedBilinearForm_swigregister, METH_O, NULL}, + { "ParMixedBilinearForm_swiginit", ParMixedBilinearForm_swiginit, METH_VARARGS, NULL}, + { "new_ParDiscreteLinearOperator", _wrap_new_ParDiscreteLinearOperator, METH_VARARGS, "new_ParDiscreteLinearOperator(ParFiniteElementSpace dfes, ParFiniteElementSpace rfes) -> ParDiscreteLinearOperator"}, + { "ParDiscreteLinearOperator_ParallelAssemble", _wrap_ParDiscreteLinearOperator_ParallelAssemble, METH_O, "ParallelAssemble(ParDiscreteLinearOperator self) -> HypreParMatrix"}, + { "ParDiscreteLinearOperator_GetParBlocks", _wrap_ParDiscreteLinearOperator_GetParBlocks, METH_VARARGS, "GetParBlocks(ParDiscreteLinearOperator self, mfem::Array2D< mfem::HypreParMatrix * > & blocks)"}, + { "delete_ParDiscreteLinearOperator", _wrap_delete_ParDiscreteLinearOperator, METH_O, "delete_ParDiscreteLinearOperator(ParDiscreteLinearOperator self)"}, + { "ParDiscreteLinearOperator_swigregister", ParDiscreteLinearOperator_swigregister, METH_O, NULL}, + { "ParDiscreteLinearOperator_swiginit", ParDiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6651,26 +6894,26 @@ static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(n static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); -} static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); } +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +} static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); } static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); } -static void *_p_mfem__ParBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::BilinearForm *) ((mfem::ParBilinearForm *) x)); +static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); } static void *_p_mfem__MixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::MixedBilinearForm *) x)); } -static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); +static void *_p_mfem__ParBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::BilinearForm *) ((mfem::ParBilinearForm *) x)); } static void *_p_mfem__ParMixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::ParMixedBilinearForm *) x)); @@ -6681,18 +6924,18 @@ static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPAR static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); } -static void *_p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConformingProlongationOperator *) x)); -} -static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); -} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } @@ -6708,12 +6951,33 @@ static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWI static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); +} +static void *_p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConformingProlongationOperator *) x)); +} +static void *_p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::ConformingProlongationOperator *) ((mfem::DeviceConformingProlongationOperator *) x)); +} static void *_p_mfem__ParDiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *)(mfem::DiscreteLinearOperator *) ((mfem::ParDiscreteLinearOperator *) x)); } +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); } @@ -6802,6 +7066,7 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -6825,15 +7090,22 @@ static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ConformingProlongationOperator = {"_p_mfem__ConformingProlongationOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConformingProlongationOperator = {"_p_mfem__ConformingProlongationOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DeviceConformingProlongationOperator = {"_p_mfem__DeviceConformingProlongationOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; @@ -6865,6 +7137,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -6876,10 +7149,12 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__DenseMatrix, &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__DeviceConformingProlongationOperator, &_swigt__p_mfem__DiscreteLinearOperator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__HypreADS, &_swigt__p_mfem__HypreAMS, &_swigt__p_mfem__HypreBoomerAMG, @@ -6895,6 +7170,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__HypreSolver, &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2_FECollection, &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__Matrix, @@ -6911,6 +7188,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -6928,6 +7208,7 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -6950,15 +7231,22 @@ static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__Hypr static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ConformingProlongationOperator[] = {{&_swigt__p_mfem__ConformingProlongationOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConformingProlongationOperator[] = {{&_swigt__p_mfem__ConformingProlongationOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DeviceConformingProlongationOperator[] = {{&_swigt__p_mfem__DeviceConformingProlongationOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; @@ -6970,7 +7258,7 @@ static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0 static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParBilinearForm, _p_mfem__ParBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParMixedBilinearForm, _p_mfem__ParMixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConformingProlongationOperator, _p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParDiscreteLinearOperator, _p_mfem__ParDiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParBilinearForm, _p_mfem__ParBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParMixedBilinearForm, _p_mfem__ParMixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConformingProlongationOperator, _p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DeviceConformingProlongationOperator, _p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParDiscreteLinearOperator, _p_mfem__ParDiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParBilinearForm[] = { {&_swigt__p_mfem__ParBilinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParDiscreteLinearOperator[] = { {&_swigt__p_mfem__ParDiscreteLinearOperator, 0, 0, 0},{0, 0, 0, 0}}; @@ -6991,6 +7279,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -7002,10 +7291,12 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__DenseMatrix, _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__DeviceConformingProlongationOperator, _swigc__p_mfem__DiscreteLinearOperator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__GridFunction, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__HypreADS, _swigc__p_mfem__HypreAMS, _swigc__p_mfem__HypreBoomerAMG, @@ -7021,6 +7312,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__HypreSolver, _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2_FECollection, _swigc__p_mfem__LinearForm, _swigc__p_mfem__Matrix, @@ -7037,6 +7330,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, @@ -7777,18 +8073,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pfespace.i b/mfem/_par/pfespace.i index 17664fa0..713bbd9d 100644 --- a/mfem/_par/pfespace.i +++ b/mfem/_par/pfespace.i @@ -4,6 +4,8 @@ #include "config/config.hpp" #include "fem/linearform.hpp" #include "fem/pfespace.hpp" +#include "fem/restriction.hpp" +#include "fem/prestriction.hpp" #include "numpy/arrayobject.h" #include "pyoperator.hpp" %} @@ -40,6 +42,7 @@ import_array(); %import "fespace.i" %import "pmesh.i" %import "hypre.i" +%import "restriction.i" %import "../common/exception.i" %pointer_class(int, intp); diff --git a/mfem/_par/pfespace.py b/mfem/_par/pfespace.py index e35e8597..eeddf25d 100644 --- a/mfem/_par/pfespace.py +++ b/mfem/_par/pfespace.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _pfespace.SWIG_PyInstanceMethod_New +_swig_new_static_method = _pfespace.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -90,6 +93,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -101,6 +105,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.pmesh import mfem._par.pncmesh import mfem._par.communication @@ -129,42 +134,52 @@ def __init__(self, *args): def GetComm(self): r"""GetComm(ParFiniteElementSpace self) -> MPI_Comm""" return _pfespace.ParFiniteElementSpace_GetComm(self) + GetComm = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetComm) def GetNRanks(self): r"""GetNRanks(ParFiniteElementSpace self) -> int""" return _pfespace.ParFiniteElementSpace_GetNRanks(self) + GetNRanks = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetNRanks) def GetMyRank(self): r"""GetMyRank(ParFiniteElementSpace self) -> int""" return _pfespace.ParFiniteElementSpace_GetMyRank(self) + GetMyRank = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetMyRank) def GetParMesh(self): r"""GetParMesh(ParFiniteElementSpace self) -> ParMesh""" return _pfespace.ParFiniteElementSpace_GetParMesh(self) + GetParMesh = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetParMesh) def GetDofSign(self, i): r"""GetDofSign(ParFiniteElementSpace self, int i) -> int""" return _pfespace.ParFiniteElementSpace_GetDofSign(self, i) + GetDofSign = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetDofSign) def GetDofOffsets(self): r"""GetDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *""" return _pfespace.ParFiniteElementSpace_GetDofOffsets(self) + GetDofOffsets = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetDofOffsets) def GetTrueDofOffsets(self): r"""GetTrueDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *""" return _pfespace.ParFiniteElementSpace_GetTrueDofOffsets(self) + GetTrueDofOffsets = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetTrueDofOffsets) def GlobalVSize(self): r"""GlobalVSize(ParFiniteElementSpace self) -> HYPRE_Int""" return _pfespace.ParFiniteElementSpace_GlobalVSize(self) + GlobalVSize = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GlobalVSize) def GlobalTrueVSize(self): r"""GlobalTrueVSize(ParFiniteElementSpace self) -> HYPRE_Int""" return _pfespace.ParFiniteElementSpace_GlobalTrueVSize(self) + GlobalTrueVSize = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GlobalTrueVSize) def GetTrueVSize(self): r"""GetTrueVSize(ParFiniteElementSpace self) -> int""" return _pfespace.ParFiniteElementSpace_GetTrueVSize(self) + GetTrueVSize = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetTrueVSize) def GetElementDofs(self, i): from .array import intArray @@ -190,6 +205,11 @@ def GetFaceDofs(self, i): + def GetFaceRestriction(self, *args): + r"""GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator""" + return _pfespace.ParFiniteElementSpace_GetFaceRestriction(self, *args) + GetFaceRestriction = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceRestriction) + def GetSharedEdgeDofs(self, group, ei): from .array import intArray dofs = intArray() @@ -201,26 +221,32 @@ def GetSharedEdgeDofs(self, group, ei): def GetSharedTriangleDofs(self, group, fi, dofs): r"""GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)""" return _pfespace.ParFiniteElementSpace_GetSharedTriangleDofs(self, group, fi, dofs) + GetSharedTriangleDofs = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetSharedTriangleDofs) def GetSharedQuadrilateralDofs(self, group, fi, dofs): r"""GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)""" return _pfespace.ParFiniteElementSpace_GetSharedQuadrilateralDofs(self, group, fi, dofs) + GetSharedQuadrilateralDofs = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetSharedQuadrilateralDofs) def Dof_TrueDof_Matrix(self): r"""Dof_TrueDof_Matrix(ParFiniteElementSpace self) -> HypreParMatrix""" return _pfespace.ParFiniteElementSpace_Dof_TrueDof_Matrix(self) + Dof_TrueDof_Matrix = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_Dof_TrueDof_Matrix) def GetPartialConformingInterpolation(self): r"""GetPartialConformingInterpolation(ParFiniteElementSpace self) -> HypreParMatrix""" return _pfespace.ParFiniteElementSpace_GetPartialConformingInterpolation(self) + GetPartialConformingInterpolation = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetPartialConformingInterpolation) def NewTrueDofVector(self): r"""NewTrueDofVector(ParFiniteElementSpace self) -> HypreParVector""" return _pfespace.ParFiniteElementSpace_NewTrueDofVector(self) + NewTrueDofVector = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_NewTrueDofVector) def DivideByGroupSize(self, vec): r"""DivideByGroupSize(ParFiniteElementSpace self, double * vec)""" return _pfespace.ParFiniteElementSpace_DivideByGroupSize(self, vec) + DivideByGroupSize = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_DivideByGroupSize) def GroupComm(self, *args): r""" @@ -228,119 +254,148 @@ def GroupComm(self, *args): GroupComm(ParFiniteElementSpace self) -> GroupCommunicator """ return _pfespace.ParFiniteElementSpace_GroupComm(self, *args) + GroupComm = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GroupComm) def ScalarGroupComm(self): r"""ScalarGroupComm(ParFiniteElementSpace self) -> GroupCommunicator""" return _pfespace.ParFiniteElementSpace_ScalarGroupComm(self) + ScalarGroupComm = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_ScalarGroupComm) def Synchronize(self, ldof_marker): r"""Synchronize(ParFiniteElementSpace self, intArray ldof_marker)""" return _pfespace.ParFiniteElementSpace_Synchronize(self, ldof_marker) + Synchronize = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_Synchronize) def GetEssentialVDofs(self, bdr_attr_is_ess, ess_dofs, component=-1): r"""GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)""" return _pfespace.ParFiniteElementSpace_GetEssentialVDofs(self, bdr_attr_is_ess, ess_dofs, component) + GetEssentialVDofs = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetEssentialVDofs) def GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component=-1): r"""GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)""" return _pfespace.ParFiniteElementSpace_GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component) + GetEssentialTrueDofs = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetEssentialTrueDofs) def GetLocalTDofNumber(self, ldof): r"""GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int""" return _pfespace.ParFiniteElementSpace_GetLocalTDofNumber(self, ldof) + GetLocalTDofNumber = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetLocalTDofNumber) def GetGlobalTDofNumber(self, ldof): r"""GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int""" return _pfespace.ParFiniteElementSpace_GetGlobalTDofNumber(self, ldof) + GetGlobalTDofNumber = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetGlobalTDofNumber) def GetGlobalScalarTDofNumber(self, sldof): r"""GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int""" return _pfespace.ParFiniteElementSpace_GetGlobalScalarTDofNumber(self, sldof) + GetGlobalScalarTDofNumber = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetGlobalScalarTDofNumber) def GetMyDofOffset(self): r"""GetMyDofOffset(ParFiniteElementSpace self) -> HYPRE_Int""" return _pfespace.ParFiniteElementSpace_GetMyDofOffset(self) + GetMyDofOffset = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetMyDofOffset) def GetMyTDofOffset(self): r"""GetMyTDofOffset(ParFiniteElementSpace self) -> HYPRE_Int""" return _pfespace.ParFiniteElementSpace_GetMyTDofOffset(self) + GetMyTDofOffset = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetMyTDofOffset) def GetProlongationMatrix(self): r"""GetProlongationMatrix(ParFiniteElementSpace self) -> Operator""" return _pfespace.ParFiniteElementSpace_GetProlongationMatrix(self) + GetProlongationMatrix = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetProlongationMatrix) def GetRestrictionMatrix(self): r"""GetRestrictionMatrix(ParFiniteElementSpace self) -> SparseMatrix""" return _pfespace.ParFiniteElementSpace_GetRestrictionMatrix(self) + GetRestrictionMatrix = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetRestrictionMatrix) def ExchangeFaceNbrData(self): r"""ExchangeFaceNbrData(ParFiniteElementSpace self)""" return _pfespace.ParFiniteElementSpace_ExchangeFaceNbrData(self) + ExchangeFaceNbrData = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_ExchangeFaceNbrData) def GetFaceNbrVSize(self): r"""GetFaceNbrVSize(ParFiniteElementSpace self) -> int""" return _pfespace.ParFiniteElementSpace_GetFaceNbrVSize(self) + GetFaceNbrVSize = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceNbrVSize) def GetFaceNbrElementVDofs(self, i, vdofs): r"""GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)""" return _pfespace.ParFiniteElementSpace_GetFaceNbrElementVDofs(self, i, vdofs) + GetFaceNbrElementVDofs = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceNbrElementVDofs) def GetFaceNbrFaceVDofs(self, i, vdofs): r"""GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)""" return _pfespace.ParFiniteElementSpace_GetFaceNbrFaceVDofs(self, i, vdofs) + GetFaceNbrFaceVDofs = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceNbrFaceVDofs) def GetFaceNbrFE(self, i): r"""GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement""" return _pfespace.ParFiniteElementSpace_GetFaceNbrFE(self, i) + GetFaceNbrFE = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceNbrFE) def GetFaceNbrFaceFE(self, i): r"""GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement""" return _pfespace.ParFiniteElementSpace_GetFaceNbrFaceFE(self, i) + GetFaceNbrFaceFE = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceNbrFaceFE) def GetFaceNbrGlobalDofMap(self): r"""GetFaceNbrGlobalDofMap(ParFiniteElementSpace self) -> HYPRE_Int const *""" return _pfespace.ParFiniteElementSpace_GetFaceNbrGlobalDofMap(self) + GetFaceNbrGlobalDofMap = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceNbrGlobalDofMap) def Lose_Dof_TrueDof_Matrix(self): r"""Lose_Dof_TrueDof_Matrix(ParFiniteElementSpace self)""" return _pfespace.ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix(self) + Lose_Dof_TrueDof_Matrix = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix) def LoseDofOffsets(self): r"""LoseDofOffsets(ParFiniteElementSpace self)""" return _pfespace.ParFiniteElementSpace_LoseDofOffsets(self) + LoseDofOffsets = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_LoseDofOffsets) def LoseTrueDofOffsets(self): r"""LoseTrueDofOffsets(ParFiniteElementSpace self)""" return _pfespace.ParFiniteElementSpace_LoseTrueDofOffsets(self) + LoseTrueDofOffsets = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_LoseTrueDofOffsets) def Conforming(self): r"""Conforming(ParFiniteElementSpace self) -> bool""" return _pfespace.ParFiniteElementSpace_Conforming(self) + Conforming = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_Conforming) def Nonconforming(self): r"""Nonconforming(ParFiniteElementSpace self) -> bool""" return _pfespace.ParFiniteElementSpace_Nonconforming(self) + Nonconforming = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_Nonconforming) def GetTrueTransferOperator(self, coarse_fes, T): r"""GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)""" return _pfespace.ParFiniteElementSpace_GetTrueTransferOperator(self, coarse_fes, T) + GetTrueTransferOperator = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetTrueTransferOperator) def Update(self, want_transform=True): r"""Update(ParFiniteElementSpace self, bool want_transform=True)""" return _pfespace.ParFiniteElementSpace_Update(self, want_transform) + Update = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_Update) def UpdatesFinished(self): r"""UpdatesFinished(ParFiniteElementSpace self)""" return _pfespace.ParFiniteElementSpace_UpdatesFinished(self) + UpdatesFinished = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_UpdatesFinished) __swig_destroy__ = _pfespace.delete_ParFiniteElementSpace def PrintPartitionStats(self): r"""PrintPartitionStats(ParFiniteElementSpace self)""" return _pfespace.ParFiniteElementSpace_PrintPartitionStats(self) + PrintPartitionStats = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_PrintPartitionStats) def TrueVSize(self): r"""TrueVSize(ParFiniteElementSpace self) -> int""" return _pfespace.ParFiniteElementSpace_TrueVSize(self) + TrueVSize = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_TrueVSize) # Register ParFiniteElementSpace in _pfespace: _pfespace.ParFiniteElementSpace_swigregister(ParFiniteElementSpace) @@ -358,14 +413,40 @@ def __init__(self, pfes): def Mult(self, x, y): r"""Mult(ConformingProlongationOperator self, Vector x, Vector y)""" return _pfespace.ConformingProlongationOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_pfespace.ConformingProlongationOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)""" return _pfespace.ConformingProlongationOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_pfespace.ConformingProlongationOperator_MultTranspose) __swig_destroy__ = _pfespace.delete_ConformingProlongationOperator # Register ConformingProlongationOperator in _pfespace: _pfespace.ConformingProlongationOperator_swigregister(ConformingProlongationOperator) +class DeviceConformingProlongationOperator(ConformingProlongationOperator): + r"""Proxy of C++ mfem::DeviceConformingProlongationOperator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, pfes): + r"""__init__(DeviceConformingProlongationOperator self, ParFiniteElementSpace pfes) -> DeviceConformingProlongationOperator""" + _pfespace.DeviceConformingProlongationOperator_swiginit(self, _pfespace.new_DeviceConformingProlongationOperator(pfes)) + __swig_destroy__ = _pfespace.delete_DeviceConformingProlongationOperator + + def Mult(self, x, y): + r"""Mult(DeviceConformingProlongationOperator self, Vector x, Vector y)""" + return _pfespace.DeviceConformingProlongationOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_pfespace.DeviceConformingProlongationOperator_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(DeviceConformingProlongationOperator self, Vector x, Vector y)""" + return _pfespace.DeviceConformingProlongationOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_pfespace.DeviceConformingProlongationOperator_MultTranspose) + +# Register DeviceConformingProlongationOperator in _pfespace: +_pfespace.DeviceConformingProlongationOperator_swigregister(DeviceConformingProlongationOperator) + diff --git a/mfem/_par/pfespace_wrap.cxx b/mfem/_par/pfespace_wrap.cxx index 7f3e28f2..3ded0775 100644 --- a/mfem/_par/pfespace_wrap.cxx +++ b/mfem/_par/pfespace_wrap.cxx @@ -3069,197 +3069,208 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_double swig_types[5] -#define SWIGTYPE_p_hex_t swig_types[6] -#define SWIGTYPE_p_int swig_types[7] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[12] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[13] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[14] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[15] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[16] -#define SWIGTYPE_p_mfem__ConformingProlongationOperator swig_types[17] -#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[18] -#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[19] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[20] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[21] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[22] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[23] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[24] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[25] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[26] -#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[27] -#define SWIGTYPE_p_mfem__CubicFECollection swig_types[28] -#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[29] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[30] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[31] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[32] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[33] -#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[34] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[35] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[36] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[37] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[38] -#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[39] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[40] -#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[41] -#define SWIGTYPE_p_mfem__GridFunction swig_types[42] -#define SWIGTYPE_p_mfem__GroupCommunicator swig_types[43] -#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[44] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[45] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[46] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[47] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[48] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[49] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[50] -#define SWIGTYPE_p_mfem__H1_FECollection swig_types[51] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[52] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[53] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[54] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[55] -#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[56] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[57] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[58] -#define SWIGTYPE_p_mfem__HypreADS swig_types[59] -#define SWIGTYPE_p_mfem__HypreAMS swig_types[60] -#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[61] -#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[62] -#define SWIGTYPE_p_mfem__HypreEuclid swig_types[63] -#define SWIGTYPE_p_mfem__HypreGMRES swig_types[64] -#define SWIGTYPE_p_mfem__HypreIdentity swig_types[65] -#define SWIGTYPE_p_mfem__HyprePCG swig_types[66] -#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[67] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[68] -#define SWIGTYPE_p_mfem__HypreParaSails swig_types[69] -#define SWIGTYPE_p_mfem__HypreSmoother swig_types[70] -#define SWIGTYPE_p_mfem__HypreSolver swig_types[71] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[72] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[73] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[74] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[75] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[76] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[77] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[78] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[79] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[80] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[81] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[82] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[83] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[84] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[85] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[86] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[92] -#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[93] -#define SWIGTYPE_p_mfem__LinearFECollection swig_types[94] -#define SWIGTYPE_p_mfem__LinearForm swig_types[95] -#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[96] -#define SWIGTYPE_p_mfem__Local_FECollection swig_types[97] -#define SWIGTYPE_p_mfem__Matrix swig_types[98] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[99] -#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[100] -#define SWIGTYPE_p_mfem__ND_FECollection swig_types[101] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[102] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[103] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[104] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[105] -#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[106] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[107] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[109] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[110] -#define SWIGTYPE_p_mfem__NURBSExtension swig_types[111] -#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[112] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[114] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__Operator swig_types[118] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[119] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[123] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[124] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[125] -#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[126] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[127] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[128] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[129] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[130] -#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[131] -#define SWIGTYPE_p_mfem__ParMesh swig_types[132] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[133] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[134] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[135] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[136] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[137] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[138] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[139] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[140] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[141] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[142] -#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[143] -#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[144] -#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[145] -#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[146] -#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[147] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[148] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[149] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[150] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[151] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[152] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[153] -#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[154] -#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[155] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[156] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[157] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[158] -#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[159] -#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[160] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[161] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[162] -#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[163] -#define SWIGTYPE_p_mfem__RT_FECollection swig_types[164] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[165] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[166] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[167] -#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[168] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[169] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[170] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[171] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[172] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[173] -#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[174] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[175] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[176] -#define SWIGTYPE_p_mfem__STable swig_types[177] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[178] -#define SWIGTYPE_p_mfem__Solver swig_types[179] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[180] -#define SWIGTYPE_p_mfem__Table swig_types[181] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[182] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[183] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[184] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[185] -#define SWIGTYPE_p_mfem__Vector swig_types[186] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[187] -#define SWIGTYPE_p_pri_t swig_types[188] -#define SWIGTYPE_p_quad_t swig_types[189] -#define SWIGTYPE_p_seg_t swig_types[190] -#define SWIGTYPE_p_tet_t swig_types[191] -#define SWIGTYPE_p_tri_t swig_types[192] -static swig_type_info *swig_types[194]; -static swig_module_info swig_module = {swig_types, 193, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_char swig_types[5] +#define SWIGTYPE_p_double swig_types[6] +#define SWIGTYPE_p_hex_t swig_types[7] +#define SWIGTYPE_p_int swig_types[8] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[10] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[13] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[14] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[15] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[16] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[17] +#define SWIGTYPE_p_mfem__ConformingProlongationOperator swig_types[18] +#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[19] +#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[20] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[21] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[22] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[24] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[25] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[26] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[27] +#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[28] +#define SWIGTYPE_p_mfem__CubicFECollection swig_types[29] +#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[30] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[31] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[32] +#define SWIGTYPE_p_mfem__DeviceConformingProlongationOperator swig_types[33] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[34] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[35] +#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[36] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[37] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[38] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[39] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[40] +#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[41] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[42] +#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[43] +#define SWIGTYPE_p_mfem__GridFunction swig_types[44] +#define SWIGTYPE_p_mfem__GroupCommunicator swig_types[45] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[46] +#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[47] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[49] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[50] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[51] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[52] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[53] +#define SWIGTYPE_p_mfem__H1Ser_FECollection swig_types[54] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[55] +#define SWIGTYPE_p_mfem__H1_FECollection swig_types[56] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[57] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[58] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[59] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[60] +#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[61] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[62] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[63] +#define SWIGTYPE_p_mfem__HypreADS swig_types[64] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[65] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[66] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[67] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[68] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[69] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[70] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[71] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[72] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[73] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[74] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[75] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[76] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[77] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[78] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[79] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[80] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[81] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[82] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[83] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[84] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[85] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[86] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[87] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[88] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[89] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[90] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[91] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[92] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[93] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[99] +#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[100] +#define SWIGTYPE_p_mfem__LinearFECollection swig_types[101] +#define SWIGTYPE_p_mfem__LinearForm swig_types[102] +#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[103] +#define SWIGTYPE_p_mfem__Local_FECollection swig_types[104] +#define SWIGTYPE_p_mfem__Matrix swig_types[105] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[106] +#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[107] +#define SWIGTYPE_p_mfem__ND_FECollection swig_types[108] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[109] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[110] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[111] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[112] +#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[113] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[114] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[117] +#define SWIGTYPE_p_mfem__NURBSExtension swig_types[118] +#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[119] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__Operator swig_types[125] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[126] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[127] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[128] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[129] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[130] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[131] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[132] +#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[133] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[134] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[135] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[136] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[137] +#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[138] +#define SWIGTYPE_p_mfem__ParMesh swig_types[139] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[140] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[141] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[142] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[143] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[144] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[145] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[146] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[147] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[148] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[149] +#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[150] +#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[151] +#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[152] +#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[153] +#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[154] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[155] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[156] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[157] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[158] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[159] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[160] +#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[161] +#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[162] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[163] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[164] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[165] +#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[166] +#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[167] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[168] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[169] +#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[170] +#define SWIGTYPE_p_mfem__RT_FECollection swig_types[171] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[172] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[173] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[174] +#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[175] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[176] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[177] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[178] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[179] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[180] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[181] +#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[182] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[183] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[184] +#define SWIGTYPE_p_mfem__STable swig_types[185] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[186] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[187] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[188] +#define SWIGTYPE_p_mfem__Solver swig_types[189] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[190] +#define SWIGTYPE_p_mfem__Table swig_types[191] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[192] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[193] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[194] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[195] +#define SWIGTYPE_p_mfem__Vector swig_types[196] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[197] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[198] +#define SWIGTYPE_p_pri_t swig_types[199] +#define SWIGTYPE_p_quad_t swig_types[200] +#define SWIGTYPE_p_seg_t swig_types[201] +#define SWIGTYPE_p_tet_t swig_types[202] +#define SWIGTYPE_p_tri_t swig_types[203] +static swig_type_info *swig_types[205]; +static swig_module_info swig_module = {swig_types, 204, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3367,6 +3378,8 @@ namespace swig { #include "config/config.hpp" #include "fem/linearform.hpp" #include "fem/pfespace.hpp" +#include "fem/restriction.hpp" +#include "fem/prestriction.hpp" #include "numpy/arrayobject.h" #include "pyoperator.hpp" @@ -3444,11 +3457,14 @@ SWIG_From_MPI_Comm (MPI_Comm v) { } -SWIGINTERNINLINE PyObject* - SWIG_From_bool (bool value) -{ - return PyBool_FromLong(value ? 1 : 0); -} +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif SWIGINTERN int @@ -3576,6 +3592,29 @@ SWIG_AsVal_long (PyObject *obj, long* val) } +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + SWIGINTERN int SWIG_AsVal_bool (PyObject *obj, bool *val) { @@ -5162,6 +5201,168 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSE } +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + mfem::L2FaceValues arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); + { + try { + result = (mfem::Operator *)((mfem::ParFiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::Operator *)((mfem::ParFiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetFaceRestriction", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParFiniteElementSpace_GetFaceRestriction'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParFiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues) const\n" + " mfem::ParFiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType) const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedEdgeDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; @@ -7027,103 +7228,367 @@ SWIGINTERN PyObject *ConformingProlongationOperator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -static PyMethodDef SwigMethods[] = { - { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, - { "ParFiniteElementSpace_num_face_nbr_dofs_set", _wrap_ParFiniteElementSpace_num_face_nbr_dofs_set, METH_VARARGS, "ParFiniteElementSpace_num_face_nbr_dofs_set(ParFiniteElementSpace self, int num_face_nbr_dofs)"}, - { "ParFiniteElementSpace_num_face_nbr_dofs_get", _wrap_ParFiniteElementSpace_num_face_nbr_dofs_get, METH_O, "ParFiniteElementSpace_num_face_nbr_dofs_get(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_face_nbr_element_dof_set", _wrap_ParFiniteElementSpace_face_nbr_element_dof_set, METH_VARARGS, "ParFiniteElementSpace_face_nbr_element_dof_set(ParFiniteElementSpace self, Table face_nbr_element_dof)"}, - { "ParFiniteElementSpace_face_nbr_element_dof_get", _wrap_ParFiniteElementSpace_face_nbr_element_dof_get, METH_O, "ParFiniteElementSpace_face_nbr_element_dof_get(ParFiniteElementSpace self) -> Table"}, - { "ParFiniteElementSpace_face_nbr_ldof_set", _wrap_ParFiniteElementSpace_face_nbr_ldof_set, METH_VARARGS, "ParFiniteElementSpace_face_nbr_ldof_set(ParFiniteElementSpace self, Table face_nbr_ldof)"}, - { "ParFiniteElementSpace_face_nbr_ldof_get", _wrap_ParFiniteElementSpace_face_nbr_ldof_get, METH_O, "ParFiniteElementSpace_face_nbr_ldof_get(ParFiniteElementSpace self) -> Table"}, - { "ParFiniteElementSpace_face_nbr_glob_dof_map_get", _wrap_ParFiniteElementSpace_face_nbr_glob_dof_map_get, METH_O, "ParFiniteElementSpace_face_nbr_glob_dof_map_get(ParFiniteElementSpace self) -> intArray"}, - { "ParFiniteElementSpace_send_face_nbr_ldof_set", _wrap_ParFiniteElementSpace_send_face_nbr_ldof_set, METH_VARARGS, "ParFiniteElementSpace_send_face_nbr_ldof_set(ParFiniteElementSpace self, Table send_face_nbr_ldof)"}, - { "ParFiniteElementSpace_send_face_nbr_ldof_get", _wrap_ParFiniteElementSpace_send_face_nbr_ldof_get, METH_O, "ParFiniteElementSpace_send_face_nbr_ldof_get(ParFiniteElementSpace self) -> Table"}, - { "new_ParFiniteElementSpace", _wrap_new_ParFiniteElementSpace, METH_VARARGS, "\n" - "ParFiniteElementSpace(ParFiniteElementSpace orig, ParMesh pmesh=None, FiniteElementCollection fec=None)\n" - "ParFiniteElementSpace(FiniteElementSpace orig, ParMesh pmesh, FiniteElementCollection fec=None)\n" - "ParFiniteElementSpace(ParMesh pm, FiniteElementSpace global_fes, int const * partitioning, FiniteElementCollection f=None)\n" - "ParFiniteElementSpace(ParMesh pm, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" - "ParFiniteElementSpace(ParMesh pm, mfem::NURBSExtension * ext, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" - ""}, - { "ParFiniteElementSpace_GetComm", _wrap_ParFiniteElementSpace_GetComm, METH_O, "ParFiniteElementSpace_GetComm(ParFiniteElementSpace self) -> MPI_Comm"}, - { "ParFiniteElementSpace_GetNRanks", _wrap_ParFiniteElementSpace_GetNRanks, METH_O, "ParFiniteElementSpace_GetNRanks(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetMyRank", _wrap_ParFiniteElementSpace_GetMyRank, METH_O, "ParFiniteElementSpace_GetMyRank(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetParMesh", _wrap_ParFiniteElementSpace_GetParMesh, METH_O, "ParFiniteElementSpace_GetParMesh(ParFiniteElementSpace self) -> ParMesh"}, - { "ParFiniteElementSpace_GetDofSign", _wrap_ParFiniteElementSpace_GetDofSign, METH_VARARGS, "ParFiniteElementSpace_GetDofSign(ParFiniteElementSpace self, int i) -> int"}, - { "ParFiniteElementSpace_GetDofOffsets", _wrap_ParFiniteElementSpace_GetDofOffsets, METH_O, "ParFiniteElementSpace_GetDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, - { "ParFiniteElementSpace_GetTrueDofOffsets", _wrap_ParFiniteElementSpace_GetTrueDofOffsets, METH_O, "ParFiniteElementSpace_GetTrueDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, - { "ParFiniteElementSpace_GlobalVSize", _wrap_ParFiniteElementSpace_GlobalVSize, METH_O, "ParFiniteElementSpace_GlobalVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GlobalTrueVSize", _wrap_ParFiniteElementSpace_GlobalTrueVSize, METH_O, "ParFiniteElementSpace_GlobalTrueVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GetTrueVSize", _wrap_ParFiniteElementSpace_GetTrueVSize, METH_O, "ParFiniteElementSpace_GetTrueVSize(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetElementDofs", _wrap_ParFiniteElementSpace_GetElementDofs, METH_VARARGS, "ParFiniteElementSpace_GetElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetBdrElementDofs", _wrap_ParFiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "ParFiniteElementSpace_GetBdrElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetFaceDofs", _wrap_ParFiniteElementSpace_GetFaceDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetSharedEdgeDofs", _wrap_ParFiniteElementSpace_GetSharedEdgeDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedEdgeDofs(ParFiniteElementSpace self, int group, int ei, intArray dofs)"}, - { "ParFiniteElementSpace_GetSharedTriangleDofs", _wrap_ParFiniteElementSpace_GetSharedTriangleDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, - { "ParFiniteElementSpace_GetSharedQuadrilateralDofs", _wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, - { "ParFiniteElementSpace_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Dof_TrueDof_Matrix, METH_O, "ParFiniteElementSpace_Dof_TrueDof_Matrix(ParFiniteElementSpace self) -> HypreParMatrix"}, - { "ParFiniteElementSpace_GetPartialConformingInterpolation", _wrap_ParFiniteElementSpace_GetPartialConformingInterpolation, METH_O, "ParFiniteElementSpace_GetPartialConformingInterpolation(ParFiniteElementSpace self) -> HypreParMatrix"}, - { "ParFiniteElementSpace_NewTrueDofVector", _wrap_ParFiniteElementSpace_NewTrueDofVector, METH_O, "ParFiniteElementSpace_NewTrueDofVector(ParFiniteElementSpace self) -> HypreParVector"}, - { "ParFiniteElementSpace_DivideByGroupSize", _wrap_ParFiniteElementSpace_DivideByGroupSize, METH_VARARGS, "ParFiniteElementSpace_DivideByGroupSize(ParFiniteElementSpace self, double * vec)"}, - { "ParFiniteElementSpace_GroupComm", _wrap_ParFiniteElementSpace_GroupComm, METH_VARARGS, "\n" - "ParFiniteElementSpace_GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" - "ParFiniteElementSpace_GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" - ""}, - { "ParFiniteElementSpace_ScalarGroupComm", _wrap_ParFiniteElementSpace_ScalarGroupComm, METH_O, "ParFiniteElementSpace_ScalarGroupComm(ParFiniteElementSpace self) -> GroupCommunicator"}, - { "ParFiniteElementSpace_Synchronize", _wrap_ParFiniteElementSpace_Synchronize, METH_VARARGS, "ParFiniteElementSpace_Synchronize(ParFiniteElementSpace self, intArray ldof_marker)"}, - { "ParFiniteElementSpace_GetEssentialVDofs", _wrap_ParFiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "ParFiniteElementSpace_GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)"}, - { "ParFiniteElementSpace_GetEssentialTrueDofs", _wrap_ParFiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "ParFiniteElementSpace_GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, - { "ParFiniteElementSpace_GetLocalTDofNumber", _wrap_ParFiniteElementSpace_GetLocalTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int"}, - { "ParFiniteElementSpace_GetGlobalTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GetGlobalScalarTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GetMyDofOffset", _wrap_ParFiniteElementSpace_GetMyDofOffset, METH_O, "ParFiniteElementSpace_GetMyDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GetMyTDofOffset", _wrap_ParFiniteElementSpace_GetMyTDofOffset, METH_O, "ParFiniteElementSpace_GetMyTDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GetProlongationMatrix", _wrap_ParFiniteElementSpace_GetProlongationMatrix, METH_O, "ParFiniteElementSpace_GetProlongationMatrix(ParFiniteElementSpace self) -> Operator"}, - { "ParFiniteElementSpace_GetRestrictionMatrix", _wrap_ParFiniteElementSpace_GetRestrictionMatrix, METH_O, "ParFiniteElementSpace_GetRestrictionMatrix(ParFiniteElementSpace self) -> SparseMatrix"}, - { "ParFiniteElementSpace_ExchangeFaceNbrData", _wrap_ParFiniteElementSpace_ExchangeFaceNbrData, METH_O, "ParFiniteElementSpace_ExchangeFaceNbrData(ParFiniteElementSpace self)"}, - { "ParFiniteElementSpace_GetFaceNbrVSize", _wrap_ParFiniteElementSpace_GetFaceNbrVSize, METH_O, "ParFiniteElementSpace_GetFaceNbrVSize(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetFaceNbrElementVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, - { "ParFiniteElementSpace_GetFaceNbrFaceVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, - { "ParFiniteElementSpace_GetFaceNbrFE", _wrap_ParFiniteElementSpace_GetFaceNbrFE, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, - { "ParFiniteElementSpace_GetFaceNbrFaceFE", _wrap_ParFiniteElementSpace_GetFaceNbrFaceFE, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, - { "ParFiniteElementSpace_GetFaceNbrGlobalDofMap", _wrap_ParFiniteElementSpace_GetFaceNbrGlobalDofMap, METH_O, "ParFiniteElementSpace_GetFaceNbrGlobalDofMap(ParFiniteElementSpace self) -> HYPRE_Int const *"}, - { "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix, METH_O, "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix(ParFiniteElementSpace self)"}, - { "ParFiniteElementSpace_LoseDofOffsets", _wrap_ParFiniteElementSpace_LoseDofOffsets, METH_O, "ParFiniteElementSpace_LoseDofOffsets(ParFiniteElementSpace self)"}, - { "ParFiniteElementSpace_LoseTrueDofOffsets", _wrap_ParFiniteElementSpace_LoseTrueDofOffsets, METH_O, "ParFiniteElementSpace_LoseTrueDofOffsets(ParFiniteElementSpace self)"}, - { "ParFiniteElementSpace_Conforming", _wrap_ParFiniteElementSpace_Conforming, METH_O, "ParFiniteElementSpace_Conforming(ParFiniteElementSpace self) -> bool"}, - { "ParFiniteElementSpace_Nonconforming", _wrap_ParFiniteElementSpace_Nonconforming, METH_O, "ParFiniteElementSpace_Nonconforming(ParFiniteElementSpace self) -> bool"}, - { "ParFiniteElementSpace_GetTrueTransferOperator", _wrap_ParFiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "ParFiniteElementSpace_GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "ParFiniteElementSpace_Update", _wrap_ParFiniteElementSpace_Update, METH_VARARGS, "ParFiniteElementSpace_Update(ParFiniteElementSpace self, bool want_transform=True)"}, - { "ParFiniteElementSpace_UpdatesFinished", _wrap_ParFiniteElementSpace_UpdatesFinished, METH_O, "ParFiniteElementSpace_UpdatesFinished(ParFiniteElementSpace self)"}, - { "delete_ParFiniteElementSpace", _wrap_delete_ParFiniteElementSpace, METH_O, "delete_ParFiniteElementSpace(ParFiniteElementSpace self)"}, - { "ParFiniteElementSpace_PrintPartitionStats", _wrap_ParFiniteElementSpace_PrintPartitionStats, METH_O, "ParFiniteElementSpace_PrintPartitionStats(ParFiniteElementSpace self)"}, - { "ParFiniteElementSpace_TrueVSize", _wrap_ParFiniteElementSpace_TrueVSize, METH_O, "ParFiniteElementSpace_TrueVSize(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_swigregister", ParFiniteElementSpace_swigregister, METH_O, NULL}, - { "ParFiniteElementSpace_swiginit", ParFiniteElementSpace_swiginit, METH_VARARGS, NULL}, - { "new_ConformingProlongationOperator", _wrap_new_ConformingProlongationOperator, METH_O, "new_ConformingProlongationOperator(ParFiniteElementSpace pfes) -> ConformingProlongationOperator"}, - { "ConformingProlongationOperator_Mult", _wrap_ConformingProlongationOperator_Mult, METH_VARARGS, "ConformingProlongationOperator_Mult(ConformingProlongationOperator self, Vector x, Vector y)"}, - { "ConformingProlongationOperator_MultTranspose", _wrap_ConformingProlongationOperator_MultTranspose, METH_VARARGS, "ConformingProlongationOperator_MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)"}, - { "delete_ConformingProlongationOperator", _wrap_delete_ConformingProlongationOperator, METH_O, "delete_ConformingProlongationOperator(ConformingProlongationOperator self)"}, - { "ConformingProlongationOperator_swigregister", ConformingProlongationOperator_swigregister, METH_O, NULL}, - { "ConformingProlongationOperator_swiginit", ConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, - { NULL, NULL, 0, NULL } -}; - -static PyMethodDef SwigMethods_proxydocs[] = { - { NULL, NULL, 0, NULL } -}; - +SWIGINTERN PyObject *_wrap_new_DeviceConformingProlongationOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::DeviceConformingProlongationOperator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceConformingProlongationOperator" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DeviceConformingProlongationOperator" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + { + try { + result = (mfem::DeviceConformingProlongationOperator *)new mfem::DeviceConformingProlongationOperator((mfem::ParFiniteElementSpace const &)*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); -} -static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); -} -static void *_p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::ND1_3DFECollection *) x)); +SWIGINTERN PyObject *_wrap_delete_DeviceConformingProlongationOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DeviceConformingProlongationOperator *arg1 = (mfem::DeviceConformingProlongationOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DeviceConformingProlongationOperator" "', argument " "1"" of type '" "mfem::DeviceConformingProlongationOperator *""'"); + } + arg1 = reinterpret_cast< mfem::DeviceConformingProlongationOperator * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DeviceConformingProlongationOperator *arg1 = (mfem::DeviceConformingProlongationOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "DeviceConformingProlongationOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "1"" of type '" "mfem::DeviceConformingProlongationOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::DeviceConformingProlongationOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::DeviceConformingProlongationOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DeviceConformingProlongationOperator *arg1 = (mfem::DeviceConformingProlongationOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "DeviceConformingProlongationOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "1"" of type '" "mfem::DeviceConformingProlongationOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::DeviceConformingProlongationOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::DeviceConformingProlongationOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *DeviceConformingProlongationOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DeviceConformingProlongationOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "ParFiniteElementSpace_num_face_nbr_dofs_set", _wrap_ParFiniteElementSpace_num_face_nbr_dofs_set, METH_VARARGS, "ParFiniteElementSpace_num_face_nbr_dofs_set(ParFiniteElementSpace self, int num_face_nbr_dofs)"}, + { "ParFiniteElementSpace_num_face_nbr_dofs_get", _wrap_ParFiniteElementSpace_num_face_nbr_dofs_get, METH_O, "ParFiniteElementSpace_num_face_nbr_dofs_get(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_face_nbr_element_dof_set", _wrap_ParFiniteElementSpace_face_nbr_element_dof_set, METH_VARARGS, "ParFiniteElementSpace_face_nbr_element_dof_set(ParFiniteElementSpace self, Table face_nbr_element_dof)"}, + { "ParFiniteElementSpace_face_nbr_element_dof_get", _wrap_ParFiniteElementSpace_face_nbr_element_dof_get, METH_O, "ParFiniteElementSpace_face_nbr_element_dof_get(ParFiniteElementSpace self) -> Table"}, + { "ParFiniteElementSpace_face_nbr_ldof_set", _wrap_ParFiniteElementSpace_face_nbr_ldof_set, METH_VARARGS, "ParFiniteElementSpace_face_nbr_ldof_set(ParFiniteElementSpace self, Table face_nbr_ldof)"}, + { "ParFiniteElementSpace_face_nbr_ldof_get", _wrap_ParFiniteElementSpace_face_nbr_ldof_get, METH_O, "ParFiniteElementSpace_face_nbr_ldof_get(ParFiniteElementSpace self) -> Table"}, + { "ParFiniteElementSpace_face_nbr_glob_dof_map_get", _wrap_ParFiniteElementSpace_face_nbr_glob_dof_map_get, METH_O, "ParFiniteElementSpace_face_nbr_glob_dof_map_get(ParFiniteElementSpace self) -> intArray"}, + { "ParFiniteElementSpace_send_face_nbr_ldof_set", _wrap_ParFiniteElementSpace_send_face_nbr_ldof_set, METH_VARARGS, "ParFiniteElementSpace_send_face_nbr_ldof_set(ParFiniteElementSpace self, Table send_face_nbr_ldof)"}, + { "ParFiniteElementSpace_send_face_nbr_ldof_get", _wrap_ParFiniteElementSpace_send_face_nbr_ldof_get, METH_O, "ParFiniteElementSpace_send_face_nbr_ldof_get(ParFiniteElementSpace self) -> Table"}, + { "new_ParFiniteElementSpace", _wrap_new_ParFiniteElementSpace, METH_VARARGS, "\n" + "ParFiniteElementSpace(ParFiniteElementSpace orig, ParMesh pmesh=None, FiniteElementCollection fec=None)\n" + "ParFiniteElementSpace(FiniteElementSpace orig, ParMesh pmesh, FiniteElementCollection fec=None)\n" + "ParFiniteElementSpace(ParMesh pm, FiniteElementSpace global_fes, int const * partitioning, FiniteElementCollection f=None)\n" + "ParFiniteElementSpace(ParMesh pm, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" + "ParFiniteElementSpace(ParMesh pm, mfem::NURBSExtension * ext, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" + ""}, + { "ParFiniteElementSpace_GetComm", _wrap_ParFiniteElementSpace_GetComm, METH_O, "ParFiniteElementSpace_GetComm(ParFiniteElementSpace self) -> MPI_Comm"}, + { "ParFiniteElementSpace_GetNRanks", _wrap_ParFiniteElementSpace_GetNRanks, METH_O, "ParFiniteElementSpace_GetNRanks(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetMyRank", _wrap_ParFiniteElementSpace_GetMyRank, METH_O, "ParFiniteElementSpace_GetMyRank(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetParMesh", _wrap_ParFiniteElementSpace_GetParMesh, METH_O, "ParFiniteElementSpace_GetParMesh(ParFiniteElementSpace self) -> ParMesh"}, + { "ParFiniteElementSpace_GetDofSign", _wrap_ParFiniteElementSpace_GetDofSign, METH_VARARGS, "ParFiniteElementSpace_GetDofSign(ParFiniteElementSpace self, int i) -> int"}, + { "ParFiniteElementSpace_GetDofOffsets", _wrap_ParFiniteElementSpace_GetDofOffsets, METH_O, "ParFiniteElementSpace_GetDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, + { "ParFiniteElementSpace_GetTrueDofOffsets", _wrap_ParFiniteElementSpace_GetTrueDofOffsets, METH_O, "ParFiniteElementSpace_GetTrueDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, + { "ParFiniteElementSpace_GlobalVSize", _wrap_ParFiniteElementSpace_GlobalVSize, METH_O, "ParFiniteElementSpace_GlobalVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GlobalTrueVSize", _wrap_ParFiniteElementSpace_GlobalTrueVSize, METH_O, "ParFiniteElementSpace_GlobalTrueVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetTrueVSize", _wrap_ParFiniteElementSpace_GetTrueVSize, METH_O, "ParFiniteElementSpace_GetTrueVSize(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetElementDofs", _wrap_ParFiniteElementSpace_GetElementDofs, METH_VARARGS, "ParFiniteElementSpace_GetElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetBdrElementDofs", _wrap_ParFiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "ParFiniteElementSpace_GetBdrElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceDofs", _wrap_ParFiniteElementSpace_GetFaceDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceRestriction", _wrap_ParFiniteElementSpace_GetFaceRestriction, METH_VARARGS, "ParFiniteElementSpace_GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "ParFiniteElementSpace_GetSharedEdgeDofs", _wrap_ParFiniteElementSpace_GetSharedEdgeDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedEdgeDofs(ParFiniteElementSpace self, int group, int ei, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedTriangleDofs", _wrap_ParFiniteElementSpace_GetSharedTriangleDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedQuadrilateralDofs", _wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Dof_TrueDof_Matrix, METH_O, "ParFiniteElementSpace_Dof_TrueDof_Matrix(ParFiniteElementSpace self) -> HypreParMatrix"}, + { "ParFiniteElementSpace_GetPartialConformingInterpolation", _wrap_ParFiniteElementSpace_GetPartialConformingInterpolation, METH_O, "ParFiniteElementSpace_GetPartialConformingInterpolation(ParFiniteElementSpace self) -> HypreParMatrix"}, + { "ParFiniteElementSpace_NewTrueDofVector", _wrap_ParFiniteElementSpace_NewTrueDofVector, METH_O, "ParFiniteElementSpace_NewTrueDofVector(ParFiniteElementSpace self) -> HypreParVector"}, + { "ParFiniteElementSpace_DivideByGroupSize", _wrap_ParFiniteElementSpace_DivideByGroupSize, METH_VARARGS, "ParFiniteElementSpace_DivideByGroupSize(ParFiniteElementSpace self, double * vec)"}, + { "ParFiniteElementSpace_GroupComm", _wrap_ParFiniteElementSpace_GroupComm, METH_VARARGS, "\n" + "ParFiniteElementSpace_GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" + "ParFiniteElementSpace_GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" + ""}, + { "ParFiniteElementSpace_ScalarGroupComm", _wrap_ParFiniteElementSpace_ScalarGroupComm, METH_O, "ParFiniteElementSpace_ScalarGroupComm(ParFiniteElementSpace self) -> GroupCommunicator"}, + { "ParFiniteElementSpace_Synchronize", _wrap_ParFiniteElementSpace_Synchronize, METH_VARARGS, "ParFiniteElementSpace_Synchronize(ParFiniteElementSpace self, intArray ldof_marker)"}, + { "ParFiniteElementSpace_GetEssentialVDofs", _wrap_ParFiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "ParFiniteElementSpace_GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)"}, + { "ParFiniteElementSpace_GetEssentialTrueDofs", _wrap_ParFiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "ParFiniteElementSpace_GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "ParFiniteElementSpace_GetLocalTDofNumber", _wrap_ParFiniteElementSpace_GetLocalTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int"}, + { "ParFiniteElementSpace_GetGlobalTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetGlobalScalarTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetMyDofOffset", _wrap_ParFiniteElementSpace_GetMyDofOffset, METH_O, "ParFiniteElementSpace_GetMyDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetMyTDofOffset", _wrap_ParFiniteElementSpace_GetMyTDofOffset, METH_O, "ParFiniteElementSpace_GetMyTDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetProlongationMatrix", _wrap_ParFiniteElementSpace_GetProlongationMatrix, METH_O, "ParFiniteElementSpace_GetProlongationMatrix(ParFiniteElementSpace self) -> Operator"}, + { "ParFiniteElementSpace_GetRestrictionMatrix", _wrap_ParFiniteElementSpace_GetRestrictionMatrix, METH_O, "ParFiniteElementSpace_GetRestrictionMatrix(ParFiniteElementSpace self) -> SparseMatrix"}, + { "ParFiniteElementSpace_ExchangeFaceNbrData", _wrap_ParFiniteElementSpace_ExchangeFaceNbrData, METH_O, "ParFiniteElementSpace_ExchangeFaceNbrData(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_GetFaceNbrVSize", _wrap_ParFiniteElementSpace_GetFaceNbrVSize, METH_O, "ParFiniteElementSpace_GetFaceNbrVSize(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetFaceNbrElementVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFaceVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFE", _wrap_ParFiniteElementSpace_GetFaceNbrFE, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrFaceFE", _wrap_ParFiniteElementSpace_GetFaceNbrFaceFE, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrGlobalDofMap", _wrap_ParFiniteElementSpace_GetFaceNbrGlobalDofMap, METH_O, "ParFiniteElementSpace_GetFaceNbrGlobalDofMap(ParFiniteElementSpace self) -> HYPRE_Int const *"}, + { "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix, METH_O, "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_LoseDofOffsets", _wrap_ParFiniteElementSpace_LoseDofOffsets, METH_O, "ParFiniteElementSpace_LoseDofOffsets(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_LoseTrueDofOffsets", _wrap_ParFiniteElementSpace_LoseTrueDofOffsets, METH_O, "ParFiniteElementSpace_LoseTrueDofOffsets(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_Conforming", _wrap_ParFiniteElementSpace_Conforming, METH_O, "ParFiniteElementSpace_Conforming(ParFiniteElementSpace self) -> bool"}, + { "ParFiniteElementSpace_Nonconforming", _wrap_ParFiniteElementSpace_Nonconforming, METH_O, "ParFiniteElementSpace_Nonconforming(ParFiniteElementSpace self) -> bool"}, + { "ParFiniteElementSpace_GetTrueTransferOperator", _wrap_ParFiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "ParFiniteElementSpace_GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "ParFiniteElementSpace_Update", _wrap_ParFiniteElementSpace_Update, METH_VARARGS, "ParFiniteElementSpace_Update(ParFiniteElementSpace self, bool want_transform=True)"}, + { "ParFiniteElementSpace_UpdatesFinished", _wrap_ParFiniteElementSpace_UpdatesFinished, METH_O, "ParFiniteElementSpace_UpdatesFinished(ParFiniteElementSpace self)"}, + { "delete_ParFiniteElementSpace", _wrap_delete_ParFiniteElementSpace, METH_O, "delete_ParFiniteElementSpace(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_PrintPartitionStats", _wrap_ParFiniteElementSpace_PrintPartitionStats, METH_O, "ParFiniteElementSpace_PrintPartitionStats(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_TrueVSize", _wrap_ParFiniteElementSpace_TrueVSize, METH_O, "ParFiniteElementSpace_TrueVSize(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_swigregister", ParFiniteElementSpace_swigregister, METH_O, NULL}, + { "ParFiniteElementSpace_swiginit", ParFiniteElementSpace_swiginit, METH_VARARGS, NULL}, + { "new_ConformingProlongationOperator", _wrap_new_ConformingProlongationOperator, METH_O, "new_ConformingProlongationOperator(ParFiniteElementSpace pfes) -> ConformingProlongationOperator"}, + { "ConformingProlongationOperator_Mult", _wrap_ConformingProlongationOperator_Mult, METH_VARARGS, "ConformingProlongationOperator_Mult(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "ConformingProlongationOperator_MultTranspose", _wrap_ConformingProlongationOperator_MultTranspose, METH_VARARGS, "ConformingProlongationOperator_MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "delete_ConformingProlongationOperator", _wrap_delete_ConformingProlongationOperator, METH_O, "delete_ConformingProlongationOperator(ConformingProlongationOperator self)"}, + { "ConformingProlongationOperator_swigregister", ConformingProlongationOperator_swigregister, METH_O, NULL}, + { "ConformingProlongationOperator_swiginit", ConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, + { "new_DeviceConformingProlongationOperator", _wrap_new_DeviceConformingProlongationOperator, METH_O, "new_DeviceConformingProlongationOperator(ParFiniteElementSpace pfes) -> DeviceConformingProlongationOperator"}, + { "delete_DeviceConformingProlongationOperator", _wrap_delete_DeviceConformingProlongationOperator, METH_O, "delete_DeviceConformingProlongationOperator(DeviceConformingProlongationOperator self)"}, + { "DeviceConformingProlongationOperator_Mult", _wrap_DeviceConformingProlongationOperator_Mult, METH_VARARGS, "DeviceConformingProlongationOperator_Mult(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_MultTranspose", _wrap_DeviceConformingProlongationOperator_MultTranspose, METH_VARARGS, "DeviceConformingProlongationOperator_MultTranspose(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_swigregister", DeviceConformingProlongationOperator_swigregister, METH_O, NULL}, + { "DeviceConformingProlongationOperator_swiginit", DeviceConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "ParFiniteElementSpace_num_face_nbr_dofs_set", _wrap_ParFiniteElementSpace_num_face_nbr_dofs_set, METH_VARARGS, "ParFiniteElementSpace_num_face_nbr_dofs_set(ParFiniteElementSpace self, int num_face_nbr_dofs)"}, + { "ParFiniteElementSpace_num_face_nbr_dofs_get", _wrap_ParFiniteElementSpace_num_face_nbr_dofs_get, METH_O, "ParFiniteElementSpace_num_face_nbr_dofs_get(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_face_nbr_element_dof_set", _wrap_ParFiniteElementSpace_face_nbr_element_dof_set, METH_VARARGS, "ParFiniteElementSpace_face_nbr_element_dof_set(ParFiniteElementSpace self, Table face_nbr_element_dof)"}, + { "ParFiniteElementSpace_face_nbr_element_dof_get", _wrap_ParFiniteElementSpace_face_nbr_element_dof_get, METH_O, "ParFiniteElementSpace_face_nbr_element_dof_get(ParFiniteElementSpace self) -> Table"}, + { "ParFiniteElementSpace_face_nbr_ldof_set", _wrap_ParFiniteElementSpace_face_nbr_ldof_set, METH_VARARGS, "ParFiniteElementSpace_face_nbr_ldof_set(ParFiniteElementSpace self, Table face_nbr_ldof)"}, + { "ParFiniteElementSpace_face_nbr_ldof_get", _wrap_ParFiniteElementSpace_face_nbr_ldof_get, METH_O, "ParFiniteElementSpace_face_nbr_ldof_get(ParFiniteElementSpace self) -> Table"}, + { "ParFiniteElementSpace_face_nbr_glob_dof_map_get", _wrap_ParFiniteElementSpace_face_nbr_glob_dof_map_get, METH_O, "ParFiniteElementSpace_face_nbr_glob_dof_map_get(ParFiniteElementSpace self) -> intArray"}, + { "ParFiniteElementSpace_send_face_nbr_ldof_set", _wrap_ParFiniteElementSpace_send_face_nbr_ldof_set, METH_VARARGS, "ParFiniteElementSpace_send_face_nbr_ldof_set(ParFiniteElementSpace self, Table send_face_nbr_ldof)"}, + { "ParFiniteElementSpace_send_face_nbr_ldof_get", _wrap_ParFiniteElementSpace_send_face_nbr_ldof_get, METH_O, "ParFiniteElementSpace_send_face_nbr_ldof_get(ParFiniteElementSpace self) -> Table"}, + { "new_ParFiniteElementSpace", _wrap_new_ParFiniteElementSpace, METH_VARARGS, "\n" + "ParFiniteElementSpace(ParFiniteElementSpace orig, ParMesh pmesh=None, FiniteElementCollection fec=None)\n" + "ParFiniteElementSpace(FiniteElementSpace orig, ParMesh pmesh, FiniteElementCollection fec=None)\n" + "ParFiniteElementSpace(ParMesh pm, FiniteElementSpace global_fes, int const * partitioning, FiniteElementCollection f=None)\n" + "ParFiniteElementSpace(ParMesh pm, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" + "ParFiniteElementSpace(ParMesh pm, mfem::NURBSExtension * ext, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" + ""}, + { "ParFiniteElementSpace_GetComm", _wrap_ParFiniteElementSpace_GetComm, METH_O, "GetComm(ParFiniteElementSpace self) -> MPI_Comm"}, + { "ParFiniteElementSpace_GetNRanks", _wrap_ParFiniteElementSpace_GetNRanks, METH_O, "GetNRanks(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetMyRank", _wrap_ParFiniteElementSpace_GetMyRank, METH_O, "GetMyRank(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetParMesh", _wrap_ParFiniteElementSpace_GetParMesh, METH_O, "GetParMesh(ParFiniteElementSpace self) -> ParMesh"}, + { "ParFiniteElementSpace_GetDofSign", _wrap_ParFiniteElementSpace_GetDofSign, METH_VARARGS, "GetDofSign(ParFiniteElementSpace self, int i) -> int"}, + { "ParFiniteElementSpace_GetDofOffsets", _wrap_ParFiniteElementSpace_GetDofOffsets, METH_O, "GetDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, + { "ParFiniteElementSpace_GetTrueDofOffsets", _wrap_ParFiniteElementSpace_GetTrueDofOffsets, METH_O, "GetTrueDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, + { "ParFiniteElementSpace_GlobalVSize", _wrap_ParFiniteElementSpace_GlobalVSize, METH_O, "GlobalVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GlobalTrueVSize", _wrap_ParFiniteElementSpace_GlobalTrueVSize, METH_O, "GlobalTrueVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetTrueVSize", _wrap_ParFiniteElementSpace_GetTrueVSize, METH_O, "GetTrueVSize(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetElementDofs", _wrap_ParFiniteElementSpace_GetElementDofs, METH_VARARGS, "GetElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetBdrElementDofs", _wrap_ParFiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "GetBdrElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceDofs", _wrap_ParFiniteElementSpace_GetFaceDofs, METH_VARARGS, "GetFaceDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceRestriction", _wrap_ParFiniteElementSpace_GetFaceRestriction, METH_VARARGS, "GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "ParFiniteElementSpace_GetSharedEdgeDofs", _wrap_ParFiniteElementSpace_GetSharedEdgeDofs, METH_VARARGS, "GetSharedEdgeDofs(ParFiniteElementSpace self, int group, int ei, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedTriangleDofs", _wrap_ParFiniteElementSpace_GetSharedTriangleDofs, METH_VARARGS, "GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedQuadrilateralDofs", _wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs, METH_VARARGS, "GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Dof_TrueDof_Matrix, METH_O, "Dof_TrueDof_Matrix(ParFiniteElementSpace self) -> HypreParMatrix"}, + { "ParFiniteElementSpace_GetPartialConformingInterpolation", _wrap_ParFiniteElementSpace_GetPartialConformingInterpolation, METH_O, "GetPartialConformingInterpolation(ParFiniteElementSpace self) -> HypreParMatrix"}, + { "ParFiniteElementSpace_NewTrueDofVector", _wrap_ParFiniteElementSpace_NewTrueDofVector, METH_O, "NewTrueDofVector(ParFiniteElementSpace self) -> HypreParVector"}, + { "ParFiniteElementSpace_DivideByGroupSize", _wrap_ParFiniteElementSpace_DivideByGroupSize, METH_VARARGS, "DivideByGroupSize(ParFiniteElementSpace self, double * vec)"}, + { "ParFiniteElementSpace_GroupComm", _wrap_ParFiniteElementSpace_GroupComm, METH_VARARGS, "\n" + "GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" + "GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" + ""}, + { "ParFiniteElementSpace_ScalarGroupComm", _wrap_ParFiniteElementSpace_ScalarGroupComm, METH_O, "ScalarGroupComm(ParFiniteElementSpace self) -> GroupCommunicator"}, + { "ParFiniteElementSpace_Synchronize", _wrap_ParFiniteElementSpace_Synchronize, METH_VARARGS, "Synchronize(ParFiniteElementSpace self, intArray ldof_marker)"}, + { "ParFiniteElementSpace_GetEssentialVDofs", _wrap_ParFiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)"}, + { "ParFiniteElementSpace_GetEssentialTrueDofs", _wrap_ParFiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "ParFiniteElementSpace_GetLocalTDofNumber", _wrap_ParFiniteElementSpace_GetLocalTDofNumber, METH_VARARGS, "GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int"}, + { "ParFiniteElementSpace_GetGlobalTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalTDofNumber, METH_VARARGS, "GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetGlobalScalarTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber, METH_VARARGS, "GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetMyDofOffset", _wrap_ParFiniteElementSpace_GetMyDofOffset, METH_O, "GetMyDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetMyTDofOffset", _wrap_ParFiniteElementSpace_GetMyTDofOffset, METH_O, "GetMyTDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetProlongationMatrix", _wrap_ParFiniteElementSpace_GetProlongationMatrix, METH_O, "GetProlongationMatrix(ParFiniteElementSpace self) -> Operator"}, + { "ParFiniteElementSpace_GetRestrictionMatrix", _wrap_ParFiniteElementSpace_GetRestrictionMatrix, METH_O, "GetRestrictionMatrix(ParFiniteElementSpace self) -> SparseMatrix"}, + { "ParFiniteElementSpace_ExchangeFaceNbrData", _wrap_ParFiniteElementSpace_ExchangeFaceNbrData, METH_O, "ExchangeFaceNbrData(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_GetFaceNbrVSize", _wrap_ParFiniteElementSpace_GetFaceNbrVSize, METH_O, "GetFaceNbrVSize(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_GetFaceNbrElementVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs, METH_VARARGS, "GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFaceVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs, METH_VARARGS, "GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFE", _wrap_ParFiniteElementSpace_GetFaceNbrFE, METH_VARARGS, "GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrFaceFE", _wrap_ParFiniteElementSpace_GetFaceNbrFaceFE, METH_VARARGS, "GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrGlobalDofMap", _wrap_ParFiniteElementSpace_GetFaceNbrGlobalDofMap, METH_O, "GetFaceNbrGlobalDofMap(ParFiniteElementSpace self) -> HYPRE_Int const *"}, + { "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix, METH_O, "Lose_Dof_TrueDof_Matrix(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_LoseDofOffsets", _wrap_ParFiniteElementSpace_LoseDofOffsets, METH_O, "LoseDofOffsets(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_LoseTrueDofOffsets", _wrap_ParFiniteElementSpace_LoseTrueDofOffsets, METH_O, "LoseTrueDofOffsets(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_Conforming", _wrap_ParFiniteElementSpace_Conforming, METH_O, "Conforming(ParFiniteElementSpace self) -> bool"}, + { "ParFiniteElementSpace_Nonconforming", _wrap_ParFiniteElementSpace_Nonconforming, METH_O, "Nonconforming(ParFiniteElementSpace self) -> bool"}, + { "ParFiniteElementSpace_GetTrueTransferOperator", _wrap_ParFiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "ParFiniteElementSpace_Update", _wrap_ParFiniteElementSpace_Update, METH_VARARGS, "Update(ParFiniteElementSpace self, bool want_transform=True)"}, + { "ParFiniteElementSpace_UpdatesFinished", _wrap_ParFiniteElementSpace_UpdatesFinished, METH_O, "UpdatesFinished(ParFiniteElementSpace self)"}, + { "delete_ParFiniteElementSpace", _wrap_delete_ParFiniteElementSpace, METH_O, "delete_ParFiniteElementSpace(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_PrintPartitionStats", _wrap_ParFiniteElementSpace_PrintPartitionStats, METH_O, "PrintPartitionStats(ParFiniteElementSpace self)"}, + { "ParFiniteElementSpace_TrueVSize", _wrap_ParFiniteElementSpace_TrueVSize, METH_O, "TrueVSize(ParFiniteElementSpace self) -> int"}, + { "ParFiniteElementSpace_swigregister", ParFiniteElementSpace_swigregister, METH_O, NULL}, + { "ParFiniteElementSpace_swiginit", ParFiniteElementSpace_swiginit, METH_VARARGS, NULL}, + { "new_ConformingProlongationOperator", _wrap_new_ConformingProlongationOperator, METH_O, "new_ConformingProlongationOperator(ParFiniteElementSpace pfes) -> ConformingProlongationOperator"}, + { "ConformingProlongationOperator_Mult", _wrap_ConformingProlongationOperator_Mult, METH_VARARGS, "Mult(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "ConformingProlongationOperator_MultTranspose", _wrap_ConformingProlongationOperator_MultTranspose, METH_VARARGS, "MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "delete_ConformingProlongationOperator", _wrap_delete_ConformingProlongationOperator, METH_O, "delete_ConformingProlongationOperator(ConformingProlongationOperator self)"}, + { "ConformingProlongationOperator_swigregister", ConformingProlongationOperator_swigregister, METH_O, NULL}, + { "ConformingProlongationOperator_swiginit", ConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, + { "new_DeviceConformingProlongationOperator", _wrap_new_DeviceConformingProlongationOperator, METH_O, "new_DeviceConformingProlongationOperator(ParFiniteElementSpace pfes) -> DeviceConformingProlongationOperator"}, + { "delete_DeviceConformingProlongationOperator", _wrap_delete_DeviceConformingProlongationOperator, METH_O, "delete_DeviceConformingProlongationOperator(DeviceConformingProlongationOperator self)"}, + { "DeviceConformingProlongationOperator_Mult", _wrap_DeviceConformingProlongationOperator_Mult, METH_VARARGS, "Mult(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_MultTranspose", _wrap_DeviceConformingProlongationOperator_MultTranspose, METH_VARARGS, "MultTranspose(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_swigregister", DeviceConformingProlongationOperator_swigregister, METH_O, NULL}, + { "DeviceConformingProlongationOperator_swiginit", DeviceConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); +} +static void *_p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::ND1_3DFECollection *) x)); } static void *_p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::RefinedLinearFECollection *) x)); @@ -7176,12 +7641,18 @@ static void *_p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollect static void *_p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::CrouzeixRaviartFECollection *) x)); } +static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +} static void *_p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::H1_FECollection *) x)); } static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -7215,111 +7686,129 @@ static void *_p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection(vo static void *_p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::QuadraticPosFECollection *) x)); } -static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); } static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::Local_FECollection *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } -static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); } -static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } -static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); +static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +} +static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +} +static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); } static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); } -static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } -static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +} +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +} +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConformingProlongationOperator *) x)); +} +static void *_p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::ConformingProlongationOperator *) ((mfem::DeviceConformingProlongationOperator *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); } static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } -static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); } -static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); +static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); } -static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); +static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); } -static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); +static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); } -static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); } static void *_p_mfem__HypreSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSmoother *) x)); } -static void *_p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConformingProlongationOperator *) x)); +static void *_p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__ConformingProlongationOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ConformingProlongationOperator *) ((mfem::DeviceConformingProlongationOperator *) x)); } static void *_p_mfem__ParFiniteElementSpaceTo_p_mfem__FiniteElementSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementSpace *) ((mfem::ParFiniteElementSpace *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -7353,6 +7842,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -7368,6 +7860,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -7536,6 +8031,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -7579,10 +8080,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -7624,12 +8125,14 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *|mfem::Array< HYPRE_Int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ConformingProlongationOperator = {"_p_mfem__ConformingProlongationOperator", "mfem::ConformingProlongationOperator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__DeviceConformingProlongationOperator = {"_p_mfem__DeviceConformingProlongationOperator", "mfem::DeviceConformingProlongationOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FiniteElement = {"_p_mfem__FiniteElement", "mfem::FiniteElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__P0HexFiniteElement = {"_p_mfem__P0HexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LagrangeHexFiniteElement = {"_p_mfem__LagrangeHexFiniteElement", 0, 0, 0, 0, 0}; @@ -7646,13 +8149,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -7664,6 +8165,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -7705,6 +8208,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -7729,6 +8234,7 @@ static swig_type_info _swigt__p_mfem__NURBS1DFiniteElement = {"_p_mfem__NURBS1DF static swig_type_info _swigt__p_mfem__NURBS2DFiniteElement = {"_p_mfem__NURBS2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS3DFiniteElement = {"_p_mfem__NURBS3DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementCollection = {"_p_mfem__FiniteElementCollection", "mfem::FiniteElementCollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GaussLinearDiscont2DFECollection = {"_p_mfem__GaussLinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1OnQuadFECollection = {"_p_mfem__P1OnQuadFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticDiscont2DFECollection = {"_p_mfem__QuadraticDiscont2DFECollection", 0, 0, 0, 0, 0}; @@ -7741,15 +8247,13 @@ static swig_type_info _swigt__p_mfem__QuadraticDiscont3DFECollection = {"_p_mfem static swig_type_info _swigt__p_mfem__RefinedLinearFECollection = {"_p_mfem__RefinedLinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ND1_3DFECollection = {"_p_mfem__ND1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_3DFECollection = {"_p_mfem__RT0_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Const2DFECollection = {"_p_mfem__Const2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT2_2DFECollection = {"_p_mfem__RT2_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1_2DFECollection = {"_p_mfem__RT1_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_2DFECollection = {"_p_mfem__RT0_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearNonConf3DFECollection = {"_p_mfem__LinearNonConf3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CrouzeixRaviartFECollection = {"_p_mfem__CrouzeixRaviartFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticFECollection = {"_p_mfem__QuadraticFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearFECollection = {"_p_mfem__LinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBSFECollection = {"_p_mfem__NURBSFECollection", 0, 0, 0, 0, 0}; @@ -7759,9 +8263,11 @@ static swig_type_info _swigt__p_mfem__DG_Interface_FECollection = {"_p_mfem__DG_ static swig_type_info _swigt__p_mfem__RT_Trace_FECollection = {"_p_mfem__RT_Trace_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT_FECollection = {"_p_mfem__RT_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_Trace_FECollection = {"_p_mfem__H1_Trace_FECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_FECollection = {"_p_mfem__H1Ser_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_FECollection = {"_p_mfem__H1Pos_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_FECollection = {"_p_mfem__H1_FECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Local_FECollection = {"_p_mfem__Local_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; @@ -7772,32 +8278,38 @@ static swig_type_info _swigt__p_mfem__IntegrationRule = {"_p_mfem__IntegrationRu static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollection", "mfem::L2_FECollection *|mfem::DG_FECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__NURBSExtension = {"_p_mfem__NURBSExtension", "mfem::NURBSExtension *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreSmoother = {"_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ParFiniteElementSpace = {"_p_mfem__ParFiniteElementSpace", "mfem::ParFiniteElementSpace *", 0, 0, (void*)0, 0}; @@ -7819,6 +8331,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_hex_t, @@ -7847,6 +8360,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__DG_Interface_FECollection, &_swigt__p_mfem__DenseMatrix, &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__DeviceConformingProlongationOperator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__FiniteElement, &_swigt__p_mfem__FiniteElementCollection, @@ -7859,6 +8373,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GroupCommunicator, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__H1Pos_FECollection, &_swigt__p_mfem__H1Pos_HexahedronElement, &_swigt__p_mfem__H1Pos_QuadrilateralElement, @@ -7866,6 +8381,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_FECollection, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_FECollection, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, @@ -7889,6 +8406,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__HypreSolver, &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2Pos_HexahedronElement, &_swigt__p_mfem__L2Pos_QuadrilateralElement, &_swigt__p_mfem__L2Pos_SegmentElement, @@ -7985,6 +8504,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__RT_TetrahedronElement, &_swigt__p_mfem__RT_Trace_FECollection, &_swigt__p_mfem__RT_TriangleElement, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__RefinedBiLinear2DFiniteElement, &_swigt__p_mfem__RefinedLinear1DFiniteElement, &_swigt__p_mfem__RefinedLinear2DFiniteElement, @@ -7994,6 +8514,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__RotTriLinearHexFiniteElement, &_swigt__p_mfem__STable, &_swigt__p_mfem__ScalarFiniteElement, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__Table, @@ -8003,6 +8525,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__TripleProductOperator, &_swigt__p_mfem__Vector, &_swigt__p_mfem__VectorFiniteElement, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -8014,12 +8537,14 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ConformingProlongationOperator[] = { {&_swigt__p_mfem__ConformingProlongationOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConformingProlongationOperator[] = { {&_swigt__p_mfem__ConformingProlongationOperator, 0, 0, 0}, {&_swigt__p_mfem__DeviceConformingProlongationOperator, _p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__ConformingProlongationOperator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DeviceConformingProlongationOperator[] = { {&_swigt__p_mfem__DeviceConformingProlongationOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0HexFiniteElement[] = {{&_swigt__p_mfem__P0HexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LagrangeHexFiniteElement[] = {{&_swigt__p_mfem__LagrangeHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RefinedLinear1DFiniteElement[] = {{&_swigt__p_mfem__RefinedLinear1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -8035,13 +8560,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -8053,6 +8576,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -8094,6 +8619,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -8117,7 +8644,8 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussLinearDiscont2DFECollection[] = {{&_swigt__p_mfem__GaussLinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1OnQuadFECollection[] = {{&_swigt__p_mfem__P1OnQuadFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticDiscont2DFECollection[] = {{&_swigt__p_mfem__QuadraticDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -8130,15 +8658,13 @@ static swig_cast_info _swigc__p_mfem__QuadraticDiscont3DFECollection[] = {{&_swi static swig_cast_info _swigc__p_mfem__RefinedLinearFECollection[] = {{&_swigt__p_mfem__RefinedLinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ND1_3DFECollection[] = {{&_swigt__p_mfem__ND1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_3DFECollection[] = {{&_swigt__p_mfem__RT0_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Const2DFECollection[] = {{&_swigt__p_mfem__Const2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT2_2DFECollection[] = {{&_swigt__p_mfem__RT2_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1_2DFECollection[] = {{&_swigt__p_mfem__RT1_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_2DFECollection[] = {{&_swigt__p_mfem__RT0_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearNonConf3DFECollection[] = {{&_swigt__p_mfem__LinearNonConf3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CrouzeixRaviartFECollection[] = {{&_swigt__p_mfem__CrouzeixRaviartFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticFECollection[] = {{&_swigt__p_mfem__QuadraticFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearFECollection[] = {{&_swigt__p_mfem__LinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBSFECollection[] = {{&_swigt__p_mfem__NURBSFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -8148,11 +8674,13 @@ static swig_cast_info _swigc__p_mfem__DG_Interface_FECollection[] = {{&_swigt__p static swig_cast_info _swigc__p_mfem__RT_Trace_FECollection[] = {{&_swigt__p_mfem__RT_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT_FECollection[] = {{&_swigt__p_mfem__RT_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_Trace_FECollection[] = {{&_swigt__p_mfem__H1_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_FECollection[] = {{&_swigt__p_mfem__H1Ser_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_FECollection[] = {{&_swigt__p_mfem__H1Pos_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_FECollection[] = {{&_swigt__p_mfem__H1_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Local_FECollection[] = {{&_swigt__p_mfem__Local_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0}, {&_swigt__p_mfem__ParFiniteElementSpace, _p_mfem__ParFiniteElementSpaceTo_p_mfem__FiniteElementSpace, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GroupCommunicator[] = { {&_swigt__p_mfem__GroupCommunicator, 0, 0, 0},{0, 0, 0, 0}}; @@ -8161,34 +8689,40 @@ static swig_cast_info _swigc__p_mfem__HypreParVector[] = { {&_swigt__p_mfem__Hy static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBSExtension[] = { {&_swigt__p_mfem__NURBSExtension, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConformingProlongationOperator, _p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DeviceConformingProlongationOperator, _p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConformingProlongationOperator, _p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParFiniteElementSpace[] = { {&_swigt__p_mfem__ParFiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParMesh[] = { {&_swigt__p_mfem__ParMesh, 0, 0, 0},{0, 0, 0, 0}}; @@ -8209,6 +8743,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_hex_t, @@ -8237,6 +8772,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__DG_Interface_FECollection, _swigc__p_mfem__DenseMatrix, _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__DeviceConformingProlongationOperator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__FiniteElement, _swigc__p_mfem__FiniteElementCollection, @@ -8249,6 +8785,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__GaussQuadraticDiscont2DFECollection, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GroupCommunicator, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__H1Pos_FECollection, _swigc__p_mfem__H1Pos_HexahedronElement, _swigc__p_mfem__H1Pos_QuadrilateralElement, @@ -8256,6 +8793,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_FECollection, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_FECollection, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, @@ -8279,6 +8818,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__HypreSolver, _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2Pos_HexahedronElement, _swigc__p_mfem__L2Pos_QuadrilateralElement, _swigc__p_mfem__L2Pos_SegmentElement, @@ -8375,6 +8916,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__RT_TetrahedronElement, _swigc__p_mfem__RT_Trace_FECollection, _swigc__p_mfem__RT_TriangleElement, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__RefinedBiLinear2DFiniteElement, _swigc__p_mfem__RefinedLinear1DFiniteElement, _swigc__p_mfem__RefinedLinear2DFiniteElement, @@ -8384,6 +8926,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__RotTriLinearHexFiniteElement, _swigc__p_mfem__STable, _swigc__p_mfem__ScalarFiniteElement, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__Table, @@ -8393,6 +8937,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__TripleProductOperator, _swigc__p_mfem__Vector, _swigc__p_mfem__VectorFiniteElement, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, @@ -9127,18 +9672,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pgridfunc.py b/mfem/_par/pgridfunc.py index eab3579f..3614ca7e 100644 --- a/mfem/_par/pgridfunc.py +++ b/mfem/_par/pgridfunc.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _pgridfunc.SWIG_PyInstanceMethod_New +_swig_new_static_method = _pgridfunc.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -103,6 +106,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -114,6 +118,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.pmesh import mfem._par.pncmesh import mfem._par.communication @@ -122,6 +127,7 @@ class _SwigNonDynamicMeta(type): def GlobalLpNorm(p, loc_norm, comm): r"""GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double""" return _pgridfunc.GlobalLpNorm(p, loc_norm, comm) +GlobalLpNorm = _pgridfunc.GlobalLpNorm class ParGridFunction(mfem._par.gridfunc.GridFunction): r"""Proxy of C++ mfem::ParGridFunction class.""" @@ -131,10 +137,12 @@ class ParGridFunction(mfem._par.gridfunc.GridFunction): def ParFESpace(self): r"""ParFESpace(ParGridFunction self) -> ParFiniteElementSpace""" return _pgridfunc.ParGridFunction_ParFESpace(self) + ParFESpace = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParFESpace) def Update(self): r"""Update(ParGridFunction self)""" return _pgridfunc.ParGridFunction_Update(self) + Update = _swig_new_instance_method(_pgridfunc.ParGridFunction_Update) def SetSpace(self, *args): r""" @@ -142,15 +150,19 @@ def SetSpace(self, *args): SetSpace(ParGridFunction self, ParFiniteElementSpace f) """ return _pgridfunc.ParGridFunction_SetSpace(self, *args) + SetSpace = _swig_new_instance_method(_pgridfunc.ParGridFunction_SetSpace) def MakeRef(self, *args): r""" + MakeRef(ParGridFunction self, Vector base, int offset, int size) + MakeRef(ParGridFunction self, Vector base, int offset) MakeRef(ParGridFunction self, FiniteElementSpace f, double * v) MakeRef(ParGridFunction self, ParFiniteElementSpace f, double * v) MakeRef(ParGridFunction self, FiniteElementSpace f, Vector v, int v_offset) MakeRef(ParGridFunction self, ParFiniteElementSpace f, Vector v, int v_offset) """ return _pgridfunc.ParGridFunction_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_pgridfunc.ParGridFunction_MakeRef) def Distribute(self, *args): r""" @@ -158,6 +170,7 @@ def Distribute(self, *args): Distribute(ParGridFunction self, Vector tv) """ return _pgridfunc.ParGridFunction_Distribute(self, *args) + Distribute = _swig_new_instance_method(_pgridfunc.ParGridFunction_Distribute) def AddDistribute(self, *args): r""" @@ -165,10 +178,12 @@ def AddDistribute(self, *args): AddDistribute(ParGridFunction self, double a, Vector tv) """ return _pgridfunc.ParGridFunction_AddDistribute(self, *args) + AddDistribute = _swig_new_instance_method(_pgridfunc.ParGridFunction_AddDistribute) def SetFromTrueDofs(self, tv): r"""SetFromTrueDofs(ParGridFunction self, Vector tv)""" return _pgridfunc.ParGridFunction_SetFromTrueDofs(self, tv) + SetFromTrueDofs = _swig_new_instance_method(_pgridfunc.ParGridFunction_SetFromTrueDofs) def Assign(self, *args): r""" @@ -178,6 +193,7 @@ def Assign(self, *args): Assign(ParGridFunction self, HypreParVector tv) -> ParGridFunction """ return _pgridfunc.ParGridFunction_Assign(self, *args) + Assign = _swig_new_instance_method(_pgridfunc.ParGridFunction_Assign) def GetTrueDofs(self, *args): r""" @@ -185,6 +201,7 @@ def GetTrueDofs(self, *args): GetTrueDofs(ParGridFunction self) -> HypreParVector """ return _pgridfunc.ParGridFunction_GetTrueDofs(self, *args) + GetTrueDofs = _swig_new_instance_method(_pgridfunc.ParGridFunction_GetTrueDofs) def ParallelAverage(self, *args): r""" @@ -193,6 +210,7 @@ def ParallelAverage(self, *args): ParallelAverage(ParGridFunction self) -> HypreParVector """ return _pgridfunc.ParGridFunction_ParallelAverage(self, *args) + ParallelAverage = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParallelAverage) def ParallelProject(self, *args): r""" @@ -201,6 +219,7 @@ def ParallelProject(self, *args): ParallelProject(ParGridFunction self) -> HypreParVector """ return _pgridfunc.ParGridFunction_ParallelProject(self, *args) + ParallelProject = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParallelProject) def ParallelAssemble(self, *args): r""" @@ -209,10 +228,12 @@ def ParallelAssemble(self, *args): ParallelAssemble(ParGridFunction self) -> HypreParVector """ return _pgridfunc.ParGridFunction_ParallelAssemble(self, *args) + ParallelAssemble = _swig_new_instance_method(_pgridfunc.ParGridFunction_ParallelAssemble) def ExchangeFaceNbrData(self): r"""ExchangeFaceNbrData(ParGridFunction self)""" return _pgridfunc.ParGridFunction_ExchangeFaceNbrData(self) + ExchangeFaceNbrData = _swig_new_instance_method(_pgridfunc.ParGridFunction_ExchangeFaceNbrData) def FaceNbrData(self, *args): r""" @@ -220,6 +241,7 @@ def FaceNbrData(self, *args): FaceNbrData(ParGridFunction self) -> Vector """ return _pgridfunc.ParGridFunction_FaceNbrData(self, *args) + FaceNbrData = _swig_new_instance_method(_pgridfunc.ParGridFunction_FaceNbrData) def GetValue(self, *args): r""" @@ -227,6 +249,7 @@ def GetValue(self, *args): GetValue(ParGridFunction self, ElementTransformation T) -> double """ return _pgridfunc.ParGridFunction_GetValue(self, *args) + GetValue = _swig_new_instance_method(_pgridfunc.ParGridFunction_GetValue) def ProjectCoefficient(self, *args): r""" @@ -239,6 +262,7 @@ def ProjectCoefficient(self, *args): ProjectCoefficient(ParGridFunction self, Coefficient coeff) """ return _pgridfunc.ParGridFunction_ProjectCoefficient(self, *args) + ProjectCoefficient = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectCoefficient) def ProjectDiscCoefficient(self, *args): r""" @@ -251,6 +275,7 @@ def ProjectDiscCoefficient(self, *args): ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient vcoeff, mfem::GridFunction::AvgType type) """ return _pgridfunc.ParGridFunction_ProjectDiscCoefficient(self, *args) + ProjectDiscCoefficient = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectDiscCoefficient) def ProjectBdrCoefficient(self, *args): r""" @@ -261,10 +286,12 @@ def ProjectBdrCoefficient(self, *args): ProjectBdrCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff, intArray attr) """ return _pgridfunc.ParGridFunction_ProjectBdrCoefficient(self, *args) + ProjectBdrCoefficient = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectBdrCoefficient) def ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr): r"""ProjectBdrCoefficientTangent(ParGridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)""" return _pgridfunc.ParGridFunction_ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr) + ProjectBdrCoefficientTangent = _swig_new_instance_method(_pgridfunc.ParGridFunction_ProjectBdrCoefficientTangent) def ComputeL1Error(self, *args): r""" @@ -273,6 +300,7 @@ def ComputeL1Error(self, *args): ComputeL1Error(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double """ return _pgridfunc.ParGridFunction_ComputeL1Error(self, *args) + ComputeL1Error = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeL1Error) def ComputeL2Error(self, *args): r""" @@ -281,6 +309,7 @@ def ComputeL2Error(self, *args): ComputeL2Error(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double """ return _pgridfunc.ParGridFunction_ComputeL2Error(self, *args) + ComputeL2Error = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeL2Error) def ComputeMaxError(self, *args): r""" @@ -289,6 +318,7 @@ def ComputeMaxError(self, *args): ComputeMaxError(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double """ return _pgridfunc.ParGridFunction_ComputeMaxError(self, *args) + ComputeMaxError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeMaxError) def ComputeLpError(self, *args): r""" @@ -296,10 +326,12 @@ def ComputeLpError(self, *args): ComputeLpError(ParGridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double """ return _pgridfunc.ParGridFunction_ComputeLpError(self, *args) + ComputeLpError = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeLpError) - def ComputeFlux(self, blfi, flux, wcoef=1, subdomain=-1): - r"""ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, int wcoef=1, int subdomain=-1)""" + def ComputeFlux(self, blfi, flux, wcoef=True, subdomain=-1): + r"""ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)""" return _pgridfunc.ParGridFunction_ComputeFlux(self, blfi, flux, wcoef, subdomain) + ComputeFlux = _swig_new_instance_method(_pgridfunc.ParGridFunction_ComputeFlux) __swig_destroy__ = _pgridfunc.delete_ParGridFunction def __init__(self, *args): @@ -341,6 +373,7 @@ def Save(self, *args): Save(ParGridFunction self, char const * file, int precision=8) """ return _pgridfunc.ParGridFunction_Save(self, *args) + Save = _swig_new_instance_method(_pgridfunc.ParGridFunction_Save) def SaveAsOne(self, *args): r""" @@ -348,6 +381,7 @@ def SaveAsOne(self, *args): SaveAsOne(ParGridFunction self, char const * file, int precision=8) """ return _pgridfunc.ParGridFunction_SaveAsOne(self, *args) + SaveAsOne = _swig_new_instance_method(_pgridfunc.ParGridFunction_SaveAsOne) # Register ParGridFunction in _pgridfunc: _pgridfunc.ParGridFunction_swigregister(ParGridFunction) @@ -356,5 +390,6 @@ def SaveAsOne(self, *args): def L2ZZErrorEstimator(flux_integrator, x, smooth_flux_fes, flux_fes, errors, norm_p=2, solver_tol=1e-12, solver_max_it=200): r"""L2ZZErrorEstimator(BilinearFormIntegrator flux_integrator, ParGridFunction x, ParFiniteElementSpace smooth_flux_fes, ParFiniteElementSpace flux_fes, Vector errors, int norm_p=2, double solver_tol=1e-12, int solver_max_it=200) -> double""" return _pgridfunc.L2ZZErrorEstimator(flux_integrator, x, smooth_flux_fes, flux_fes, errors, norm_p, solver_tol, solver_max_it) +L2ZZErrorEstimator = _pgridfunc.L2ZZErrorEstimator diff --git a/mfem/_par/pgridfunc_wrap.cxx b/mfem/_par/pgridfunc_wrap.cxx index e142f91b..b71518eb 100644 --- a/mfem/_par/pgridfunc_wrap.cxx +++ b/mfem/_par/pgridfunc_wrap.cxx @@ -3069,160 +3069,162 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_double swig_types[5] -#define SWIGTYPE_p_hex_t swig_types[6] -#define SWIGTYPE_p_int swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[10] -#define SWIGTYPE_p_mfem__Coefficient swig_types[11] -#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[12] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[15] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[16] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[17] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[18] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[20] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[21] -#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[22] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[23] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[24] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[25] -#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[26] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[27] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[29] -#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[30] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[31] -#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[32] -#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[33] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[34] -#define SWIGTYPE_p_mfem__GridFunction swig_types[35] -#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[36] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[38] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[39] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[40] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[41] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[42] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[43] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[44] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[45] -#define SWIGTYPE_p_mfem__LinearForm swig_types[46] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[47] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[48] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[49] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[50] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[51] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[53] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[57] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[58] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[59] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[60] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[61] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[62] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[63] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[66] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[67] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[74] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[75] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[76] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[77] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[78] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[79] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[80] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[82] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[83] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[86] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[89] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[90] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[92] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[93] -#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[94] -#define SWIGTYPE_p_mfem__ParGridFunction swig_types[95] -#define SWIGTYPE_p_mfem__ParMesh swig_types[96] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[97] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[98] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[99] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[100] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[101] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[102] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[103] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[104] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[105] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[106] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[107] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[108] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[109] -#define SWIGTYPE_p_mfem__Vector swig_types[110] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[111] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[112] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[113] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[114] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[115] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[116] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[117] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[118] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[119] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[120] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[121] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[122] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[123] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[124] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[125] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[126] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[127] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[128] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[129] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[130] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[131] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[132] -#define SWIGTYPE_p_p_mfem__Coefficient swig_types[133] -#define SWIGTYPE_p_p_mfem__ConstantCoefficient swig_types[134] -#define SWIGTYPE_p_p_mfem__DeltaCoefficient swig_types[135] -#define SWIGTYPE_p_p_mfem__DeterminantCoefficient swig_types[136] -#define SWIGTYPE_p_p_mfem__DivergenceGridFunctionCoefficient swig_types[137] -#define SWIGTYPE_p_p_mfem__ExtrudeCoefficient swig_types[138] -#define SWIGTYPE_p_p_mfem__FunctionCoefficient swig_types[139] -#define SWIGTYPE_p_p_mfem__GridFunctionCoefficient swig_types[140] -#define SWIGTYPE_p_p_mfem__InnerProductCoefficient swig_types[141] -#define SWIGTYPE_p_p_mfem__PWConstCoefficient swig_types[142] -#define SWIGTYPE_p_p_mfem__PowerCoefficient swig_types[143] -#define SWIGTYPE_p_p_mfem__ProductCoefficient swig_types[144] -#define SWIGTYPE_p_p_mfem__PyCoefficientBase swig_types[145] -#define SWIGTYPE_p_p_mfem__RestrictedCoefficient swig_types[146] -#define SWIGTYPE_p_p_mfem__SumCoefficient swig_types[147] -#define SWIGTYPE_p_p_mfem__TransformedCoefficient swig_types[148] -#define SWIGTYPE_p_p_mfem__VectorRotProductCoefficient swig_types[149] -#define SWIGTYPE_p_pri_t swig_types[150] -#define SWIGTYPE_p_quad_t swig_types[151] -#define SWIGTYPE_p_seg_t swig_types[152] -#define SWIGTYPE_p_std__istream swig_types[153] -#define SWIGTYPE_p_tet_t swig_types[154] -#define SWIGTYPE_p_tri_t swig_types[155] -static swig_type_info *swig_types[157]; -static swig_module_info swig_module = {swig_types, 156, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_char swig_types[5] +#define SWIGTYPE_p_double swig_types[6] +#define SWIGTYPE_p_hex_t swig_types[7] +#define SWIGTYPE_p_int swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[10] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[11] +#define SWIGTYPE_p_mfem__Coefficient swig_types[12] +#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[13] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[16] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[17] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[18] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[19] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[21] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[22] +#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[23] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[24] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[25] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[26] +#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[27] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[28] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[29] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[30] +#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[31] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[32] +#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[33] +#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[34] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[36] +#define SWIGTYPE_p_mfem__GridFunction swig_types[37] +#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[38] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[39] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[40] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[41] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[42] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[43] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[44] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[45] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[46] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[47] +#define SWIGTYPE_p_mfem__LinearForm swig_types[48] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[49] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[50] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[51] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[52] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[53] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[56] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[57] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[60] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[61] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[62] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[63] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[64] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[65] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[66] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[69] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[70] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[76] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[77] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[78] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[79] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[80] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[81] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[84] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[85] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[91] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[92] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[93] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[94] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[95] +#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[96] +#define SWIGTYPE_p_mfem__ParGridFunction swig_types[97] +#define SWIGTYPE_p_mfem__ParMesh swig_types[98] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[99] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[100] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[101] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[102] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[103] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[104] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[105] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[106] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[107] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[108] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[109] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[110] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[111] +#define SWIGTYPE_p_mfem__Vector swig_types[112] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[113] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[114] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[115] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[116] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[117] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[118] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[119] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[120] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[121] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[122] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[123] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[124] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[125] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[126] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[127] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[128] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[129] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[130] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[131] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[132] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[133] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[134] +#define SWIGTYPE_p_p_mfem__Coefficient swig_types[135] +#define SWIGTYPE_p_p_mfem__ConstantCoefficient swig_types[136] +#define SWIGTYPE_p_p_mfem__DeltaCoefficient swig_types[137] +#define SWIGTYPE_p_p_mfem__DeterminantCoefficient swig_types[138] +#define SWIGTYPE_p_p_mfem__DivergenceGridFunctionCoefficient swig_types[139] +#define SWIGTYPE_p_p_mfem__ExtrudeCoefficient swig_types[140] +#define SWIGTYPE_p_p_mfem__FunctionCoefficient swig_types[141] +#define SWIGTYPE_p_p_mfem__GridFunctionCoefficient swig_types[142] +#define SWIGTYPE_p_p_mfem__InnerProductCoefficient swig_types[143] +#define SWIGTYPE_p_p_mfem__PWConstCoefficient swig_types[144] +#define SWIGTYPE_p_p_mfem__PowerCoefficient swig_types[145] +#define SWIGTYPE_p_p_mfem__ProductCoefficient swig_types[146] +#define SWIGTYPE_p_p_mfem__PyCoefficientBase swig_types[147] +#define SWIGTYPE_p_p_mfem__RestrictedCoefficient swig_types[148] +#define SWIGTYPE_p_p_mfem__SumCoefficient swig_types[149] +#define SWIGTYPE_p_p_mfem__TransformedCoefficient swig_types[150] +#define SWIGTYPE_p_p_mfem__VectorRotProductCoefficient swig_types[151] +#define SWIGTYPE_p_pri_t swig_types[152] +#define SWIGTYPE_p_quad_t swig_types[153] +#define SWIGTYPE_p_seg_t swig_types[154] +#define SWIGTYPE_p_std__istream swig_types[155] +#define SWIGTYPE_p_tet_t swig_types[156] +#define SWIGTYPE_p_tri_t swig_types[157] +static swig_type_info *swig_types[159]; +static swig_module_info swig_module = {swig_types, 158, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3570,6 +3572,20 @@ SWIG_AsVal_int (PyObject * obj, int *val) return res; } + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + SWIGINTERN mfem::ParGridFunction *new_mfem_ParGridFunction__SWIG_9(mfem::ParFiniteElementSpace *fes,mfem::Vector const &v,int offset){ mfem::ParGridFunction *gf; gf = new mfem::ParGridFunction(fes, v.GetData() + offset); @@ -4360,7 +4376,120 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SetSpace(PyObject *self, PyObject *ar } -SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_MakeRef" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_MakeRef" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -4403,7 +4532,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; @@ -4446,7 +4575,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -4499,7 +4628,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_2(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; @@ -4560,6 +4689,30 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef(PyObject *self, PyObject *arg if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_MakeRef", 0, 4, argv))) SWIG_fail; --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParGridFunction_MakeRef__SWIG_0_1(self, argc, argv); + } + } + } + } if (argc == 3) { int _v; void *vptr = 0; @@ -4574,7 +4727,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_MakeRef__SWIG_1(self, argc, argv); + return _wrap_ParGridFunction_MakeRef__SWIG_2(self, argc, argv); } } } @@ -4593,7 +4746,41 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_MakeRef__SWIG_0(self, argc, argv); + return _wrap_ParGridFunction_MakeRef__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParGridFunction_MakeRef__SWIG_0_0(self, argc, argv); + } } } } @@ -4621,7 +4808,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_ParGridFunction_MakeRef__SWIG_3(self, argc, argv); + return _wrap_ParGridFunction_MakeRef__SWIG_4(self, argc, argv); } } } @@ -4650,7 +4837,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_ParGridFunction_MakeRef__SWIG_2(self, argc, argv); + return _wrap_ParGridFunction_MakeRef__SWIG_3(self, argc, argv); } } } @@ -4660,6 +4847,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_MakeRef(PyObject *self, PyObject *arg fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_MakeRef'.\n" " Possible C/C++ prototypes are:\n" + " MakeRef(mfem::Vector &,int,int)\n" + " MakeRef(mfem::Vector &,int)\n" " mfem::ParGridFunction::MakeRef(mfem::FiniteElementSpace *,double *)\n" " mfem::ParGridFunction::MakeRef(mfem::ParFiniteElementSpace *,double *)\n" " mfem::ParGridFunction::MakeRef(mfem::FiniteElementSpace *,mfem::Vector &,int)\n" @@ -9289,7 +9478,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNU mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - int arg4 ; + bool arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -9297,6 +9486,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); @@ -9320,12 +9511,11 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParGridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -9352,13 +9542,15 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNU mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - int arg4 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); @@ -9382,12 +9574,11 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParGridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { try { (arg1)->ComputeFlux(*arg2,*arg3,arg4); @@ -9494,12 +9685,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux(PyObject *self, PyObject _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { return _wrap_ParGridFunction_ComputeFlux__SWIG_1(self, argc, argv); @@ -9523,12 +9710,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux(PyObject *self, PyObject _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { { @@ -9551,8 +9734,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux(PyObject *self, PyObject fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_ComputeFlux'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,int,int)\n" - " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,int)\n" + " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool,int)\n" + " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool)\n" " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &)\n"); return 0; } @@ -10795,6 +10978,7 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "GlobalLpNorm", _wrap_GlobalLpNorm, METH_VARARGS, "GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double"}, { "ParGridFunction_ParFESpace", _wrap_ParGridFunction_ParFESpace, METH_O, "ParGridFunction_ParFESpace(ParGridFunction self) -> ParFiniteElementSpace"}, { "ParGridFunction_Update", _wrap_ParGridFunction_Update, METH_O, "ParGridFunction_Update(ParGridFunction self)"}, @@ -10803,6 +10987,8 @@ static PyMethodDef SwigMethods[] = { "ParGridFunction_SetSpace(ParGridFunction self, ParFiniteElementSpace f)\n" ""}, { "ParGridFunction_MakeRef", _wrap_ParGridFunction_MakeRef, METH_VARARGS, "\n" + "ParGridFunction_MakeRef(ParGridFunction self, Vector base, int offset, int size)\n" + "ParGridFunction_MakeRef(ParGridFunction self, Vector base, int offset)\n" "ParGridFunction_MakeRef(ParGridFunction self, FiniteElementSpace f, double * v)\n" "ParGridFunction_MakeRef(ParGridFunction self, ParFiniteElementSpace f, double * v)\n" "ParGridFunction_MakeRef(ParGridFunction self, FiniteElementSpace f, Vector v, int v_offset)\n" @@ -10896,7 +11082,7 @@ static PyMethodDef SwigMethods[] = { "ParGridFunction_ComputeLpError(ParGridFunction self, double const p, Coefficient exsol, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" "ParGridFunction_ComputeLpError(ParGridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" ""}, - { "ParGridFunction_ComputeFlux", _wrap_ParGridFunction_ComputeFlux, METH_VARARGS, "ParGridFunction_ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, int wcoef=1, int subdomain=-1)"}, + { "ParGridFunction_ComputeFlux", _wrap_ParGridFunction_ComputeFlux, METH_VARARGS, "ParGridFunction_ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "delete_ParGridFunction", _wrap_delete_ParGridFunction, METH_O, "delete_ParGridFunction(ParGridFunction self)"}, { "new_ParGridFunction", _wrap_new_ParGridFunction, METH_VARARGS, "\n" "ParGridFunction()\n" @@ -10924,6 +11110,135 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "GlobalLpNorm", _wrap_GlobalLpNorm, METH_VARARGS, "GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double"}, + { "ParGridFunction_ParFESpace", _wrap_ParGridFunction_ParFESpace, METH_O, "ParFESpace(ParGridFunction self) -> ParFiniteElementSpace"}, + { "ParGridFunction_Update", _wrap_ParGridFunction_Update, METH_O, "Update(ParGridFunction self)"}, + { "ParGridFunction_SetSpace", _wrap_ParGridFunction_SetSpace, METH_VARARGS, "\n" + "SetSpace(ParGridFunction self, FiniteElementSpace f)\n" + "SetSpace(ParGridFunction self, ParFiniteElementSpace f)\n" + ""}, + { "ParGridFunction_MakeRef", _wrap_ParGridFunction_MakeRef, METH_VARARGS, "\n" + "MakeRef(ParGridFunction self, Vector base, int offset, int size)\n" + "MakeRef(ParGridFunction self, Vector base, int offset)\n" + "MakeRef(ParGridFunction self, FiniteElementSpace f, double * v)\n" + "MakeRef(ParGridFunction self, ParFiniteElementSpace f, double * v)\n" + "MakeRef(ParGridFunction self, FiniteElementSpace f, Vector v, int v_offset)\n" + "MakeRef(ParGridFunction self, ParFiniteElementSpace f, Vector v, int v_offset)\n" + ""}, + { "ParGridFunction_Distribute", _wrap_ParGridFunction_Distribute, METH_VARARGS, "\n" + "Distribute(ParGridFunction self, Vector tv)\n" + "Distribute(ParGridFunction self, Vector tv)\n" + ""}, + { "ParGridFunction_AddDistribute", _wrap_ParGridFunction_AddDistribute, METH_VARARGS, "\n" + "AddDistribute(ParGridFunction self, double a, Vector tv)\n" + "AddDistribute(ParGridFunction self, double a, Vector tv)\n" + ""}, + { "ParGridFunction_SetFromTrueDofs", _wrap_ParGridFunction_SetFromTrueDofs, METH_VARARGS, "SetFromTrueDofs(ParGridFunction self, Vector tv)"}, + { "ParGridFunction_Assign", _wrap_ParGridFunction_Assign, METH_VARARGS, "\n" + "Assign(ParGridFunction self, ParGridFunction rhs) -> ParGridFunction\n" + "Assign(ParGridFunction self, double value) -> ParGridFunction\n" + "Assign(ParGridFunction self, Vector v) -> ParGridFunction\n" + "Assign(ParGridFunction self, HypreParVector tv) -> ParGridFunction\n" + ""}, + { "ParGridFunction_GetTrueDofs", _wrap_ParGridFunction_GetTrueDofs, METH_VARARGS, "\n" + "GetTrueDofs(ParGridFunction self, Vector tv)\n" + "GetTrueDofs(ParGridFunction self) -> HypreParVector\n" + ""}, + { "ParGridFunction_ParallelAverage", _wrap_ParGridFunction_ParallelAverage, METH_VARARGS, "\n" + "ParallelAverage(ParGridFunction self, Vector tv)\n" + "ParallelAverage(ParGridFunction self, HypreParVector tv)\n" + "ParallelAverage(ParGridFunction self) -> HypreParVector\n" + ""}, + { "ParGridFunction_ParallelProject", _wrap_ParGridFunction_ParallelProject, METH_VARARGS, "\n" + "ParallelProject(ParGridFunction self, Vector tv)\n" + "ParallelProject(ParGridFunction self, HypreParVector tv)\n" + "ParallelProject(ParGridFunction self) -> HypreParVector\n" + ""}, + { "ParGridFunction_ParallelAssemble", _wrap_ParGridFunction_ParallelAssemble, METH_VARARGS, "\n" + "ParallelAssemble(ParGridFunction self, Vector tv)\n" + "ParallelAssemble(ParGridFunction self, HypreParVector tv)\n" + "ParallelAssemble(ParGridFunction self) -> HypreParVector\n" + ""}, + { "ParGridFunction_ExchangeFaceNbrData", _wrap_ParGridFunction_ExchangeFaceNbrData, METH_O, "ExchangeFaceNbrData(ParGridFunction self)"}, + { "ParGridFunction_FaceNbrData", _wrap_ParGridFunction_FaceNbrData, METH_VARARGS, "\n" + "FaceNbrData(ParGridFunction self) -> Vector\n" + "FaceNbrData(ParGridFunction self) -> Vector\n" + ""}, + { "ParGridFunction_GetValue", _wrap_ParGridFunction_GetValue, METH_VARARGS, "\n" + "GetValue(ParGridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double\n" + "GetValue(ParGridFunction self, ElementTransformation T) -> double\n" + ""}, + { "ParGridFunction_ProjectCoefficient", _wrap_ParGridFunction_ProjectCoefficient, METH_VARARGS, "\n" + "ProjectCoefficient(ParGridFunction self, Coefficient coeff)\n" + "ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" + "ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs)\n" + "ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff)\n" + "ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray dofs)\n" + "ProjectCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff)\n" + "ProjectCoefficient(ParGridFunction self, Coefficient coeff)\n" + ""}, + { "ParGridFunction_ProjectDiscCoefficient", _wrap_ParGridFunction_ProjectDiscCoefficient, METH_VARARGS, "\n" + "ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff, intArray dof_attr)\n" + "ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff)\n" + "ProjectDiscCoefficient(ParGridFunction self, Coefficient coeff, mfem::GridFunction::AvgType type)\n" + "ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff, mfem::GridFunction::AvgType type)\n" + "ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient coeff)\n" + "ProjectDiscCoefficient(ParGridFunction self, Coefficient coeff, mfem::GridFunction::AvgType type)\n" + "ProjectDiscCoefficient(ParGridFunction self, VectorCoefficient vcoeff, mfem::GridFunction::AvgType type)\n" + ""}, + { "ParGridFunction_ProjectBdrCoefficient", _wrap_ParGridFunction_ProjectBdrCoefficient, METH_VARARGS, "\n" + "ProjectBdrCoefficient(ParGridFunction self, Coefficient coeff, intArray attr)\n" + "ProjectBdrCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray attr)\n" + "ProjectBdrCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" + "ProjectBdrCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray attr)\n" + "ProjectBdrCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" + ""}, + { "ParGridFunction_ProjectBdrCoefficientTangent", _wrap_ParGridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "ProjectBdrCoefficientTangent(ParGridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "ParGridFunction_ComputeL1Error", _wrap_ParGridFunction_ComputeL1Error, METH_VARARGS, "\n" + "ComputeL1Error(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL1Error(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL1Error(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "ParGridFunction_ComputeL2Error", _wrap_ParGridFunction_ComputeL2Error, METH_VARARGS, "\n" + "ComputeL2Error(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL2Error(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL2Error(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double\n" + ""}, + { "ParGridFunction_ComputeMaxError", _wrap_ParGridFunction_ComputeMaxError, METH_VARARGS, "\n" + "ComputeMaxError(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeMaxError(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeMaxError(ParGridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "ParGridFunction_ComputeLpError", _wrap_ParGridFunction_ComputeLpError, METH_VARARGS, "\n" + "ComputeLpError(ParGridFunction self, double const p, Coefficient exsol, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeLpError(ParGridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "ParGridFunction_ComputeFlux", _wrap_ParGridFunction_ComputeFlux, METH_VARARGS, "ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "delete_ParGridFunction", _wrap_delete_ParGridFunction, METH_O, "delete_ParGridFunction(ParGridFunction self)"}, + { "new_ParGridFunction", _wrap_new_ParGridFunction, METH_VARARGS, "\n" + "ParGridFunction()\n" + "ParGridFunction(ParGridFunction orig)\n" + "ParGridFunction(ParFiniteElementSpace pf)\n" + "ParGridFunction(ParFiniteElementSpace pf, double * data)\n" + "ParGridFunction(ParFiniteElementSpace pf, GridFunction gf)\n" + "ParGridFunction(ParFiniteElementSpace pf, HypreParVector tv)\n" + "ParGridFunction(ParMesh pmesh, GridFunction gf, int const * partitioning=None)\n" + "ParGridFunction(ParMesh pmesh, std::istream & input)\n" + "new_ParGridFunction(ParFiniteElementSpace fes, Vector v, int offset) -> ParGridFunction\n" + ""}, + { "ParGridFunction_Save", _wrap_ParGridFunction_Save, METH_VARARGS, "\n" + "Save(ParGridFunction self, std::ostream & out)\n" + "Save(ParGridFunction self, char const * file, int precision=8)\n" + ""}, + { "ParGridFunction_SaveAsOne", _wrap_ParGridFunction_SaveAsOne, METH_VARARGS, "\n" + "SaveAsOne(ParGridFunction self, std::ostream & out=mfem::out)\n" + "SaveAsOne(ParGridFunction self, char const * file, int precision=8)\n" + ""}, + { "ParGridFunction_swigregister", ParGridFunction_swigregister, METH_O, NULL}, + { "ParGridFunction_swiginit", ParGridFunction_swiginit, METH_VARARGS, NULL}, + { "L2ZZErrorEstimator", _wrap_L2ZZErrorEstimator, METH_VARARGS, "L2ZZErrorEstimator(BilinearFormIntegrator flux_integrator, ParGridFunction x, ParFiniteElementSpace smooth_flux_fes, ParFiniteElementSpace flux_fes, Vector errors, int norm_p=2, double solver_tol=1e-12, int solver_max_it=200) -> double"}, { NULL, NULL, 0, NULL } }; @@ -10996,6 +11311,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -11125,9 +11443,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -11152,6 +11467,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -11324,13 +11642,13 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -11341,6 +11659,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -11362,6 +11681,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -11394,8 +11714,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -11404,6 +11723,7 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Coefficient = {"_p_mfem__Coefficient", "mfem::Coefficient *", 0, 0, (void*)0, 0}; @@ -11482,6 +11802,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_hex_t, @@ -11512,6 +11833,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__FunctionCoefficient, &_swigt__p_mfem__GradientGridFunctionCoefficient, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GridFunctionCoefficient, @@ -11640,12 +11962,12 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -11656,6 +11978,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -11677,6 +12000,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -11709,8 +12033,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -11719,9 +12042,10 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyCoefficientBase[] = {{&_swigt__p_mfem__PyCoefficientBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DeterminantCoefficient[] = {{&_swigt__p_mfem__DeterminantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorRotProductCoefficient[] = {{&_swigt__p_mfem__VectorRotProductCoefficient, 0, 0, 0},{0, 0, 0, 0}}; @@ -11798,6 +12122,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_hex_t, @@ -11828,6 +12153,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__FunctionCoefficient, _swigc__p_mfem__GradientGridFunctionCoefficient, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GridFunctionCoefficient, @@ -12679,18 +13005,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/plinearform.py b/mfem/_par/plinearform.py index 99396dd2..ac89ed85 100644 --- a/mfem/_par/plinearform.py +++ b/mfem/_par/plinearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _plinearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _plinearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -90,6 +93,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -100,6 +104,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.pfespace import mfem._par.pmesh @@ -117,6 +122,7 @@ def __init__(self, *args): r""" __init__(ParLinearForm self) -> ParLinearForm __init__(ParLinearForm self, ParFiniteElementSpace pf) -> ParLinearForm + __init__(ParLinearForm self, ParFiniteElementSpace pf, double * data) -> ParLinearForm __init__(ParLinearForm self, ParFiniteElementSpace pf, ParLinearForm plf) -> ParLinearForm """ _plinearform.ParLinearForm_swiginit(self, _plinearform.new_ParLinearForm(*args)) @@ -124,6 +130,7 @@ def __init__(self, *args): def ParFESpace(self): r"""ParFESpace(ParLinearForm self) -> ParFiniteElementSpace""" return _plinearform.ParLinearForm_ParFESpace(self) + ParFESpace = _swig_new_instance_method(_plinearform.ParLinearForm_ParFESpace) def Update(self, *args): r""" @@ -131,6 +138,7 @@ def Update(self, *args): Update(ParLinearForm self, ParFiniteElementSpace pf, Vector v, int v_offset) """ return _plinearform.ParLinearForm_Update(self, *args) + Update = _swig_new_instance_method(_plinearform.ParLinearForm_Update) def ParallelAssemble(self, *args): r""" @@ -138,10 +146,12 @@ def ParallelAssemble(self, *args): ParallelAssemble(ParLinearForm self) -> HypreParVector """ return _plinearform.ParLinearForm_ParallelAssemble(self, *args) + ParallelAssemble = _swig_new_instance_method(_plinearform.ParLinearForm_ParallelAssemble) def __call__(self, gf): r"""__call__(ParLinearForm self, ParGridFunction gf) -> double""" return _plinearform.ParLinearForm___call__(self, gf) + __call__ = _swig_new_instance_method(_plinearform.ParLinearForm___call__) __swig_destroy__ = _plinearform.delete_ParLinearForm # Register ParLinearForm in _plinearform: diff --git a/mfem/_par/plinearform_wrap.cxx b/mfem/_par/plinearform_wrap.cxx index 46a99c14..edd70262 100644 --- a/mfem/_par/plinearform_wrap.cxx +++ b/mfem/_par/plinearform_wrap.cxx @@ -3069,27 +3069,29 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_hex_t swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_mfem__GridFunction swig_types[7] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[8] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[9] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[10] -#define SWIGTYPE_p_mfem__LinearForm swig_types[11] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[12] -#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[13] -#define SWIGTYPE_p_mfem__ParGridFunction swig_types[14] -#define SWIGTYPE_p_mfem__ParLinearForm swig_types[15] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[16] -#define SWIGTYPE_p_mfem__Vector swig_types[17] -#define SWIGTYPE_p_pri_t swig_types[18] -#define SWIGTYPE_p_quad_t swig_types[19] -#define SWIGTYPE_p_seg_t swig_types[20] -#define SWIGTYPE_p_tet_t swig_types[21] -#define SWIGTYPE_p_tri_t swig_types[22] -static swig_type_info *swig_types[24]; -static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_char swig_types[5] +#define SWIGTYPE_p_double swig_types[6] +#define SWIGTYPE_p_hex_t swig_types[7] +#define SWIGTYPE_p_int swig_types[8] +#define SWIGTYPE_p_mfem__GridFunction swig_types[9] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[10] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[11] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[12] +#define SWIGTYPE_p_mfem__LinearForm swig_types[13] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[14] +#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[15] +#define SWIGTYPE_p_mfem__ParGridFunction swig_types[16] +#define SWIGTYPE_p_mfem__ParLinearForm swig_types[17] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[18] +#define SWIGTYPE_p_mfem__Vector swig_types[19] +#define SWIGTYPE_p_pri_t swig_types[20] +#define SWIGTYPE_p_quad_t swig_types[21] +#define SWIGTYPE_p_seg_t swig_types[22] +#define SWIGTYPE_p_tet_t swig_types[23] +#define SWIGTYPE_p_tri_t swig_types[24] +static swig_type_info *swig_types[26]; +static swig_module_info swig_module = {swig_types, 25, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3317,6 +3319,42 @@ SWIGINTERN PyObject *_wrap_new_ParLinearForm__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *_wrap_new_ParLinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; + double *arg2 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::ParLinearForm *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParLinearForm" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParLinearForm" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (mfem::ParLinearForm *)new mfem::ParLinearForm(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParLinearForm, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ParLinearForm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::ParLinearForm *arg2 = (mfem::ParLinearForm *) 0 ; @@ -3379,19 +3417,34 @@ SWIGINTERN PyObject *_wrap_new_ParLinearForm(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParLinearForm, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ParLinearForm__SWIG_2(self, argc, argv); } } } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParLinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ParLinearForm__SWIG_3(self, argc, argv); + } + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ParLinearForm'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParLinearForm::ParLinearForm()\n" " mfem::ParLinearForm::ParLinearForm(mfem::ParFiniteElementSpace *)\n" + " mfem::ParLinearForm::ParLinearForm(mfem::ParFiniteElementSpace *,double *)\n" " mfem::ParLinearForm::ParLinearForm(mfem::ParFiniteElementSpace *,mfem::ParLinearForm *)\n"); return 0; } @@ -3802,9 +3855,11 @@ SWIGINTERN PyObject *ParLinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_ParLinearForm", _wrap_new_ParLinearForm, METH_VARARGS, "\n" "ParLinearForm()\n" "ParLinearForm(ParFiniteElementSpace pf)\n" + "ParLinearForm(ParFiniteElementSpace pf, double * data)\n" "new_ParLinearForm(ParFiniteElementSpace pf, ParLinearForm plf) -> ParLinearForm\n" ""}, { "ParLinearForm_ParFESpace", _wrap_ParLinearForm_ParFESpace, METH_O, "ParLinearForm_ParFESpace(ParLinearForm self) -> ParFiniteElementSpace"}, @@ -3824,6 +3879,27 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ParLinearForm", _wrap_new_ParLinearForm, METH_VARARGS, "\n" + "ParLinearForm()\n" + "ParLinearForm(ParFiniteElementSpace pf)\n" + "ParLinearForm(ParFiniteElementSpace pf, double * data)\n" + "new_ParLinearForm(ParFiniteElementSpace pf, ParLinearForm plf) -> ParLinearForm\n" + ""}, + { "ParLinearForm_ParFESpace", _wrap_ParLinearForm_ParFESpace, METH_O, "ParFESpace(ParLinearForm self) -> ParFiniteElementSpace"}, + { "ParLinearForm_Update", _wrap_ParLinearForm_Update, METH_VARARGS, "\n" + "Update(ParLinearForm self, ParFiniteElementSpace pf=None)\n" + "Update(ParLinearForm self, ParFiniteElementSpace pf, Vector v, int v_offset)\n" + ""}, + { "ParLinearForm_ParallelAssemble", _wrap_ParLinearForm_ParallelAssemble, METH_VARARGS, "\n" + "ParallelAssemble(ParLinearForm self, Vector tv)\n" + "ParallelAssemble(ParLinearForm self) -> HypreParVector\n" + ""}, + { "ParLinearForm___call__", _wrap_ParLinearForm___call__, METH_VARARGS, "__call__(ParLinearForm self, ParGridFunction gf) -> double"}, + { "delete_ParLinearForm", _wrap_delete_ParLinearForm, METH_O, "delete_ParLinearForm(ParLinearForm self)"}, + { "ParLinearForm_swigregister", ParLinearForm_swigregister, METH_O, NULL}, + { "ParLinearForm_swiginit", ParLinearForm_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -3858,7 +3934,9 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; @@ -3883,7 +3961,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, + &_swigt__p_double, &_swigt__p_hex_t, &_swigt__p_int, &_swigt__p_mfem__GridFunction, @@ -3908,7 +3988,9 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0}, {&_swigt__p_mfem__ParGridFunction, _p_mfem__ParGridFunctionTo_p_mfem__GridFunction, 0, 0},{0, 0, 0, 0}}; @@ -3933,7 +4015,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, + _swigc__p_double, _swigc__p_hex_t, _swigc__p_int, _swigc__p_mfem__GridFunction, @@ -4681,18 +4765,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pmesh.py b/mfem/_par/pmesh.py index 313ec315..85dd8923 100644 --- a/mfem/_par/pmesh.py +++ b/mfem/_par/pmesh.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _pmesh.SWIG_PyInstanceMethod_New +_swig_new_static_method = _pmesh.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -94,6 +97,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.mem_manager import mfem._par.operators import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.densemat import mfem._par.geom @@ -111,6 +115,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform import mfem._par.pncmesh @@ -125,18 +130,27 @@ class ParMesh(mfem._par.mesh.Mesh): def Finalize(self, refine=False, fix_orientation=False): r"""Finalize(ParMesh self, bool refine=False, bool fix_orientation=False)""" return _pmesh.ParMesh_Finalize(self, refine, fix_orientation) + Finalize = _swig_new_instance_method(_pmesh.ParMesh_Finalize) + + def SetAttributes(self): + r"""SetAttributes(ParMesh self)""" + return _pmesh.ParMesh_SetAttributes(self) + SetAttributes = _swig_new_instance_method(_pmesh.ParMesh_SetAttributes) def GetComm(self): r"""GetComm(ParMesh self) -> MPI_Comm""" return _pmesh.ParMesh_GetComm(self) + GetComm = _swig_new_instance_method(_pmesh.ParMesh_GetComm) def GetNRanks(self): r"""GetNRanks(ParMesh self) -> int""" return _pmesh.ParMesh_GetNRanks(self) + GetNRanks = _swig_new_instance_method(_pmesh.ParMesh_GetNRanks) def GetMyRank(self): r"""GetMyRank(ParMesh self) -> int""" return _pmesh.ParMesh_GetMyRank(self) + GetMyRank = _swig_new_instance_method(_pmesh.ParMesh_GetMyRank) gtopo = property(_pmesh.ParMesh_gtopo_get, doc=r"""gtopo : mfem::GroupTopology""") have_face_nbr_data = property(_pmesh.ParMesh_have_face_nbr_data_get, _pmesh.ParMesh_have_face_nbr_data_set, doc=r"""have_face_nbr_data : bool""") face_nbr_group = property(_pmesh.ParMesh_face_nbr_group_get, _pmesh.ParMesh_face_nbr_group_set, doc=r"""face_nbr_group : mfem::Array<(int)>""") @@ -151,26 +165,32 @@ def GetMyRank(self): def GetNGroups(self): r"""GetNGroups(ParMesh self) -> int""" return _pmesh.ParMesh_GetNGroups(self) + GetNGroups = _swig_new_instance_method(_pmesh.ParMesh_GetNGroups) def GroupNVertices(self, group): r"""GroupNVertices(ParMesh self, int group) -> int""" return _pmesh.ParMesh_GroupNVertices(self, group) + GroupNVertices = _swig_new_instance_method(_pmesh.ParMesh_GroupNVertices) def GroupNEdges(self, group): r"""GroupNEdges(ParMesh self, int group) -> int""" return _pmesh.ParMesh_GroupNEdges(self, group) + GroupNEdges = _swig_new_instance_method(_pmesh.ParMesh_GroupNEdges) def GroupNTriangles(self, group): r"""GroupNTriangles(ParMesh self, int group) -> int""" return _pmesh.ParMesh_GroupNTriangles(self, group) + GroupNTriangles = _swig_new_instance_method(_pmesh.ParMesh_GroupNTriangles) def GroupNQuadrilaterals(self, group): r"""GroupNQuadrilaterals(ParMesh self, int group) -> int""" return _pmesh.ParMesh_GroupNQuadrilaterals(self, group) + GroupNQuadrilaterals = _swig_new_instance_method(_pmesh.ParMesh_GroupNQuadrilaterals) def GroupVertex(self, group, i): r"""GroupVertex(ParMesh self, int group, int i) -> int""" return _pmesh.ParMesh_GroupVertex(self, group, i) + GroupVertex = _swig_new_instance_method(_pmesh.ParMesh_GroupVertex) def GroupEdge(self, group, i, *args): if len(args) == 0: @@ -187,62 +207,85 @@ def GroupEdge(self, group, i, *args): def GroupTriangle(self, group, i, face, o): r"""GroupTriangle(ParMesh self, int group, int i, int & face, int & o)""" return _pmesh.ParMesh_GroupTriangle(self, group, i, face, o) + GroupTriangle = _swig_new_instance_method(_pmesh.ParMesh_GroupTriangle) def GroupQuadrilateral(self, group, i, face, o): r"""GroupQuadrilateral(ParMesh self, int group, int i, int & face, int & o)""" return _pmesh.ParMesh_GroupQuadrilateral(self, group, i, face, o) + GroupQuadrilateral = _swig_new_instance_method(_pmesh.ParMesh_GroupQuadrilateral) def GenerateOffsets(self, N, loc_sizes, offsets): r"""GenerateOffsets(ParMesh self, int N, HYPRE_Int [] loc_sizes, mfem::Array< HYPRE_Int > *[] offsets)""" return _pmesh.ParMesh_GenerateOffsets(self, N, loc_sizes, offsets) + GenerateOffsets = _swig_new_instance_method(_pmesh.ParMesh_GenerateOffsets) def ExchangeFaceNbrData(self): r"""ExchangeFaceNbrData(ParMesh self)""" return _pmesh.ParMesh_ExchangeFaceNbrData(self) + ExchangeFaceNbrData = _swig_new_instance_method(_pmesh.ParMesh_ExchangeFaceNbrData) def ExchangeFaceNbrNodes(self): r"""ExchangeFaceNbrNodes(ParMesh self)""" return _pmesh.ParMesh_ExchangeFaceNbrNodes(self) + ExchangeFaceNbrNodes = _swig_new_instance_method(_pmesh.ParMesh_ExchangeFaceNbrNodes) + + def SetCurvature(self, order, discont=False, space_dim=-1, ordering=1): + r"""SetCurvature(ParMesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)""" + return _pmesh.ParMesh_SetCurvature(self, order, discont, space_dim, ordering) + SetCurvature = _swig_new_instance_method(_pmesh.ParMesh_SetCurvature) def GetNFaceNeighbors(self): r"""GetNFaceNeighbors(ParMesh self) -> int""" return _pmesh.ParMesh_GetNFaceNeighbors(self) + GetNFaceNeighbors = _swig_new_instance_method(_pmesh.ParMesh_GetNFaceNeighbors) def GetFaceNbrGroup(self, fn): r"""GetFaceNbrGroup(ParMesh self, int fn) -> int""" return _pmesh.ParMesh_GetFaceNbrGroup(self, fn) + GetFaceNbrGroup = _swig_new_instance_method(_pmesh.ParMesh_GetFaceNbrGroup) def GetFaceNbrRank(self, fn): r"""GetFaceNbrRank(ParMesh self, int fn) -> int""" return _pmesh.ParMesh_GetFaceNbrRank(self, fn) + GetFaceNbrRank = _swig_new_instance_method(_pmesh.ParMesh_GetFaceNbrRank) def GetFaceToAllElementTable(self): r"""GetFaceToAllElementTable(ParMesh self) -> Table""" return _pmesh.ParMesh_GetFaceToAllElementTable(self) + GetFaceToAllElementTable = _swig_new_instance_method(_pmesh.ParMesh_GetFaceToAllElementTable) def GetSharedFaceTransformations(self, sf, fill2=True): r"""GetSharedFaceTransformations(ParMesh self, int sf, bool fill2=True) -> FaceElementTransformations""" return _pmesh.ParMesh_GetSharedFaceTransformations(self, sf, fill2) + GetSharedFaceTransformations = _swig_new_instance_method(_pmesh.ParMesh_GetSharedFaceTransformations) def GetNSharedFaces(self): r"""GetNSharedFaces(ParMesh self) -> int""" return _pmesh.ParMesh_GetNSharedFaces(self) + GetNSharedFaces = _swig_new_instance_method(_pmesh.ParMesh_GetNSharedFaces) def GetSharedFace(self, sface): r"""GetSharedFace(ParMesh self, int sface) -> int""" return _pmesh.ParMesh_GetSharedFace(self, sface) + GetSharedFace = _swig_new_instance_method(_pmesh.ParMesh_GetSharedFace) def ReorientTetMesh(self): r"""ReorientTetMesh(ParMesh self)""" return _pmesh.ParMesh_ReorientTetMesh(self) + ReorientTetMesh = _swig_new_instance_method(_pmesh.ParMesh_ReorientTetMesh) def ReduceInt(self, value): r"""ReduceInt(ParMesh self, int value) -> long""" return _pmesh.ParMesh_ReduceInt(self, value) + ReduceInt = _swig_new_instance_method(_pmesh.ParMesh_ReduceInt) - def Rebalance(self): - r"""Rebalance(ParMesh self)""" - return _pmesh.ParMesh_Rebalance(self) + def Rebalance(self, *args): + r""" + Rebalance(ParMesh self) + Rebalance(ParMesh self, intArray partition) + """ + return _pmesh.ParMesh_Rebalance(self, *args) + Rebalance = _swig_new_instance_method(_pmesh.ParMesh_Rebalance) def GetBoundingBox(self, ref = 2): from .vector import Vector @@ -256,14 +299,17 @@ def GetBoundingBox(self, ref = 2): def GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max): r"""GetCharacteristics(ParMesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max)""" return _pmesh.ParMesh_GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max) + GetCharacteristics = _swig_new_instance_method(_pmesh.ParMesh_GetCharacteristics) def FindPoints(self, point_mat, elem_ids, ips, warn=True, inv_trans=None): r"""FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int""" return _pmesh.ParMesh_FindPoints(self, point_mat, elem_ids, ips, warn, inv_trans) + FindPoints = _swig_new_instance_method(_pmesh.ParMesh_FindPoints) def PrintSharedEntities(self, fname_prefix): r"""PrintSharedEntities(ParMesh self, char const * fname_prefix)""" return _pmesh.ParMesh_PrintSharedEntities(self, fname_prefix) + PrintSharedEntities = _swig_new_instance_method(_pmesh.ParMesh_PrintSharedEntities) __swig_destroy__ = _pmesh.delete_ParMesh def __init__(self, *args): @@ -279,6 +325,7 @@ def __init__(self, *args): def ParPrintToFile(self, mesh_file, precision): r"""ParPrintToFile(ParMesh self, char const * mesh_file, int const precision)""" return _pmesh.ParMesh_ParPrintToFile(self, mesh_file, precision) + ParPrintToFile = _swig_new_instance_method(_pmesh.ParMesh_ParPrintToFile) def Print(self, *args): r""" @@ -286,6 +333,7 @@ def Print(self, *args): Print(ParMesh self, char const * file, int precision=8) """ return _pmesh.ParMesh_Print(self, *args) + Print = _swig_new_instance_method(_pmesh.ParMesh_Print) def PrintXG(self, *args): r""" @@ -293,6 +341,7 @@ def PrintXG(self, *args): PrintXG(ParMesh self, char const * file, int precision=8) """ return _pmesh.ParMesh_PrintXG(self, *args) + PrintXG = _swig_new_instance_method(_pmesh.ParMesh_PrintXG) def PrintAsOne(self, *args): r""" @@ -300,6 +349,7 @@ def PrintAsOne(self, *args): PrintAsOne(ParMesh self, char const * file, int precision=8) """ return _pmesh.ParMesh_PrintAsOne(self, *args) + PrintAsOne = _swig_new_instance_method(_pmesh.ParMesh_PrintAsOne) def PrintAsOneXG(self, *args): r""" @@ -307,6 +357,7 @@ def PrintAsOneXG(self, *args): PrintAsOneXG(ParMesh self, char const * file, int precision=8) """ return _pmesh.ParMesh_PrintAsOneXG(self, *args) + PrintAsOneXG = _swig_new_instance_method(_pmesh.ParMesh_PrintAsOneXG) def PrintInfo(self, *args): r""" @@ -314,6 +365,7 @@ def PrintInfo(self, *args): PrintInfo(ParMesh self, char const * file, int precision=8) """ return _pmesh.ParMesh_PrintInfo(self, *args) + PrintInfo = _swig_new_instance_method(_pmesh.ParMesh_PrintInfo) def ParPrint(self, *args): r""" @@ -322,6 +374,7 @@ def ParPrint(self, *args): ParPrint(ParMesh self) """ return _pmesh.ParMesh_ParPrint(self, *args) + ParPrint = _swig_new_instance_method(_pmesh.ParMesh_ParPrint) # Register ParMesh in _pmesh: _pmesh.ParMesh_swigregister(ParMesh) diff --git a/mfem/_par/pmesh_wrap.cxx b/mfem/_par/pmesh_wrap.cxx index 745ebca9..9e94af04 100644 --- a/mfem/_par/pmesh_wrap.cxx +++ b/mfem/_par/pmesh_wrap.cxx @@ -3069,41 +3069,42 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_double swig_types[5] -#define SWIGTYPE_p_hex_t swig_types[6] -#define SWIGTYPE_p_int swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Element_p_t swig_types[9] -#define SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t swig_types[10] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t swig_types[11] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[12] -#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[13] -#define SWIGTYPE_p_mfem__GridFunction swig_types[14] -#define SWIGTYPE_p_mfem__GroupTopology swig_types[15] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[16] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[17] -#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[18] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[19] -#define SWIGTYPE_p_mfem__LinearForm swig_types[20] -#define SWIGTYPE_p_mfem__Mesh swig_types[21] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[22] -#define SWIGTYPE_p_mfem__ParMesh swig_types[23] -#define SWIGTYPE_p_mfem__ParNCMesh swig_types[24] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[25] -#define SWIGTYPE_p_mfem__STable swig_types[26] -#define SWIGTYPE_p_mfem__Table swig_types[27] -#define SWIGTYPE_p_mfem__Vector swig_types[28] -#define SWIGTYPE_p_p_mfem__ArrayT_int_t swig_types[29] -#define SWIGTYPE_p_pri_t swig_types[30] -#define SWIGTYPE_p_quad_t swig_types[31] -#define SWIGTYPE_p_seg_t swig_types[32] -#define SWIGTYPE_p_std__istream swig_types[33] -#define SWIGTYPE_p_tet_t swig_types[34] -#define SWIGTYPE_p_tri_t swig_types[35] -#define SWIGTYPE_p_void swig_types[36] -static swig_type_info *swig_types[38]; -static swig_module_info swig_module = {swig_types, 37, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_char swig_types[5] +#define SWIGTYPE_p_double swig_types[6] +#define SWIGTYPE_p_hex_t swig_types[7] +#define SWIGTYPE_p_int swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Element_p_t swig_types[10] +#define SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t swig_types[11] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t swig_types[12] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[13] +#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[14] +#define SWIGTYPE_p_mfem__GridFunction swig_types[15] +#define SWIGTYPE_p_mfem__GroupTopology swig_types[16] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[17] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[18] +#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[19] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[20] +#define SWIGTYPE_p_mfem__LinearForm swig_types[21] +#define SWIGTYPE_p_mfem__Mesh swig_types[22] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[23] +#define SWIGTYPE_p_mfem__ParMesh swig_types[24] +#define SWIGTYPE_p_mfem__ParNCMesh swig_types[25] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[26] +#define SWIGTYPE_p_mfem__STable swig_types[27] +#define SWIGTYPE_p_mfem__Table swig_types[28] +#define SWIGTYPE_p_mfem__Vector swig_types[29] +#define SWIGTYPE_p_p_mfem__ArrayT_int_t swig_types[30] +#define SWIGTYPE_p_pri_t swig_types[31] +#define SWIGTYPE_p_quad_t swig_types[32] +#define SWIGTYPE_p_seg_t swig_types[33] +#define SWIGTYPE_p_std__istream swig_types[34] +#define SWIGTYPE_p_tet_t swig_types[35] +#define SWIGTYPE_p_tri_t swig_types[36] +#define SWIGTYPE_p_void swig_types[37] +static swig_type_info *swig_types[39]; +static swig_module_info swig_module = {swig_types, 38, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4173,6 +4174,35 @@ SWIGINTERN PyObject *_wrap_ParMesh_Finalize(PyObject *self, PyObject *args) { } +SWIGINTERN PyObject *_wrap_ParMesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetAttributes" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + { + try { + (arg1)->SetAttributes(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_ParMesh_GetComm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; @@ -5214,6 +5244,331 @@ SWIGINTERN PyObject *_wrap_ParMesh_ExchangeFaceNbrNodes(PyObject *SWIGUNUSEDPARM } +SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + int arg2 ; + bool arg3 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + (arg1)->SetCurvature(arg2,arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + int arg2 ; + bool arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->SetCurvature(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + int arg2 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + { + try { + (arg1)->SetCurvature(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + (arg1)->SetCurvature(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_SetCurvature", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParMesh_SetCurvature__SWIG_3(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ParMesh_SetCurvature__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParMesh_SetCurvature__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParMesh_SetCurvature__SWIG_0(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_SetCurvature'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParMesh::SetCurvature(int,bool,int,int)\n" + " mfem::ParMesh::SetCurvature(int,bool,int)\n" + " mfem::ParMesh::SetCurvature(int,bool)\n" + " mfem::ParMesh::SetCurvature(int)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ParMesh_GetNFaceNeighbors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; @@ -5617,15 +5972,13 @@ SWIGINTERN PyObject *_wrap_ParMesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_ParMesh_Rebalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_Rebalance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Rebalance" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -5646,6 +5999,84 @@ SWIGINTERN PyObject *_wrap_ParMesh_Rebalance(PyObject *SWIGUNUSEDPARM(self), PyO } +SWIGINTERN PyObject *_wrap_ParMesh_Rebalance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Rebalance" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + } + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_Rebalance" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_Rebalance" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + (arg1)->Rebalance((mfem::Array< int > const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParMesh_Rebalance(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_Rebalance", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ParMesh_Rebalance__SWIG_0(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ParMesh_Rebalance__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_Rebalance'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParMesh::Rebalance()\n" + " mfem::ParMesh::Rebalance(mfem::Array< int > const &)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; @@ -8051,7 +8482,9 @@ SWIGINTERN PyObject *ParMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "ParMesh_Finalize", _wrap_ParMesh_Finalize, METH_VARARGS, "ParMesh_Finalize(ParMesh self, bool refine=False, bool fix_orientation=False)"}, + { "ParMesh_SetAttributes", _wrap_ParMesh_SetAttributes, METH_O, "ParMesh_SetAttributes(ParMesh self)"}, { "ParMesh_GetComm", _wrap_ParMesh_GetComm, METH_O, "ParMesh_GetComm(ParMesh self) -> MPI_Comm"}, { "ParMesh_GetNRanks", _wrap_ParMesh_GetNRanks, METH_O, "ParMesh_GetNRanks(ParMesh self) -> int"}, { "ParMesh_GetMyRank", _wrap_ParMesh_GetMyRank, METH_O, "ParMesh_GetMyRank(ParMesh self) -> int"}, @@ -8084,6 +8517,7 @@ static PyMethodDef SwigMethods[] = { { "ParMesh_GenerateOffsets", _wrap_ParMesh_GenerateOffsets, METH_VARARGS, "ParMesh_GenerateOffsets(ParMesh self, int N, HYPRE_Int [] loc_sizes, mfem::Array< HYPRE_Int > *[] offsets)"}, { "ParMesh_ExchangeFaceNbrData", _wrap_ParMesh_ExchangeFaceNbrData, METH_O, "ParMesh_ExchangeFaceNbrData(ParMesh self)"}, { "ParMesh_ExchangeFaceNbrNodes", _wrap_ParMesh_ExchangeFaceNbrNodes, METH_O, "ParMesh_ExchangeFaceNbrNodes(ParMesh self)"}, + { "ParMesh_SetCurvature", _wrap_ParMesh_SetCurvature, METH_VARARGS, "ParMesh_SetCurvature(ParMesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, { "ParMesh_GetNFaceNeighbors", _wrap_ParMesh_GetNFaceNeighbors, METH_O, "ParMesh_GetNFaceNeighbors(ParMesh self) -> int"}, { "ParMesh_GetFaceNbrGroup", _wrap_ParMesh_GetFaceNbrGroup, METH_VARARGS, "ParMesh_GetFaceNbrGroup(ParMesh self, int fn) -> int"}, { "ParMesh_GetFaceNbrRank", _wrap_ParMesh_GetFaceNbrRank, METH_VARARGS, "ParMesh_GetFaceNbrRank(ParMesh self, int fn) -> int"}, @@ -8093,7 +8527,10 @@ static PyMethodDef SwigMethods[] = { { "ParMesh_GetSharedFace", _wrap_ParMesh_GetSharedFace, METH_VARARGS, "ParMesh_GetSharedFace(ParMesh self, int sface) -> int"}, { "ParMesh_ReorientTetMesh", _wrap_ParMesh_ReorientTetMesh, METH_O, "ParMesh_ReorientTetMesh(ParMesh self)"}, { "ParMesh_ReduceInt", _wrap_ParMesh_ReduceInt, METH_VARARGS, "ParMesh_ReduceInt(ParMesh self, int value) -> long"}, - { "ParMesh_Rebalance", _wrap_ParMesh_Rebalance, METH_O, "ParMesh_Rebalance(ParMesh self)"}, + { "ParMesh_Rebalance", _wrap_ParMesh_Rebalance, METH_VARARGS, "\n" + "ParMesh_Rebalance(ParMesh self)\n" + "ParMesh_Rebalance(ParMesh self, intArray partition)\n" + ""}, { "ParMesh_GetBoundingBox", _wrap_ParMesh_GetBoundingBox, METH_VARARGS, "ParMesh_GetBoundingBox(ParMesh self, Vector p_min, Vector p_max, int ref=2)"}, { "ParMesh_GetCharacteristics", _wrap_ParMesh_GetCharacteristics, METH_VARARGS, "ParMesh_GetCharacteristics(ParMesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max)"}, { "ParMesh_FindPoints", _wrap_ParMesh_FindPoints, METH_VARARGS, "ParMesh_FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, @@ -8138,6 +8575,96 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "ParMesh_Finalize", _wrap_ParMesh_Finalize, METH_VARARGS, "Finalize(ParMesh self, bool refine=False, bool fix_orientation=False)"}, + { "ParMesh_SetAttributes", _wrap_ParMesh_SetAttributes, METH_O, "SetAttributes(ParMesh self)"}, + { "ParMesh_GetComm", _wrap_ParMesh_GetComm, METH_O, "GetComm(ParMesh self) -> MPI_Comm"}, + { "ParMesh_GetNRanks", _wrap_ParMesh_GetNRanks, METH_O, "GetNRanks(ParMesh self) -> int"}, + { "ParMesh_GetMyRank", _wrap_ParMesh_GetMyRank, METH_O, "GetMyRank(ParMesh self) -> int"}, + { "ParMesh_gtopo_get", _wrap_ParMesh_gtopo_get, METH_O, "ParMesh_gtopo_get(ParMesh self) -> GroupTopology"}, + { "ParMesh_have_face_nbr_data_set", _wrap_ParMesh_have_face_nbr_data_set, METH_VARARGS, "ParMesh_have_face_nbr_data_set(ParMesh self, bool have_face_nbr_data)"}, + { "ParMesh_have_face_nbr_data_get", _wrap_ParMesh_have_face_nbr_data_get, METH_O, "ParMesh_have_face_nbr_data_get(ParMesh self) -> bool"}, + { "ParMesh_face_nbr_group_set", _wrap_ParMesh_face_nbr_group_set, METH_VARARGS, "ParMesh_face_nbr_group_set(ParMesh self, intArray face_nbr_group)"}, + { "ParMesh_face_nbr_group_get", _wrap_ParMesh_face_nbr_group_get, METH_O, "ParMesh_face_nbr_group_get(ParMesh self) -> intArray"}, + { "ParMesh_face_nbr_elements_offset_set", _wrap_ParMesh_face_nbr_elements_offset_set, METH_VARARGS, "ParMesh_face_nbr_elements_offset_set(ParMesh self, intArray face_nbr_elements_offset)"}, + { "ParMesh_face_nbr_elements_offset_get", _wrap_ParMesh_face_nbr_elements_offset_get, METH_O, "ParMesh_face_nbr_elements_offset_get(ParMesh self) -> intArray"}, + { "ParMesh_face_nbr_vertices_offset_set", _wrap_ParMesh_face_nbr_vertices_offset_set, METH_VARARGS, "ParMesh_face_nbr_vertices_offset_set(ParMesh self, intArray face_nbr_vertices_offset)"}, + { "ParMesh_face_nbr_vertices_offset_get", _wrap_ParMesh_face_nbr_vertices_offset_get, METH_O, "ParMesh_face_nbr_vertices_offset_get(ParMesh self) -> intArray"}, + { "ParMesh_face_nbr_elements_get", _wrap_ParMesh_face_nbr_elements_get, METH_O, "ParMesh_face_nbr_elements_get(ParMesh self) -> mfem::Array< mfem::Element * > *"}, + { "ParMesh_face_nbr_vertices_get", _wrap_ParMesh_face_nbr_vertices_get, METH_O, "ParMesh_face_nbr_vertices_get(ParMesh self) -> mfem::Array< mfem::Vertex > *"}, + { "ParMesh_send_face_nbr_elements_set", _wrap_ParMesh_send_face_nbr_elements_set, METH_VARARGS, "ParMesh_send_face_nbr_elements_set(ParMesh self, Table send_face_nbr_elements)"}, + { "ParMesh_send_face_nbr_elements_get", _wrap_ParMesh_send_face_nbr_elements_get, METH_O, "ParMesh_send_face_nbr_elements_get(ParMesh self) -> Table"}, + { "ParMesh_send_face_nbr_vertices_set", _wrap_ParMesh_send_face_nbr_vertices_set, METH_VARARGS, "ParMesh_send_face_nbr_vertices_set(ParMesh self, Table send_face_nbr_vertices)"}, + { "ParMesh_send_face_nbr_vertices_get", _wrap_ParMesh_send_face_nbr_vertices_get, METH_O, "ParMesh_send_face_nbr_vertices_get(ParMesh self) -> Table"}, + { "ParMesh_pncmesh_set", _wrap_ParMesh_pncmesh_set, METH_VARARGS, "ParMesh_pncmesh_set(ParMesh self, ParNCMesh pncmesh)"}, + { "ParMesh_pncmesh_get", _wrap_ParMesh_pncmesh_get, METH_O, "ParMesh_pncmesh_get(ParMesh self) -> ParNCMesh"}, + { "ParMesh_GetNGroups", _wrap_ParMesh_GetNGroups, METH_O, "GetNGroups(ParMesh self) -> int"}, + { "ParMesh_GroupNVertices", _wrap_ParMesh_GroupNVertices, METH_VARARGS, "GroupNVertices(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNEdges", _wrap_ParMesh_GroupNEdges, METH_VARARGS, "GroupNEdges(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNTriangles", _wrap_ParMesh_GroupNTriangles, METH_VARARGS, "GroupNTriangles(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNQuadrilaterals", _wrap_ParMesh_GroupNQuadrilaterals, METH_VARARGS, "GroupNQuadrilaterals(ParMesh self, int group) -> int"}, + { "ParMesh_GroupVertex", _wrap_ParMesh_GroupVertex, METH_VARARGS, "GroupVertex(ParMesh self, int group, int i) -> int"}, + { "ParMesh_GroupEdge", _wrap_ParMesh_GroupEdge, METH_VARARGS, "GroupEdge(ParMesh self, int group, int i, int & edge, int & o)"}, + { "ParMesh_GroupTriangle", _wrap_ParMesh_GroupTriangle, METH_VARARGS, "GroupTriangle(ParMesh self, int group, int i, int & face, int & o)"}, + { "ParMesh_GroupQuadrilateral", _wrap_ParMesh_GroupQuadrilateral, METH_VARARGS, "GroupQuadrilateral(ParMesh self, int group, int i, int & face, int & o)"}, + { "ParMesh_GenerateOffsets", _wrap_ParMesh_GenerateOffsets, METH_VARARGS, "GenerateOffsets(ParMesh self, int N, HYPRE_Int [] loc_sizes, mfem::Array< HYPRE_Int > *[] offsets)"}, + { "ParMesh_ExchangeFaceNbrData", _wrap_ParMesh_ExchangeFaceNbrData, METH_O, "ExchangeFaceNbrData(ParMesh self)"}, + { "ParMesh_ExchangeFaceNbrNodes", _wrap_ParMesh_ExchangeFaceNbrNodes, METH_O, "ExchangeFaceNbrNodes(ParMesh self)"}, + { "ParMesh_SetCurvature", _wrap_ParMesh_SetCurvature, METH_VARARGS, "SetCurvature(ParMesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "ParMesh_GetNFaceNeighbors", _wrap_ParMesh_GetNFaceNeighbors, METH_O, "GetNFaceNeighbors(ParMesh self) -> int"}, + { "ParMesh_GetFaceNbrGroup", _wrap_ParMesh_GetFaceNbrGroup, METH_VARARGS, "GetFaceNbrGroup(ParMesh self, int fn) -> int"}, + { "ParMesh_GetFaceNbrRank", _wrap_ParMesh_GetFaceNbrRank, METH_VARARGS, "GetFaceNbrRank(ParMesh self, int fn) -> int"}, + { "ParMesh_GetFaceToAllElementTable", _wrap_ParMesh_GetFaceToAllElementTable, METH_O, "GetFaceToAllElementTable(ParMesh self) -> Table"}, + { "ParMesh_GetSharedFaceTransformations", _wrap_ParMesh_GetSharedFaceTransformations, METH_VARARGS, "GetSharedFaceTransformations(ParMesh self, int sf, bool fill2=True) -> FaceElementTransformations"}, + { "ParMesh_GetNSharedFaces", _wrap_ParMesh_GetNSharedFaces, METH_O, "GetNSharedFaces(ParMesh self) -> int"}, + { "ParMesh_GetSharedFace", _wrap_ParMesh_GetSharedFace, METH_VARARGS, "GetSharedFace(ParMesh self, int sface) -> int"}, + { "ParMesh_ReorientTetMesh", _wrap_ParMesh_ReorientTetMesh, METH_O, "ReorientTetMesh(ParMesh self)"}, + { "ParMesh_ReduceInt", _wrap_ParMesh_ReduceInt, METH_VARARGS, "ReduceInt(ParMesh self, int value) -> long"}, + { "ParMesh_Rebalance", _wrap_ParMesh_Rebalance, METH_VARARGS, "\n" + "Rebalance(ParMesh self)\n" + "Rebalance(ParMesh self, intArray partition)\n" + ""}, + { "ParMesh_GetBoundingBox", _wrap_ParMesh_GetBoundingBox, METH_VARARGS, "GetBoundingBox(ParMesh self, Vector p_min, Vector p_max, int ref=2)"}, + { "ParMesh_GetCharacteristics", _wrap_ParMesh_GetCharacteristics, METH_VARARGS, "GetCharacteristics(ParMesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max)"}, + { "ParMesh_FindPoints", _wrap_ParMesh_FindPoints, METH_VARARGS, "FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "ParMesh_PrintSharedEntities", _wrap_ParMesh_PrintSharedEntities, METH_VARARGS, "PrintSharedEntities(ParMesh self, char const * fname_prefix)"}, + { "delete_ParMesh", _wrap_delete_ParMesh, METH_O, "delete_ParMesh(ParMesh self)"}, + { "new_ParMesh", _wrap_new_ParMesh, METH_VARARGS, "\n" + "ParMesh(ParMesh pmesh, bool copy_nodes=True)\n" + "ParMesh(MPI_Comm comm, Mesh mesh, int * partitioning_=None, int part_method=1)\n" + "ParMesh(MPI_Comm comm, std::istream & input, bool refine=True)\n" + "ParMesh(ParMesh orig_mesh, int ref_factor, int ref_type)\n" + "new_ParMesh(MPI_Comm comm, char const * mesh_file) -> ParMesh\n" + ""}, + { "ParMesh_ParPrintToFile", _wrap_ParMesh_ParPrintToFile, METH_VARARGS, "ParPrintToFile(ParMesh self, char const * mesh_file, int const precision)"}, + { "ParMesh_Print", _wrap_ParMesh_Print, METH_VARARGS, "\n" + "Print(ParMesh self, std::ostream & out=mfem::out)\n" + "Print(ParMesh self, char const * file, int precision=8)\n" + ""}, + { "ParMesh_PrintXG", _wrap_ParMesh_PrintXG, METH_VARARGS, "\n" + "PrintXG(ParMesh self, std::ostream & out=mfem::out)\n" + "PrintXG(ParMesh self, char const * file, int precision=8)\n" + ""}, + { "ParMesh_PrintAsOne", _wrap_ParMesh_PrintAsOne, METH_VARARGS, "\n" + "PrintAsOne(ParMesh self, std::ostream & out=mfem::out)\n" + "PrintAsOne(ParMesh self, char const * file, int precision=8)\n" + ""}, + { "ParMesh_PrintAsOneXG", _wrap_ParMesh_PrintAsOneXG, METH_VARARGS, "\n" + "PrintAsOneXG(ParMesh self, std::ostream & out=mfem::out)\n" + "PrintAsOneXG(ParMesh self, char const * file, int precision=8)\n" + ""}, + { "ParMesh_PrintInfo", _wrap_ParMesh_PrintInfo, METH_VARARGS, "\n" + "PrintInfo(ParMesh self, std::ostream & out=mfem::out)\n" + "PrintInfo(ParMesh self, char const * file, int precision=8)\n" + ""}, + { "ParMesh_ParPrint", _wrap_ParMesh_ParPrint, METH_VARARGS, "\n" + "ParPrint(ParMesh self, std::ostream & out)\n" + "ParPrint(ParMesh self, char const * file, int precision=8)\n" + "ParPrint(ParMesh self)\n" + ""}, + { "ParMesh_swigregister", ParMesh_swigregister, METH_O, NULL}, + { "ParMesh_swiginit", ParMesh_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -8169,6 +8696,7 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -8208,6 +8736,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_hex_t, @@ -8247,6 +8776,7 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -8286,6 +8816,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_hex_t, @@ -9048,18 +9579,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); import_array(); diff --git a/mfem/_par/pncmesh.py b/mfem/_par/pncmesh.py index 0f4fd31b..bacb13ac 100644 --- a/mfem/_par/pncmesh.py +++ b/mfem/_par/pncmesh.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _pncmesh.SWIG_PyInstanceMethod_New +_swig_new_static_method = _pncmesh.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -94,6 +97,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.mem_manager import mfem._par.operators import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.densemat import mfem._par.geom @@ -111,6 +115,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform import mfem._par.communication @@ -132,130 +137,157 @@ def __init__(self, *args): def Refine(self, refinements): r"""Refine(ParNCMesh self, mfem::Array< mfem::Refinement > const & refinements)""" return _pncmesh.ParNCMesh_Refine(self, refinements) + Refine = _swig_new_instance_method(_pncmesh.ParNCMesh_Refine) def LimitNCLevel(self, max_nc_level): r"""LimitNCLevel(ParNCMesh self, int max_nc_level)""" return _pncmesh.ParNCMesh_LimitNCLevel(self, max_nc_level) + LimitNCLevel = _swig_new_instance_method(_pncmesh.ParNCMesh_LimitNCLevel) def CheckDerefinementNCLevel(self, deref_table, level_ok, max_nc_level): r"""CheckDerefinementNCLevel(ParNCMesh self, Table deref_table, intArray level_ok, int max_nc_level)""" return _pncmesh.ParNCMesh_CheckDerefinementNCLevel(self, deref_table, level_ok, max_nc_level) + CheckDerefinementNCLevel = _swig_new_instance_method(_pncmesh.ParNCMesh_CheckDerefinementNCLevel) def Derefine(self, derefs): r"""Derefine(ParNCMesh self, intArray derefs)""" return _pncmesh.ParNCMesh_Derefine(self, derefs) + Derefine = _swig_new_instance_method(_pncmesh.ParNCMesh_Derefine) - def Rebalance(self): - r"""Rebalance(ParNCMesh self)""" - return _pncmesh.ParNCMesh_Rebalance(self) + def Rebalance(self, custom_partition=None): + r"""Rebalance(ParNCMesh self, intArray custom_partition=None)""" + return _pncmesh.ParNCMesh_Rebalance(self, custom_partition) + Rebalance = _swig_new_instance_method(_pncmesh.ParNCMesh_Rebalance) def GetNElements(self): r"""GetNElements(ParNCMesh self) -> int""" return _pncmesh.ParNCMesh_GetNElements(self) + GetNElements = _swig_new_instance_method(_pncmesh.ParNCMesh_GetNElements) def GetNGhostVertices(self): r"""GetNGhostVertices(ParNCMesh self) -> int""" return _pncmesh.ParNCMesh_GetNGhostVertices(self) + GetNGhostVertices = _swig_new_instance_method(_pncmesh.ParNCMesh_GetNGhostVertices) def GetNGhostEdges(self): r"""GetNGhostEdges(ParNCMesh self) -> int""" return _pncmesh.ParNCMesh_GetNGhostEdges(self) + GetNGhostEdges = _swig_new_instance_method(_pncmesh.ParNCMesh_GetNGhostEdges) def GetNGhostFaces(self): r"""GetNGhostFaces(ParNCMesh self) -> int""" return _pncmesh.ParNCMesh_GetNGhostFaces(self) + GetNGhostFaces = _swig_new_instance_method(_pncmesh.ParNCMesh_GetNGhostFaces) def GetNGhostElements(self): r"""GetNGhostElements(ParNCMesh self) -> int""" return _pncmesh.ParNCMesh_GetNGhostElements(self) - - def GetGhostFaceGeometry(self, ghost_face_id): - r"""GetGhostFaceGeometry(ParNCMesh self, int ghost_face_id) -> mfem::Geometry::Type""" - return _pncmesh.ParNCMesh_GetGhostFaceGeometry(self, ghost_face_id) + GetNGhostElements = _swig_new_instance_method(_pncmesh.ParNCMesh_GetNGhostElements) def GetSharedVertices(self): r"""GetSharedVertices(ParNCMesh self) -> mfem::NCMesh::NCList const &""" return _pncmesh.ParNCMesh_GetSharedVertices(self) + GetSharedVertices = _swig_new_instance_method(_pncmesh.ParNCMesh_GetSharedVertices) def GetSharedEdges(self): r"""GetSharedEdges(ParNCMesh self) -> mfem::NCMesh::NCList const &""" return _pncmesh.ParNCMesh_GetSharedEdges(self) + GetSharedEdges = _swig_new_instance_method(_pncmesh.ParNCMesh_GetSharedEdges) def GetSharedFaces(self): r"""GetSharedFaces(ParNCMesh self) -> mfem::NCMesh::NCList const &""" return _pncmesh.ParNCMesh_GetSharedFaces(self) + GetSharedFaces = _swig_new_instance_method(_pncmesh.ParNCMesh_GetSharedFaces) def GetSharedList(self, entity): r"""GetSharedList(ParNCMesh self, int entity) -> mfem::NCMesh::NCList const &""" return _pncmesh.ParNCMesh_GetSharedList(self, entity) + GetSharedList = _swig_new_instance_method(_pncmesh.ParNCMesh_GetSharedList) def GetFaceOrientation(self, index): r"""GetFaceOrientation(ParNCMesh self, int index) -> int""" return _pncmesh.ParNCMesh_GetFaceOrientation(self, index) + GetFaceOrientation = _swig_new_instance_method(_pncmesh.ParNCMesh_GetFaceOrientation) def GetEntityOwnerId(self, entity, index): r"""GetEntityOwnerId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId""" return _pncmesh.ParNCMesh_GetEntityOwnerId(self, entity, index) + GetEntityOwnerId = _swig_new_instance_method(_pncmesh.ParNCMesh_GetEntityOwnerId) def GetEntityGroupId(self, entity, index): r"""GetEntityGroupId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId""" return _pncmesh.ParNCMesh_GetEntityGroupId(self, entity, index) + GetEntityGroupId = _swig_new_instance_method(_pncmesh.ParNCMesh_GetEntityGroupId) def GetGroup(self, id): r"""GetGroup(ParNCMesh self, mfem::ParNCMesh::GroupId id) -> mfem::ParNCMesh::CommGroup const &""" return _pncmesh.ParNCMesh_GetGroup(self, id) + GetGroup = _swig_new_instance_method(_pncmesh.ParNCMesh_GetGroup) def GroupContains(self, id, rank): r"""GroupContains(ParNCMesh self, mfem::ParNCMesh::GroupId id, int rank) -> bool""" return _pncmesh.ParNCMesh_GroupContains(self, id, rank) + GroupContains = _swig_new_instance_method(_pncmesh.ParNCMesh_GroupContains) def IsGhost(self, entity, index): r"""IsGhost(ParNCMesh self, int entity, int index) -> bool""" return _pncmesh.ParNCMesh_IsGhost(self, entity, index) + IsGhost = _swig_new_instance_method(_pncmesh.ParNCMesh_IsGhost) def ElementRank(self, index): r"""ElementRank(ParNCMesh self, int index) -> int""" return _pncmesh.ParNCMesh_ElementRank(self, index) + ElementRank = _swig_new_instance_method(_pncmesh.ParNCMesh_ElementRank) def GetMyRank(self): r"""GetMyRank(ParNCMesh self) -> int""" return _pncmesh.ParNCMesh_GetMyRank(self) + GetMyRank = _swig_new_instance_method(_pncmesh.ParNCMesh_GetMyRank) def SendRebalanceDofs(self, old_ndofs, old_element_dofs, old_global_offset, space): r"""SendRebalanceDofs(ParNCMesh self, int old_ndofs, Table old_element_dofs, long old_global_offset, FiniteElementSpace space)""" return _pncmesh.ParNCMesh_SendRebalanceDofs(self, old_ndofs, old_element_dofs, old_global_offset, space) + SendRebalanceDofs = _swig_new_instance_method(_pncmesh.ParNCMesh_SendRebalanceDofs) def RecvRebalanceDofs(self, elements, dofs): r"""RecvRebalanceDofs(ParNCMesh self, intArray elements, mfem::Array< long > & dofs)""" return _pncmesh.ParNCMesh_RecvRebalanceDofs(self, elements, dofs) + RecvRebalanceDofs = _swig_new_instance_method(_pncmesh.ParNCMesh_RecvRebalanceDofs) def GetRebalanceOldIndex(self): r"""GetRebalanceOldIndex(ParNCMesh self) -> intArray""" return _pncmesh.ParNCMesh_GetRebalanceOldIndex(self) + GetRebalanceOldIndex = _swig_new_instance_method(_pncmesh.ParNCMesh_GetRebalanceOldIndex) def GetDerefineOldRanks(self): r"""GetDerefineOldRanks(ParNCMesh self) -> intArray""" return _pncmesh.ParNCMesh_GetDerefineOldRanks(self) + GetDerefineOldRanks = _swig_new_instance_method(_pncmesh.ParNCMesh_GetDerefineOldRanks) def GetBoundaryClosure(self, bdr_attr_is_ess, bdr_vertices, bdr_edges): r"""GetBoundaryClosure(ParNCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)""" return _pncmesh.ParNCMesh_GetBoundaryClosure(self, bdr_attr_is_ess, bdr_vertices, bdr_edges) + GetBoundaryClosure = _swig_new_instance_method(_pncmesh.ParNCMesh_GetBoundaryClosure) def Trim(self): r"""Trim(ParNCMesh self)""" return _pncmesh.ParNCMesh_Trim(self) + Trim = _swig_new_instance_method(_pncmesh.ParNCMesh_Trim) def MemoryUsage(self, with_base=True): r"""MemoryUsage(ParNCMesh self, bool with_base=True) -> long""" return _pncmesh.ParNCMesh_MemoryUsage(self, with_base) + MemoryUsage = _swig_new_instance_method(_pncmesh.ParNCMesh_MemoryUsage) def PrintMemoryDetail(self, with_base=True): r"""PrintMemoryDetail(ParNCMesh self, bool with_base=True) -> int""" return _pncmesh.ParNCMesh_PrintMemoryDetail(self, with_base) + PrintMemoryDetail = _swig_new_instance_method(_pncmesh.ParNCMesh_PrintMemoryDetail) def GetDebugMesh(self, debug_mesh): r"""GetDebugMesh(ParNCMesh self, Mesh debug_mesh)""" return _pncmesh.ParNCMesh_GetDebugMesh(self, debug_mesh) + GetDebugMesh = _swig_new_instance_method(_pncmesh.ParNCMesh_GetDebugMesh) # Register ParNCMesh in _pncmesh: _pncmesh.ParNCMesh_swigregister(ParNCMesh) @@ -264,9 +296,11 @@ def GetDebugMesh(self, debug_mesh): def __lt__(a, b): r"""__lt__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool""" return _pncmesh.__lt__(a, b) +__lt__ = _pncmesh.__lt__ def __eq__(a, b): r"""__eq__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool""" return _pncmesh.__eq__(a, b) +__eq__ = _pncmesh.__eq__ diff --git a/mfem/_par/pncmesh_wrap.cxx b/mfem/_par/pncmesh_wrap.cxx index bb63a404..be73d2ba 100644 --- a/mfem/_par/pncmesh_wrap.cxx +++ b/mfem/_par/pncmesh_wrap.cxx @@ -3069,32 +3069,33 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_hex_t swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_long_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[9] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[10] -#define SWIGTYPE_p_mfem__GridFunction swig_types[11] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[12] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[13] -#define SWIGTYPE_p_mfem__Mesh swig_types[14] -#define SWIGTYPE_p_mfem__NCMesh swig_types[15] -#define SWIGTYPE_p_mfem__NCMesh__MeshId swig_types[16] -#define SWIGTYPE_p_mfem__NCMesh__NCList swig_types[17] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[18] -#define SWIGTYPE_p_mfem__ParNCMesh swig_types[19] -#define SWIGTYPE_p_mfem__STable swig_types[20] -#define SWIGTYPE_p_mfem__Table swig_types[21] -#define SWIGTYPE_p_pri_t swig_types[22] -#define SWIGTYPE_p_quad_t swig_types[23] -#define SWIGTYPE_p_seg_t swig_types[24] -#define SWIGTYPE_p_std__vectorT_int_t swig_types[25] -#define SWIGTYPE_p_tet_t swig_types[26] -#define SWIGTYPE_p_tri_t swig_types[27] -static swig_type_info *swig_types[29]; -static swig_module_info swig_module = {swig_types, 28, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_char swig_types[5] +#define SWIGTYPE_p_hex_t swig_types[6] +#define SWIGTYPE_p_int swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_long_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[10] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[11] +#define SWIGTYPE_p_mfem__GridFunction swig_types[12] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[13] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[14] +#define SWIGTYPE_p_mfem__Mesh swig_types[15] +#define SWIGTYPE_p_mfem__NCMesh swig_types[16] +#define SWIGTYPE_p_mfem__NCMesh__MeshId swig_types[17] +#define SWIGTYPE_p_mfem__NCMesh__NCList swig_types[18] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[19] +#define SWIGTYPE_p_mfem__ParNCMesh swig_types[20] +#define SWIGTYPE_p_mfem__STable swig_types[21] +#define SWIGTYPE_p_mfem__Table swig_types[22] +#define SWIGTYPE_p_pri_t swig_types[23] +#define SWIGTYPE_p_quad_t swig_types[24] +#define SWIGTYPE_p_seg_t swig_types[25] +#define SWIGTYPE_p_std__vectorT_int_t swig_types[26] +#define SWIGTYPE_p_tet_t swig_types[27] +#define SWIGTYPE_p_tri_t swig_types[28] +static swig_type_info *swig_types[30]; +static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3849,23 +3850,29 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; + mfem::Array< int > *arg2 = (mfem::Array< int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_Rebalance" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_Rebalance" "', argument " "2"" of type '" "mfem::Array< int > const *""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->Rebalance(); + (arg1)->Rebalance((mfem::Array< int > const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3878,37 +3885,75 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetNElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNElements" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_Rebalance" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { try { - result = (int)((mfem::ParNCMesh const *)arg1)->GetNElements(); + (arg1)->Rebalance(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ParNCMesh_Rebalance", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ParNCMesh_Rebalance__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ParNCMesh_Rebalance__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParNCMesh_Rebalance'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParNCMesh::Rebalance(mfem::Array< int > const *)\n" + " mfem::ParNCMesh::Rebalance()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ParNCMesh_GetNElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; void *argp1 = 0 ; @@ -3920,12 +3965,12 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostVertices(PyObject *SWIGUNUSEDPARM( swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostVertices" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNElements" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { try { - result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostVertices(); + result = (int)((mfem::ParNCMesh const *)arg1)->GetNElements(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3938,7 +3983,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostVertices(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; void *argp1 = 0 ; @@ -3950,12 +3995,12 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostEdges(PyObject *SWIGUNUSEDPARM(sel swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostEdges" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostVertices" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { try { - result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostEdges(); + result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostVertices(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3968,7 +4013,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostEdges(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; void *argp1 = 0 ; @@ -3980,12 +4025,12 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostFaces(PyObject *SWIGUNUSEDPARM(sel swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostFaces" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostEdges" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { try { - result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostFaces(); + result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostEdges(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3998,7 +4043,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostFaces(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; void *argp1 = 0 ; @@ -4010,12 +4055,12 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostElements(PyObject *SWIGUNUSEDPARM( swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostElements" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostFaces" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { try { - result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostElements(); + result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostFaces(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4028,30 +4073,24 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostElements(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetGhostFaceGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetNGhostElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + PyObject *swig_obj[1] ; + int result; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetGhostFaceGeometry", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetGhostFaceGeometry" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetNGhostElements" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::Geometry::Type)((mfem::ParNCMesh const *)arg1)->GetGhostFaceGeometry(arg2); + result = (int)((mfem::ParNCMesh const *)arg1)->GetNGhostElements(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5118,6 +5157,7 @@ SWIGINTERN PyObject *_wrap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_ParNCMesh", _wrap_new_ParNCMesh, METH_VARARGS, "\n" "ParNCMesh(MPI_Comm comm, NCMesh ncmesh, int * part=None)\n" "new_ParNCMesh(ParNCMesh other) -> ParNCMesh\n" @@ -5127,13 +5167,12 @@ static PyMethodDef SwigMethods[] = { { "ParNCMesh_LimitNCLevel", _wrap_ParNCMesh_LimitNCLevel, METH_VARARGS, "ParNCMesh_LimitNCLevel(ParNCMesh self, int max_nc_level)"}, { "ParNCMesh_CheckDerefinementNCLevel", _wrap_ParNCMesh_CheckDerefinementNCLevel, METH_VARARGS, "ParNCMesh_CheckDerefinementNCLevel(ParNCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, { "ParNCMesh_Derefine", _wrap_ParNCMesh_Derefine, METH_VARARGS, "ParNCMesh_Derefine(ParNCMesh self, intArray derefs)"}, - { "ParNCMesh_Rebalance", _wrap_ParNCMesh_Rebalance, METH_O, "ParNCMesh_Rebalance(ParNCMesh self)"}, + { "ParNCMesh_Rebalance", _wrap_ParNCMesh_Rebalance, METH_VARARGS, "ParNCMesh_Rebalance(ParNCMesh self, intArray custom_partition=None)"}, { "ParNCMesh_GetNElements", _wrap_ParNCMesh_GetNElements, METH_O, "ParNCMesh_GetNElements(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostVertices", _wrap_ParNCMesh_GetNGhostVertices, METH_O, "ParNCMesh_GetNGhostVertices(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostEdges", _wrap_ParNCMesh_GetNGhostEdges, METH_O, "ParNCMesh_GetNGhostEdges(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostFaces", _wrap_ParNCMesh_GetNGhostFaces, METH_O, "ParNCMesh_GetNGhostFaces(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostElements", _wrap_ParNCMesh_GetNGhostElements, METH_O, "ParNCMesh_GetNGhostElements(ParNCMesh self) -> int"}, - { "ParNCMesh_GetGhostFaceGeometry", _wrap_ParNCMesh_GetGhostFaceGeometry, METH_VARARGS, "ParNCMesh_GetGhostFaceGeometry(ParNCMesh self, int ghost_face_id) -> mfem::Geometry::Type"}, { "ParNCMesh_GetSharedVertices", _wrap_ParNCMesh_GetSharedVertices, METH_O, "ParNCMesh_GetSharedVertices(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, { "ParNCMesh_GetSharedEdges", _wrap_ParNCMesh_GetSharedEdges, METH_O, "ParNCMesh_GetSharedEdges(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, { "ParNCMesh_GetSharedFaces", _wrap_ParNCMesh_GetSharedFaces, METH_O, "ParNCMesh_GetSharedFaces(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, @@ -5163,6 +5202,48 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ParNCMesh", _wrap_new_ParNCMesh, METH_VARARGS, "\n" + "ParNCMesh(MPI_Comm comm, NCMesh ncmesh, int * part=None)\n" + "new_ParNCMesh(ParNCMesh other) -> ParNCMesh\n" + ""}, + { "delete_ParNCMesh", _wrap_delete_ParNCMesh, METH_O, "delete_ParNCMesh(ParNCMesh self)"}, + { "ParNCMesh_Refine", _wrap_ParNCMesh_Refine, METH_VARARGS, "Refine(ParNCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "ParNCMesh_LimitNCLevel", _wrap_ParNCMesh_LimitNCLevel, METH_VARARGS, "LimitNCLevel(ParNCMesh self, int max_nc_level)"}, + { "ParNCMesh_CheckDerefinementNCLevel", _wrap_ParNCMesh_CheckDerefinementNCLevel, METH_VARARGS, "CheckDerefinementNCLevel(ParNCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "ParNCMesh_Derefine", _wrap_ParNCMesh_Derefine, METH_VARARGS, "Derefine(ParNCMesh self, intArray derefs)"}, + { "ParNCMesh_Rebalance", _wrap_ParNCMesh_Rebalance, METH_VARARGS, "Rebalance(ParNCMesh self, intArray custom_partition=None)"}, + { "ParNCMesh_GetNElements", _wrap_ParNCMesh_GetNElements, METH_O, "GetNElements(ParNCMesh self) -> int"}, + { "ParNCMesh_GetNGhostVertices", _wrap_ParNCMesh_GetNGhostVertices, METH_O, "GetNGhostVertices(ParNCMesh self) -> int"}, + { "ParNCMesh_GetNGhostEdges", _wrap_ParNCMesh_GetNGhostEdges, METH_O, "GetNGhostEdges(ParNCMesh self) -> int"}, + { "ParNCMesh_GetNGhostFaces", _wrap_ParNCMesh_GetNGhostFaces, METH_O, "GetNGhostFaces(ParNCMesh self) -> int"}, + { "ParNCMesh_GetNGhostElements", _wrap_ParNCMesh_GetNGhostElements, METH_O, "GetNGhostElements(ParNCMesh self) -> int"}, + { "ParNCMesh_GetSharedVertices", _wrap_ParNCMesh_GetSharedVertices, METH_O, "GetSharedVertices(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, + { "ParNCMesh_GetSharedEdges", _wrap_ParNCMesh_GetSharedEdges, METH_O, "GetSharedEdges(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, + { "ParNCMesh_GetSharedFaces", _wrap_ParNCMesh_GetSharedFaces, METH_O, "GetSharedFaces(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, + { "ParNCMesh_GetSharedList", _wrap_ParNCMesh_GetSharedList, METH_VARARGS, "GetSharedList(ParNCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "ParNCMesh_GetFaceOrientation", _wrap_ParNCMesh_GetFaceOrientation, METH_VARARGS, "GetFaceOrientation(ParNCMesh self, int index) -> int"}, + { "ParNCMesh_GetEntityOwnerId", _wrap_ParNCMesh_GetEntityOwnerId, METH_VARARGS, "GetEntityOwnerId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, + { "ParNCMesh_GetEntityGroupId", _wrap_ParNCMesh_GetEntityGroupId, METH_VARARGS, "GetEntityGroupId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, + { "ParNCMesh_GetGroup", _wrap_ParNCMesh_GetGroup, METH_VARARGS, "GetGroup(ParNCMesh self, mfem::ParNCMesh::GroupId id) -> mfem::ParNCMesh::CommGroup const &"}, + { "ParNCMesh_GroupContains", _wrap_ParNCMesh_GroupContains, METH_VARARGS, "GroupContains(ParNCMesh self, mfem::ParNCMesh::GroupId id, int rank) -> bool"}, + { "ParNCMesh_IsGhost", _wrap_ParNCMesh_IsGhost, METH_VARARGS, "IsGhost(ParNCMesh self, int entity, int index) -> bool"}, + { "ParNCMesh_ElementRank", _wrap_ParNCMesh_ElementRank, METH_VARARGS, "ElementRank(ParNCMesh self, int index) -> int"}, + { "ParNCMesh_GetMyRank", _wrap_ParNCMesh_GetMyRank, METH_O, "GetMyRank(ParNCMesh self) -> int"}, + { "ParNCMesh_SendRebalanceDofs", _wrap_ParNCMesh_SendRebalanceDofs, METH_VARARGS, "SendRebalanceDofs(ParNCMesh self, int old_ndofs, Table old_element_dofs, long old_global_offset, FiniteElementSpace space)"}, + { "ParNCMesh_RecvRebalanceDofs", _wrap_ParNCMesh_RecvRebalanceDofs, METH_VARARGS, "RecvRebalanceDofs(ParNCMesh self, intArray elements, mfem::Array< long > & dofs)"}, + { "ParNCMesh_GetRebalanceOldIndex", _wrap_ParNCMesh_GetRebalanceOldIndex, METH_O, "GetRebalanceOldIndex(ParNCMesh self) -> intArray"}, + { "ParNCMesh_GetDerefineOldRanks", _wrap_ParNCMesh_GetDerefineOldRanks, METH_O, "GetDerefineOldRanks(ParNCMesh self) -> intArray"}, + { "ParNCMesh_GetBoundaryClosure", _wrap_ParNCMesh_GetBoundaryClosure, METH_VARARGS, "GetBoundaryClosure(ParNCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "ParNCMesh_Trim", _wrap_ParNCMesh_Trim, METH_O, "Trim(ParNCMesh self)"}, + { "ParNCMesh_MemoryUsage", _wrap_ParNCMesh_MemoryUsage, METH_VARARGS, "MemoryUsage(ParNCMesh self, bool with_base=True) -> long"}, + { "ParNCMesh_PrintMemoryDetail", _wrap_ParNCMesh_PrintMemoryDetail, METH_VARARGS, "PrintMemoryDetail(ParNCMesh self, bool with_base=True) -> int"}, + { "ParNCMesh_GetDebugMesh", _wrap_ParNCMesh_GetDebugMesh, METH_VARARGS, "GetDebugMesh(ParNCMesh self, Mesh debug_mesh)"}, + { "ParNCMesh_swigregister", ParNCMesh_swigregister, METH_O, NULL}, + { "ParNCMesh_swiginit", ParNCMesh_swiginit, METH_VARARGS, NULL}, + { "__lt__", _wrap___lt__, METH_VARARGS, "__lt__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, + { "__eq__", _wrap___eq__, METH_VARARGS, "__eq__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, { NULL, NULL, 0, NULL } }; @@ -5179,6 +5260,7 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -5209,6 +5291,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -5239,6 +5322,7 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -5269,6 +5353,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, @@ -6022,18 +6107,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pnonlinearform.py b/mfem/_par/pnonlinearform.py index 0f7560b7..3612dc16 100644 --- a/mfem/_par/pnonlinearform.py +++ b/mfem/_par/pnonlinearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _pnonlinearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _pnonlinearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -91,6 +94,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -102,6 +106,8 @@ class _SwigNonDynamicMeta(type): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction +import mfem._par.bilinearform import mfem._par.nonlininteg import mfem._par.blockoperator import mfem._par.pfespace @@ -123,10 +129,12 @@ def __init__(self, pf): def ParFESpace(self): r"""ParFESpace(ParNonlinearForm self) -> ParFiniteElementSpace""" return _pnonlinearform.ParNonlinearForm_ParFESpace(self) + ParFESpace = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_ParFESpace) def GetParGridFunctionEnergy(self, x): r"""GetParGridFunctionEnergy(ParNonlinearForm self, Vector x) -> double""" return _pnonlinearform.ParNonlinearForm_GetParGridFunctionEnergy(self, x) + GetParGridFunctionEnergy = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_GetParGridFunctionEnergy) def GetEnergy(self, *args): r""" @@ -134,26 +142,32 @@ def GetEnergy(self, *args): GetEnergy(ParNonlinearForm self, Vector x) -> double """ return _pnonlinearform.ParNonlinearForm_GetEnergy(self, *args) + GetEnergy = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_GetEnergy) def Mult(self, x, y): r"""Mult(ParNonlinearForm self, Vector x, Vector y)""" return _pnonlinearform.ParNonlinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_Mult) def GetLocalGradient(self, x): r"""GetLocalGradient(ParNonlinearForm self, Vector x) -> SparseMatrix""" return _pnonlinearform.ParNonlinearForm_GetLocalGradient(self, x) + GetLocalGradient = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_GetLocalGradient) def GetGradient(self, x): r"""GetGradient(ParNonlinearForm self, Vector x) -> Operator""" return _pnonlinearform.ParNonlinearForm_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_GetGradient) def SetGradientType(self, tid): r"""SetGradientType(ParNonlinearForm self, mfem::Operator::Type tid)""" return _pnonlinearform.ParNonlinearForm_SetGradientType(self, tid) + SetGradientType = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_SetGradientType) def Update(self): r"""Update(ParNonlinearForm self)""" return _pnonlinearform.ParNonlinearForm_Update(self) + Update = _swig_new_instance_method(_pnonlinearform.ParNonlinearForm_Update) __swig_destroy__ = _pnonlinearform.delete_ParNonlinearForm # Register ParNonlinearForm in _pnonlinearform: @@ -178,30 +192,37 @@ def ParFESpace(self, *args): ParFESpace(ParBlockNonlinearForm self, int k) -> ParFiniteElementSpace """ return _pnonlinearform.ParBlockNonlinearForm_ParFESpace(self, *args) + ParFESpace = _swig_new_instance_method(_pnonlinearform.ParBlockNonlinearForm_ParFESpace) def SetParSpaces(self, pf): r"""SetParSpaces(ParBlockNonlinearForm self, mfem::Array< mfem::ParFiniteElementSpace * > & pf)""" return _pnonlinearform.ParBlockNonlinearForm_SetParSpaces(self, pf) + SetParSpaces = _swig_new_instance_method(_pnonlinearform.ParBlockNonlinearForm_SetParSpaces) def SetEssentialBC(self, bdr_attr_is_ess, rhs): r"""SetEssentialBC(ParBlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)""" return _pnonlinearform.ParBlockNonlinearForm_SetEssentialBC(self, bdr_attr_is_ess, rhs) + SetEssentialBC = _swig_new_instance_method(_pnonlinearform.ParBlockNonlinearForm_SetEssentialBC) def Mult(self, x, y): r"""Mult(ParBlockNonlinearForm self, Vector x, Vector y)""" return _pnonlinearform.ParBlockNonlinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_pnonlinearform.ParBlockNonlinearForm_Mult) def GetLocalGradient(self, x): r"""GetLocalGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator""" return _pnonlinearform.ParBlockNonlinearForm_GetLocalGradient(self, x) + GetLocalGradient = _swig_new_instance_method(_pnonlinearform.ParBlockNonlinearForm_GetLocalGradient) def GetGradient(self, x): r"""GetGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator""" return _pnonlinearform.ParBlockNonlinearForm_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_pnonlinearform.ParBlockNonlinearForm_GetGradient) def SetGradientType(self, tid): r"""SetGradientType(ParBlockNonlinearForm self, mfem::Operator::Type tid)""" return _pnonlinearform.ParBlockNonlinearForm_SetGradientType(self, tid) + SetGradientType = _swig_new_instance_method(_pnonlinearform.ParBlockNonlinearForm_SetGradientType) __swig_destroy__ = _pnonlinearform.delete_ParBlockNonlinearForm # Register ParBlockNonlinearForm in _pnonlinearform: diff --git a/mfem/_par/pnonlinearform_wrap.cxx b/mfem/_par/pnonlinearform_wrap.cxx index d069fdc3..6b737c1d 100644 --- a/mfem/_par/pnonlinearform_wrap.cxx +++ b/mfem/_par/pnonlinearform_wrap.cxx @@ -3069,66 +3069,77 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_char swig_types[4] -#define SWIGTYPE_p_hex_t swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] -#define SWIGTYPE_p_mfem__BlockDiagonalPreconditioner swig_types[9] -#define SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner swig_types[10] -#define SWIGTYPE_p_mfem__BlockNonlinearForm swig_types[11] -#define SWIGTYPE_p_mfem__BlockOperator swig_types[12] -#define SWIGTYPE_p_mfem__ConformingProlongationOperator swig_types[13] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[14] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[15] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[16] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[17] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[18] -#define SWIGTYPE_p_mfem__GridFunction swig_types[19] -#define SWIGTYPE_p_mfem__HypreADS swig_types[20] -#define SWIGTYPE_p_mfem__HypreAMS swig_types[21] -#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[22] -#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[23] -#define SWIGTYPE_p_mfem__HypreEuclid swig_types[24] -#define SWIGTYPE_p_mfem__HypreGMRES swig_types[25] -#define SWIGTYPE_p_mfem__HypreIdentity swig_types[26] -#define SWIGTYPE_p_mfem__HyprePCG swig_types[27] -#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[28] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[29] -#define SWIGTYPE_p_mfem__HypreParaSails swig_types[30] -#define SWIGTYPE_p_mfem__HypreSmoother swig_types[31] -#define SWIGTYPE_p_mfem__HypreSolver swig_types[32] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[33] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[34] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[35] -#define SWIGTYPE_p_mfem__LinearForm swig_types[36] -#define SWIGTYPE_p_mfem__Matrix swig_types[37] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[38] -#define SWIGTYPE_p_mfem__NonlinearForm swig_types[39] -#define SWIGTYPE_p_mfem__Operator swig_types[40] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[41] -#define SWIGTYPE_p_mfem__ParBlockNonlinearForm swig_types[42] -#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[43] -#define SWIGTYPE_p_mfem__ParGridFunction swig_types[44] -#define SWIGTYPE_p_mfem__ParNonlinearForm swig_types[45] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[46] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[47] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[48] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[49] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[50] -#define SWIGTYPE_p_mfem__Solver swig_types[51] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[52] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[53] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[54] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[55] -#define SWIGTYPE_p_mfem__Vector swig_types[56] -#define SWIGTYPE_p_pri_t swig_types[57] -#define SWIGTYPE_p_quad_t swig_types[58] -#define SWIGTYPE_p_seg_t swig_types[59] -#define SWIGTYPE_p_tet_t swig_types[60] -#define SWIGTYPE_p_tri_t swig_types[61] -static swig_type_info *swig_types[63]; -static swig_module_info swig_module = {swig_types, 62, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_char swig_types[5] +#define SWIGTYPE_p_hex_t swig_types[6] +#define SWIGTYPE_p_int swig_types[7] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[10] +#define SWIGTYPE_p_mfem__BlockDiagonalPreconditioner swig_types[11] +#define SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner swig_types[12] +#define SWIGTYPE_p_mfem__BlockNonlinearForm swig_types[13] +#define SWIGTYPE_p_mfem__BlockOperator swig_types[14] +#define SWIGTYPE_p_mfem__ConformingProlongationOperator swig_types[15] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[16] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[17] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[18] +#define SWIGTYPE_p_mfem__DeviceConformingProlongationOperator swig_types[19] +#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[20] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[21] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[22] +#define SWIGTYPE_p_mfem__GridFunction swig_types[23] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[24] +#define SWIGTYPE_p_mfem__HypreADS swig_types[25] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[26] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[27] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[28] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[29] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[30] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[31] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[32] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[33] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[34] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[35] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[36] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[37] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[38] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[39] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[40] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[41] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[42] +#define SWIGTYPE_p_mfem__LinearForm swig_types[43] +#define SWIGTYPE_p_mfem__Matrix swig_types[44] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[45] +#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[46] +#define SWIGTYPE_p_mfem__NonlinearForm swig_types[47] +#define SWIGTYPE_p_mfem__Operator swig_types[48] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[49] +#define SWIGTYPE_p_mfem__ParBlockNonlinearForm swig_types[50] +#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[51] +#define SWIGTYPE_p_mfem__ParGridFunction swig_types[52] +#define SWIGTYPE_p_mfem__ParNonlinearForm swig_types[53] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[54] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[55] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[56] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[57] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[58] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[59] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[60] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[61] +#define SWIGTYPE_p_mfem__Solver swig_types[62] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[63] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[64] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[65] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[66] +#define SWIGTYPE_p_mfem__Vector swig_types[67] +#define SWIGTYPE_p_pri_t swig_types[68] +#define SWIGTYPE_p_quad_t swig_types[69] +#define SWIGTYPE_p_seg_t swig_types[70] +#define SWIGTYPE_p_tet_t swig_types[71] +#define SWIGTYPE_p_tri_t swig_types[72] +static swig_type_info *swig_types[74]; +static swig_module_info swig_module = {swig_types, 73, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4716,6 +4727,7 @@ SWIGINTERN PyObject *ParBlockNonlinearForm_swiginit(PyObject *SWIGUNUSEDPARM(sel static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_ParNonlinearForm", _wrap_new_ParNonlinearForm, METH_O, "new_ParNonlinearForm(ParFiniteElementSpace pf) -> ParNonlinearForm"}, { "ParNonlinearForm_ParFESpace", _wrap_ParNonlinearForm_ParFESpace, METH_O, "ParNonlinearForm_ParFESpace(ParNonlinearForm self) -> ParFiniteElementSpace"}, { "ParNonlinearForm_GetParGridFunctionEnergy", _wrap_ParNonlinearForm_GetParGridFunctionEnergy, METH_VARARGS, "ParNonlinearForm_GetParGridFunctionEnergy(ParNonlinearForm self, Vector x) -> double"}, @@ -4752,38 +4764,51 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ParNonlinearForm", _wrap_new_ParNonlinearForm, METH_O, "new_ParNonlinearForm(ParFiniteElementSpace pf) -> ParNonlinearForm"}, + { "ParNonlinearForm_ParFESpace", _wrap_ParNonlinearForm_ParFESpace, METH_O, "ParFESpace(ParNonlinearForm self) -> ParFiniteElementSpace"}, + { "ParNonlinearForm_GetParGridFunctionEnergy", _wrap_ParNonlinearForm_GetParGridFunctionEnergy, METH_VARARGS, "GetParGridFunctionEnergy(ParNonlinearForm self, Vector x) -> double"}, + { "ParNonlinearForm_GetEnergy", _wrap_ParNonlinearForm_GetEnergy, METH_VARARGS, "\n" + "GetEnergy(ParNonlinearForm self, ParGridFunction x) -> double\n" + "GetEnergy(ParNonlinearForm self, Vector x) -> double\n" + ""}, + { "ParNonlinearForm_Mult", _wrap_ParNonlinearForm_Mult, METH_VARARGS, "Mult(ParNonlinearForm self, Vector x, Vector y)"}, + { "ParNonlinearForm_GetLocalGradient", _wrap_ParNonlinearForm_GetLocalGradient, METH_VARARGS, "GetLocalGradient(ParNonlinearForm self, Vector x) -> SparseMatrix"}, + { "ParNonlinearForm_GetGradient", _wrap_ParNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(ParNonlinearForm self, Vector x) -> Operator"}, + { "ParNonlinearForm_SetGradientType", _wrap_ParNonlinearForm_SetGradientType, METH_VARARGS, "SetGradientType(ParNonlinearForm self, mfem::Operator::Type tid)"}, + { "ParNonlinearForm_Update", _wrap_ParNonlinearForm_Update, METH_O, "Update(ParNonlinearForm self)"}, + { "delete_ParNonlinearForm", _wrap_delete_ParNonlinearForm, METH_O, "delete_ParNonlinearForm(ParNonlinearForm self)"}, + { "ParNonlinearForm_swigregister", ParNonlinearForm_swigregister, METH_O, NULL}, + { "ParNonlinearForm_swiginit", ParNonlinearForm_swiginit, METH_VARARGS, NULL}, + { "new_ParBlockNonlinearForm", _wrap_new_ParBlockNonlinearForm, METH_VARARGS, "\n" + "ParBlockNonlinearForm()\n" + "new_ParBlockNonlinearForm(mfem::Array< mfem::ParFiniteElementSpace * > & pf) -> ParBlockNonlinearForm\n" + ""}, + { "ParBlockNonlinearForm_ParFESpace", _wrap_ParBlockNonlinearForm_ParFESpace, METH_VARARGS, "\n" + "ParFESpace(ParBlockNonlinearForm self, int k) -> ParFiniteElementSpace\n" + "ParFESpace(ParBlockNonlinearForm self, int k) -> ParFiniteElementSpace\n" + ""}, + { "ParBlockNonlinearForm_SetParSpaces", _wrap_ParBlockNonlinearForm_SetParSpaces, METH_VARARGS, "SetParSpaces(ParBlockNonlinearForm self, mfem::Array< mfem::ParFiniteElementSpace * > & pf)"}, + { "ParBlockNonlinearForm_SetEssentialBC", _wrap_ParBlockNonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(ParBlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "ParBlockNonlinearForm_Mult", _wrap_ParBlockNonlinearForm_Mult, METH_VARARGS, "Mult(ParBlockNonlinearForm self, Vector x, Vector y)"}, + { "ParBlockNonlinearForm_GetLocalGradient", _wrap_ParBlockNonlinearForm_GetLocalGradient, METH_VARARGS, "GetLocalGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, + { "ParBlockNonlinearForm_GetGradient", _wrap_ParBlockNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, + { "ParBlockNonlinearForm_SetGradientType", _wrap_ParBlockNonlinearForm_SetGradientType, METH_VARARGS, "SetGradientType(ParBlockNonlinearForm self, mfem::Operator::Type tid)"}, + { "delete_ParBlockNonlinearForm", _wrap_delete_ParBlockNonlinearForm, METH_O, "delete_ParBlockNonlinearForm(ParBlockNonlinearForm self)"}, + { "ParBlockNonlinearForm_swigregister", ParBlockNonlinearForm_swigregister, METH_O, NULL}, + { "ParBlockNonlinearForm_swiginit", ParBlockNonlinearForm_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__HypreParVectorTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::HypreParVector *) x)); -} -static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); -} -static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); -} -static void *_p_mfem__ParGridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) (mfem::GridFunction *) ((mfem::ParGridFunction *) x)); -} -static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); -} -static void *_p_mfem__ParGridFunctionTo_p_mfem__GridFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::GridFunction *) ((mfem::ParGridFunction *) x)); -} -static void *_p_mfem__ParBlockNonlinearFormTo_p_mfem__BlockNonlinearForm(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BlockNonlinearForm *) ((mfem::ParBlockNonlinearForm *) x)); -} static void *_p_mfem__ParNonlinearFormTo_p_mfem__NonlinearForm(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NonlinearForm *) ((mfem::ParNonlinearForm *) x)); } -static void *_p_mfem__ParFiniteElementSpaceTo_p_mfem__FiniteElementSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementSpace *) ((mfem::ParFiniteElementSpace *) x)); +static void *_p_mfem__ParBlockNonlinearFormTo_p_mfem__BlockNonlinearForm(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BlockNonlinearForm *) ((mfem::ParBlockNonlinearForm *) x)); } static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); @@ -4791,30 +4816,36 @@ static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(n static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); -} static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); } +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +} static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); } static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); } +static void *_p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::BlockDiagonalPreconditioner *) x)); +} static void *_p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::BlockLowerTriangularPreconditioner *) x)); } -static void *_p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::BlockDiagonalPreconditioner *) x)); +static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); } -static void *_p_mfem__BlockNonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::BlockNonlinearForm *) x)); +static void *_p_mfem__MixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::MixedBilinearForm *) x)); } static void *_p_mfem__NonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::NonlinearForm *) x)); } +static void *_p_mfem__BlockNonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::BlockNonlinearForm *) x)); +} static void *_p_mfem__ParNonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::NonlinearForm *) ((mfem::ParNonlinearForm *) x)); } @@ -4827,15 +4858,18 @@ static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPAR static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); } -static void *_p_mfem__BlockOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::BlockOperator *) x)); -} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } @@ -4851,12 +4885,33 @@ static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWI static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); +} +static void *_p_mfem__BlockOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::BlockOperator *) x)); +} static void *_p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConformingProlongationOperator *) x)); } +static void *_p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::ConformingProlongationOperator *) ((mfem::DeviceConformingProlongationOperator *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); } @@ -4896,10 +4951,32 @@ static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPAR static void *_p_mfem__HypreSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSmoother *) x)); } +static void *_p_mfem__ParFiniteElementSpaceTo_p_mfem__FiniteElementSpace(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementSpace *) ((mfem::ParFiniteElementSpace *) x)); +} +static void *_p_mfem__ParGridFunctionTo_p_mfem__GridFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GridFunction *) ((mfem::ParGridFunction *) x)); +} +static void *_p_mfem__HypreParVectorTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::HypreParVector *) x)); +} +static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); +} +static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); +} +static void *_p_mfem__ParGridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) (mfem::GridFunction *) ((mfem::ParGridFunction *) x)); +} +static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); +} static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -4913,32 +4990,42 @@ static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollecti static swig_type_info _swigt__p_mfem__NonlinearForm = {"_p_mfem__NonlinearForm", "mfem::NonlinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__BlockLowerTriangularPreconditioner = {"_p_mfem__BlockLowerTriangularPreconditioner", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BlockDiagonalPreconditioner = {"_p_mfem__BlockDiagonalPreconditioner", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__BlockLowerTriangularPreconditioner = {"_p_mfem__BlockLowerTriangularPreconditioner", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__BilinearForm = {"_p_mfem__BilinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedBilinearForm = {"_p_mfem__MixedBilinearForm", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DiscreteLinearOperator = {"_p_mfem__DiscreteLinearOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConformingProlongationOperator = {"_p_mfem__ConformingProlongationOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DeviceConformingProlongationOperator = {"_p_mfem__DeviceConformingProlongationOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreParMatrix = {"_p_mfem__HypreParMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; @@ -4964,11 +5051,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, &_swigt__p_mfem__AbstractSparseMatrix, &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_mfem__BilinearForm, &_swigt__p_mfem__BlockDiagonalPreconditioner, &_swigt__p_mfem__BlockLowerTriangularPreconditioner, &_swigt__p_mfem__BlockNonlinearForm, @@ -4977,9 +5066,12 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__DenseMatrix, &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__DeviceConformingProlongationOperator, + &_swigt__p_mfem__DiscreteLinearOperator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__HypreADS, &_swigt__p_mfem__HypreAMS, &_swigt__p_mfem__HypreBoomerAMG, @@ -4995,10 +5087,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__HypreSolver, &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2_FECollection, &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__Matrix, &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__MixedBilinearForm, &_swigt__p_mfem__NonlinearForm, &_swigt__p_mfem__Operator, &_swigt__p_mfem__OperatorHandle, @@ -5011,6 +5106,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -5028,6 +5126,7 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -5040,37 +5139,47 @@ static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__I static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NonlinearForm[] = { {&_swigt__p_mfem__NonlinearForm, 0, 0, 0}, {&_swigt__p_mfem__ParNonlinearForm, _p_mfem__ParNonlinearFormTo_p_mfem__NonlinearForm, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BlockLowerTriangularPreconditioner[] = {{&_swigt__p_mfem__BlockLowerTriangularPreconditioner, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockDiagonalPreconditioner[] = {{&_swigt__p_mfem__BlockDiagonalPreconditioner, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BlockLowerTriangularPreconditioner[] = {{&_swigt__p_mfem__BlockLowerTriangularPreconditioner, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearForm[] = {{&_swigt__p_mfem__BilinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedBilinearForm[] = {{&_swigt__p_mfem__MixedBilinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DiscreteLinearOperator[] = {{&_swigt__p_mfem__DiscreteLinearOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConformingProlongationOperator[] = {{&_swigt__p_mfem__ConformingProlongationOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DeviceConformingProlongationOperator[] = {{&_swigt__p_mfem__DeviceConformingProlongationOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreParMatrix[] = {{&_swigt__p_mfem__HypreParMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockNonlinearForm, _p_mfem__BlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParBlockNonlinearForm, _p_mfem__ParBlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NonlinearForm, _p_mfem__NonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParNonlinearForm, _p_mfem__ParNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockOperator, _p_mfem__BlockOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConformingProlongationOperator, _p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockNonlinearForm, _p_mfem__BlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParNonlinearForm, _p_mfem__ParNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParBlockNonlinearForm, _p_mfem__ParBlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NonlinearForm, _p_mfem__NonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockOperator, _p_mfem__BlockOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConformingProlongationOperator, _p_mfem__ConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DeviceConformingProlongationOperator, _p_mfem__DeviceConformingProlongationOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParBlockNonlinearForm[] = { {&_swigt__p_mfem__ParBlockNonlinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ParFiniteElementSpace[] = { {&_swigt__p_mfem__ParFiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; @@ -5092,11 +5201,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, _swigc__p_mfem__AbstractSparseMatrix, _swigc__p_mfem__ArrayT_int_t, + _swigc__p_mfem__BilinearForm, _swigc__p_mfem__BlockDiagonalPreconditioner, _swigc__p_mfem__BlockLowerTriangularPreconditioner, _swigc__p_mfem__BlockNonlinearForm, @@ -5105,9 +5216,12 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__DenseMatrix, _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__DeviceConformingProlongationOperator, + _swigc__p_mfem__DiscreteLinearOperator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__GridFunction, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__HypreADS, _swigc__p_mfem__HypreAMS, _swigc__p_mfem__HypreBoomerAMG, @@ -5123,10 +5237,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__HypreSolver, _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2_FECollection, _swigc__p_mfem__LinearForm, _swigc__p_mfem__Matrix, _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__MixedBilinearForm, _swigc__p_mfem__NonlinearForm, _swigc__p_mfem__Operator, _swigc__p_mfem__OperatorHandle, @@ -5139,6 +5256,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, @@ -5879,18 +5999,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/point.py b/mfem/_par/point.py index 83a61333..b27a203d 100644 --- a/mfem/_par/point.py +++ b/mfem/_par/point.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _point.SWIG_PyInstanceMethod_New +_swig_new_static_method = _point.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -90,6 +93,7 @@ def __init__(self, *args): def GetType(self): r"""GetType(Point self) -> mfem::Element::Type""" return _point.Point_GetType(self) + GetType = _swig_new_instance_method(_point.Point_GetType) def GetVertices(self, *args): r""" @@ -97,30 +101,45 @@ def GetVertices(self, *args): GetVertices(Point self) -> int * """ return _point.Point_GetVertices(self, *args) + GetVertices = _swig_new_instance_method(_point.Point_GetVertices) def GetNVertices(self): r"""GetNVertices(Point self) -> int""" return _point.Point_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_point.Point_GetNVertices) def GetNEdges(self): r"""GetNEdges(Point self) -> int""" return _point.Point_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_point.Point_GetNEdges) def GetEdgeVertices(self, ei): r"""GetEdgeVertices(Point self, int ei) -> int const *""" return _point.Point_GetEdgeVertices(self, ei) + GetEdgeVertices = _swig_new_instance_method(_point.Point_GetEdgeVertices) + + def GetNFaces(self, *args): + r""" + GetNFaces(Point self, int & nFaceVertices) -> int + GetNFaces(Point self) -> int + """ + return _point.Point_GetNFaces(self, *args) + GetNFaces = _swig_new_instance_method(_point.Point_GetNFaces) - def GetNFaces(self, nFaceVertices): - r"""GetNFaces(Point self, int & nFaceVertices) -> int""" - return _point.Point_GetNFaces(self, nFaceVertices) + def GetNFaceVertices(self, arg2): + r"""GetNFaceVertices(Point self, int arg2) -> int""" + return _point.Point_GetNFaceVertices(self, arg2) + GetNFaceVertices = _swig_new_instance_method(_point.Point_GetNFaceVertices) def GetFaceVertices(self, fi): r"""GetFaceVertices(Point self, int fi) -> int const *""" return _point.Point_GetFaceVertices(self, fi) + GetFaceVertices = _swig_new_instance_method(_point.Point_GetFaceVertices) def Duplicate(self, m): r"""Duplicate(Point self, mfem::Mesh * m) -> Element""" return _point.Point_Duplicate(self, m) + Duplicate = _swig_new_instance_method(_point.Point_Duplicate) __swig_destroy__ = _point.delete_Point # Register Point in _point: diff --git a/mfem/_par/point_wrap.cxx b/mfem/_par/point_wrap.cxx index c23692de..ab32885a 100644 --- a/mfem/_par/point_wrap.cxx +++ b/mfem/_par/point_wrap.cxx @@ -3641,7 +3641,7 @@ SWIGINTERN PyObject *_wrap_Point_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetNFaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int *arg2 = 0 ; @@ -3649,10 +3649,9 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; int result; - if (!SWIG_Python_UnpackTuple(args, "Point_GetNFaces", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaces" "', argument " "1"" of type '" "mfem::Point const *""'"); @@ -3686,6 +3685,121 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObj } +SWIGINTERN PyObject *_wrap_Point_GetNFaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Point *arg1 = (mfem::Point *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaces" "', argument " "1"" of type '" "mfem::Point const *""'"); + } + arg1 = reinterpret_cast< mfem::Point * >(argp1); + { + try { + result = (int)((mfem::Point const *)arg1)->GetNFaces(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Point_GetNFaces", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Point, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point_GetNFaces__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Point, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point_GetNFaces__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Point_GetNFaces'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Point::GetNFaces(int &) const\n" + " mfem::Point::GetNFaces() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Point *arg1 = (mfem::Point *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Point_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); + } + arg1 = reinterpret_cast< mfem::Point * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::Point const *)arg1)->GetNFaceVertices(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; @@ -3846,6 +3960,7 @@ SWIGINTERN PyObject *Swig_var_PointFE_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" "Point()\n" "Point(int const * ind, int attr=-1)\n" @@ -3858,7 +3973,11 @@ static PyMethodDef SwigMethods[] = { { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "Point_GetNVertices(Point self) -> int"}, { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "Point_GetNEdges(Point self) -> int"}, { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "Point_GetEdgeVertices(Point self, int ei) -> int const *"}, - { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "Point_GetNFaces(Point self, int & nFaceVertices) -> int"}, + { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" + "Point_GetNFaces(Point self, int & nFaceVertices) -> int\n" + "Point_GetNFaces(Point self) -> int\n" + ""}, + { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "Point_GetNFaceVertices(Point self, int arg2) -> int"}, { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "Point_GetFaceVertices(Point self, int fi) -> int const *"}, { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Point_Duplicate(Point self, mfem::Mesh * m) -> Element"}, { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, @@ -3868,6 +3987,30 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" + "Point()\n" + "Point(int const * ind, int attr=-1)\n" + ""}, + { "Point_GetType", _wrap_Point_GetType, METH_O, "GetType(Point self) -> mfem::Element::Type"}, + { "Point_GetVertices", _wrap_Point_GetVertices, METH_VARARGS, "\n" + "GetVertices(Point self, intArray v)\n" + "GetVertices(Point self) -> int *\n" + ""}, + { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "GetNVertices(Point self) -> int"}, + { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "GetNEdges(Point self) -> int"}, + { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Point self, int ei) -> int const *"}, + { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" + "GetNFaces(Point self, int & nFaceVertices) -> int\n" + "GetNFaces(Point self) -> int\n" + ""}, + { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Point self, int arg2) -> int"}, + { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Point self, int fi) -> int const *"}, + { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Duplicate(Point self, mfem::Mesh * m) -> Element"}, + { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, + { "Point_swigregister", Point_swigregister, METH_O, NULL}, + { "Point_swiginit", Point_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/prestriction.i b/mfem/_par/prestriction.i new file mode 100644 index 00000000..958de9ee --- /dev/null +++ b/mfem/_par/prestriction.i @@ -0,0 +1,20 @@ +%module(package="mfem._par") prestriction +%{ +#include "mfem.hpp" +#include "fem/prestriction.hpp" +#include "numpy/arrayobject.h" +#include "pyoperator.hpp" +%} + +%init %{ +import_array(); +%} +%include "exception.i" +%import "element.i" +%include "../common/exception.i" +%import "../common/numpy_int_typemap.i" + +%import "restriction.i" + +%include "fem/prestriction.hpp" + diff --git a/mfem/_par/prestriction.py b/mfem/_par/prestriction.py new file mode 100644 index 00000000..6c1787ff --- /dev/null +++ b/mfem/_par/prestriction.py @@ -0,0 +1,122 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 4.0.1 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info as _swig_python_version_info +if _swig_python_version_info < (2, 7, 0): + raise RuntimeError("Python 2.7 or later required") + +# Import the low-level C/C++ module +if __package__ or "." in __name__: + from . import _prestriction +else: + import _prestriction + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + +_swig_new_instance_method = _prestriction.SWIG_PyInstanceMethod_New +_swig_new_static_method = _prestriction.SWIG_PyStaticMethod_New + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +def _swig_setattr_nondynamic_instance_variable(set): + def set_instance_attr(self, name, value): + if name == "thisown": + self.this.own(value) + elif name == "this": + set(self, name, value) + elif hasattr(self, name) and isinstance(getattr(type(self), name), property): + set(self, name, value) + else: + raise AttributeError("You cannot add instance attributes to %s" % self) + return set_instance_attr + + +def _swig_setattr_nondynamic_class_variable(set): + def set_class_attr(cls, name, value): + if hasattr(cls, name) and not isinstance(getattr(cls, name), property): + set(cls, name, value) + else: + raise AttributeError("You cannot add class attributes to %s" % cls) + return set_class_attr + + +def _swig_add_metaclass(metaclass): + """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" + def wrapper(cls): + return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) + return wrapper + + +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) + + +import weakref + +import mfem._par.element +import mfem._par.array +import mfem._par.mem_manager +import mfem._par.densemat +import mfem._par.vector +import mfem._par.operators +import mfem._par.matrix +import mfem._par.geom +import mfem._par.intrules +import mfem._par.table +import mfem._par.hash +import mfem._par.restriction +import mfem._par.mesh +import mfem._par.ncmesh +import mfem._par.vtk +import mfem._par.vertex +import mfem._par.gridfunc +import mfem._par.coefficient +import mfem._par.sparsemat +import mfem._par.eltrans +import mfem._par.fe +import mfem._par.fespace +import mfem._par.fe_coll +import mfem._par.lininteg +import mfem._par.handle +import mfem._par.hypre +import mfem._par.bilininteg +import mfem._par.linearform +class ParL2FaceRestriction(mfem._par.operators.Operator): + r"""Proxy of C++ mfem::ParL2FaceRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r"""__init__(ParL2FaceRestriction self, mfem::ParFiniteElementSpace const & arg2, mfem::ElementDofOrdering arg3, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued) -> ParL2FaceRestriction""" + _prestriction.ParL2FaceRestriction_swiginit(self, _prestriction.new_ParL2FaceRestriction(*args)) + + def Mult(self, x, y): + r"""Mult(ParL2FaceRestriction self, Vector x, Vector y)""" + return _prestriction.ParL2FaceRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_prestriction.ParL2FaceRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(ParL2FaceRestriction self, Vector x, Vector y)""" + return _prestriction.ParL2FaceRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_prestriction.ParL2FaceRestriction_MultTranspose) + __swig_destroy__ = _prestriction.delete_ParL2FaceRestriction + +# Register ParL2FaceRestriction in _prestriction: +_prestriction.ParL2FaceRestriction_swigregister(ParL2FaceRestriction) + + + diff --git a/mfem/_par/prestriction_wrap.cxx b/mfem/_par/prestriction_wrap.cxx new file mode 100644 index 00000000..3692118f --- /dev/null +++ b/mfem/_par/prestriction_wrap.cxx @@ -0,0 +1,4822 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGPYTHON +#define SWIGPYTHON +#endif + +#define SWIG_DIRECTORS +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + + +#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) +/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ +# include +#endif + +#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) +/* Use debug wrappers with the Python release dll */ +# undef _DEBUG +# include +# define _DEBUG 1 +#else +# include +#endif + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = (unsigned char)((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = (unsigned char)((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (unsigned char)(d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (unsigned char)(d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Warning: This function will allocate a new string in Python 3, + * so please call SWIG_Python_str_DelForPy3(x) to free the space. + */ +SWIGINTERN char* +SWIG_Python_str_AsChar(PyObject *str) +{ +#if PY_VERSION_HEX >= 0x03000000 + char *newstr = 0; + str = PyUnicode_AsUTF8String(str); + if (str) { + char *cstr; + Py_ssize_t len; + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char *) malloc(len+1); + memcpy(newstr, cstr, len+1); + Py_XDECREF(str); + } + return newstr; +#else + return PyString_AsString(str); +#endif +} + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#else +# define SWIG_Python_str_DelForPy3(x) +#endif + + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user +// interface files check for it. +# define SWIGPY_USE_CAPSULE +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define Py_hash_t long +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + PyErr_Clear(); + Py_XINCREF(type); + if (tmp) + PyErr_Format(type, "%s %s", tmp, mesg); + else + PyErr_Format(type, "%s", mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +SWIGRUNTIME int +SWIG_Python_TypeErrorOccurred(PyObject *obj) +{ + PyObject *error; + if (obj) + return 0; + error = PyErr_Occurred(); + return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError); +} + +SWIGRUNTIME void +SWIG_Python_RaiseOrModifyTypeError(const char *message) +{ + if (SWIG_Python_TypeErrorOccurred(NULL)) { + /* Use existing TypeError to preserve stacktrace and enhance with given message */ + PyObject *newvalue; + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); +#if PY_VERSION_HEX >= 0x03000000 + newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message); +#else + newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); +#endif + Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + /* Raise TypeError using given message */ + PyErr_SetString(PyExc_TypeError, message); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# define SWIG_PYTHON_USE_GIL +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + const char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */ +# error "This version of SWIG only supports Python >= 2.7" +#endif + +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000 +# error "This version of SWIG only supports Python 3 >= 3.2" +#endif + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +} + +/* Unpack the argument tuple */ + +SWIGINTERN Py_ssize_t +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + Py_ssize_t i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + Py_ssize_t i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + int fail = data ? data->implicitconv : 0; + if (fail) + PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors."); + return fail; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { + data->newraw = PyObject_GetAttrString(data->klass, "__new__"); + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); + data->delargs = !(flags & (METH_O)); + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + + +#ifdef SWIGPYTHON_BUILTIN + +SWIGRUNTIME PyObject * +SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + + if (!sobj->dict) + sobj->dict = PyDict_New(); + + Py_INCREF(sobj->dict); + return sobj->dict; +} + +#endif + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { + PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_repr(SwigPyObject *v) +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (v->next) { + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } + return repr; +} + +/* We need a version taking two PyObject* parameters so it's a valid + * PyCFunction to use in swigobject_methods[]. */ +SWIGRUNTIME PyObject * +SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + return SwigPyObject_repr((SwigPyObject*)v); +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res; + if( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { +#ifdef SWIGPYTHON_BUILTIN + PyTypeObject *target_tp = SwigPyObject_type(); + if (PyType_IsSubtype(op->ob_type, target_tp)) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); +#else + return (Py_TYPE(op) == SwigPyObject_type()) + || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + + /* PyObject_CallFunction() has the potential to silently drop + the active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); + + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if (!res) + PyErr_WriteUnraisable(destroy); + + PyErr_Restore(type, value, traceback); + + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (!SwigPyObject_Check(next)) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) { + return NULL; + } else { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v,args); + } else { + SwigPyObject_disown(v,args); + } + } + return obj; + } +} + +static PyMethodDef +swigobject_methods[] = { + {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"}, + {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"}, + {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"}, + {"append", SwigPyObject_append, METH_O, "appends another 'this' object"}, + {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"}, + {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"}, + {0, 0, 0, 0} +}; + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ +#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#else + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpyobject_type) < 0) + return NULL; + } + return &swigpyobject_type; +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) + || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpypacked_type) < 0) + return NULL; + } + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +static PyObject *Swig_This_global = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (Swig_This_global == NULL) + Swig_This_global = SWIG_Python_str_FromChar("this"); + return Swig_This_global; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None && !implicit_conv) { + if (ptr) + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + res = SWIG_OK; + } else { + if (implicit_conv) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + swig_cast_info *tc; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) + return SWIG_ERROR; + tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + return SWIG_OK; + } +} + +/* Convert a packed pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *empty_args = PyTuple_New(0); + if (empty_args) { + PyObject *empty_kwargs = PyDict_New(); + if (empty_kwargs) { + inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + Py_DECREF(empty_kwargs); + if (inst) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } + } + Py_DECREF(empty_args); + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, "__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { + PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +SWIGRUNTIME void +SWIG_Python_DestroyModule(PyObject *obj) +{ + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + Swig_This_global = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { + obj = PyCapsule_New((void*) descriptor, NULL, NULL); + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + const char *errmesg = tmp ? tmp : "Invalid error message"; + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, errmesg); + } else { + PyErr_Format(type, "%s %s", errmesg, mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +#if SWIG_POINTER_EXCEPTION + if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } +#endif + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res = -1; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) < 0) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + if (!encoded_name) + return -1; + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Method creation and docstring support functions */ + +SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name); +SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); +SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); + +#ifdef __cplusplus +} +#endif + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Python proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ +#define SWIG_DIRECTOR_PYTHON_HEADER_ + +#include +#include +#include +#include +#include + + +/* + Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual + table', and avoid multiple GetAttr calls to retrieve the python + methods. +*/ + +#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE +#ifndef SWIG_PYTHON_DIRECTOR_VTABLE +#define SWIG_PYTHON_DIRECTOR_VTABLE +#endif +#endif + + + +/* + Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the + Undefined Exception Handler provided by swig. +*/ +#ifndef SWIG_DIRECTOR_NO_UEH +#ifndef SWIG_DIRECTOR_UEH +#define SWIG_DIRECTOR_UEH +#endif +#endif + + +/* + Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the + native C++ RTTI and dynamic_cast<>. But be aware that directors + could stop working when using this option. +*/ +#ifdef SWIG_DIRECTOR_NORTTI +/* + When we don't use the native C++ RTTI, we implement a minimal one + only for Directors. +*/ +# ifndef SWIG_DIRECTOR_RTDIR +# define SWIG_DIRECTOR_RTDIR + +namespace Swig { + class Director; + SWIGINTERN std::map& get_rtdir_map() { + static std::map rtdir_map; + return rtdir_map; + } + + SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { + get_rtdir_map()[vptr] = rtdir; + } + + SWIGINTERNINLINE Director *get_rtdir(void *vptr) { + std::map::const_iterator pos = get_rtdir_map().find(vptr); + Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; + return rtdir; + } +} +# endif /* SWIG_DIRECTOR_RTDIR */ + +# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) + +#else + +# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) + +#endif /* SWIG_DIRECTOR_NORTTI */ + +extern "C" { + struct swig_type_info; +} + +namespace Swig { + + /* memory handler */ + struct GCItem { + virtual ~GCItem() {} + + virtual int get_own() const { + return 0; + } + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem * operator->() const { + return _item; + } + + private: + GCItem *_item; + }; + + struct GCItem_Object : GCItem { + GCItem_Object(int own) : _own(own) { + } + + virtual ~GCItem_Object() { + } + + int get_own() const { + return _own; + } + + private: + int _own; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; + + template + struct GCArray_T : GCItem { + GCArray_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCArray_T() { + delete[] _ptr; + } + + private: + Type *_ptr; + }; + + /* base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + public: + DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (msg[0]) { + swig_msg += " "; + swig_msg += msg; + } + if (!PyErr_Occurred()) { + PyErr_SetString(error, what()); + } + SWIG_PYTHON_THREAD_END_BLOCK; + } + + virtual ~DirectorException() throw() { + } + + /* Deprecated, use what() instead */ + const char *getMessage() const { + return what(); + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorException(error, msg); + } + + static void raise(const char *msg) { + raise(PyExc_RuntimeError, msg); + } + }; + + /* type mismatch in the return value from a python method call */ + class DirectorTypeMismatchException : public DirectorException { + public: + DirectorTypeMismatchException(PyObject *error, const char *msg="") + : DirectorException(error, "SWIG director type mismatch", msg) { + } + + DirectorTypeMismatchException(const char *msg="") + : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorTypeMismatchException(error, msg); + } + + static void raise(const char *msg) { + throw DirectorTypeMismatchException(msg); + } + }; + + /* any python exception that occurs during a director method call */ + class DirectorMethodException : public DirectorException { + public: + DirectorMethodException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { + } + + static void raise(const char *msg) { + throw DirectorMethodException(msg); + } + }; + + /* attempt to call a pure virtual method via a director method */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { + } + + static void raise(const char *msg) { + throw DirectorPureVirtualException(msg); + } + }; + + +#if defined(SWIG_PYTHON_THREADS) +/* __THREAD__ is the old macro to activate some thread support */ +# if !defined(__THREAD__) +# define __THREAD__ 1 +# endif +#endif + +#ifdef __THREAD__ +# include "pythread.h" + class Guard { + PyThread_type_lock &mutex_; + + public: + Guard(PyThread_type_lock & mutex) : mutex_(mutex) { + PyThread_acquire_lock(mutex_, WAIT_LOCK); + } + + ~Guard() { + PyThread_release_lock(mutex_); + } + }; +# define SWIG_GUARD(mutex) Guard _guard(mutex) +#else +# define SWIG_GUARD(mutex) +#endif + + /* director base class */ + class Director { + private: + /* pointer to the wrapped python object */ + PyObject *swig_self; + /* flag indicating whether the object is owned by python or c++ */ + mutable bool swig_disown_flag; + + /* decrement the reference count of the wrapped python object */ + void swig_decref() const { + if (swig_disown_flag) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_DECREF(swig_self); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + public: + /* wrap a python object. */ + Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { + } + + /* discard our reference at destruction */ + virtual ~Director() { + swig_decref(); + } + + /* return a pointer to the wrapped python object */ + PyObject *swig_get_self() const { + return swig_self; + } + + /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); + } + } + + /* increase the reference count of the wrapped python object */ + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); + } + } + + /* methods to implement pseudo protected director members */ + virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { + return true; + } + + virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { + } + + /* ownership management */ + private: + typedef std::map swig_ownership_map; + mutable swig_ownership_map swig_owner; +#ifdef __THREAD__ + static PyThread_type_lock swig_mutex_own; +#endif + + public: + template + void swig_acquire_ownership_array(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCArray_T(vptr); + } + } + + template + void swig_acquire_ownership(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_T(vptr); + } + } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_Object(own); + } + } + + int swig_release_ownership(void *vptr) const { + int own = 0; + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_ownership_map::iterator iter = swig_owner.find(vptr); + if (iter != swig_owner.end()) { + own = iter->second->get_own(); + swig_owner.erase(iter); + } + } + return own; + } + + template + static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { + SwigPyObject *sobj = (SwigPyObject *)pyobj; + sobj->own = 0; + Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); + if (d) + d->swig_disown(); + return PyWeakref_NewProxy(pyobj, NULL); + } + }; + +#ifdef __THREAD__ + PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock(); +#endif +} + +#endif + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_MPI_Comm swig_types[0] +#define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[7] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[8] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[9] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[10] +#define SWIGTYPE_p_mfem__GridFunction swig_types[11] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[12] +#define SWIGTYPE_p_mfem__HypreADS swig_types[13] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[14] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[15] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[16] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[17] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[18] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[19] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[20] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[21] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[22] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[23] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[24] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[25] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[26] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[27] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[28] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[29] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[30] +#define SWIGTYPE_p_mfem__LinearForm swig_types[31] +#define SWIGTYPE_p_mfem__Matrix swig_types[32] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[33] +#define SWIGTYPE_p_mfem__Operator swig_types[34] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[35] +#define SWIGTYPE_p_mfem__ParFiniteElementSpace swig_types[36] +#define SWIGTYPE_p_mfem__ParL2FaceRestriction swig_types[37] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[38] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[39] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[40] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[41] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[42] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[43] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[44] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[45] +#define SWIGTYPE_p_mfem__Solver swig_types[46] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[47] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[48] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[49] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[50] +#define SWIGTYPE_p_mfem__Vector swig_types[51] +#define SWIGTYPE_p_pri_t swig_types[52] +#define SWIGTYPE_p_quad_t swig_types[53] +#define SWIGTYPE_p_seg_t swig_types[54] +#define SWIGTYPE_p_tet_t swig_types[55] +#define SWIGTYPE_p_tri_t swig_types[56] +static swig_type_info *swig_types[58]; +static swig_module_info swig_module = {swig_types, 57, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#ifdef SWIG_TypeQuery +# undef SWIG_TypeQuery +#endif +#define SWIG_TypeQuery SWIG_Python_TypeQuery + +/*----------------------------------------------- + @(target):= _prestriction.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__prestriction + +#else +# define SWIG_init init_prestriction + +#endif +#define SWIG_name "_prestriction" + +#define SWIGVERSION 0x040001 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include "mfem.hpp" +#include "fem/prestriction.hpp" +#include "numpy/arrayobject.h" +#include "pyoperator.hpp" + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "prestriction_wrap.h" + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + mfem::L2FaceValues arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::ParL2FaceRestriction *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ParL2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParL2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParL2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); + { + try { + result = (mfem::ParL2FaceRestriction *)new mfem::ParL2FaceRestriction((mfem::ParFiniteElementSpace const &)*arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParL2FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ParFiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::ParL2FaceRestriction *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ParL2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParL2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::ParL2FaceRestriction *)new mfem::ParL2FaceRestriction((mfem::ParFiniteElementSpace const &)*arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParL2FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ParL2FaceRestriction", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ParL2FaceRestriction__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ParL2FaceRestriction__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ParL2FaceRestriction'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParL2FaceRestriction::ParL2FaceRestriction(mfem::ParFiniteElementSpace const &,mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues)\n" + " mfem::ParL2FaceRestriction::ParL2FaceRestriction(mfem::ParFiniteElementSpace const &,mfem::ElementDofOrdering,mfem::FaceType)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParL2FaceRestriction *arg1 = (mfem::ParL2FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ParL2FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParL2FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParL2FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::ParL2FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ParL2FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParL2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParL2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParL2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParL2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ParL2FaceRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParL2FaceRestriction *arg1 = (mfem::ParL2FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ParL2FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParL2FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ParL2FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ParL2FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ParL2FaceRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ParL2FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ParL2FaceRestriction *arg1 = (mfem::ParL2FaceRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParL2FaceRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParL2FaceRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::ParL2FaceRestriction * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ParL2FaceRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ParL2FaceRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ParL2FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ParL2FaceRestriction", _wrap_new_ParL2FaceRestriction, METH_VARARGS, "ParL2FaceRestriction(mfem::ParFiniteElementSpace const & arg1, mfem::ElementDofOrdering arg2, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued)"}, + { "ParL2FaceRestriction_Mult", _wrap_ParL2FaceRestriction_Mult, METH_VARARGS, "ParL2FaceRestriction_Mult(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "ParL2FaceRestriction_MultTranspose", _wrap_ParL2FaceRestriction_MultTranspose, METH_VARARGS, "ParL2FaceRestriction_MultTranspose(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "delete_ParL2FaceRestriction", _wrap_delete_ParL2FaceRestriction, METH_O, "delete_ParL2FaceRestriction(ParL2FaceRestriction self)"}, + { "ParL2FaceRestriction_swigregister", ParL2FaceRestriction_swigregister, METH_O, NULL}, + { "ParL2FaceRestriction_swiginit", ParL2FaceRestriction_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ParL2FaceRestriction", _wrap_new_ParL2FaceRestriction, METH_VARARGS, "ParL2FaceRestriction(mfem::ParFiniteElementSpace const & arg1, mfem::ElementDofOrdering arg2, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued)"}, + { "ParL2FaceRestriction_Mult", _wrap_ParL2FaceRestriction_Mult, METH_VARARGS, "Mult(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "ParL2FaceRestriction_MultTranspose", _wrap_ParL2FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "delete_ParL2FaceRestriction", _wrap_delete_ParL2FaceRestriction, METH_O, "delete_ParL2FaceRestriction(ParL2FaceRestriction self)"}, + { "ParL2FaceRestriction_swigregister", ParL2FaceRestriction_swigregister, METH_O, NULL}, + { "ParL2FaceRestriction_swiginit", ParL2FaceRestriction_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_mfem__HypreParVectorTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::HypreParVector *) x)); +} +static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); +} +static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); +} +static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); +} +static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); +} +static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); +} +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +} +static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +} +static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +} +static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); +} +static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); +} +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +} +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +} +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +} +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +} +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +} +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +} +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +} +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} +static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); +} +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} +static void *_p_mfem__ParL2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ParL2FaceRestriction *) x)); +} +static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); +} +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +} +static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); +} +static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); +} +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +} +static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); +} +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +} +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +} +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); +} +static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); +} +static void *_p_mfem__HypreSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSmoother *) x)); +} +static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__IntegrationRule = {"_p_mfem__IntegrationRule", "mfem::IntegrationRule *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollection", "mfem::L2_FECollection *|mfem::DG_FECollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParMatrix = {"_p_mfem__HypreParMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSmoother = {"_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ParFiniteElementSpace = {"_p_mfem__ParFiniteElementSpace", "mfem::ParFiniteElementSpace *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ParL2FaceRestriction = {"_p_mfem__ParL2FaceRestriction", "mfem::ParL2FaceRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__HypreParVector = {"_p_mfem__HypreParVector", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_MPI_Comm, + &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, + &_swigt__p_char, + &_swigt__p_hex_t, + &_swigt__p_int, + &_swigt__p_mfem__AbstractSparseMatrix, + &_swigt__p_mfem__ConstrainedOperator, + &_swigt__p_mfem__DenseMatrix, + &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__ElementRestriction, + &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__H1FaceRestriction, + &_swigt__p_mfem__HypreADS, + &_swigt__p_mfem__HypreAMS, + &_swigt__p_mfem__HypreBoomerAMG, + &_swigt__p_mfem__HypreDiagScale, + &_swigt__p_mfem__HypreEuclid, + &_swigt__p_mfem__HypreGMRES, + &_swigt__p_mfem__HypreIdentity, + &_swigt__p_mfem__HyprePCG, + &_swigt__p_mfem__HypreParMatrix, + &_swigt__p_mfem__HypreParVector, + &_swigt__p_mfem__HypreParaSails, + &_swigt__p_mfem__HypreSmoother, + &_swigt__p_mfem__HypreSolver, + &_swigt__p_mfem__IdentityOperator, + &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, + &_swigt__p_mfem__L2_FECollection, + &_swigt__p_mfem__LinearForm, + &_swigt__p_mfem__Matrix, + &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__Operator, + &_swigt__p_mfem__OperatorHandle, + &_swigt__p_mfem__ParFiniteElementSpace, + &_swigt__p_mfem__ParL2FaceRestriction, + &_swigt__p_mfem__ProductOperator, + &_swigt__p_mfem__PyOperatorBase, + &_swigt__p_mfem__PyTimeDependentOperatorBase, + &_swigt__p_mfem__QuadratureFunction, + &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, + &_swigt__p_mfem__Solver, + &_swigt__p_mfem__SparseMatrix, + &_swigt__p_mfem__TimeDependentOperator, + &_swigt__p_mfem__TransposeOperator, + &_swigt__p_mfem__TripleProductOperator, + &_swigt__p_mfem__Vector, + &_swigt__p_pri_t, + &_swigt__p_quad_t, + &_swigt__p_seg_t, + &_swigt__p_tet_t, + &_swigt__p_tri_t, +}; + +static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SparseMatrix[] = {{&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParMatrix[] = {{&_swigt__p_mfem__HypreParMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ParL2FaceRestriction, _p_mfem__ParL2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ParFiniteElementSpace[] = { {&_swigt__p_mfem__ParFiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ParL2FaceRestriction[] = { {&_swigt__p_mfem__ParL2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__HypreParVector, _p_mfem__HypreParVectorTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_MPI_Comm, + _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, + _swigc__p_char, + _swigc__p_hex_t, + _swigc__p_int, + _swigc__p_mfem__AbstractSparseMatrix, + _swigc__p_mfem__ConstrainedOperator, + _swigc__p_mfem__DenseMatrix, + _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__ElementRestriction, + _swigc__p_mfem__GridFunction, + _swigc__p_mfem__H1FaceRestriction, + _swigc__p_mfem__HypreADS, + _swigc__p_mfem__HypreAMS, + _swigc__p_mfem__HypreBoomerAMG, + _swigc__p_mfem__HypreDiagScale, + _swigc__p_mfem__HypreEuclid, + _swigc__p_mfem__HypreGMRES, + _swigc__p_mfem__HypreIdentity, + _swigc__p_mfem__HyprePCG, + _swigc__p_mfem__HypreParMatrix, + _swigc__p_mfem__HypreParVector, + _swigc__p_mfem__HypreParaSails, + _swigc__p_mfem__HypreSmoother, + _swigc__p_mfem__HypreSolver, + _swigc__p_mfem__IdentityOperator, + _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, + _swigc__p_mfem__L2_FECollection, + _swigc__p_mfem__LinearForm, + _swigc__p_mfem__Matrix, + _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__Operator, + _swigc__p_mfem__OperatorHandle, + _swigc__p_mfem__ParFiniteElementSpace, + _swigc__p_mfem__ParL2FaceRestriction, + _swigc__p_mfem__ProductOperator, + _swigc__p_mfem__PyOperatorBase, + _swigc__p_mfem__PyTimeDependentOperatorBase, + _swigc__p_mfem__QuadratureFunction, + _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, + _swigc__p_mfem__Solver, + _swigc__p_mfem__SparseMatrix, + _swigc__p_mfem__TimeDependentOperator, + _swigc__p_mfem__TransposeOperator, + _swigc__p_mfem__TripleProductOperator, + _swigc__p_mfem__Vector, + _swigc__p_pri_t, + _swigc__p_quad_t, + _swigc__p_seg_t, + _swigc__p_tet_t, + _swigc__p_tri_t, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *globals = 0; + if (!globals) { + globals = SWIG_newvarlink(); + } + return globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (!c) continue; + c = strstr(c, "swig_ptr: "); + if (c) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + memcpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + memcpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + + /* ----------------------------------------------------------------------------- + * Method creation and docstring support functions + * ----------------------------------------------------------------------------- */ + + /* ----------------------------------------------------------------------------- + * Function to find the method definition with the correct docstring for the + * proxy module as opposed to the low-level API + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) { + /* Find the function in the modified method table */ + size_t offset = 0; + int found = 0; + while (SwigMethods_proxydocs[offset].ml_meth != NULL) { + if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) { + found = 1; + break; + } + offset++; + } + /* Use the copy with the modified docstring if available */ + return found ? &SwigMethods_proxydocs[offset] : NULL; + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyInstanceMethod_New() used in Python 3 + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } +#if PY_VERSION_HEX >= 0x03000000 + return PyInstanceMethod_New(func); +#else + return PyMethod_New(func, NULL, NULL); +#endif + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyStaticMethod_New() + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } + return PyStaticMethod_New(func); + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md, *globals; + +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { + PyModuleDef_HEAD_INIT, + SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + SwigPyObject_own, + SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + PyTypeObject *swigpyobject; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + PyObject *self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); + assert(metatype); +#endif + + (void)globals; + + /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */ + SWIG_This(); + SWIG_Python_TypeCache(); + SwigPyPacked_type(); +#ifndef SWIGPYTHON_BUILTIN + SwigPyObject_type(); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule(SWIG_name, SwigMethods); +#endif + + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + swigpyobject = SwigPyObject_TypeOnce(); + + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = swigpyobject; + } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + + import_array(); + +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/mfem/_par/prestriction_wrap.h b/mfem/_par/prestriction_wrap.h new file mode 100644 index 00000000..87c1f06f --- /dev/null +++ b/mfem/_par/prestriction_wrap.h @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_prestriction_WRAP_H_ +#define SWIG_prestriction_WRAP_H_ + +#include +#include + + +#endif diff --git a/mfem/_par/pumi.py b/mfem/_par/pumi.py index 2ccf3c89..ee270026 100644 --- a/mfem/_par/pumi.py +++ b/mfem/_par/pumi.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _pumi.SWIG_PyInstanceMethod_New +_swig_new_static_method = _pumi.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -101,19 +104,23 @@ def __init__(self): def assign(self, value): r"""assign(intp self, int value)""" return _pumi.intp_assign(self, value) + assign = _swig_new_instance_method(_pumi.intp_assign) def value(self): r"""value(intp self) -> int""" return _pumi.intp_value(self) + value = _swig_new_instance_method(_pumi.intp_value) def cast(self): r"""cast(intp self) -> int *""" return _pumi.intp_cast(self) + cast = _swig_new_instance_method(_pumi.intp_cast) @staticmethod def frompointer(t): r"""frompointer(int * t) -> intp""" return _pumi.intp_frompointer(t) + frompointer = _swig_new_static_method(_pumi.intp_frompointer) # Register intp in _pumi: _pumi.intp_swigregister(intp) @@ -121,6 +128,7 @@ def frompointer(t): def intp_frompointer(t): r"""intp_frompointer(int * t) -> intp""" return _pumi.intp_frompointer(t) +intp_frompointer = _pumi.intp_frompointer class doublep(object): r"""Proxy of C++ doublep class.""" @@ -136,19 +144,23 @@ def __init__(self): def assign(self, value): r"""assign(doublep self, double value)""" return _pumi.doublep_assign(self, value) + assign = _swig_new_instance_method(_pumi.doublep_assign) def value(self): r"""value(doublep self) -> double""" return _pumi.doublep_value(self) + value = _swig_new_instance_method(_pumi.doublep_value) def cast(self): r"""cast(doublep self) -> double *""" return _pumi.doublep_cast(self) + cast = _swig_new_instance_method(_pumi.doublep_cast) @staticmethod def frompointer(t): r"""frompointer(double * t) -> doublep""" return _pumi.doublep_frompointer(t) + frompointer = _swig_new_static_method(_pumi.doublep_frompointer) # Register doublep in _pumi: _pumi.doublep_swigregister(doublep) @@ -156,6 +168,7 @@ def frompointer(t): def doublep_frompointer(t): r"""doublep_frompointer(double * t) -> doublep""" return _pumi.doublep_frompointer(t) +doublep_frompointer = _pumi.doublep_frompointer import mfem._par.pgridfunc import mfem._par.pfespace @@ -174,6 +187,7 @@ def doublep_frompointer(t): import mfem._par.geom import mfem._par.mesh import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.table import mfem._par.hash @@ -185,6 +199,7 @@ def doublep_frompointer(t): import mfem._par.linearform import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.pmesh import mfem._par.pncmesh import mfem._par.communication @@ -193,6 +208,7 @@ def doublep_frompointer(t): def ParMesh2ParPumiMesh(pmesh): r"""ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh""" return _pumi.ParMesh2ParPumiMesh(pmesh) +ParMesh2ParPumiMesh = _pumi.ParMesh2ParPumiMesh class PumiMesh(mfem._par.mesh.Mesh): r"""Proxy of C++ mfem::PumiMesh class.""" @@ -212,6 +228,7 @@ def Load(self, *args): Load(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True) """ return _pumi.PumiMesh_Load(self, *args) + Load = _swig_new_instance_method(_pumi.PumiMesh_Load) __swig_destroy__ = _pumi.delete_PumiMesh # Register PumiMesh in _pumi: @@ -233,18 +250,22 @@ def FieldMFEMtoPUMI(self, *args): FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Pr, apf::Field * PrField, apf::Field * PrMagField) """ return _pumi.ParPumiMesh_FieldMFEMtoPUMI(self, *args) + FieldMFEMtoPUMI = _swig_new_instance_method(_pumi.ParPumiMesh_FieldMFEMtoPUMI) def VectorFieldMFEMtoPUMI(self, apf_mesh, Vel, VelField, VelMagField): r"""VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)""" return _pumi.ParPumiMesh_VectorFieldMFEMtoPUMI(self, apf_mesh, Vel, VelField, VelMagField) + VectorFieldMFEMtoPUMI = _swig_new_instance_method(_pumi.ParPumiMesh_VectorFieldMFEMtoPUMI) def UpdateMesh(self, AdaptedpMesh): r"""UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)""" return _pumi.ParPumiMesh_UpdateMesh(self, AdaptedpMesh) + UpdateMesh = _swig_new_instance_method(_pumi.ParPumiMesh_UpdateMesh) def FieldPUMItoMFEM(self, apf_mesh, ScalarField, Pr): r"""FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)""" return _pumi.ParPumiMesh_FieldPUMItoMFEM(self, apf_mesh, ScalarField, Pr) + FieldPUMItoMFEM = _swig_new_instance_method(_pumi.ParPumiMesh_FieldPUMItoMFEM) __swig_destroy__ = _pumi.delete_ParPumiMesh # Register ParPumiMesh in _pumi: diff --git a/mfem/_par/pumi_wrap.cxx b/mfem/_par/pumi_wrap.cxx index dac0ac30..33b63dec 100644 --- a/mfem/_par/pumi_wrap.cxx +++ b/mfem/_par/pumi_wrap.cxx @@ -3069,37 +3069,38 @@ namespace Swig { #define SWIGTYPE_p_GroupId swig_types[1] #define SWIGTYPE_p_MPI_Comm swig_types[2] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[3] -#define SWIGTYPE_p_apf__Field swig_types[4] -#define SWIGTYPE_p_apf__Mesh2 swig_types[5] -#define SWIGTYPE_p_apf__Numbering swig_types[6] -#define SWIGTYPE_p_char swig_types[7] -#define SWIGTYPE_p_double swig_types[8] -#define SWIGTYPE_p_doublep swig_types[9] -#define SWIGTYPE_p_hex_t swig_types[10] -#define SWIGTYPE_p_int swig_types[11] -#define SWIGTYPE_p_intp swig_types[12] -#define SWIGTYPE_p_mfem__GridFunction swig_types[13] -#define SWIGTYPE_p_mfem__GridFunctionPumi swig_types[14] -#define SWIGTYPE_p_mfem__HypreParVector swig_types[15] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[16] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[17] -#define SWIGTYPE_p_mfem__LinearForm swig_types[18] -#define SWIGTYPE_p_mfem__Mesh swig_types[19] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[20] -#define SWIGTYPE_p_mfem__ParGridFunction swig_types[21] -#define SWIGTYPE_p_mfem__ParMesh swig_types[22] -#define SWIGTYPE_p_mfem__ParPumiMesh swig_types[23] -#define SWIGTYPE_p_mfem__PumiMesh swig_types[24] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[25] -#define SWIGTYPE_p_mfem__Vector swig_types[26] -#define SWIGTYPE_p_pri_t swig_types[27] -#define SWIGTYPE_p_quad_t swig_types[28] -#define SWIGTYPE_p_seg_t swig_types[29] -#define SWIGTYPE_p_std__istream swig_types[30] -#define SWIGTYPE_p_tet_t swig_types[31] -#define SWIGTYPE_p_tri_t swig_types[32] -static swig_type_info *swig_types[34]; -static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[4] +#define SWIGTYPE_p_apf__Field swig_types[5] +#define SWIGTYPE_p_apf__Mesh2 swig_types[6] +#define SWIGTYPE_p_apf__Numbering swig_types[7] +#define SWIGTYPE_p_char swig_types[8] +#define SWIGTYPE_p_double swig_types[9] +#define SWIGTYPE_p_doublep swig_types[10] +#define SWIGTYPE_p_hex_t swig_types[11] +#define SWIGTYPE_p_int swig_types[12] +#define SWIGTYPE_p_intp swig_types[13] +#define SWIGTYPE_p_mfem__GridFunction swig_types[14] +#define SWIGTYPE_p_mfem__GridFunctionPumi swig_types[15] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[16] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[17] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[18] +#define SWIGTYPE_p_mfem__LinearForm swig_types[19] +#define SWIGTYPE_p_mfem__Mesh swig_types[20] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[21] +#define SWIGTYPE_p_mfem__ParGridFunction swig_types[22] +#define SWIGTYPE_p_mfem__ParMesh swig_types[23] +#define SWIGTYPE_p_mfem__ParPumiMesh swig_types[24] +#define SWIGTYPE_p_mfem__PumiMesh swig_types[25] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[26] +#define SWIGTYPE_p_mfem__Vector swig_types[27] +#define SWIGTYPE_p_pri_t swig_types[28] +#define SWIGTYPE_p_quad_t swig_types[29] +#define SWIGTYPE_p_seg_t swig_types[30] +#define SWIGTYPE_p_std__istream swig_types[31] +#define SWIGTYPE_p_tet_t swig_types[32] +#define SWIGTYPE_p_tri_t swig_types[33] +static swig_type_info *swig_types[35]; +static swig_module_info swig_module = {swig_types, 34, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5312,6 +5313,7 @@ SWIGINTERN PyObject *GridFunctionPumi_swiginit(PyObject *SWIGUNUSEDPARM(self), P static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, { "intp_assign", _wrap_intp_assign, METH_VARARGS, "intp_assign(intp self, int value)"}, @@ -5359,6 +5361,51 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, + { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, "assign(intp self, int value)"}, + { "intp_value", _wrap_intp_value, METH_O, "value(intp self) -> int"}, + { "intp_cast", _wrap_intp_cast, METH_O, "cast(intp self) -> int *"}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, "frompointer(int * t) -> intp"}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, + { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "assign(doublep self, double value)"}, + { "doublep_value", _wrap_doublep_value, METH_O, "value(doublep self) -> double"}, + { "doublep_cast", _wrap_doublep_cast, METH_O, "cast(doublep self) -> double *"}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "frompointer(double * t) -> doublep"}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "ParMesh2ParPumiMesh", _wrap_ParMesh2ParPumiMesh, METH_O, "ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh"}, + { "new_PumiMesh", _wrap_new_PumiMesh, METH_VARARGS, "PumiMesh(apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "PumiMesh_Load", _wrap_PumiMesh_Load, METH_VARARGS, "\n" + "Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + "Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1)\n" + "Load(PumiMesh self, std::istream & input, int generate_edges=0)\n" + "Load(PumiMesh self, std::istream & input)\n" + "Load(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + ""}, + { "delete_PumiMesh", _wrap_delete_PumiMesh, METH_O, "delete_PumiMesh(PumiMesh self)"}, + { "PumiMesh_swigregister", PumiMesh_swigregister, METH_O, NULL}, + { "PumiMesh_swiginit", PumiMesh_swiginit, METH_VARARGS, NULL}, + { "new_ParPumiMesh", _wrap_new_ParPumiMesh, METH_VARARGS, "new_ParPumiMesh(MPI_Comm comm, apf::Mesh2 * apf_mesh) -> ParPumiMesh"}, + { "ParPumiMesh_FieldMFEMtoPUMI", _wrap_ParPumiMesh_FieldMFEMtoPUMI, METH_VARARGS, "\n" + "FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, ParGridFunction Pr, apf::Field * VelField, apf::Field * PrField, apf::Field * VelMagField)\n" + "FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Pr, apf::Field * PrField, apf::Field * PrMagField)\n" + ""}, + { "ParPumiMesh_VectorFieldMFEMtoPUMI", _wrap_ParPumiMesh_VectorFieldMFEMtoPUMI, METH_VARARGS, "VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)"}, + { "ParPumiMesh_UpdateMesh", _wrap_ParPumiMesh_UpdateMesh, METH_VARARGS, "UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)"}, + { "ParPumiMesh_FieldPUMItoMFEM", _wrap_ParPumiMesh_FieldPUMItoMFEM, METH_VARARGS, "FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)"}, + { "delete_ParPumiMesh", _wrap_delete_ParPumiMesh, METH_O, "delete_ParPumiMesh(ParPumiMesh self)"}, + { "ParPumiMesh_swigregister", ParPumiMesh_swigregister, METH_O, NULL}, + { "ParPumiMesh_swiginit", ParPumiMesh_swiginit, METH_VARARGS, NULL}, + { "new_GridFunctionPumi", _wrap_new_GridFunctionPumi, METH_VARARGS, "new_GridFunctionPumi(Mesh m, apf::Mesh2 * PumiM, apf::Numbering * v_num_loc, int const mesh_order) -> GridFunctionPumi"}, + { "delete_GridFunctionPumi", _wrap_delete_GridFunctionPumi, METH_O, "delete_GridFunctionPumi(GridFunctionPumi self)"}, + { "GridFunctionPumi_swigregister", GridFunctionPumi_swigregister, METH_O, NULL}, + { "GridFunctionPumi_swiginit", GridFunctionPumi_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5411,6 +5458,7 @@ static swig_type_info _swigt__p_CommGroup = {"_p_CommGroup", "CommGroup *", 0, 0 static swig_type_info _swigt__p_GroupId = {"_p_GroupId", "GroupId *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_apf__Field = {"_p_apf__Field", "apf::Field *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_apf__Mesh2 = {"_p_apf__Mesh2", "apf::Mesh2 *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_apf__Numbering = {"_p_apf__Numbering", "apf::Numbering *", 0, 0, (void*)0, 0}; @@ -5446,6 +5494,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GroupId, &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_apf__Field, &_swigt__p_apf__Mesh2, &_swigt__p_apf__Numbering, @@ -5481,6 +5530,7 @@ static swig_cast_info _swigc__p_CommGroup[] = { {&_swigt__p_CommGroup, 0, 0, 0} static swig_cast_info _swigc__p_GroupId[] = { {&_swigt__p_GroupId, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_apf__Field[] = { {&_swigt__p_apf__Field, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_apf__Mesh2[] = { {&_swigt__p_apf__Mesh2, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_apf__Numbering[] = { {&_swigt__p_apf__Numbering, 0, 0, 0},{0, 0, 0, 0}}; @@ -5516,6 +5566,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GroupId, _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_apf__Field, _swigc__p_apf__Mesh2, _swigc__p_apf__Numbering, @@ -6274,18 +6325,18 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/restriction.i b/mfem/_par/restriction.i new file mode 100644 index 00000000..e6c9fc82 --- /dev/null +++ b/mfem/_par/restriction.i @@ -0,0 +1,21 @@ +%module(package="mfem._par") restriction +%{ +#include "mfem.hpp" +#include "fem/restriction.hpp" +#include "numpy/arrayobject.h" +#include "pyoperator.hpp" +%} + +%init %{ +import_array(); +%} +%include "exception.i" +%import "element.i" +%include "../common/exception.i" +%import "../common/numpy_int_typemap.i" + +%import "operators.i" +%import "mesh.i" + +%include "fem/restriction.hpp" + diff --git a/mfem/_par/restriction.py b/mfem/_par/restriction.py new file mode 100644 index 00000000..2f2f39c7 --- /dev/null +++ b/mfem/_par/restriction.py @@ -0,0 +1,217 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 4.0.1 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info as _swig_python_version_info +if _swig_python_version_info < (2, 7, 0): + raise RuntimeError("Python 2.7 or later required") + +# Import the low-level C/C++ module +if __package__ or "." in __name__: + from . import _restriction +else: + import _restriction + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + +_swig_new_instance_method = _restriction.SWIG_PyInstanceMethod_New +_swig_new_static_method = _restriction.SWIG_PyStaticMethod_New + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +def _swig_setattr_nondynamic_instance_variable(set): + def set_instance_attr(self, name, value): + if name == "thisown": + self.this.own(value) + elif name == "this": + set(self, name, value) + elif hasattr(self, name) and isinstance(getattr(type(self), name), property): + set(self, name, value) + else: + raise AttributeError("You cannot add instance attributes to %s" % self) + return set_instance_attr + + +def _swig_setattr_nondynamic_class_variable(set): + def set_class_attr(cls, name, value): + if hasattr(cls, name) and not isinstance(getattr(cls, name), property): + set(cls, name, value) + else: + raise AttributeError("You cannot add class attributes to %s" % cls) + return set_class_attr + + +def _swig_add_metaclass(metaclass): + """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" + def wrapper(cls): + return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) + return wrapper + + +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) + + +import weakref + +import mfem._par.element +import mfem._par.array +import mfem._par.mem_manager +import mfem._par.densemat +import mfem._par.vector +import mfem._par.operators +import mfem._par.matrix +import mfem._par.geom +import mfem._par.intrules +import mfem._par.table +import mfem._par.hash +import mfem._par.mesh +import mfem._par.ncmesh +import mfem._par.vtk +import mfem._par.vertex +import mfem._par.gridfunc +import mfem._par.coefficient +import mfem._par.sparsemat +import mfem._par.eltrans +import mfem._par.fe +import mfem._par.fespace +import mfem._par.fe_coll +import mfem._par.lininteg +import mfem._par.handle +import mfem._par.hypre +import mfem._par.bilininteg +import mfem._par.linearform +L2FaceValues_SingleValued = _restriction.L2FaceValues_SingleValued + +L2FaceValues_DoubleValued = _restriction.L2FaceValues_DoubleValued + +class ElementRestriction(mfem._par.operators.Operator): + r"""Proxy of C++ mfem::ElementRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, arg2, arg3): + r"""__init__(ElementRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering arg3) -> ElementRestriction""" + _restriction.ElementRestriction_swiginit(self, _restriction.new_ElementRestriction(arg2, arg3)) + + def Mult(self, x, y): + r"""Mult(ElementRestriction self, Vector x, Vector y)""" + return _restriction.ElementRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.ElementRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(ElementRestriction self, Vector x, Vector y)""" + return _restriction.ElementRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.ElementRestriction_MultTranspose) + + def MultTransposeUnsigned(self, x, y): + r"""MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)""" + return _restriction.ElementRestriction_MultTransposeUnsigned(self, x, y) + MultTransposeUnsigned = _swig_new_instance_method(_restriction.ElementRestriction_MultTransposeUnsigned) + __swig_destroy__ = _restriction.delete_ElementRestriction + +# Register ElementRestriction in _restriction: +_restriction.ElementRestriction_swigregister(ElementRestriction) + +class L2ElementRestriction(mfem._par.operators.Operator): + r"""Proxy of C++ mfem::L2ElementRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, arg2): + r"""__init__(L2ElementRestriction self, FiniteElementSpace arg2) -> L2ElementRestriction""" + _restriction.L2ElementRestriction_swiginit(self, _restriction.new_L2ElementRestriction(arg2)) + + def Mult(self, x, y): + r"""Mult(L2ElementRestriction self, Vector x, Vector y)""" + return _restriction.L2ElementRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.L2ElementRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(L2ElementRestriction self, Vector x, Vector y)""" + return _restriction.L2ElementRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.L2ElementRestriction_MultTranspose) + __swig_destroy__ = _restriction.delete_L2ElementRestriction + +# Register L2ElementRestriction in _restriction: +_restriction.L2ElementRestriction_swigregister(L2ElementRestriction) + +class H1FaceRestriction(mfem._par.operators.Operator): + r"""Proxy of C++ mfem::H1FaceRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, arg2, arg3, arg4): + r"""__init__(H1FaceRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering const arg3, mfem::FaceType const arg4) -> H1FaceRestriction""" + _restriction.H1FaceRestriction_swiginit(self, _restriction.new_H1FaceRestriction(arg2, arg3, arg4)) + + def Mult(self, x, y): + r"""Mult(H1FaceRestriction self, Vector x, Vector y)""" + return _restriction.H1FaceRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.H1FaceRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(H1FaceRestriction self, Vector x, Vector y)""" + return _restriction.H1FaceRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.H1FaceRestriction_MultTranspose) + __swig_destroy__ = _restriction.delete_H1FaceRestriction + +# Register H1FaceRestriction in _restriction: +_restriction.H1FaceRestriction_swigregister(H1FaceRestriction) + +class L2FaceRestriction(mfem._par.operators.Operator): + r"""Proxy of C++ mfem::L2FaceRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r"""__init__(L2FaceRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering const arg3, mfem::FaceType const arg4, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction""" + _restriction.L2FaceRestriction_swiginit(self, _restriction.new_L2FaceRestriction(*args)) + + def Mult(self, x, y): + r"""Mult(L2FaceRestriction self, Vector x, Vector y)""" + return _restriction.L2FaceRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.L2FaceRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(L2FaceRestriction self, Vector x, Vector y)""" + return _restriction.L2FaceRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.L2FaceRestriction_MultTranspose) + __swig_destroy__ = _restriction.delete_L2FaceRestriction + +# Register L2FaceRestriction in _restriction: +_restriction.L2FaceRestriction_swigregister(L2FaceRestriction) + + +def GetFaceDofs(dim, face_id, dof1d, faceMap): + r"""GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)""" + return _restriction.GetFaceDofs(dim, face_id, dof1d, faceMap) +GetFaceDofs = _restriction.GetFaceDofs + +def ToLexOrdering(dim, face_id, size1d, index): + r"""ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int""" + return _restriction.ToLexOrdering(dim, face_id, size1d, index) +ToLexOrdering = _restriction.ToLexOrdering + +def PermuteFaceL2(dim, face_id1, face_id2, orientation, size1d, index): + r"""PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int""" + return _restriction.PermuteFaceL2(dim, face_id1, face_id2, orientation, size1d, index) +PermuteFaceL2 = _restriction.PermuteFaceL2 + + diff --git a/mfem/_par/restriction_wrap.cxx b/mfem/_par/restriction_wrap.cxx new file mode 100644 index 00000000..b3ce894b --- /dev/null +++ b/mfem/_par/restriction_wrap.cxx @@ -0,0 +1,5627 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGPYTHON +#define SWIGPYTHON +#endif + +#define SWIG_DIRECTORS +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + + +#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) +/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ +# include +#endif + +#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) +/* Use debug wrappers with the Python release dll */ +# undef _DEBUG +# include +# define _DEBUG 1 +#else +# include +#endif + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = (unsigned char)((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = (unsigned char)((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (unsigned char)(d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (unsigned char)(d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Warning: This function will allocate a new string in Python 3, + * so please call SWIG_Python_str_DelForPy3(x) to free the space. + */ +SWIGINTERN char* +SWIG_Python_str_AsChar(PyObject *str) +{ +#if PY_VERSION_HEX >= 0x03000000 + char *newstr = 0; + str = PyUnicode_AsUTF8String(str); + if (str) { + char *cstr; + Py_ssize_t len; + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char *) malloc(len+1); + memcpy(newstr, cstr, len+1); + Py_XDECREF(str); + } + return newstr; +#else + return PyString_AsString(str); +#endif +} + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#else +# define SWIG_Python_str_DelForPy3(x) +#endif + + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user +// interface files check for it. +# define SWIGPY_USE_CAPSULE +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define Py_hash_t long +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + PyErr_Clear(); + Py_XINCREF(type); + if (tmp) + PyErr_Format(type, "%s %s", tmp, mesg); + else + PyErr_Format(type, "%s", mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +SWIGRUNTIME int +SWIG_Python_TypeErrorOccurred(PyObject *obj) +{ + PyObject *error; + if (obj) + return 0; + error = PyErr_Occurred(); + return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError); +} + +SWIGRUNTIME void +SWIG_Python_RaiseOrModifyTypeError(const char *message) +{ + if (SWIG_Python_TypeErrorOccurred(NULL)) { + /* Use existing TypeError to preserve stacktrace and enhance with given message */ + PyObject *newvalue; + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); +#if PY_VERSION_HEX >= 0x03000000 + newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message); +#else + newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); +#endif + Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + /* Raise TypeError using given message */ + PyErr_SetString(PyExc_TypeError, message); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# define SWIG_PYTHON_USE_GIL +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + const char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */ +# error "This version of SWIG only supports Python >= 2.7" +#endif + +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000 +# error "This version of SWIG only supports Python 3 >= 3.2" +#endif + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +} + +/* Unpack the argument tuple */ + +SWIGINTERN Py_ssize_t +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + Py_ssize_t i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + Py_ssize_t i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + int fail = data ? data->implicitconv : 0; + if (fail) + PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors."); + return fail; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { + data->newraw = PyObject_GetAttrString(data->klass, "__new__"); + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); + data->delargs = !(flags & (METH_O)); + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + + +#ifdef SWIGPYTHON_BUILTIN + +SWIGRUNTIME PyObject * +SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + + if (!sobj->dict) + sobj->dict = PyDict_New(); + + Py_INCREF(sobj->dict); + return sobj->dict; +} + +#endif + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { + PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_repr(SwigPyObject *v) +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (v->next) { + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } + return repr; +} + +/* We need a version taking two PyObject* parameters so it's a valid + * PyCFunction to use in swigobject_methods[]. */ +SWIGRUNTIME PyObject * +SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + return SwigPyObject_repr((SwigPyObject*)v); +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res; + if( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { +#ifdef SWIGPYTHON_BUILTIN + PyTypeObject *target_tp = SwigPyObject_type(); + if (PyType_IsSubtype(op->ob_type, target_tp)) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); +#else + return (Py_TYPE(op) == SwigPyObject_type()) + || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + + /* PyObject_CallFunction() has the potential to silently drop + the active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); + + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if (!res) + PyErr_WriteUnraisable(destroy); + + PyErr_Restore(type, value, traceback); + + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (!SwigPyObject_Check(next)) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) { + return NULL; + } else { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v,args); + } else { + SwigPyObject_disown(v,args); + } + } + return obj; + } +} + +static PyMethodDef +swigobject_methods[] = { + {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"}, + {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"}, + {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"}, + {"append", SwigPyObject_append, METH_O, "appends another 'this' object"}, + {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"}, + {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"}, + {0, 0, 0, 0} +}; + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ +#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#else + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpyobject_type) < 0) + return NULL; + } + return &swigpyobject_type; +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) + || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpypacked_type) < 0) + return NULL; + } + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +static PyObject *Swig_This_global = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (Swig_This_global == NULL) + Swig_This_global = SWIG_Python_str_FromChar("this"); + return Swig_This_global; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None && !implicit_conv) { + if (ptr) + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + res = SWIG_OK; + } else { + if (implicit_conv) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + swig_cast_info *tc; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) + return SWIG_ERROR; + tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + return SWIG_OK; + } +} + +/* Convert a packed pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *empty_args = PyTuple_New(0); + if (empty_args) { + PyObject *empty_kwargs = PyDict_New(); + if (empty_kwargs) { + inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + Py_DECREF(empty_kwargs); + if (inst) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } + } + Py_DECREF(empty_args); + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, "__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { + PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +SWIGRUNTIME void +SWIG_Python_DestroyModule(PyObject *obj) +{ + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + Swig_This_global = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { + obj = PyCapsule_New((void*) descriptor, NULL, NULL); + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + const char *errmesg = tmp ? tmp : "Invalid error message"; + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, errmesg); + } else { + PyErr_Format(type, "%s %s", errmesg, mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +#if SWIG_POINTER_EXCEPTION + if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } +#endif + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res = -1; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) < 0) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + if (!encoded_name) + return -1; + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Method creation and docstring support functions */ + +SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name); +SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); +SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); + +#ifdef __cplusplus +} +#endif + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Python proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ +#define SWIG_DIRECTOR_PYTHON_HEADER_ + +#include +#include +#include +#include +#include + + +/* + Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual + table', and avoid multiple GetAttr calls to retrieve the python + methods. +*/ + +#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE +#ifndef SWIG_PYTHON_DIRECTOR_VTABLE +#define SWIG_PYTHON_DIRECTOR_VTABLE +#endif +#endif + + + +/* + Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the + Undefined Exception Handler provided by swig. +*/ +#ifndef SWIG_DIRECTOR_NO_UEH +#ifndef SWIG_DIRECTOR_UEH +#define SWIG_DIRECTOR_UEH +#endif +#endif + + +/* + Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the + native C++ RTTI and dynamic_cast<>. But be aware that directors + could stop working when using this option. +*/ +#ifdef SWIG_DIRECTOR_NORTTI +/* + When we don't use the native C++ RTTI, we implement a minimal one + only for Directors. +*/ +# ifndef SWIG_DIRECTOR_RTDIR +# define SWIG_DIRECTOR_RTDIR + +namespace Swig { + class Director; + SWIGINTERN std::map& get_rtdir_map() { + static std::map rtdir_map; + return rtdir_map; + } + + SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { + get_rtdir_map()[vptr] = rtdir; + } + + SWIGINTERNINLINE Director *get_rtdir(void *vptr) { + std::map::const_iterator pos = get_rtdir_map().find(vptr); + Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; + return rtdir; + } +} +# endif /* SWIG_DIRECTOR_RTDIR */ + +# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) + +#else + +# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) + +#endif /* SWIG_DIRECTOR_NORTTI */ + +extern "C" { + struct swig_type_info; +} + +namespace Swig { + + /* memory handler */ + struct GCItem { + virtual ~GCItem() {} + + virtual int get_own() const { + return 0; + } + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem * operator->() const { + return _item; + } + + private: + GCItem *_item; + }; + + struct GCItem_Object : GCItem { + GCItem_Object(int own) : _own(own) { + } + + virtual ~GCItem_Object() { + } + + int get_own() const { + return _own; + } + + private: + int _own; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; + + template + struct GCArray_T : GCItem { + GCArray_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCArray_T() { + delete[] _ptr; + } + + private: + Type *_ptr; + }; + + /* base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + public: + DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (msg[0]) { + swig_msg += " "; + swig_msg += msg; + } + if (!PyErr_Occurred()) { + PyErr_SetString(error, what()); + } + SWIG_PYTHON_THREAD_END_BLOCK; + } + + virtual ~DirectorException() throw() { + } + + /* Deprecated, use what() instead */ + const char *getMessage() const { + return what(); + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorException(error, msg); + } + + static void raise(const char *msg) { + raise(PyExc_RuntimeError, msg); + } + }; + + /* type mismatch in the return value from a python method call */ + class DirectorTypeMismatchException : public DirectorException { + public: + DirectorTypeMismatchException(PyObject *error, const char *msg="") + : DirectorException(error, "SWIG director type mismatch", msg) { + } + + DirectorTypeMismatchException(const char *msg="") + : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorTypeMismatchException(error, msg); + } + + static void raise(const char *msg) { + throw DirectorTypeMismatchException(msg); + } + }; + + /* any python exception that occurs during a director method call */ + class DirectorMethodException : public DirectorException { + public: + DirectorMethodException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { + } + + static void raise(const char *msg) { + throw DirectorMethodException(msg); + } + }; + + /* attempt to call a pure virtual method via a director method */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { + } + + static void raise(const char *msg) { + throw DirectorPureVirtualException(msg); + } + }; + + +#if defined(SWIG_PYTHON_THREADS) +/* __THREAD__ is the old macro to activate some thread support */ +# if !defined(__THREAD__) +# define __THREAD__ 1 +# endif +#endif + +#ifdef __THREAD__ +# include "pythread.h" + class Guard { + PyThread_type_lock &mutex_; + + public: + Guard(PyThread_type_lock & mutex) : mutex_(mutex) { + PyThread_acquire_lock(mutex_, WAIT_LOCK); + } + + ~Guard() { + PyThread_release_lock(mutex_); + } + }; +# define SWIG_GUARD(mutex) Guard _guard(mutex) +#else +# define SWIG_GUARD(mutex) +#endif + + /* director base class */ + class Director { + private: + /* pointer to the wrapped python object */ + PyObject *swig_self; + /* flag indicating whether the object is owned by python or c++ */ + mutable bool swig_disown_flag; + + /* decrement the reference count of the wrapped python object */ + void swig_decref() const { + if (swig_disown_flag) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_DECREF(swig_self); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + public: + /* wrap a python object. */ + Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { + } + + /* discard our reference at destruction */ + virtual ~Director() { + swig_decref(); + } + + /* return a pointer to the wrapped python object */ + PyObject *swig_get_self() const { + return swig_self; + } + + /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); + } + } + + /* increase the reference count of the wrapped python object */ + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); + } + } + + /* methods to implement pseudo protected director members */ + virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { + return true; + } + + virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { + } + + /* ownership management */ + private: + typedef std::map swig_ownership_map; + mutable swig_ownership_map swig_owner; +#ifdef __THREAD__ + static PyThread_type_lock swig_mutex_own; +#endif + + public: + template + void swig_acquire_ownership_array(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCArray_T(vptr); + } + } + + template + void swig_acquire_ownership(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_T(vptr); + } + } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_Object(own); + } + } + + int swig_release_ownership(void *vptr) const { + int own = 0; + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_ownership_map::iterator iter = swig_owner.find(vptr); + if (iter != swig_owner.end()) { + own = iter->second->get_own(); + swig_owner.erase(iter); + } + } + return own; + } + + template + static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { + SwigPyObject *sobj = (SwigPyObject *)pyobj; + sobj->own = 0; + Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); + if (d) + d->swig_disown(); + return PyWeakref_NewProxy(pyobj, NULL); + } + }; + +#ifdef __THREAD__ + PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock(); +#endif +} + +#endif + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_MPI_Comm swig_types[0] +#define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[8] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[9] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[10] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[11] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[12] +#define SWIGTYPE_p_mfem__GridFunction swig_types[13] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[14] +#define SWIGTYPE_p_mfem__HypreADS swig_types[15] +#define SWIGTYPE_p_mfem__HypreAMS swig_types[16] +#define SWIGTYPE_p_mfem__HypreBoomerAMG swig_types[17] +#define SWIGTYPE_p_mfem__HypreDiagScale swig_types[18] +#define SWIGTYPE_p_mfem__HypreEuclid swig_types[19] +#define SWIGTYPE_p_mfem__HypreGMRES swig_types[20] +#define SWIGTYPE_p_mfem__HypreIdentity swig_types[21] +#define SWIGTYPE_p_mfem__HyprePCG swig_types[22] +#define SWIGTYPE_p_mfem__HypreParMatrix swig_types[23] +#define SWIGTYPE_p_mfem__HypreParVector swig_types[24] +#define SWIGTYPE_p_mfem__HypreParaSails swig_types[25] +#define SWIGTYPE_p_mfem__HypreSmoother swig_types[26] +#define SWIGTYPE_p_mfem__HypreSolver swig_types[27] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[28] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[29] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[30] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[31] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[32] +#define SWIGTYPE_p_mfem__LinearForm swig_types[33] +#define SWIGTYPE_p_mfem__Matrix swig_types[34] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[35] +#define SWIGTYPE_p_mfem__Operator swig_types[36] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[37] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[38] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[39] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[40] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[41] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[42] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[43] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[44] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[45] +#define SWIGTYPE_p_mfem__Solver swig_types[46] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[47] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[48] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[49] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[50] +#define SWIGTYPE_p_mfem__Vector swig_types[51] +#define SWIGTYPE_p_pri_t swig_types[52] +#define SWIGTYPE_p_quad_t swig_types[53] +#define SWIGTYPE_p_seg_t swig_types[54] +#define SWIGTYPE_p_tet_t swig_types[55] +#define SWIGTYPE_p_tri_t swig_types[56] +static swig_type_info *swig_types[58]; +static swig_module_info swig_module = {swig_types, 57, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#ifdef SWIG_TypeQuery +# undef SWIG_TypeQuery +#endif +#define SWIG_TypeQuery SWIG_Python_TypeQuery + +/*----------------------------------------------- + @(target):= _restriction.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__restriction + +#else +# define SWIG_init init_restriction + +#endif +#define SWIG_name "_restriction" + +#define SWIGVERSION 0x040001 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include "mfem.hpp" +#include "fem/restriction.hpp" +#include "numpy/arrayobject.h" +#include "pyoperator.hpp" + + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "restriction_wrap.h" + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + mfem::ElementRestriction *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ElementRestriction", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + { + try { + result = (mfem::ElementRestriction *)new mfem::ElementRestriction((mfem::FiniteElementSpace const &)*arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ElementRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ElementRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTransposeUnsigned", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ElementRestriction const *)arg1)->MultTransposeUnsigned((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElementRestriction" "', argument " "1"" of type '" "mfem::ElementRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ElementRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElementRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::L2ElementRestriction *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + { + try { + result = (mfem::L2ElementRestriction *)new mfem::L2ElementRestriction((mfem::FiniteElementSpace const &)*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2ElementRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2ElementRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2ElementRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_L2ElementRestriction" "', argument " "1"" of type '" "mfem::L2ElementRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *L2ElementRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__L2ElementRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *L2ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::H1FaceRestriction *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_H1FaceRestriction", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_H1FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_H1FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::H1FaceRestriction *)new mfem::H1FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::H1FaceRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::H1FaceRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1FaceRestriction" "', argument " "1"" of type '" "mfem::H1FaceRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *H1FaceRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1FaceRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + mfem::L2FaceValues arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::L2FaceRestriction *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); + { + try { + result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::L2FaceRestriction *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2FaceRestriction", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_L2FaceRestriction__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_L2FaceRestriction__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2FaceRestriction'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const,mfem::L2FaceValues const)\n" + " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2FaceRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2FaceRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_L2FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_L2FaceRestriction" "', argument " "1"" of type '" "mfem::L2FaceRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *L2FaceRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *L2FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + mfem::Array< int > *arg4 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetFaceDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetFaceDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + try { + mfem::GetFaceDofs(arg1,arg2,arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + PyObject *swig_obj[4] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "ToLexOrdering", 4, 4, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + result = (int)mfem::ToLexOrdering(arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + PyObject *swig_obj[6] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "PermuteFaceL2", 6, 6, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + result = (int)mfem::PermuteFaceL2(arg1,arg2,arg3,arg4,arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "ElementRestriction_MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, + { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, + { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "L2ElementRestriction_Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "L2ElementRestriction_MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, + { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, + { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "H1FaceRestriction_Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "H1FaceRestriction_MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, + { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, + { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, + { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "L2FaceRestriction_Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "L2FaceRestriction_MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, + { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, + { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, + { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, + { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, + { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, + { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, + { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, + { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, + { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, + { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, + { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_mfem__HypreParVectorTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::HypreParVector *) x)); +} +static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); +} +static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); +} +static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); +} +static void *_p_mfem__HyprePCGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HyprePCG *) x)); +} +static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); +} +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +} +static void *_p_mfem__HypreDiagScaleTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreDiagScale *) x)); +} +static void *_p_mfem__HypreADSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreADS *) x)); +} +static void *_p_mfem__HypreEuclidTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreEuclid *) x)); +} +static void *_p_mfem__HypreBoomerAMGTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreBoomerAMG *) x)); +} +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +} +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +} +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +} +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +} +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +} +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +} +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +} +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} +static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); +} +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} +static void *_p_mfem__HypreGMRESTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreGMRES *) x)); +} +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +} +static void *_p_mfem__HypreParaSailsTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreParaSails *) x)); +} +static void *_p_mfem__HypreParMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::HypreParMatrix *) x)); +} +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +} +static void *_p_mfem__HypreIdentityTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreIdentity *) x)); +} +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +} +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +} +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__HypreAMSTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::HypreSolver *) ((mfem::HypreAMS *) x)); +} +static void *_p_mfem__HypreSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSolver *) x)); +} +static void *_p_mfem__HypreSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::HypreSmoother *) x)); +} +static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", "mfem::ElementRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", "mfem::H1FaceRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__IntegrationRule = {"_p_mfem__IntegrationRule", "mfem::IntegrationRule *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", "mfem::L2ElementRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", "mfem::L2FaceRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollection", "mfem::L2_FECollection *|mfem::DG_FECollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__HyprePCG = {"_p_mfem__HyprePCG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreDiagScale = {"_p_mfem__HypreDiagScale", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreADS = {"_p_mfem__HypreADS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreEuclid = {"_p_mfem__HypreEuclid", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreBoomerAMG = {"_p_mfem__HypreBoomerAMG", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreGMRES = {"_p_mfem__HypreGMRES", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParaSails = {"_p_mfem__HypreParaSails", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreParMatrix = {"_p_mfem__HypreParMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreIdentity = {"_p_mfem__HypreIdentity", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreAMS = {"_p_mfem__HypreAMS", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSolver = {"_p_mfem__HypreSolver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__HypreSmoother = {"_p_mfem__HypreSmoother", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__HypreParVector = {"_p_mfem__HypreParVector", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_MPI_Comm, + &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, + &_swigt__p_char, + &_swigt__p_hex_t, + &_swigt__p_int, + &_swigt__p_mfem__AbstractSparseMatrix, + &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_mfem__ConstrainedOperator, + &_swigt__p_mfem__DenseMatrix, + &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__ElementRestriction, + &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__H1FaceRestriction, + &_swigt__p_mfem__HypreADS, + &_swigt__p_mfem__HypreAMS, + &_swigt__p_mfem__HypreBoomerAMG, + &_swigt__p_mfem__HypreDiagScale, + &_swigt__p_mfem__HypreEuclid, + &_swigt__p_mfem__HypreGMRES, + &_swigt__p_mfem__HypreIdentity, + &_swigt__p_mfem__HyprePCG, + &_swigt__p_mfem__HypreParMatrix, + &_swigt__p_mfem__HypreParVector, + &_swigt__p_mfem__HypreParaSails, + &_swigt__p_mfem__HypreSmoother, + &_swigt__p_mfem__HypreSolver, + &_swigt__p_mfem__IdentityOperator, + &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, + &_swigt__p_mfem__L2_FECollection, + &_swigt__p_mfem__LinearForm, + &_swigt__p_mfem__Matrix, + &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__Operator, + &_swigt__p_mfem__OperatorHandle, + &_swigt__p_mfem__ProductOperator, + &_swigt__p_mfem__PyOperatorBase, + &_swigt__p_mfem__PyTimeDependentOperatorBase, + &_swigt__p_mfem__QuadratureFunction, + &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, + &_swigt__p_mfem__Solver, + &_swigt__p_mfem__SparseMatrix, + &_swigt__p_mfem__TimeDependentOperator, + &_swigt__p_mfem__TransposeOperator, + &_swigt__p_mfem__TripleProductOperator, + &_swigt__p_mfem__Vector, + &_swigt__p_pri_t, + &_swigt__p_quad_t, + &_swigt__p_seg_t, + &_swigt__p_tet_t, + &_swigt__p_tri_t, +}; + +static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ElementRestriction[] = { {&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = { {&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = { {&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = { {&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HyprePCG[] = {{&_swigt__p_mfem__HyprePCG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SparseMatrix[] = {{&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreDiagScale[] = {{&_swigt__p_mfem__HypreDiagScale, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreADS[] = {{&_swigt__p_mfem__HypreADS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreEuclid[] = {{&_swigt__p_mfem__HypreEuclid, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreBoomerAMG[] = {{&_swigt__p_mfem__HypreBoomerAMG, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreGMRES[] = {{&_swigt__p_mfem__HypreGMRES, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParaSails[] = {{&_swigt__p_mfem__HypreParaSails, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParMatrix[] = {{&_swigt__p_mfem__HypreParMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreIdentity[] = {{&_swigt__p_mfem__HypreIdentity, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreAMS[] = {{&_swigt__p_mfem__HypreAMS, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSolver[] = {{&_swigt__p_mfem__HypreSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreSmoother[] = {{&_swigt__p_mfem__HypreSmoother, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__HyprePCG, _p_mfem__HyprePCGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreDiagScale, _p_mfem__HypreDiagScaleTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreADS, _p_mfem__HypreADSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreEuclid, _p_mfem__HypreEuclidTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreBoomerAMG, _p_mfem__HypreBoomerAMGTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreGMRES, _p_mfem__HypreGMRESTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParaSails, _p_mfem__HypreParaSailsTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreParMatrix, _p_mfem__HypreParMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreIdentity, _p_mfem__HypreIdentityTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreAMS, _p_mfem__HypreAMSTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSolver, _p_mfem__HypreSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__HypreSmoother, _p_mfem__HypreSmootherTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HypreParVector[] = {{&_swigt__p_mfem__HypreParVector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__HypreParVector, _p_mfem__HypreParVectorTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_MPI_Comm, + _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, + _swigc__p_char, + _swigc__p_hex_t, + _swigc__p_int, + _swigc__p_mfem__AbstractSparseMatrix, + _swigc__p_mfem__ArrayT_int_t, + _swigc__p_mfem__ConstrainedOperator, + _swigc__p_mfem__DenseMatrix, + _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__ElementRestriction, + _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GridFunction, + _swigc__p_mfem__H1FaceRestriction, + _swigc__p_mfem__HypreADS, + _swigc__p_mfem__HypreAMS, + _swigc__p_mfem__HypreBoomerAMG, + _swigc__p_mfem__HypreDiagScale, + _swigc__p_mfem__HypreEuclid, + _swigc__p_mfem__HypreGMRES, + _swigc__p_mfem__HypreIdentity, + _swigc__p_mfem__HyprePCG, + _swigc__p_mfem__HypreParMatrix, + _swigc__p_mfem__HypreParVector, + _swigc__p_mfem__HypreParaSails, + _swigc__p_mfem__HypreSmoother, + _swigc__p_mfem__HypreSolver, + _swigc__p_mfem__IdentityOperator, + _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, + _swigc__p_mfem__L2_FECollection, + _swigc__p_mfem__LinearForm, + _swigc__p_mfem__Matrix, + _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__Operator, + _swigc__p_mfem__OperatorHandle, + _swigc__p_mfem__ProductOperator, + _swigc__p_mfem__PyOperatorBase, + _swigc__p_mfem__PyTimeDependentOperatorBase, + _swigc__p_mfem__QuadratureFunction, + _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, + _swigc__p_mfem__Solver, + _swigc__p_mfem__SparseMatrix, + _swigc__p_mfem__TimeDependentOperator, + _swigc__p_mfem__TransposeOperator, + _swigc__p_mfem__TripleProductOperator, + _swigc__p_mfem__Vector, + _swigc__p_pri_t, + _swigc__p_quad_t, + _swigc__p_seg_t, + _swigc__p_tet_t, + _swigc__p_tri_t, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *globals = 0; + if (!globals) { + globals = SWIG_newvarlink(); + } + return globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (!c) continue; + c = strstr(c, "swig_ptr: "); + if (c) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + memcpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + memcpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + + /* ----------------------------------------------------------------------------- + * Method creation and docstring support functions + * ----------------------------------------------------------------------------- */ + + /* ----------------------------------------------------------------------------- + * Function to find the method definition with the correct docstring for the + * proxy module as opposed to the low-level API + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) { + /* Find the function in the modified method table */ + size_t offset = 0; + int found = 0; + while (SwigMethods_proxydocs[offset].ml_meth != NULL) { + if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) { + found = 1; + break; + } + offset++; + } + /* Use the copy with the modified docstring if available */ + return found ? &SwigMethods_proxydocs[offset] : NULL; + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyInstanceMethod_New() used in Python 3 + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } +#if PY_VERSION_HEX >= 0x03000000 + return PyInstanceMethod_New(func); +#else + return PyMethod_New(func, NULL, NULL); +#endif + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyStaticMethod_New() + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } + return PyStaticMethod_New(func); + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md, *globals; + +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { + PyModuleDef_HEAD_INIT, + SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + SwigPyObject_own, + SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + PyTypeObject *swigpyobject; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + PyObject *self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); + assert(metatype); +#endif + + (void)globals; + + /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */ + SWIG_This(); + SWIG_Python_TypeCache(); + SwigPyPacked_type(); +#ifndef SWIGPYTHON_BUILTIN + SwigPyObject_type(); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule(SWIG_name, SwigMethods); +#endif + + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + swigpyobject = SwigPyObject_TypeOnce(); + + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = swigpyobject; + } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + + import_array(); + + SWIG_Python_SetConstant(d, "L2FaceValues_SingleValued",SWIG_From_int(static_cast< int >(mfem::L2FaceValues::SingleValued))); + SWIG_Python_SetConstant(d, "L2FaceValues_DoubleValued",SWIG_From_int(static_cast< int >(mfem::L2FaceValues::DoubleValued))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/mfem/_par/restriction_wrap.h b/mfem/_par/restriction_wrap.h new file mode 100644 index 00000000..9b86ae20 --- /dev/null +++ b/mfem/_par/restriction_wrap.h @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_restriction_WRAP_H_ +#define SWIG_restriction_WRAP_H_ + +#include +#include + + +#endif diff --git a/mfem/_par/segment.py b/mfem/_par/segment.py index 701928a6..c7b8b1ee 100644 --- a/mfem/_par/segment.py +++ b/mfem/_par/segment.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _segment.SWIG_PyInstanceMethod_New +_swig_new_static_method = _segment.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -91,10 +94,12 @@ def __init__(self, *args): def SetVertices(self, ind): r"""SetVertices(Segment self, int const * ind)""" return _segment.Segment_SetVertices(self, ind) + SetVertices = _swig_new_instance_method(_segment.Segment_SetVertices) def GetType(self): r"""GetType(Segment self) -> mfem::Element::Type""" return _segment.Segment_GetType(self) + GetType = _swig_new_instance_method(_segment.Segment_GetType) def GetVertices(self, *args): r""" @@ -102,30 +107,45 @@ def GetVertices(self, *args): GetVertices(Segment self) -> int * """ return _segment.Segment_GetVertices(self, *args) + GetVertices = _swig_new_instance_method(_segment.Segment_GetVertices) def GetNVertices(self): r"""GetNVertices(Segment self) -> int""" return _segment.Segment_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_segment.Segment_GetNVertices) def GetNEdges(self): r"""GetNEdges(Segment self) -> int""" return _segment.Segment_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_segment.Segment_GetNEdges) def GetEdgeVertices(self, ei): r"""GetEdgeVertices(Segment self, int ei) -> int const *""" return _segment.Segment_GetEdgeVertices(self, ei) + GetEdgeVertices = _swig_new_instance_method(_segment.Segment_GetEdgeVertices) + + def GetNFaces(self, *args): + r""" + GetNFaces(Segment self, int & nFaceVertices) -> int + GetNFaces(Segment self) -> int + """ + return _segment.Segment_GetNFaces(self, *args) + GetNFaces = _swig_new_instance_method(_segment.Segment_GetNFaces) - def GetNFaces(self, nFaceVertices): - r"""GetNFaces(Segment self, int & nFaceVertices) -> int""" - return _segment.Segment_GetNFaces(self, nFaceVertices) + def GetNFaceVertices(self, arg2): + r"""GetNFaceVertices(Segment self, int arg2) -> int""" + return _segment.Segment_GetNFaceVertices(self, arg2) + GetNFaceVertices = _swig_new_instance_method(_segment.Segment_GetNFaceVertices) def GetFaceVertices(self, fi): r"""GetFaceVertices(Segment self, int fi) -> int const *""" return _segment.Segment_GetFaceVertices(self, fi) + GetFaceVertices = _swig_new_instance_method(_segment.Segment_GetFaceVertices) def Duplicate(self, m): r"""Duplicate(Segment self, mfem::Mesh * m) -> Element""" return _segment.Segment_Duplicate(self, m) + Duplicate = _swig_new_instance_method(_segment.Segment_Duplicate) __swig_destroy__ = _segment.delete_Segment # Register Segment in _segment: diff --git a/mfem/_par/segment_wrap.cxx b/mfem/_par/segment_wrap.cxx index 7b3e5c0c..b744082e 100644 --- a/mfem/_par/segment_wrap.cxx +++ b/mfem/_par/segment_wrap.cxx @@ -3867,7 +3867,7 @@ SWIGINTERN PyObject *_wrap_Segment_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetNFaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int *arg2 = 0 ; @@ -3875,10 +3875,9 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; int result; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetNFaces", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaces" "', argument " "1"" of type '" "mfem::Segment const *""'"); @@ -3912,6 +3911,121 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO } +SWIGINTERN PyObject *_wrap_Segment_GetNFaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Segment *arg1 = (mfem::Segment *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaces" "', argument " "1"" of type '" "mfem::Segment const *""'"); + } + arg1 = reinterpret_cast< mfem::Segment * >(argp1); + { + try { + result = (int)((mfem::Segment const *)arg1)->GetNFaces(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Segment_GetNFaces", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Segment, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Segment_GetNFaces__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Segment, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Segment_GetNFaces__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Segment_GetNFaces'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Segment::GetNFaces(int &) const\n" + " mfem::Segment::GetNFaces() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Segment *arg1 = (mfem::Segment *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Segment_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); + } + arg1 = reinterpret_cast< mfem::Segment * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::Segment const *)arg1)->GetNFaceVertices(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; @@ -4072,6 +4186,7 @@ SWIGINTERN PyObject *Swig_var_SegmentFE_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" "Segment()\n" "Segment(int const * ind, int attr=1)\n" @@ -4086,7 +4201,11 @@ static PyMethodDef SwigMethods[] = { { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "Segment_GetNVertices(Segment self) -> int"}, { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "Segment_GetNEdges(Segment self) -> int"}, { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "Segment_GetEdgeVertices(Segment self, int ei) -> int const *"}, - { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "Segment_GetNFaces(Segment self, int & nFaceVertices) -> int"}, + { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" + "Segment_GetNFaces(Segment self, int & nFaceVertices) -> int\n" + "Segment_GetNFaces(Segment self) -> int\n" + ""}, + { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "Segment_GetNFaceVertices(Segment self, int arg2) -> int"}, { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "Segment_GetFaceVertices(Segment self, int fi) -> int const *"}, { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Segment_Duplicate(Segment self, mfem::Mesh * m) -> Element"}, { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, @@ -4096,6 +4215,32 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" + "Segment()\n" + "Segment(int const * ind, int attr=1)\n" + "Segment(int ind1, int ind2, int attr=1)\n" + ""}, + { "Segment_SetVertices", _wrap_Segment_SetVertices, METH_VARARGS, "SetVertices(Segment self, int const * ind)"}, + { "Segment_GetType", _wrap_Segment_GetType, METH_O, "GetType(Segment self) -> mfem::Element::Type"}, + { "Segment_GetVertices", _wrap_Segment_GetVertices, METH_VARARGS, "\n" + "GetVertices(Segment self, intArray v)\n" + "GetVertices(Segment self) -> int *\n" + ""}, + { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "GetNVertices(Segment self) -> int"}, + { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "GetNEdges(Segment self) -> int"}, + { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Segment self, int ei) -> int const *"}, + { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" + "GetNFaces(Segment self, int & nFaceVertices) -> int\n" + "GetNFaces(Segment self) -> int\n" + ""}, + { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Segment self, int arg2) -> int"}, + { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Segment self, int fi) -> int const *"}, + { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Duplicate(Segment self, mfem::Mesh * m) -> Element"}, + { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, + { "Segment_swigregister", Segment_swigregister, METH_O, NULL}, + { "Segment_swiginit", Segment_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/sets.py b/mfem/_par/sets.py index 9ef5ec6f..138ad83b 100644 --- a/mfem/_par/sets.py +++ b/mfem/_par/sets.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _sets.SWIG_PyInstanceMethod_New +_swig_new_static_method = _sets.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -81,22 +84,27 @@ def __init__(self, *args): def Size(self): r"""Size(IntegerSet self) -> int""" return _sets.IntegerSet_Size(self) + Size = _swig_new_instance_method(_sets.IntegerSet_Size) def PickElement(self): r"""PickElement(IntegerSet self) -> int""" return _sets.IntegerSet_PickElement(self) + PickElement = _swig_new_instance_method(_sets.IntegerSet_PickElement) def PickRandomElement(self): r"""PickRandomElement(IntegerSet self) -> int""" return _sets.IntegerSet_PickRandomElement(self) + PickRandomElement = _swig_new_instance_method(_sets.IntegerSet_PickRandomElement) def __eq__(self, s): r"""__eq__(IntegerSet self, IntegerSet s) -> int""" return _sets.IntegerSet___eq__(self, s) + __eq__ = _swig_new_instance_method(_sets.IntegerSet___eq__) def Recreate(self, n, p): r"""Recreate(IntegerSet self, int const n, int const * p)""" return _sets.IntegerSet_Recreate(self, n, p) + Recreate = _swig_new_instance_method(_sets.IntegerSet_Recreate) __swig_destroy__ = _sets.delete_IntegerSet # Register IntegerSet in _sets: @@ -111,26 +119,32 @@ class ListOfIntegerSets(object): def Size(self): r"""Size(ListOfIntegerSets self) -> int""" return _sets.ListOfIntegerSets_Size(self) + Size = _swig_new_instance_method(_sets.ListOfIntegerSets_Size) def PickElementInSet(self, i): r"""PickElementInSet(ListOfIntegerSets self, int i) -> int""" return _sets.ListOfIntegerSets_PickElementInSet(self, i) + PickElementInSet = _swig_new_instance_method(_sets.ListOfIntegerSets_PickElementInSet) def PickRandomElementInSet(self, i): r"""PickRandomElementInSet(ListOfIntegerSets self, int i) -> int""" return _sets.ListOfIntegerSets_PickRandomElementInSet(self, i) + PickRandomElementInSet = _swig_new_instance_method(_sets.ListOfIntegerSets_PickRandomElementInSet) def Insert(self, s): r"""Insert(ListOfIntegerSets self, IntegerSet s) -> int""" return _sets.ListOfIntegerSets_Insert(self, s) + Insert = _swig_new_instance_method(_sets.ListOfIntegerSets_Insert) def Lookup(self, s): r"""Lookup(ListOfIntegerSets self, IntegerSet s) -> int""" return _sets.ListOfIntegerSets_Lookup(self, s) + Lookup = _swig_new_instance_method(_sets.ListOfIntegerSets_Lookup) def AsTable(self, t): r"""AsTable(ListOfIntegerSets self, Table t)""" return _sets.ListOfIntegerSets_AsTable(self, t) + AsTable = _swig_new_instance_method(_sets.ListOfIntegerSets_AsTable) __swig_destroy__ = _sets.delete_ListOfIntegerSets def __init__(self): diff --git a/mfem/_par/sets_wrap.cxx b/mfem/_par/sets_wrap.cxx index 858b3924..1bcdcb19 100644 --- a/mfem/_par/sets_wrap.cxx +++ b/mfem/_par/sets_wrap.cxx @@ -3556,6 +3556,7 @@ SWIGINTERN PyObject *ListOfIntegerSets_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_IntegerSet", _wrap_new_IntegerSet, METH_VARARGS, "\n" "IntegerSet()\n" "IntegerSet(IntegerSet s)\n" @@ -3583,6 +3584,31 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_IntegerSet", _wrap_new_IntegerSet, METH_VARARGS, "\n" + "IntegerSet()\n" + "IntegerSet(IntegerSet s)\n" + "new_IntegerSet(int const n, int const * p) -> IntegerSet\n" + ""}, + { "IntegerSet_Size", _wrap_IntegerSet_Size, METH_O, "Size(IntegerSet self) -> int"}, + { "IntegerSet_PickElement", _wrap_IntegerSet_PickElement, METH_O, "PickElement(IntegerSet self) -> int"}, + { "IntegerSet_PickRandomElement", _wrap_IntegerSet_PickRandomElement, METH_O, "PickRandomElement(IntegerSet self) -> int"}, + { "IntegerSet___eq__", _wrap_IntegerSet___eq__, METH_VARARGS, "__eq__(IntegerSet self, IntegerSet s) -> int"}, + { "IntegerSet_Recreate", _wrap_IntegerSet_Recreate, METH_VARARGS, "Recreate(IntegerSet self, int const n, int const * p)"}, + { "delete_IntegerSet", _wrap_delete_IntegerSet, METH_O, "delete_IntegerSet(IntegerSet self)"}, + { "IntegerSet_swigregister", IntegerSet_swigregister, METH_O, NULL}, + { "IntegerSet_swiginit", IntegerSet_swiginit, METH_VARARGS, NULL}, + { "ListOfIntegerSets_Size", _wrap_ListOfIntegerSets_Size, METH_O, "Size(ListOfIntegerSets self) -> int"}, + { "ListOfIntegerSets_PickElementInSet", _wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS, "PickElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_PickRandomElementInSet", _wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS, "PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_Insert", _wrap_ListOfIntegerSets_Insert, METH_VARARGS, "Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_Lookup", _wrap_ListOfIntegerSets_Lookup, METH_VARARGS, "Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_AsTable", _wrap_ListOfIntegerSets_AsTable, METH_VARARGS, "AsTable(ListOfIntegerSets self, Table t)"}, + { "delete_ListOfIntegerSets", _wrap_delete_ListOfIntegerSets, METH_O, "delete_ListOfIntegerSets(ListOfIntegerSets self)"}, + { "new_ListOfIntegerSets", _wrap_new_ListOfIntegerSets, METH_NOARGS, "new_ListOfIntegerSets() -> ListOfIntegerSets"}, + { "ListOfIntegerSets_swigregister", ListOfIntegerSets_swigregister, METH_O, NULL}, + { "ListOfIntegerSets_swiginit", ListOfIntegerSets_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/setup.py b/mfem/_par/setup.py index aff07472..8815eab5 100644 --- a/mfem/_par/setup.py +++ b/mfem/_par/setup.py @@ -26,7 +26,7 @@ from distutils.core import * from distutils import sysconfig -modules= ["io_stream", +modules= ["io_stream", "vtk", "globals", "mem_manager", "device", "hash", "stable3d", "cpointers", "error", "array", "common_functions", @@ -46,7 +46,7 @@ "pmesh", "pncmesh", "communication", "pfespace", "pgridfunc", "plinearform", "pbilinearform", "pnonlinearform", - "hypre", ] + "hypre", "restriction", "prestriction"] if add_pumi != '': modules.append("pumi") diff --git a/mfem/_par/socketstream.py b/mfem/_par/socketstream.py index 19e5e36e..2561940c 100644 --- a/mfem/_par/socketstream.py +++ b/mfem/_par/socketstream.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _socketstream.SWIG_PyInstanceMethod_New +_swig_new_static_method = _socketstream.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -70,6 +73,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.mem_manager import mfem._par.operators import mfem._par.ncmesh +import mfem._par.vtk import mfem._par.element import mfem._par.densemat import mfem._par.geom @@ -87,6 +91,7 @@ class _SwigNonDynamicMeta(type): import mfem._par.lininteg import mfem._par.handle import mfem._par.hypre +import mfem._par.restriction import mfem._par.bilininteg import mfem._par.linearform class socketbuf(object): @@ -106,26 +111,32 @@ def __init__(self, *args): def attach(self, sd): r"""attach(socketbuf self, int sd) -> int""" return _socketstream.socketbuf_attach(self, sd) + attach = _swig_new_instance_method(_socketstream.socketbuf_attach) def detach(self): r"""detach(socketbuf self) -> int""" return _socketstream.socketbuf_detach(self) + detach = _swig_new_instance_method(_socketstream.socketbuf_detach) def open(self, hostname, port): r"""open(socketbuf self, char const [] hostname, int port) -> int""" return _socketstream.socketbuf_open(self, hostname, port) + open = _swig_new_instance_method(_socketstream.socketbuf_open) def close(self): r"""close(socketbuf self) -> int""" return _socketstream.socketbuf_close(self) + close = _swig_new_instance_method(_socketstream.socketbuf_close) def getsocketdescriptor(self): r"""getsocketdescriptor(socketbuf self) -> int""" return _socketstream.socketbuf_getsocketdescriptor(self) + getsocketdescriptor = _swig_new_instance_method(_socketstream.socketbuf_getsocketdescriptor) def is_open(self): r"""is_open(socketbuf self) -> bool""" return _socketstream.socketbuf_is_open(self) + is_open = _swig_new_instance_method(_socketstream.socketbuf_is_open) __swig_destroy__ = _socketstream.delete_socketbuf # Register socketbuf in _socketstream: @@ -151,18 +162,22 @@ def __init__(self, *args): def rdbuf(self): r"""rdbuf(socketstream self) -> socketbuf""" return _socketstream.socketstream_rdbuf(self) + rdbuf = _swig_new_instance_method(_socketstream.socketstream_rdbuf) def open(self, hostname, port): r"""open(socketstream self, char const [] hostname, int port) -> int""" return _socketstream.socketstream_open(self, hostname, port) + open = _swig_new_instance_method(_socketstream.socketstream_open) def close(self): r"""close(socketstream self) -> int""" return _socketstream.socketstream_close(self) + close = _swig_new_instance_method(_socketstream.socketstream_close) def is_open(self): r"""is_open(socketstream self) -> bool""" return _socketstream.socketstream_is_open(self) + is_open = _swig_new_instance_method(_socketstream.socketstream_is_open) __swig_destroy__ = _socketstream.delete_socketstream def precision(self, *args): @@ -171,18 +186,22 @@ def precision(self, *args): precision(socketstream self) -> int """ return _socketstream.socketstream_precision(self, *args) + precision = _swig_new_instance_method(_socketstream.socketstream_precision) def send_solution(self, mesh, gf): r"""send_solution(socketstream self, Mesh mesh, GridFunction gf)""" return _socketstream.socketstream_send_solution(self, mesh, gf) + send_solution = _swig_new_instance_method(_socketstream.socketstream_send_solution) def send_text(self, ostr): r"""send_text(socketstream self, char const [] ostr)""" return _socketstream.socketstream_send_text(self, ostr) + send_text = _swig_new_instance_method(_socketstream.socketstream_send_text) def flush(self): r"""flush(socketstream self)""" return _socketstream.socketstream_flush(self) + flush = _swig_new_instance_method(_socketstream.socketstream_flush) def __lshift__(self, *args): r""" @@ -192,10 +211,12 @@ def __lshift__(self, *args): __lshift__(socketstream self, GridFunction gf) -> socketstream """ return _socketstream.socketstream___lshift__(self, *args) + __lshift__ = _swig_new_instance_method(_socketstream.socketstream___lshift__) def endline(self): r"""endline(socketstream self) -> socketstream""" return _socketstream.socketstream_endline(self) + endline = _swig_new_instance_method(_socketstream.socketstream_endline) # Register socketstream in _socketstream: _socketstream.socketstream_swigregister(socketstream) @@ -213,10 +234,12 @@ def __init__(self, port, backlog=4): def good(self): r"""good(socketserver self) -> bool""" return _socketstream.socketserver_good(self) + good = _swig_new_instance_method(_socketstream.socketserver_good) def close(self): r"""close(socketserver self) -> int""" return _socketstream.socketserver_close(self) + close = _swig_new_instance_method(_socketstream.socketserver_close) def accept(self, *args): r""" @@ -224,6 +247,7 @@ def accept(self, *args): accept(socketserver self, socketstream sockstr) -> int """ return _socketstream.socketserver_accept(self, *args) + accept = _swig_new_instance_method(_socketstream.socketserver_accept) __swig_destroy__ = _socketstream.delete_socketserver # Register socketserver in _socketstream: diff --git a/mfem/_par/socketstream_wrap.cxx b/mfem/_par/socketstream_wrap.cxx index 9ce706f8..f3407b3f 100644 --- a/mfem/_par/socketstream_wrap.cxx +++ b/mfem/_par/socketstream_wrap.cxx @@ -3067,24 +3067,25 @@ namespace Swig { #define SWIGTYPE_p_MPI_Comm swig_types[0] #define SWIGTYPE_p_PyMFEM__wFILE swig_types[1] -#define SWIGTYPE_p_char swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_int swig_types[4] -#define SWIGTYPE_p_mfem__GridFunction swig_types[5] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[6] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[7] -#define SWIGTYPE_p_mfem__Mesh swig_types[8] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[9] -#define SWIGTYPE_p_mfem__socketbuf swig_types[10] -#define SWIGTYPE_p_mfem__socketserver swig_types[11] -#define SWIGTYPE_p_mfem__socketstream swig_types[12] -#define SWIGTYPE_p_pri_t swig_types[13] -#define SWIGTYPE_p_quad_t swig_types[14] -#define SWIGTYPE_p_seg_t swig_types[15] -#define SWIGTYPE_p_tet_t swig_types[16] -#define SWIGTYPE_p_tri_t swig_types[17] -static swig_type_info *swig_types[19]; -static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[2] +#define SWIGTYPE_p_char swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_int swig_types[5] +#define SWIGTYPE_p_mfem__GridFunction swig_types[6] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[7] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[8] +#define SWIGTYPE_p_mfem__Mesh swig_types[9] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[10] +#define SWIGTYPE_p_mfem__socketbuf swig_types[11] +#define SWIGTYPE_p_mfem__socketserver swig_types[12] +#define SWIGTYPE_p_mfem__socketstream swig_types[13] +#define SWIGTYPE_p_pri_t swig_types[14] +#define SWIGTYPE_p_quad_t swig_types[15] +#define SWIGTYPE_p_seg_t swig_types[16] +#define SWIGTYPE_p_tet_t swig_types[17] +#define SWIGTYPE_p_tri_t swig_types[18] +static swig_type_info *swig_types[20]; +static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5236,6 +5237,7 @@ SWIGINTERN PyObject *socketserver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_socketbuf", _wrap_new_socketbuf, METH_VARARGS, "\n" "socketbuf()\n" "socketbuf(int sd)\n" @@ -5291,6 +5293,59 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_socketbuf", _wrap_new_socketbuf, METH_VARARGS, "\n" + "socketbuf()\n" + "socketbuf(int sd)\n" + "new_socketbuf(char const [] hostname, int port) -> socketbuf\n" + ""}, + { "socketbuf_attach", _wrap_socketbuf_attach, METH_VARARGS, "attach(socketbuf self, int sd) -> int"}, + { "socketbuf_detach", _wrap_socketbuf_detach, METH_O, "detach(socketbuf self) -> int"}, + { "socketbuf_open", _wrap_socketbuf_open, METH_VARARGS, "open(socketbuf self, char const [] hostname, int port) -> int"}, + { "socketbuf_close", _wrap_socketbuf_close, METH_O, "close(socketbuf self) -> int"}, + { "socketbuf_getsocketdescriptor", _wrap_socketbuf_getsocketdescriptor, METH_O, "getsocketdescriptor(socketbuf self) -> int"}, + { "socketbuf_is_open", _wrap_socketbuf_is_open, METH_O, "is_open(socketbuf self) -> bool"}, + { "delete_socketbuf", _wrap_delete_socketbuf, METH_O, "delete_socketbuf(socketbuf self)"}, + { "socketbuf_swigregister", socketbuf_swigregister, METH_O, NULL}, + { "socketbuf_swiginit", socketbuf_swiginit, METH_VARARGS, NULL}, + { "new_socketstream", _wrap_new_socketstream, METH_VARARGS, "\n" + "socketstream(bool secure=secure_default)\n" + "socketstream(socketbuf buf)\n" + "socketstream(int s, bool secure=secure_default)\n" + "socketstream(char const [] hostname, int port, bool secure=secure_default)\n" + ""}, + { "socketstream_rdbuf", _wrap_socketstream_rdbuf, METH_O, "rdbuf(socketstream self) -> socketbuf"}, + { "socketstream_open", _wrap_socketstream_open, METH_VARARGS, "open(socketstream self, char const [] hostname, int port) -> int"}, + { "socketstream_close", _wrap_socketstream_close, METH_O, "close(socketstream self) -> int"}, + { "socketstream_is_open", _wrap_socketstream_is_open, METH_O, "is_open(socketstream self) -> bool"}, + { "delete_socketstream", _wrap_delete_socketstream, METH_O, "delete_socketstream(socketstream self)"}, + { "socketstream_precision", _wrap_socketstream_precision, METH_VARARGS, "\n" + "precision(socketstream self, int const p) -> int\n" + "precision(socketstream self) -> int\n" + ""}, + { "socketstream_send_solution", _wrap_socketstream_send_solution, METH_VARARGS, "send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, + { "socketstream_send_text", _wrap_socketstream_send_text, METH_VARARGS, "send_text(socketstream self, char const [] ostr)"}, + { "socketstream_flush", _wrap_socketstream_flush, METH_O, "flush(socketstream self)"}, + { "socketstream___lshift__", _wrap_socketstream___lshift__, METH_VARARGS, "\n" + "__lshift__(socketstream self, char const [] ostr) -> socketstream\n" + "__lshift__(socketstream self, int const x) -> socketstream\n" + "__lshift__(socketstream self, Mesh mesh) -> socketstream\n" + "__lshift__(socketstream self, GridFunction gf) -> socketstream\n" + ""}, + { "socketstream_endline", _wrap_socketstream_endline, METH_O, "endline(socketstream self) -> socketstream"}, + { "socketstream_swigregister", socketstream_swigregister, METH_O, NULL}, + { "socketstream_swiginit", socketstream_swiginit, METH_VARARGS, NULL}, + { "new_socketserver", _wrap_new_socketserver, METH_VARARGS, "socketserver(int port, int backlog=4)"}, + { "socketserver_good", _wrap_socketserver_good, METH_O, "good(socketserver self) -> bool"}, + { "socketserver_close", _wrap_socketserver_close, METH_O, "close(socketserver self) -> int"}, + { "socketserver_accept", _wrap_socketserver_accept, METH_VARARGS, "\n" + "accept(socketserver self) -> int\n" + "accept(socketserver self, socketstream sockstr) -> int\n" + ""}, + { "delete_socketserver", _wrap_delete_socketserver, METH_O, "delete_socketserver(socketserver self)"}, + { "socketserver_swigregister", socketserver_swigregister, METH_O, NULL}, + { "socketserver_swiginit", socketserver_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5299,6 +5354,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *|HYPRE_Int *", 0, 0, (void*)0, 0}; @@ -5319,6 +5375,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_MPI_Comm, &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_hex_t, &_swigt__p_int, @@ -5339,6 +5396,7 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_MPI_Comm[] = { {&_swigt__p_MPI_Comm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; @@ -5359,6 +5417,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_MPI_Comm, _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_hex_t, _swigc__p_int, diff --git a/mfem/_par/solvers.py b/mfem/_par/solvers.py index a878c8f1..9ee60800 100644 --- a/mfem/_par/solvers.py +++ b/mfem/_par/solvers.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _solvers.SWIG_PyInstanceMethod_New +_swig_new_static_method = _solvers.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -94,43 +97,84 @@ def __init__(self, *args, **kwargs): def SetRelTol(self, rtol): r"""SetRelTol(IterativeSolver self, double rtol)""" return _solvers.IterativeSolver_SetRelTol(self, rtol) + SetRelTol = _swig_new_instance_method(_solvers.IterativeSolver_SetRelTol) def SetAbsTol(self, atol): r"""SetAbsTol(IterativeSolver self, double atol)""" return _solvers.IterativeSolver_SetAbsTol(self, atol) + SetAbsTol = _swig_new_instance_method(_solvers.IterativeSolver_SetAbsTol) def SetMaxIter(self, max_it): r"""SetMaxIter(IterativeSolver self, int max_it)""" return _solvers.IterativeSolver_SetMaxIter(self, max_it) + SetMaxIter = _swig_new_instance_method(_solvers.IterativeSolver_SetMaxIter) def SetPrintLevel(self, print_lvl): r"""SetPrintLevel(IterativeSolver self, int print_lvl)""" return _solvers.IterativeSolver_SetPrintLevel(self, print_lvl) + SetPrintLevel = _swig_new_instance_method(_solvers.IterativeSolver_SetPrintLevel) def GetNumIterations(self): r"""GetNumIterations(IterativeSolver self) -> int""" return _solvers.IterativeSolver_GetNumIterations(self) + GetNumIterations = _swig_new_instance_method(_solvers.IterativeSolver_GetNumIterations) def GetConverged(self): r"""GetConverged(IterativeSolver self) -> int""" return _solvers.IterativeSolver_GetConverged(self) + GetConverged = _swig_new_instance_method(_solvers.IterativeSolver_GetConverged) def GetFinalNorm(self): r"""GetFinalNorm(IterativeSolver self) -> double""" return _solvers.IterativeSolver_GetFinalNorm(self) + GetFinalNorm = _swig_new_instance_method(_solvers.IterativeSolver_GetFinalNorm) def SetPreconditioner(self, pr): r"""SetPreconditioner(IterativeSolver self, Solver pr)""" return _solvers.IterativeSolver_SetPreconditioner(self, pr) + SetPreconditioner = _swig_new_instance_method(_solvers.IterativeSolver_SetPreconditioner) def SetOperator(self, op): r"""SetOperator(IterativeSolver self, Operator op)""" return _solvers.IterativeSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.IterativeSolver_SetOperator) __swig_destroy__ = _solvers.delete_IterativeSolver # Register IterativeSolver in _solvers: _solvers.IterativeSolver_swigregister(IterativeSolver) +class OperatorJacobiSmoother(mfem._par.operators.Solver): + r"""Proxy of C++ mfem::OperatorJacobiSmoother class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(OperatorJacobiSmoother self, mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother + __init__(OperatorJacobiSmoother self, Vector d, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother + """ + _solvers.OperatorJacobiSmoother_swiginit(self, _solvers.new_OperatorJacobiSmoother(*args)) + __swig_destroy__ = _solvers.delete_OperatorJacobiSmoother + + def Mult(self, x, y): + r"""Mult(OperatorJacobiSmoother self, Vector x, Vector y)""" + return _solvers.OperatorJacobiSmoother_Mult(self, x, y) + Mult = _swig_new_instance_method(_solvers.OperatorJacobiSmoother_Mult) + + def SetOperator(self, op): + r"""SetOperator(OperatorJacobiSmoother self, Operator op)""" + return _solvers.OperatorJacobiSmoother_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.OperatorJacobiSmoother_SetOperator) + + def Setup(self, diag): + r"""Setup(OperatorJacobiSmoother self, Vector diag)""" + return _solvers.OperatorJacobiSmoother_Setup(self, diag) + Setup = _swig_new_instance_method(_solvers.OperatorJacobiSmoother_Setup) + +# Register OperatorJacobiSmoother in _solvers: +_solvers.OperatorJacobiSmoother_swigregister(OperatorJacobiSmoother) + class SLISolver(IterativeSolver): r"""Proxy of C++ mfem::SLISolver class.""" @@ -147,10 +191,12 @@ def __init__(self, *args): def SetOperator(self, op): r"""SetOperator(SLISolver self, Operator op)""" return _solvers.SLISolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.SLISolver_SetOperator) def Mult(self, b, x): r"""Mult(SLISolver self, Vector b, Vector x)""" return _solvers.SLISolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.SLISolver_Mult) __swig_destroy__ = _solvers.delete_SLISolver # Register SLISolver in _solvers: @@ -163,6 +209,7 @@ def SLI(*args): SLI(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24) """ return _solvers.SLI(*args) +SLI = _solvers.SLI class CGSolver(IterativeSolver): r"""Proxy of C++ mfem::CGSolver class.""" @@ -179,10 +226,12 @@ def __init__(self, *args): def SetOperator(self, op): r"""SetOperator(CGSolver self, Operator op)""" return _solvers.CGSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.CGSolver_SetOperator) def Mult(self, b, x): r"""Mult(CGSolver self, Vector b, Vector x)""" return _solvers.CGSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.CGSolver_Mult) __swig_destroy__ = _solvers.delete_CGSolver # Register CGSolver in _solvers: @@ -192,10 +241,12 @@ def Mult(self, b, x): def CG(A, b, x, print_iter=0, max_num_iter=1000, RTOLERANCE=1e-12, ATOLERANCE=1e-24): r"""CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)""" return _solvers.CG(A, b, x, print_iter, max_num_iter, RTOLERANCE, ATOLERANCE) +CG = _solvers.CG def PCG(A, B, b, x, print_iter=0, max_num_iter=1000, RTOLERANCE=1e-12, ATOLERANCE=1e-24): r"""PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)""" return _solvers.PCG(A, B, b, x, print_iter, max_num_iter, RTOLERANCE, ATOLERANCE) +PCG = _solvers.PCG class GMRESSolver(IterativeSolver): r"""Proxy of C++ mfem::GMRESSolver class.""" @@ -212,10 +263,12 @@ def __init__(self, *args): def SetKDim(self, dim): r"""SetKDim(GMRESSolver self, int dim)""" return _solvers.GMRESSolver_SetKDim(self, dim) + SetKDim = _swig_new_instance_method(_solvers.GMRESSolver_SetKDim) def Mult(self, b, x): r"""Mult(GMRESSolver self, Vector b, Vector x)""" return _solvers.GMRESSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.GMRESSolver_Mult) __swig_destroy__ = _solvers.delete_GMRESSolver # Register GMRESSolver in _solvers: @@ -237,10 +290,12 @@ def __init__(self, *args): def SetKDim(self, dim): r"""SetKDim(FGMRESSolver self, int dim)""" return _solvers.FGMRESSolver_SetKDim(self, dim) + SetKDim = _swig_new_instance_method(_solvers.FGMRESSolver_SetKDim) def Mult(self, b, x): r"""Mult(FGMRESSolver self, Vector b, Vector x)""" return _solvers.FGMRESSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.FGMRESSolver_Mult) __swig_destroy__ = _solvers.delete_FGMRESSolver # Register FGMRESSolver in _solvers: @@ -253,6 +308,7 @@ def GMRES(*args): GMRES(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, int m=50, double rtol=1e-12, double atol=1e-24) """ return _solvers.GMRES(*args) +GMRES = _solvers.GMRES class BiCGSTABSolver(IterativeSolver): r"""Proxy of C++ mfem::BiCGSTABSolver class.""" @@ -269,10 +325,12 @@ def __init__(self, *args): def SetOperator(self, op): r"""SetOperator(BiCGSTABSolver self, Operator op)""" return _solvers.BiCGSTABSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.BiCGSTABSolver_SetOperator) def Mult(self, b, x): r"""Mult(BiCGSTABSolver self, Vector b, Vector x)""" return _solvers.BiCGSTABSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.BiCGSTABSolver_Mult) __swig_destroy__ = _solvers.delete_BiCGSTABSolver # Register BiCGSTABSolver in _solvers: @@ -285,6 +343,7 @@ def BiCGSTAB(*args): BiCGSTAB(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double rtol=1e-12, double atol=1e-24) """ return _solvers.BiCGSTAB(*args) +BiCGSTAB = _solvers.BiCGSTAB class MINRESSolver(IterativeSolver): r"""Proxy of C++ mfem::MINRESSolver class.""" @@ -301,14 +360,17 @@ def __init__(self, *args): def SetPreconditioner(self, pr): r"""SetPreconditioner(MINRESSolver self, Solver pr)""" return _solvers.MINRESSolver_SetPreconditioner(self, pr) + SetPreconditioner = _swig_new_instance_method(_solvers.MINRESSolver_SetPreconditioner) def SetOperator(self, op): r"""SetOperator(MINRESSolver self, Operator op)""" return _solvers.MINRESSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.MINRESSolver_SetOperator) def Mult(self, b, x): r"""Mult(MINRESSolver self, Vector b, Vector x)""" return _solvers.MINRESSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.MINRESSolver_Mult) __swig_destroy__ = _solvers.delete_MINRESSolver # Register MINRESSolver in _solvers: @@ -321,6 +383,7 @@ def MINRES(*args): MINRES(Operator A, Solver B, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24) """ return _solvers.MINRES(*args) +MINRES = _solvers.MINRES class NewtonSolver(IterativeSolver): r"""Proxy of C++ mfem::NewtonSolver class.""" @@ -337,18 +400,27 @@ def __init__(self, *args): def SetOperator(self, op): r"""SetOperator(NewtonSolver self, Operator op)""" return _solvers.NewtonSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.NewtonSolver_SetOperator) def SetSolver(self, solver): r"""SetSolver(NewtonSolver self, Solver solver)""" return _solvers.NewtonSolver_SetSolver(self, solver) + SetSolver = _swig_new_instance_method(_solvers.NewtonSolver_SetSolver) def Mult(self, b, x): r"""Mult(NewtonSolver self, Vector b, Vector x)""" return _solvers.NewtonSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.NewtonSolver_Mult) def ComputeScalingFactor(self, x, b): r"""ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double""" return _solvers.NewtonSolver_ComputeScalingFactor(self, x, b) + ComputeScalingFactor = _swig_new_instance_method(_solvers.NewtonSolver_ComputeScalingFactor) + + def ProcessNewState(self, x): + r"""ProcessNewState(NewtonSolver self, Vector x)""" + return _solvers.NewtonSolver_ProcessNewState(self, x) + ProcessNewState = _swig_new_instance_method(_solvers.NewtonSolver_ProcessNewState) __swig_destroy__ = _solvers.delete_NewtonSolver # Register NewtonSolver in _solvers: @@ -358,7 +430,120 @@ def ComputeScalingFactor(self, x, b): def aGMRES(A, x, b, M, max_iter, m_max, m_min, m_step, cf, tol, atol, printit): r"""aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int""" return _solvers.aGMRES(A, x, b, M, max_iter, m_max, m_min, m_step, cf, tol, atol, printit) -class SLBQPOptimizer(IterativeSolver): +aGMRES = _solvers.aGMRES +class OptimizationProblem(object): + r"""Proxy of C++ mfem::OptimizationProblem class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + input_size = property(_solvers.OptimizationProblem_input_size_get, doc=r"""input_size : q(const).int""") + + def CalcObjective(self, x): + r"""CalcObjective(OptimizationProblem self, Vector x) -> double""" + return _solvers.OptimizationProblem_CalcObjective(self, x) + CalcObjective = _swig_new_instance_method(_solvers.OptimizationProblem_CalcObjective) + + def CalcObjectiveGrad(self, x, grad): + r"""CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)""" + return _solvers.OptimizationProblem_CalcObjectiveGrad(self, x, grad) + CalcObjectiveGrad = _swig_new_instance_method(_solvers.OptimizationProblem_CalcObjectiveGrad) + + def SetEqualityConstraint(self, c): + r"""SetEqualityConstraint(OptimizationProblem self, Vector c)""" + return _solvers.OptimizationProblem_SetEqualityConstraint(self, c) + SetEqualityConstraint = _swig_new_instance_method(_solvers.OptimizationProblem_SetEqualityConstraint) + + def SetInequalityConstraint(self, dl, dh): + r"""SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)""" + return _solvers.OptimizationProblem_SetInequalityConstraint(self, dl, dh) + SetInequalityConstraint = _swig_new_instance_method(_solvers.OptimizationProblem_SetInequalityConstraint) + + def SetSolutionBounds(self, xl, xh): + r"""SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)""" + return _solvers.OptimizationProblem_SetSolutionBounds(self, xl, xh) + SetSolutionBounds = _swig_new_instance_method(_solvers.OptimizationProblem_SetSolutionBounds) + + def GetC(self): + r"""GetC(OptimizationProblem self) -> Operator""" + return _solvers.OptimizationProblem_GetC(self) + GetC = _swig_new_instance_method(_solvers.OptimizationProblem_GetC) + + def GetD(self): + r"""GetD(OptimizationProblem self) -> Operator""" + return _solvers.OptimizationProblem_GetD(self) + GetD = _swig_new_instance_method(_solvers.OptimizationProblem_GetD) + + def GetEqualityVec(self): + r"""GetEqualityVec(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetEqualityVec(self) + GetEqualityVec = _swig_new_instance_method(_solvers.OptimizationProblem_GetEqualityVec) + + def GetInequalityVec_Lo(self): + r"""GetInequalityVec_Lo(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetInequalityVec_Lo(self) + GetInequalityVec_Lo = _swig_new_instance_method(_solvers.OptimizationProblem_GetInequalityVec_Lo) + + def GetInequalityVec_Hi(self): + r"""GetInequalityVec_Hi(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetInequalityVec_Hi(self) + GetInequalityVec_Hi = _swig_new_instance_method(_solvers.OptimizationProblem_GetInequalityVec_Hi) + + def GetBoundsVec_Lo(self): + r"""GetBoundsVec_Lo(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetBoundsVec_Lo(self) + GetBoundsVec_Lo = _swig_new_instance_method(_solvers.OptimizationProblem_GetBoundsVec_Lo) + + def GetBoundsVec_Hi(self): + r"""GetBoundsVec_Hi(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetBoundsVec_Hi(self) + GetBoundsVec_Hi = _swig_new_instance_method(_solvers.OptimizationProblem_GetBoundsVec_Hi) + + def GetNumConstraints(self): + r"""GetNumConstraints(OptimizationProblem self) -> int""" + return _solvers.OptimizationProblem_GetNumConstraints(self) + GetNumConstraints = _swig_new_instance_method(_solvers.OptimizationProblem_GetNumConstraints) + __swig_destroy__ = _solvers.delete_OptimizationProblem + +# Register OptimizationProblem in _solvers: +_solvers.OptimizationProblem_swigregister(OptimizationProblem) + +class OptimizationSolver(IterativeSolver): + r"""Proxy of C++ mfem::OptimizationSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _solvers.delete_OptimizationSolver + + def SetOptimizationProblem(self, prob): + r"""SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)""" + return _solvers.OptimizationSolver_SetOptimizationProblem(self, prob) + SetOptimizationProblem = _swig_new_instance_method(_solvers.OptimizationSolver_SetOptimizationProblem) + + def Mult(self, xt, x): + r"""Mult(OptimizationSolver self, Vector xt, Vector x)""" + return _solvers.OptimizationSolver_Mult(self, xt, x) + Mult = _swig_new_instance_method(_solvers.OptimizationSolver_Mult) + + def SetPreconditioner(self, pr): + r"""SetPreconditioner(OptimizationSolver self, Solver pr)""" + return _solvers.OptimizationSolver_SetPreconditioner(self, pr) + SetPreconditioner = _swig_new_instance_method(_solvers.OptimizationSolver_SetPreconditioner) + + def SetOperator(self, op): + r"""SetOperator(OptimizationSolver self, Operator op)""" + return _solvers.OptimizationSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.OptimizationSolver_SetOperator) + +# Register OptimizationSolver in _solvers: +_solvers.OptimizationSolver_swigregister(OptimizationSolver) + +class SLBQPOptimizer(OptimizationSolver): r"""Proxy of C++ mfem::SLBQPOptimizer class.""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -371,29 +556,75 @@ def __init__(self, *args): """ _solvers.SLBQPOptimizer_swiginit(self, _solvers.new_SLBQPOptimizer(*args)) + def SetOptimizationProblem(self, prob): + r"""SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)""" + return _solvers.SLBQPOptimizer_SetOptimizationProblem(self, prob) + SetOptimizationProblem = _swig_new_instance_method(_solvers.SLBQPOptimizer_SetOptimizationProblem) + def SetBounds(self, _lo, _hi): r"""SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)""" return _solvers.SLBQPOptimizer_SetBounds(self, _lo, _hi) + SetBounds = _swig_new_instance_method(_solvers.SLBQPOptimizer_SetBounds) def SetLinearConstraint(self, _w, _a): r"""SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)""" return _solvers.SLBQPOptimizer_SetLinearConstraint(self, _w, _a) + SetLinearConstraint = _swig_new_instance_method(_solvers.SLBQPOptimizer_SetLinearConstraint) def Mult(self, xt, x): r"""Mult(SLBQPOptimizer self, Vector xt, Vector x)""" return _solvers.SLBQPOptimizer_Mult(self, xt, x) - - def SetPreconditioner(self, pr): - r"""SetPreconditioner(SLBQPOptimizer self, Solver pr)""" - return _solvers.SLBQPOptimizer_SetPreconditioner(self, pr) - - def SetOperator(self, op): - r"""SetOperator(SLBQPOptimizer self, Operator op)""" - return _solvers.SLBQPOptimizer_SetOperator(self, op) + Mult = _swig_new_instance_method(_solvers.SLBQPOptimizer_Mult) __swig_destroy__ = _solvers.delete_SLBQPOptimizer # Register SLBQPOptimizer in _solvers: _solvers.SLBQPOptimizer_swigregister(SLBQPOptimizer) +class BlockILU(mfem._par.operators.Solver): + r"""Proxy of C++ mfem::BlockILU class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + Reordering_MINIMUM_DISCARDED_FILL = _solvers.BlockILU_Reordering_MINIMUM_DISCARDED_FILL + + Reordering_NONE = _solvers.BlockILU_Reordering_NONE + + + def __init__(self, *args): + r""" + __init__(BlockILU self, int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU + __init__(BlockILU self, Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU + """ + _solvers.BlockILU_swiginit(self, _solvers.new_BlockILU(*args)) + + def SetOperator(self, op): + r"""SetOperator(BlockILU self, Operator op)""" + return _solvers.BlockILU_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.BlockILU_SetOperator) + + def Mult(self, b, x): + r"""Mult(BlockILU self, Vector b, Vector x)""" + return _solvers.BlockILU_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.BlockILU_Mult) + + def GetBlockI(self): + r"""GetBlockI(BlockILU self) -> int *""" + return _solvers.BlockILU_GetBlockI(self) + GetBlockI = _swig_new_instance_method(_solvers.BlockILU_GetBlockI) + + def GetBlockJ(self): + r"""GetBlockJ(BlockILU self) -> int *""" + return _solvers.BlockILU_GetBlockJ(self) + GetBlockJ = _swig_new_instance_method(_solvers.BlockILU_GetBlockJ) + + def GetBlockData(self): + r"""GetBlockData(BlockILU self) -> double *""" + return _solvers.BlockILU_GetBlockData(self) + GetBlockData = _swig_new_instance_method(_solvers.BlockILU_GetBlockData) + __swig_destroy__ = _solvers.delete_BlockILU + +# Register BlockILU in _solvers: +_solvers.BlockILU_swigregister(BlockILU) + diff --git a/mfem/_par/solvers_wrap.cxx b/mfem/_par/solvers_wrap.cxx index 255baa90..9a3ebbde 100644 --- a/mfem/_par/solvers_wrap.cxx +++ b/mfem/_par/solvers_wrap.cxx @@ -3071,34 +3071,43 @@ namespace Swig { #define SWIGTYPE_p_double swig_types[3] #define SWIGTYPE_p_int swig_types[4] #define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[5] -#define SWIGTYPE_p_mfem__BiCGSTABSolver swig_types[6] -#define SWIGTYPE_p_mfem__CGSolver swig_types[7] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[8] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[9] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[10] -#define SWIGTYPE_p_mfem__FGMRESSolver swig_types[11] -#define SWIGTYPE_p_mfem__GMRESSolver swig_types[12] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[13] -#define SWIGTYPE_p_mfem__IterativeSolver swig_types[14] -#define SWIGTYPE_p_mfem__MINRESSolver swig_types[15] -#define SWIGTYPE_p_mfem__Matrix swig_types[16] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[17] -#define SWIGTYPE_p_mfem__NewtonSolver swig_types[18] -#define SWIGTYPE_p_mfem__Operator swig_types[19] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[20] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[21] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[22] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[23] -#define SWIGTYPE_p_mfem__SLBQPOptimizer swig_types[24] -#define SWIGTYPE_p_mfem__SLISolver swig_types[25] -#define SWIGTYPE_p_mfem__Solver swig_types[26] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[27] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[28] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[29] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[30] -#define SWIGTYPE_p_mfem__Vector swig_types[31] -static swig_type_info *swig_types[33]; -static swig_module_info swig_module = {swig_types, 32, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] +#define SWIGTYPE_p_mfem__BiCGSTABSolver swig_types[7] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[8] +#define SWIGTYPE_p_mfem__BlockILU swig_types[9] +#define SWIGTYPE_p_mfem__CGSolver swig_types[10] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[11] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[12] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[13] +#define SWIGTYPE_p_mfem__FGMRESSolver swig_types[14] +#define SWIGTYPE_p_mfem__GMRESSolver swig_types[15] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[16] +#define SWIGTYPE_p_mfem__IterativeSolver swig_types[17] +#define SWIGTYPE_p_mfem__MINRESSolver swig_types[18] +#define SWIGTYPE_p_mfem__Matrix swig_types[19] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[20] +#define SWIGTYPE_p_mfem__NewtonSolver swig_types[21] +#define SWIGTYPE_p_mfem__Operator swig_types[22] +#define SWIGTYPE_p_mfem__OperatorJacobiSmoother swig_types[23] +#define SWIGTYPE_p_mfem__OptimizationProblem swig_types[24] +#define SWIGTYPE_p_mfem__OptimizationSolver swig_types[25] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[26] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[27] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[28] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[29] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[30] +#define SWIGTYPE_p_mfem__SLBQPOptimizer swig_types[31] +#define SWIGTYPE_p_mfem__SLISolver swig_types[32] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[33] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[34] +#define SWIGTYPE_p_mfem__Solver swig_types[35] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[36] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[37] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[38] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[39] +#define SWIGTYPE_p_mfem__Vector swig_types[40] +static swig_type_info *swig_types[42]; +static swig_module_info swig_module = {swig_types, 41, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3334,6 +3343,111 @@ SWIG_AsPtr_MPI_Comm (PyObject * input, MPI_Comm **p) { } +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + /* --------------------------------------------------- * C++ director class methods @@ -3740,14 +3854,44 @@ SWIGINTERN PyObject *IterativeSolver_swigregister(PyObject *SWIGUNUSEDPARM(self) return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_SLISolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SLISolver *result = 0 ; + mfem::BilinearForm *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::OperatorJacobiSmoother *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::SLISolver *)new mfem::SLISolver(); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3758,31 +3902,43 @@ SWIGINTERN PyObject *_wrap_new_SLISolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SLISolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::SLISolver *result = 0 ; + mfem::BilinearForm *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::OperatorJacobiSmoother *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SLISolver" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - result = (mfem::SLISolver *)new mfem::SLISolver(arg1); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3793,69 +3949,51 @@ SWIGINTERN PyObject *_wrap_new_SLISolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SLISolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SLISolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SLISolver__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_SLISolver__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SLISolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SLISolver::SLISolver()\n" - " mfem::SLISolver::SLISolver(MPI_Comm)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::Vector *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + double val3 ; + int ecode3 = 0 ; + mfem::OperatorJacobiSmoother *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_SetOperator" "', argument " "1"" of type '" "mfem::SLISolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); } - arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3866,51 +4004,43 @@ SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Vector *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + mfem::OperatorJacobiSmoother *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_Mult" "', argument " "1"" of type '" "mfem::SLISolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); } - arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - ((mfem::SLISolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3921,27 +4051,107 @@ SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_OperatorJacobiSmoother", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_3(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OperatorJacobiSmoother'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &,double const)\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &)\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &,double const)\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_OperatorJacobiSmoother(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLISolver" "', argument " "1"" of type '" "mfem::SLISolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } - arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); { try { delete arg1; @@ -3962,87 +4172,44 @@ SWIGINTERN PyObject *_wrap_delete_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *SLISolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLISolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *SLISolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + ((mfem::OperatorJacobiSmoother const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4060,68 +4227,33 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4139,60 +4271,33 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Setup", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Setup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + (arg1)->Setup((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4210,53 +4315,25 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *OperatorJacobiSmoother_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *OperatorJacobiSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SLISolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + mfem::SLISolver *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + result = (mfem::SLISolver *)new mfem::SLISolver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4267,53 +4344,31 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SLISolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + MPI_Comm arg1 ; + mfem::SLISolver *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SLISolver" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + result = (mfem::SLISolver *)new mfem::SLISolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4324,94 +4379,158 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; +SWIGINTERN PyObject *_wrap_new_SLISolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SLISolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SLISolver__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_SLISolver__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SLISolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SLISolver::SLISolver()\n" + " mfem::SLISolver::SLISolver(MPI_Comm)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SLISolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_SetOperator" "', argument " "1"" of type '" "mfem::SLISolver *""'"); + } + arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "SLISolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_Mult" "', argument " "1"" of type '" "mfem::SLISolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + try { + ((mfem::SLISolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLISolver" "', argument " "1"" of type '" "mfem::SLISolver *""'"); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4429,14 +4548,25 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *SLISolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLISolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SLISolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg4 ; int arg5 ; - int arg6 ; + double arg6 ; double arg7 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4444,8 +4574,8 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; double val7 ; int ecode7 = 0 ; @@ -4458,42 +4588,39 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); @@ -4501,7 +4628,7 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ arg7 = static_cast< double >(val7); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4519,22 +4646,22 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg4 ; int arg5 ; - int arg6 ; + double arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); @@ -4545,30 +4672,104 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -4576,14 +4777,72 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ arg5 = PyArray_PyIntAsInt(swig_obj[4]); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + try { + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4601,13 +4860,73 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; int arg5 ; + int arg6 ; + double arg7 ; + double arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4616,8 +4935,12 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -4656,9 +4979,25 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ }; arg5 = PyArray_PyIntAsInt(swig_obj[4]); } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4676,12 +5015,15 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4690,8 +5032,10 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -4725,13 +5069,255 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + { + try { + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ // SWIG_fail; //} // catch (Swig::DirectorMethodException &e) { SWIG_fail; } @@ -10749,14 +11335,58 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_delete_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ProcessNewState", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ProcessNewState" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); + } + arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ProcessNewState" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ProcessNewState" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + ((mfem::NewtonSolver const *)arg1)->ProcessNewState((mfem::Vector const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { @@ -10933,14 +11563,57 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_input_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *result = 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_input_size_get" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + result = (int)(int) ((arg1)->input_size); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjective", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjective" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjective" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjective" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(); + result = (double)((mfem::OptimizationProblem const *)arg1)->CalcObjective((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10951,31 +11624,95 @@ SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer__SWIG_0(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::SLBQPOptimizer *result = 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjectiveGrad", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SLBQPOptimizer" "', argument " "1"" of type '" "MPI_Comm""'"); + try { + ((mfem::OptimizationProblem const *)arg1)->CalcObjectiveGrad((mfem::Vector const &)*arg2,*arg3); } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetEqualityConstraint", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(arg1); + (arg1)->SetEqualityConstraint((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10986,45 +11723,71 @@ SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer__SWIG_1(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SLBQPOptimizer", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SLBQPOptimizer__SWIG_0(self, argc, argv); + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetInequalityConstraint", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_SLBQPOptimizer__SWIG_1(self, argc, argv); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + (arg1)->SetInequalityConstraint((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SLBQPOptimizer'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SLBQPOptimizer::SLBQPOptimizer()\n" - " mfem::SLBQPOptimizer::SLBQPOptimizer(MPI_Comm)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -11035,83 +11798,1446 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetBounds", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetSolutionBounds", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->SetBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + (arg1)->SetSolutionBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetC" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Operator *)((mfem::OptimizationProblem const *)arg1)->GetC(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetD" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Operator *)((mfem::OptimizationProblem const *)arg1)->GetD(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetEqualityVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetEqualityVec" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetEqualityVec(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetInequalityVec_Lo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetInequalityVec_Lo" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetInequalityVec_Lo(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetInequalityVec_Hi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetInequalityVec_Hi" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetInequalityVec_Hi(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetBoundsVec_Lo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetBoundsVec_Lo" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetBoundsVec_Lo(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetBoundsVec_Hi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetBoundsVec_Hi" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetBoundsVec_Hi(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetNumConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetNumConstraints" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (int)((mfem::OptimizationProblem const *)arg1)->GetNumConstraints(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_OptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *OptimizationProblem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationProblem, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_OptimizationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationSolver" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::OptimizationProblem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + } + arg2 = reinterpret_cast< mfem::OptimizationProblem * >(argp2); + { + try { + (arg1)->SetOptimizationProblem((mfem::OptimizationProblem const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_Mult" "', argument " "1"" of type '" "mfem::OptimizationSolver const *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::OptimizationSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Solver *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + { + try { + (arg1)->SetPreconditioner(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOperator" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *OptimizationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + MPI_Comm arg1 ; + mfem::SLBQPOptimizer *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_SLBQPOptimizer" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; + } + { + try { + result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SLBQPOptimizer", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SLBQPOptimizer__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_SLBQPOptimizer__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SLBQPOptimizer'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SLBQPOptimizer::SLBQPOptimizer()\n" + " mfem::SLBQPOptimizer::SLBQPOptimizer(MPI_Comm)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::OptimizationProblem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + } + arg2 = reinterpret_cast< mfem::OptimizationProblem * >(argp2); + { + try { + (arg1)->SetOptimizationProblem((mfem::OptimizationProblem const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetBounds", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + (arg1)->SetBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetLinearConstraint", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::BlockILU::Reordering arg2 ; + int arg3 ; + int val2 ; + int ecode2 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg2 = static_cast< mfem::BlockILU::Reordering >(val2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::BlockILU::Reordering arg2 ; + int val2 ; + int ecode2 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg2 = static_cast< mfem::BlockILU::Reordering >(val2); + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + int arg2 ; + mfem::BlockILU::Reordering arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg3 = static_cast< mfem::BlockILU::Reordering >(val3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + int arg2 ; + mfem::BlockILU::Reordering arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg3 = static_cast< mfem::BlockILU::Reordering >(val3); + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlockILU", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_BlockILU__SWIG_6(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_2(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_5(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_BlockILU__SWIG_4(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_3(self, argc, argv); + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlockILU'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering,int)\n" + " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering)\n" + " mfem::BlockILU::BlockILU(int)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering,int)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &,int)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetLinearConstraint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BlockILU_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_SetOperator" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11129,9 +13255,9 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -11142,31 +13268,31 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BlockILU_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_Mult" "', argument " "1"" of type '" "mfem::BlockILU const *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockILU_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::BlockILU const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11184,33 +13310,24 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_GetBlockI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Solver *arg2 = 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; + int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetPreconditioner" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); - } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_GetBlockI" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); { try { - (arg1)->SetPreconditioner(*arg2); + result = (int *)(arg1)->GetBlockI(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11221,40 +13338,66 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetPreconditioner(PyObject *SWIGUNUSED // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_GetBlockJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; + int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetOperator" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_GetBlockJ" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); + { + try { + result = (int *)(arg1)->GetBlockJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BlockILU_GetBlockData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_GetBlockData" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + result = (double *)(arg1)->GetBlockData(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11265,27 +13408,27 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOperator(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_BlockILU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlockILU" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); { try { delete arg1; @@ -11306,19 +13449,20 @@ SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BlockILU_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BlockILU, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BlockILU_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "IterativeSolver_SetRelTol(IterativeSolver self, double rtol)"}, { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "IterativeSolver_SetAbsTol(IterativeSolver self, double atol)"}, { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "IterativeSolver_SetMaxIter(IterativeSolver self, int max_it)"}, @@ -11330,6 +13474,16 @@ static PyMethodDef SwigMethods[] = { { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "IterativeSolver_SetOperator(IterativeSolver self, Operator op)"}, { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, + { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" + "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" + "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + ""}, + { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, + { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "OperatorJacobiSmoother_Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "OperatorJacobiSmoother_SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "OperatorJacobiSmoother_Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, + { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, { "new_SLISolver", _wrap_new_SLISolver, METH_VARARGS, "\n" "SLISolver()\n" "new_SLISolver(MPI_Comm _comm) -> SLISolver\n" @@ -11411,26 +13565,214 @@ static PyMethodDef SwigMethods[] = { { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "NewtonSolver_SetSolver(NewtonSolver self, Solver solver)"}, { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "NewtonSolver_Mult(NewtonSolver self, Vector b, Vector x)"}, { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "NewtonSolver_ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "NewtonSolver_ProcessNewState(NewtonSolver self, Vector x)"}, { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, + { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "OptimizationProblem_CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "OptimizationProblem_CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "OptimizationProblem_SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "OptimizationProblem_SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "OptimizationProblem_SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "OptimizationProblem_GetC(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "OptimizationProblem_GetD(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "OptimizationProblem_GetEqualityVec(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Lo", _wrap_OptimizationProblem_GetInequalityVec_Lo, METH_O, "OptimizationProblem_GetInequalityVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Hi", _wrap_OptimizationProblem_GetInequalityVec_Hi, METH_O, "OptimizationProblem_GetInequalityVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Lo", _wrap_OptimizationProblem_GetBoundsVec_Lo, METH_O, "OptimizationProblem_GetBoundsVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Hi", _wrap_OptimizationProblem_GetBoundsVec_Hi, METH_O, "OptimizationProblem_GetBoundsVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetNumConstraints", _wrap_OptimizationProblem_GetNumConstraints, METH_O, "OptimizationProblem_GetNumConstraints(OptimizationProblem self) -> int"}, + { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, + { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, + { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, + { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "OptimizationSolver_SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "OptimizationSolver_Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "OptimizationSolver_SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "OptimizationSolver_SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_VARARGS, "\n" "SLBQPOptimizer()\n" "new_SLBQPOptimizer(MPI_Comm _comm) -> SLBQPOptimizer\n" ""}, + { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SLBQPOptimizer_SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SLBQPOptimizer_SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SLBQPOptimizer_SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "SLBQPOptimizer_Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, - { "SLBQPOptimizer_SetPreconditioner", _wrap_SLBQPOptimizer_SetPreconditioner, METH_VARARGS, "SLBQPOptimizer_SetPreconditioner(SLBQPOptimizer self, Solver pr)"}, - { "SLBQPOptimizer_SetOperator", _wrap_SLBQPOptimizer_SetOperator, METH_VARARGS, "SLBQPOptimizer_SetOperator(SLBQPOptimizer self, Operator op)"}, { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, + { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" + "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + ""}, + { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "BlockILU_SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "BlockILU_Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "BlockILU_GetBlockI(BlockILU self) -> int *"}, + { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "BlockILU_GetBlockJ(BlockILU self) -> int *"}, + { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "BlockILU_GetBlockData(BlockILU self) -> double *"}, + { "delete_BlockILU", _wrap_delete_BlockILU, METH_O, "delete_BlockILU(BlockILU self)"}, + { "BlockILU_swigregister", BlockILU_swigregister, METH_O, NULL}, + { "BlockILU_swiginit", BlockILU_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "SetRelTol(IterativeSolver self, double rtol)"}, + { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "SetAbsTol(IterativeSolver self, double atol)"}, + { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "SetMaxIter(IterativeSolver self, int max_it)"}, + { "IterativeSolver_SetPrintLevel", _wrap_IterativeSolver_SetPrintLevel, METH_VARARGS, "SetPrintLevel(IterativeSolver self, int print_lvl)"}, + { "IterativeSolver_GetNumIterations", _wrap_IterativeSolver_GetNumIterations, METH_O, "GetNumIterations(IterativeSolver self) -> int"}, + { "IterativeSolver_GetConverged", _wrap_IterativeSolver_GetConverged, METH_O, "GetConverged(IterativeSolver self) -> int"}, + { "IterativeSolver_GetFinalNorm", _wrap_IterativeSolver_GetFinalNorm, METH_O, "GetFinalNorm(IterativeSolver self) -> double"}, + { "IterativeSolver_SetPreconditioner", _wrap_IterativeSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(IterativeSolver self, Solver pr)"}, + { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "SetOperator(IterativeSolver self, Operator op)"}, + { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, + { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, + { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" + "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" + "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + ""}, + { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, + { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, + { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, + { "new_SLISolver", _wrap_new_SLISolver, METH_VARARGS, "\n" + "SLISolver()\n" + "new_SLISolver(MPI_Comm _comm) -> SLISolver\n" + ""}, + { "SLISolver_SetOperator", _wrap_SLISolver_SetOperator, METH_VARARGS, "SetOperator(SLISolver self, Operator op)"}, + { "SLISolver_Mult", _wrap_SLISolver_Mult, METH_VARARGS, "Mult(SLISolver self, Vector b, Vector x)"}, + { "delete_SLISolver", _wrap_delete_SLISolver, METH_O, "delete_SLISolver(SLISolver self)"}, + { "SLISolver_swigregister", SLISolver_swigregister, METH_O, NULL}, + { "SLISolver_swiginit", SLISolver_swiginit, METH_VARARGS, NULL}, + { "SLI", _wrap_SLI, METH_VARARGS, "\n" + "SLI(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)\n" + "SLI(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)\n" + ""}, + { "new_CGSolver", _wrap_new_CGSolver, METH_VARARGS, "\n" + "CGSolver()\n" + "new_CGSolver(MPI_Comm _comm) -> CGSolver\n" + ""}, + { "CGSolver_SetOperator", _wrap_CGSolver_SetOperator, METH_VARARGS, "SetOperator(CGSolver self, Operator op)"}, + { "CGSolver_Mult", _wrap_CGSolver_Mult, METH_VARARGS, "Mult(CGSolver self, Vector b, Vector x)"}, + { "delete_CGSolver", _wrap_delete_CGSolver, METH_O, "delete_CGSolver(CGSolver self)"}, + { "CGSolver_swigregister", CGSolver_swigregister, METH_O, NULL}, + { "CGSolver_swiginit", CGSolver_swiginit, METH_VARARGS, NULL}, + { "CG", _wrap_CG, METH_VARARGS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "PCG", _wrap_PCG, METH_VARARGS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "new_GMRESSolver", _wrap_new_GMRESSolver, METH_VARARGS, "\n" + "GMRESSolver()\n" + "new_GMRESSolver(MPI_Comm _comm) -> GMRESSolver\n" + ""}, + { "GMRESSolver_SetKDim", _wrap_GMRESSolver_SetKDim, METH_VARARGS, "SetKDim(GMRESSolver self, int dim)"}, + { "GMRESSolver_Mult", _wrap_GMRESSolver_Mult, METH_VARARGS, "Mult(GMRESSolver self, Vector b, Vector x)"}, + { "delete_GMRESSolver", _wrap_delete_GMRESSolver, METH_O, "delete_GMRESSolver(GMRESSolver self)"}, + { "GMRESSolver_swigregister", GMRESSolver_swigregister, METH_O, NULL}, + { "GMRESSolver_swiginit", GMRESSolver_swiginit, METH_VARARGS, NULL}, + { "new_FGMRESSolver", _wrap_new_FGMRESSolver, METH_VARARGS, "\n" + "FGMRESSolver()\n" + "new_FGMRESSolver(MPI_Comm _comm) -> FGMRESSolver\n" + ""}, + { "FGMRESSolver_SetKDim", _wrap_FGMRESSolver_SetKDim, METH_VARARGS, "SetKDim(FGMRESSolver self, int dim)"}, + { "FGMRESSolver_Mult", _wrap_FGMRESSolver_Mult, METH_VARARGS, "Mult(FGMRESSolver self, Vector b, Vector x)"}, + { "delete_FGMRESSolver", _wrap_delete_FGMRESSolver, METH_O, "delete_FGMRESSolver(FGMRESSolver self)"}, + { "FGMRESSolver_swigregister", FGMRESSolver_swigregister, METH_O, NULL}, + { "FGMRESSolver_swiginit", FGMRESSolver_swiginit, METH_VARARGS, NULL}, + { "GMRES", _wrap_GMRES, METH_VARARGS, "\n" + "GMRES(Operator A, Vector x, Vector b, Solver M, int & max_iter, int m, double & tol, double atol, int printit) -> int\n" + "GMRES(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, int m=50, double rtol=1e-12, double atol=1e-24)\n" + ""}, + { "new_BiCGSTABSolver", _wrap_new_BiCGSTABSolver, METH_VARARGS, "\n" + "BiCGSTABSolver()\n" + "new_BiCGSTABSolver(MPI_Comm _comm) -> BiCGSTABSolver\n" + ""}, + { "BiCGSTABSolver_SetOperator", _wrap_BiCGSTABSolver_SetOperator, METH_VARARGS, "SetOperator(BiCGSTABSolver self, Operator op)"}, + { "BiCGSTABSolver_Mult", _wrap_BiCGSTABSolver_Mult, METH_VARARGS, "Mult(BiCGSTABSolver self, Vector b, Vector x)"}, + { "delete_BiCGSTABSolver", _wrap_delete_BiCGSTABSolver, METH_O, "delete_BiCGSTABSolver(BiCGSTABSolver self)"}, + { "BiCGSTABSolver_swigregister", BiCGSTABSolver_swigregister, METH_O, NULL}, + { "BiCGSTABSolver_swiginit", BiCGSTABSolver_swiginit, METH_VARARGS, NULL}, + { "BiCGSTAB", _wrap_BiCGSTAB, METH_VARARGS, "\n" + "BiCGSTAB(Operator A, Vector x, Vector b, Solver M, int & max_iter, double & tol, double atol, int printit) -> int\n" + "BiCGSTAB(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double rtol=1e-12, double atol=1e-24)\n" + ""}, + { "new_MINRESSolver", _wrap_new_MINRESSolver, METH_VARARGS, "\n" + "MINRESSolver()\n" + "new_MINRESSolver(MPI_Comm _comm) -> MINRESSolver\n" + ""}, + { "MINRESSolver_SetPreconditioner", _wrap_MINRESSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(MINRESSolver self, Solver pr)"}, + { "MINRESSolver_SetOperator", _wrap_MINRESSolver_SetOperator, METH_VARARGS, "SetOperator(MINRESSolver self, Operator op)"}, + { "MINRESSolver_Mult", _wrap_MINRESSolver_Mult, METH_VARARGS, "Mult(MINRESSolver self, Vector b, Vector x)"}, + { "delete_MINRESSolver", _wrap_delete_MINRESSolver, METH_O, "delete_MINRESSolver(MINRESSolver self)"}, + { "MINRESSolver_swigregister", MINRESSolver_swigregister, METH_O, NULL}, + { "MINRESSolver_swiginit", MINRESSolver_swiginit, METH_VARARGS, NULL}, + { "MINRES", _wrap_MINRES, METH_VARARGS, "\n" + "MINRES(Operator A, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24)\n" + "MINRES(Operator A, Solver B, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24)\n" + ""}, + { "new_NewtonSolver", _wrap_new_NewtonSolver, METH_VARARGS, "\n" + "NewtonSolver()\n" + "new_NewtonSolver(MPI_Comm _comm) -> NewtonSolver\n" + ""}, + { "NewtonSolver_SetOperator", _wrap_NewtonSolver_SetOperator, METH_VARARGS, "SetOperator(NewtonSolver self, Operator op)"}, + { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "SetSolver(NewtonSolver self, Solver solver)"}, + { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "Mult(NewtonSolver self, Vector b, Vector x)"}, + { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "ProcessNewState(NewtonSolver self, Vector x)"}, + { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, + { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, + { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, + { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, + { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "GetC(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "GetD(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "GetEqualityVec(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Lo", _wrap_OptimizationProblem_GetInequalityVec_Lo, METH_O, "GetInequalityVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Hi", _wrap_OptimizationProblem_GetInequalityVec_Hi, METH_O, "GetInequalityVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Lo", _wrap_OptimizationProblem_GetBoundsVec_Lo, METH_O, "GetBoundsVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Hi", _wrap_OptimizationProblem_GetBoundsVec_Hi, METH_O, "GetBoundsVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetNumConstraints", _wrap_OptimizationProblem_GetNumConstraints, METH_O, "GetNumConstraints(OptimizationProblem self) -> int"}, + { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, + { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, + { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, + { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, + { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_VARARGS, "\n" + "SLBQPOptimizer()\n" + "new_SLBQPOptimizer(MPI_Comm _comm) -> SLBQPOptimizer\n" + ""}, + { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, + { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, + { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, + { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, + { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, + { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, + { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, + { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" + "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + ""}, + { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "GetBlockI(BlockILU self) -> int *"}, + { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "GetBlockJ(BlockILU self) -> int *"}, + { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "GetBlockData(BlockILU self) -> double *"}, + { "delete_BlockILU", _wrap_delete_BlockILU, METH_O, "delete_BlockILU(BlockILU self)"}, + { "BlockILU_swigregister", BlockILU_swigregister, METH_O, NULL}, + { "BlockILU_swiginit", BlockILU_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -11443,6 +13785,9 @@ static void *_p_mfem__BiCGSTABSolverTo_p_mfem__IterativeSolver(void *x, int *SWI static void *_p_mfem__NewtonSolverTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); } +static void *_p_mfem__OptimizationSolverTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::IterativeSolver *) ((mfem::OptimizationSolver *) x)); +} static void *_p_mfem__SLISolverTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::IterativeSolver *) ((mfem::SLISolver *) x)); } @@ -11459,40 +13804,52 @@ static void *_p_mfem__MINRESSolverTo_p_mfem__IterativeSolver(void *x, int *SWIGU return (void *)((mfem::IterativeSolver *) ((mfem::MINRESSolver *) x)); } static void *_p_mfem__SLBQPOptimizerTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::IterativeSolver *) ((mfem::SLBQPOptimizer *) x)); + return (void *)((mfem::IterativeSolver *) (mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); } -static void *_p_mfem__BiCGSTABSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::BiCGSTABSolver *) x)); -} -static void *_p_mfem__NewtonSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); +static void *_p_mfem__MINRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::MINRESSolver *) x)); } -static void *_p_mfem__IterativeSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) ((mfem::IterativeSolver *) x)); +static void *_p_mfem__FGMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::FGMRESSolver *) x)); } -static void *_p_mfem__SLISolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::SLISolver *) x)); +static void *_p_mfem__GMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::GMRESSolver *) x)); } static void *_p_mfem__CGSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::CGSolver *) x)); } -static void *_p_mfem__GMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::GMRESSolver *) x)); +static void *_p_mfem__SLISolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::SLISolver *) x)); } -static void *_p_mfem__FGMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::FGMRESSolver *) x)); +static void *_p_mfem__IterativeSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) ((mfem::IterativeSolver *) x)); } -static void *_p_mfem__MINRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::MINRESSolver *) x)); +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); } static void *_p_mfem__MatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) ((mfem::MatrixInverse *) x)); } -static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +static void *_p_mfem__OptimizationSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::OptimizationSolver *) x)); +} +static void *_p_mfem__NewtonSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); +} +static void *_p_mfem__BiCGSTABSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::BiCGSTABSolver *) x)); } static void *_p_mfem__SLBQPOptimizerTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::SLBQPOptimizer *) x)); + return (void *)((mfem::Solver *) (mfem::IterativeSolver *)(mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); +} +static void *_p_mfem__BlockILUTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) ((mfem::BlockILU *) x)); +} +static void *_p_mfem__OperatorJacobiSmootherTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) ((mfem::OperatorJacobiSmoother *) x)); +} +static void *_p_mfem__SLBQPOptimizerTo_p_mfem__OptimizationSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); } static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); @@ -11533,21 +13890,30 @@ static void *_p_mfem__BiCGSTABSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSED static void *_p_mfem__NewtonSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +static void *_p_mfem__OptimizationSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *) ((mfem::OptimizationSolver *) x)); } static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__SLBQPOptimizerTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *) ((mfem::SLBQPOptimizer *) x)); + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *)(mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); +} +static void *_p_mfem__BlockILUTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::BlockILU *) x)); } static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -11563,18 +13929,30 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__OperatorJacobiSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::OperatorJacobiSmoother *) x)); +} static swig_type_info _swigt__p_MPI_Comm = {"_p_MPI_Comm", "MPI_Comm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BiCGSTABSolver = {"_p_mfem__BiCGSTABSolver", "mfem::BiCGSTABSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__BilinearForm = {"_p_mfem__BilinearForm", "mfem::BilinearForm *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__BlockILU = {"_p_mfem__BlockILU", "mfem::BlockILU *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__CGSolver = {"_p_mfem__CGSolver", "mfem::CGSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FGMRESSolver = {"_p_mfem__FGMRESSolver", "mfem::FGMRESSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GMRESSolver = {"_p_mfem__GMRESSolver", "mfem::GMRESSolver *", 0, 0, (void*)0, 0}; @@ -11586,17 +13964,23 @@ static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__P static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__OperatorJacobiSmoother = {"_p_mfem__OperatorJacobiSmoother", "mfem::OperatorJacobiSmoother *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__OptimizationProblem = {"_p_mfem__OptimizationProblem", "mfem::OptimizationProblem *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__OptimizationSolver = {"_p_mfem__OptimizationSolver", "mfem::OptimizationSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SLBQPOptimizer = {"_p_mfem__SLBQPOptimizer", "mfem::SLBQPOptimizer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SLISolver = {"_p_mfem__SLISolver", "mfem::SLISolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; @@ -11609,7 +13993,10 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_double, &_swigt__p_int, &_swigt__p_mfem__AbstractSparseMatrix, + &_swigt__p_mfem__ArrayT_int_t, &_swigt__p_mfem__BiCGSTABSolver, + &_swigt__p_mfem__BilinearForm, + &_swigt__p_mfem__BlockILU, &_swigt__p_mfem__CGSolver, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__DenseMatrix, @@ -11623,12 +14010,18 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__MatrixInverse, &_swigt__p_mfem__NewtonSolver, &_swigt__p_mfem__Operator, + &_swigt__p_mfem__OperatorJacobiSmoother, + &_swigt__p_mfem__OptimizationProblem, + &_swigt__p_mfem__OptimizationSolver, &_swigt__p_mfem__ProductOperator, &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__SLBQPOptimizer, &_swigt__p_mfem__SLISolver, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -11642,32 +14035,41 @@ static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCGSTABSolver[] = { {&_swigt__p_mfem__BiCGSTABSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearForm[] = { {&_swigt__p_mfem__BilinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BlockILU[] = { {&_swigt__p_mfem__BlockILU, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CGSolver[] = { {&_swigt__p_mfem__CGSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FGMRESSolver[] = { {&_swigt__p_mfem__FGMRESSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GMRESSolver[] = { {&_swigt__p_mfem__GMRESSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__IterativeSolver[] = { {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__IterativeSolver, 0, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__IterativeSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IterativeSolver[] = { {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__OptimizationSolver, _p_mfem__OptimizationSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__IterativeSolver, 0, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__IterativeSolver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MINRESSolver[] = { {&_swigt__p_mfem__MINRESSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NewtonSolver[] = { {&_swigt__p_mfem__NewtonSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = {{&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__OptimizationSolver, _p_mfem__OptimizationSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockILU, _p_mfem__BlockILUTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__OperatorJacobiSmoother, _p_mfem__OperatorJacobiSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OperatorJacobiSmoother[] = { {&_swigt__p_mfem__OperatorJacobiSmoother, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OptimizationProblem[] = { {&_swigt__p_mfem__OptimizationProblem, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OptimizationSolver[] = { {&_swigt__p_mfem__OptimizationSolver, 0, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__OptimizationSolver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SLBQPOptimizer[] = { {&_swigt__p_mfem__SLBQPOptimizer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SLISolver[] = { {&_swigt__p_mfem__SLISolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__OptimizationSolver, _p_mfem__OptimizationSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__BlockILU, _p_mfem__BlockILUTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__OperatorJacobiSmoother, _p_mfem__OperatorJacobiSmootherTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { @@ -11677,7 +14079,10 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_double, _swigc__p_int, _swigc__p_mfem__AbstractSparseMatrix, + _swigc__p_mfem__ArrayT_int_t, _swigc__p_mfem__BiCGSTABSolver, + _swigc__p_mfem__BilinearForm, + _swigc__p_mfem__BlockILU, _swigc__p_mfem__CGSolver, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__DenseMatrix, @@ -11691,12 +14096,18 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__MatrixInverse, _swigc__p_mfem__NewtonSolver, _swigc__p_mfem__Operator, + _swigc__p_mfem__OperatorJacobiSmoother, + _swigc__p_mfem__OptimizationProblem, + _swigc__p_mfem__OptimizationSolver, _swigc__p_mfem__ProductOperator, _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__SLBQPOptimizer, _swigc__p_mfem__SLISolver, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, @@ -12435,18 +14846,18 @@ SWIG_init(void) { import_array(); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 @@ -12455,6 +14866,8 @@ SWIG_init(void) { return; #endif + SWIG_Python_SetConstant(d, "BlockILU_Reordering_MINIMUM_DISCARDED_FILL",SWIG_From_int(static_cast< int >(mfem::BlockILU::Reordering::MINIMUM_DISCARDED_FILL))); + SWIG_Python_SetConstant(d, "BlockILU_Reordering_NONE",SWIG_From_int(static_cast< int >(mfem::BlockILU::Reordering::NONE))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/sparsemat.py b/mfem/_par/sparsemat.py index c41fe0c4..ff641caa 100644 --- a/mfem/_par/sparsemat.py +++ b/mfem/_par/sparsemat.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _sparsemat.SWIG_PyInstanceMethod_New +_swig_new_static_method = _sparsemat.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -73,18 +76,22 @@ class _SwigNonDynamicMeta(type): def RAP_P(A, R, ORAP): r"""RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix""" return _sparsemat.RAP_P(A, R, ORAP) +RAP_P = _sparsemat.RAP_P def RAP_R(Rt, A, P): r"""RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix""" return _sparsemat.RAP_R(Rt, A, P) +RAP_R = _sparsemat.RAP_R def OperatorPtr2SparseMatrix(op): r"""OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix""" return _sparsemat.OperatorPtr2SparseMatrix(op) +OperatorPtr2SparseMatrix = _sparsemat.OperatorPtr2SparseMatrix def OperatorHandle2SparseMatrix(op): r"""OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix""" return _sparsemat.OperatorHandle2SparseMatrix(op) +OperatorHandle2SparseMatrix = _sparsemat.OperatorHandle2SparseMatrix class RowNode(object): r"""Proxy of C++ mfem::RowNode class.""" @@ -148,18 +155,22 @@ def __init__(self, *args): def MakeRef(self, master): r"""MakeRef(SparseMatrix self, SparseMatrix master)""" return _sparsemat.SparseMatrix_MakeRef(self, master) + MakeRef = _swig_new_instance_method(_sparsemat.SparseMatrix_MakeRef) def Size(self): r"""Size(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_Size(self) + Size = _swig_new_instance_method(_sparsemat.SparseMatrix_Size) def Clear(self): r"""Clear(SparseMatrix self)""" return _sparsemat.SparseMatrix_Clear(self) + Clear = _swig_new_instance_method(_sparsemat.SparseMatrix_Clear) def Empty(self): r"""Empty(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_Empty(self) + Empty = _swig_new_instance_method(_sparsemat.SparseMatrix_Empty) def GetI(self, *args): r""" @@ -167,6 +178,7 @@ def GetI(self, *args): GetI(SparseMatrix self) -> int const * """ return _sparsemat.SparseMatrix_GetI(self, *args) + GetI = _swig_new_instance_method(_sparsemat.SparseMatrix_GetI) def GetJ(self, *args): r""" @@ -174,6 +186,7 @@ def GetJ(self, *args): GetJ(SparseMatrix self) -> int const * """ return _sparsemat.SparseMatrix_GetJ(self, *args) + GetJ = _swig_new_instance_method(_sparsemat.SparseMatrix_GetJ) def GetData(self, *args): r""" @@ -181,14 +194,131 @@ def GetData(self, *args): GetData(SparseMatrix self) -> double const * """ return _sparsemat.SparseMatrix_GetData(self, *args) + GetData = _swig_new_instance_method(_sparsemat.SparseMatrix_GetData) + + def GetMemoryI(self, *args): + r""" + GetMemoryI(SparseMatrix self) -> mfem::Memory< int > + GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const & + """ + return _sparsemat.SparseMatrix_GetMemoryI(self, *args) + GetMemoryI = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryI) + + def ReadI(self, on_dev=True): + r"""ReadI(SparseMatrix self, bool on_dev=True) -> int const""" + return _sparsemat.SparseMatrix_ReadI(self, on_dev) + ReadI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadI) + + def WriteI(self, on_dev=True): + r"""WriteI(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_WriteI(self, on_dev) + WriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteI) + + def ReadWriteI(self, on_dev=True): + r"""ReadWriteI(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_ReadWriteI(self, on_dev) + ReadWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteI) + + def HostReadI(self): + r"""HostReadI(SparseMatrix self) -> int const *""" + return _sparsemat.SparseMatrix_HostReadI(self) + HostReadI = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadI) + + def HostWriteI(self): + r"""HostWriteI(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostWriteI(self) + HostWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_HostWriteI) + + def HostReadWriteI(self): + r"""HostReadWriteI(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostReadWriteI(self) + HostReadWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadWriteI) + + def GetMemoryJ(self, *args): + r""" + GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > + GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const & + """ + return _sparsemat.SparseMatrix_GetMemoryJ(self, *args) + GetMemoryJ = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryJ) + + def ReadJ(self, on_dev=True): + r"""ReadJ(SparseMatrix self, bool on_dev=True) -> int const""" + return _sparsemat.SparseMatrix_ReadJ(self, on_dev) + ReadJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadJ) + + def WriteJ(self, on_dev=True): + r"""WriteJ(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_WriteJ(self, on_dev) + WriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteJ) + + def ReadWriteJ(self, on_dev=True): + r"""ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_ReadWriteJ(self, on_dev) + ReadWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteJ) + + def HostReadJ(self): + r"""HostReadJ(SparseMatrix self) -> int const *""" + return _sparsemat.SparseMatrix_HostReadJ(self) + HostReadJ = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadJ) + + def HostWriteJ(self): + r"""HostWriteJ(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostWriteJ(self) + HostWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_HostWriteJ) + + def HostReadWriteJ(self): + r"""HostReadWriteJ(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostReadWriteJ(self) + HostReadWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadWriteJ) + + def GetMemoryData(self, *args): + r""" + GetMemoryData(SparseMatrix self) -> mfem::Memory< double > + GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const & + """ + return _sparsemat.SparseMatrix_GetMemoryData(self, *args) + GetMemoryData = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryData) + + def ReadData(self, on_dev=True): + r"""ReadData(SparseMatrix self, bool on_dev=True) -> double const""" + return _sparsemat.SparseMatrix_ReadData(self, on_dev) + ReadData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadData) + + def WriteData(self, on_dev=True): + r"""WriteData(SparseMatrix self, bool on_dev=True) -> double""" + return _sparsemat.SparseMatrix_WriteData(self, on_dev) + WriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteData) + + def ReadWriteData(self, on_dev=True): + r"""ReadWriteData(SparseMatrix self, bool on_dev=True) -> double""" + return _sparsemat.SparseMatrix_ReadWriteData(self, on_dev) + ReadWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteData) + + def HostReadData(self): + r"""HostReadData(SparseMatrix self) -> double const *""" + return _sparsemat.SparseMatrix_HostReadData(self) + HostReadData = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadData) + + def HostWriteData(self): + r"""HostWriteData(SparseMatrix self) -> double *""" + return _sparsemat.SparseMatrix_HostWriteData(self) + HostWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_HostWriteData) + + def HostReadWriteData(self): + r"""HostReadWriteData(SparseMatrix self) -> double *""" + return _sparsemat.SparseMatrix_HostReadWriteData(self) + HostReadWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadWriteData) def RowSize(self, i): r"""RowSize(SparseMatrix self, int const i) -> int""" return _sparsemat.SparseMatrix_RowSize(self, i) + RowSize = _swig_new_instance_method(_sparsemat.SparseMatrix_RowSize) def MaxRowSize(self): r"""MaxRowSize(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_MaxRowSize(self) + MaxRowSize = _swig_new_instance_method(_sparsemat.SparseMatrix_MaxRowSize) def GetRowColumns(self, *args): r""" @@ -196,6 +326,7 @@ def GetRowColumns(self, *args): GetRowColumns(SparseMatrix self, int const row) -> int const * """ return _sparsemat.SparseMatrix_GetRowColumns(self, *args) + GetRowColumns = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowColumns) def GetRowEntries(self, *args): r""" @@ -203,22 +334,27 @@ def GetRowEntries(self, *args): GetRowEntries(SparseMatrix self, int const row) -> double const * """ return _sparsemat.SparseMatrix_GetRowEntries(self, *args) + GetRowEntries = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowEntries) def SetWidth(self, width_=-1): r"""SetWidth(SparseMatrix self, int width_=-1)""" return _sparsemat.SparseMatrix_SetWidth(self, width_) + SetWidth = _swig_new_instance_method(_sparsemat.SparseMatrix_SetWidth) def ActualWidth(self): r"""ActualWidth(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_ActualWidth(self) + ActualWidth = _swig_new_instance_method(_sparsemat.SparseMatrix_ActualWidth) def SortColumnIndices(self): r"""SortColumnIndices(SparseMatrix self)""" return _sparsemat.SparseMatrix_SortColumnIndices(self) + SortColumnIndices = _swig_new_instance_method(_sparsemat.SparseMatrix_SortColumnIndices) def MoveDiagonalFirst(self): r"""MoveDiagonalFirst(SparseMatrix self)""" return _sparsemat.SparseMatrix_MoveDiagonalFirst(self) + MoveDiagonalFirst = _swig_new_instance_method(_sparsemat.SparseMatrix_MoveDiagonalFirst) def Elem(self, *args): r""" @@ -226,6 +362,7 @@ def Elem(self, *args): Elem(SparseMatrix self, int i, int j) -> double const & """ return _sparsemat.SparseMatrix_Elem(self, *args) + Elem = _swig_new_instance_method(_sparsemat.SparseMatrix_Elem) def __call__(self, *args): r""" @@ -233,10 +370,12 @@ def __call__(self, *args): __call__(SparseMatrix self, int i, int j) -> double const & """ return _sparsemat.SparseMatrix___call__(self, *args) + __call__ = _swig_new_instance_method(_sparsemat.SparseMatrix___call__) def GetDiag(self, d): r"""GetDiag(SparseMatrix self, Vector d)""" return _sparsemat.SparseMatrix_GetDiag(self, d) + GetDiag = _swig_new_instance_method(_sparsemat.SparseMatrix_GetDiag) def ToDenseMatrix(self, *args): r""" @@ -244,66 +383,82 @@ def ToDenseMatrix(self, *args): ToDenseMatrix(SparseMatrix self, DenseMatrix B) """ return _sparsemat.SparseMatrix_ToDenseMatrix(self, *args) + ToDenseMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_ToDenseMatrix) def GetMemoryClass(self): r"""GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass""" return _sparsemat.SparseMatrix_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryClass) def Mult(self, x, y): r"""Mult(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_Mult(self, x, y) + Mult = _swig_new_instance_method(_sparsemat.SparseMatrix_Mult) def AddMult(self, x, y, a=1.0): r"""AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)""" return _sparsemat.SparseMatrix_AddMult(self, x, y, a) + AddMult = _swig_new_instance_method(_sparsemat.SparseMatrix_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_MultTranspose) def AddMultTranspose(self, x, y, a=1.0): r"""AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)""" return _sparsemat.SparseMatrix_AddMultTranspose(self, x, y, a) + AddMultTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_AddMultTranspose) def BuildTranspose(self): r"""BuildTranspose(SparseMatrix self)""" return _sparsemat.SparseMatrix_BuildTranspose(self) + BuildTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_BuildTranspose) def ResetTranspose(self): r"""ResetTranspose(SparseMatrix self)""" return _sparsemat.SparseMatrix_ResetTranspose(self) + ResetTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_ResetTranspose) def PartMult(self, rows, x, y): r"""PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)""" return _sparsemat.SparseMatrix_PartMult(self, rows, x, y) + PartMult = _swig_new_instance_method(_sparsemat.SparseMatrix_PartMult) def PartAddMult(self, rows, x, y, a=1.0): r"""PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)""" return _sparsemat.SparseMatrix_PartAddMult(self, rows, x, y, a) + PartAddMult = _swig_new_instance_method(_sparsemat.SparseMatrix_PartAddMult) def BooleanMult(self, x, y): r"""BooleanMult(SparseMatrix self, intArray x, intArray y)""" return _sparsemat.SparseMatrix_BooleanMult(self, x, y) + BooleanMult = _swig_new_instance_method(_sparsemat.SparseMatrix_BooleanMult) def BooleanMultTranspose(self, x, y): r"""BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)""" return _sparsemat.SparseMatrix_BooleanMultTranspose(self, x, y) + BooleanMultTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_BooleanMultTranspose) def InnerProduct(self, x, y): r"""InnerProduct(SparseMatrix self, Vector x, Vector y) -> double""" return _sparsemat.SparseMatrix_InnerProduct(self, x, y) + InnerProduct = _swig_new_instance_method(_sparsemat.SparseMatrix_InnerProduct) def GetRowSums(self, x): r"""GetRowSums(SparseMatrix self, Vector x)""" return _sparsemat.SparseMatrix_GetRowSums(self, x) + GetRowSums = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowSums) def GetRowNorml1(self, irow): r"""GetRowNorml1(SparseMatrix self, int irow) -> double""" return _sparsemat.SparseMatrix_GetRowNorml1(self, irow) + GetRowNorml1 = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowNorml1) def Inverse(self): r"""Inverse(SparseMatrix self) -> MatrixInverse""" return _sparsemat.SparseMatrix_Inverse(self) + Inverse = _swig_new_instance_method(_sparsemat.SparseMatrix_Inverse) def EliminateRow(self, *args): r""" @@ -311,22 +466,30 @@ def EliminateRow(self, *args): EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO) """ return _sparsemat.SparseMatrix_EliminateRow(self, *args) + EliminateRow = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRow) def EliminateCol(self, *args): r"""EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)""" return _sparsemat.SparseMatrix_EliminateCol(self, *args) + EliminateCol = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCol) - def EliminateCols(self, cols, x=None, b=None): - r"""EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)""" - return _sparsemat.SparseMatrix_EliminateCols(self, cols, x, b) + def EliminateCols(self, *args): + r""" + EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None) + EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae) + """ + return _sparsemat.SparseMatrix_EliminateCols(self, *args) + EliminateCols = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCols) def EliminateRowColMultipleRHS(self, *args): r"""EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)""" return _sparsemat.SparseMatrix_EliminateRowColMultipleRHS(self, *args) + EliminateRowColMultipleRHS = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowColMultipleRHS) def EliminateRowColDiag(self, rc, value): r"""EliminateRowColDiag(SparseMatrix self, int rc, double value)""" return _sparsemat.SparseMatrix_EliminateRowColDiag(self, rc, value) + EliminateRowColDiag = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowColDiag) def EliminateRowCol(self, *args): r""" @@ -335,42 +498,52 @@ def EliminateRowCol(self, *args): EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _sparsemat.SparseMatrix_EliminateRowCol(self, *args) + EliminateRowCol = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowCol) def SetDiagIdentity(self): r"""SetDiagIdentity(SparseMatrix self)""" return _sparsemat.SparseMatrix_SetDiagIdentity(self) + SetDiagIdentity = _swig_new_instance_method(_sparsemat.SparseMatrix_SetDiagIdentity) def EliminateZeroRows(self, threshold=1e-12): r"""EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)""" return _sparsemat.SparseMatrix_EliminateZeroRows(self, threshold) + EliminateZeroRows = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateZeroRows) def Gauss_Seidel_forw(self, x, y): r"""Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_Gauss_Seidel_forw(self, x, y) + Gauss_Seidel_forw = _swig_new_instance_method(_sparsemat.SparseMatrix_Gauss_Seidel_forw) def Gauss_Seidel_back(self, x, y): r"""Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_Gauss_Seidel_back(self, x, y) + Gauss_Seidel_back = _swig_new_instance_method(_sparsemat.SparseMatrix_Gauss_Seidel_back) def GetJacobiScaling(self): r"""GetJacobiScaling(SparseMatrix self) -> double""" return _sparsemat.SparseMatrix_GetJacobiScaling(self) + GetJacobiScaling = _swig_new_instance_method(_sparsemat.SparseMatrix_GetJacobiScaling) def Jacobi(self, b, x0, x1, sc): r"""Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)""" return _sparsemat.SparseMatrix_Jacobi(self, b, x0, x1, sc) + Jacobi = _swig_new_instance_method(_sparsemat.SparseMatrix_Jacobi) def DiagScale(self, b, x, sc=1.0): r"""DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)""" return _sparsemat.SparseMatrix_DiagScale(self, b, x, sc) + DiagScale = _swig_new_instance_method(_sparsemat.SparseMatrix_DiagScale) def Jacobi2(self, b, x0, x1, sc=1.0): r"""Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)""" return _sparsemat.SparseMatrix_Jacobi2(self, b, x0, x1, sc) + Jacobi2 = _swig_new_instance_method(_sparsemat.SparseMatrix_Jacobi2) def Jacobi3(self, b, x0, x1, sc=1.0): r"""Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)""" return _sparsemat.SparseMatrix_Jacobi3(self, b, x0, x1, sc) + Jacobi3 = _swig_new_instance_method(_sparsemat.SparseMatrix_Jacobi3) def Finalize(self, *args): r""" @@ -378,38 +551,47 @@ def Finalize(self, *args): Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows) """ return _sparsemat.SparseMatrix_Finalize(self, *args) + Finalize = _swig_new_instance_method(_sparsemat.SparseMatrix_Finalize) def Finalized(self): r"""Finalized(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_Finalized(self) + Finalized = _swig_new_instance_method(_sparsemat.SparseMatrix_Finalized) - def areColumnsSorted(self): - r"""areColumnsSorted(SparseMatrix self) -> bool""" - return _sparsemat.SparseMatrix_areColumnsSorted(self) + def ColumnsAreSorted(self): + r"""ColumnsAreSorted(SparseMatrix self) -> bool""" + return _sparsemat.SparseMatrix_ColumnsAreSorted(self) + ColumnsAreSorted = _swig_new_instance_method(_sparsemat.SparseMatrix_ColumnsAreSorted) def Threshold(self, tol, fix_empty_rows=False): r"""Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)""" return _sparsemat.SparseMatrix_Threshold(self, tol, fix_empty_rows) + Threshold = _swig_new_instance_method(_sparsemat.SparseMatrix_Threshold) def GetBlocks(self, blocks): r"""GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)""" return _sparsemat.SparseMatrix_GetBlocks(self, blocks) + GetBlocks = _swig_new_instance_method(_sparsemat.SparseMatrix_GetBlocks) def GetSubMatrix(self, rows, cols, subm): r"""GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)""" return _sparsemat.SparseMatrix_GetSubMatrix(self, rows, cols, subm) + GetSubMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_GetSubMatrix) def SetColPtr(self, row): r"""SetColPtr(SparseMatrix self, int const row)""" return _sparsemat.SparseMatrix_SetColPtr(self, row) + SetColPtr = _swig_new_instance_method(_sparsemat.SparseMatrix_SetColPtr) def ClearColPtr(self): r"""ClearColPtr(SparseMatrix self)""" return _sparsemat.SparseMatrix_ClearColPtr(self) + ClearColPtr = _swig_new_instance_method(_sparsemat.SparseMatrix_ClearColPtr) def _Get_(self, col): r"""_Get_(SparseMatrix self, int const col) -> double""" return _sparsemat.SparseMatrix__Get_(self, col) + _Get_ = _swig_new_instance_method(_sparsemat.SparseMatrix__Get_) def SearchRow(self, *args): r""" @@ -417,6 +599,7 @@ def SearchRow(self, *args): SearchRow(SparseMatrix self, int const row, int const col) -> double & """ return _sparsemat.SparseMatrix_SearchRow(self, *args) + SearchRow = _swig_new_instance_method(_sparsemat.SparseMatrix_SearchRow) def _Add_(self, *args): r""" @@ -424,6 +607,7 @@ def _Add_(self, *args): _Add_(SparseMatrix self, int const row, int const col, double const a) """ return _sparsemat.SparseMatrix__Add_(self, *args) + _Add_ = _swig_new_instance_method(_sparsemat.SparseMatrix__Add_) def _Set_(self, *args): r""" @@ -431,50 +615,62 @@ def _Set_(self, *args): _Set_(SparseMatrix self, int const row, int const col, double const a) """ return _sparsemat.SparseMatrix__Set_(self, *args) + _Set_ = _swig_new_instance_method(_sparsemat.SparseMatrix__Set_) def Set(self, i, j, a): r"""Set(SparseMatrix self, int const i, int const j, double const a)""" return _sparsemat.SparseMatrix_Set(self, i, j, a) + Set = _swig_new_instance_method(_sparsemat.SparseMatrix_Set) def SetSubMatrix(self, rows, cols, subm, skip_zeros=1): r"""SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)""" return _sparsemat.SparseMatrix_SetSubMatrix(self, rows, cols, subm, skip_zeros) + SetSubMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_SetSubMatrix) def SetSubMatrixTranspose(self, rows, cols, subm, skip_zeros=1): r"""SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)""" return _sparsemat.SparseMatrix_SetSubMatrixTranspose(self, rows, cols, subm, skip_zeros) + SetSubMatrixTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_SetSubMatrixTranspose) def AddSubMatrix(self, rows, cols, subm, skip_zeros=1): r"""AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)""" return _sparsemat.SparseMatrix_AddSubMatrix(self, rows, cols, subm, skip_zeros) + AddSubMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_AddSubMatrix) def RowIsEmpty(self, row): r"""RowIsEmpty(SparseMatrix self, int const row) -> bool""" return _sparsemat.SparseMatrix_RowIsEmpty(self, row) + RowIsEmpty = _swig_new_instance_method(_sparsemat.SparseMatrix_RowIsEmpty) def GetRow(self, row, cols, srow): r"""GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int""" return _sparsemat.SparseMatrix_GetRow(self, row, cols, srow) + GetRow = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRow) def SetRow(self, row, cols, srow): r"""SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)""" return _sparsemat.SparseMatrix_SetRow(self, row, cols, srow) + SetRow = _swig_new_instance_method(_sparsemat.SparseMatrix_SetRow) def AddRow(self, row, cols, srow): r"""AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)""" return _sparsemat.SparseMatrix_AddRow(self, row, cols, srow) + AddRow = _swig_new_instance_method(_sparsemat.SparseMatrix_AddRow) def ScaleRow(self, row, scale): r"""ScaleRow(SparseMatrix self, int const row, double const scale)""" return _sparsemat.SparseMatrix_ScaleRow(self, row, scale) + ScaleRow = _swig_new_instance_method(_sparsemat.SparseMatrix_ScaleRow) def ScaleRows(self, sl): r"""ScaleRows(SparseMatrix self, Vector sl)""" return _sparsemat.SparseMatrix_ScaleRows(self, sl) + ScaleRows = _swig_new_instance_method(_sparsemat.SparseMatrix_ScaleRows) def ScaleColumns(self, sr): r"""ScaleColumns(SparseMatrix self, Vector sr)""" return _sparsemat.SparseMatrix_ScaleColumns(self, sr) + ScaleColumns = _swig_new_instance_method(_sparsemat.SparseMatrix_ScaleColumns) def __iadd__(self, B): r"""__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix""" @@ -493,6 +689,7 @@ def Add(self, *args): Add(SparseMatrix self, double const a, SparseMatrix B) """ return _sparsemat.SparseMatrix_Add(self, *args) + Add = _swig_new_instance_method(_sparsemat.SparseMatrix_Add) def __imul__(self, a): r"""__imul__(SparseMatrix self, double a) -> SparseMatrix""" @@ -508,67 +705,83 @@ def __imul__(self, a): def IsSymmetric(self): r"""IsSymmetric(SparseMatrix self) -> double""" return _sparsemat.SparseMatrix_IsSymmetric(self) + IsSymmetric = _swig_new_instance_method(_sparsemat.SparseMatrix_IsSymmetric) def Symmetrize(self): r"""Symmetrize(SparseMatrix self)""" return _sparsemat.SparseMatrix_Symmetrize(self) + Symmetrize = _swig_new_instance_method(_sparsemat.SparseMatrix_Symmetrize) def NumNonZeroElems(self): r"""NumNonZeroElems(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_NumNonZeroElems(self) + NumNonZeroElems = _swig_new_instance_method(_sparsemat.SparseMatrix_NumNonZeroElems) def MaxNorm(self): r"""MaxNorm(SparseMatrix self) -> double""" return _sparsemat.SparseMatrix_MaxNorm(self) + MaxNorm = _swig_new_instance_method(_sparsemat.SparseMatrix_MaxNorm) def CountSmallElems(self, tol): r"""CountSmallElems(SparseMatrix self, double tol) -> int""" return _sparsemat.SparseMatrix_CountSmallElems(self, tol) + CountSmallElems = _swig_new_instance_method(_sparsemat.SparseMatrix_CountSmallElems) def CheckFinite(self): r"""CheckFinite(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_CheckFinite(self) + CheckFinite = _swig_new_instance_method(_sparsemat.SparseMatrix_CheckFinite) def SetGraphOwner(self, ownij): r"""SetGraphOwner(SparseMatrix self, bool ownij)""" return _sparsemat.SparseMatrix_SetGraphOwner(self, ownij) + SetGraphOwner = _swig_new_instance_method(_sparsemat.SparseMatrix_SetGraphOwner) def SetDataOwner(self, owna): r"""SetDataOwner(SparseMatrix self, bool owna)""" return _sparsemat.SparseMatrix_SetDataOwner(self, owna) + SetDataOwner = _swig_new_instance_method(_sparsemat.SparseMatrix_SetDataOwner) def OwnsGraph(self): r"""OwnsGraph(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_OwnsGraph(self) + OwnsGraph = _swig_new_instance_method(_sparsemat.SparseMatrix_OwnsGraph) def OwnsData(self): r"""OwnsData(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_OwnsData(self) + OwnsData = _swig_new_instance_method(_sparsemat.SparseMatrix_OwnsData) def LoseData(self): r"""LoseData(SparseMatrix self)""" return _sparsemat.SparseMatrix_LoseData(self) + LoseData = _swig_new_instance_method(_sparsemat.SparseMatrix_LoseData) def Swap(self, other): r"""Swap(SparseMatrix self, SparseMatrix other)""" return _sparsemat.SparseMatrix_Swap(self, other) + Swap = _swig_new_instance_method(_sparsemat.SparseMatrix_Swap) __swig_destroy__ = _sparsemat.delete_SparseMatrix def GetType(self): r"""GetType(SparseMatrix self) -> mfem::Operator::Type""" return _sparsemat.SparseMatrix_GetType(self) + GetType = _swig_new_instance_method(_sparsemat.SparseMatrix_GetType) def GetIArray(self): r"""GetIArray(SparseMatrix self) -> PyObject *""" return _sparsemat.SparseMatrix_GetIArray(self) + GetIArray = _swig_new_instance_method(_sparsemat.SparseMatrix_GetIArray) def GetJArray(self): r"""GetJArray(SparseMatrix self) -> PyObject *""" return _sparsemat.SparseMatrix_GetJArray(self) + GetJArray = _swig_new_instance_method(_sparsemat.SparseMatrix_GetJArray) def GetDataArray(self): r"""GetDataArray(SparseMatrix self) -> PyObject *""" return _sparsemat.SparseMatrix_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_sparsemat.SparseMatrix_GetDataArray) def Print(self, *args): r""" @@ -576,6 +789,7 @@ def Print(self, *args): Print(SparseMatrix self, char const * file, int precision=8) """ return _sparsemat.SparseMatrix_Print(self, *args) + Print = _swig_new_instance_method(_sparsemat.SparseMatrix_Print) def PrintMatlab(self, *args): r""" @@ -583,6 +797,7 @@ def PrintMatlab(self, *args): PrintMatlab(SparseMatrix self, char const * file, int precision=8) """ return _sparsemat.SparseMatrix_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintMatlab) def PrintMM(self, *args): r""" @@ -590,6 +805,7 @@ def PrintMM(self, *args): PrintMM(SparseMatrix self, char const * file, int precision=8) """ return _sparsemat.SparseMatrix_PrintMM(self, *args) + PrintMM = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintMM) def PrintCSR(self, *args): r""" @@ -598,6 +814,7 @@ def PrintCSR(self, *args): PrintCSR(SparseMatrix self) """ return _sparsemat.SparseMatrix_PrintCSR(self, *args) + PrintCSR = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintCSR) def PrintCSR2(self, *args): r""" @@ -606,6 +823,7 @@ def PrintCSR2(self, *args): PrintCSR2(SparseMatrix self) """ return _sparsemat.SparseMatrix_PrintCSR2(self, *args) + PrintCSR2 = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintCSR2) def PrintInfo(self, *args): r""" @@ -614,6 +832,7 @@ def PrintInfo(self, *args): PrintInfo(SparseMatrix self) """ return _sparsemat.SparseMatrix_PrintInfo(self, *args) + PrintInfo = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintInfo) # Register SparseMatrix in _sparsemat: _sparsemat.SparseMatrix_swigregister(SparseMatrix) @@ -622,22 +841,27 @@ def PrintInfo(self, *args): def SparseMatrixFunction(S, f): r"""SparseMatrixFunction(SparseMatrix S, double (*)(double) f)""" return _sparsemat.SparseMatrixFunction(S, f) +SparseMatrixFunction = _sparsemat.SparseMatrixFunction def TransposeAbstractSparseMatrix(A, useActualWidth): r"""TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix""" return _sparsemat.TransposeAbstractSparseMatrix(A, useActualWidth) +TransposeAbstractSparseMatrix = _sparsemat.TransposeAbstractSparseMatrix def TransposeMult(A, B): r"""TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix""" return _sparsemat.TransposeMult(A, B) +TransposeMult = _sparsemat.TransposeMult def MultAbstractSparseMatrix(A, B): r"""MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix""" return _sparsemat.MultAbstractSparseMatrix(A, B) +MultAbstractSparseMatrix = _sparsemat.MultAbstractSparseMatrix def Mult_AtDA(A, D, OAtDA=None): r"""Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix""" return _sparsemat.Mult_AtDA(A, D, OAtDA) +Mult_AtDA = _sparsemat.Mult_AtDA def OuterProduct(*args): r""" @@ -647,5 +871,6 @@ def OuterProduct(*args): OuterProduct(SparseMatrix A, SparseMatrix B) -> SparseMatrix """ return _sparsemat.OuterProduct(*args) +OuterProduct = _sparsemat.OuterProduct diff --git a/mfem/_par/sparsemat_wrap.cxx b/mfem/_par/sparsemat_wrap.cxx index 640d081d..9c53ac93 100644 --- a/mfem/_par/sparsemat_wrap.cxx +++ b/mfem/_par/sparsemat_wrap.cxx @@ -3079,23 +3079,28 @@ namespace Swig { #define SWIGTYPE_p_mfem__IdentityOperator swig_types[11] #define SWIGTYPE_p_mfem__Matrix swig_types[12] #define SWIGTYPE_p_mfem__MatrixInverse swig_types[13] -#define SWIGTYPE_p_mfem__Operator swig_types[14] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[15] -#define SWIGTYPE_p_mfem__OperatorPtr swig_types[16] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[17] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[18] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[19] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[20] -#define SWIGTYPE_p_mfem__RowNode swig_types[21] -#define SWIGTYPE_p_mfem__Solver swig_types[22] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[23] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[24] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[25] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[26] -#define SWIGTYPE_p_mfem__Vector swig_types[27] -#define SWIGTYPE_p_void swig_types[28] -static swig_type_info *swig_types[30]; -static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__MemoryT_double_t swig_types[14] +#define SWIGTYPE_p_mfem__MemoryT_int_t swig_types[15] +#define SWIGTYPE_p_mfem__Operator swig_types[16] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[17] +#define SWIGTYPE_p_mfem__OperatorPtr swig_types[18] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[19] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[20] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[21] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[22] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[23] +#define SWIGTYPE_p_mfem__RowNode swig_types[24] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[25] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[26] +#define SWIGTYPE_p_mfem__Solver swig_types[27] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[28] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[29] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[30] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[31] +#define SWIGTYPE_p_mfem__Vector swig_types[32] +#define SWIGTYPE_p_void swig_types[33] +static swig_type_info *swig_types[35]; +static swig_module_info swig_module = {swig_types, 34, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5129,6 +5134,1671 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetData(PyObject *self, PyObject *args) } +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &(arg1)->GetMemoryI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryI", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryI__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryI__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::GetMemoryI()\n" + " mfem::SparseMatrix::GetMemoryI() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadI", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadI__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadI__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadI(bool) const\n" + " mfem::SparseMatrix::ReadI() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->WriteI(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->WriteI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteI", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_WriteI__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_WriteI__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::WriteI(bool)\n" + " mfem::SparseMatrix::WriteI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->ReadWriteI(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->ReadWriteI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteI", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadWriteI__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadWriteI__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadWriteI(bool)\n" + " mfem::SparseMatrix::ReadWriteI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostWriteI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostReadWriteI(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &(arg1)->GetMemoryJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryJ", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryJ__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryJ__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::GetMemoryJ()\n" + " mfem::SparseMatrix::GetMemoryJ() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadJ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadJ__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadJ__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadJ(bool) const\n" + " mfem::SparseMatrix::ReadJ() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->WriteJ(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->WriteJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteJ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_WriteJ__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_WriteJ__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::WriteJ(bool)\n" + " mfem::SparseMatrix::WriteJ()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->ReadWriteJ(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->ReadWriteJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteJ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadWriteJ__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadWriteJ__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadWriteJ(bool)\n" + " mfem::SparseMatrix::ReadWriteJ()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostWriteJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostReadWriteJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &(arg1)->GetMemoryData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryData", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryData__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryData__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::GetMemoryData()\n" + " mfem::SparseMatrix::GetMemoryData() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadData", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadData__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadData__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadData(bool) const\n" + " mfem::SparseMatrix::ReadData() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)(arg1)->WriteData(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->WriteData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteData", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_WriteData__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_WriteData__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::WriteData(bool)\n" + " mfem::SparseMatrix::WriteData()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)(arg1)->ReadWriteData(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->ReadWriteData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteData", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadWriteData__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadWriteData__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadWriteData(bool)\n" + " mfem::SparseMatrix::ReadWriteData()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)((mfem::SparseMatrix const *)arg1)->HostReadData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->HostWriteData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->HostReadWriteData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_SparseMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; @@ -7859,6 +9529,60 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_2(PyObject *SWIGUNUS } +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::SparseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + { + try { + (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { @@ -7898,6 +9622,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * } } } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_EliminateCols__SWIG_3(self, argc, argv); + } + } + } + } if (argc == 4) { int _v; void *vptr = 0; @@ -7927,7 +9669,8 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *,mfem::Vector *)\n" " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *)\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &)\n"); + " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &)\n" + " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::SparseMatrix &)\n"); return 0; } @@ -9874,7 +11617,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalized(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SparseMatrix_areColumnsSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ColumnsAreSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -9886,12 +11629,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_areColumnsSorted(PyObject *SWIGUNUSEDPAR swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_areColumnsSorted" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ColumnsAreSorted" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (bool)((mfem::SparseMatrix const *)arg1)->areColumnsSorted(); + result = (bool)((mfem::SparseMatrix const *)arg1)->ColumnsAreSorted(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15030,6 +16773,7 @@ SWIGINTERN PyObject *_wrap_OuterProduct(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, @@ -15069,6 +16813,36 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetData(SparseMatrix self) -> double\n" "SparseMatrix_GetData(SparseMatrix self) -> double const *\n" ""}, + { "SparseMatrix_GetMemoryI", _wrap_SparseMatrix_GetMemoryI, METH_VARARGS, "\n" + "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" + "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "SparseMatrix_ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "SparseMatrix_WriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "SparseMatrix_ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "SparseMatrix_HostReadI(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "SparseMatrix_HostWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "SparseMatrix_HostReadWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryJ", _wrap_SparseMatrix_GetMemoryJ, METH_VARARGS, "\n" + "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" + "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "SparseMatrix_ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "SparseMatrix_WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "SparseMatrix_ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "SparseMatrix_HostReadJ(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "SparseMatrix_HostWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "SparseMatrix_HostReadWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryData", _wrap_SparseMatrix_GetMemoryData, METH_VARARGS, "\n" + "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" + "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" + ""}, + { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "SparseMatrix_ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, + { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "SparseMatrix_WriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "SparseMatrix_ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "SparseMatrix_HostReadData(SparseMatrix self) -> double const *"}, + { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "SparseMatrix_HostWriteData(SparseMatrix self) -> double *"}, + { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "SparseMatrix_HostReadWriteData(SparseMatrix self) -> double *"}, { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "SparseMatrix_RowSize(SparseMatrix self, int const i) -> int"}, { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "SparseMatrix_MaxRowSize(SparseMatrix self) -> int"}, { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" @@ -15116,7 +16890,10 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" ""}, { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "SparseMatrix_EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, - { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "SparseMatrix_EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)"}, + { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" + "SparseMatrix_EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" + "SparseMatrix_EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" + ""}, { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "SparseMatrix_EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "SparseMatrix_EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" @@ -15138,7 +16915,7 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" ""}, { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "SparseMatrix_Finalized(SparseMatrix self) -> bool"}, - { "SparseMatrix_areColumnsSorted", _wrap_SparseMatrix_areColumnsSorted, METH_O, "SparseMatrix_areColumnsSorted(SparseMatrix self) -> bool"}, + { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "SparseMatrix_ColumnsAreSorted(SparseMatrix self) -> bool"}, { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "SparseMatrix_Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "SparseMatrix_GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "SparseMatrix_GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, @@ -15235,6 +17012,242 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, + { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, + { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, + { "OperatorHandle2SparseMatrix", _wrap_OperatorHandle2SparseMatrix, METH_O, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, + { "RowNode_Value_set", _wrap_RowNode_Value_set, METH_VARARGS, "RowNode_Value_set(RowNode self, double Value)"}, + { "RowNode_Value_get", _wrap_RowNode_Value_get, METH_O, "RowNode_Value_get(RowNode self) -> double"}, + { "RowNode_Prev_set", _wrap_RowNode_Prev_set, METH_VARARGS, "RowNode_Prev_set(RowNode self, RowNode Prev)"}, + { "RowNode_Prev_get", _wrap_RowNode_Prev_get, METH_O, "RowNode_Prev_get(RowNode self) -> RowNode"}, + { "RowNode_Column_set", _wrap_RowNode_Column_set, METH_VARARGS, "RowNode_Column_set(RowNode self, int Column)"}, + { "RowNode_Column_get", _wrap_RowNode_Column_get, METH_O, "RowNode_Column_get(RowNode self) -> int"}, + { "new_RowNode", _wrap_new_RowNode, METH_NOARGS, "new_RowNode() -> RowNode"}, + { "delete_RowNode", _wrap_delete_RowNode, METH_O, "delete_RowNode(RowNode self)"}, + { "RowNode_swigregister", RowNode_swigregister, METH_O, NULL}, + { "RowNode_swiginit", RowNode_swiginit, METH_VARARGS, NULL}, + { "new_SparseMatrix", _wrap_new_SparseMatrix, METH_VARARGS, "\n" + "SparseMatrix()\n" + "SparseMatrix(int nrows, int ncols=-1)\n" + "SparseMatrix(int * i)\n" + "SparseMatrix(int * i, bool ownij, bool owna, bool issorted)\n" + "SparseMatrix(int nrows, int ncols, int rowsize)\n" + "SparseMatrix(SparseMatrix mat, bool copy_graph=True)\n" + "new_SparseMatrix(Vector v) -> SparseMatrix\n" + ""}, + { "SparseMatrix_MakeRef", _wrap_SparseMatrix_MakeRef, METH_VARARGS, "MakeRef(SparseMatrix self, SparseMatrix master)"}, + { "SparseMatrix_Size", _wrap_SparseMatrix_Size, METH_O, "Size(SparseMatrix self) -> int"}, + { "SparseMatrix_Clear", _wrap_SparseMatrix_Clear, METH_O, "Clear(SparseMatrix self)"}, + { "SparseMatrix_Empty", _wrap_SparseMatrix_Empty, METH_O, "Empty(SparseMatrix self) -> bool"}, + { "SparseMatrix_GetI", _wrap_SparseMatrix_GetI, METH_VARARGS, "\n" + "GetI(SparseMatrix self) -> int\n" + "GetI(SparseMatrix self) -> int const *\n" + ""}, + { "SparseMatrix_GetJ", _wrap_SparseMatrix_GetJ, METH_VARARGS, "\n" + "GetJ(SparseMatrix self) -> int\n" + "GetJ(SparseMatrix self) -> int const *\n" + ""}, + { "SparseMatrix_GetData", _wrap_SparseMatrix_GetData, METH_VARARGS, "\n" + "GetData(SparseMatrix self) -> double\n" + "GetData(SparseMatrix self) -> double const *\n" + ""}, + { "SparseMatrix_GetMemoryI", _wrap_SparseMatrix_GetMemoryI, METH_VARARGS, "\n" + "GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" + "GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "WriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "HostReadI(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "HostWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "HostReadWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryJ", _wrap_SparseMatrix_GetMemoryJ, METH_VARARGS, "\n" + "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" + "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "HostReadJ(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "HostWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "HostReadWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryData", _wrap_SparseMatrix_GetMemoryData, METH_VARARGS, "\n" + "GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" + "GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" + ""}, + { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, + { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "WriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "HostReadData(SparseMatrix self) -> double const *"}, + { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "HostWriteData(SparseMatrix self) -> double *"}, + { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "HostReadWriteData(SparseMatrix self) -> double *"}, + { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "RowSize(SparseMatrix self, int const i) -> int"}, + { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "MaxRowSize(SparseMatrix self) -> int"}, + { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" + "GetRowColumns(SparseMatrix self, int const row) -> int\n" + "GetRowColumns(SparseMatrix self, int const row) -> int const *\n" + ""}, + { "SparseMatrix_GetRowEntries", _wrap_SparseMatrix_GetRowEntries, METH_VARARGS, "\n" + "GetRowEntries(SparseMatrix self, int const row) -> double\n" + "GetRowEntries(SparseMatrix self, int const row) -> double const *\n" + ""}, + { "SparseMatrix_SetWidth", _wrap_SparseMatrix_SetWidth, METH_VARARGS, "SetWidth(SparseMatrix self, int width_=-1)"}, + { "SparseMatrix_ActualWidth", _wrap_SparseMatrix_ActualWidth, METH_O, "ActualWidth(SparseMatrix self) -> int"}, + { "SparseMatrix_SortColumnIndices", _wrap_SparseMatrix_SortColumnIndices, METH_O, "SortColumnIndices(SparseMatrix self)"}, + { "SparseMatrix_MoveDiagonalFirst", _wrap_SparseMatrix_MoveDiagonalFirst, METH_O, "MoveDiagonalFirst(SparseMatrix self)"}, + { "SparseMatrix_Elem", _wrap_SparseMatrix_Elem, METH_VARARGS, "\n" + "Elem(SparseMatrix self, int i, int j) -> double\n" + "Elem(SparseMatrix self, int i, int j) -> double const &\n" + ""}, + { "SparseMatrix___call__", _wrap_SparseMatrix___call__, METH_VARARGS, "\n" + "__call__(SparseMatrix self, int i, int j) -> double\n" + "__call__(SparseMatrix self, int i, int j) -> double const &\n" + ""}, + { "SparseMatrix_GetDiag", _wrap_SparseMatrix_GetDiag, METH_VARARGS, "GetDiag(SparseMatrix self, Vector d)"}, + { "SparseMatrix_ToDenseMatrix", _wrap_SparseMatrix_ToDenseMatrix, METH_VARARGS, "\n" + "ToDenseMatrix(SparseMatrix self) -> DenseMatrix\n" + "ToDenseMatrix(SparseMatrix self, DenseMatrix B)\n" + ""}, + { "SparseMatrix_GetMemoryClass", _wrap_SparseMatrix_GetMemoryClass, METH_O, "GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass"}, + { "SparseMatrix_Mult", _wrap_SparseMatrix_Mult, METH_VARARGS, "Mult(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMult", _wrap_SparseMatrix_AddMult, METH_VARARGS, "AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_MultTranspose", _wrap_SparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMultTranspose", _wrap_SparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BuildTranspose", _wrap_SparseMatrix_BuildTranspose, METH_O, "BuildTranspose(SparseMatrix self)"}, + { "SparseMatrix_ResetTranspose", _wrap_SparseMatrix_ResetTranspose, METH_O, "ResetTranspose(SparseMatrix self)"}, + { "SparseMatrix_PartMult", _wrap_SparseMatrix_PartMult, METH_VARARGS, "PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, + { "SparseMatrix_PartAddMult", _wrap_SparseMatrix_PartAddMult, METH_VARARGS, "PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BooleanMult", _wrap_SparseMatrix_BooleanMult, METH_VARARGS, "BooleanMult(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_BooleanMultTranspose", _wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS, "BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_InnerProduct", _wrap_SparseMatrix_InnerProduct, METH_VARARGS, "InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, + { "SparseMatrix_GetRowSums", _wrap_SparseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(SparseMatrix self, Vector x)"}, + { "SparseMatrix_GetRowNorml1", _wrap_SparseMatrix_GetRowNorml1, METH_VARARGS, "GetRowNorml1(SparseMatrix self, int irow) -> double"}, + { "SparseMatrix_Inverse", _wrap_SparseMatrix_Inverse, METH_O, "Inverse(SparseMatrix self) -> MatrixInverse"}, + { "SparseMatrix_EliminateRow", _wrap_SparseMatrix_EliminateRow, METH_VARARGS, "\n" + "EliminateRow(SparseMatrix self, int row, double const sol, Vector rhs)\n" + "EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" + ""}, + { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, + { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" + "EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" + "EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" + ""}, + { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, + { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, + { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" + "EliminateRowCol(SparseMatrix self, int rc, double const sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateRowCol(SparseMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "SparseMatrix_SetDiagIdentity", _wrap_SparseMatrix_SetDiagIdentity, METH_O, "SetDiagIdentity(SparseMatrix self)"}, + { "SparseMatrix_EliminateZeroRows", _wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, + { "SparseMatrix_Gauss_Seidel_forw", _wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS, "Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_Gauss_Seidel_back", _wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS, "Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_GetJacobiScaling", _wrap_SparseMatrix_GetJacobiScaling, METH_O, "GetJacobiScaling(SparseMatrix self) -> double"}, + { "SparseMatrix_Jacobi", _wrap_SparseMatrix_Jacobi, METH_VARARGS, "Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, + { "SparseMatrix_DiagScale", _wrap_SparseMatrix_DiagScale, METH_VARARGS, "DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, + { "SparseMatrix_Jacobi2", _wrap_SparseMatrix_Jacobi2, METH_VARARGS, "Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi3", _wrap_SparseMatrix_Jacobi3, METH_VARARGS, "Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Finalize", _wrap_SparseMatrix_Finalize, METH_VARARGS, "\n" + "Finalize(SparseMatrix self, int skip_zeros=1)\n" + "Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" + ""}, + { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "Finalized(SparseMatrix self) -> bool"}, + { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "ColumnsAreSorted(SparseMatrix self) -> bool"}, + { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, + { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, + { "SparseMatrix_SetColPtr", _wrap_SparseMatrix_SetColPtr, METH_VARARGS, "SetColPtr(SparseMatrix self, int const row)"}, + { "SparseMatrix_ClearColPtr", _wrap_SparseMatrix_ClearColPtr, METH_O, "ClearColPtr(SparseMatrix self)"}, + { "SparseMatrix__Get_", _wrap_SparseMatrix__Get_, METH_VARARGS, "_Get_(SparseMatrix self, int const col) -> double"}, + { "SparseMatrix_SearchRow", _wrap_SparseMatrix_SearchRow, METH_VARARGS, "\n" + "SearchRow(SparseMatrix self, int const col) -> double\n" + "SearchRow(SparseMatrix self, int const row, int const col) -> double &\n" + ""}, + { "SparseMatrix__Add_", _wrap_SparseMatrix__Add_, METH_VARARGS, "\n" + "_Add_(SparseMatrix self, int const col, double const a)\n" + "_Add_(SparseMatrix self, int const row, int const col, double const a)\n" + ""}, + { "SparseMatrix__Set_", _wrap_SparseMatrix__Set_, METH_VARARGS, "\n" + "_Set_(SparseMatrix self, int const col, double const a)\n" + "_Set_(SparseMatrix self, int const row, int const col, double const a)\n" + ""}, + { "SparseMatrix_Set", _wrap_SparseMatrix_Set, METH_VARARGS, "Set(SparseMatrix self, int const i, int const j, double const a)"}, + { "SparseMatrix_SetSubMatrix", _wrap_SparseMatrix_SetSubMatrix, METH_VARARGS, "SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_SetSubMatrixTranspose", _wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS, "SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_AddSubMatrix", _wrap_SparseMatrix_AddSubMatrix, METH_VARARGS, "AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_RowIsEmpty", _wrap_SparseMatrix_RowIsEmpty, METH_VARARGS, "RowIsEmpty(SparseMatrix self, int const row) -> bool"}, + { "SparseMatrix_GetRow", _wrap_SparseMatrix_GetRow, METH_VARARGS, "GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "SparseMatrix_SetRow", _wrap_SparseMatrix_SetRow, METH_VARARGS, "SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_AddRow", _wrap_SparseMatrix_AddRow, METH_VARARGS, "AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_ScaleRow", _wrap_SparseMatrix_ScaleRow, METH_VARARGS, "ScaleRow(SparseMatrix self, int const row, double const scale)"}, + { "SparseMatrix_ScaleRows", _wrap_SparseMatrix_ScaleRows, METH_VARARGS, "ScaleRows(SparseMatrix self, Vector sl)"}, + { "SparseMatrix_ScaleColumns", _wrap_SparseMatrix_ScaleColumns, METH_VARARGS, "ScaleColumns(SparseMatrix self, Vector sr)"}, + { "SparseMatrix___iadd__", _wrap_SparseMatrix___iadd__, METH_VARARGS, "__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, + { "SparseMatrix_Add", _wrap_SparseMatrix_Add, METH_VARARGS, "\n" + "Add(SparseMatrix self, int const i, int const j, double const a)\n" + "Add(SparseMatrix self, double const a, SparseMatrix B)\n" + ""}, + { "SparseMatrix___imul__", _wrap_SparseMatrix___imul__, METH_VARARGS, "__imul__(SparseMatrix self, double a) -> SparseMatrix"}, + { "SparseMatrix_IsSymmetric", _wrap_SparseMatrix_IsSymmetric, METH_O, "IsSymmetric(SparseMatrix self) -> double"}, + { "SparseMatrix_Symmetrize", _wrap_SparseMatrix_Symmetrize, METH_O, "Symmetrize(SparseMatrix self)"}, + { "SparseMatrix_NumNonZeroElems", _wrap_SparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(SparseMatrix self) -> int"}, + { "SparseMatrix_MaxNorm", _wrap_SparseMatrix_MaxNorm, METH_O, "MaxNorm(SparseMatrix self) -> double"}, + { "SparseMatrix_CountSmallElems", _wrap_SparseMatrix_CountSmallElems, METH_VARARGS, "CountSmallElems(SparseMatrix self, double tol) -> int"}, + { "SparseMatrix_CheckFinite", _wrap_SparseMatrix_CheckFinite, METH_O, "CheckFinite(SparseMatrix self) -> int"}, + { "SparseMatrix_SetGraphOwner", _wrap_SparseMatrix_SetGraphOwner, METH_VARARGS, "SetGraphOwner(SparseMatrix self, bool ownij)"}, + { "SparseMatrix_SetDataOwner", _wrap_SparseMatrix_SetDataOwner, METH_VARARGS, "SetDataOwner(SparseMatrix self, bool owna)"}, + { "SparseMatrix_OwnsGraph", _wrap_SparseMatrix_OwnsGraph, METH_O, "OwnsGraph(SparseMatrix self) -> bool"}, + { "SparseMatrix_OwnsData", _wrap_SparseMatrix_OwnsData, METH_O, "OwnsData(SparseMatrix self) -> bool"}, + { "SparseMatrix_LoseData", _wrap_SparseMatrix_LoseData, METH_O, "LoseData(SparseMatrix self)"}, + { "SparseMatrix_Swap", _wrap_SparseMatrix_Swap, METH_VARARGS, "Swap(SparseMatrix self, SparseMatrix other)"}, + { "delete_SparseMatrix", _wrap_delete_SparseMatrix, METH_O, "delete_SparseMatrix(SparseMatrix self)"}, + { "SparseMatrix_GetType", _wrap_SparseMatrix_GetType, METH_O, "GetType(SparseMatrix self) -> mfem::Operator::Type"}, + { "SparseMatrix_GetIArray", _wrap_SparseMatrix_GetIArray, METH_O, "GetIArray(SparseMatrix self) -> PyObject *"}, + { "SparseMatrix_GetJArray", _wrap_SparseMatrix_GetJArray, METH_O, "GetJArray(SparseMatrix self) -> PyObject *"}, + { "SparseMatrix_GetDataArray", _wrap_SparseMatrix_GetDataArray, METH_O, "GetDataArray(SparseMatrix self) -> PyObject *"}, + { "SparseMatrix_Print", _wrap_SparseMatrix_Print, METH_VARARGS, "\n" + "Print(SparseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" + "Print(SparseMatrix self, char const * file, int precision=8)\n" + ""}, + { "SparseMatrix_PrintMatlab", _wrap_SparseMatrix_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(SparseMatrix self, std::ostream & out=mfem::out)\n" + "PrintMatlab(SparseMatrix self, char const * file, int precision=8)\n" + ""}, + { "SparseMatrix_PrintMM", _wrap_SparseMatrix_PrintMM, METH_VARARGS, "\n" + "PrintMM(SparseMatrix self, std::ostream & out=mfem::out)\n" + "PrintMM(SparseMatrix self, char const * file, int precision=8)\n" + ""}, + { "SparseMatrix_PrintCSR", _wrap_SparseMatrix_PrintCSR, METH_VARARGS, "\n" + "PrintCSR(SparseMatrix self, std::ostream & out)\n" + "PrintCSR(SparseMatrix self, char const * file, int precision=8)\n" + "PrintCSR(SparseMatrix self)\n" + ""}, + { "SparseMatrix_PrintCSR2", _wrap_SparseMatrix_PrintCSR2, METH_VARARGS, "\n" + "PrintCSR2(SparseMatrix self, std::ostream & out)\n" + "PrintCSR2(SparseMatrix self, char const * file, int precision=8)\n" + "PrintCSR2(SparseMatrix self)\n" + ""}, + { "SparseMatrix_PrintInfo", _wrap_SparseMatrix_PrintInfo, METH_VARARGS, "\n" + "PrintInfo(SparseMatrix self, std::ostream & out)\n" + "PrintInfo(SparseMatrix self, char const * file, int precision=8)\n" + "PrintInfo(SparseMatrix self)\n" + ""}, + { "SparseMatrix_swigregister", SparseMatrix_swigregister, METH_O, NULL}, + { "SparseMatrix_swiginit", SparseMatrix_swiginit, METH_VARARGS, NULL}, + { "SparseMatrixFunction", _wrap_SparseMatrixFunction, METH_VARARGS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, + { "TransposeAbstractSparseMatrix", _wrap_TransposeAbstractSparseMatrix, METH_VARARGS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, + { "TransposeMult", _wrap_TransposeMult, METH_VARARGS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, + { "MultAbstractSparseMatrix", _wrap_MultAbstractSparseMatrix, METH_VARARGS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, + { "Mult_AtDA", _wrap_Mult_AtDA, METH_VARARGS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, + { "OuterProduct", _wrap_OuterProduct, METH_VARARGS, "\n" + "OuterProduct(DenseMatrix A, DenseMatrix B) -> DenseMatrix\n" + "OuterProduct(DenseMatrix A, SparseMatrix B) -> SparseMatrix\n" + "OuterProduct(SparseMatrix A, DenseMatrix B) -> SparseMatrix\n" + "OuterProduct(SparseMatrix A, SparseMatrix B) -> SparseMatrix\n" + ""}, { NULL, NULL, 0, NULL } }; @@ -15271,18 +17284,21 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -15298,9 +17314,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -15316,16 +17338,21 @@ static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mf static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", "mfem::Matrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", "mfem::MatrixInverse *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MemoryT_double_t = {"_p_mfem__MemoryT_double_t", "mfem::Memory< double > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__MemoryT_int_t = {"_p_mfem__MemoryT_int_t", "mfem::Memory< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__OperatorPtr = {"_p_mfem__OperatorPtr", "mfem::OperatorPtr *", 0, 0, (void*)0, 0}; @@ -15349,6 +17376,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__Matrix, &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__MemoryT_double_t, + &_swigt__p_mfem__MemoryT_int_t, &_swigt__p_mfem__Operator, &_swigt__p_mfem__OperatorHandle, &_swigt__p_mfem__OperatorPtr, @@ -15356,7 +17385,10 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__RowNode, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -15378,17 +17410,22 @@ static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__Dense static swig_cast_info _swigc__p_mfem__Matrix[] = { {&_swigt__p_mfem__Matrix, 0, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Matrix, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Matrix, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Matrix, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__MatrixInverse, 0, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__MatrixInverse, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MemoryT_double_t[] = { {&_swigt__p_mfem__MemoryT_double_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MemoryT_int_t[] = { {&_swigt__p_mfem__MemoryT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorPtr[] = { {&_swigt__p_mfem__OperatorPtr, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RowNode[] = { {&_swigt__p_mfem__RowNode, 0, 0, 0},{0, 0, 0, 0}}; @@ -15411,6 +17448,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__Matrix, _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__MemoryT_double_t, + _swigc__p_mfem__MemoryT_int_t, _swigc__p_mfem__Operator, _swigc__p_mfem__OperatorHandle, _swigc__p_mfem__OperatorPtr, @@ -15418,7 +17457,10 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__RowNode, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_par/sparsesmoothers.py b/mfem/_par/sparsesmoothers.py index 388b5dbc..6c2ec3ad 100644 --- a/mfem/_par/sparsesmoothers.py +++ b/mfem/_par/sparsesmoothers.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _sparsesmoothers.SWIG_PyInstanceMethod_New +_swig_new_static_method = _sparsesmoothers.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,6 +85,7 @@ def __init__(self, *args, **kwargs): def SetOperator(self, a): r"""SetOperator(SparseSmoother self, Operator a)""" return _sparsesmoothers.SparseSmoother_SetOperator(self, a) + SetOperator = _swig_new_instance_method(_sparsesmoothers.SparseSmoother_SetOperator) __swig_destroy__ = _sparsesmoothers.delete_SparseSmoother # Register SparseSmoother in _sparsesmoothers: @@ -103,6 +107,7 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(GSSmoother self, Vector x, Vector y)""" return _sparsesmoothers.GSSmoother_Mult(self, x, y) + Mult = _swig_new_instance_method(_sparsesmoothers.GSSmoother_Mult) __swig_destroy__ = _sparsesmoothers.delete_GSSmoother # Register GSSmoother in _sparsesmoothers: @@ -124,6 +129,7 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(DSmoother self, Vector x, Vector y)""" return _sparsesmoothers.DSmoother_Mult(self, x, y) + Mult = _swig_new_instance_method(_sparsesmoothers.DSmoother_Mult) __swig_destroy__ = _sparsesmoothers.delete_DSmoother # Register DSmoother in _sparsesmoothers: diff --git a/mfem/_par/sparsesmoothers_wrap.cxx b/mfem/_par/sparsesmoothers_wrap.cxx index 53e707ba..7cd99343 100644 --- a/mfem/_par/sparsesmoothers_wrap.cxx +++ b/mfem/_par/sparsesmoothers_wrap.cxx @@ -3081,15 +3081,18 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[13] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[14] #define SWIGTYPE_p_mfem__RAPOperator swig_types[15] -#define SWIGTYPE_p_mfem__Solver swig_types[16] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[17] -#define SWIGTYPE_p_mfem__SparseSmoother swig_types[18] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[19] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[20] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[21] -#define SWIGTYPE_p_mfem__Vector swig_types[22] -static swig_type_info *swig_types[24]; -static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[16] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[17] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[18] +#define SWIGTYPE_p_mfem__Solver swig_types[19] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[20] +#define SWIGTYPE_p_mfem__SparseSmoother swig_types[21] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[22] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[23] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[24] +#define SWIGTYPE_p_mfem__Vector swig_types[25] +static swig_type_info *swig_types[27]; +static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4390,6 +4393,7 @@ SWIGINTERN PyObject *DSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SparseSmoother_SetOperator(SparseSmoother self, Operator a)"}, { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, @@ -4413,6 +4417,27 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SetOperator(SparseSmoother self, Operator a)"}, + { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, + { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, + { "new_GSSmoother", _wrap_new_GSSmoother, METH_VARARGS, "\n" + "GSSmoother(int t=0, int it=1)\n" + "GSSmoother(SparseMatrix a, int t=0, int it=1)\n" + ""}, + { "GSSmoother_Mult", _wrap_GSSmoother_Mult, METH_VARARGS, "Mult(GSSmoother self, Vector x, Vector y)"}, + { "delete_GSSmoother", _wrap_delete_GSSmoother, METH_O, "delete_GSSmoother(GSSmoother self)"}, + { "GSSmoother_swigregister", GSSmoother_swigregister, METH_O, NULL}, + { "GSSmoother_swiginit", GSSmoother_swiginit, METH_VARARGS, NULL}, + { "new_DSmoother", _wrap_new_DSmoother, METH_VARARGS, "\n" + "DSmoother(int t=0, double s=1., int it=1)\n" + "DSmoother(SparseMatrix a, int t=0, double s=1., int it=1)\n" + ""}, + { "DSmoother_Mult", _wrap_DSmoother_Mult, METH_VARARGS, "Mult(DSmoother self, Vector x, Vector y)"}, + { "delete_DSmoother", _wrap_delete_DSmoother, METH_O, "delete_DSmoother(DSmoother self)"}, + { "DSmoother_swigregister", DSmoother_swigregister, METH_O, NULL}, + { "DSmoother_swiginit", DSmoother_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4455,18 +4480,21 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -4482,9 +4510,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -4518,15 +4552,18 @@ static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatri static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; @@ -4550,6 +4587,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__SparseSmoother, @@ -4567,17 +4607,20 @@ static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__MatrixInverse, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__MatrixInverse, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__MatrixInverse, 0, 0}, {&_swigt__p_mfem__MatrixInverse, 0, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__MatrixInverse, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseSmoother[] = { {&_swigt__p_mfem__SparseSmoother, 0, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__SparseSmoother, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__SparseSmoother, 0, 0},{0, 0, 0, 0}}; @@ -4600,6 +4643,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__SparseSmoother, diff --git a/mfem/_par/stable3d.py b/mfem/_par/stable3d.py index 51d0827b..548166db 100644 --- a/mfem/_par/stable3d.py +++ b/mfem/_par/stable3d.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _stable3d.SWIG_PyInstanceMethod_New +_swig_new_static_method = _stable3d.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -105,14 +108,17 @@ def __init__(self, nr): def Push(self, r, c, f): r"""Push(STable3D self, int r, int c, int f) -> int""" return _stable3d.STable3D_Push(self, r, c, f) + Push = _swig_new_instance_method(_stable3d.STable3D_Push) def Index(self, r, c, f): r"""Index(STable3D self, int r, int c, int f) -> int""" return _stable3d.STable3D_Index(self, r, c, f) + Index = _swig_new_instance_method(_stable3d.STable3D_Index) def Push4(self, r, c, f, t): r"""Push4(STable3D self, int r, int c, int f, int t) -> int""" return _stable3d.STable3D_Push4(self, r, c, f, t) + Push4 = _swig_new_instance_method(_stable3d.STable3D_Push4) def __call__(self, *args): r""" @@ -120,10 +126,12 @@ def __call__(self, *args): __call__(STable3D self, int r, int c, int f, int t) -> int """ return _stable3d.STable3D___call__(self, *args) + __call__ = _swig_new_instance_method(_stable3d.STable3D___call__) def NumberOfElements(self): r"""NumberOfElements(STable3D self) -> int""" return _stable3d.STable3D_NumberOfElements(self) + NumberOfElements = _swig_new_instance_method(_stable3d.STable3D_NumberOfElements) __swig_destroy__ = _stable3d.delete_STable3D def Print(self, *args): @@ -132,6 +140,7 @@ def Print(self, *args): Print(STable3D self, char const * file, int precision=8) """ return _stable3d.STable3D_Print(self, *args) + Print = _swig_new_instance_method(_stable3d.STable3D_Print) # Register STable3D in _stable3d: _stable3d.STable3D_swigregister(STable3D) diff --git a/mfem/_par/stable3d_wrap.cxx b/mfem/_par/stable3d_wrap.cxx index d8afc868..72c2ca0b 100644 --- a/mfem/_par/stable3d_wrap.cxx +++ b/mfem/_par/stable3d_wrap.cxx @@ -4386,6 +4386,7 @@ SWIGINTERN PyObject *STable3D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "STable3DNode_Prev_set", _wrap_STable3DNode_Prev_set, METH_VARARGS, "STable3DNode_Prev_set(STable3DNode self, STable3DNode Prev)"}, { "STable3DNode_Prev_get", _wrap_STable3DNode_Prev_get, METH_O, "STable3DNode_Prev_get(STable3DNode self) -> STable3DNode"}, { "STable3DNode_Column_set", _wrap_STable3DNode_Column_set, METH_VARARGS, "STable3DNode_Column_set(STable3DNode self, int Column)"}, @@ -4418,6 +4419,36 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "STable3DNode_Prev_set", _wrap_STable3DNode_Prev_set, METH_VARARGS, "STable3DNode_Prev_set(STable3DNode self, STable3DNode Prev)"}, + { "STable3DNode_Prev_get", _wrap_STable3DNode_Prev_get, METH_O, "STable3DNode_Prev_get(STable3DNode self) -> STable3DNode"}, + { "STable3DNode_Column_set", _wrap_STable3DNode_Column_set, METH_VARARGS, "STable3DNode_Column_set(STable3DNode self, int Column)"}, + { "STable3DNode_Column_get", _wrap_STable3DNode_Column_get, METH_O, "STable3DNode_Column_get(STable3DNode self) -> int"}, + { "STable3DNode_Floor_set", _wrap_STable3DNode_Floor_set, METH_VARARGS, "STable3DNode_Floor_set(STable3DNode self, int Floor)"}, + { "STable3DNode_Floor_get", _wrap_STable3DNode_Floor_get, METH_O, "STable3DNode_Floor_get(STable3DNode self) -> int"}, + { "STable3DNode_Number_set", _wrap_STable3DNode_Number_set, METH_VARARGS, "STable3DNode_Number_set(STable3DNode self, int Number)"}, + { "STable3DNode_Number_get", _wrap_STable3DNode_Number_get, METH_O, "STable3DNode_Number_get(STable3DNode self) -> int"}, + { "new_STable3DNode", _wrap_new_STable3DNode, METH_NOARGS, "new_STable3DNode() -> STable3DNode"}, + { "delete_STable3DNode", _wrap_delete_STable3DNode, METH_O, "delete_STable3DNode(STable3DNode self)"}, + { "STable3DNode_swigregister", STable3DNode_swigregister, METH_O, NULL}, + { "STable3DNode_swiginit", STable3DNode_swiginit, METH_VARARGS, NULL}, + { "new_STable3D", _wrap_new_STable3D, METH_O, "new_STable3D(int nr) -> STable3D"}, + { "STable3D_Push", _wrap_STable3D_Push, METH_VARARGS, "Push(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Index", _wrap_STable3D_Index, METH_VARARGS, "Index(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Push4", _wrap_STable3D_Push4, METH_VARARGS, "Push4(STable3D self, int r, int c, int f, int t) -> int"}, + { "STable3D___call__", _wrap_STable3D___call__, METH_VARARGS, "\n" + "__call__(STable3D self, int r, int c, int f) -> int\n" + "__call__(STable3D self, int r, int c, int f, int t) -> int\n" + ""}, + { "STable3D_NumberOfElements", _wrap_STable3D_NumberOfElements, METH_O, "NumberOfElements(STable3D self) -> int"}, + { "delete_STable3D", _wrap_delete_STable3D, METH_O, "delete_STable3D(STable3D self)"}, + { "STable3D_Print", _wrap_STable3D_Print, METH_VARARGS, "\n" + "Print(STable3D self, std::ostream & out=mfem::out)\n" + "Print(STable3D self, char const * file, int precision=8)\n" + ""}, + { "STable3D_swigregister", STable3D_swigregister, METH_O, NULL}, + { "STable3D_swiginit", STable3D_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/table.py b/mfem/_par/table.py index 77b4662d..26e02417 100644 --- a/mfem/_par/table.py +++ b/mfem/_par/table.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _table.SWIG_PyInstanceMethod_New +_swig_new_static_method = _table.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -81,10 +84,12 @@ def __init__(self, *args): def __eq__(self, rhs): r"""__eq__(Connection self, Connection rhs) -> bool""" return _table.Connection___eq__(self, rhs) + __eq__ = _swig_new_instance_method(_table.Connection___eq__) def __lt__(self, rhs): r"""__lt__(Connection self, Connection rhs) -> bool""" return _table.Connection___lt__(self, rhs) + __lt__ = _swig_new_instance_method(_table.Connection___lt__) __swig_destroy__ = _table.delete_Connection # Register Connection in _table: @@ -109,54 +114,67 @@ def __init__(self, *args): def MakeI(self, nrows): r"""MakeI(Table self, int nrows)""" return _table.Table_MakeI(self, nrows) + MakeI = _swig_new_instance_method(_table.Table_MakeI) def AddAColumnInRow(self, r): r"""AddAColumnInRow(Table self, int r)""" return _table.Table_AddAColumnInRow(self, r) + AddAColumnInRow = _swig_new_instance_method(_table.Table_AddAColumnInRow) def AddColumnsInRow(self, r, ncol): r"""AddColumnsInRow(Table self, int r, int ncol)""" return _table.Table_AddColumnsInRow(self, r, ncol) + AddColumnsInRow = _swig_new_instance_method(_table.Table_AddColumnsInRow) def MakeJ(self): r"""MakeJ(Table self)""" return _table.Table_MakeJ(self) + MakeJ = _swig_new_instance_method(_table.Table_MakeJ) def AddConnection(self, r, c): r"""AddConnection(Table self, int r, int c)""" return _table.Table_AddConnection(self, r, c) + AddConnection = _swig_new_instance_method(_table.Table_AddConnection) def AddConnections(self, r, c, nc): r"""AddConnections(Table self, int r, int const * c, int nc)""" return _table.Table_AddConnections(self, r, c, nc) + AddConnections = _swig_new_instance_method(_table.Table_AddConnections) def ShiftUpI(self): r"""ShiftUpI(Table self)""" return _table.Table_ShiftUpI(self) + ShiftUpI = _swig_new_instance_method(_table.Table_ShiftUpI) def SetSize(self, dim, connections_per_row): r"""SetSize(Table self, int dim, int connections_per_row)""" return _table.Table_SetSize(self, dim, connections_per_row) + SetSize = _swig_new_instance_method(_table.Table_SetSize) def SetDims(self, rows, nnz): r"""SetDims(Table self, int rows, int nnz)""" return _table.Table_SetDims(self, rows, nnz) + SetDims = _swig_new_instance_method(_table.Table_SetDims) def Size(self): r"""Size(Table self) -> int""" return _table.Table_Size(self) + Size = _swig_new_instance_method(_table.Table_Size) def Size_of_connections(self): r"""Size_of_connections(Table self) -> int""" return _table.Table_Size_of_connections(self) + Size_of_connections = _swig_new_instance_method(_table.Table_Size_of_connections) def __call__(self, i, j): r"""__call__(Table self, int i, int j) -> int""" return _table.Table___call__(self, i, j) + __call__ = _swig_new_instance_method(_table.Table___call__) def RowSize(self, i): r"""RowSize(Table self, int i) -> int""" return _table.Table_RowSize(self, i) + RowSize = _swig_new_instance_method(_table.Table_RowSize) def GetRow(self, *args): r""" @@ -165,6 +183,7 @@ def GetRow(self, *args): GetRow(Table self, int i) -> int * """ return _table.Table_GetRow(self, *args) + GetRow = _swig_new_instance_method(_table.Table_GetRow) def GetI(self, *args): r""" @@ -172,6 +191,7 @@ def GetI(self, *args): GetI(Table self) -> int const * """ return _table.Table_GetI(self, *args) + GetI = _swig_new_instance_method(_table.Table_GetI) def GetJ(self, *args): r""" @@ -179,6 +199,7 @@ def GetJ(self, *args): GetJ(Table self) -> int const * """ return _table.Table_GetJ(self, *args) + GetJ = _swig_new_instance_method(_table.Table_GetJ) def GetIMemory(self, *args): r""" @@ -186,6 +207,7 @@ def GetIMemory(self, *args): GetIMemory(Table self) -> mfem::Memory< int > const & """ return _table.Table_GetIMemory(self, *args) + GetIMemory = _swig_new_instance_method(_table.Table_GetIMemory) def GetJMemory(self, *args): r""" @@ -193,59 +215,73 @@ def GetJMemory(self, *args): GetJMemory(Table self) -> mfem::Memory< int > const & """ return _table.Table_GetJMemory(self, *args) + GetJMemory = _swig_new_instance_method(_table.Table_GetJMemory) def SortRows(self): r"""SortRows(Table self)""" return _table.Table_SortRows(self) + SortRows = _swig_new_instance_method(_table.Table_SortRows) def SetIJ(self, newI, newJ, newsize=-1): r"""SetIJ(Table self, int * newI, int * newJ, int newsize=-1)""" return _table.Table_SetIJ(self, newI, newJ, newsize) + SetIJ = _swig_new_instance_method(_table.Table_SetIJ) def Push(self, i, j): r"""Push(Table self, int i, int j) -> int""" return _table.Table_Push(self, i, j) + Push = _swig_new_instance_method(_table.Table_Push) def Finalize(self): r"""Finalize(Table self)""" return _table.Table_Finalize(self) + Finalize = _swig_new_instance_method(_table.Table_Finalize) def MakeFromList(self, nrows, list): r"""MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)""" return _table.Table_MakeFromList(self, nrows, list) + MakeFromList = _swig_new_instance_method(_table.Table_MakeFromList) def Width(self): r"""Width(Table self) -> int""" return _table.Table_Width(self) + Width = _swig_new_instance_method(_table.Table_Width) def LoseData(self): r"""LoseData(Table self)""" return _table.Table_LoseData(self) + LoseData = _swig_new_instance_method(_table.Table_LoseData) def Load(self, _in): r"""Load(Table self, std::istream & _in)""" return _table.Table_Load(self, _in) + Load = _swig_new_instance_method(_table.Table_Load) def Copy(self, copy): r"""Copy(Table self, Table copy)""" return _table.Table_Copy(self, copy) + Copy = _swig_new_instance_method(_table.Table_Copy) def Swap(self, other): r"""Swap(Table self, Table other)""" return _table.Table_Swap(self, other) + Swap = _swig_new_instance_method(_table.Table_Swap) def Clear(self): r"""Clear(Table self)""" return _table.Table_Clear(self) + Clear = _swig_new_instance_method(_table.Table_Clear) def MemoryUsage(self): r"""MemoryUsage(Table self) -> long""" return _table.Table_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_table.Table_MemoryUsage) __swig_destroy__ = _table.delete_Table def GetRowList(self, i): r"""GetRowList(Table self, int i) -> PyObject *""" return _table.Table_GetRowList(self, i) + GetRowList = _swig_new_instance_method(_table.Table_GetRowList) def Print(self, *args): r""" @@ -253,6 +289,7 @@ def Print(self, *args): Print(Table self, char const * file, int precision=8) """ return _table.Table_Print(self, *args) + Print = _swig_new_instance_method(_table.Table_Print) def PrintMatlab(self, *args): r""" @@ -260,6 +297,7 @@ def PrintMatlab(self, *args): PrintMatlab(Table self, char const * file, int precision=8) """ return _table.Table_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_table.Table_PrintMatlab) def Save(self, *args): r""" @@ -268,6 +306,7 @@ def Save(self, *args): Save(Table self) """ return _table.Table_Save(self, *args) + Save = _swig_new_instance_method(_table.Table_Save) # Register Table in _table: _table.Table_swigregister(Table) @@ -285,10 +324,12 @@ def __init__(self, dim, connections_per_row=3): def __call__(self, i, j): r"""__call__(STable self, int i, int j) -> int""" return _table.STable___call__(self, i, j) + __call__ = _swig_new_instance_method(_table.STable___call__) def Push(self, i, j): r"""Push(STable self, int i, int j) -> int""" return _table.STable_Push(self, i, j) + Push = _swig_new_instance_method(_table.STable_Push) __swig_destroy__ = _table.delete_STable # Register STable in _table: @@ -307,18 +348,22 @@ def __init__(self, nrows): def NumberOfRows(self): r"""NumberOfRows(DSTable self) -> int""" return _table.DSTable_NumberOfRows(self) + NumberOfRows = _swig_new_instance_method(_table.DSTable_NumberOfRows) def NumberOfEntries(self): r"""NumberOfEntries(DSTable self) -> int""" return _table.DSTable_NumberOfEntries(self) + NumberOfEntries = _swig_new_instance_method(_table.DSTable_NumberOfEntries) def Push(self, a, b): r"""Push(DSTable self, int a, int b) -> int""" return _table.DSTable_Push(self, a, b) + Push = _swig_new_instance_method(_table.DSTable_Push) def __call__(self, a, b): r"""__call__(DSTable self, int a, int b) -> int""" return _table.DSTable___call__(self, a, b) + __call__ = _swig_new_instance_method(_table.DSTable___call__) __swig_destroy__ = _table.delete_DSTable # Register DSTable in _table: diff --git a/mfem/_par/table_wrap.cxx b/mfem/_par/table_wrap.cxx index 9cf663e8..f7eba450 100644 --- a/mfem/_par/table_wrap.cxx +++ b/mfem/_par/table_wrap.cxx @@ -7108,6 +7108,7 @@ SWIGINTERN PyObject *DSTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Connection__from_set", _wrap_Connection__from_set, METH_VARARGS, "Connection__from_set(Connection self, int _from)"}, { "Connection__from_get", _wrap_Connection__from_get, METH_O, "Connection__from_get(Connection self) -> int"}, { "Connection_to_set", _wrap_Connection_to_set, METH_VARARGS, "Connection_to_set(Connection self, int to)"}, @@ -7209,6 +7210,105 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Connection__from_set", _wrap_Connection__from_set, METH_VARARGS, "Connection__from_set(Connection self, int _from)"}, + { "Connection__from_get", _wrap_Connection__from_get, METH_O, "Connection__from_get(Connection self) -> int"}, + { "Connection_to_set", _wrap_Connection_to_set, METH_VARARGS, "Connection_to_set(Connection self, int to)"}, + { "Connection_to_get", _wrap_Connection_to_get, METH_O, "Connection_to_get(Connection self) -> int"}, + { "new_Connection", _wrap_new_Connection, METH_VARARGS, "\n" + "Connection()\n" + "new_Connection(int _from, int to) -> Connection\n" + ""}, + { "Connection___eq__", _wrap_Connection___eq__, METH_VARARGS, "__eq__(Connection self, Connection rhs) -> bool"}, + { "Connection___lt__", _wrap_Connection___lt__, METH_VARARGS, "__lt__(Connection self, Connection rhs) -> bool"}, + { "delete_Connection", _wrap_delete_Connection, METH_O, "delete_Connection(Connection self)"}, + { "Connection_swigregister", Connection_swigregister, METH_O, NULL}, + { "Connection_swiginit", Connection_swiginit, METH_VARARGS, NULL}, + { "new_Table", _wrap_new_Table, METH_VARARGS, "\n" + "Table()\n" + "Table(Table arg1)\n" + "Table(int dim, int connections_per_row=3)\n" + "Table(int nrows, mfem::Array< mfem::Connection > & list)\n" + "new_Table(int nrows, int * partitioning) -> Table\n" + ""}, + { "Table_MakeI", _wrap_Table_MakeI, METH_VARARGS, "MakeI(Table self, int nrows)"}, + { "Table_AddAColumnInRow", _wrap_Table_AddAColumnInRow, METH_VARARGS, "AddAColumnInRow(Table self, int r)"}, + { "Table_AddColumnsInRow", _wrap_Table_AddColumnsInRow, METH_VARARGS, "AddColumnsInRow(Table self, int r, int ncol)"}, + { "Table_MakeJ", _wrap_Table_MakeJ, METH_O, "MakeJ(Table self)"}, + { "Table_AddConnection", _wrap_Table_AddConnection, METH_VARARGS, "AddConnection(Table self, int r, int c)"}, + { "Table_AddConnections", _wrap_Table_AddConnections, METH_VARARGS, "AddConnections(Table self, int r, int const * c, int nc)"}, + { "Table_ShiftUpI", _wrap_Table_ShiftUpI, METH_O, "ShiftUpI(Table self)"}, + { "Table_SetSize", _wrap_Table_SetSize, METH_VARARGS, "SetSize(Table self, int dim, int connections_per_row)"}, + { "Table_SetDims", _wrap_Table_SetDims, METH_VARARGS, "SetDims(Table self, int rows, int nnz)"}, + { "Table_Size", _wrap_Table_Size, METH_O, "Size(Table self) -> int"}, + { "Table_Size_of_connections", _wrap_Table_Size_of_connections, METH_O, "Size_of_connections(Table self) -> int"}, + { "Table___call__", _wrap_Table___call__, METH_VARARGS, "__call__(Table self, int i, int j) -> int"}, + { "Table_RowSize", _wrap_Table_RowSize, METH_VARARGS, "RowSize(Table self, int i) -> int"}, + { "Table_GetRow", _wrap_Table_GetRow, METH_VARARGS, "\n" + "GetRow(Table self, int i, intArray row)\n" + "GetRow(Table self, int i) -> int const\n" + "GetRow(Table self, int i) -> int *\n" + ""}, + { "Table_GetI", _wrap_Table_GetI, METH_VARARGS, "\n" + "GetI(Table self) -> int\n" + "GetI(Table self) -> int const *\n" + ""}, + { "Table_GetJ", _wrap_Table_GetJ, METH_VARARGS, "\n" + "GetJ(Table self) -> int\n" + "GetJ(Table self) -> int const *\n" + ""}, + { "Table_GetIMemory", _wrap_Table_GetIMemory, METH_VARARGS, "\n" + "GetIMemory(Table self) -> mfem::Memory< int >\n" + "GetIMemory(Table self) -> mfem::Memory< int > const &\n" + ""}, + { "Table_GetJMemory", _wrap_Table_GetJMemory, METH_VARARGS, "\n" + "GetJMemory(Table self) -> mfem::Memory< int >\n" + "GetJMemory(Table self) -> mfem::Memory< int > const &\n" + ""}, + { "Table_SortRows", _wrap_Table_SortRows, METH_O, "SortRows(Table self)"}, + { "Table_SetIJ", _wrap_Table_SetIJ, METH_VARARGS, "SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, + { "Table_Push", _wrap_Table_Push, METH_VARARGS, "Push(Table self, int i, int j) -> int"}, + { "Table_Finalize", _wrap_Table_Finalize, METH_O, "Finalize(Table self)"}, + { "Table_MakeFromList", _wrap_Table_MakeFromList, METH_VARARGS, "MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, + { "Table_Width", _wrap_Table_Width, METH_O, "Width(Table self) -> int"}, + { "Table_LoseData", _wrap_Table_LoseData, METH_O, "LoseData(Table self)"}, + { "Table_Load", _wrap_Table_Load, METH_VARARGS, "Load(Table self, std::istream & _in)"}, + { "Table_Copy", _wrap_Table_Copy, METH_VARARGS, "Copy(Table self, Table copy)"}, + { "Table_Swap", _wrap_Table_Swap, METH_VARARGS, "Swap(Table self, Table other)"}, + { "Table_Clear", _wrap_Table_Clear, METH_O, "Clear(Table self)"}, + { "Table_MemoryUsage", _wrap_Table_MemoryUsage, METH_O, "MemoryUsage(Table self) -> long"}, + { "delete_Table", _wrap_delete_Table, METH_O, "delete_Table(Table self)"}, + { "Table_GetRowList", _wrap_Table_GetRowList, METH_VARARGS, "GetRowList(Table self, int i) -> PyObject *"}, + { "Table_Print", _wrap_Table_Print, METH_VARARGS, "\n" + "Print(Table self, std::ostream & out=mfem::out, int width=4)\n" + "Print(Table self, char const * file, int precision=8)\n" + ""}, + { "Table_PrintMatlab", _wrap_Table_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(Table self, std::ostream & out)\n" + "PrintMatlab(Table self, char const * file, int precision=8)\n" + ""}, + { "Table_Save", _wrap_Table_Save, METH_VARARGS, "\n" + "Save(Table self, std::ostream & out)\n" + "Save(Table self, char const * file, int precision=8)\n" + "Save(Table self)\n" + ""}, + { "Table_swigregister", Table_swigregister, METH_O, NULL}, + { "Table_swiginit", Table_swiginit, METH_VARARGS, NULL}, + { "new_STable", _wrap_new_STable, METH_VARARGS, "STable(int dim, int connections_per_row=3)"}, + { "STable___call__", _wrap_STable___call__, METH_VARARGS, "__call__(STable self, int i, int j) -> int"}, + { "STable_Push", _wrap_STable_Push, METH_VARARGS, "Push(STable self, int i, int j) -> int"}, + { "delete_STable", _wrap_delete_STable, METH_O, "delete_STable(STable self)"}, + { "STable_swigregister", STable_swigregister, METH_O, NULL}, + { "STable_swiginit", STable_swiginit, METH_VARARGS, NULL}, + { "new_DSTable", _wrap_new_DSTable, METH_O, "new_DSTable(int nrows) -> DSTable"}, + { "DSTable_NumberOfRows", _wrap_DSTable_NumberOfRows, METH_O, "NumberOfRows(DSTable self) -> int"}, + { "DSTable_NumberOfEntries", _wrap_DSTable_NumberOfEntries, METH_O, "NumberOfEntries(DSTable self) -> int"}, + { "DSTable_Push", _wrap_DSTable_Push, METH_VARARGS, "Push(DSTable self, int a, int b) -> int"}, + { "DSTable___call__", _wrap_DSTable___call__, METH_VARARGS, "__call__(DSTable self, int a, int b) -> int"}, + { "delete_DSTable", _wrap_delete_DSTable, METH_O, "delete_DSTable(DSTable self)"}, + { "DSTable_swigregister", DSTable_swigregister, METH_O, NULL}, + { "DSTable_swiginit", DSTable_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/vector.py b/mfem/_par/vector.py index 5bb6b348..14057254 100644 --- a/mfem/_par/vector.py +++ b/mfem/_par/vector.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _vector.SWIG_PyInstanceMethod_New +_swig_new_static_method = _vector.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -72,6 +75,7 @@ def add_vector(*args): add_vector(double const a, Vector x, double const b, Vector y, Vector z) """ return _vector.add_vector(*args) +add_vector = _vector.add_vector def subtract_vector(*args): r""" @@ -79,14 +83,17 @@ def subtract_vector(*args): subtract_vector(double const a, Vector x, Vector y, Vector z) """ return _vector.subtract_vector(*args) +subtract_vector = _vector.subtract_vector def CheckFinite(v, n): r"""CheckFinite(double const * v, int const n) -> int""" return _vector.CheckFinite(v, n) +CheckFinite = _vector.CheckFinite def infinity(): r"""infinity() -> double""" return _vector.infinity() +infinity = _vector.infinity class Vector(object): r"""Proxy of C++ mfem::Vector class.""" @@ -99,6 +106,7 @@ def UseDevice(self, *args): UseDevice(Vector self) -> bool """ return _vector.Vector_UseDevice(self, *args) + UseDevice = _swig_new_instance_method(_vector.Vector_UseDevice) def Load(self, *args): r""" @@ -107,6 +115,7 @@ def Load(self, *args): Load(Vector self, std::istream & _in) """ return _vector.Vector_Load(self, *args) + Load = _swig_new_instance_method(_vector.Vector_Load) def SetSize(self, *args): r""" @@ -115,42 +124,60 @@ def SetSize(self, *args): SetSize(Vector self, int s, Vector v) """ return _vector.Vector_SetSize(self, *args) + SetSize = _swig_new_instance_method(_vector.Vector_SetSize) def SetData(self, d): r"""SetData(Vector self, double * d)""" return _vector.Vector_SetData(self, d) + SetData = _swig_new_instance_method(_vector.Vector_SetData) def SetDataAndSize(self, d, s): r"""SetDataAndSize(Vector self, double * d, int s)""" return _vector.Vector_SetDataAndSize(self, d, s) + SetDataAndSize = _swig_new_instance_method(_vector.Vector_SetDataAndSize) def NewDataAndSize(self, d, s): r"""NewDataAndSize(Vector self, double * d, int s)""" return _vector.Vector_NewDataAndSize(self, d, s) + NewDataAndSize = _swig_new_instance_method(_vector.Vector_NewDataAndSize) def NewMemoryAndSize(self, mem, s, own_mem): r"""NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)""" return _vector.Vector_NewMemoryAndSize(self, mem, s, own_mem) + NewMemoryAndSize = _swig_new_instance_method(_vector.Vector_NewMemoryAndSize) + + def MakeRef(self, *args): + r""" + MakeRef(Vector self, Vector base, int offset, int size) + MakeRef(Vector self, Vector base, int offset) + """ + return _vector.Vector_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_vector.Vector_MakeRef) def MakeDataOwner(self): r"""MakeDataOwner(Vector self)""" return _vector.Vector_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_vector.Vector_MakeDataOwner) def Destroy(self): r"""Destroy(Vector self)""" return _vector.Vector_Destroy(self) + Destroy = _swig_new_instance_method(_vector.Vector_Destroy) def Size(self): r"""Size(Vector self) -> int""" return _vector.Vector_Size(self) + Size = _swig_new_instance_method(_vector.Vector_Size) def Capacity(self): r"""Capacity(Vector self) -> int""" return _vector.Vector_Capacity(self) + Capacity = _swig_new_instance_method(_vector.Vector_Capacity) def GetData(self): r"""GetData(Vector self) -> double *""" return _vector.Vector_GetData(self) + GetData = _swig_new_instance_method(_vector.Vector_GetData) def GetMemory(self, *args): r""" @@ -158,18 +185,22 @@ def GetMemory(self, *args): GetMemory(Vector self) -> mfem::Memory< double > const & """ return _vector.Vector_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_vector.Vector_GetMemory) def SyncMemory(self, v): r"""SyncMemory(Vector self, Vector v)""" return _vector.Vector_SyncMemory(self, v) + SyncMemory = _swig_new_instance_method(_vector.Vector_SyncMemory) def SyncAliasMemory(self, v): r"""SyncAliasMemory(Vector self, Vector v)""" return _vector.Vector_SyncAliasMemory(self, v) + SyncAliasMemory = _swig_new_instance_method(_vector.Vector_SyncAliasMemory) def OwnsData(self): r"""OwnsData(Vector self) -> bool""" return _vector.Vector_OwnsData(self) + OwnsData = _swig_new_instance_method(_vector.Vector_OwnsData) def StealData(self, *args): r""" @@ -177,6 +208,7 @@ def StealData(self, *args): StealData(Vector self) -> double * """ return _vector.Vector_StealData(self, *args) + StealData = _swig_new_instance_method(_vector.Vector_StealData) def Elem(self, *args): r""" @@ -184,6 +216,7 @@ def Elem(self, *args): Elem(Vector self, int i) -> double const & """ return _vector.Vector_Elem(self, *args) + Elem = _swig_new_instance_method(_vector.Vector_Elem) def __call__(self, *args): r""" @@ -191,6 +224,7 @@ def __call__(self, *args): __call__(Vector self, int i) -> double const & """ return _vector.Vector___call__(self, *args) + __call__ = _swig_new_instance_method(_vector.Vector___call__) def __mul__(self, *args): r""" @@ -198,6 +232,7 @@ def __mul__(self, *args): __mul__(Vector self, Vector v) -> double """ return _vector.Vector___mul__(self, *args) + __mul__ = _swig_new_instance_method(_vector.Vector___mul__) def __imul__(self, v): ret = _vector.Vector___imul__(self, v) @@ -234,26 +269,32 @@ def __iadd__(self, v): def Add(self, a, Va): r"""Add(Vector self, double const a, Vector Va) -> Vector""" return _vector.Vector_Add(self, a, Va) + Add = _swig_new_instance_method(_vector.Vector_Add) def Set(self, a, x): r"""Set(Vector self, double const a, Vector x) -> Vector""" return _vector.Vector_Set(self, a, x) + Set = _swig_new_instance_method(_vector.Vector_Set) def SetVector(self, v, offset): r"""SetVector(Vector self, Vector v, int offset)""" return _vector.Vector_SetVector(self, v, offset) + SetVector = _swig_new_instance_method(_vector.Vector_SetVector) def Neg(self): r"""Neg(Vector self)""" return _vector.Vector_Neg(self) + Neg = _swig_new_instance_method(_vector.Vector_Neg) def Swap(self, other): r"""Swap(Vector self, Vector other)""" return _vector.Vector_Swap(self, other) + Swap = _swig_new_instance_method(_vector.Vector_Swap) def median(self, lo, hi): r"""median(Vector self, Vector lo, Vector hi)""" return _vector.Vector_median(self, lo, hi) + median = _swig_new_instance_method(_vector.Vector_median) def GetSubVector(self, *args): r""" @@ -261,6 +302,7 @@ def GetSubVector(self, *args): GetSubVector(Vector self, intArray dofs, double * elem_data) """ return _vector.Vector_GetSubVector(self, *args) + GetSubVector = _swig_new_instance_method(_vector.Vector_GetSubVector) def SetSubVector(self, *args): r""" @@ -269,6 +311,7 @@ def SetSubVector(self, *args): SetSubVector(Vector self, intArray dofs, double * elem_data) """ return _vector.Vector_SetSubVector(self, *args) + SetSubVector = _swig_new_instance_method(_vector.Vector_SetSubVector) def AddElementVector(self, *args): r""" @@ -277,79 +320,98 @@ def AddElementVector(self, *args): AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect) """ return _vector.Vector_AddElementVector(self, *args) + AddElementVector = _swig_new_instance_method(_vector.Vector_AddElementVector) def SetSubVectorComplement(self, dofs, val): r"""SetSubVectorComplement(Vector self, intArray dofs, double const val)""" return _vector.Vector_SetSubVectorComplement(self, dofs, val) + SetSubVectorComplement = _swig_new_instance_method(_vector.Vector_SetSubVectorComplement) def Randomize(self, seed=0): r"""Randomize(Vector self, int seed=0)""" return _vector.Vector_Randomize(self, seed) + Randomize = _swig_new_instance_method(_vector.Vector_Randomize) def Norml2(self): r"""Norml2(Vector self) -> double""" return _vector.Vector_Norml2(self) + Norml2 = _swig_new_instance_method(_vector.Vector_Norml2) def Normlinf(self): r"""Normlinf(Vector self) -> double""" return _vector.Vector_Normlinf(self) + Normlinf = _swig_new_instance_method(_vector.Vector_Normlinf) def Norml1(self): r"""Norml1(Vector self) -> double""" return _vector.Vector_Norml1(self) + Norml1 = _swig_new_instance_method(_vector.Vector_Norml1) def Normlp(self, p): r"""Normlp(Vector self, double p) -> double""" return _vector.Vector_Normlp(self, p) + Normlp = _swig_new_instance_method(_vector.Vector_Normlp) def Max(self): r"""Max(Vector self) -> double""" return _vector.Vector_Max(self) + Max = _swig_new_instance_method(_vector.Vector_Max) def Min(self): r"""Min(Vector self) -> double""" return _vector.Vector_Min(self) + Min = _swig_new_instance_method(_vector.Vector_Min) def Sum(self): r"""Sum(Vector self) -> double""" return _vector.Vector_Sum(self) + Sum = _swig_new_instance_method(_vector.Vector_Sum) def DistanceSquaredTo(self, p): r"""DistanceSquaredTo(Vector self, double const * p) -> double""" return _vector.Vector_DistanceSquaredTo(self, p) + DistanceSquaredTo = _swig_new_instance_method(_vector.Vector_DistanceSquaredTo) def DistanceTo(self, p): r"""DistanceTo(Vector self, double const * p) -> double""" return _vector.Vector_DistanceTo(self, p) + DistanceTo = _swig_new_instance_method(_vector.Vector_DistanceTo) def CheckFinite(self): r"""CheckFinite(Vector self) -> int""" return _vector.Vector_CheckFinite(self) + CheckFinite = _swig_new_instance_method(_vector.Vector_CheckFinite) __swig_destroy__ = _vector.delete_Vector def Read(self, on_dev=True): r"""Read(Vector self, bool on_dev=True) -> double const""" return _vector.Vector_Read(self, on_dev) + Read = _swig_new_instance_method(_vector.Vector_Read) def HostRead(self): r"""HostRead(Vector self) -> double const *""" return _vector.Vector_HostRead(self) + HostRead = _swig_new_instance_method(_vector.Vector_HostRead) def Write(self, on_dev=True): r"""Write(Vector self, bool on_dev=True) -> double""" return _vector.Vector_Write(self, on_dev) + Write = _swig_new_instance_method(_vector.Vector_Write) def HostWrite(self): r"""HostWrite(Vector self) -> double *""" return _vector.Vector_HostWrite(self) + HostWrite = _swig_new_instance_method(_vector.Vector_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(Vector self, bool on_dev=True) -> double""" return _vector.Vector_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_vector.Vector_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(Vector self) -> double *""" return _vector.Vector_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_vector.Vector_HostReadWrite) def __init__(self, *args): r""" @@ -427,14 +489,17 @@ def Assign(self, *args): def __setitem__(self, i, v): r"""__setitem__(Vector self, int i, double const v)""" return _vector.Vector___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_vector.Vector___setitem__) def __getitem__(self, param): r"""__getitem__(Vector self, PyObject * param) -> PyObject *""" return _vector.Vector___getitem__(self, param) + __getitem__ = _swig_new_instance_method(_vector.Vector___getitem__) def GetDataArray(self): r"""GetDataArray(Vector self) -> PyObject *""" return _vector.Vector_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_vector.Vector_GetDataArray) def Print(self, *args): r""" @@ -442,6 +507,7 @@ def Print(self, *args): Print(Vector self, char const * file, int precision=8) """ return _vector.Vector_Print(self, *args) + Print = _swig_new_instance_method(_vector.Vector_Print) def Print_HYPRE(self, *args): r""" @@ -450,6 +516,7 @@ def Print_HYPRE(self, *args): Print_HYPRE(Vector self) """ return _vector.Vector_Print_HYPRE(self, *args) + Print_HYPRE = _swig_new_instance_method(_vector.Vector_Print_HYPRE) # Register Vector in _vector: _vector.Vector_swigregister(Vector) @@ -458,14 +525,17 @@ def Print_HYPRE(self, *args): def IsFinite(val): r"""IsFinite(double const & val) -> bool""" return _vector.IsFinite(val) +IsFinite = _vector.IsFinite def DistanceSquared(x, y, n): r"""DistanceSquared(double const * x, double const * y, int const n) -> double""" return _vector.DistanceSquared(x, y, n) +DistanceSquared = _vector.DistanceSquared def Distance(x, y, n): r"""Distance(double const * x, double const * y, int const n) -> double""" return _vector.Distance(x, y, n) +Distance = _vector.Distance Vector.__idiv__ = Vector.__itruediv__ diff --git a/mfem/_par/vector_wrap.cxx b/mfem/_par/vector_wrap.cxx index fdb122ac..20de6ecc 100644 --- a/mfem/_par/vector_wrap.cxx +++ b/mfem/_par/vector_wrap.cxx @@ -4898,6 +4898,195 @@ SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self } +SWIGINTERN PyObject *_wrap_Vector_MakeRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Vector *arg1 = (mfem::Vector *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_MakeRef" "', argument " "1"" of type '" "mfem::Vector *""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Vector_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Vector *arg1 = (mfem::Vector *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_MakeRef" "', argument " "1"" of type '" "mfem::Vector *""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Vector_MakeRef(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_MakeRef", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Vector_MakeRef__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Vector_MakeRef__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_MakeRef'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Vector::MakeRef(mfem::Vector &,int,int)\n" + " mfem::Vector::MakeRef(mfem::Vector &,int)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_Vector_MakeDataOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -9455,6 +9644,7 @@ SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *ar static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "add_vector", _wrap_add_vector, METH_VARARGS, "\n" "add_vector(Vector v1, Vector v2, Vector v)\n" "add_vector(Vector v1, double alpha, Vector v2, Vector v)\n" @@ -9485,6 +9675,10 @@ static PyMethodDef SwigMethods[] = { { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "Vector_SetDataAndSize(Vector self, double * d, int s)"}, { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "Vector_NewDataAndSize(Vector self, double * d, int s)"}, { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "Vector_NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" + "Vector_MakeRef(Vector self, Vector base, int offset, int size)\n" + "Vector_MakeRef(Vector self, Vector base, int offset)\n" + ""}, { "Vector_MakeDataOwner", _wrap_Vector_MakeDataOwner, METH_O, "Vector_MakeDataOwner(Vector self)"}, { "Vector_Destroy", _wrap_Vector_Destroy, METH_O, "Vector_Destroy(Vector self)"}, { "Vector_Size", _wrap_Vector_Size, METH_O, "Vector_Size(Vector self) -> int"}, @@ -9592,6 +9786,145 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "add_vector", _wrap_add_vector, METH_VARARGS, "\n" + "add_vector(Vector v1, Vector v2, Vector v)\n" + "add_vector(Vector v1, double alpha, Vector v2, Vector v)\n" + "add_vector(double const a, Vector x, Vector y, Vector z)\n" + "add_vector(double const a, Vector x, double const b, Vector y, Vector z)\n" + ""}, + { "subtract_vector", _wrap_subtract_vector, METH_VARARGS, "\n" + "subtract_vector(Vector v1, Vector v2, Vector v)\n" + "subtract_vector(double const a, Vector x, Vector y, Vector z)\n" + ""}, + { "CheckFinite", _wrap_CheckFinite, METH_VARARGS, "CheckFinite(double const * v, int const n) -> int"}, + { "infinity", _wrap_infinity, METH_NOARGS, "infinity() -> double"}, + { "Vector_UseDevice", _wrap_Vector_UseDevice, METH_VARARGS, "\n" + "UseDevice(Vector self, bool use_dev)\n" + "UseDevice(Vector self) -> bool\n" + ""}, + { "Vector_Load", _wrap_Vector_Load, METH_VARARGS, "\n" + "Load(Vector self, std::istream ** _in, int np, int * dim)\n" + "Load(Vector self, std::istream & _in, int Size)\n" + "Load(Vector self, std::istream & _in)\n" + ""}, + { "Vector_SetSize", _wrap_Vector_SetSize, METH_VARARGS, "\n" + "SetSize(Vector self, int s)\n" + "SetSize(Vector self, int s, mfem::MemoryType mt)\n" + "SetSize(Vector self, int s, Vector v)\n" + ""}, + { "Vector_SetData", _wrap_Vector_SetData, METH_VARARGS, "SetData(Vector self, double * d)"}, + { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "SetDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "NewDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" + "MakeRef(Vector self, Vector base, int offset, int size)\n" + "MakeRef(Vector self, Vector base, int offset)\n" + ""}, + { "Vector_MakeDataOwner", _wrap_Vector_MakeDataOwner, METH_O, "MakeDataOwner(Vector self)"}, + { "Vector_Destroy", _wrap_Vector_Destroy, METH_O, "Destroy(Vector self)"}, + { "Vector_Size", _wrap_Vector_Size, METH_O, "Size(Vector self) -> int"}, + { "Vector_Capacity", _wrap_Vector_Capacity, METH_O, "Capacity(Vector self) -> int"}, + { "Vector_GetData", _wrap_Vector_GetData, METH_O, "GetData(Vector self) -> double *"}, + { "Vector_GetMemory", _wrap_Vector_GetMemory, METH_VARARGS, "\n" + "GetMemory(Vector self) -> mfem::Memory< double >\n" + "GetMemory(Vector self) -> mfem::Memory< double > const &\n" + ""}, + { "Vector_SyncMemory", _wrap_Vector_SyncMemory, METH_VARARGS, "SyncMemory(Vector self, Vector v)"}, + { "Vector_SyncAliasMemory", _wrap_Vector_SyncAliasMemory, METH_VARARGS, "SyncAliasMemory(Vector self, Vector v)"}, + { "Vector_OwnsData", _wrap_Vector_OwnsData, METH_O, "OwnsData(Vector self) -> bool"}, + { "Vector_StealData", _wrap_Vector_StealData, METH_VARARGS, "\n" + "StealData(Vector self, double ** p)\n" + "StealData(Vector self) -> double *\n" + ""}, + { "Vector_Elem", _wrap_Vector_Elem, METH_VARARGS, "\n" + "Elem(Vector self, int i) -> double\n" + "Elem(Vector self, int i) -> double const &\n" + ""}, + { "Vector___call__", _wrap_Vector___call__, METH_VARARGS, "\n" + "__call__(Vector self, int i) -> double\n" + "__call__(Vector self, int i) -> double const &\n" + ""}, + { "Vector___mul__", _wrap_Vector___mul__, METH_VARARGS, "\n" + "__mul__(Vector self, double const * arg2) -> double\n" + "__mul__(Vector self, Vector v) -> double\n" + ""}, + { "Vector___imul__", _wrap_Vector___imul__, METH_VARARGS, "__imul__(Vector self, double c) -> Vector"}, + { "Vector___itruediv__", _wrap_Vector___itruediv__, METH_VARARGS, "__itruediv__(Vector self, double c) -> Vector"}, + { "Vector___isub__", _wrap_Vector___isub__, METH_VARARGS, "\n" + "__isub__(Vector self, double c) -> Vector\n" + "__isub__(Vector self, Vector v) -> Vector\n" + ""}, + { "Vector___iadd__", _wrap_Vector___iadd__, METH_VARARGS, "__iadd__(Vector self, Vector v) -> Vector"}, + { "Vector_Add", _wrap_Vector_Add, METH_VARARGS, "Add(Vector self, double const a, Vector Va) -> Vector"}, + { "Vector_Set", _wrap_Vector_Set, METH_VARARGS, "Set(Vector self, double const a, Vector x) -> Vector"}, + { "Vector_SetVector", _wrap_Vector_SetVector, METH_VARARGS, "SetVector(Vector self, Vector v, int offset)"}, + { "Vector_Neg", _wrap_Vector_Neg, METH_O, "Neg(Vector self)"}, + { "Vector_Swap", _wrap_Vector_Swap, METH_VARARGS, "Swap(Vector self, Vector other)"}, + { "Vector_median", _wrap_Vector_median, METH_VARARGS, "median(Vector self, Vector lo, Vector hi)"}, + { "Vector_GetSubVector", _wrap_Vector_GetSubVector, METH_VARARGS, "\n" + "GetSubVector(Vector self, intArray dofs, Vector elemvect)\n" + "GetSubVector(Vector self, intArray dofs, double * elem_data)\n" + ""}, + { "Vector_SetSubVector", _wrap_Vector_SetSubVector, METH_VARARGS, "\n" + "SetSubVector(Vector self, intArray dofs, double const value)\n" + "SetSubVector(Vector self, intArray dofs, Vector elemvect)\n" + "SetSubVector(Vector self, intArray dofs, double * elem_data)\n" + ""}, + { "Vector_AddElementVector", _wrap_Vector_AddElementVector, METH_VARARGS, "\n" + "AddElementVector(Vector self, intArray dofs, Vector elemvect)\n" + "AddElementVector(Vector self, intArray dofs, double * elem_data)\n" + "AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect)\n" + ""}, + { "Vector_SetSubVectorComplement", _wrap_Vector_SetSubVectorComplement, METH_VARARGS, "SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, + { "Vector_Randomize", _wrap_Vector_Randomize, METH_VARARGS, "Randomize(Vector self, int seed=0)"}, + { "Vector_Norml2", _wrap_Vector_Norml2, METH_O, "Norml2(Vector self) -> double"}, + { "Vector_Normlinf", _wrap_Vector_Normlinf, METH_O, "Normlinf(Vector self) -> double"}, + { "Vector_Norml1", _wrap_Vector_Norml1, METH_O, "Norml1(Vector self) -> double"}, + { "Vector_Normlp", _wrap_Vector_Normlp, METH_VARARGS, "Normlp(Vector self, double p) -> double"}, + { "Vector_Max", _wrap_Vector_Max, METH_O, "Max(Vector self) -> double"}, + { "Vector_Min", _wrap_Vector_Min, METH_O, "Min(Vector self) -> double"}, + { "Vector_Sum", _wrap_Vector_Sum, METH_O, "Sum(Vector self) -> double"}, + { "Vector_DistanceSquaredTo", _wrap_Vector_DistanceSquaredTo, METH_VARARGS, "DistanceSquaredTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceTo", _wrap_Vector_DistanceTo, METH_VARARGS, "DistanceTo(Vector self, double const * p) -> double"}, + { "Vector_CheckFinite", _wrap_Vector_CheckFinite, METH_O, "CheckFinite(Vector self) -> int"}, + { "delete_Vector", _wrap_delete_Vector, METH_O, "delete_Vector(Vector self)"}, + { "Vector_Read", _wrap_Vector_Read, METH_VARARGS, "Read(Vector self, bool on_dev=True) -> double const"}, + { "Vector_HostRead", _wrap_Vector_HostRead, METH_O, "HostRead(Vector self) -> double const *"}, + { "Vector_Write", _wrap_Vector_Write, METH_VARARGS, "Write(Vector self, bool on_dev=True) -> double"}, + { "Vector_HostWrite", _wrap_Vector_HostWrite, METH_O, "HostWrite(Vector self) -> double *"}, + { "Vector_ReadWrite", _wrap_Vector_ReadWrite, METH_VARARGS, "ReadWrite(Vector self, bool on_dev=True) -> double"}, + { "Vector_HostReadWrite", _wrap_Vector_HostReadWrite, METH_O, "HostReadWrite(Vector self) -> double *"}, + { "new_Vector", _wrap_new_Vector, METH_VARARGS, "\n" + "Vector()\n" + "Vector(Vector arg1)\n" + "Vector(int s)\n" + "Vector(double * _data, int _size)\n" + "Vector(int size_, mfem::MemoryType mt)\n" + "new_Vector(Vector v, int offset, int size) -> Vector\n" + ""}, + { "Vector_Assign", _wrap_Vector_Assign, METH_VARARGS, "\n" + "Assign(Vector self, double const v)\n" + "Assign(Vector self, PyObject * param)\n" + ""}, + { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, "__setitem__(Vector self, int i, double const v)"}, + { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, "__getitem__(Vector self, PyObject * param) -> PyObject *"}, + { "Vector_GetDataArray", _wrap_Vector_GetDataArray, METH_O, "GetDataArray(Vector self) -> PyObject *"}, + { "Vector_Print", _wrap_Vector_Print, METH_VARARGS, "\n" + "Print(Vector self, std::ostream & out=mfem::out, int width=8)\n" + "Print(Vector self, char const * file, int precision=8)\n" + ""}, + { "Vector_Print_HYPRE", _wrap_Vector_Print_HYPRE, METH_VARARGS, "\n" + "Print_HYPRE(Vector self, std::ostream & out)\n" + "Print_HYPRE(Vector self, char const * file, int precision=8)\n" + "Print_HYPRE(Vector self)\n" + ""}, + { "Vector_swigregister", Vector_swigregister, METH_O, NULL}, + { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL}, + { "IsFinite", _wrap_IsFinite, METH_O, "IsFinite(double const & val) -> bool"}, + { "DistanceSquared", _wrap_DistanceSquared, METH_VARARGS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, + { "Distance", _wrap_Distance, METH_VARARGS, "Distance(double const * x, double const * y, int const n) -> double"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/vertex.py b/mfem/_par/vertex.py index c601cfdf..798af3c7 100644 --- a/mfem/_par/vertex.py +++ b/mfem/_par/vertex.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _vertex.SWIG_PyInstanceMethod_New +_swig_new_static_method = _vertex.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -96,6 +99,7 @@ def __call__(self, *args): __call__(Vertex self, int i) -> double const & """ return _vertex.Vertex___call__(self, *args) + __call__ = _swig_new_instance_method(_vertex.Vertex___call__) def SetCoords(self, *args): r""" @@ -103,6 +107,7 @@ def SetCoords(self, *args): SetCoords(Vertex self, int dim, double const * p) """ return _vertex.Vertex_SetCoords(self, *args) + SetCoords = _swig_new_instance_method(_vertex.Vertex_SetCoords) __swig_destroy__ = _vertex.delete_Vertex # Register Vertex in _vertex: diff --git a/mfem/_par/vertex_wrap.cxx b/mfem/_par/vertex_wrap.cxx index 16199721..d3ac6a41 100644 --- a/mfem/_par/vertex_wrap.cxx +++ b/mfem/_par/vertex_wrap.cxx @@ -3841,6 +3841,7 @@ SWIGINTERN PyObject *Vertex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Vertex", _wrap_new_Vertex, METH_VARARGS, "\n" "Vertex()\n" "Vertex(double * xx, int dim)\n" @@ -3863,6 +3864,26 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Vertex", _wrap_new_Vertex, METH_VARARGS, "\n" + "Vertex()\n" + "Vertex(double * xx, int dim)\n" + "Vertex(double x, double y)\n" + "new_Vertex(double x, double y, double z) -> Vertex\n" + ""}, + { "Vertex___call__", _wrap_Vertex___call__, METH_VARARGS, "\n" + "__call__(Vertex self) -> double\n" + "__call__(Vertex self, int i) -> double\n" + "__call__(Vertex self, int i) -> double const &\n" + ""}, + { "Vertex_SetCoords", _wrap_Vertex_SetCoords, METH_VARARGS, "\n" + "SetCoords(Vertex self, double const * p)\n" + "SetCoords(Vertex self, int dim, double const * p)\n" + ""}, + { "delete_Vertex", _wrap_delete_Vertex, METH_O, "delete_Vertex(Vertex self)"}, + { "Vertex_swigregister", Vertex_swigregister, METH_O, NULL}, + { "Vertex_swiginit", Vertex_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/vtk.i b/mfem/_par/vtk.i new file mode 100644 index 00000000..6bf578b3 --- /dev/null +++ b/mfem/_par/vtk.i @@ -0,0 +1,21 @@ +%module(package="mfem._par") vtk +%{ +#include "mfem.hpp" +#include "mesh/vtk.hpp" +#include "numpy/arrayobject.h" +#include "io_stream.hpp" +%} + +%init %{ +import_array(); +%} +%include "exception.i" +%import "element.i" +%include "../common/exception.i" + +%import "../common/numpy_int_typemap.i" +%import "../common/io_stream_typemap.i" +OSTREAM_TYPEMAP(std::ostream&) + +%include "mesh/vtk.hpp" + diff --git a/mfem/_par/vtk.py b/mfem/_par/vtk.py new file mode 100644 index 00000000..ad7abcda --- /dev/null +++ b/mfem/_par/vtk.py @@ -0,0 +1,102 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 4.0.1 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info as _swig_python_version_info +if _swig_python_version_info < (2, 7, 0): + raise RuntimeError("Python 2.7 or later required") + +# Import the low-level C/C++ module +if __package__ or "." in __name__: + from . import _vtk +else: + import _vtk + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + +_swig_new_instance_method = _vtk.SWIG_PyInstanceMethod_New +_swig_new_static_method = _vtk.SWIG_PyStaticMethod_New + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +def _swig_setattr_nondynamic_instance_variable(set): + def set_instance_attr(self, name, value): + if name == "thisown": + self.this.own(value) + elif name == "this": + set(self, name, value) + elif hasattr(self, name) and isinstance(getattr(type(self), name), property): + set(self, name, value) + else: + raise AttributeError("You cannot add instance attributes to %s" % self) + return set_instance_attr + + +def _swig_setattr_nondynamic_class_variable(set): + def set_class_attr(cls, name, value): + if hasattr(cls, name) and not isinstance(getattr(cls, name), property): + set(cls, name, value) + else: + raise AttributeError("You cannot add class attributes to %s" % cls) + return set_class_attr + + +def _swig_add_metaclass(metaclass): + """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" + def wrapper(cls): + return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) + return wrapper + + +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) + + +import weakref + +import mfem._par.element +import mfem._par.array +import mfem._par.mem_manager +import mfem._par.densemat +import mfem._par.vector +import mfem._par.operators +import mfem._par.matrix +import mfem._par.geom +import mfem._par.intrules +import mfem._par.table +import mfem._par.hash +VTKFormat_ASCII = _vtk.VTKFormat_ASCII + +VTKFormat_BINARY = _vtk.VTKFormat_BINARY + +VTKFormat_BINARY32 = _vtk.VTKFormat_BINARY32 + + +def CreateVTKElementConnectivity(con, geom, ref): + r"""CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)""" + return _vtk.CreateVTKElementConnectivity(con, geom, ref) +CreateVTKElementConnectivity = _vtk.CreateVTKElementConnectivity + +def WriteVTKEncodedCompressed(out, bytes, nbytes, compression_level): + r"""WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)""" + return _vtk.WriteVTKEncodedCompressed(out, bytes, nbytes, compression_level) +WriteVTKEncodedCompressed = _vtk.WriteVTKEncodedCompressed + +def VTKByteOrder(): + r"""VTKByteOrder() -> char const *""" + return _vtk.VTKByteOrder() +VTKByteOrder = _vtk.VTKByteOrder + + diff --git a/mfem/_par/vtk_wrap.cxx b/mfem/_par/vtk_wrap.cxx new file mode 100644 index 00000000..34d6ffd7 --- /dev/null +++ b/mfem/_par/vtk_wrap.cxx @@ -0,0 +1,4338 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGPYTHON +#define SWIGPYTHON +#endif + +#define SWIG_DIRECTORS +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + + +#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) +/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ +# include +#endif + +#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) +/* Use debug wrappers with the Python release dll */ +# undef _DEBUG +# include +# define _DEBUG 1 +#else +# include +#endif + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = (unsigned char)((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = (unsigned char)((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (unsigned char)(d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (unsigned char)(d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Warning: This function will allocate a new string in Python 3, + * so please call SWIG_Python_str_DelForPy3(x) to free the space. + */ +SWIGINTERN char* +SWIG_Python_str_AsChar(PyObject *str) +{ +#if PY_VERSION_HEX >= 0x03000000 + char *newstr = 0; + str = PyUnicode_AsUTF8String(str); + if (str) { + char *cstr; + Py_ssize_t len; + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char *) malloc(len+1); + memcpy(newstr, cstr, len+1); + Py_XDECREF(str); + } + return newstr; +#else + return PyString_AsString(str); +#endif +} + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#else +# define SWIG_Python_str_DelForPy3(x) +#endif + + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user +// interface files check for it. +# define SWIGPY_USE_CAPSULE +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define Py_hash_t long +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + PyErr_Clear(); + Py_XINCREF(type); + if (tmp) + PyErr_Format(type, "%s %s", tmp, mesg); + else + PyErr_Format(type, "%s", mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +SWIGRUNTIME int +SWIG_Python_TypeErrorOccurred(PyObject *obj) +{ + PyObject *error; + if (obj) + return 0; + error = PyErr_Occurred(); + return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError); +} + +SWIGRUNTIME void +SWIG_Python_RaiseOrModifyTypeError(const char *message) +{ + if (SWIG_Python_TypeErrorOccurred(NULL)) { + /* Use existing TypeError to preserve stacktrace and enhance with given message */ + PyObject *newvalue; + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); +#if PY_VERSION_HEX >= 0x03000000 + newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message); +#else + newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); +#endif + Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + /* Raise TypeError using given message */ + PyErr_SetString(PyExc_TypeError, message); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# define SWIG_PYTHON_USE_GIL +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + const char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */ +# error "This version of SWIG only supports Python >= 2.7" +#endif + +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000 +# error "This version of SWIG only supports Python 3 >= 3.2" +#endif + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +} + +/* Unpack the argument tuple */ + +SWIGINTERN Py_ssize_t +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + Py_ssize_t i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + Py_ssize_t i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + int fail = data ? data->implicitconv : 0; + if (fail) + PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors."); + return fail; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { + data->newraw = PyObject_GetAttrString(data->klass, "__new__"); + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); + data->delargs = !(flags & (METH_O)); + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + + +#ifdef SWIGPYTHON_BUILTIN + +SWIGRUNTIME PyObject * +SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + + if (!sobj->dict) + sobj->dict = PyDict_New(); + + Py_INCREF(sobj->dict); + return sobj->dict; +} + +#endif + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { + PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_repr(SwigPyObject *v) +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (v->next) { + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } + return repr; +} + +/* We need a version taking two PyObject* parameters so it's a valid + * PyCFunction to use in swigobject_methods[]. */ +SWIGRUNTIME PyObject * +SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + return SwigPyObject_repr((SwigPyObject*)v); +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res; + if( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { +#ifdef SWIGPYTHON_BUILTIN + PyTypeObject *target_tp = SwigPyObject_type(); + if (PyType_IsSubtype(op->ob_type, target_tp)) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); +#else + return (Py_TYPE(op) == SwigPyObject_type()) + || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + + /* PyObject_CallFunction() has the potential to silently drop + the active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); + + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if (!res) + PyErr_WriteUnraisable(destroy); + + PyErr_Restore(type, value, traceback); + + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (!SwigPyObject_Check(next)) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) { + return NULL; + } else { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v,args); + } else { + SwigPyObject_disown(v,args); + } + } + return obj; + } +} + +static PyMethodDef +swigobject_methods[] = { + {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"}, + {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"}, + {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"}, + {"append", SwigPyObject_append, METH_O, "appends another 'this' object"}, + {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"}, + {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"}, + {0, 0, 0, 0} +}; + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ +#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#else + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpyobject_type) < 0) + return NULL; + } + return &swigpyobject_type; +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) + || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpypacked_type) < 0) + return NULL; + } + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +static PyObject *Swig_This_global = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (Swig_This_global == NULL) + Swig_This_global = SWIG_Python_str_FromChar("this"); + return Swig_This_global; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None && !implicit_conv) { + if (ptr) + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + res = SWIG_OK; + } else { + if (implicit_conv) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + swig_cast_info *tc; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) + return SWIG_ERROR; + tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + return SWIG_OK; + } +} + +/* Convert a packed pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *empty_args = PyTuple_New(0); + if (empty_args) { + PyObject *empty_kwargs = PyDict_New(); + if (empty_kwargs) { + inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + Py_DECREF(empty_kwargs); + if (inst) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } + } + Py_DECREF(empty_args); + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, "__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { + PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +SWIGRUNTIME void +SWIG_Python_DestroyModule(PyObject *obj) +{ + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + Swig_This_global = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { + obj = PyCapsule_New((void*) descriptor, NULL, NULL); + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + const char *errmesg = tmp ? tmp : "Invalid error message"; + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, errmesg); + } else { + PyErr_Format(type, "%s %s", errmesg, mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +#if SWIG_POINTER_EXCEPTION + if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } +#endif + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res = -1; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) < 0) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + if (!encoded_name) + return -1; + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Method creation and docstring support functions */ + +SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name); +SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); +SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); + +#ifdef __cplusplus +} +#endif + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Python proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ +#define SWIG_DIRECTOR_PYTHON_HEADER_ + +#include +#include +#include +#include +#include + + +/* + Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual + table', and avoid multiple GetAttr calls to retrieve the python + methods. +*/ + +#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE +#ifndef SWIG_PYTHON_DIRECTOR_VTABLE +#define SWIG_PYTHON_DIRECTOR_VTABLE +#endif +#endif + + + +/* + Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the + Undefined Exception Handler provided by swig. +*/ +#ifndef SWIG_DIRECTOR_NO_UEH +#ifndef SWIG_DIRECTOR_UEH +#define SWIG_DIRECTOR_UEH +#endif +#endif + + +/* + Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the + native C++ RTTI and dynamic_cast<>. But be aware that directors + could stop working when using this option. +*/ +#ifdef SWIG_DIRECTOR_NORTTI +/* + When we don't use the native C++ RTTI, we implement a minimal one + only for Directors. +*/ +# ifndef SWIG_DIRECTOR_RTDIR +# define SWIG_DIRECTOR_RTDIR + +namespace Swig { + class Director; + SWIGINTERN std::map& get_rtdir_map() { + static std::map rtdir_map; + return rtdir_map; + } + + SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { + get_rtdir_map()[vptr] = rtdir; + } + + SWIGINTERNINLINE Director *get_rtdir(void *vptr) { + std::map::const_iterator pos = get_rtdir_map().find(vptr); + Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; + return rtdir; + } +} +# endif /* SWIG_DIRECTOR_RTDIR */ + +# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) + +#else + +# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) + +#endif /* SWIG_DIRECTOR_NORTTI */ + +extern "C" { + struct swig_type_info; +} + +namespace Swig { + + /* memory handler */ + struct GCItem { + virtual ~GCItem() {} + + virtual int get_own() const { + return 0; + } + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem * operator->() const { + return _item; + } + + private: + GCItem *_item; + }; + + struct GCItem_Object : GCItem { + GCItem_Object(int own) : _own(own) { + } + + virtual ~GCItem_Object() { + } + + int get_own() const { + return _own; + } + + private: + int _own; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; + + template + struct GCArray_T : GCItem { + GCArray_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCArray_T() { + delete[] _ptr; + } + + private: + Type *_ptr; + }; + + /* base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + public: + DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (msg[0]) { + swig_msg += " "; + swig_msg += msg; + } + if (!PyErr_Occurred()) { + PyErr_SetString(error, what()); + } + SWIG_PYTHON_THREAD_END_BLOCK; + } + + virtual ~DirectorException() throw() { + } + + /* Deprecated, use what() instead */ + const char *getMessage() const { + return what(); + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorException(error, msg); + } + + static void raise(const char *msg) { + raise(PyExc_RuntimeError, msg); + } + }; + + /* type mismatch in the return value from a python method call */ + class DirectorTypeMismatchException : public DirectorException { + public: + DirectorTypeMismatchException(PyObject *error, const char *msg="") + : DirectorException(error, "SWIG director type mismatch", msg) { + } + + DirectorTypeMismatchException(const char *msg="") + : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorTypeMismatchException(error, msg); + } + + static void raise(const char *msg) { + throw DirectorTypeMismatchException(msg); + } + }; + + /* any python exception that occurs during a director method call */ + class DirectorMethodException : public DirectorException { + public: + DirectorMethodException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { + } + + static void raise(const char *msg) { + throw DirectorMethodException(msg); + } + }; + + /* attempt to call a pure virtual method via a director method */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { + } + + static void raise(const char *msg) { + throw DirectorPureVirtualException(msg); + } + }; + + +#if defined(SWIG_PYTHON_THREADS) +/* __THREAD__ is the old macro to activate some thread support */ +# if !defined(__THREAD__) +# define __THREAD__ 1 +# endif +#endif + +#ifdef __THREAD__ +# include "pythread.h" + class Guard { + PyThread_type_lock &mutex_; + + public: + Guard(PyThread_type_lock & mutex) : mutex_(mutex) { + PyThread_acquire_lock(mutex_, WAIT_LOCK); + } + + ~Guard() { + PyThread_release_lock(mutex_); + } + }; +# define SWIG_GUARD(mutex) Guard _guard(mutex) +#else +# define SWIG_GUARD(mutex) +#endif + + /* director base class */ + class Director { + private: + /* pointer to the wrapped python object */ + PyObject *swig_self; + /* flag indicating whether the object is owned by python or c++ */ + mutable bool swig_disown_flag; + + /* decrement the reference count of the wrapped python object */ + void swig_decref() const { + if (swig_disown_flag) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_DECREF(swig_self); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + public: + /* wrap a python object. */ + Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { + } + + /* discard our reference at destruction */ + virtual ~Director() { + swig_decref(); + } + + /* return a pointer to the wrapped python object */ + PyObject *swig_get_self() const { + return swig_self; + } + + /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); + } + } + + /* increase the reference count of the wrapped python object */ + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); + } + } + + /* methods to implement pseudo protected director members */ + virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { + return true; + } + + virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { + } + + /* ownership management */ + private: + typedef std::map swig_ownership_map; + mutable swig_ownership_map swig_owner; +#ifdef __THREAD__ + static PyThread_type_lock swig_mutex_own; +#endif + + public: + template + void swig_acquire_ownership_array(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCArray_T(vptr); + } + } + + template + void swig_acquire_ownership(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_T(vptr); + } + } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_Object(own); + } + } + + int swig_release_ownership(void *vptr) const { + int own = 0; + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_ownership_map::iterator iter = swig_owner.find(vptr); + if (iter != swig_owner.end()) { + own = iter->second->get_own(); + swig_owner.erase(iter); + } + } + return own; + } + + template + static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { + SwigPyObject *sobj = (SwigPyObject *)pyobj; + sobj->own = 0; + Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); + if (d) + d->swig_disown(); + return PyWeakref_NewProxy(pyobj, NULL); + } + }; + +#ifdef __THREAD__ + PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock(); +#endif +} + +#endif + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] +#define SWIGTYPE_p_char swig_types[1] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[2] +#define SWIGTYPE_p_uint32_t swig_types[3] +static swig_type_info *swig_types[5]; +static swig_module_info swig_module = {swig_types, 4, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#ifdef SWIG_TypeQuery +# undef SWIG_TypeQuery +#endif +#define SWIG_TypeQuery SWIG_Python_TypeQuery + +/*----------------------------------------------- + @(target):= _vtk.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__vtk + +#else +# define SWIG_init init_vtk + +#endif +#define SWIG_name "_vtk" + +#define SWIGVERSION 0x040001 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include "mfem.hpp" +#include "mesh/vtk.hpp" +#include "numpy/arrayobject.h" +#include "io_stream.hpp" + + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor(void) +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + if (carray) { + if (size > INT_MAX) { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + return pchar_descriptor ? + SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { +#if PY_VERSION_HEX >= 0x03000000 +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#else + return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); +#endif +#else + return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#endif + } + } else { + return SWIG_Py_Void(); + } +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtr(const char *cptr) +{ + return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); +} + + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "vtk_wrap.h" + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Array< int > *arg1 = 0 ; + mfem::Geometry::Type arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "CreateVTKElementConnectivity", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); + } + arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateVTKElementConnectivity" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + mfem::CreateVTKElementConnectivity(*arg1,arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::ostream *arg1 = 0 ; + void *arg2 = (void *) 0 ; + uint32_t arg3 ; + int arg4 ; + PyMFEM::wFILE *temp1 = 0 ; + std::ofstream out1 ; + int res2 ; + void *argp3 ; + int res3 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "WriteVTKEncodedCompressed", 4, 4, swig_obj)) SWIG_fail; + { + if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp1->isSTDOUT() == 1) { + arg1 = &std::cout; + } + else { + out1.open(temp1->getFilename()); + out1.precision(temp1->getPrecision()); + arg1 = &out1; + } + } + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteVTKEncodedCompressed" "', argument " "2"" of type '" "void const *""'"); + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_uint32_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WriteVTKEncodedCompressed" "', argument " "3"" of type '" "uint32_t""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteVTKEncodedCompressed" "', argument " "3"" of type '" "uint32_t""'"); + } else { + uint32_t * temp = reinterpret_cast< uint32_t * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + mfem::WriteVTKEncodedCompressed(*arg1,(void const *)arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + return resultobj; +fail: + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VTKByteOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VTKByteOrder", 0, 0, 0)) SWIG_fail; + { + try { + result = (char *)mfem::VTKByteOrder(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_PyMFEM__wFILE, + &_swigt__p_char, + &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_uint32_t, +}; + +static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_PyMFEM__wFILE, + _swigc__p_char, + _swigc__p_mfem__ArrayT_int_t, + _swigc__p_uint32_t, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *globals = 0; + if (!globals) { + globals = SWIG_newvarlink(); + } + return globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (!c) continue; + c = strstr(c, "swig_ptr: "); + if (c) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + memcpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + memcpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + + /* ----------------------------------------------------------------------------- + * Method creation and docstring support functions + * ----------------------------------------------------------------------------- */ + + /* ----------------------------------------------------------------------------- + * Function to find the method definition with the correct docstring for the + * proxy module as opposed to the low-level API + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) { + /* Find the function in the modified method table */ + size_t offset = 0; + int found = 0; + while (SwigMethods_proxydocs[offset].ml_meth != NULL) { + if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) { + found = 1; + break; + } + offset++; + } + /* Use the copy with the modified docstring if available */ + return found ? &SwigMethods_proxydocs[offset] : NULL; + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyInstanceMethod_New() used in Python 3 + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } +#if PY_VERSION_HEX >= 0x03000000 + return PyInstanceMethod_New(func); +#else + return PyMethod_New(func, NULL, NULL); +#endif + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyStaticMethod_New() + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } + return PyStaticMethod_New(func); + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md, *globals; + +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { + PyModuleDef_HEAD_INIT, + SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + SwigPyObject_own, + SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + PyTypeObject *swigpyobject; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + PyObject *self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); + assert(metatype); +#endif + + (void)globals; + + /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */ + SWIG_This(); + SWIG_Python_TypeCache(); + SwigPyPacked_type(); +#ifndef SWIGPYTHON_BUILTIN + SwigPyObject_type(); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule(SWIG_name, SwigMethods); +#endif + + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + swigpyobject = SwigPyObject_TypeOnce(); + + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = swigpyobject; + } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + + import_array(); + + SWIG_Python_SetConstant(d, "VTKFormat_ASCII",SWIG_From_int(static_cast< int >(mfem::VTKFormat::ASCII))); + SWIG_Python_SetConstant(d, "VTKFormat_BINARY",SWIG_From_int(static_cast< int >(mfem::VTKFormat::BINARY))); + SWIG_Python_SetConstant(d, "VTKFormat_BINARY32",SWIG_From_int(static_cast< int >(mfem::VTKFormat::BINARY32))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/mfem/_par/vtk_wrap.h b/mfem/_par/vtk_wrap.h new file mode 100644 index 00000000..6ac318d3 --- /dev/null +++ b/mfem/_par/vtk_wrap.h @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_vtk_WRAP_H_ +#define SWIG_vtk_WRAP_H_ + +#include +#include + + +#endif diff --git a/mfem/_ser/array.py b/mfem/_ser/array.py index 8f0c5ca4..dfff23b9 100644 --- a/mfem/_ser/array.py +++ b/mfem/_ser/array.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _array.SWIG_PyInstanceMethod_New +_swig_new_static_method = _array.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -70,7 +73,9 @@ class intArray(object): def __init__(self, *args): r""" - __init__(intArray self, int asize=0) -> intArray + __init__(intArray self) -> intArray + __init__(intArray self, mfem::MemoryType mt) -> intArray + __init__(intArray self, int asize) -> intArray __init__(intArray self, int * _data) -> intArray __init__(intArray self, intArray src) -> intArray """ @@ -89,6 +94,7 @@ def GetData(self, *args): GetData(intArray self) -> int const * """ return _array.intArray_GetData(self, *args) + GetData = _swig_new_instance_method(_array.intArray_GetData) def GetMemory(self, *args): r""" @@ -96,30 +102,37 @@ def GetMemory(self, *args): GetMemory(intArray self) -> mfem::Memory< int > const & """ return _array.intArray_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_array.intArray_GetMemory) def UseDevice(self): r"""UseDevice(intArray self) -> bool""" return _array.intArray_UseDevice(self) + UseDevice = _swig_new_instance_method(_array.intArray_UseDevice) def OwnsData(self): r"""OwnsData(intArray self) -> bool""" return _array.intArray_OwnsData(self) + OwnsData = _swig_new_instance_method(_array.intArray_OwnsData) def StealData(self, p): r"""StealData(intArray self, int ** p)""" return _array.intArray_StealData(self, p) + StealData = _swig_new_instance_method(_array.intArray_StealData) def LoseData(self): r"""LoseData(intArray self)""" return _array.intArray_LoseData(self) + LoseData = _swig_new_instance_method(_array.intArray_LoseData) def MakeDataOwner(self): r"""MakeDataOwner(intArray self)""" return _array.intArray_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_array.intArray_MakeDataOwner) def Size(self): r"""Size(intArray self) -> int""" return _array.intArray_Size(self) + Size = _swig_new_instance_method(_array.intArray_Size) def SetSize(self, *args): r""" @@ -128,14 +141,17 @@ def SetSize(self, *args): SetSize(intArray self, int nsize, mfem::MemoryType mt) """ return _array.intArray_SetSize(self, *args) + SetSize = _swig_new_instance_method(_array.intArray_SetSize) def Capacity(self): r"""Capacity(intArray self) -> int""" return _array.intArray_Capacity(self) + Capacity = _swig_new_instance_method(_array.intArray_Capacity) def Reserve(self, capacity): r"""Reserve(intArray self, int capacity)""" return _array.intArray_Reserve(self, capacity) + Reserve = _swig_new_instance_method(_array.intArray_Reserve) def Append(self, *args): r""" @@ -144,10 +160,12 @@ def Append(self, *args): Append(intArray self, intArray els) -> int """ return _array.intArray_Append(self, *args) + Append = _swig_new_instance_method(_array.intArray_Append) def Prepend(self, el): r"""Prepend(intArray self, int const & el) -> int""" return _array.intArray_Prepend(self, el) + Prepend = _swig_new_instance_method(_array.intArray_Prepend) def Last(self, *args): r""" @@ -155,34 +173,42 @@ def Last(self, *args): Last(intArray self) -> int const & """ return _array.intArray_Last(self, *args) + Last = _swig_new_instance_method(_array.intArray_Last) def Union(self, el): r"""Union(intArray self, int const & el) -> int""" return _array.intArray_Union(self, el) + Union = _swig_new_instance_method(_array.intArray_Union) def Find(self, el): r"""Find(intArray self, int const & el) -> int""" return _array.intArray_Find(self, el) + Find = _swig_new_instance_method(_array.intArray_Find) def FindSorted(self, el): r"""FindSorted(intArray self, int const & el) -> int""" return _array.intArray_FindSorted(self, el) + FindSorted = _swig_new_instance_method(_array.intArray_FindSorted) def DeleteLast(self): r"""DeleteLast(intArray self)""" return _array.intArray_DeleteLast(self) + DeleteLast = _swig_new_instance_method(_array.intArray_DeleteLast) def DeleteFirst(self, el): r"""DeleteFirst(intArray self, int const & el)""" return _array.intArray_DeleteFirst(self, el) + DeleteFirst = _swig_new_instance_method(_array.intArray_DeleteFirst) def DeleteAll(self): r"""DeleteAll(intArray self)""" return _array.intArray_DeleteAll(self) + DeleteAll = _swig_new_instance_method(_array.intArray_DeleteAll) def Copy(self, copy): r"""Copy(intArray self, intArray copy)""" return _array.intArray_Copy(self, copy) + Copy = _swig_new_instance_method(_array.intArray_Copy) def MakeRef(self, *args): r""" @@ -190,10 +216,12 @@ def MakeRef(self, *args): MakeRef(intArray self, intArray master) """ return _array.intArray_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_array.intArray_MakeRef) def GetSubArray(self, offset, sa_size, sa): r"""GetSubArray(intArray self, int offset, int sa_size, intArray sa)""" return _array.intArray_GetSubArray(self, offset, sa_size, sa) + GetSubArray = _swig_new_instance_method(_array.intArray_GetSubArray) def Load(self, *args): r""" @@ -201,78 +229,103 @@ def Load(self, *args): Load(intArray self, int new_size, std::istream & _in) """ return _array.intArray_Load(self, *args) + Load = _swig_new_instance_method(_array.intArray_Load) def Max(self): r"""Max(intArray self) -> int""" return _array.intArray_Max(self) + Max = _swig_new_instance_method(_array.intArray_Max) def Min(self): r"""Min(intArray self) -> int""" return _array.intArray_Min(self) + Min = _swig_new_instance_method(_array.intArray_Min) def Sort(self): r"""Sort(intArray self)""" return _array.intArray_Sort(self) + Sort = _swig_new_instance_method(_array.intArray_Sort) def Unique(self): r"""Unique(intArray self)""" return _array.intArray_Unique(self) + Unique = _swig_new_instance_method(_array.intArray_Unique) def IsSorted(self): r"""IsSorted(intArray self) -> int""" return _array.intArray_IsSorted(self) + IsSorted = _swig_new_instance_method(_array.intArray_IsSorted) def PartialSum(self): r"""PartialSum(intArray self)""" return _array.intArray_PartialSum(self) + PartialSum = _swig_new_instance_method(_array.intArray_PartialSum) def Sum(self): r"""Sum(intArray self) -> int""" return _array.intArray_Sum(self) + Sum = _swig_new_instance_method(_array.intArray_Sum) - def begin(self): - r"""begin(intArray self) -> int *""" - return _array.intArray_begin(self) + def begin(self, *args): + r""" + begin(intArray self) -> int + begin(intArray self) -> int const * + """ + return _array.intArray_begin(self, *args) + begin = _swig_new_instance_method(_array.intArray_begin) - def end(self): - r"""end(intArray self) -> int *""" - return _array.intArray_end(self) + def end(self, *args): + r""" + end(intArray self) -> int + end(intArray self) -> int const * + """ + return _array.intArray_end(self, *args) + end = _swig_new_instance_method(_array.intArray_end) def MemoryUsage(self): r"""MemoryUsage(intArray self) -> long""" return _array.intArray_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_array.intArray_MemoryUsage) def Read(self, on_dev=True): r"""Read(intArray self, bool on_dev=True) -> int const""" return _array.intArray_Read(self, on_dev) + Read = _swig_new_instance_method(_array.intArray_Read) def HostRead(self): r"""HostRead(intArray self) -> int const *""" return _array.intArray_HostRead(self) + HostRead = _swig_new_instance_method(_array.intArray_HostRead) def Write(self, on_dev=True): r"""Write(intArray self, bool on_dev=True) -> int""" return _array.intArray_Write(self, on_dev) + Write = _swig_new_instance_method(_array.intArray_Write) def HostWrite(self): r"""HostWrite(intArray self) -> int *""" return _array.intArray_HostWrite(self) + HostWrite = _swig_new_instance_method(_array.intArray_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(intArray self, bool on_dev=True) -> int""" return _array.intArray_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_array.intArray_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(intArray self) -> int *""" return _array.intArray_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_array.intArray_HostReadWrite) def __setitem__(self, i, v): r"""__setitem__(intArray self, int i, int const v)""" return _array.intArray___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_array.intArray___setitem__) def __getitem__(self, i): r"""__getitem__(intArray self, int const i) -> int const &""" return _array.intArray___getitem__(self, i) + __getitem__ = _swig_new_instance_method(_array.intArray___getitem__) def Assign(self, *args): r""" @@ -280,6 +333,7 @@ def Assign(self, *args): Assign(intArray self, int const & a) """ return _array.intArray_Assign(self, *args) + Assign = _swig_new_instance_method(_array.intArray_Assign) def ToList(self): return [self[i] for i in range(self.Size())] @@ -292,6 +346,7 @@ def Print(self, *args): Print(intArray self, char const * file, int precision=8) """ return _array.intArray_Print(self, *args) + Print = _swig_new_instance_method(_array.intArray_Print) def Save(self, *args): r""" @@ -300,6 +355,7 @@ def Save(self, *args): Save(intArray self) """ return _array.intArray_Save(self, *args) + Save = _swig_new_instance_method(_array.intArray_Save) # Register intArray in _array: _array.intArray_swigregister(intArray) @@ -312,7 +368,9 @@ class doubleArray(object): def __init__(self, *args): r""" - __init__(doubleArray self, int asize=0) -> doubleArray + __init__(doubleArray self) -> doubleArray + __init__(doubleArray self, mfem::MemoryType mt) -> doubleArray + __init__(doubleArray self, int asize) -> doubleArray __init__(doubleArray self, double * _data) -> doubleArray __init__(doubleArray self, doubleArray src) -> doubleArray """ @@ -331,6 +389,7 @@ def GetData(self, *args): GetData(doubleArray self) -> double const * """ return _array.doubleArray_GetData(self, *args) + GetData = _swig_new_instance_method(_array.doubleArray_GetData) def GetMemory(self, *args): r""" @@ -338,30 +397,37 @@ def GetMemory(self, *args): GetMemory(doubleArray self) -> mfem::Memory< double > const & """ return _array.doubleArray_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_array.doubleArray_GetMemory) def UseDevice(self): r"""UseDevice(doubleArray self) -> bool""" return _array.doubleArray_UseDevice(self) + UseDevice = _swig_new_instance_method(_array.doubleArray_UseDevice) def OwnsData(self): r"""OwnsData(doubleArray self) -> bool""" return _array.doubleArray_OwnsData(self) + OwnsData = _swig_new_instance_method(_array.doubleArray_OwnsData) def StealData(self, p): r"""StealData(doubleArray self, double ** p)""" return _array.doubleArray_StealData(self, p) + StealData = _swig_new_instance_method(_array.doubleArray_StealData) def LoseData(self): r"""LoseData(doubleArray self)""" return _array.doubleArray_LoseData(self) + LoseData = _swig_new_instance_method(_array.doubleArray_LoseData) def MakeDataOwner(self): r"""MakeDataOwner(doubleArray self)""" return _array.doubleArray_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_array.doubleArray_MakeDataOwner) def Size(self): r"""Size(doubleArray self) -> int""" return _array.doubleArray_Size(self) + Size = _swig_new_instance_method(_array.doubleArray_Size) def SetSize(self, *args): r""" @@ -370,14 +436,17 @@ def SetSize(self, *args): SetSize(doubleArray self, int nsize, mfem::MemoryType mt) """ return _array.doubleArray_SetSize(self, *args) + SetSize = _swig_new_instance_method(_array.doubleArray_SetSize) def Capacity(self): r"""Capacity(doubleArray self) -> int""" return _array.doubleArray_Capacity(self) + Capacity = _swig_new_instance_method(_array.doubleArray_Capacity) def Reserve(self, capacity): r"""Reserve(doubleArray self, int capacity)""" return _array.doubleArray_Reserve(self, capacity) + Reserve = _swig_new_instance_method(_array.doubleArray_Reserve) def Append(self, *args): r""" @@ -386,10 +455,12 @@ def Append(self, *args): Append(doubleArray self, doubleArray els) -> int """ return _array.doubleArray_Append(self, *args) + Append = _swig_new_instance_method(_array.doubleArray_Append) def Prepend(self, el): r"""Prepend(doubleArray self, double const & el) -> int""" return _array.doubleArray_Prepend(self, el) + Prepend = _swig_new_instance_method(_array.doubleArray_Prepend) def Last(self, *args): r""" @@ -397,34 +468,42 @@ def Last(self, *args): Last(doubleArray self) -> double const & """ return _array.doubleArray_Last(self, *args) + Last = _swig_new_instance_method(_array.doubleArray_Last) def Union(self, el): r"""Union(doubleArray self, double const & el) -> int""" return _array.doubleArray_Union(self, el) + Union = _swig_new_instance_method(_array.doubleArray_Union) def Find(self, el): r"""Find(doubleArray self, double const & el) -> int""" return _array.doubleArray_Find(self, el) + Find = _swig_new_instance_method(_array.doubleArray_Find) def FindSorted(self, el): r"""FindSorted(doubleArray self, double const & el) -> int""" return _array.doubleArray_FindSorted(self, el) + FindSorted = _swig_new_instance_method(_array.doubleArray_FindSorted) def DeleteLast(self): r"""DeleteLast(doubleArray self)""" return _array.doubleArray_DeleteLast(self) + DeleteLast = _swig_new_instance_method(_array.doubleArray_DeleteLast) def DeleteFirst(self, el): r"""DeleteFirst(doubleArray self, double const & el)""" return _array.doubleArray_DeleteFirst(self, el) + DeleteFirst = _swig_new_instance_method(_array.doubleArray_DeleteFirst) def DeleteAll(self): r"""DeleteAll(doubleArray self)""" return _array.doubleArray_DeleteAll(self) + DeleteAll = _swig_new_instance_method(_array.doubleArray_DeleteAll) def Copy(self, copy): r"""Copy(doubleArray self, doubleArray copy)""" return _array.doubleArray_Copy(self, copy) + Copy = _swig_new_instance_method(_array.doubleArray_Copy) def MakeRef(self, *args): r""" @@ -432,10 +511,12 @@ def MakeRef(self, *args): MakeRef(doubleArray self, doubleArray master) """ return _array.doubleArray_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_array.doubleArray_MakeRef) def GetSubArray(self, offset, sa_size, sa): r"""GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)""" return _array.doubleArray_GetSubArray(self, offset, sa_size, sa) + GetSubArray = _swig_new_instance_method(_array.doubleArray_GetSubArray) def Load(self, *args): r""" @@ -443,78 +524,103 @@ def Load(self, *args): Load(doubleArray self, int new_size, std::istream & _in) """ return _array.doubleArray_Load(self, *args) + Load = _swig_new_instance_method(_array.doubleArray_Load) def Max(self): r"""Max(doubleArray self) -> double""" return _array.doubleArray_Max(self) + Max = _swig_new_instance_method(_array.doubleArray_Max) def Min(self): r"""Min(doubleArray self) -> double""" return _array.doubleArray_Min(self) + Min = _swig_new_instance_method(_array.doubleArray_Min) def Sort(self): r"""Sort(doubleArray self)""" return _array.doubleArray_Sort(self) + Sort = _swig_new_instance_method(_array.doubleArray_Sort) def Unique(self): r"""Unique(doubleArray self)""" return _array.doubleArray_Unique(self) + Unique = _swig_new_instance_method(_array.doubleArray_Unique) def IsSorted(self): r"""IsSorted(doubleArray self) -> int""" return _array.doubleArray_IsSorted(self) + IsSorted = _swig_new_instance_method(_array.doubleArray_IsSorted) def PartialSum(self): r"""PartialSum(doubleArray self)""" return _array.doubleArray_PartialSum(self) + PartialSum = _swig_new_instance_method(_array.doubleArray_PartialSum) def Sum(self): r"""Sum(doubleArray self) -> double""" return _array.doubleArray_Sum(self) + Sum = _swig_new_instance_method(_array.doubleArray_Sum) - def begin(self): - r"""begin(doubleArray self) -> double *""" - return _array.doubleArray_begin(self) + def begin(self, *args): + r""" + begin(doubleArray self) -> double + begin(doubleArray self) -> double const * + """ + return _array.doubleArray_begin(self, *args) + begin = _swig_new_instance_method(_array.doubleArray_begin) - def end(self): - r"""end(doubleArray self) -> double *""" - return _array.doubleArray_end(self) + def end(self, *args): + r""" + end(doubleArray self) -> double + end(doubleArray self) -> double const * + """ + return _array.doubleArray_end(self, *args) + end = _swig_new_instance_method(_array.doubleArray_end) def MemoryUsage(self): r"""MemoryUsage(doubleArray self) -> long""" return _array.doubleArray_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_array.doubleArray_MemoryUsage) def Read(self, on_dev=True): r"""Read(doubleArray self, bool on_dev=True) -> double const""" return _array.doubleArray_Read(self, on_dev) + Read = _swig_new_instance_method(_array.doubleArray_Read) def HostRead(self): r"""HostRead(doubleArray self) -> double const *""" return _array.doubleArray_HostRead(self) + HostRead = _swig_new_instance_method(_array.doubleArray_HostRead) def Write(self, on_dev=True): r"""Write(doubleArray self, bool on_dev=True) -> double""" return _array.doubleArray_Write(self, on_dev) + Write = _swig_new_instance_method(_array.doubleArray_Write) def HostWrite(self): r"""HostWrite(doubleArray self) -> double *""" return _array.doubleArray_HostWrite(self) + HostWrite = _swig_new_instance_method(_array.doubleArray_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(doubleArray self, bool on_dev=True) -> double""" return _array.doubleArray_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_array.doubleArray_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(doubleArray self) -> double *""" return _array.doubleArray_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_array.doubleArray_HostReadWrite) def __setitem__(self, i, v): r"""__setitem__(doubleArray self, int i, double const v)""" return _array.doubleArray___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_array.doubleArray___setitem__) def __getitem__(self, i): r"""__getitem__(doubleArray self, int const i) -> double const &""" return _array.doubleArray___getitem__(self, i) + __getitem__ = _swig_new_instance_method(_array.doubleArray___getitem__) def Assign(self, *args): r""" @@ -522,6 +628,7 @@ def Assign(self, *args): Assign(doubleArray self, double const & a) """ return _array.doubleArray_Assign(self, *args) + Assign = _swig_new_instance_method(_array.doubleArray_Assign) def ToList(self): return [self[i] for i in range(self.Size())] @@ -534,6 +641,7 @@ def Print(self, *args): Print(doubleArray self, char const * file, int precision=8) """ return _array.doubleArray_Print(self, *args) + Print = _swig_new_instance_method(_array.doubleArray_Print) def Save(self, *args): r""" @@ -542,6 +650,7 @@ def Save(self, *args): Save(doubleArray self) """ return _array.doubleArray_Save(self, *args) + Save = _swig_new_instance_method(_array.doubleArray_Save) # Register doubleArray in _array: _array.doubleArray_swigregister(doubleArray) @@ -554,6 +663,7 @@ def doubleSwap(*args): doubleSwap(double & a, double & b) """ return _array.doubleSwap(*args) +doubleSwap = _array.doubleSwap def intSwap(*args): r""" @@ -562,5 +672,6 @@ def intSwap(*args): intSwap(int & a, int & b) """ return _array.intSwap(*args) +intSwap = _array.intSwap diff --git a/mfem/_ser/array_wrap.cxx b/mfem/_ser/array_wrap.cxx index 84d3bad9..c25db321 100644 --- a/mfem/_ser/array_wrap.cxx +++ b/mfem/_ser/array_wrap.cxx @@ -3166,9 +3166,37 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_4(mfem::Array< double > *sel #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - int arg1 ; + mfem::Array< int > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::Array< int > *)new mfem::Array< int >(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; mfem::Array< int > *result = 0 ; @@ -3176,9 +3204,9 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "mfem::MemoryType""'"); } - arg1 = static_cast< int >(val1); + arg1 = static_cast< mfem::MemoryType >(val1); { try { result = (mfem::Array< int > *)new mfem::Array< int >(arg1); @@ -3202,14 +3230,22 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; mfem::Array< int > *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); { try { - result = (mfem::Array< int > *)new mfem::Array< int >(); + result = (mfem::Array< int > *)new mfem::Array< int >(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3230,7 +3266,7 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; int arg2 ; @@ -3281,7 +3317,7 @@ SWIGINTERN PyObject *_wrap_new_intArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_intArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_intArray__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; @@ -3329,14 +3365,24 @@ SWIGINTERN PyObject *_wrap_new_intArray(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_intArray", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_intArray__SWIG_1(self, argc, argv); + return _wrap_new_intArray__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_intArray__SWIG_3(self, argc, argv); + return _wrap_new_intArray__SWIG_4(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_intArray__SWIG_2(self, argc, argv); } } if (argc == 1) { @@ -3346,7 +3392,7 @@ SWIGINTERN PyObject *_wrap_new_intArray(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_intArray__SWIG_0(self, argc, argv); + return _wrap_new_intArray__SWIG_1(self, argc, argv); } } if (argc == 1) { @@ -3356,17 +3402,18 @@ SWIGINTERN PyObject *_wrap_new_intArray(PyObject *self, PyObject *args) { } if (_v) { if (argc <= 1) { - return _wrap_new_intArray__SWIG_2(self, argc, argv); + return _wrap_new_intArray__SWIG_3(self, argc, argv); } - return _wrap_new_intArray__SWIG_2(self, argc, argv); + return _wrap_new_intArray__SWIG_3(self, argc, argv); } } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_intArray'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Array(int)\n" " mfem::Array< int >::Array()\n" + " mfem::Array< int >::Array(mfem::MemoryType)\n" + " mfem::Array< int >::Array(int)\n" " mfem::Array< int >::Array(int *,int)\n" " mfem::Array< int >::Array(mfem::Array< int > const &)\n"); return 0; @@ -5885,16 +5932,14 @@ SWIGINTERN PyObject *_wrap_intArray_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_intArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_begin" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -5923,16 +5968,14 @@ SWIGINTERN PyObject *_wrap_intArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_intArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_end" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -5961,6 +6004,150 @@ SWIGINTERN PyObject *_wrap_intArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject } +SWIGINTERN PyObject *_wrap_intArray_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_begin" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + { + try { + result = (int *)((mfem::Array< int > const *)arg1)->begin(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intArray_begin(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_begin", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_begin__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_begin__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_begin'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< int >::begin()\n" + " mfem::Array< int >::begin() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_intArray_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_end" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + { + try { + result = (int *)((mfem::Array< int > const *)arg1)->end(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intArray_end(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_end", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_end__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_end__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_end'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< int >::end()\n" + " mfem::Array< int >::end() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_intArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -7167,9 +7354,37 @@ SWIGINTERN PyObject *intArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - int arg1 ; + mfem::Array< double > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::Array< double > *)new mfem::Array< double >(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; mfem::Array< double > *result = 0 ; @@ -7177,9 +7392,9 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "mfem::MemoryType""'"); } - arg1 = static_cast< int >(val1); + arg1 = static_cast< mfem::MemoryType >(val1); { try { result = (mfem::Array< double > *)new mfem::Array< double >(arg1); @@ -7203,14 +7418,22 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; mfem::Array< double > *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); { try { - result = (mfem::Array< double > *)new mfem::Array< double >(); + result = (mfem::Array< double > *)new mfem::Array< double >(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7231,7 +7454,7 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -7282,7 +7505,7 @@ SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_doubleArray__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = 0 ; void *argp1 = 0 ; @@ -7330,14 +7553,14 @@ SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_doubleArray", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_doubleArray__SWIG_1(self, argc, argv); + return _wrap_new_doubleArray__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_doubleArray__SWIG_3(self, argc, argv); + return _wrap_new_doubleArray__SWIG_4(self, argc, argv); } } if (argc == 1) { @@ -7347,7 +7570,17 @@ SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_doubleArray__SWIG_0(self, argc, argv); + return _wrap_new_doubleArray__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_doubleArray__SWIG_1(self, argc, argv); } } if (argc == 1) { @@ -7357,17 +7590,18 @@ SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *self, PyObject *args) { } if (_v) { if (argc <= 1) { - return _wrap_new_doubleArray__SWIG_2(self, argc, argv); + return _wrap_new_doubleArray__SWIG_3(self, argc, argv); } - return _wrap_new_doubleArray__SWIG_2(self, argc, argv); + return _wrap_new_doubleArray__SWIG_3(self, argc, argv); } } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_doubleArray'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::Array(int)\n" " mfem::Array< double >::Array()\n" + " mfem::Array< double >::Array(mfem::MemoryType)\n" + " mfem::Array< double >::Array(int)\n" " mfem::Array< double >::Array(double *,int)\n" " mfem::Array< double >::Array(mfem::Array< double > const &)\n"); return 0; @@ -9886,16 +10120,14 @@ SWIGINTERN PyObject *_wrap_doubleArray_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_doubleArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_begin" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -9924,16 +10156,14 @@ SWIGINTERN PyObject *_wrap_doubleArray_begin(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_doubleArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_end" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -9962,6 +10192,150 @@ SWIGINTERN PyObject *_wrap_doubleArray_end(PyObject *SWIGUNUSEDPARM(self), PyObj } +SWIGINTERN PyObject *_wrap_doubleArray_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_begin" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + { + try { + result = (double *)((mfem::Array< double > const *)arg1)->begin(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doubleArray_begin(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_begin", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_begin__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_begin__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_begin'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< double >::begin()\n" + " mfem::Array< double >::begin() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_doubleArray_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_end" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + { + try { + result = (double *)((mfem::Array< double > const *)arg1)->end(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doubleArray_end(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_end", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_end__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_doubleArray_end__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_end'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< double >::end()\n" + " mfem::Array< double >::end() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_doubleArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; @@ -11586,8 +11960,11 @@ SWIGINTERN PyObject *_wrap_intSwap(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intArray", _wrap_new_intArray, METH_VARARGS, "\n" - "intArray(int asize=0)\n" + "intArray()\n" + "intArray(mfem::MemoryType mt)\n" + "intArray(int asize)\n" "intArray(int * _data)\n" "new_intArray(intArray src) -> intArray\n" ""}, @@ -11646,8 +12023,14 @@ static PyMethodDef SwigMethods[] = { { "intArray_IsSorted", _wrap_intArray_IsSorted, METH_O, "intArray_IsSorted(intArray self) -> int"}, { "intArray_PartialSum", _wrap_intArray_PartialSum, METH_O, "intArray_PartialSum(intArray self)"}, { "intArray_Sum", _wrap_intArray_Sum, METH_O, "intArray_Sum(intArray self) -> int"}, - { "intArray_begin", _wrap_intArray_begin, METH_O, "intArray_begin(intArray self) -> int *"}, - { "intArray_end", _wrap_intArray_end, METH_O, "intArray_end(intArray self) -> int *"}, + { "intArray_begin", _wrap_intArray_begin, METH_VARARGS, "\n" + "intArray_begin(intArray self) -> int\n" + "intArray_begin(intArray self) -> int const *\n" + ""}, + { "intArray_end", _wrap_intArray_end, METH_VARARGS, "\n" + "intArray_end(intArray self) -> int\n" + "intArray_end(intArray self) -> int const *\n" + ""}, { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "intArray_MemoryUsage(intArray self) -> long"}, { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "intArray_Read(intArray self, bool on_dev=True) -> int const"}, { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "intArray_HostRead(intArray self) -> int const *"}, @@ -11674,7 +12057,9 @@ static PyMethodDef SwigMethods[] = { { "intArray_swigregister", intArray_swigregister, METH_O, NULL}, { "intArray_swiginit", intArray_swiginit, METH_VARARGS, NULL}, { "new_doubleArray", _wrap_new_doubleArray, METH_VARARGS, "\n" - "doubleArray(int asize=0)\n" + "doubleArray()\n" + "doubleArray(mfem::MemoryType mt)\n" + "doubleArray(int asize)\n" "doubleArray(double * _data)\n" "new_doubleArray(doubleArray src) -> doubleArray\n" ""}, @@ -11733,8 +12118,14 @@ static PyMethodDef SwigMethods[] = { { "doubleArray_IsSorted", _wrap_doubleArray_IsSorted, METH_O, "doubleArray_IsSorted(doubleArray self) -> int"}, { "doubleArray_PartialSum", _wrap_doubleArray_PartialSum, METH_O, "doubleArray_PartialSum(doubleArray self)"}, { "doubleArray_Sum", _wrap_doubleArray_Sum, METH_O, "doubleArray_Sum(doubleArray self) -> double"}, - { "doubleArray_begin", _wrap_doubleArray_begin, METH_O, "doubleArray_begin(doubleArray self) -> double *"}, - { "doubleArray_end", _wrap_doubleArray_end, METH_O, "doubleArray_end(doubleArray self) -> double *"}, + { "doubleArray_begin", _wrap_doubleArray_begin, METH_VARARGS, "\n" + "doubleArray_begin(doubleArray self) -> double\n" + "doubleArray_begin(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_end", _wrap_doubleArray_end, METH_VARARGS, "\n" + "doubleArray_end(doubleArray self) -> double\n" + "doubleArray_end(doubleArray self) -> double const *\n" + ""}, { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "doubleArray_MemoryUsage(doubleArray self) -> long"}, { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "doubleArray_Read(doubleArray self, bool on_dev=True) -> double const"}, { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "doubleArray_HostRead(doubleArray self) -> double const *"}, @@ -11774,6 +12165,208 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intArray", _wrap_new_intArray, METH_VARARGS, "\n" + "intArray()\n" + "intArray(mfem::MemoryType mt)\n" + "intArray(int asize)\n" + "intArray(int * _data)\n" + "new_intArray(intArray src) -> intArray\n" + ""}, + { "delete_intArray", _wrap_delete_intArray, METH_O, "delete_intArray(intArray self)"}, + { "intArray_GetData", _wrap_intArray_GetData, METH_VARARGS, "\n" + "GetData(intArray self) -> int\n" + "GetData(intArray self) -> int const *\n" + ""}, + { "intArray_GetMemory", _wrap_intArray_GetMemory, METH_VARARGS, "\n" + "GetMemory(intArray self) -> mfem::Memory< int >\n" + "GetMemory(intArray self) -> mfem::Memory< int > const &\n" + ""}, + { "intArray_UseDevice", _wrap_intArray_UseDevice, METH_O, "UseDevice(intArray self) -> bool"}, + { "intArray_OwnsData", _wrap_intArray_OwnsData, METH_O, "OwnsData(intArray self) -> bool"}, + { "intArray_StealData", _wrap_intArray_StealData, METH_VARARGS, "StealData(intArray self, int ** p)"}, + { "intArray_LoseData", _wrap_intArray_LoseData, METH_O, "LoseData(intArray self)"}, + { "intArray_MakeDataOwner", _wrap_intArray_MakeDataOwner, METH_O, "MakeDataOwner(intArray self)"}, + { "intArray_Size", _wrap_intArray_Size, METH_O, "Size(intArray self) -> int"}, + { "intArray_SetSize", _wrap_intArray_SetSize, METH_VARARGS, "\n" + "SetSize(intArray self, int nsize)\n" + "SetSize(intArray self, int nsize, int const & initval)\n" + "SetSize(intArray self, int nsize, mfem::MemoryType mt)\n" + ""}, + { "intArray_Capacity", _wrap_intArray_Capacity, METH_O, "Capacity(intArray self) -> int"}, + { "intArray_Reserve", _wrap_intArray_Reserve, METH_VARARGS, "Reserve(intArray self, int capacity)"}, + { "intArray_Append", _wrap_intArray_Append, METH_VARARGS, "\n" + "Append(intArray self, int const & el) -> int\n" + "Append(intArray self, int const * els, int nels) -> int\n" + "Append(intArray self, intArray els) -> int\n" + ""}, + { "intArray_Prepend", _wrap_intArray_Prepend, METH_VARARGS, "Prepend(intArray self, int const & el) -> int"}, + { "intArray_Last", _wrap_intArray_Last, METH_VARARGS, "\n" + "Last(intArray self) -> int\n" + "Last(intArray self) -> int const &\n" + ""}, + { "intArray_Union", _wrap_intArray_Union, METH_VARARGS, "Union(intArray self, int const & el) -> int"}, + { "intArray_Find", _wrap_intArray_Find, METH_VARARGS, "Find(intArray self, int const & el) -> int"}, + { "intArray_FindSorted", _wrap_intArray_FindSorted, METH_VARARGS, "FindSorted(intArray self, int const & el) -> int"}, + { "intArray_DeleteLast", _wrap_intArray_DeleteLast, METH_O, "DeleteLast(intArray self)"}, + { "intArray_DeleteFirst", _wrap_intArray_DeleteFirst, METH_VARARGS, "DeleteFirst(intArray self, int const & el)"}, + { "intArray_DeleteAll", _wrap_intArray_DeleteAll, METH_O, "DeleteAll(intArray self)"}, + { "intArray_Copy", _wrap_intArray_Copy, METH_VARARGS, "Copy(intArray self, intArray copy)"}, + { "intArray_MakeRef", _wrap_intArray_MakeRef, METH_VARARGS, "\n" + "MakeRef(intArray self, int * arg2, int arg3)\n" + "MakeRef(intArray self, intArray master)\n" + ""}, + { "intArray_GetSubArray", _wrap_intArray_GetSubArray, METH_VARARGS, "GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, + { "intArray_Load", _wrap_intArray_Load, METH_VARARGS, "\n" + "Load(intArray self, std::istream & _in, int fmt=0)\n" + "Load(intArray self, int new_size, std::istream & _in)\n" + ""}, + { "intArray_Max", _wrap_intArray_Max, METH_O, "Max(intArray self) -> int"}, + { "intArray_Min", _wrap_intArray_Min, METH_O, "Min(intArray self) -> int"}, + { "intArray_Sort", _wrap_intArray_Sort, METH_O, "Sort(intArray self)"}, + { "intArray_Unique", _wrap_intArray_Unique, METH_O, "Unique(intArray self)"}, + { "intArray_IsSorted", _wrap_intArray_IsSorted, METH_O, "IsSorted(intArray self) -> int"}, + { "intArray_PartialSum", _wrap_intArray_PartialSum, METH_O, "PartialSum(intArray self)"}, + { "intArray_Sum", _wrap_intArray_Sum, METH_O, "Sum(intArray self) -> int"}, + { "intArray_begin", _wrap_intArray_begin, METH_VARARGS, "\n" + "begin(intArray self) -> int\n" + "begin(intArray self) -> int const *\n" + ""}, + { "intArray_end", _wrap_intArray_end, METH_VARARGS, "\n" + "end(intArray self) -> int\n" + "end(intArray self) -> int const *\n" + ""}, + { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "MemoryUsage(intArray self) -> long"}, + { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "Read(intArray self, bool on_dev=True) -> int const"}, + { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "HostRead(intArray self) -> int const *"}, + { "intArray_Write", _wrap_intArray_Write, METH_VARARGS, "Write(intArray self, bool on_dev=True) -> int"}, + { "intArray_HostWrite", _wrap_intArray_HostWrite, METH_O, "HostWrite(intArray self) -> int *"}, + { "intArray_ReadWrite", _wrap_intArray_ReadWrite, METH_VARARGS, "ReadWrite(intArray self, bool on_dev=True) -> int"}, + { "intArray_HostReadWrite", _wrap_intArray_HostReadWrite, METH_O, "HostReadWrite(intArray self) -> int *"}, + { "intArray___setitem__", _wrap_intArray___setitem__, METH_VARARGS, "__setitem__(intArray self, int i, int const v)"}, + { "intArray___getitem__", _wrap_intArray___getitem__, METH_VARARGS, "__getitem__(intArray self, int const i) -> int const &"}, + { "intArray_Assign", _wrap_intArray_Assign, METH_VARARGS, "\n" + "Assign(intArray self, int const * arg2)\n" + "Assign(intArray self, int const & a)\n" + ""}, + { "intArray_FakeToList", _wrap_intArray_FakeToList, METH_O, "FakeToList(intArray self)"}, + { "intArray_Print", _wrap_intArray_Print, METH_VARARGS, "\n" + "Print(intArray self, std::ostream & out=mfem::out, int width=4)\n" + "Print(intArray self, char const * file, int precision=8)\n" + ""}, + { "intArray_Save", _wrap_intArray_Save, METH_VARARGS, "\n" + "Save(intArray self, std::ostream & out, int fmt=0)\n" + "Save(intArray self, char const * file, int precision=8)\n" + "Save(intArray self)\n" + ""}, + { "intArray_swigregister", intArray_swigregister, METH_O, NULL}, + { "intArray_swiginit", intArray_swiginit, METH_VARARGS, NULL}, + { "new_doubleArray", _wrap_new_doubleArray, METH_VARARGS, "\n" + "doubleArray()\n" + "doubleArray(mfem::MemoryType mt)\n" + "doubleArray(int asize)\n" + "doubleArray(double * _data)\n" + "new_doubleArray(doubleArray src) -> doubleArray\n" + ""}, + { "delete_doubleArray", _wrap_delete_doubleArray, METH_O, "delete_doubleArray(doubleArray self)"}, + { "doubleArray_GetData", _wrap_doubleArray_GetData, METH_VARARGS, "\n" + "GetData(doubleArray self) -> double\n" + "GetData(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_GetMemory", _wrap_doubleArray_GetMemory, METH_VARARGS, "\n" + "GetMemory(doubleArray self) -> mfem::Memory< double >\n" + "GetMemory(doubleArray self) -> mfem::Memory< double > const &\n" + ""}, + { "doubleArray_UseDevice", _wrap_doubleArray_UseDevice, METH_O, "UseDevice(doubleArray self) -> bool"}, + { "doubleArray_OwnsData", _wrap_doubleArray_OwnsData, METH_O, "OwnsData(doubleArray self) -> bool"}, + { "doubleArray_StealData", _wrap_doubleArray_StealData, METH_VARARGS, "StealData(doubleArray self, double ** p)"}, + { "doubleArray_LoseData", _wrap_doubleArray_LoseData, METH_O, "LoseData(doubleArray self)"}, + { "doubleArray_MakeDataOwner", _wrap_doubleArray_MakeDataOwner, METH_O, "MakeDataOwner(doubleArray self)"}, + { "doubleArray_Size", _wrap_doubleArray_Size, METH_O, "Size(doubleArray self) -> int"}, + { "doubleArray_SetSize", _wrap_doubleArray_SetSize, METH_VARARGS, "\n" + "SetSize(doubleArray self, int nsize)\n" + "SetSize(doubleArray self, int nsize, double const & initval)\n" + "SetSize(doubleArray self, int nsize, mfem::MemoryType mt)\n" + ""}, + { "doubleArray_Capacity", _wrap_doubleArray_Capacity, METH_O, "Capacity(doubleArray self) -> int"}, + { "doubleArray_Reserve", _wrap_doubleArray_Reserve, METH_VARARGS, "Reserve(doubleArray self, int capacity)"}, + { "doubleArray_Append", _wrap_doubleArray_Append, METH_VARARGS, "\n" + "Append(doubleArray self, double const & el) -> int\n" + "Append(doubleArray self, double const * els, int nels) -> int\n" + "Append(doubleArray self, doubleArray els) -> int\n" + ""}, + { "doubleArray_Prepend", _wrap_doubleArray_Prepend, METH_VARARGS, "Prepend(doubleArray self, double const & el) -> int"}, + { "doubleArray_Last", _wrap_doubleArray_Last, METH_VARARGS, "\n" + "Last(doubleArray self) -> double\n" + "Last(doubleArray self) -> double const &\n" + ""}, + { "doubleArray_Union", _wrap_doubleArray_Union, METH_VARARGS, "Union(doubleArray self, double const & el) -> int"}, + { "doubleArray_Find", _wrap_doubleArray_Find, METH_VARARGS, "Find(doubleArray self, double const & el) -> int"}, + { "doubleArray_FindSorted", _wrap_doubleArray_FindSorted, METH_VARARGS, "FindSorted(doubleArray self, double const & el) -> int"}, + { "doubleArray_DeleteLast", _wrap_doubleArray_DeleteLast, METH_O, "DeleteLast(doubleArray self)"}, + { "doubleArray_DeleteFirst", _wrap_doubleArray_DeleteFirst, METH_VARARGS, "DeleteFirst(doubleArray self, double const & el)"}, + { "doubleArray_DeleteAll", _wrap_doubleArray_DeleteAll, METH_O, "DeleteAll(doubleArray self)"}, + { "doubleArray_Copy", _wrap_doubleArray_Copy, METH_VARARGS, "Copy(doubleArray self, doubleArray copy)"}, + { "doubleArray_MakeRef", _wrap_doubleArray_MakeRef, METH_VARARGS, "\n" + "MakeRef(doubleArray self, double * arg2, int arg3)\n" + "MakeRef(doubleArray self, doubleArray master)\n" + ""}, + { "doubleArray_GetSubArray", _wrap_doubleArray_GetSubArray, METH_VARARGS, "GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, + { "doubleArray_Load", _wrap_doubleArray_Load, METH_VARARGS, "\n" + "Load(doubleArray self, std::istream & _in, int fmt=0)\n" + "Load(doubleArray self, int new_size, std::istream & _in)\n" + ""}, + { "doubleArray_Max", _wrap_doubleArray_Max, METH_O, "Max(doubleArray self) -> double"}, + { "doubleArray_Min", _wrap_doubleArray_Min, METH_O, "Min(doubleArray self) -> double"}, + { "doubleArray_Sort", _wrap_doubleArray_Sort, METH_O, "Sort(doubleArray self)"}, + { "doubleArray_Unique", _wrap_doubleArray_Unique, METH_O, "Unique(doubleArray self)"}, + { "doubleArray_IsSorted", _wrap_doubleArray_IsSorted, METH_O, "IsSorted(doubleArray self) -> int"}, + { "doubleArray_PartialSum", _wrap_doubleArray_PartialSum, METH_O, "PartialSum(doubleArray self)"}, + { "doubleArray_Sum", _wrap_doubleArray_Sum, METH_O, "Sum(doubleArray self) -> double"}, + { "doubleArray_begin", _wrap_doubleArray_begin, METH_VARARGS, "\n" + "begin(doubleArray self) -> double\n" + "begin(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_end", _wrap_doubleArray_end, METH_VARARGS, "\n" + "end(doubleArray self) -> double\n" + "end(doubleArray self) -> double const *\n" + ""}, + { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "MemoryUsage(doubleArray self) -> long"}, + { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "Read(doubleArray self, bool on_dev=True) -> double const"}, + { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "HostRead(doubleArray self) -> double const *"}, + { "doubleArray_Write", _wrap_doubleArray_Write, METH_VARARGS, "Write(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_HostWrite", _wrap_doubleArray_HostWrite, METH_O, "HostWrite(doubleArray self) -> double *"}, + { "doubleArray_ReadWrite", _wrap_doubleArray_ReadWrite, METH_VARARGS, "ReadWrite(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_HostReadWrite", _wrap_doubleArray_HostReadWrite, METH_O, "HostReadWrite(doubleArray self) -> double *"}, + { "doubleArray___setitem__", _wrap_doubleArray___setitem__, METH_VARARGS, "__setitem__(doubleArray self, int i, double const v)"}, + { "doubleArray___getitem__", _wrap_doubleArray___getitem__, METH_VARARGS, "__getitem__(doubleArray self, int const i) -> double const &"}, + { "doubleArray_Assign", _wrap_doubleArray_Assign, METH_VARARGS, "\n" + "Assign(doubleArray self, double const * arg2)\n" + "Assign(doubleArray self, double const & a)\n" + ""}, + { "doubleArray_FakeToList", _wrap_doubleArray_FakeToList, METH_O, "FakeToList(doubleArray self)"}, + { "doubleArray_Print", _wrap_doubleArray_Print, METH_VARARGS, "\n" + "Print(doubleArray self, std::ostream & out=mfem::out, int width=4)\n" + "Print(doubleArray self, char const * file, int precision=8)\n" + ""}, + { "doubleArray_Save", _wrap_doubleArray_Save, METH_VARARGS, "\n" + "Save(doubleArray self, std::ostream & out, int fmt=0)\n" + "Save(doubleArray self, char const * file, int precision=8)\n" + "Save(doubleArray self)\n" + ""}, + { "doubleArray_swigregister", doubleArray_swigregister, METH_O, NULL}, + { "doubleArray_swiginit", doubleArray_swiginit, METH_VARARGS, NULL}, + { "doubleSwap", _wrap_doubleSwap, METH_VARARGS, "\n" + "doubleSwap(doubleArray arg1, doubleArray arg2)\n" + "doubleSwap(mfem::Array2D< double > & arg1, mfem::Array2D< double > & arg2)\n" + "doubleSwap(double & a, double & b)\n" + ""}, + { "intSwap", _wrap_intSwap, METH_VARARGS, "\n" + "intSwap(intArray arg1, intArray arg2)\n" + "intSwap(mfem::Array2D< int > & arg1, mfem::Array2D< int > & arg2)\n" + "intSwap(int & a, int & b)\n" + ""}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/bilinearform.py b/mfem/_ser/bilinearform.py index 57b15d6b..dcb81683 100644 --- a/mfem/_ser/bilinearform.py +++ b/mfem/_ser/bilinearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _bilinearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _bilinearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -73,22 +76,27 @@ def __init__(self): def assign(self, value): return _bilinearform.intp_assign(self, value) + assign = _swig_new_instance_method(_bilinearform.intp_assign) def value(self): return _bilinearform.intp_value(self) + value = _swig_new_instance_method(_bilinearform.intp_value) def cast(self): return _bilinearform.intp_cast(self) + cast = _swig_new_instance_method(_bilinearform.intp_cast) @staticmethod def frompointer(t): return _bilinearform.intp_frompointer(t) + frompointer = _swig_new_static_method(_bilinearform.intp_frompointer) # Register intp in _bilinearform: _bilinearform.intp_swigregister(intp) def intp_frompointer(t): return _bilinearform.intp_frompointer(t) +intp_frompointer = _bilinearform.intp_frompointer class doublep(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -100,22 +108,27 @@ def __init__(self): def assign(self, value): return _bilinearform.doublep_assign(self, value) + assign = _swig_new_instance_method(_bilinearform.doublep_assign) def value(self): return _bilinearform.doublep_value(self) + value = _swig_new_instance_method(_bilinearform.doublep_value) def cast(self): return _bilinearform.doublep_cast(self) + cast = _swig_new_instance_method(_bilinearform.doublep_cast) @staticmethod def frompointer(t): return _bilinearform.doublep_frompointer(t) + frompointer = _swig_new_static_method(_bilinearform.doublep_frompointer) # Register doublep in _bilinearform: _bilinearform.doublep_swigregister(doublep) def doublep_frompointer(t): return _bilinearform.doublep_frompointer(t) +doublep_frompointer = _bilinearform.doublep_frompointer import mfem._ser.mem_manager import mfem._ser.array @@ -141,7 +154,9 @@ def doublep_frompointer(t): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.handle +import mfem._ser.restriction AssemblyLevel_FULL = _bilinearform.AssemblyLevel_FULL AssemblyLevel_ELEMENT = _bilinearform.AssemblyLevel_ELEMENT @@ -171,22 +186,32 @@ def __init__(self, *args): def Size(self): r"""Size(BilinearForm self) -> int""" return _bilinearform.BilinearForm_Size(self) + Size = _swig_new_instance_method(_bilinearform.BilinearForm_Size) def SetAssemblyLevel(self, assembly_level): r"""SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)""" return _bilinearform.BilinearForm_SetAssemblyLevel(self, assembly_level) + SetAssemblyLevel = _swig_new_instance_method(_bilinearform.BilinearForm_SetAssemblyLevel) + + def GetAssemblyLevel(self): + r"""GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel""" + return _bilinearform.BilinearForm_GetAssemblyLevel(self) + GetAssemblyLevel = _swig_new_instance_method(_bilinearform.BilinearForm_GetAssemblyLevel) def EnableStaticCondensation(self): r"""EnableStaticCondensation(BilinearForm self)""" return _bilinearform.BilinearForm_EnableStaticCondensation(self) + EnableStaticCondensation = _swig_new_instance_method(_bilinearform.BilinearForm_EnableStaticCondensation) def StaticCondensationIsEnabled(self): r"""StaticCondensationIsEnabled(BilinearForm self) -> bool""" return _bilinearform.BilinearForm_StaticCondensationIsEnabled(self) + StaticCondensationIsEnabled = _swig_new_instance_method(_bilinearform.BilinearForm_StaticCondensationIsEnabled) def SCFESpace(self): r"""SCFESpace(BilinearForm self) -> FiniteElementSpace""" return _bilinearform.BilinearForm_SCFESpace(self) + SCFESpace = _swig_new_instance_method(_bilinearform.BilinearForm_SCFESpace) def EnableHybridization(self, constr_space, constr_integ, ess_tdof_list): r"""EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)""" @@ -203,6 +228,7 @@ def EnableHybridization(self, constr_space, constr_integ, ess_tdof_list): def UsePrecomputedSparsity(self, ps=1): r"""UsePrecomputedSparsity(BilinearForm self, int ps=1)""" return _bilinearform.BilinearForm_UsePrecomputedSparsity(self, ps) + UsePrecomputedSparsity = _swig_new_instance_method(_bilinearform.BilinearForm_UsePrecomputedSparsity) def UseSparsity(self, *args): r""" @@ -210,38 +236,47 @@ def UseSparsity(self, *args): UseSparsity(BilinearForm self, SparseMatrix A) """ return _bilinearform.BilinearForm_UseSparsity(self, *args) + UseSparsity = _swig_new_instance_method(_bilinearform.BilinearForm_UseSparsity) def AllocateMatrix(self): r"""AllocateMatrix(BilinearForm self)""" return _bilinearform.BilinearForm_AllocateMatrix(self) + AllocateMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_AllocateMatrix) def GetDBFI(self): r"""GetDBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetDBFI(self) + GetDBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetDBFI) def GetBBFI(self): r"""GetBBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetBBFI(self) + GetBBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetBBFI) def GetBBFI_Marker(self): r"""GetBBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" return _bilinearform.BilinearForm_GetBBFI_Marker(self) + GetBBFI_Marker = _swig_new_instance_method(_bilinearform.BilinearForm_GetBBFI_Marker) def GetFBFI(self): r"""GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetFBFI(self) + GetFBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetFBFI) def GetBFBFI(self): r"""GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.BilinearForm_GetBFBFI(self) + GetBFBFI = _swig_new_instance_method(_bilinearform.BilinearForm_GetBFBFI) def GetBFBFI_Marker(self): r"""GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" return _bilinearform.BilinearForm_GetBFBFI_Marker(self) + GetBFBFI_Marker = _swig_new_instance_method(_bilinearform.BilinearForm_GetBFBFI_Marker) def __call__(self, i, j): r"""__call__(BilinearForm self, int i, int j) -> double const &""" return _bilinearform.BilinearForm___call__(self, i, j) + __call__ = _swig_new_instance_method(_bilinearform.BilinearForm___call__) def Elem(self, *args): r""" @@ -249,46 +284,57 @@ def Elem(self, *args): Elem(BilinearForm self, int i, int j) -> double const & """ return _bilinearform.BilinearForm_Elem(self, *args) + Elem = _swig_new_instance_method(_bilinearform.BilinearForm_Elem) def Mult(self, x, y): r"""Mult(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_bilinearform.BilinearForm_Mult) def FullMult(self, x, y): r"""FullMult(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_FullMult(self, x, y) + FullMult = _swig_new_instance_method(_bilinearform.BilinearForm_FullMult) def AddMult(self, x, y, a=1.0): r"""AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)""" return _bilinearform.BilinearForm_AddMult(self, x, y, a) + AddMult = _swig_new_instance_method(_bilinearform.BilinearForm_AddMult) def FullAddMult(self, x, y): r"""FullAddMult(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_FullAddMult(self, x, y) + FullAddMult = _swig_new_instance_method(_bilinearform.BilinearForm_FullAddMult) def AddMultTranspose(self, x, y, a=1.0): r"""AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)""" return _bilinearform.BilinearForm_AddMultTranspose(self, x, y, a) + AddMultTranspose = _swig_new_instance_method(_bilinearform.BilinearForm_AddMultTranspose) def FullAddMultTranspose(self, x, y): r"""FullAddMultTranspose(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_FullAddMultTranspose(self, x, y) + FullAddMultTranspose = _swig_new_instance_method(_bilinearform.BilinearForm_FullAddMultTranspose) def MultTranspose(self, x, y): r"""MultTranspose(BilinearForm self, Vector x, Vector y)""" return _bilinearform.BilinearForm_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_bilinearform.BilinearForm_MultTranspose) def InnerProduct(self, x, y): r"""InnerProduct(BilinearForm self, Vector x, Vector y) -> double""" return _bilinearform.BilinearForm_InnerProduct(self, x, y) + InnerProduct = _swig_new_instance_method(_bilinearform.BilinearForm_InnerProduct) def Inverse(self): r"""Inverse(BilinearForm self) -> MatrixInverse""" return _bilinearform.BilinearForm_Inverse(self) + Inverse = _swig_new_instance_method(_bilinearform.BilinearForm_Inverse) def Finalize(self, skip_zeros=1): r"""Finalize(BilinearForm self, int skip_zeros=1)""" return _bilinearform.BilinearForm_Finalize(self, skip_zeros) + Finalize = _swig_new_instance_method(_bilinearform.BilinearForm_Finalize) def SpMat(self, *args): r""" @@ -308,6 +354,7 @@ def SpMat(self, *args): def LoseMat(self): r"""LoseMat(BilinearForm self) -> SparseMatrix""" return _bilinearform.BilinearForm_LoseMat(self) + LoseMat = _swig_new_instance_method(_bilinearform.BilinearForm_LoseMat) def SpMatElim(self, *args): r""" @@ -315,6 +362,7 @@ def SpMatElim(self, *args): SpMatElim(BilinearForm self) -> SparseMatrix """ return _bilinearform.BilinearForm_SpMatElim(self, *args) + SpMatElim = _swig_new_instance_method(_bilinearform.BilinearForm_SpMatElim) def AddDomainIntegrator(self, bfi): r"""AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)""" @@ -371,38 +419,73 @@ def AddBdrFaceIntegrator(self, *args): def Assemble(self, skip_zeros=1): r"""Assemble(BilinearForm self, int skip_zeros=1)""" return _bilinearform.BilinearForm_Assemble(self, skip_zeros) + Assemble = _swig_new_instance_method(_bilinearform.BilinearForm_Assemble) + + def AssembleDiagonal(self, diag): + r"""AssembleDiagonal(BilinearForm self, Vector diag)""" + return _bilinearform.BilinearForm_AssembleDiagonal(self, diag) + AssembleDiagonal = _swig_new_instance_method(_bilinearform.BilinearForm_AssembleDiagonal) def GetProlongation(self): r"""GetProlongation(BilinearForm self) -> Operator""" return _bilinearform.BilinearForm_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_bilinearform.BilinearForm_GetProlongation) def GetRestriction(self): r"""GetRestriction(BilinearForm self) -> Operator""" return _bilinearform.BilinearForm_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_bilinearform.BilinearForm_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(BilinearForm self) -> Operator""" + return _bilinearform.BilinearForm_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_bilinearform.BilinearForm_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(BilinearForm self) -> Operator""" + return _bilinearform.BilinearForm_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_bilinearform.BilinearForm_GetOutputRestriction) def RecoverFEMSolution(self, X, b, x): r"""RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)""" return _bilinearform.BilinearForm_RecoverFEMSolution(self, X, b, x) + RecoverFEMSolution = _swig_new_instance_method(_bilinearform.BilinearForm_RecoverFEMSolution) def ComputeElementMatrices(self): r"""ComputeElementMatrices(BilinearForm self)""" return _bilinearform.BilinearForm_ComputeElementMatrices(self) + ComputeElementMatrices = _swig_new_instance_method(_bilinearform.BilinearForm_ComputeElementMatrices) def FreeElementMatrices(self): r"""FreeElementMatrices(BilinearForm self)""" return _bilinearform.BilinearForm_FreeElementMatrices(self) + FreeElementMatrices = _swig_new_instance_method(_bilinearform.BilinearForm_FreeElementMatrices) def ComputeElementMatrix(self, i, elmat): r"""ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)""" return _bilinearform.BilinearForm_ComputeElementMatrix(self, i, elmat) + ComputeElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_ComputeElementMatrix) + + def ComputeBdrElementMatrix(self, i, elmat): + r"""ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)""" + return _bilinearform.BilinearForm_ComputeBdrElementMatrix(self, i, elmat) + ComputeBdrElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_ComputeBdrElementMatrix) - def AssembleElementMatrix(self, i, elmat, vdofs, skip_zeros=1): - r"""AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)""" - return _bilinearform.BilinearForm_AssembleElementMatrix(self, i, elmat, vdofs, skip_zeros) + def AssembleElementMatrix(self, *args): + r""" + AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1) + """ + return _bilinearform.BilinearForm_AssembleElementMatrix(self, *args) + AssembleElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_AssembleElementMatrix) - def AssembleBdrElementMatrix(self, i, elmat, vdofs, skip_zeros=1): - r"""AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)""" - return _bilinearform.BilinearForm_AssembleBdrElementMatrix(self, i, elmat, vdofs, skip_zeros) + def AssembleBdrElementMatrix(self, *args): + r""" + AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1) + """ + return _bilinearform.BilinearForm_AssembleBdrElementMatrix(self, *args) + AssembleBdrElementMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_AssembleBdrElementMatrix) def EliminateEssentialBC(self, *args): r""" @@ -410,10 +493,12 @@ def EliminateEssentialBC(self, *args): EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _bilinearform.BilinearForm_EliminateEssentialBC(self, *args) + EliminateEssentialBC = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBC) def EliminateEssentialBCDiag(self, bdr_attr_is_ess, value): r"""EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)""" return _bilinearform.BilinearForm_EliminateEssentialBCDiag(self, bdr_attr_is_ess, value) + EliminateEssentialBCDiag = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBCDiag) def EliminateVDofs(self, *args): r""" @@ -421,6 +506,7 @@ def EliminateVDofs(self, *args): EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _bilinearform.BilinearForm_EliminateVDofs(self, *args) + EliminateVDofs = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateVDofs) def EliminateEssentialBCFromDofs(self, *args): r""" @@ -428,26 +514,32 @@ def EliminateEssentialBCFromDofs(self, *args): EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _bilinearform.BilinearForm_EliminateEssentialBCFromDofs(self, *args) + EliminateEssentialBCFromDofs = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBCFromDofs) def EliminateEssentialBCFromDofsDiag(self, ess_dofs, value): r"""EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)""" return _bilinearform.BilinearForm_EliminateEssentialBCFromDofsDiag(self, ess_dofs, value) + EliminateEssentialBCFromDofsDiag = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateEssentialBCFromDofsDiag) def EliminateVDofsInRHS(self, vdofs, x, b): r"""EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)""" return _bilinearform.BilinearForm_EliminateVDofsInRHS(self, vdofs, x, b) + EliminateVDofsInRHS = _swig_new_instance_method(_bilinearform.BilinearForm_EliminateVDofsInRHS) def FullInnerProduct(self, x, y): r"""FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double""" return _bilinearform.BilinearForm_FullInnerProduct(self, x, y) + FullInnerProduct = _swig_new_instance_method(_bilinearform.BilinearForm_FullInnerProduct) def Update(self, nfes=None): r"""Update(BilinearForm self, FiniteElementSpace nfes=None)""" return _bilinearform.BilinearForm_Update(self, nfes) + Update = _swig_new_instance_method(_bilinearform.BilinearForm_Update) def GetFES(self): r"""GetFES(BilinearForm self) -> FiniteElementSpace""" return _bilinearform.BilinearForm_GetFES(self) + GetFES = _swig_new_instance_method(_bilinearform.BilinearForm_GetFES) def FESpace(self, *args): r""" @@ -455,10 +547,17 @@ def FESpace(self, *args): FESpace(BilinearForm self) -> FiniteElementSpace """ return _bilinearform.BilinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_bilinearform.BilinearForm_FESpace) def SetDiagonalPolicy(self, policy): r"""SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)""" return _bilinearform.BilinearForm_SetDiagonalPolicy(self, policy) + SetDiagonalPolicy = _swig_new_instance_method(_bilinearform.BilinearForm_SetDiagonalPolicy) + + def UseExternalIntegrators(self): + r"""UseExternalIntegrators(BilinearForm self)""" + return _bilinearform.BilinearForm_UseExternalIntegrators(self) + UseExternalIntegrators = _swig_new_instance_method(_bilinearform.BilinearForm_UseExternalIntegrators) __swig_destroy__ = _bilinearform.delete_BilinearForm def FormLinearSystem(self, *args): @@ -467,6 +566,7 @@ def FormLinearSystem(self, *args): FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, SparseMatrix A, Vector X, Vector B, int copy_interior=0) """ return _bilinearform.BilinearForm_FormLinearSystem(self, *args) + FormLinearSystem = _swig_new_instance_method(_bilinearform.BilinearForm_FormLinearSystem) def FormSystemMatrix(self, *args): r""" @@ -474,6 +574,7 @@ def FormSystemMatrix(self, *args): FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A) """ return _bilinearform.BilinearForm_FormSystemMatrix(self, *args) + FormSystemMatrix = _swig_new_instance_method(_bilinearform.BilinearForm_FormSystemMatrix) def __disown__(self): self.this.disown() _bilinearform.disown_BilinearForm(self) @@ -501,34 +602,42 @@ def Elem(self, *args): Elem(MixedBilinearForm self, int i, int j) -> double const & """ return _bilinearform.MixedBilinearForm_Elem(self, *args) + Elem = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Elem) def Mult(self, x, y): r"""Mult(MixedBilinearForm self, Vector x, Vector y)""" return _bilinearform.MixedBilinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Mult) def AddMult(self, x, y, a=1.0): r"""AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)""" return _bilinearform.MixedBilinearForm_AddMult(self, x, y, a) - - def AddMultTranspose(self, x, y, a=1.0): - r"""AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)""" - return _bilinearform.MixedBilinearForm_AddMultTranspose(self, x, y, a) + AddMult = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(MixedBilinearForm self, Vector x, Vector y)""" return _bilinearform.MixedBilinearForm_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_bilinearform.MixedBilinearForm_MultTranspose) + + def AddMultTranspose(self, x, y, a=1.0): + r"""AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)""" + return _bilinearform.MixedBilinearForm_AddMultTranspose(self, x, y, a) + AddMultTranspose = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AddMultTranspose) def Inverse(self): r"""Inverse(MixedBilinearForm self) -> MatrixInverse""" return _bilinearform.MixedBilinearForm_Inverse(self) + Inverse = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Inverse) def Finalize(self, skip_zeros=1): r"""Finalize(MixedBilinearForm self, int skip_zeros=1)""" return _bilinearform.MixedBilinearForm_Finalize(self, skip_zeros) + Finalize = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Finalize) def GetBlocks(self, blocks): r"""GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)""" return _bilinearform.MixedBilinearForm_GetBlocks(self, blocks) + GetBlocks = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBlocks) def SpMat(self, *args): r""" @@ -548,6 +657,7 @@ def SpMat(self, *args): def LoseMat(self): r"""LoseMat(MixedBilinearForm self) -> SparseMatrix""" return _bilinearform.MixedBilinearForm_LoseMat(self) + LoseMat = _swig_new_instance_method(_bilinearform.MixedBilinearForm_LoseMat) def AddDomainIntegrator(self, bfi): r"""AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)""" @@ -560,15 +670,18 @@ def AddDomainIntegrator(self, bfi): return _bilinearform.MixedBilinearForm_AddDomainIntegrator(self, bfi) - def AddBoundaryIntegrator(self, bfi): - r"""AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)""" + def AddBoundaryIntegrator(self, *args): + r""" + AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi) + AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker) + """ if not hasattr(self, "_integrators"): self._integrators = [] self._integrators.append(bfi) bfi.thisown=0 - return _bilinearform.MixedBilinearForm_AddBoundaryIntegrator(self, bfi) + return _bilinearform.MixedBilinearForm_AddBoundaryIntegrator(self, *args) def AddTraceFaceIntegrator(self, bfi): @@ -582,41 +695,150 @@ def AddTraceFaceIntegrator(self, bfi): return _bilinearform.MixedBilinearForm_AddTraceFaceIntegrator(self, bfi) + def AddBdrTraceFaceIntegrator(self, *args): + r""" + AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi) + AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker) + """ + return _bilinearform.MixedBilinearForm_AddBdrTraceFaceIntegrator(self, *args) + AddBdrTraceFaceIntegrator = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AddBdrTraceFaceIntegrator) + def GetDBFI(self): r"""GetDBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.MixedBilinearForm_GetDBFI(self) + GetDBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetDBFI) def GetBBFI(self): r"""GetBBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.MixedBilinearForm_GetBBFI(self) + GetBBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBBFI) + + def GetBBFI_Marker(self): + r"""GetBBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" + return _bilinearform.MixedBilinearForm_GetBBFI_Marker(self) + GetBBFI_Marker = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBBFI_Marker) def GetTFBFI(self): r"""GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.MixedBilinearForm_GetTFBFI(self) + GetTFBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetTFBFI) + + def GetBTFBFI(self): + r"""GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" + return _bilinearform.MixedBilinearForm_GetBTFBFI(self) + GetBTFBFI = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBTFBFI) + + def GetBTFBFI_Marker(self): + r"""GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *""" + return _bilinearform.MixedBilinearForm_GetBTFBFI_Marker(self) + GetBTFBFI_Marker = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetBTFBFI_Marker) + + def SetAssemblyLevel(self, assembly_level): + r"""SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)""" + return _bilinearform.MixedBilinearForm_SetAssemblyLevel(self, assembly_level) + SetAssemblyLevel = _swig_new_instance_method(_bilinearform.MixedBilinearForm_SetAssemblyLevel) def Assemble(self, skip_zeros=1): r"""Assemble(MixedBilinearForm self, int skip_zeros=1)""" return _bilinearform.MixedBilinearForm_Assemble(self, skip_zeros) + Assemble = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Assemble) + + def GetProlongation(self): + r"""GetProlongation(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetProlongation) + + def GetRestriction(self): + r"""GetRestriction(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(MixedBilinearForm self) -> Operator""" + return _bilinearform.MixedBilinearForm_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_bilinearform.MixedBilinearForm_GetOutputRestriction) def ConformingAssemble(self): r"""ConformingAssemble(MixedBilinearForm self)""" return _bilinearform.MixedBilinearForm_ConformingAssemble(self) + ConformingAssemble = _swig_new_instance_method(_bilinearform.MixedBilinearForm_ConformingAssemble) + + def ComputeElementMatrix(self, i, elmat): + r"""ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)""" + return _bilinearform.MixedBilinearForm_ComputeElementMatrix(self, i, elmat) + ComputeElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_ComputeElementMatrix) + + def ComputeBdrElementMatrix(self, i, elmat): + r"""ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)""" + return _bilinearform.MixedBilinearForm_ComputeBdrElementMatrix(self, i, elmat) + ComputeBdrElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_ComputeBdrElementMatrix) + + def AssembleElementMatrix(self, *args): + r""" + AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1) + """ + return _bilinearform.MixedBilinearForm_AssembleElementMatrix(self, *args) + AssembleElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AssembleElementMatrix) + + def AssembleBdrElementMatrix(self, *args): + r""" + AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1) + AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1) + """ + return _bilinearform.MixedBilinearForm_AssembleBdrElementMatrix(self, *args) + AssembleBdrElementMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_AssembleBdrElementMatrix) def EliminateTrialDofs(self, bdr_attr_is_ess, sol, rhs): r"""EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)""" return _bilinearform.MixedBilinearForm_EliminateTrialDofs(self, bdr_attr_is_ess, sol, rhs) + EliminateTrialDofs = _swig_new_instance_method(_bilinearform.MixedBilinearForm_EliminateTrialDofs) def EliminateEssentialBCFromTrialDofs(self, marked_vdofs, sol, rhs): r"""EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)""" return _bilinearform.MixedBilinearForm_EliminateEssentialBCFromTrialDofs(self, marked_vdofs, sol, rhs) + EliminateEssentialBCFromTrialDofs = _swig_new_instance_method(_bilinearform.MixedBilinearForm_EliminateEssentialBCFromTrialDofs) def EliminateTestDofs(self, bdr_attr_is_ess): r"""EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)""" return _bilinearform.MixedBilinearForm_EliminateTestDofs(self, bdr_attr_is_ess) + EliminateTestDofs = _swig_new_instance_method(_bilinearform.MixedBilinearForm_EliminateTestDofs) + + def FormRectangularSystemMatrix(self, trial_tdof_list, test_tdof_list, A): + r"""FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)""" + return _bilinearform.MixedBilinearForm_FormRectangularSystemMatrix(self, trial_tdof_list, test_tdof_list, A) + FormRectangularSystemMatrix = _swig_new_instance_method(_bilinearform.MixedBilinearForm_FormRectangularSystemMatrix) + + def FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B): + r"""FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)""" + return _bilinearform.MixedBilinearForm_FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B) + FormRectangularLinearSystem = _swig_new_instance_method(_bilinearform.MixedBilinearForm_FormRectangularLinearSystem) def Update(self): r"""Update(MixedBilinearForm self)""" return _bilinearform.MixedBilinearForm_Update(self) + Update = _swig_new_instance_method(_bilinearform.MixedBilinearForm_Update) + + def TrialFESpace(self, *args): + r""" + TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace + TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace + """ + return _bilinearform.MixedBilinearForm_TrialFESpace(self, *args) + TrialFESpace = _swig_new_instance_method(_bilinearform.MixedBilinearForm_TrialFESpace) + + def TestFESpace(self, *args): + r""" + TestFESpace(MixedBilinearForm self) -> FiniteElementSpace + TestFESpace(MixedBilinearForm self) -> FiniteElementSpace + """ + return _bilinearform.MixedBilinearForm_TestFESpace(self, *args) + TestFESpace = _swig_new_instance_method(_bilinearform.MixedBilinearForm_TestFESpace) __swig_destroy__ = _bilinearform.delete_MixedBilinearForm # Register MixedBilinearForm in _bilinearform: @@ -657,10 +879,12 @@ def AddTraceFaceInterpolator(self, di): def GetDI(self): r"""GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *""" return _bilinearform.DiscreteLinearOperator_GetDI(self) + GetDI = _swig_new_instance_method(_bilinearform.DiscreteLinearOperator_GetDI) def Assemble(self, skip_zeros=1): r"""Assemble(DiscreteLinearOperator self, int skip_zeros=1)""" return _bilinearform.DiscreteLinearOperator_Assemble(self, skip_zeros) + Assemble = _swig_new_instance_method(_bilinearform.DiscreteLinearOperator_Assemble) __swig_destroy__ = _bilinearform.delete_DiscreteLinearOperator # Register DiscreteLinearOperator in _bilinearform: diff --git a/mfem/_ser/bilinearform_wrap.cxx b/mfem/_ser/bilinearform_wrap.cxx index f161eaa4..3f3750c1 100644 --- a/mfem/_ser/bilinearform_wrap.cxx +++ b/mfem/_ser/bilinearform_wrap.cxx @@ -3066,130 +3066,138 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_double swig_types[2] -#define SWIGTYPE_p_doublep swig_types[3] -#define SWIGTYPE_p_hex_t swig_types[4] -#define SWIGTYPE_p_int swig_types[5] -#define SWIGTYPE_p_intp swig_types[6] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[7] -#define SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] -#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[10] -#define SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t swig_types[11] -#define SWIGTYPE_p_mfem__BilinearForm swig_types[12] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[15] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[17] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[18] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[20] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[21] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[22] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[23] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[24] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[25] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[26] -#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[27] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[29] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[31] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[32] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[33] -#define SWIGTYPE_p_mfem__GridFunction swig_types[34] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[35] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[36] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[37] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[38] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[39] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[40] -#define SWIGTYPE_p_mfem__LinearForm swig_types[41] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[42] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[43] -#define SWIGTYPE_p_mfem__Matrix swig_types[44] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[45] -#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[46] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[47] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[48] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[49] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[50] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[51] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[53] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[57] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[58] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[59] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[60] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[61] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[62] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[63] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[66] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[67] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[74] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[75] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[76] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[77] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[78] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[79] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[80] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[82] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[83] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[86] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__Operator swig_types[88] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[89] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[90] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[91] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[92] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[93] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[94] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[95] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[96] -#define SWIGTYPE_p_mfem__Solver swig_types[97] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[98] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[99] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[100] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[101] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[102] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[103] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[104] -#define SWIGTYPE_p_mfem__Vector swig_types[105] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[106] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[107] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[108] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[109] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[110] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[111] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[112] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[113] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[114] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[115] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[116] -#define SWIGTYPE_p_pri_t swig_types[117] -#define SWIGTYPE_p_quad_t swig_types[118] -#define SWIGTYPE_p_seg_t swig_types[119] -#define SWIGTYPE_p_std__ostream swig_types[120] -#define SWIGTYPE_p_tet_t swig_types[121] -#define SWIGTYPE_p_tri_t swig_types[122] -static swig_type_info *swig_types[124]; -static swig_module_info swig_module = {swig_types, 123, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_double swig_types[3] +#define SWIGTYPE_p_doublep swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_intp swig_types[7] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[8] +#define SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[10] +#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[11] +#define SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t swig_types[12] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[13] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[16] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[18] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[19] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[21] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[22] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[23] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[24] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[25] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[26] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[27] +#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[28] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[29] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[30] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[32] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[33] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[34] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[35] +#define SWIGTYPE_p_mfem__GridFunction swig_types[36] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[37] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[38] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[39] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[40] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[41] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[42] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[43] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[44] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[45] +#define SWIGTYPE_p_mfem__LinearForm swig_types[46] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[47] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[48] +#define SWIGTYPE_p_mfem__Matrix swig_types[49] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[50] +#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[51] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[52] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[53] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[56] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[57] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[60] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[61] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[62] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[63] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[64] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[65] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[66] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[69] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[70] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[76] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[77] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[78] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[79] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[80] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[81] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[84] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[85] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[91] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__Operator swig_types[93] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[94] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[95] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[96] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[97] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[98] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[99] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[100] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[101] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[102] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[103] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[104] +#define SWIGTYPE_p_mfem__Solver swig_types[105] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[106] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[107] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[108] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[109] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[110] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[111] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[112] +#define SWIGTYPE_p_mfem__Vector swig_types[113] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[114] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[115] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[116] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[117] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[118] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[119] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[120] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[121] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[122] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[123] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[124] +#define SWIGTYPE_p_pri_t swig_types[125] +#define SWIGTYPE_p_quad_t swig_types[126] +#define SWIGTYPE_p_seg_t swig_types[127] +#define SWIGTYPE_p_std__ostream swig_types[128] +#define SWIGTYPE_p_tet_t swig_types[129] +#define SWIGTYPE_p_tri_t swig_types[130] +static swig_type_info *swig_types[132]; +static swig_module_info swig_module = {swig_types, 131, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3755,6 +3763,80 @@ mfem::Operator const *SwigDirector_BilinearForm::GetRestriction() const { } +mfem::Operator const *SwigDirector_BilinearForm::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_BilinearForm::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_BilinearForm::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -3766,7 +3848,7 @@ void SwigDirector_BilinearForm::RecoverFEMSolution(mfem::Vector const &X, mfem:: Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -3802,7 +3884,7 @@ double &SwigDirector_BilinearForm::Elem(int i, int j) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "Elem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3842,7 +3924,7 @@ double const &SwigDirector_BilinearForm::Elem(int i, int j) const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 10; const char *const swig_method_name = "Elem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3880,7 +3962,7 @@ mfem::MatrixInverse *SwigDirector_BilinearForm::Inverse() const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 11; const char *const swig_method_name = "Inverse"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject args = PyTuple_New(0); @@ -3914,7 +3996,7 @@ void SwigDirector_BilinearForm::Finalize(int skip_zeros) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 12; const char *const swig_method_name = "Finalize"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -3942,7 +4024,7 @@ void SwigDirector_BilinearForm::Print(std::ostream &out, int width_) const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 11; + const size_t swig_method_index = 13; const char *const swig_method_name = "Print"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3972,7 +4054,7 @@ void SwigDirector_BilinearForm::AddMult(mfem::Vector const &x, mfem::Vector &y, Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 14; + const size_t swig_method_index = 16; const char *const swig_method_name = "AddMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4002,7 +4084,7 @@ void SwigDirector_BilinearForm::AddMultTranspose(mfem::Vector const &x, mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 16; + const size_t swig_method_index = 18; const char *const swig_method_name = "AddMultTranspose"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4040,7 +4122,7 @@ void SwigDirector_BilinearForm::FormLinearSystem(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 19; + const size_t swig_method_index = 21; const char *const swig_method_name = "FormLinearSystem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL); @@ -4068,7 +4150,7 @@ void SwigDirector_BilinearForm::FormSystemMatrix(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 21; + const size_t swig_method_index = 23; const char *const swig_method_name = "FormSystemMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -4094,7 +4176,7 @@ void SwigDirector_BilinearForm::Update(mfem::FiniteElementSpace *nfes) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 22; + const size_t swig_method_index = 24; const char *const swig_method_name = "Update"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4779,6 +4861,47 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPAR } +SWIGINTERN PyObject *_wrap_BilinearForm_GetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::AssemblyLevel result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetAssemblyLevel" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + try { + result = (mfem::AssemblyLevel)(arg1)->GetAssemblyLevel(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_BilinearForm_EnableStaticCondensation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -7646,6 +7769,56 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Assemble(PyObject *self, PyObject *args) } +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleDiagonal", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleDiagonal" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + ((mfem::BilinearForm const *)arg1)->AssembleDiagonal(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_BilinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -7758,102 +7931,32 @@ SWIGINTERN PyObject *_wrap_BilinearForm_GetRestriction(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::OperatorHandle *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; + PyObject *swig_obj[1] ; Swig::Director *director = 0; bool upcall = false; + mfem::Operator *result = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetOutputProlongation" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__OperatorHandle, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - arg5 = reinterpret_cast< mfem::OperatorHandle * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearForm::FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::GetOutputProlongation(); } else { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->GetOutputProlongation(); } } #ifdef MFEM_USE_EXCEPTIONS @@ -7874,22 +7977,204 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU } catch (Swig::DirectorException&) { SWIG_fail; } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::OperatorHandle *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetOutputRestriction" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::GetOutputRestriction(); + } else { + result = (mfem::Operator *)((mfem::BilinearForm const *)arg1)->GetOutputRestriction(); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::OperatorHandle *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + int arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + Swig::Director *director = 0; + bool upcall = false; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); + } + arg5 = reinterpret_cast< mfem::OperatorHandle * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearForm::FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + } else { + (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::OperatorHandle *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8290,24 +8575,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - int arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -8316,31 +8598,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject * }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); + (arg1)->ComputeBdrElementMatrix(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8364,18 +8632,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); @@ -8397,17 +8663,15 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8431,91 +8695,63 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleElementMatrix", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); - } - } - } - } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; @@ -8532,7 +8768,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -8543,18 +8779,18 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { @@ -8565,7 +8801,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8589,7 +8825,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; @@ -8605,7 +8841,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObjec if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -8616,23 +8852,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObjec } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8656,14 +8892,37 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleBdrElementMatrix", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleElementMatrix", 0, 5, argv))) SWIG_fail; --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } if (argc == 4) { int _v; void *vptr = 0; @@ -8686,7 +8945,40 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); } } } @@ -8723,7 +9015,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, } } if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); } } } @@ -8732,70 +9024,56 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleBdrElementMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int val5 ; - int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8819,54 +9097,39 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8890,40 +9153,57 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8947,32 +9227,50 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8996,42 +9294,61 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBC", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleBdrElementMatrix", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_3(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + } } } } - if (argc == 3) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); + } } } } @@ -9042,17 +9359,28 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); } } } @@ -9064,22 +9392,32 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); } } } @@ -9088,130 +9426,72 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBC'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleBdrElementMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - double arg3 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Matrix::DiagonalPolicy arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCDiag", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - (arg1)->EliminateEssentialBCDiag((mfem::Array< int > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int val5 ; - int ecode5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9235,7 +9515,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9253,36 +9533,36 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNU if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9306,7 +9586,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9321,25 +9601,25 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9363,7 +9643,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9375,20 +9655,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNU if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9412,13 +9692,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofs", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBC", 0, 5, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -9429,7 +9709,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_3(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_3(self, argc, argv); } } } @@ -9447,7 +9727,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_2(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_2(self, argc, argv); } } } @@ -9468,7 +9748,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); } } } @@ -9495,7 +9775,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_0(self, argc, argv); } } } @@ -9504,17 +9784,75 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateVDofs'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBC'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCDiag", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + (arg1)->EliminateEssentialBCDiag((mfem::Array< int > const &)*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9535,41 +9873,41 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9593,7 +9931,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9611,36 +9949,36 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyO if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9664,7 +10002,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9679,25 +10017,25 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyO if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9721,7 +10059,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9733,20 +10071,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyO if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9770,13 +10108,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofs", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofs", 0, 5, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -9787,7 +10125,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_3(self, argc, argv); } } } @@ -9805,7 +10143,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_2(self, argc, argv); } } } @@ -9826,7 +10164,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); } } } @@ -9853,7 +10191,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_EliminateVDofs__SWIG_0(self, argc, argv); } } } @@ -9862,51 +10200,72 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBCFromDofs'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateVDofs'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - double arg3 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Matrix::DiagonalPolicy arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofsDiag", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "3"" of type '" "double""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } - arg3 = static_cast< double >(val3); + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); { try { - (arg1)->EliminateEssentialBCFromDofsDiag((mfem::Array< int > const &)*arg2,arg3); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9930,7 +10289,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9944,41 +10303,40 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofsInRHS", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateVDofsInRHS((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10002,45 +10360,40 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Matrix::DiagonalPolicy arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - double result; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullInnerProduct", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullInnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - result = (double)((mfem::BilinearForm const *)arg1)->FullInnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10057,113 +10410,54 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - Swig::Director *director = 0; - bool upcall = false; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Update(arg2); - } else { - (arg1)->Update(arg2); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Update(); - } else { - (arg1)->Update(); - } - } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2); + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } - } catch (Swig::DirectorException&) { - SWIG_fail; +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } resultobj = SWIG_Py_Void(); return resultobj; @@ -10172,65 +10466,143 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Update", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofs", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_Update__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(self, argc, argv); + } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_Update__SWIG_0(self, argc, argv); - } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(self, argc, argv); + } + } + } + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Update'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBCFromDofs'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Update(mfem::FiniteElementSpace *)\n" - " mfem::BilinearForm::Update()\n"); + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_GetFES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElementSpace *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofsDiag", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetFES" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::FiniteElementSpace *)(arg1)->GetFES(); + (arg1)->EliminateEssentialBCFromDofsDiag((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10247,29 +10619,62 @@ SWIGINTERN PyObject *_wrap_BilinearForm_GetFES(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofsInRHS", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::FiniteElementSpace *)(arg1)->FESpace(); + (arg1)->EliminateVDofsInRHS((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10286,29 +10691,52 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + double result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullInnerProduct", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullInnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::FiniteElementSpace *)((mfem::BilinearForm const *)arg1)->FESpace(); + result = (double)((mfem::BilinearForm const *)arg1)->FullInnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10325,88 +10753,63 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FESpace(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FESpace", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FESpace__SWIG_0(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FESpace__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FESpace'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::FESpace()\n" - " mfem::BilinearForm::FESpace() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Matrix::DiagonalPolicy arg2 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 = 0 ; + int res2 = 0 ; + Swig::Director *director = 0; + bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetDiagonalPolicy", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "2"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg2 = static_cast< mfem::Matrix::DiagonalPolicy >(val2); - { - try { - (arg1)->SetDiagonalPolicy(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearForm::Update(arg2); + } else { + (arg1)->Update(arg2); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } resultobj = SWIG_Py_Void(); return resultobj; @@ -10415,23 +10818,115 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + Swig::Director *director = 0; + bool upcall = false; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearForm::Update(); + } else { + (arg1)->Update(); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Update", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_Update__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_Update__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Update'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::Update(mfem::FiniteElementSpace *)\n" + " mfem::BilinearForm::Update()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_GetFES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + mfem::FiniteElementSpace *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_GetFES" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - delete arg1; + result = (mfem::FiniteElementSpace *)(arg1)->GetFES(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10448,101 +10943,29 @@ SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::SparseMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; + mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + result = (mfem::FiniteElementSpace *)(arg1)->FESpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10559,94 +10982,29 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::SparseMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; + mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FESpace" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + result = (mfem::FiniteElementSpace *)((mfem::BilinearForm const *)arg1)->FESpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10663,242 +11021,73 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_FESpace(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[9] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FESpace", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); - } - } - } - } - } - } - } + return _wrap_BilinearForm_FESpace__SWIG_0(self, argc, argv); } } - if (argc == 8) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } + return _wrap_BilinearForm_FESpace__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormLinearSystem'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FESpace'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &)\n"); + " mfem::BilinearForm::FESpace()\n" + " mfem::BilinearForm::FESpace() const\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::SparseMatrix *arg3 = 0 ; + mfem::Matrix::DiagonalPolicy arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetDiagonalPolicy", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "2"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg2 = static_cast< mfem::Matrix::DiagonalPolicy >(val2); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormSystemMatrix< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3); + (arg1)->SetDiagonalPolicy(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10922,61 +11111,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_2(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormSystemMatrix", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormSystemMatrix__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormSystemMatrix__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormSystemMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::FormSystemMatrix(mfem::Array< int > const &,mfem::OperatorHandle &)\n" - " mfem::BilinearForm::FormSystemMatrix< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::SparseMatrix &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_UseExternalIntegrators(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; void *argp1 = 0 ; @@ -10987,14 +11122,28 @@ SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), P swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_UseExternalIntegrators" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { - Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); - if (director) director->swig_disown(); + try { + (arg1)->UseExternalIntegrators(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -11002,41 +11151,23 @@ SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *BilinearForm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BilinearForm, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BilinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::MixedBilinearForm *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11053,45 +11184,101 @@ SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - mfem::MixedBilinearForm *arg3 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::SparseMatrix *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + int arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - mfem::MixedBilinearForm *result = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MixedBilinearForm" "', argument " "3"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); } - arg3 = reinterpret_cast< mfem::MixedBilinearForm * >(argp3); { try { - result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2,arg3); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11108,94 +11295,2346 @@ SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedBilinearForm(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::SparseMatrix *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedBilinearForm", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedBilinearForm__SWIG_0(self, argc, argv); - } - } + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; + --argc; + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_5(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); + } + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormLinearSystem'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &,int)\n" + " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &)\n" + " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n" + " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::SparseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormSystemMatrix< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormSystemMatrix", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormSystemMatrix__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_FormSystemMatrix__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormSystemMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::FormSystemMatrix(mfem::Array< int > const &,mfem::OperatorHandle &)\n" + " mfem::BilinearForm::FormSystemMatrix< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::SparseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *BilinearForm_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BilinearForm, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BilinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::MixedBilinearForm *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MixedBilinearForm__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::MixedBilinearForm *arg3 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + mfem::MixedBilinearForm *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedBilinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MixedBilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MixedBilinearForm" "', argument " "3"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg3 = reinterpret_cast< mfem::MixedBilinearForm * >(argp3); + { + try { + result = (mfem::MixedBilinearForm *)new mfem::MixedBilinearForm(arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedBilinearForm, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MixedBilinearForm(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedBilinearForm", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedBilinearForm__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedBilinearForm__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedBilinearForm'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *)\n" + " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *,mfem::MixedBilinearForm *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (double *) &(arg1)->Elem(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (double *) &((mfem::MixedBilinearForm const *)arg1)->Elem(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_double(static_cast< double >(*result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Elem", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_Elem__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_Elem__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Elem'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::Elem(int,int)\n" + " mfem::MixedBilinearForm::Elem(int,int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Mult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMult", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AddMult__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[3])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AddMult__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMult'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" + " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[3])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMultTranspose'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" + " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MatrixInverse *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Inverse" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::MatrixInverse *)((mfem::MixedBilinearForm const *)arg1)->Inverse(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + (arg1)->Finalize(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + (arg1)->Finalize(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Finalize", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_Finalize__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_Finalize__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Finalize'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::Finalize(int)\n" + " mfem::MixedBilinearForm::Finalize()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_GetBlocks", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + } + arg2 = reinterpret_cast< mfem::Array2D< mfem::SparseMatrix * > * >(argp2); + { + try { + ((mfem::MixedBilinearForm const *)arg1)->GetBlocks(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &((mfem::MixedBilinearForm const *)arg1)->SpMat(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &(arg1)->SpMat(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SpMat", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_SpMat__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_SpMat__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_SpMat'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::SpMat() const\n" + " mfem::MixedBilinearForm::SpMat()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_LoseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::SparseMatrix *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_LoseMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::SparseMatrix *)(arg1)->LoseMat(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + { + try { + (arg1)->AddDomainIntegrator(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + { + try { + (arg1)->AddBoundaryIntegrator(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::Array< int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + { + try { + (arg1)->AddBoundaryIntegrator(arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddBoundaryIntegrator", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AddBoundaryIntegrator__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddBoundaryIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AddBoundaryIntegrator(mfem::BilinearFormIntegrator *)\n" + " mfem::MixedBilinearForm::AddBoundaryIntegrator(mfem::BilinearFormIntegrator *,mfem::Array< int > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddTraceFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + { + try { + (arg1)->AddTraceFaceIntegrator(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + { + try { + (arg1)->AddBdrTraceFaceIntegrator(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::Array< int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddBdrTraceFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + { + try { + (arg1)->AddBdrTraceFaceIntegrator(arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddBdrTraceFaceIntegrator", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedBilinearForm__SWIG_1(self, argc, argv); + return _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator__SWIG_1(self, argc, argv); } } } } - + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddBdrTraceFaceIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AddBdrTraceFaceIntegrator(mfem::BilinearFormIntegrator *)\n" + " mfem::MixedBilinearForm::AddBdrTraceFaceIntegrator(mfem::BilinearFormIntegrator *,mfem::Array< int > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetDBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetDBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetDBFI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetBBFI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBBFI_Marker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::Array< int > * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBBFI_Marker" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::Array< mfem::Array< int > * > *)(arg1)->GetBBFI_Marker(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetTFBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetTFBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetTFBFI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedBilinearForm'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *)\n" - " mfem::MixedBilinearForm::MixedBilinearForm(mfem::FiniteElementSpace *,mfem::FiniteElementSpace *,mfem::MixedBilinearForm *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBTFBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBTFBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetBTFBFI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBTFBFI_Marker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::Array< int > * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBTFBFI_Marker" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + try { + result = (mfem::Array< mfem::Array< int > * > *)(arg1)->GetBTFBFI_Marker(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::AssemblyLevel arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); + } + arg2 = static_cast< mfem::AssemblyLevel >(val2); { try { - result = (double *) &(arg1)->Elem(arg2,arg3); + (arg1)->SetAssemblyLevel(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11212,26 +13651,24 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { @@ -11241,14 +13678,46 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPA arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + try { + (arg1)->Assemble(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - result = (double *) &((mfem::MixedBilinearForm const *)arg1)->Elem(arg2,arg3); + (arg1)->Assemble(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11265,51 +13734,31 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(*result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Elem", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Assemble", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 3) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Elem__SWIG_0(self, argc, argv); - } - } + return _wrap_MixedBilinearForm_Assemble__SWIG_1(self, argc, argv); } } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -11324,68 +13773,79 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Elem__SWIG_1(self, argc, argv); - } + return _wrap_MixedBilinearForm_Assemble__SWIG_0(self, argc, argv); } } } - + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Assemble'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::Assemble(int)\n" + " mfem::MixedBilinearForm::Assemble()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetProlongation" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetProlongation(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Elem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Elem(int,int)\n" - " mfem::MixedBilinearForm::Elem(int,int) const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Mult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetRestriction" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetRestriction(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11402,58 +13862,31 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetOutputProlongation" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetOutputProlongation(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11470,50 +13903,31 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetOutputRestriction" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); + result = (mfem::Operator *)((mfem::MixedBilinearForm const *)arg1)->GetOutputRestriction(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11530,121 +13944,87 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_1(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ConformingAssemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_0(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + try { + (arg1)->ConformingAssemble(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeElementMatrix", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); + (arg1)->ComputeElementMatrix(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11668,43 +14048,40 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + (arg1)->ComputeBdrElementMatrix(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11728,107 +14105,46 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11852,24 +14168,39 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MatrixInverse *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Inverse" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - result = (mfem::MatrixInverse *)((mfem::MixedBilinearForm const *)arg1)->Inverse(); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11886,24 +14217,34 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { @@ -11912,9 +14253,39 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUS }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } { try { - (arg1)->Finalize(arg2); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11938,21 +14309,61 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); { try { - (arg1)->Finalize(); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11976,24 +14387,104 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Finalize", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleElementMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); + } + } + } + } + } + if (argc == 5) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_1(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); + } + } + } + } } } - if (argc == 2) { + if (argc == 6) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -12008,47 +14499,86 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *self, PyObject * } } if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_0(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); + } + } + } + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Finalize'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleElementMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Finalize(int)\n" - " mfem::MixedBilinearForm::Finalize()\n"); + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_GetBlocks", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg2 = reinterpret_cast< mfem::Array2D< mfem::SparseMatrix * > * >(argp2); { try { - ((mfem::MixedBilinearForm const *)arg1)->GetBlocks(*arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12072,61 +14602,39 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::SparseMatrix *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - try { - result = (mfem::SparseMatrix *) &((mfem::MixedBilinearForm const *)arg1)->SpMat(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SpMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - result = (mfem::SparseMatrix *) &(arg1)->SpMat(); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12143,114 +14651,75 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat__SWIG_1(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SpMat(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SpMat", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_SpMat__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_SpMat__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_SpMat'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::SpMat() const\n" - " mfem::MixedBilinearForm::SpMat()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_LoseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::SparseMatrix *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_LoseMat" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - try { - result = (mfem::SparseMatrix *)(arg1)->LoseMat(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); { try { - (arg1)->AddDomainIntegrator(arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12274,30 +14743,61 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + mfem::Array< int > *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddBoundaryIntegrator", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddBoundaryIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); { try { - (arg1)->AddBoundaryIntegrator(arg2); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12321,71 +14821,207 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *SWI } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddTraceFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleBdrElementMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + } + } + } } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + } + } + } + } } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - { - try { - (arg1)->AddTraceFaceIntegrator(arg2); + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); + } + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); + } + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleBdrElementMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetDBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTrialDofs", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetDBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetDBFI(); + (arg1)->EliminateTrialDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12402,31 +15038,62 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetDBFI(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetBBFI(); + (arg1)->EliminateEssentialBCFromTrialDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12443,31 +15110,40 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBBFI(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetTFBFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Array< mfem::BilinearFormIntegrator * > *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTestDofs", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetTFBFI" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - result = (mfem::Array< mfem::BilinearFormIntegrator * > *)(arg1)->GetTFBFI(); + (arg1)->EliminateTestDofs((mfem::Array< int > const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12484,35 +15160,62 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetTFBFI(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::OperatorHandle *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularSystemMatrix", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); + } + arg4 = reinterpret_cast< mfem::OperatorHandle * >(argp4); { try { - (arg1)->Assemble(arg2); + (arg1)->FormRectangularSystemMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12536,21 +15239,99 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::OperatorHandle *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); + } + arg6 = reinterpret_cast< mfem::OperatorHandle * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); { try { - (arg1)->Assemble(); + (arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12574,53 +15355,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Assemble(int)\n" - " mfem::MixedBilinearForm::Assemble()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; void *argp1 = 0 ; @@ -12631,12 +15366,12 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUN swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ConformingAssemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Update" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->ConformingAssemble(); + (arg1)->Update(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12653,62 +15388,29 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTrialDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TrialFESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::FiniteElementSpace *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TrialFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->EliminateTrialDofs(*arg2,(mfem::Vector const &)*arg3,*arg4); + result = (mfem::FiniteElementSpace *)(arg1)->TrialFESpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12725,62 +15427,29 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TrialFESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::FiniteElementSpace *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TrialFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateEssentialBCFromTrialDofs(*arg2,(mfem::Vector const &)*arg3,*arg4); + result = (mfem::FiniteElementSpace *)((mfem::MixedBilinearForm const *)arg1)->TrialFESpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12797,40 +15466,65 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TrialFESpace(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_TrialFESpace", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TrialFESpace__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TrialFESpace__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_TrialFESpace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::TrialFESpace()\n" + " mfem::MixedBilinearForm::TrialFESpace() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TestFESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::FiniteElementSpace *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTestDofs", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TestFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateTestDofs(*arg2); + result = (mfem::FiniteElementSpace *)(arg1)->TestFESpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12847,30 +15541,29 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TestFESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::FiniteElementSpace *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Update" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_TestFESpace" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->Update(); + result = (mfem::FiniteElementSpace *)((mfem::MixedBilinearForm const *)arg1)->TestFESpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12887,13 +15580,49 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Update(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } +SWIGINTERN PyObject *_wrap_MixedBilinearForm_TestFESpace(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_TestFESpace", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TestFESpace__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MixedBilinearForm_TestFESpace__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_TestFESpace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::TestFESpace()\n" + " mfem::MixedBilinearForm::TestFESpace() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_delete_MixedBilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; @@ -13310,6 +16039,7 @@ SWIGINTERN PyObject *DiscreteLinearOperator_swiginit(PyObject *SWIGUNUSEDPARM(se static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, @@ -13333,6 +16063,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "BilinearForm_Size(BilinearForm self) -> int"}, { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "BilinearForm_SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "BilinearForm_GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "BilinearForm_EnableStaticCondensation(BilinearForm self)"}, { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "BilinearForm_StaticCondensationIsEnabled(BilinearForm self) -> bool"}, { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "BilinearForm_SCFESpace(BilinearForm self) -> FiniteElementSpace"}, @@ -13384,14 +16115,24 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "BilinearForm_Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "BilinearForm_AssembleDiagonal(BilinearForm self, Vector diag)"}, { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "BilinearForm_GetProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "BilinearForm_GetRestriction(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "BilinearForm_GetOutputProlongation(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "BilinearForm_GetOutputRestriction(BilinearForm self) -> Operator"}, { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "BilinearForm_RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "BilinearForm_ComputeElementMatrices(BilinearForm self)"}, { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "BilinearForm_FreeElementMatrices(BilinearForm self)"}, { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "BilinearForm_ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, - { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)"}, - { "BilinearForm_AssembleBdrElementMatrix", _wrap_BilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "BilinearForm_AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)"}, + { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "BilinearForm_ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, + { "BilinearForm_AssembleBdrElementMatrix", _wrap_BilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "BilinearForm_AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "BilinearForm_AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, { "BilinearForm_EliminateEssentialBC", _wrap_BilinearForm_EliminateEssentialBC, METH_VARARGS, "\n" "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" @@ -13415,6 +16156,7 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_FESpace(BilinearForm self) -> FiniteElementSpace\n" ""}, { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "BilinearForm_SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "BilinearForm_UseExternalIntegrators(BilinearForm self)"}, { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" "BilinearForm_FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B, int copy_interior=0)\n" @@ -13437,8 +16179,8 @@ static PyMethodDef SwigMethods[] = { ""}, { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "MixedBilinearForm_Mult(MixedBilinearForm self, Vector x, Vector y)"}, { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "MixedBilinearForm_AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MixedBilinearForm_MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "MixedBilinearForm_Inverse(MixedBilinearForm self) -> MatrixInverse"}, { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "MixedBilinearForm_Finalize(MixedBilinearForm self, int skip_zeros=1)"}, { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "MixedBilinearForm_GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, @@ -13448,17 +16190,52 @@ static PyMethodDef SwigMethods[] = { ""}, { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "MixedBilinearForm_LoseMat(MixedBilinearForm self) -> SparseMatrix"}, { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "MixedBilinearForm_AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, - { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "MixedBilinearForm_AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" + "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, { "MixedBilinearForm_GetDBFI", _wrap_MixedBilinearForm_GetDBFI, METH_O, "MixedBilinearForm_GetDBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBBFI", _wrap_MixedBilinearForm_GetBBFI, METH_O, "MixedBilinearForm_GetBBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBBFI_Marker", _wrap_MixedBilinearForm_GetBBFI_Marker, METH_O, "MixedBilinearForm_GetBBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "MixedBilinearForm_GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "MixedBilinearForm_GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "MixedBilinearForm_GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "MixedBilinearForm_SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "MixedBilinearForm_Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "MixedBilinearForm_GetProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "MixedBilinearForm_GetRestriction(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "MixedBilinearForm_GetOutputProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "MixedBilinearForm_GetOutputRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "MixedBilinearForm_ConformingAssemble(MixedBilinearForm self)"}, + { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, + { "MixedBilinearForm_AssembleBdrElementMatrix", _wrap_MixedBilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "MixedBilinearForm_EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "MixedBilinearForm_FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "MixedBilinearForm_FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "MixedBilinearForm_Update(MixedBilinearForm self)"}, + { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" + "MixedBilinearForm_TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "MixedBilinearForm_TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + ""}, + { "MixedBilinearForm_TestFESpace", _wrap_MixedBilinearForm_TestFESpace, METH_VARARGS, "\n" + "MixedBilinearForm_TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "MixedBilinearForm_TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + ""}, { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, @@ -13474,6 +16251,215 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, + { "delete_intp", _wrap_delete_intp, METH_O, NULL}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_value", _wrap_intp_value, METH_O, NULL}, + { "intp_cast", _wrap_intp_cast, METH_O, NULL}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, + { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_value", _wrap_doublep_value, METH_O, NULL}, + { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "new_BilinearForm", _wrap_new_BilinearForm, METH_VARARGS, "\n" + "BilinearForm()\n" + "BilinearForm(FiniteElementSpace f)\n" + "BilinearForm(FiniteElementSpace f, BilinearForm bf, int ps=0)\n" + ""}, + { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "Size(BilinearForm self) -> int"}, + { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, + { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "EnableStaticCondensation(BilinearForm self)"}, + { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "StaticCondensationIsEnabled(BilinearForm self) -> bool"}, + { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "SCFESpace(BilinearForm self) -> FiniteElementSpace"}, + { "BilinearForm_EnableHybridization", _wrap_BilinearForm_EnableHybridization, METH_VARARGS, "EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, + { "BilinearForm_UsePrecomputedSparsity", _wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS, "UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, + { "BilinearForm_UseSparsity", _wrap_BilinearForm_UseSparsity, METH_VARARGS, "\n" + "UseSparsity(BilinearForm self, int * I, int * J, bool isSorted)\n" + "UseSparsity(BilinearForm self, SparseMatrix A)\n" + ""}, + { "BilinearForm_AllocateMatrix", _wrap_BilinearForm_AllocateMatrix, METH_O, "AllocateMatrix(BilinearForm self)"}, + { "BilinearForm_GetDBFI", _wrap_BilinearForm_GetDBFI, METH_O, "GetDBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBBFI", _wrap_BilinearForm_GetBBFI, METH_O, "GetBBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBBFI_Marker", _wrap_BilinearForm_GetBBFI_Marker, METH_O, "GetBBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "BilinearForm_GetFBFI", _wrap_BilinearForm_GetFBFI, METH_O, "GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBFBFI", _wrap_BilinearForm_GetBFBFI, METH_O, "GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "BilinearForm_GetBFBFI_Marker", _wrap_BilinearForm_GetBFBFI_Marker, METH_O, "GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "BilinearForm___call__", _wrap_BilinearForm___call__, METH_VARARGS, "__call__(BilinearForm self, int i, int j) -> double const &"}, + { "BilinearForm_Elem", _wrap_BilinearForm_Elem, METH_VARARGS, "\n" + "Elem(BilinearForm self, int i, int j) -> double\n" + "Elem(BilinearForm self, int i, int j) -> double const &\n" + ""}, + { "BilinearForm_Mult", _wrap_BilinearForm_Mult, METH_VARARGS, "Mult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_FullMult", _wrap_BilinearForm_FullMult, METH_VARARGS, "FullMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMult", _wrap_BilinearForm_AddMult, METH_VARARGS, "AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMult", _wrap_BilinearForm_FullAddMult, METH_VARARGS, "FullAddMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMultTranspose", _wrap_BilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMultTranspose", _wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS, "FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_MultTranspose", _wrap_BilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_InnerProduct", _wrap_BilinearForm_InnerProduct, METH_VARARGS, "InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Inverse", _wrap_BilinearForm_Inverse, METH_O, "Inverse(BilinearForm self) -> MatrixInverse"}, + { "BilinearForm_Finalize", _wrap_BilinearForm_Finalize, METH_VARARGS, "Finalize(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_SpMat", _wrap_BilinearForm_SpMat, METH_VARARGS, "\n" + "SpMat(BilinearForm self) -> SparseMatrix\n" + "SpMat(BilinearForm self) -> SparseMatrix\n" + ""}, + { "BilinearForm_LoseMat", _wrap_BilinearForm_LoseMat, METH_O, "LoseMat(BilinearForm self) -> SparseMatrix"}, + { "BilinearForm_SpMatElim", _wrap_BilinearForm_SpMatElim, METH_VARARGS, "\n" + "SpMatElim(BilinearForm self) -> SparseMatrix\n" + "SpMatElim(BilinearForm self) -> SparseMatrix\n" + ""}, + { "BilinearForm_AddDomainIntegrator", _wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddBoundaryIntegrator", _wrap_BilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "BilinearForm_AddInteriorFaceIntegrator", _wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddBdrFaceIntegrator", _wrap_BilinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "AssembleDiagonal(BilinearForm self, Vector diag)"}, + { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "GetProlongation(BilinearForm self) -> Operator"}, + { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "GetRestriction(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(BilinearForm self) -> Operator"}, + { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(BilinearForm self) -> Operator"}, + { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, + { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "ComputeElementMatrices(BilinearForm self)"}, + { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "FreeElementMatrices(BilinearForm self)"}, + { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, + { "BilinearForm_AssembleBdrElementMatrix", _wrap_BilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" + ""}, + { "BilinearForm_EliminateEssentialBC", _wrap_BilinearForm_EliminateEssentialBC, METH_VARARGS, "\n" + "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "BilinearForm_EliminateEssentialBCDiag", _wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS, "EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, + { "BilinearForm_EliminateVDofs", _wrap_BilinearForm_EliminateVDofs, METH_VARARGS, "\n" + "EliminateVDofs(BilinearForm self, intArray vdofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "BilinearForm_EliminateEssentialBCFromDofs", _wrap_BilinearForm_EliminateEssentialBCFromDofs, METH_VARARGS, "\n" + "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "BilinearForm_EliminateEssentialBCFromDofsDiag", _wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS, "EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, + { "BilinearForm_EliminateVDofsInRHS", _wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS, "EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, + { "BilinearForm_FullInnerProduct", _wrap_BilinearForm_FullInnerProduct, METH_VARARGS, "FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Update", _wrap_BilinearForm_Update, METH_VARARGS, "Update(BilinearForm self, FiniteElementSpace nfes=None)"}, + { "BilinearForm_GetFES", _wrap_BilinearForm_GetFES, METH_O, "GetFES(BilinearForm self) -> FiniteElementSpace"}, + { "BilinearForm_FESpace", _wrap_BilinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(BilinearForm self) -> FiniteElementSpace\n" + "FESpace(BilinearForm self) -> FiniteElementSpace\n" + ""}, + { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "UseExternalIntegrators(BilinearForm self)"}, + { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, + { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" + "FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B, int copy_interior=0)\n" + "FormLinearSystem(BilinearForm self, intArray ess_tdof_list, Vector x, Vector b, SparseMatrix A, Vector X, Vector B, int copy_interior=0)\n" + ""}, + { "BilinearForm_FormSystemMatrix", _wrap_BilinearForm_FormSystemMatrix, METH_VARARGS, "\n" + "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, OperatorHandle A)\n" + "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" + ""}, + { "disown_BilinearForm", _wrap_disown_BilinearForm, METH_O, NULL}, + { "BilinearForm_swigregister", BilinearForm_swigregister, METH_O, NULL}, + { "BilinearForm_swiginit", BilinearForm_swiginit, METH_VARARGS, NULL}, + { "new_MixedBilinearForm", _wrap_new_MixedBilinearForm, METH_VARARGS, "\n" + "MixedBilinearForm(FiniteElementSpace tr_fes, FiniteElementSpace te_fes)\n" + "new_MixedBilinearForm(FiniteElementSpace tr_fes, FiniteElementSpace te_fes, MixedBilinearForm mbf) -> MixedBilinearForm\n" + ""}, + { "MixedBilinearForm_Elem", _wrap_MixedBilinearForm_Elem, METH_VARARGS, "\n" + "Elem(MixedBilinearForm self, int i, int j) -> double\n" + "Elem(MixedBilinearForm self, int i, int j) -> double const &\n" + ""}, + { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "Mult(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "Inverse(MixedBilinearForm self) -> MatrixInverse"}, + { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "Finalize(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "MixedBilinearForm_SpMat", _wrap_MixedBilinearForm_SpMat, METH_VARARGS, "\n" + "SpMat(MixedBilinearForm self) -> SparseMatrix\n" + "SpMat(MixedBilinearForm self) -> SparseMatrix\n" + ""}, + { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "LoseMat(MixedBilinearForm self) -> SparseMatrix"}, + { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" + "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" + "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" + ""}, + { "MixedBilinearForm_GetDBFI", _wrap_MixedBilinearForm_GetDBFI, METH_O, "GetDBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBBFI", _wrap_MixedBilinearForm_GetBBFI, METH_O, "GetBBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBBFI_Marker", _wrap_MixedBilinearForm_GetBBFI_Marker, METH_O, "GetBBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "GetProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "GetRestriction(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(MixedBilinearForm self) -> Operator"}, + { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "ConformingAssemble(MixedBilinearForm self)"}, + { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" + "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, + { "MixedBilinearForm_AssembleBdrElementMatrix", _wrap_MixedBilinearForm_AssembleBdrElementMatrix, METH_VARARGS, "\n" + "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" + "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" + ""}, + { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "Update(MixedBilinearForm self)"}, + { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" + "TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + ""}, + { "MixedBilinearForm_TestFESpace", _wrap_MixedBilinearForm_TestFESpace, METH_VARARGS, "\n" + "TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + "TestFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" + ""}, + { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, + { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, + { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, + { "new_DiscreteLinearOperator", _wrap_new_DiscreteLinearOperator, METH_VARARGS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, + { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, + { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, + { "delete_DiscreteLinearOperator", _wrap_delete_DiscreteLinearOperator, METH_O, "delete_DiscreteLinearOperator(DiscreteLinearOperator self)"}, + { "DiscreteLinearOperator_swigregister", DiscreteLinearOperator_swigregister, METH_O, NULL}, + { "DiscreteLinearOperator_swiginit", DiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -13546,6 +16532,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -13675,9 +16664,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -13702,6 +16688,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -13726,18 +16715,27 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); } @@ -13747,6 +16745,9 @@ static void *_p_mfem__MixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNU static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -13762,9 +16763,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -13838,6 +16845,7 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; @@ -13850,7 +16858,6 @@ static swig_type_info _swigt__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t = {"_p_mfem_ static swig_type_info _swigt__p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t = {"_p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t", "mfem::Array< mfem::BilinearFormIntegrator * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearForm = {"_p_mfem__BilinearForm", "mfem::BilinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -13861,6 +16868,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -13882,6 +16890,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -13914,8 +16923,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -13923,6 +16931,7 @@ static swig_type_info _swigt__p_mfem__DivergenceInterpolator = {"_p_mfem__Diverg static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mfem::DenseMatrix *", 0, 0, (void*)0, 0}; @@ -13942,12 +16951,18 @@ static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__P static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; @@ -13963,6 +16978,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_doublep, @@ -13995,13 +17011,17 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GroupConvectionIntegrator, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__IdentityInterpolator, &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__IntegrationRule, &_swigt__p_mfem__InverseIntegrator, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2_FECollection, &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__LumpedIntegrator, @@ -14057,8 +17077,11 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__ScalarProductInterpolator, &_swigt__p_mfem__ScalarVectorProductInterpolator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__SumIntegrator, @@ -14088,6 +17111,7 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0}, {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; @@ -14099,7 +17123,6 @@ static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__Arra static swig_cast_info _swigc__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__BilinearFormIntegrator_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BilinearForm[] = { {&_swigt__p_mfem__BilinearForm, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -14110,6 +17133,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -14131,6 +17155,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -14163,8 +17188,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -14172,9 +17196,10 @@ static swig_cast_info _swigc__p_mfem__DivergenceInterpolator[] = {{&_swigt__p_mf static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__CurlInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = { {&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__DiscreteInterpolator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteLinearOperator[] = { {&_swigt__p_mfem__DiscreteLinearOperator, 0, 0, 0},{0, 0, 0, 0}}; @@ -14191,14 +17216,20 @@ static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt_ static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -14213,6 +17244,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_doublep, @@ -14245,13 +17277,17 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GroupConvectionIntegrator, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__IdentityInterpolator, _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__IntegrationRule, _swigc__p_mfem__InverseIntegrator, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2_FECollection, _swigc__p_mfem__LinearForm, _swigc__p_mfem__LumpedIntegrator, @@ -14307,8 +17343,11 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__ScalarProductInterpolator, _swigc__p_mfem__ScalarVectorProductInterpolator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__SumIntegrator, diff --git a/mfem/_ser/bilinearform_wrap.h b/mfem/_ser/bilinearform_wrap.h index 28fb831a..84555a81 100644 --- a/mfem/_ser/bilinearform_wrap.h +++ b/mfem/_ser/bilinearform_wrap.h @@ -27,6 +27,8 @@ class SwigDirector_BilinearForm : public mfem::BilinearForm, public Swig::Direct virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_BilinearForm(); virtual double &Elem(int i, int j); @@ -69,7 +71,7 @@ class SwigDirector_BilinearForm : public mfem::BilinearForm, public Swig::Direct return method; } private: - mutable swig::SwigVar_PyObject vtable[24]; + mutable swig::SwigVar_PyObject vtable[26]; #endif }; diff --git a/mfem/_ser/bilininteg.py b/mfem/_ser/bilininteg.py index dec64de7..cd33472c 100644 --- a/mfem/_ser/bilininteg.py +++ b/mfem/_ser/bilininteg.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _bilininteg.SWIG_PyInstanceMethod_New +_swig_new_static_method = _bilininteg.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,10 +85,12 @@ class _SwigNonDynamicMeta(type): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.fespace import mfem._ser.fe_coll import mfem._ser.lininteg import mfem._ser.handle +import mfem._ser.restriction import mfem._ser.linearform class BilinearFormIntegrator(object): r"""Proxy of C++ mfem::BilinearFormIntegrator class.""" @@ -101,25 +106,49 @@ def __init__(self, ir=None): _self = self _bilininteg.BilinearFormIntegrator_swiginit(self, _bilininteg.new_BilinearFormIntegrator(_self, ir)) - def AssemblePA(self, fes): - r"""AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)""" - return _bilininteg.BilinearFormIntegrator_AssemblePA(self, fes) + def AssemblePA(self, *args): + r""" + AssemblePA(BilinearFormIntegrator self) + AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes) + AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _bilininteg.BilinearFormIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssemblePA) + + def AssemblePAInteriorFaces(self, fes): + r"""AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.BilinearFormIntegrator_AssemblePAInteriorFaces(self, fes) + AssemblePAInteriorFaces = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssemblePAInteriorFaces) + + def AssemblePABoundaryFaces(self, fes): + r"""AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.BilinearFormIntegrator_AssemblePABoundaryFaces(self, fes) + AssemblePABoundaryFaces = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssemblePABoundaryFaces) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)""" + return _bilininteg.BilinearFormIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleDiagonalPA) def AddMultPA(self, x, y): r"""AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)""" return _bilininteg.BilinearFormIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AddMultPA) def AddMultTransposePA(self, x, y): r"""AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)""" return _bilininteg.BilinearFormIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AddMultTransposePA) def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementMatrix2) def AssembleFaceMatrix(self, *args): r""" @@ -127,26 +156,32 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.BilinearFormIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleFaceMatrix) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _bilininteg.BilinearFormIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementVector) def AssembleElementGrad(self, el, Tr, elfun, elmat): r"""AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleElementGrad) def AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat): r"""AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)""" return _bilininteg.BilinearFormIntegrator_AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat) + AssembleFaceGrad = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_AssembleFaceGrad) - def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=1): - r"""ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)""" + def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=True): + r"""ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)""" return _bilininteg.BilinearFormIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.BilinearFormIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.BilinearFormIntegrator_ComputeFluxEnergy) __swig_destroy__ = _bilininteg.delete_BilinearFormIntegrator def __disown__(self): self.this.disown() @@ -173,10 +208,12 @@ def __init__(self, _bfi, _own_bfi=1): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.TransposeIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.TransposeIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssembleElementMatrix2) def AssembleFaceMatrix(self, *args): r""" @@ -185,6 +222,35 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.TransposeIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssembleFaceMatrix) + + def AssemblePA(self, *args): + r""" + AssemblePA(TransposeIntegrator self) + AssemblePA(TransposeIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.TransposeIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssemblePA) + + def AssemblePAInteriorFaces(self, fes): + r"""AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.TransposeIntegrator_AssemblePAInteriorFaces(self, fes) + AssemblePAInteriorFaces = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssemblePAInteriorFaces) + + def AssemblePABoundaryFaces(self, fes): + r"""AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.TransposeIntegrator_AssemblePABoundaryFaces(self, fes) + AssemblePABoundaryFaces = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AssemblePABoundaryFaces) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)""" + return _bilininteg.TransposeIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AddMultTransposePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(TransposeIntegrator self, Vector x, Vector y)""" + return _bilininteg.TransposeIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.TransposeIntegrator_AddMultPA) __swig_destroy__ = _bilininteg.delete_TransposeIntegrator # Register TransposeIntegrator in _bilininteg: @@ -203,6 +269,7 @@ def __init__(self, _bfi, _own_bfi=1): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.LumpedIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.LumpedIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_LumpedIntegrator # Register LumpedIntegrator in _bilininteg: @@ -225,6 +292,7 @@ def __init__(self, integ, own_integ=1): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.InverseIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.InverseIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_InverseIntegrator # Register InverseIntegrator in _bilininteg: @@ -252,6 +320,7 @@ def AddIntegrator(self, integ): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.SumIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.SumIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_SumIntegrator # Register SumIntegrator in _bilininteg: @@ -269,10 +338,12 @@ def __init__(self, *args, **kwargs): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedScalarIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MixedScalarIntegrator_AssembleElementMatrix2) def AssembleElementMatrix(self, fe, Trans, elmat): r"""AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedScalarIntegrator_AssembleElementMatrix(self, fe, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.MixedScalarIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_MixedScalarIntegrator # Register MixedScalarIntegrator in _bilininteg: @@ -290,10 +361,12 @@ def __init__(self, *args, **kwargs): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedVectorIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MixedVectorIntegrator_AssembleElementMatrix2) def AssembleElementMatrix(self, fe, Trans, elmat): r"""AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedVectorIntegrator_AssembleElementMatrix(self, fe, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.MixedVectorIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_MixedVectorIntegrator # Register MixedVectorIntegrator in _bilininteg: @@ -311,6 +384,7 @@ def __init__(self, *args, **kwargs): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MixedScalarVectorIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MixedScalarVectorIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_MixedScalarVectorIntegrator # Register MixedScalarVectorIntegrator in _bilininteg: @@ -514,10 +588,12 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedDotProductIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedDotProductIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *""" return _bilininteg.MixedDotProductIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedDotProductIntegrator_FiniteElementTypeFailureMessage) __swig_destroy__ = _bilininteg.delete_MixedDotProductIntegrator # Register MixedDotProductIntegrator in _bilininteg: @@ -541,14 +617,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedWeakGradDotIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *""" return _bilininteg.MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedWeakGradDotIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedWeakGradDotIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedWeakGradDotIntegrator # Register MixedWeakGradDotIntegrator in _bilininteg: @@ -567,14 +646,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *""" return _bilininteg.MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedWeakDivCrossIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedWeakDivCrossIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedWeakDivCrossIntegrator # Register MixedWeakDivCrossIntegrator in _bilininteg: @@ -598,22 +680,27 @@ def __init__(self, *args): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedGradGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *""" return _bilininteg.MixedGradGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_FiniteElementTypeFailureMessage) def GetIntegrationOrder(self, trial_fe, test_fe, Trans): r"""GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int""" return _bilininteg.MixedGradGradIntegrator_GetIntegrationOrder(self, trial_fe, test_fe, Trans) + GetIntegrationOrder = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_GetIntegrationOrder) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedGradGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedGradGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedGradGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedGradGradIntegrator # Register MixedGradGradIntegrator in _bilininteg: @@ -632,18 +719,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *""" return _bilininteg.MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossGradGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossGradGradIntegrator # Register MixedCrossGradGradIntegrator in _bilininteg: @@ -667,18 +758,22 @@ def __init__(self, *args): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCurlCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *""" return _bilininteg.MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCurlCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCurlCurlIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCurlCurlIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCurlCurlIntegrator # Register MixedCurlCurlIntegrator in _bilininteg: @@ -697,18 +792,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *""" return _bilininteg.MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlCurlIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlCurlIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossCurlCurlIntegrator # Register MixedCrossCurlCurlIntegrator in _bilininteg: @@ -727,18 +826,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *""" return _bilininteg.MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossCurlGradIntegrator # Register MixedCrossCurlGradIntegrator in _bilininteg: @@ -757,18 +860,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *""" return _bilininteg.MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradCurlIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossGradCurlIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossGradCurlIntegrator # Register MixedCrossGradCurlIntegrator in _bilininteg: @@ -787,14 +894,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *""" return _bilininteg.MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedWeakCurlCrossIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedWeakCurlCrossIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedWeakCurlCrossIntegrator # Register MixedWeakCurlCrossIntegrator in _bilininteg: @@ -813,14 +923,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *""" return _bilininteg.MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedScalarWeakCurlCrossIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedScalarWeakCurlCrossIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedScalarWeakCurlCrossIntegrator # Register MixedScalarWeakCurlCrossIntegrator in _bilininteg: @@ -839,18 +952,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *""" return _bilininteg.MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_CalcTrialShape) def CalcTestShape(self, test_fe, Trans, shape): r"""CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossGradIntegrator_CalcTestShape(self, test_fe, Trans, shape) + CalcTestShape = _swig_new_instance_method(_bilininteg.MixedCrossGradIntegrator_CalcTestShape) __swig_destroy__ = _bilininteg.delete_MixedCrossGradIntegrator # Register MixedCrossGradIntegrator in _bilininteg: @@ -869,14 +986,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedCrossCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedCrossCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *""" return _bilininteg.MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage) def CalcTrialShape(self, trial_fe, Trans, shape): r"""CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedCrossCurlIntegrator_CalcTrialShape(self, trial_fe, Trans, shape) + CalcTrialShape = _swig_new_instance_method(_bilininteg.MixedCrossCurlIntegrator_CalcTrialShape) __swig_destroy__ = _bilininteg.delete_MixedCrossCurlIntegrator # Register MixedCrossCurlIntegrator in _bilininteg: @@ -895,14 +1015,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *""" return _bilininteg.MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedScalarCrossCurlIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedScalarCrossCurlIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedScalarCrossCurlIntegrator # Register MixedScalarCrossCurlIntegrator in _bilininteg: @@ -921,14 +1044,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *""" return _bilininteg.MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedScalarCrossGradIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedScalarCrossGradIntegrator_CalcVShape) __swig_destroy__ = _bilininteg.delete_MixedScalarCrossGradIntegrator # Register MixedScalarCrossGradIntegrator in _bilininteg: @@ -947,10 +1073,12 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *""" return _bilininteg.MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage) __swig_destroy__ = _bilininteg.delete_MixedScalarCrossProductIntegrator # Register MixedScalarCrossProductIntegrator in _bilininteg: @@ -969,14 +1097,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *""" return _bilininteg.MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedScalarWeakCrossProductIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedScalarWeakCrossProductIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedScalarWeakCrossProductIntegrator # Register MixedScalarWeakCrossProductIntegrator in _bilininteg: @@ -995,14 +1126,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *""" return _bilininteg.MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedDirectionalDerivativeIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedDirectionalDerivativeIntegrator_CalcVShape) __swig_destroy__ = _bilininteg.delete_MixedDirectionalDerivativeIntegrator # Register MixedDirectionalDerivativeIntegrator in _bilininteg: @@ -1021,18 +1155,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedGradDivIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *""" return _bilininteg.MixedGradDivIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedGradDivIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_CalcVShape) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedGradDivIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedGradDivIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedGradDivIntegrator # Register MixedGradDivIntegrator in _bilininteg: @@ -1051,18 +1189,22 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedDivGradIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *""" return _bilininteg.MixedDivGradIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedDivGradIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_CalcVShape) def CalcShape(self, scalar_fe, Trans, shape): r"""CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)""" return _bilininteg.MixedDivGradIntegrator_CalcShape(self, scalar_fe, Trans, shape) + CalcShape = _swig_new_instance_method(_bilininteg.MixedDivGradIntegrator_CalcShape) __swig_destroy__ = _bilininteg.delete_MixedDivGradIntegrator # Register MixedDivGradIntegrator in _bilininteg: @@ -1081,14 +1223,17 @@ def __init__(self, vq): def VerifyFiniteElementTypes(self, trial_fe, test_fe): r"""VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool""" return _bilininteg.MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(self, trial_fe, test_fe) + VerifyFiniteElementTypes = _swig_new_instance_method(_bilininteg.MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes) def FiniteElementTypeFailureMessage(self): r"""FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *""" return _bilininteg.MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(self) + FiniteElementTypeFailureMessage = _swig_new_instance_method(_bilininteg.MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage) def CalcVShape(self, vector_fe, Trans, shape): r"""CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)""" return _bilininteg.MixedScalarWeakDivergenceIntegrator_CalcVShape(self, vector_fe, Trans, shape) + CalcVShape = _swig_new_instance_method(_bilininteg.MixedScalarWeakDivergenceIntegrator_CalcVShape) __swig_destroy__ = _bilininteg.delete_MixedScalarWeakDivergenceIntegrator # Register MixedScalarWeakDivergenceIntegrator in _bilininteg: @@ -1180,6 +1325,58 @@ def __init__(self, *args): # Register MixedVectorWeakDivergenceIntegrator in _bilininteg: _bilininteg.MixedVectorWeakDivergenceIntegrator_swigregister(MixedVectorWeakDivergenceIntegrator) +class GradientIntegrator(BilinearFormIntegrator): + r"""Proxy of C++ mfem::GradientIntegrator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(GradientIntegrator self) -> GradientIntegrator + __init__(GradientIntegrator self, Coefficient _q) -> GradientIntegrator + __init__(GradientIntegrator self, Coefficient q) -> GradientIntegrator + """ + _bilininteg.GradientIntegrator_swiginit(self, _bilininteg.new_GradientIntegrator(*args)) + + def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): + r"""AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" + return _bilininteg.GradientIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.GradientIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(GradientIntegrator self) + AssemblePA(GradientIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _bilininteg.GradientIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.GradientIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(GradientIntegrator self, Vector x, Vector y)""" + return _bilininteg.GradientIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.GradientIntegrator_AddMultPA) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)""" + return _bilininteg.GradientIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.GradientIntegrator_AddMultTransposePA) + + @staticmethod + def GetRule(trial_fe, test_fe, Trans): + r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.GradientIntegrator_GetRule(trial_fe, test_fe, Trans) + GetRule = _swig_new_static_method(_bilininteg.GradientIntegrator_GetRule) + __swig_destroy__ = _bilininteg.delete_GradientIntegrator + +# Register GradientIntegrator in _bilininteg: +_bilininteg.GradientIntegrator_swigregister(GradientIntegrator) + +def GradientIntegrator_GetRule(trial_fe, test_fe, Trans): + r"""GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.GradientIntegrator_GetRule(trial_fe, test_fe, Trans) +GradientIntegrator_GetRule = _bilininteg.GradientIntegrator_GetRule + class DiffusionIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::DiffusionIntegrator class.""" @@ -1198,40 +1395,61 @@ def __init__(self, *args): + __swig_destroy__ = _bilininteg.delete_DiffusionIntegrator def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DiffusionIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DiffusionIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleElementMatrix2) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _bilininteg.DiffusionIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleElementVector) - def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=1): - r"""ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)""" + def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=True): + r"""ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)""" return _bilininteg.DiffusionIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.DiffusionIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_ComputeFluxEnergy) - def AssemblePA(self, arg2): - r"""AssemblePA(DiffusionIntegrator self, FiniteElementSpace arg2)""" - return _bilininteg.DiffusionIntegrator_AssemblePA(self, arg2) + def AssemblePA(self, *args): + r""" + AssemblePA(DiffusionIntegrator self) + AssemblePA(DiffusionIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.DiffusionIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)""" + return _bilininteg.DiffusionIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AssembleDiagonalPA) def AddMultPA(self, arg2, arg3): r"""AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)""" return _bilininteg.DiffusionIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_AddMultPA) @staticmethod def GetRule(trial_fe, test_fe): r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule""" return _bilininteg.DiffusionIntegrator_GetRule(trial_fe, test_fe) - __swig_destroy__ = _bilininteg.delete_DiffusionIntegrator + GetRule = _swig_new_static_method(_bilininteg.DiffusionIntegrator_GetRule) + + def SetupPA(self, fes, force=False): + r"""SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)""" + return _bilininteg.DiffusionIntegrator_SetupPA(self, fes, force) + SetupPA = _swig_new_instance_method(_bilininteg.DiffusionIntegrator_SetupPA) # Register DiffusionIntegrator in _bilininteg: _bilininteg.DiffusionIntegrator_swigregister(DiffusionIntegrator) @@ -1239,6 +1457,7 @@ def GetRule(trial_fe, test_fe): def DiffusionIntegrator_GetRule(trial_fe, test_fe): r"""DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule""" return _bilininteg.DiffusionIntegrator_GetRule(trial_fe, test_fe) +DiffusionIntegrator_GetRule = _bilininteg.DiffusionIntegrator_GetRule class MassIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::MassIntegrator class.""" @@ -1257,28 +1476,46 @@ def __init__(self, *args): + __swig_destroy__ = _bilininteg.delete_MassIntegrator def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MassIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.MassIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.MassIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.MassIntegrator_AssembleElementMatrix2) - def AssemblePA(self, arg2): - r"""AssemblePA(MassIntegrator self, FiniteElementSpace arg2)""" - return _bilininteg.MassIntegrator_AssemblePA(self, arg2) + def AssemblePA(self, *args): + r""" + AssemblePA(MassIntegrator self) + AssemblePA(MassIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.MassIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.MassIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(MassIntegrator self, Vector diag)""" + return _bilininteg.MassIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.MassIntegrator_AssembleDiagonalPA) def AddMultPA(self, arg2, arg3): r"""AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)""" return _bilininteg.MassIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.MassIntegrator_AddMultPA) @staticmethod def GetRule(trial_fe, test_fe, Trans): r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" return _bilininteg.MassIntegrator_GetRule(trial_fe, test_fe, Trans) - __swig_destroy__ = _bilininteg.delete_MassIntegrator + GetRule = _swig_new_static_method(_bilininteg.MassIntegrator_GetRule) + + def SetupPA(self, fes, force=False): + r"""SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)""" + return _bilininteg.MassIntegrator_SetupPA(self, fes, force) + SetupPA = _swig_new_instance_method(_bilininteg.MassIntegrator_SetupPA) # Register MassIntegrator in _bilininteg: _bilininteg.MassIntegrator_swigregister(MassIntegrator) @@ -1286,6 +1523,7 @@ def GetRule(trial_fe, test_fe, Trans): def MassIntegrator_GetRule(trial_fe, test_fe, Trans): r"""MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" return _bilininteg.MassIntegrator_GetRule(trial_fe, test_fe, Trans) +MassIntegrator_GetRule = _bilininteg.MassIntegrator_GetRule class BoundaryMassIntegrator(MassIntegrator): r"""Proxy of C++ mfem::BoundaryMassIntegrator class.""" @@ -1304,6 +1542,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.BoundaryMassIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.BoundaryMassIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_BoundaryMassIntegrator # Register BoundaryMassIntegrator in _bilininteg: @@ -1322,11 +1561,42 @@ def __init__(self, q, a=1.0): def AssembleElementMatrix(self, arg2, arg3, arg4): r"""AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)""" return _bilininteg.ConvectionIntegrator_AssembleElementMatrix(self, arg2, arg3, arg4) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.ConvectionIntegrator_AssembleElementMatrix) + + def AssemblePA(self, *args): + r""" + AssemblePA(ConvectionIntegrator self) + AssemblePA(ConvectionIntegrator self, FiniteElementSpace arg2) + """ + return _bilininteg.ConvectionIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.ConvectionIntegrator_AssemblePA) + + def AddMultPA(self, arg2, arg3): + r"""AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)""" + return _bilininteg.ConvectionIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.ConvectionIntegrator_AddMultPA) + + @staticmethod + def GetRule(*args): + r""" + GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule + GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule + """ + return _bilininteg.ConvectionIntegrator_GetRule(*args) + GetRule = _swig_new_static_method(_bilininteg.ConvectionIntegrator_GetRule) __swig_destroy__ = _bilininteg.delete_ConvectionIntegrator # Register ConvectionIntegrator in _bilininteg: _bilininteg.ConvectionIntegrator_swigregister(ConvectionIntegrator) +def ConvectionIntegrator_GetRule(*args): + r""" + ConvectionIntegrator_GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule + ConvectionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule + """ + return _bilininteg.ConvectionIntegrator_GetRule(*args) +ConvectionIntegrator_GetRule = _bilininteg.ConvectionIntegrator_GetRule + class GroupConvectionIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::GroupConvectionIntegrator class.""" @@ -1340,6 +1610,7 @@ def __init__(self, q, a=1.0): def AssembleElementMatrix(self, arg2, arg3, arg4): r"""AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)""" return _bilininteg.GroupConvectionIntegrator_AssembleElementMatrix(self, arg2, arg3, arg4) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.GroupConvectionIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_GroupConvectionIntegrator # Register GroupConvectionIntegrator in _bilininteg: @@ -1364,18 +1635,40 @@ def __init__(self, *args): def GetVDim(self): r"""GetVDim(VectorMassIntegrator self) -> int""" return _bilininteg.VectorMassIntegrator_GetVDim(self) + GetVDim = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_GetVDim) def SetVDim(self, vdim): r"""SetVDim(VectorMassIntegrator self, int vdim)""" return _bilininteg.VectorMassIntegrator_SetVDim(self, vdim) + SetVDim = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_SetVDim) def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorMassIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorMassIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorMassIntegrator self) + AssemblePA(VectorMassIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.VectorMassIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)""" + return _bilininteg.VectorMassIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AssembleDiagonalPA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorMassIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorMassIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorMassIntegrator_AddMultPA) __swig_destroy__ = _bilininteg.delete_VectorMassIntegrator # Register VectorMassIntegrator in _bilininteg: @@ -1397,10 +1690,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFEDivergenceIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorFEDivergenceIntegrator # Register VectorFEDivergenceIntegrator in _bilininteg: @@ -1422,10 +1717,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorFEWeakDivergenceIntegrator # Register VectorFEWeakDivergenceIntegrator in _bilininteg: @@ -1447,10 +1744,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFECurlIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFECurlIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFECurlIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFECurlIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorFECurlIntegrator # Register VectorFECurlIntegrator in _bilininteg: @@ -1469,10 +1768,12 @@ def __init__(self, q, i): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DerivativeIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.DerivativeIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DerivativeIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.DerivativeIntegrator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_DerivativeIntegrator # Register DerivativeIntegrator in _bilininteg: @@ -1500,14 +1801,35 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.CurlCurlIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AssembleElementMatrix) def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef): - r"""ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef)""" + r"""ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)""" return _bilininteg.CurlCurlIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.CurlCurlIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_ComputeFluxEnergy) + + def AssemblePA(self, *args): + r""" + AssemblePA(CurlCurlIntegrator self) + AssemblePA(CurlCurlIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.CurlCurlIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)""" + return _bilininteg.CurlCurlIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AddMultPA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)""" + return _bilininteg.CurlCurlIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.CurlCurlIntegrator_AssembleDiagonalPA) __swig_destroy__ = _bilininteg.delete_CurlCurlIntegrator # Register CurlCurlIntegrator in _bilininteg: @@ -1529,10 +1851,12 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorCurlCurlIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorCurlCurlIntegrator_AssembleElementMatrix) def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double""" return _bilininteg.VectorCurlCurlIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_bilininteg.VectorCurlCurlIntegrator_GetElementEnergy) __swig_destroy__ = _bilininteg.delete_VectorCurlCurlIntegrator # Register VectorCurlCurlIntegrator in _bilininteg: @@ -1564,10 +1888,30 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEMassIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssembleElementMatrix) def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorFEMassIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorFEMassIntegrator self) + AssemblePA(VectorFEMassIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.VectorFEMassIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorFEMassIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AddMultPA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)""" + return _bilininteg.VectorFEMassIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.VectorFEMassIntegrator_AssembleDiagonalPA) __swig_destroy__ = _bilininteg.delete_VectorFEMassIntegrator # Register VectorFEMassIntegrator in _bilininteg: @@ -1590,11 +1934,41 @@ def __init__(self, *args): def AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorDivergenceIntegrator_AssembleElementMatrix2(self, trial_fe, test_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AssembleElementMatrix2) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorDivergenceIntegrator self) + AssemblePA(VectorDivergenceIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _bilininteg.VectorDivergenceIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorDivergenceIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AddMultPA) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorDivergenceIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.VectorDivergenceIntegrator_AddMultTransposePA) + + @staticmethod + def GetRule(trial_fe, test_fe, Trans): + r"""GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.VectorDivergenceIntegrator_GetRule(trial_fe, test_fe, Trans) + GetRule = _swig_new_static_method(_bilininteg.VectorDivergenceIntegrator_GetRule) __swig_destroy__ = _bilininteg.delete_VectorDivergenceIntegrator # Register VectorDivergenceIntegrator in _bilininteg: _bilininteg.VectorDivergenceIntegrator_swigregister(VectorDivergenceIntegrator) +def VectorDivergenceIntegrator_GetRule(trial_fe, test_fe, Trans): + r"""VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule""" + return _bilininteg.VectorDivergenceIntegrator_GetRule(trial_fe, test_fe, Trans) +VectorDivergenceIntegrator_GetRule = _bilininteg.VectorDivergenceIntegrator_GetRule + class DivDivIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::DivDivIntegrator class.""" @@ -1611,6 +1985,7 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DivDivIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.DivDivIntegrator_AssembleElementMatrix) __swig_destroy__ = _bilininteg.delete_DivDivIntegrator # Register DivDivIntegrator in _bilininteg: @@ -1632,10 +2007,30 @@ def __init__(self, *args): def AssembleElementMatrix(self, el, Trans, elmat): r"""AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorDiffusionIntegrator_AssembleElementMatrix(self, el, Trans, elmat) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssembleElementMatrix) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _bilininteg.VectorDiffusionIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssembleElementVector) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorDiffusionIntegrator self) + AssemblePA(VectorDiffusionIntegrator self, FiniteElementSpace fes) + """ + return _bilininteg.VectorDiffusionIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssemblePA) + + def AssembleDiagonalPA(self, diag): + r"""AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)""" + return _bilininteg.VectorDiffusionIntegrator_AssembleDiagonalPA(self, diag) + AssembleDiagonalPA = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AssembleDiagonalPA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)""" + return _bilininteg.VectorDiffusionIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_bilininteg.VectorDiffusionIntegrator_AddMultPA) __swig_destroy__ = _bilininteg.delete_VectorDiffusionIntegrator # Register VectorDiffusionIntegrator in _bilininteg: @@ -1657,14 +2052,17 @@ def __init__(self, *args): def AssembleElementMatrix(self, arg2, arg3, arg4): r"""AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)""" return _bilininteg.ElasticityIntegrator_AssembleElementMatrix(self, arg2, arg3, arg4) + AssembleElementMatrix = _swig_new_instance_method(_bilininteg.ElasticityIntegrator_AssembleElementMatrix) - def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=1): - r"""ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)""" + def ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef=True): + r"""ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)""" return _bilininteg.ElasticityIntegrator_ComputeElementFlux(self, el, Trans, u, fluxelem, flux, with_coef) + ComputeElementFlux = _swig_new_instance_method(_bilininteg.ElasticityIntegrator_ComputeElementFlux) def ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy=None): r"""ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double""" return _bilininteg.ElasticityIntegrator_ComputeFluxEnergy(self, fluxelem, Trans, flux, d_energy) + ComputeFluxEnergy = _swig_new_instance_method(_bilininteg.ElasticityIntegrator_ComputeFluxEnergy) __swig_destroy__ = _bilininteg.delete_ElasticityIntegrator # Register ElasticityIntegrator in _bilininteg: @@ -1690,11 +2088,43 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.DGTraceIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AssembleFaceMatrix) + + def AssemblePAInteriorFaces(self, fes): + r"""AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.DGTraceIntegrator_AssemblePAInteriorFaces(self, fes) + AssemblePAInteriorFaces = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AssemblePAInteriorFaces) + + def AssemblePABoundaryFaces(self, fes): + r"""AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)""" + return _bilininteg.DGTraceIntegrator_AssemblePABoundaryFaces(self, fes) + AssemblePABoundaryFaces = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AssemblePABoundaryFaces) + + def AddMultTransposePA(self, x, y): + r"""AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)""" + return _bilininteg.DGTraceIntegrator_AddMultTransposePA(self, x, y) + AddMultTransposePA = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AddMultTransposePA) + + def AddMultPA(self, arg2, arg3): + r"""AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)""" + return _bilininteg.DGTraceIntegrator_AddMultPA(self, arg2, arg3) + AddMultPA = _swig_new_instance_method(_bilininteg.DGTraceIntegrator_AddMultPA) + + @staticmethod + def GetRule(geom, order, T): + r"""GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule""" + return _bilininteg.DGTraceIntegrator_GetRule(geom, order, T) + GetRule = _swig_new_static_method(_bilininteg.DGTraceIntegrator_GetRule) __swig_destroy__ = _bilininteg.delete_DGTraceIntegrator # Register DGTraceIntegrator in _bilininteg: _bilininteg.DGTraceIntegrator_swigregister(DGTraceIntegrator) +def DGTraceIntegrator_GetRule(geom, order, T): + r"""DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule""" + return _bilininteg.DGTraceIntegrator_GetRule(geom, order, T) +DGTraceIntegrator_GetRule = _bilininteg.DGTraceIntegrator_GetRule + class DGDiffusionIntegrator(BilinearFormIntegrator): r"""Proxy of C++ mfem::DGDiffusionIntegrator class.""" @@ -1716,6 +2146,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.DGDiffusionIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.DGDiffusionIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_DGDiffusionIntegrator # Register DGDiffusionIntegrator in _bilininteg: @@ -1741,6 +2172,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.DGElasticityIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.DGElasticityIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_DGElasticityIntegrator # Register DGElasticityIntegrator in _bilininteg: @@ -1763,6 +2195,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.TraceJumpIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.TraceJumpIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_TraceJumpIntegrator # Register TraceJumpIntegrator in _bilininteg: @@ -1785,6 +2218,7 @@ def AssembleFaceMatrix(self, *args): AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat) """ return _bilininteg.NormalTraceJumpIntegrator_AssembleFaceMatrix(self, *args) + AssembleFaceMatrix = _swig_new_instance_method(_bilininteg.NormalTraceJumpIntegrator_AssembleFaceMatrix) __swig_destroy__ = _bilininteg.delete_NormalTraceJumpIntegrator # Register NormalTraceJumpIntegrator in _bilininteg: @@ -1813,6 +2247,7 @@ class GradientInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, h1_fe, nd_fe, Trans, elmat): r"""AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.GradientInterpolator_AssembleElementMatrix2(self, h1_fe, nd_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.GradientInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(GradientInterpolator self) -> GradientInterpolator""" @@ -1831,6 +2266,7 @@ class IdentityInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.IdentityInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.IdentityInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(IdentityInterpolator self) -> IdentityInterpolator""" @@ -1849,6 +2285,7 @@ class CurlInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.CurlInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.CurlInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(CurlInterpolator self) -> CurlInterpolator""" @@ -1867,6 +2304,7 @@ class DivergenceInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.DivergenceInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.DivergenceInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(DivergenceInterpolator self) -> DivergenceInterpolator""" @@ -1885,6 +2323,7 @@ class NormalInterpolator(DiscreteInterpolator): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.NormalInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.NormalInterpolator_AssembleElementMatrix2) def __init__(self): r"""__init__(NormalInterpolator self) -> NormalInterpolator""" @@ -1907,6 +2346,7 @@ def __init__(self, sc): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.ScalarProductInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.ScalarProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_ScalarProductInterpolator # Register ScalarProductInterpolator in _bilininteg: @@ -1925,6 +2365,7 @@ def __init__(self, sc): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.ScalarVectorProductInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.ScalarVectorProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_ScalarVectorProductInterpolator # Register ScalarVectorProductInterpolator in _bilininteg: @@ -1943,6 +2384,7 @@ def __init__(self, vc): def AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorScalarProductInterpolator_AssembleElementMatrix2(self, dom_fe, ran_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorScalarProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorScalarProductInterpolator # Register VectorScalarProductInterpolator in _bilininteg: @@ -1961,6 +2403,7 @@ def __init__(self, vc): def AssembleElementMatrix2(self, nd_fe, rt_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorCrossProductInterpolator_AssembleElementMatrix2(self, nd_fe, rt_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorCrossProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorCrossProductInterpolator # Register VectorCrossProductInterpolator in _bilininteg: @@ -1979,6 +2422,7 @@ def __init__(self, vc): def AssembleElementMatrix2(self, rt_fe, l2_fe, Trans, elmat): r"""AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)""" return _bilininteg.VectorInnerProductInterpolator_AssembleElementMatrix2(self, rt_fe, l2_fe, Trans, elmat) + AssembleElementMatrix2 = _swig_new_instance_method(_bilininteg.VectorInnerProductInterpolator_AssembleElementMatrix2) __swig_destroy__ = _bilininteg.delete_VectorInnerProductInterpolator # Register VectorInnerProductInterpolator in _bilininteg: diff --git a/mfem/_ser/bilininteg_wrap.cxx b/mfem/_ser/bilininteg_wrap.cxx index 3659038b..50948291 100644 --- a/mfem/_ser/bilininteg_wrap.cxx +++ b/mfem/_ser/bilininteg_wrap.cxx @@ -3066,248 +3066,252 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[5] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[6] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[7] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[8] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[12] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__Coefficient swig_types[14] -#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[15] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[17] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[18] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[22] -#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[23] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[24] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[25] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[26] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[27] -#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[28] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[29] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[31] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[32] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[33] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[35] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[36] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[38] -#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[39] -#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[40] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[41] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[42] -#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[43] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[44] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[45] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[46] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[47] -#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[48] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[49] -#define SWIGTYPE_p_mfem__GridFunction swig_types[50] -#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[51] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[53] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[54] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[55] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[56] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[57] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[58] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[59] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[60] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[61] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[62] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[63] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[64] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[65] -#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[66] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[67] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[68] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[70] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[71] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[72] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[73] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[74] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[75] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[76] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[77] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[78] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[79] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[80] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[81] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[82] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[83] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[84] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__LinearForm swig_types[90] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[93] -#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[94] -#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[95] -#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[96] -#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[97] -#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[98] -#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[99] -#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[100] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[101] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[102] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[103] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[104] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[105] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[106] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[107] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[108] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[109] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[110] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[111] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[112] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[113] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[114] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[115] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[116] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[117] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[118] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[119] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[120] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[121] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[122] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[123] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[124] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[125] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[126] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[127] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[128] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[129] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[130] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[131] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[132] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[133] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[134] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[135] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[136] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[137] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[138] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[139] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[140] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[141] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[142] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[143] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[144] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[145] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[146] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[147] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[148] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[149] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[150] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[151] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[152] -#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[153] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[154] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[155] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[156] -#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[157] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[158] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[159] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[160] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[161] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[162] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[163] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[164] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[165] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[166] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[167] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[168] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[169] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[170] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[171] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[172] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[173] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[174] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[175] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[176] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[177] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[178] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[179] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[180] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[181] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[182] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[183] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[184] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[185] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[186] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[187] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[188] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[189] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[190] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[191] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[192] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[193] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[194] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[195] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[196] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[197] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[198] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[199] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[200] -#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[201] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[202] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[203] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[204] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[205] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[206] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[207] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[208] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[209] -#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[210] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[211] -#define SWIGTYPE_p_mfem__Vector swig_types[212] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[213] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[214] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[215] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[216] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[217] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[218] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[219] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[220] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[221] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[222] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[223] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[224] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[225] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[226] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[227] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[228] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[229] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[230] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[231] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[232] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[233] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[234] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[235] -#define SWIGTYPE_p_pri_t swig_types[236] -#define SWIGTYPE_p_quad_t swig_types[237] -#define SWIGTYPE_p_seg_t swig_types[238] -#define SWIGTYPE_p_tet_t swig_types[239] -#define SWIGTYPE_p_tri_t swig_types[240] -static swig_type_info *swig_types[242]; -static swig_module_info swig_module = {swig_types, 241, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[6] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[7] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[8] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[9] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[13] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__Coefficient swig_types[15] +#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[16] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[18] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[19] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[23] +#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[24] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[25] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[26] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[27] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[28] +#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[29] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[30] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[32] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[34] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[36] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[37] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[39] +#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[40] +#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[41] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[42] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[43] +#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[44] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[45] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[46] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[47] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[48] +#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[49] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[50] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[51] +#define SWIGTYPE_p_mfem__GridFunction swig_types[52] +#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[53] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[55] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[56] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[57] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[58] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[59] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[60] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[61] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[63] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[64] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[65] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[66] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[67] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[68] +#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[69] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[70] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[71] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[73] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[74] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[75] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[76] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[77] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[78] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[79] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[80] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[81] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[82] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[83] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[84] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[85] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[86] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[87] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__LinearForm swig_types[93] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[95] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[96] +#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[97] +#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[98] +#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[99] +#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[100] +#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[101] +#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[102] +#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[103] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[104] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[105] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[106] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[107] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[108] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[109] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[110] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[111] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[112] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[113] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[114] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[115] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[116] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[117] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[118] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[119] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[120] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[121] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[122] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[123] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[124] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[125] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[126] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[127] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[128] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[129] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[130] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[131] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[132] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[133] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[134] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[135] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[136] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[137] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[138] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[139] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[140] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[141] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[142] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[143] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[144] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[145] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[146] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[147] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[148] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[149] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[150] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[151] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[152] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[153] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[154] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[155] +#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[156] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[157] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[158] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[159] +#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[160] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[161] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[162] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[163] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[164] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[165] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[166] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[167] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[168] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[169] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[170] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[171] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[172] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[173] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[174] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[175] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[176] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[177] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[178] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[179] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[180] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[181] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[182] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[183] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[184] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[185] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[186] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[187] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[188] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[189] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[190] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[191] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[192] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[193] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[194] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[195] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[196] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[197] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[198] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[199] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[200] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[201] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[202] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[203] +#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[204] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[205] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[206] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[207] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[208] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[209] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[210] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[211] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[212] +#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[213] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[214] +#define SWIGTYPE_p_mfem__Vector swig_types[215] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[216] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[217] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[218] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[219] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[220] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[221] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[222] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[223] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[224] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[225] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[226] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[227] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[228] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[229] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[230] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[231] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[232] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[233] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[234] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[235] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[236] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[237] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[238] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[239] +#define SWIGTYPE_p_pri_t swig_types[240] +#define SWIGTYPE_p_quad_t swig_types[241] +#define SWIGTYPE_p_seg_t swig_types[242] +#define SWIGTYPE_p_tet_t swig_types[243] +#define SWIGTYPE_p_tri_t swig_types[244] +static swig_type_info *swig_types[246]; +static swig_module_info swig_module = {swig_types, 245, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3418,13 +3422,6 @@ namespace swig { #include "numpy/arrayobject.h" -SWIGINTERNINLINE PyObject* - SWIG_From_int (int value) -{ - return PyInt_FromLong((long) value); -} - - SWIGINTERN int SWIG_AsVal_double (PyObject *obj, double *val) { @@ -3471,7 +3468,97 @@ SWIG_AsVal_double (PyObject *obj, double *val) } - #define SWIG_From_double PyFloat_FromDouble +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} SWIGINTERNINLINE PyObject* @@ -3481,6 +3568,9 @@ SWIGINTERNINLINE PyObject* } + #define SWIG_From_double PyFloat_FromDouble + + SWIGINTERN swig_type_info* SWIG_pchar_descriptor(void) { @@ -3526,6 +3616,39 @@ SWIG_FromCharPtr(const char *cptr) } +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + /* --------------------------------------------------- * C++ director class methods @@ -3566,6 +3689,112 @@ void SwigDirector_BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace co } +void SwigDirector_BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&trial_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&test_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 1; + const char *const swig_method_name = "AssemblePA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_BilinearFormIntegrator::AssemblePAInteriorFaces(mfem::FiniteElementSpace const &fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 2; + const char *const swig_method_name = "AssemblePAInteriorFaces"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePAInteriorFaces"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_BilinearFormIntegrator::AssemblePABoundaryFaces(mfem::FiniteElementSpace const &fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 3; + const char *const swig_method_name = "AssemblePABoundaryFaces"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePABoundaryFaces"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_BilinearFormIntegrator::AssembleDiagonalPA(mfem::Vector &diag) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&diag), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 4; + const char *const swig_method_name = "AssembleDiagonalPA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssembleDiagonalPA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + void SwigDirector_BilinearFormIntegrator::AddMultPA(mfem::Vector const &x, mfem::Vector &y) const { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); @@ -3575,7 +3804,7 @@ void SwigDirector_BilinearFormIntegrator::AddMultPA(mfem::Vector const &x, mfem: Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 1; + const size_t swig_method_index = 5; const char *const swig_method_name = "AddMultPA"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3603,7 +3832,7 @@ void SwigDirector_BilinearFormIntegrator::AddMultTransposePA(mfem::Vector const Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 2; + const size_t swig_method_index = 6; const char *const swig_method_name = "AddMultTransposePA"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -3633,7 +3862,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementMatrix(mfem::FiniteElem Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 3; + const size_t swig_method_index = 7; const char *const swig_method_name = "AssembleElementMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -3665,7 +3894,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementMatrix2(mfem::FiniteEle Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 4; + const size_t swig_method_index = 8; const char *const swig_method_name = "AssembleElementMatrix2"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3697,7 +3926,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 5; + const size_t swig_method_index = 9; const char *const swig_method_name = "AssembleFaceMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3731,7 +3960,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 10; const char *const swig_method_name = "AssembleFaceMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); @@ -3763,7 +3992,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementVector(mfem::FiniteElem Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 11; const char *const swig_method_name = "AssembleElementVector"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3795,7 +4024,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleElementGrad(mfem::FiniteElemen Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 12; const char *const swig_method_name = "AssembleElementGrad"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -3829,7 +4058,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceGrad(mfem::FiniteElement c Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 13; const char *const swig_method_name = "AssembleFaceGrad"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); @@ -3848,7 +4077,7 @@ void SwigDirector_BilinearFormIntegrator::AssembleFaceGrad(mfem::FiniteElement c } -void SwigDirector_BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, int with_coef) { +void SwigDirector_BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, bool with_coef) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&el), SWIGTYPE_p_mfem__FiniteElement, 0 ); swig::SwigVar_PyObject obj1; @@ -3860,12 +4089,12 @@ void SwigDirector_BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement swig::SwigVar_PyObject obj4; obj4 = SWIG_NewPointerObj(SWIG_as_voidptr(&flux), SWIGTYPE_p_mfem__Vector, 0 ); swig::SwigVar_PyObject obj5; - obj5 = SWIG_From_int(static_cast< int >(with_coef)); + obj5 = SWIG_From_bool(static_cast< bool >(with_coef)); if (!swig_get_self()) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 14; const char *const swig_method_name = "ComputeElementFlux"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5, NULL); @@ -3899,7 +4128,7 @@ double SwigDirector_BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElemen Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 12; + const size_t swig_method_index = 16; const char *const swig_method_name = "ComputeFluxEnergy"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -4056,7 +4285,7 @@ SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -4064,11 +4293,10 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePA", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); @@ -4118,52 +4346,51 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - ((mfem::BilinearFormIntegrator const *)arg1)->mfem::BilinearFormIntegrator::AddMultPA((mfem::Vector const &)*arg2,*arg3); + (arg1)->mfem::BilinearFormIntegrator::AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } else { - ((mfem::BilinearFormIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4191,52 +4418,90 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - Swig::Director *director = 0; - bool upcall = false; +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearFormIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearFormIntegrator_AssemblePA__SWIG_2(self, argc, argv); + } + } + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearFormIntegrator::AssemblePA()\n" + " mfem::BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n" + " mfem::BilinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - ((mfem::BilinearFormIntegrator const *)arg1)->mfem::BilinearFormIntegrator::AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); + (arg1)->mfem::BilinearFormIntegrator::AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); } else { - ((mfem::BilinearFormIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); + (arg1)->AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4264,63 +4529,41 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[2] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->mfem::BilinearFormIntegrator::AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); } else { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4348,74 +4591,41 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[2] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->mfem::BilinearFormIntegrator::AssembleDiagonalPA(*arg2); } else { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleDiagonalPA(*arg2); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4443,73 +4653,52 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + ((mfem::BilinearFormIntegrator const *)arg1)->mfem::BilinearFormIntegrator::AddMultPA((mfem::Vector const &)*arg2,*arg3); } else { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + ((mfem::BilinearFormIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4537,84 +4726,52 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + ((mfem::BilinearFormIntegrator const *)arg1)->mfem::BilinearFormIntegrator::AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); } else { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + ((mfem::BilinearFormIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4642,89 +4799,12 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_1(PyO } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_AssembleFaceMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4733,59 +4813,49 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[4] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + (arg1)->mfem::BilinearFormIntegrator::AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } else { - (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4813,12 +4883,12 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4834,42 +4904,42 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); @@ -4878,9 +4948,9 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::AssembleElementGrad((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + (arg1)->mfem::BilinearFormIntegrator::AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } else { - (arg1)->AssembleElementGrad((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } } #ifdef MFEM_USE_EXCEPTIONS @@ -4908,14 +4978,13 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; mfem::FaceElementTransformations *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4926,67 +4995,56 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject *swig_obj[6] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::AssembleFaceGrad((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,(mfem::Vector const &)*arg5,*arg6); + (arg1)->mfem::BilinearFormIntegrator::AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } else { - (arg1)->AssembleFaceGrad((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,(mfem::Vector const &)*arg5,*arg6); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } } #ifdef MFEM_USE_EXCEPTIONS @@ -5014,15 +5072,14 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - int arg7 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5038,67 +5095,61 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + (arg1)->mfem::BilinearFormIntegrator::AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } else { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } } #ifdef MFEM_USE_EXCEPTIONS @@ -5126,120 +5177,15 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); - } else { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 6) { + if (argc == 5) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); @@ -5248,30 +5194,25 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *s int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } + return _wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_0(self, argc, argv); } } } } } } - if (argc == 7) { + if (argc == 6) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); @@ -5280,32 +5221,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *s int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } + return _wrap_BilinearFormIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); } } } @@ -5315,21 +5245,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *s } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeElementFlux'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_AssembleFaceMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,int)\n" - " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); + " mfem::BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::BilinearFormIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5340,43 +5270,46 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject *swig_obj[5] ; Swig::Director *director = 0; bool upcall = false; - double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); @@ -5385,9 +5318,9 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(PyOb { try { if (upcall) { - result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->mfem::BilinearFormIntegrator::AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } else { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } } #ifdef MFEM_USE_EXCEPTIONS @@ -5408,19 +5341,20 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(PyOb } catch (Swig::DirectorException&) { SWIG_fail; } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5429,49 +5363,59 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; Swig::Director *director = 0; bool upcall = false; - double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->mfem::BilinearFormIntegrator::AssembleElementGrad((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } else { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleElementGrad((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } } #ifdef MFEM_USE_EXCEPTIONS @@ -5492,114 +5436,224 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(PyOb } catch (Swig::DirectorException&) { SWIG_fail; } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject *swig_obj[6] ; + Swig::Director *director = 0; + bool upcall = false; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } + if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearFormIntegrator::AssembleFaceGrad((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,(mfem::Vector const &)*arg5,*arg6); + } else { + (arg1)->AssembleFaceGrad((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,(mfem::Vector const &)*arg5,*arg6); } } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + } catch (Swig::DirectorException&) { + SWIG_fail; } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + Swig::Director *director = 0; + bool upcall = false; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - try { - delete arg1; - } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearFormIntegrator::ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + } else { + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + } + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } #endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } resultobj = SWIG_Py_Void(); return resultobj; @@ -5608,180 +5662,206 @@ SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_disown_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + Swig::Director *director = 0; + bool upcall = false; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); - if (director) director->swig_disown(); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *BilinearFormIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BilinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::TransposeIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - { - try { - result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::TransposeIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - try { - result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1); - } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::BilinearFormIntegrator::ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + } else { + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + } + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } #endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_TransposeIntegrator", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 6) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_TransposeIntegrator__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); + } + } + } + } + } } } - if (argc == 2) { + if (argc == 7) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_TransposeIntegrator__SWIG_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); + } + } + } + } + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TransposeIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeElementFlux'.\n" " Possible C/C++ prototypes are:\n" - " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *)\n"); + " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" + " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5790,71 +5870,89 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp5 = 0 ; + int res5 = 0 ; + Swig::Director *director = 0; + bool upcall = false; + double result; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + } else { + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + } + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } #endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5863,51 +5961,162 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + Swig::Director *director = 0; + bool upcall = false; + double result; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + } else { + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); + } + } + } + } } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeFluxEnergy'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" + " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5931,65 +6140,105 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_disown_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *BilinearFormIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BilinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::TransposeIntegrator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + { + try { + result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::TransposeIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6006,21 +6255,65 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_0(PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_TransposeIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_TransposeIntegrator", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_TransposeIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_TransposeIntegrator__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TransposeIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *,int)\n" + " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6029,60 +6322,41 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_1(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6106,12 +6380,12 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_1(PyOb } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -6123,48 +6397,49 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_1(PyObje int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6188,127 +6463,65 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransposeIntegrator_AssembleFaceMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::TransposeIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeIntegrator" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - delete arg1; + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6332,40 +6545,76 @@ SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *TransposeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TransposeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::LumpedIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1,arg2); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6382,29 +6631,72 @@ SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::LumpedIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6421,108 +6713,143 @@ SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_LumpedIntegrator", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_LumpedIntegrator__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } } } - if (argc == 2) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } } } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_LumpedIntegrator__SWIG_0(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TransposeIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LumpedIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransposeIntegrator_AssembleFaceMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *)\n"); + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::TransposeIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::LumpedIntegrator *arg1 = (mfem::LumpedIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "LumpedIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::LumpedIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::LumpedIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6546,23 +6873,64 @@ SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_delete_LumpedIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TransposeIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TransposeIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TransposeIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::TransposeIntegrator::AssemblePA()\n" + " mfem::TransposeIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::LumpedIntegrator *arg1 = (mfem::LumpedIntegrator *) 0 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LumpedIntegrator" "', argument " "1"" of type '" "mfem::LumpedIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::LumpedIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - delete arg1; + (arg1)->AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6586,40 +6954,33 @@ SWIGINTERN PyObject *_wrap_delete_LumpedIntegrator(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *LumpedIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *LumpedIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::InverseIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1,arg2); + (arg1)->AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6636,29 +6997,51 @@ SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::InverseIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1); + ((mfem::TransposeIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6675,108 +7058,51 @@ SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_InverseIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_InverseIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_InverseIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::InverseIntegrator *arg1 = (mfem::InverseIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "InverseIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::InverseIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::InverseIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + ((mfem::TransposeIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6800,20 +7126,20 @@ SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWI } -SWIGINTERN PyObject *_wrap_delete_InverseIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::InverseIntegrator *arg1 = (mfem::InverseIntegrator *) 0 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InverseIntegrator" "', argument " "1"" of type '" "mfem::InverseIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeIntegrator" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::InverseIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); { try { delete arg1; @@ -6840,32 +7166,40 @@ SWIGINTERN PyObject *_wrap_delete_InverseIntegrator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *InverseIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *TransposeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__InverseIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *InverseIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *TransposeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - mfem::SumIntegrator *result = 0 ; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::LumpedIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - result = (mfem::SumIntegrator *)new mfem::SumIntegrator(arg1); + result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6882,21 +7216,29 @@ SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SumIntegrator *result = 0 ; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::LumpedIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { try { - result = (mfem::SumIntegrator *)new mfem::SumIntegrator(); + result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6913,139 +7255,103 @@ SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SumIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_LumpedIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SumIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_LumpedIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_SumIntegrator__SWIG_1(self, argc, argv); - } if (argc == 1) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_LumpedIntegrator__SWIG_1(self, argc, argv); } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_SumIntegrator__SWIG_0(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_LumpedIntegrator__SWIG_0(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SumIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LumpedIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SumIntegrator::SumIntegrator(int)\n" - " mfem::SumIntegrator::SumIntegrator()\n"); + " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *,int)\n" + " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; + mfem::LumpedIntegrator *arg1 = (mfem::LumpedIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AddIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "LumpedIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AddIntegrator" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::LumpedIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + arg1 = reinterpret_cast< mfem::LumpedIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AddIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - { - try { - (arg1)->AddIntegrator(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -7074,20 +7380,20 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_delete_SumIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_LumpedIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; + mfem::LumpedIntegrator *arg1 = (mfem::LumpedIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SumIntegrator" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LumpedIntegrator" "', argument " "1"" of type '" "mfem::LumpedIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::LumpedIntegrator * >(argp1); { try { delete arg1; @@ -7114,77 +7420,79 @@ SWIGINTERN PyObject *_wrap_delete_SumIntegrator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SumIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *LumpedIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SumIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SumIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *LumpedIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + mfem::InverseIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + { + try { + result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::InverseIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7201,16 +7509,62 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InverseIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseIntegrator", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_InverseIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_InverseIntegrator__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *,int)\n" + " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; + mfem::InverseIntegrator *arg1 = (mfem::InverseIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -7224,34 +7578,34 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "InverseIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::InverseIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::InverseIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -7280,20 +7634,20 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_delete_MixedScalarIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_InverseIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; + mfem::InverseIntegrator *arg1 = (mfem::InverseIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InverseIntegrator" "', argument " "1"" of type '" "mfem::InverseIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::InverseIntegrator * >(argp1); { try { delete arg1; @@ -7320,73 +7674,145 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *MixedScalarIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *InverseIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__InverseIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *InverseIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + int arg1 ; + mfem::SumIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::SumIntegrator *)new mfem::SumIntegrator(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::SumIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::SumIntegrator *)new mfem::SumIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SumIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SumIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SumIntegrator__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SumIntegrator__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SumIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SumIntegrator::SumIntegrator(int)\n" + " mfem::SumIntegrator::SumIntegrator()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; + mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AddIntegrator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AddIntegrator" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AddIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AddIntegrator(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7410,9 +7836,9 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; + mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -7426,34 +7852,34 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -7482,20 +7908,20 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_delete_MixedVectorIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_SumIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; + mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SumIntegrator" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); { try { delete arg1; @@ -7522,16 +7948,20 @@ SWIGINTERN PyObject *_wrap_delete_MixedVectorIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *MixedVectorIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *SumIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SumIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *SumIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarVectorIntegrator *arg1 = (mfem::MixedScalarVectorIntegrator *) 0 ; + mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; mfem::ElementTransformation *arg4 = 0 ; @@ -7548,42 +7978,42 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py int res5 = 0 ; PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarVectorIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarVectorIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { @@ -7612,23 +8042,55 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py } -SWIGINTERN PyObject *_wrap_delete_MixedScalarVectorIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarVectorIntegrator *arg1 = (mfem::MixedScalarVectorIntegrator *) 0 ; + mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarVectorIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarVectorIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarVectorIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7652,21 +8114,23 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarVectorIntegrator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *MixedScalarVectorIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarMassIntegrator *result = 0 ; + mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); { try { - result = (mfem::MixedScalarMassIntegrator *)new mfem::MixedScalarMassIntegrator(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7683,32 +8147,80 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator__SWIG_0(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *MixedScalarIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedScalarMassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::MixedScalarMassIntegrator *)new mfem::MixedScalarMassIntegrator(*arg1); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7725,60 +8237,62 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator__SWIG_1(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarMassIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_MixedScalarMassIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedScalarMassIntegrator__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarMassIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedScalarMassIntegrator::MixedScalarMassIntegrator()\n" - " mfem::MixedScalarMassIntegrator::MixedScalarMassIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_MixedScalarMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarMassIntegrator *arg1 = (mfem::MixedScalarMassIntegrator *) 0 ; + mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarMassIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7802,38 +8316,23 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarMassIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *MixedScalarMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedScalarMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedVectorIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedVectorProductIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); { try { - result = (mfem::MixedVectorProductIntegrator *)new mfem::MixedVectorProductIntegrator(*arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7850,27 +8349,117 @@ SWIGINTERN PyObject *_wrap_new_MixedVectorProductIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorProductIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedVectorIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedVectorProductIntegrator *arg1 = (mfem::MixedVectorProductIntegrator *) 0 ; + mfem::MixedScalarVectorIntegrator *arg1 = (mfem::MixedScalarVectorIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedScalarVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarVectorIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MixedScalarVectorIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MixedScalarVectorIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedScalarVectorIntegrator *arg1 = (mfem::MixedScalarVectorIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorProductIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorProductIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarVectorIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarVectorIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedVectorProductIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarVectorIntegrator * >(argp1); { try { delete arg1; @@ -7897,25 +8486,21 @@ SWIGINTERN PyObject *_wrap_delete_MixedVectorProductIntegrator(PyObject *SWIGUNU } -SWIGINTERN PyObject *MixedVectorProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarVectorIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorProductIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedVectorProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MixedScalarDerivativeIntegrator *result = 0 ; + mfem::MixedScalarMassIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MixedScalarDerivativeIntegrator *)new mfem::MixedScalarDerivativeIntegrator(); + result = (mfem::MixedScalarMassIntegrator *)new mfem::MixedScalarMassIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7932,32 +8517,32 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator__SWIG_0(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedScalarDerivativeIntegrator *result = 0 ; + mfem::MixedScalarMassIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MixedScalarDerivativeIntegrator *)new mfem::MixedScalarDerivativeIntegrator(*arg1); + result = (mfem::MixedScalarMassIntegrator *)new mfem::MixedScalarMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7974,23 +8559,23 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator__SWIG_1(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarMassIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarDerivativeIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarMassIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_MixedScalarDerivativeIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_MixedScalarMassIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -7998,33 +8583,33 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator(PyObject *self, P int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedScalarDerivativeIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_MixedScalarMassIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarDerivativeIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarMassIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedScalarDerivativeIntegrator::MixedScalarDerivativeIntegrator()\n" - " mfem::MixedScalarDerivativeIntegrator::MixedScalarDerivativeIntegrator(mfem::Coefficient &)\n"); + " mfem::MixedScalarMassIntegrator::MixedScalarMassIntegrator()\n" + " mfem::MixedScalarMassIntegrator::MixedScalarMassIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_MixedScalarDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarDerivativeIntegrator *arg1 = (mfem::MixedScalarDerivativeIntegrator *) 0 ; + mfem::MixedScalarMassIntegrator *arg1 = (mfem::MixedScalarMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarDerivativeIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarDerivativeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarMassIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarDerivativeIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarMassIntegrator * >(argp1); { try { delete arg1; @@ -8051,67 +8636,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarDerivativeIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *MixedScalarDerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarMassIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedScalarDerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::MixedScalarWeakDerivativeIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::MixedScalarWeakDerivativeIntegrator *)new mfem::MixedScalarWeakDerivativeIntegrator(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedScalarWeakDerivativeIntegrator *result = 0 ; + PyObject *swig_obj[1] ; + mfem::MixedVectorProductIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedScalarWeakDerivativeIntegrator *)new mfem::MixedScalarWeakDerivativeIntegrator(*arg1); + result = (mfem::MixedVectorProductIntegrator *)new mfem::MixedVectorProductIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8128,57 +8684,27 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_1(PyObj SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorProductIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDerivativeIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarWeakDerivativeIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarWeakDerivativeIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedScalarWeakDerivativeIntegrator::MixedScalarWeakDerivativeIntegrator()\n" - " mfem::MixedScalarWeakDerivativeIntegrator::MixedScalarWeakDerivativeIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarWeakDerivativeIntegrator *arg1 = (mfem::MixedScalarWeakDerivativeIntegrator *) 0 ; + mfem::MixedVectorProductIntegrator *arg1 = (mfem::MixedVectorProductIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorProductIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakDerivativeIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakDerivativeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorProductIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarWeakDerivativeIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedVectorProductIntegrator * >(argp1); { try { delete arg1; @@ -8205,25 +8731,25 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakDerivativeIntegrator(PyObject * } -SWIGINTERN PyObject *MixedScalarWeakDerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedVectorProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorProductIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedScalarWeakDerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedVectorProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MixedScalarDivergenceIntegrator *result = 0 ; + mfem::MixedScalarDerivativeIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MixedScalarDivergenceIntegrator *)new mfem::MixedScalarDivergenceIntegrator(); + result = (mfem::MixedScalarDerivativeIntegrator *)new mfem::MixedScalarDerivativeIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8240,32 +8766,32 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator__SWIG_0(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedScalarDivergenceIntegrator *result = 0 ; + mfem::MixedScalarDerivativeIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MixedScalarDivergenceIntegrator *)new mfem::MixedScalarDivergenceIntegrator(*arg1); + result = (mfem::MixedScalarDerivativeIntegrator *)new mfem::MixedScalarDerivativeIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8282,23 +8808,23 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator__SWIG_1(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarDerivativeIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarDivergenceIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarDerivativeIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_MixedScalarDivergenceIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_MixedScalarDerivativeIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -8306,128 +8832,33 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator(PyObject *self, P int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedScalarDivergenceIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_MixedScalarDerivativeIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarDivergenceIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarDerivativeIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedScalarDivergenceIntegrator::MixedScalarDivergenceIntegrator()\n" - " mfem::MixedScalarDivergenceIntegrator::MixedScalarDivergenceIntegrator(mfem::Coefficient &)\n"); + " mfem::MixedScalarDerivativeIntegrator::MixedScalarDerivativeIntegrator()\n" + " mfem::MixedScalarDerivativeIntegrator::MixedScalarDerivativeIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_MixedScalarDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedScalarDivergenceIntegrator *arg1 = (mfem::MixedScalarDivergenceIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarDivergenceIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarDivergenceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedScalarDivergenceIntegrator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MixedScalarDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedScalarDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MixedVectorDivergenceIntegrator *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - try { - result = (mfem::MixedVectorDivergenceIntegrator *)new mfem::MixedVectorDivergenceIntegrator(*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedVectorDivergenceIntegrator *arg1 = (mfem::MixedVectorDivergenceIntegrator *) 0 ; + mfem::MixedScalarDerivativeIntegrator *arg1 = (mfem::MixedScalarDerivativeIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarDerivativeIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarDerivativeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedVectorDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarDerivativeIntegrator * >(argp1); { try { delete arg1; @@ -8454,25 +8885,25 @@ SWIGINTERN PyObject *_wrap_delete_MixedVectorDivergenceIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *MixedVectorDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarDerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedVectorDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarDerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MixedScalarWeakGradientIntegrator *result = 0 ; + mfem::MixedScalarWeakDerivativeIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MixedScalarWeakGradientIntegrator *)new mfem::MixedScalarWeakGradientIntegrator(); + result = (mfem::MixedScalarWeakDerivativeIntegrator *)new mfem::MixedScalarWeakDerivativeIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8489,32 +8920,32 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator__SWIG_0(PyObjec SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedScalarWeakGradientIntegrator *result = 0 ; + mfem::MixedScalarWeakDerivativeIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakGradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakGradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakDerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MixedScalarWeakGradientIntegrator *)new mfem::MixedScalarWeakGradientIntegrator(*arg1); + result = (mfem::MixedScalarWeakDerivativeIntegrator *)new mfem::MixedScalarWeakDerivativeIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8531,23 +8962,23 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator__SWIG_1(PyObjec SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDerivativeIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarWeakGradientIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarWeakDerivativeIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_MixedScalarWeakGradientIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -8555,33 +8986,33 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator(PyObject *self, int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedScalarWeakGradientIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_MixedScalarWeakDerivativeIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarWeakGradientIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarWeakDerivativeIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedScalarWeakGradientIntegrator::MixedScalarWeakGradientIntegrator()\n" - " mfem::MixedScalarWeakGradientIntegrator::MixedScalarWeakGradientIntegrator(mfem::Coefficient &)\n"); + " mfem::MixedScalarWeakDerivativeIntegrator::MixedScalarWeakDerivativeIntegrator()\n" + " mfem::MixedScalarWeakDerivativeIntegrator::MixedScalarWeakDerivativeIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakGradientIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarWeakGradientIntegrator *arg1 = (mfem::MixedScalarWeakGradientIntegrator *) 0 ; + mfem::MixedScalarWeakDerivativeIntegrator *arg1 = (mfem::MixedScalarWeakDerivativeIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakGradientIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakGradientIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakDerivativeIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakDerivativeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarWeakGradientIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarWeakDerivativeIntegrator * >(argp1); { try { delete arg1; @@ -8608,25 +9039,25 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakGradientIntegrator(PyObject *SW } -SWIGINTERN PyObject *MixedScalarWeakGradientIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarWeakDerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedScalarWeakGradientIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarWeakDerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MixedScalarCurlIntegrator *result = 0 ; + mfem::MixedScalarDivergenceIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MixedScalarCurlIntegrator *)new mfem::MixedScalarCurlIntegrator(); + result = (mfem::MixedScalarDivergenceIntegrator *)new mfem::MixedScalarDivergenceIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8643,32 +9074,32 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator__SWIG_0(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedScalarCurlIntegrator *result = 0 ; + mfem::MixedScalarDivergenceIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MixedScalarCurlIntegrator *)new mfem::MixedScalarCurlIntegrator(*arg1); + result = (mfem::MixedScalarDivergenceIntegrator *)new mfem::MixedScalarDivergenceIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8685,23 +9116,23 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator__SWIG_1(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarDivergenceIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarCurlIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarDivergenceIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_MixedScalarCurlIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_MixedScalarDivergenceIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -8709,33 +9140,33 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedScalarCurlIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_MixedScalarDivergenceIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarCurlIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarDivergenceIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedScalarCurlIntegrator::MixedScalarCurlIntegrator()\n" - " mfem::MixedScalarCurlIntegrator::MixedScalarCurlIntegrator(mfem::Coefficient &)\n"); + " mfem::MixedScalarDivergenceIntegrator::MixedScalarDivergenceIntegrator()\n" + " mfem::MixedScalarDivergenceIntegrator::MixedScalarDivergenceIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_MixedScalarCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCurlIntegrator *arg1 = (mfem::MixedScalarCurlIntegrator *) 0 ; + mfem::MixedScalarDivergenceIntegrator *arg1 = (mfem::MixedScalarDivergenceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarDivergenceIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarDivergenceIntegrator * >(argp1); { try { delete arg1; @@ -8762,25 +9193,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarCurlIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *MixedScalarCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedScalarCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarWeakCurlIntegrator *result = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MixedVectorDivergenceIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedScalarWeakCurlIntegrator *)new mfem::MixedScalarWeakCurlIntegrator(); + result = (mfem::MixedVectorDivergenceIntegrator *)new mfem::MixedVectorDivergenceIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8797,32 +9241,30 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator__SWIG_0(PyObject *S SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::MixedVectorDivergenceIntegrator *arg1 = (mfem::MixedVectorDivergenceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedScalarWeakCurlIntegrator *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MixedVectorDivergenceIntegrator * >(argp1); { try { - result = (mfem::MixedScalarWeakCurlIntegrator *)new mfem::MixedScalarWeakCurlIntegrator(*arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8839,60 +9281,32 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator__SWIG_1(PyObject *S SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarWeakCurlIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_MixedScalarWeakCurlIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedScalarWeakCurlIntegrator__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarWeakCurlIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedScalarWeakCurlIntegrator::MixedScalarWeakCurlIntegrator()\n" - " mfem::MixedScalarWeakCurlIntegrator::MixedScalarWeakCurlIntegrator(mfem::Coefficient &)\n"); - return 0; +SWIGINTERN PyObject *MixedVectorDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } +SWIGINTERN PyObject *MixedVectorDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} -SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MixedScalarWeakCurlIntegrator *arg1 = (mfem::MixedScalarWeakCurlIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::MixedScalarWeakGradientIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlIntegrator * >(argp1); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - delete arg1; + result = (mfem::MixedScalarWeakGradientIntegrator *)new mfem::MixedScalarWeakGradientIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8909,32 +9323,32 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakCurlIntegrator(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MixedScalarWeakCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedScalarWeakCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedVectorMassIntegrator *result = 0 ; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::MixedScalarWeakGradientIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakGradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakGradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(); + result = (mfem::MixedScalarWeakGradientIntegrator *)new mfem::MixedScalarWeakGradientIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8951,32 +9365,60 @@ SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_0(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakGradientIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarWeakGradientIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_MixedScalarWeakGradientIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedScalarWeakGradientIntegrator__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarWeakGradientIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedScalarWeakGradientIntegrator::MixedScalarWeakGradientIntegrator()\n" + " mfem::MixedScalarWeakGradientIntegrator::MixedScalarWeakGradientIntegrator(mfem::Coefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakGradientIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::MixedScalarWeakGradientIntegrator *arg1 = (mfem::MixedScalarWeakGradientIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedVectorMassIntegrator *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakGradientIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakGradientIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarWeakGradientIntegrator * >(argp1); { try { - result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(*arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8993,32 +9435,32 @@ SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_1(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *MixedScalarWeakGradientIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedScalarWeakGradientIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::MixedVectorMassIntegrator *result = 0 ; + mfem::MixedScalarCurlIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(*arg1); + result = (mfem::MixedScalarCurlIntegrator *)new mfem::MixedScalarCurlIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9035,32 +9477,32 @@ SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_2(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedVectorMassIntegrator *result = 0 ; + mfem::MixedScalarCurlIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(*arg1); + result = (mfem::MixedScalarCurlIntegrator *)new mfem::MixedScalarCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9077,23 +9519,23 @@ SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_3(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCurlIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedVectorMassIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarCurlIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_MixedVectorMassIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_MixedScalarCurlIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -9101,53 +9543,33 @@ SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MixedVectorMassIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedVectorMassIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedVectorMassIntegrator__SWIG_3(self, argc, argv); + return _wrap_new_MixedScalarCurlIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedVectorMassIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarCurlIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator()\n" - " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator(mfem::Coefficient &)\n" - " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator(mfem::VectorCoefficient &)\n" - " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::MixedScalarCurlIntegrator::MixedScalarCurlIntegrator()\n" + " mfem::MixedScalarCurlIntegrator::MixedScalarCurlIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_MixedVectorMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedVectorMassIntegrator *arg1 = (mfem::MixedVectorMassIntegrator *) 0 ; + mfem::MixedScalarCurlIntegrator *arg1 = (mfem::MixedScalarCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedVectorMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCurlIntegrator * >(argp1); { try { delete arg1; @@ -9174,38 +9596,25 @@ SWIGINTERN PyObject *_wrap_delete_MixedVectorMassIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *MixedVectorMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedVectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MixedCrossProductIntegrator *result = 0 ; + mfem::MixedScalarWeakCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MixedCrossProductIntegrator *)new mfem::MixedCrossProductIntegrator(*arg1); + result = (mfem::MixedScalarWeakCurlIntegrator *)new mfem::MixedScalarWeakCurlIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9222,30 +9631,32 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossProductIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedCrossProductIntegrator *arg1 = (mfem::MixedCrossProductIntegrator *) 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::MixedScalarWeakCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossProductIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossProductIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossProductIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - delete arg1; + result = (mfem::MixedScalarWeakCurlIntegrator *)new mfem::MixedScalarWeakCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9262,45 +9673,60 @@ SWIGINTERN PyObject *_wrap_delete_MixedCrossProductIntegrator(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MixedCrossProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossProductIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedScalarWeakCurlIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_MixedScalarWeakCurlIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedScalarWeakCurlIntegrator__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedScalarWeakCurlIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedScalarWeakCurlIntegrator::MixedScalarWeakCurlIntegrator()\n" + " mfem::MixedScalarWeakCurlIntegrator::MixedScalarWeakCurlIntegrator(mfem::Coefficient &)\n"); + return 0; } -SWIGINTERN PyObject *MixedCrossProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MixedScalarWeakCurlIntegrator *arg1 = (mfem::MixedScalarWeakCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedDotProductIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlIntegrator * >(argp1); { try { - result = (mfem::MixedDotProductIntegrator *)new mfem::MixedDotProductIntegrator(*arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9317,52 +9743,32 @@ SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedDotProductIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarWeakCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedScalarWeakCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - bool result; + mfem::MixedVectorMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedDotProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (bool)((mfem::MixedDotProductIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9379,31 +9785,32 @@ SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - char *result = 0 ; + mfem::MixedVectorMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDotProductIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (char *)((mfem::MixedDotProductIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9420,30 +9827,32 @@ SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMes SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_FromCharPtr((const char *)result); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::MixedVectorMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - delete arg1; + result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9460,45 +9869,32 @@ SWIGINTERN PyObject *_wrap_delete_MixedDotProductIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MixedDotProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedDotProductIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedDotProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MixedWeakGradDotIntegrator *result = 0 ; + mfem::MixedVectorMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (mfem::MixedWeakGradDotIntegrator *)new mfem::MixedWeakGradDotIntegrator(*arg1); + result = (mfem::MixedVectorMassIntegrator *)new mfem::MixedVectorMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9515,93 +9911,80 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - bool result; +SWIGINTERN PyObject *_wrap_new_MixedVectorMassIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedVectorMassIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_MixedVectorMassIntegrator__SWIG_0(self, argc, argv); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedVectorMassIntegrator__SWIG_1(self, argc, argv); + } } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - { - try { - result = (bool)((mfem::MixedWeakGradDotIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedVectorMassIntegrator__SWIG_2(self, argc, argv); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedVectorMassIntegrator__SWIG_3(self, argc, argv); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedVectorMassIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator()\n" + " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator(mfem::Coefficient &)\n" + " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator(mfem::VectorCoefficient &)\n" + " mfem::MixedVectorMassIntegrator::MixedVectorMassIntegrator(mfem::MatrixCoefficient &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedVectorMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; + mfem::MixedVectorMassIntegrator *arg1 = (mfem::MixedVectorMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - char *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedVectorMassIntegrator" "', argument " "1"" of type '" "mfem::MixedVectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedVectorMassIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedWeakGradDotIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9618,62 +10001,45 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMe SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_FromCharPtr((const char *)result); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedVectorMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedVectorMassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedVectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; + mfem::MixedCrossProductIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - (arg1)->CalcShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::MixedCrossProductIntegrator *)new mfem::MixedCrossProductIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9690,27 +10056,27 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossProductIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; + mfem::MixedCrossProductIntegrator *arg1 = (mfem::MixedCrossProductIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossProductIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossProductIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossProductIntegrator * >(argp1); { try { delete arg1; @@ -9737,38 +10103,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *MixedWeakGradDotIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossProductIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedWeakGradDotIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedWeakDivCrossIntegrator *result = 0 ; + mfem::MixedDotProductIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedWeakDivCrossIntegrator *)new mfem::MixedWeakDivCrossIntegrator(*arg1); + result = (mfem::MixedDotProductIntegrator *)new mfem::MixedDotProductIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9785,16 +10151,16 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedDotProductIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; + mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -9806,31 +10172,31 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes( PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedDotProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedWeakDivCrossIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedDotProductIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9854,9 +10220,9 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes( } -SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; + mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9864,14 +10230,14 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureM if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDotProductIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedWeakDivCrossIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedDotProductIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9895,55 +10261,78 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureM } -SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MixedDotProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedDotProductIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedDotProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MixedWeakGradDotIntegrator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::MixedWeakGradDotIntegrator *)new mfem::MixedWeakGradDotIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9960,30 +10349,52 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *S SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; + mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - delete arg1; + result = (bool)((mfem::MixedWeakGradDotIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10000,32 +10411,31 @@ SWIGINTERN PyObject *_wrap_delete_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MixedWeakDivCrossIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedWeakDivCrossIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedGradGradIntegrator *result = 0 ; + mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); { try { - result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(); + result = (char *)((mfem::MixedWeakGradDotIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10042,32 +10452,62 @@ SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_0(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedGradGradIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(*arg1); + (arg1)->CalcShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10084,32 +10524,30 @@ SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_1(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedGradGradIntegrator *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); { try { - result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(*arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10126,32 +10564,45 @@ SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_2(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *MixedWeakGradDotIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedWeakGradDotIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedGradGradIntegrator *result = 0 ; + PyObject *swig_obj[1] ; + mfem::MixedWeakDivCrossIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(*arg1); + result = (mfem::MixedWeakDivCrossIntegrator *)new mfem::MixedWeakDivCrossIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10168,102 +10619,52 @@ SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_3(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; +SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedGradGradIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_MixedGradGradIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedGradGradIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedGradGradIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedGradGradIntegrator__SWIG_3(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedGradGradIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator()\n" - " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator(mfem::Coefficient &)\n" - " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator(mfem::VectorCoefficient &)\n" - " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator(mfem::MatrixCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - bool result; - - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedGradGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedWeakDivCrossIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10287,9 +10688,9 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyOb } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; + mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10297,14 +10698,14 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessa if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedGradGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedWeakDivCrossIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10328,12 +10729,12 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessa } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; + mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10343,41 +10744,40 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject void *argp4 = 0 ; int res4 = 0 ; PyObject *swig_obj[4] ; - int result; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_GetIntegrationOrder", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (int)(arg1)->GetIntegrationOrder((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4); + (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10394,62 +10794,30 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator *""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); { try { - (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10473,55 +10841,25 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedWeakDivCrossIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedWeakDivCrossIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::MixedGradGradIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10538,30 +10876,32 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MixedGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::MixedGradGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - delete arg1; + result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10578,45 +10918,32 @@ SWIGINTERN PyObject *_wrap_delete_MixedGradGradIntegrator(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MixedGradGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedGradGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MixedCrossGradGradIntegrator *result = 0 ; + mfem::MixedGradGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedCrossGradGradIntegrator *)new mfem::MixedCrossGradGradIntegrator(*arg1); + result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10633,16 +10960,108 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::MixedGradGradIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + { + try { + result = (mfem::MixedGradGradIntegrator *)new mfem::MixedGradGradIntegrator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedGradGradIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_MixedGradGradIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedGradGradIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedGradGradIntegrator__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedGradGradIntegrator__SWIG_3(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedGradGradIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator()\n" + " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator(mfem::Coefficient &)\n" + " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator(mfem::VectorCoefficient &)\n" + " mfem::MixedGradGradIntegrator::MixedGradGradIntegrator(mfem::MatrixCoefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -10654,31 +11073,31 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedCrossGradGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedGradGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10702,9 +11121,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; + mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10712,14 +11131,14 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailure if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedCrossGradGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedGradGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10743,12 +11162,12 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; + mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10758,40 +11177,41 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject void *argp4 = 0 ; int res4 = 0 ; PyObject *swig_obj[4] ; + int result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_GetIntegrationOrder", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); { try { - (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (int)(arg1)->GetIntegrationOrder((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10808,16 +11228,16 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; + mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -10831,39 +11251,39 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10887,107 +11307,55 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * } -SWIGINTERN PyObject *_wrap_delete_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; + mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *MixedCrossGradGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedCrossGradGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::MixedCurlCurlIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::MixedCurlCurlIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(*arg1); + (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11004,32 +11372,30 @@ SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_1(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_MixedGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedCurlCurlIntegrator *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedGradGradIntegrator" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); { try { - result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(*arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11046,32 +11412,45 @@ SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_2(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *MixedGradGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedGradGradIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedGradGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MixedCurlCurlIntegrator *result = 0 ; + PyObject *swig_obj[1] ; + mfem::MixedCrossGradGradIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(*arg1); + result = (mfem::MixedCrossGradGradIntegrator *)new mfem::MixedCrossGradGradIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11088,66 +11467,16 @@ SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_3(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedCurlCurlIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_MixedCurlCurlIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedCurlCurlIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedCurlCurlIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MixedCurlCurlIntegrator__SWIG_3(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedCurlCurlIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator()\n" - " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator(mfem::Coefficient &)\n" - " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator(mfem::VectorCoefficient &)\n" - " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator(mfem::MatrixCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; + mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -11159,31 +11488,31 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyOb PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedCurlCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedCrossGradGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11207,9 +11536,9 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyOb } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; + mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -11217,14 +11546,14 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessa if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedCurlCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedCrossGradGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11248,9 +11577,9 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessa } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; + mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -11264,34 +11593,34 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -11320,9 +11649,9 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; + mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -11336,34 +11665,34 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -11392,20 +11721,20 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_delete_MixedCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; + mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); { try { delete arg1; @@ -11432,38 +11761,67 @@ SWIGINTERN PyObject *_wrap_delete_MixedCurlCurlIntegrator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *MixedCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossGradGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossGradGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MixedCurlCurlIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MixedCrossCurlCurlIntegrator *result = 0 ; + mfem::MixedCurlCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MixedCrossCurlCurlIntegrator *)new mfem::MixedCrossCurlCurlIntegrator(*arg1); + result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11480,52 +11838,32 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - bool result; + mfem::MixedCurlCurlIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (bool)((mfem::MixedCrossCurlCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11542,31 +11880,32 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - char *result = 0 ; + mfem::MixedCurlCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (char *)((mfem::MixedCrossCurlCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (mfem::MixedCurlCurlIntegrator *)new mfem::MixedCurlCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11583,62 +11922,102 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailure SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_FromCharPtr((const char *)result); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MixedCurlCurlIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_MixedCurlCurlIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedCurlCurlIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedCurlCurlIntegrator__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MixedCurlCurlIntegrator__SWIG_3(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MixedCurlCurlIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator()\n" + " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator(mfem::Coefficient &)\n" + " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator(mfem::VectorCoefficient &)\n" + " mfem::MixedCurlCurlIntegrator::MixedCurlCurlIntegrator(mfem::MatrixCoefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; + mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[3] ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (bool)((mfem::MixedCurlCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11655,16 +12034,57 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; + mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); + { + try { + result = (char *)((mfem::MixedCurlCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -11678,34 +12098,106 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -11734,20 +12226,20 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * } -SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; + mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); { try { delete arg1; @@ -11774,38 +12266,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNU } -SWIGINTERN PyObject *MixedCrossCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedCrossCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedCrossCurlGradIntegrator *result = 0 ; + mfem::MixedCrossCurlCurlIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedCrossCurlGradIntegrator *)new mfem::MixedCrossCurlGradIntegrator(*arg1); + result = (mfem::MixedCrossCurlCurlIntegrator *)new mfem::MixedCrossCurlCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11822,16 +12314,16 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; + mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -11843,31 +12335,31 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedCrossCurlGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedCrossCurlCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11891,9 +12383,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; + mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -11901,14 +12393,14 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailure if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedCrossCurlGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedCrossCurlCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11932,9 +12424,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; + mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -11948,34 +12440,34 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -12004,9 +12496,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; + mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -12020,34 +12512,34 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -12076,20 +12568,20 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * } -SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; + mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); { try { delete arg1; @@ -12116,38 +12608,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlGradIntegrator(PyObject *SWIGUNU } -SWIGINTERN PyObject *MixedCrossCurlGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedCrossCurlGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedCrossGradCurlIntegrator *result = 0 ; + mfem::MixedCrossCurlGradIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedCrossGradCurlIntegrator *)new mfem::MixedCrossGradCurlIntegrator(*arg1); + result = (mfem::MixedCrossCurlGradIntegrator *)new mfem::MixedCrossCurlGradIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12164,16 +12656,16 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; + mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -12185,31 +12677,31 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedCrossGradCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedCrossCurlGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12233,9 +12725,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; + mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12243,14 +12735,14 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailure if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedCrossGradCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedCrossCurlGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12274,9 +12766,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; + mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -12290,34 +12782,34 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -12346,9 +12838,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; + mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -12362,34 +12854,34 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -12418,20 +12910,20 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * } -SWIGINTERN PyObject *_wrap_delete_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; + mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); { try { delete arg1; @@ -12458,38 +12950,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedCrossGradCurlIntegrator(PyObject *SWIGUNU } -SWIGINTERN PyObject *MixedCrossGradCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossCurlGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedCrossGradCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossCurlGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedWeakCurlCrossIntegrator *result = 0 ; + mfem::MixedCrossGradCurlIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedWeakCurlCrossIntegrator *)new mfem::MixedWeakCurlCrossIntegrator(*arg1); + result = (mfem::MixedCrossGradCurlIntegrator *)new mfem::MixedCrossGradCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12506,16 +12998,16 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; + mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -12527,31 +13019,31 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedWeakCurlCrossIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedCrossGradCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12575,9 +13067,9 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes } -SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; + mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12585,14 +13077,14 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailure if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedWeakCurlCrossIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedCrossGradCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12616,9 +13108,9 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; + mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -12632,39 +13124,39 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12688,23 +13180,55 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * } -SWIGINTERN PyObject *_wrap_delete_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; + mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12728,38 +13252,78 @@ SWIGINTERN PyObject *_wrap_delete_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNU } -SWIGINTERN PyObject *MixedWeakCurlCrossIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedWeakCurlCrossIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedScalarWeakCurlCrossIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MixedCrossGradCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedCrossGradCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MixedWeakCurlCrossIntegrator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedScalarWeakCurlCrossIntegrator *)new mfem::MixedScalarWeakCurlCrossIntegrator(*arg1); + result = (mfem::MixedWeakCurlCrossIntegrator *)new mfem::MixedWeakCurlCrossIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12776,16 +13340,16 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIG SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; + mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -12797,31 +13361,31 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElemen PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedScalarWeakCurlCrossIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedWeakCurlCrossIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12845,9 +13409,9 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElemen } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; + mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -12855,14 +13419,14 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeF if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedScalarWeakCurlCrossIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedWeakCurlCrossIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12886,12 +13450,12 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeF } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; + mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -12902,39 +13466,39 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->CalcShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12958,20 +13522,20 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject } -SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; + mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); { try { delete arg1; @@ -12998,38 +13562,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakCurlCrossIntegrator(PyObject *S } -SWIGINTERN PyObject *MixedScalarWeakCurlCrossIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedWeakCurlCrossIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedScalarWeakCurlCrossIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedWeakCurlCrossIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedCrossGradIntegrator *result = 0 ; + mfem::MixedScalarWeakCurlCrossIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedCrossGradIntegrator *)new mfem::MixedCrossGradIntegrator(*arg1); + result = (mfem::MixedScalarWeakCurlCrossIntegrator *)new mfem::MixedScalarWeakCurlCrossIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13046,16 +13610,16 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; + mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -13067,31 +13631,31 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyO PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedCrossGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedScalarWeakCurlCrossIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13115,9 +13679,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyO } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; + mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13125,14 +13689,14 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMess if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedCrossGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedScalarWeakCurlCrossIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13156,12 +13720,12 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMess } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; + mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13172,39 +13736,39 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->CalcShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13228,92 +13792,20 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - try { - (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); { try { delete arg1; @@ -13340,38 +13832,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *MixedCrossGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarWeakCurlCrossIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossGradIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedCrossGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarWeakCurlCrossIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedCrossCurlIntegrator *result = 0 ; + mfem::MixedCrossGradIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedCrossCurlIntegrator *)new mfem::MixedCrossCurlIntegrator(*arg1); + result = (mfem::MixedCrossGradIntegrator *)new mfem::MixedCrossGradIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13388,16 +13880,16 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossGradIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; + mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -13409,31 +13901,31 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyO PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedCrossCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedCrossGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13457,9 +13949,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyO } -SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; + mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13467,14 +13959,14 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMess if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedCrossCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedCrossGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13498,9 +13990,9 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMess } -SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; + mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -13514,34 +14006,34 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -13570,20 +14062,92 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; + mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + (arg1)->CalcTestShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); { try { delete arg1; @@ -13610,38 +14174,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *MixedCrossCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossGradIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedScalarCrossCurlIntegrator *result = 0 ; + mfem::MixedCrossCurlIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedScalarCrossCurlIntegrator *)new mfem::MixedScalarCrossCurlIntegrator(*arg1); + result = (mfem::MixedCrossCurlIntegrator *)new mfem::MixedCrossCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13658,16 +14222,16 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; + mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -13679,31 +14243,31 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTyp PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedScalarCrossCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedCrossCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13727,9 +14291,9 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTyp } -SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; + mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -13737,14 +14301,14 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailu if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedScalarCrossCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedCrossCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13768,12 +14332,12 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailu } -SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; + mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13784,39 +14348,39 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->CalcShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->CalcTrialShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13840,20 +14404,20 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW } -SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; + mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); { try { delete arg1; @@ -13880,38 +14444,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossCurlIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *MixedScalarCrossCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedScalarCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedScalarCrossGradIntegrator *result = 0 ; + mfem::MixedScalarCrossCurlIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedScalarCrossGradIntegrator *)new mfem::MixedScalarCrossGradIntegrator(*arg1); + result = (mfem::MixedScalarCrossCurlIntegrator *)new mfem::MixedScalarCrossCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13928,16 +14492,16 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; + mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -13949,31 +14513,31 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTyp PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedScalarCrossGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedScalarCrossCurlIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13997,9 +14561,9 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTyp } -SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; + mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14007,14 +14571,14 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailu if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedScalarCrossGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedScalarCrossCurlIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14038,12 +14602,12 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailu } -SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; + mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -14054,39 +14618,39 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->CalcVShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->CalcShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14110,20 +14674,20 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S } -SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; + mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); { try { delete arg1; @@ -14150,38 +14714,38 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossGradIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *MixedScalarCrossGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarCrossCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MixedScalarCrossGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *MixedScalarCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::MixedScalarCrossProductIntegrator *result = 0 ; + mfem::MixedScalarCrossGradIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::MixedScalarCrossProductIntegrator *)new mfem::MixedScalarCrossProductIntegrator(*arg1); + result = (mfem::MixedScalarCrossGradIntegrator *)new mfem::MixedScalarCrossGradIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14198,16 +14762,16 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; + mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; void *argp1 = 0 ; @@ -14219,31 +14783,31 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElement PyObject *swig_obj[3] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); { try { - result = (bool)((mfem::MixedScalarCrossProductIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + result = (bool)((mfem::MixedScalarCrossGradIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14267,9 +14831,9 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElement } -SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; + mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -14277,14 +14841,14 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFa if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); { try { - result = (char *)((mfem::MixedScalarCrossProductIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + result = (char *)((mfem::MixedScalarCrossGradIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14308,23 +14872,55 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFa } -SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; + mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->CalcVShape((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14348,18 +14944,256 @@ SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossProductIntegrator(PyObject *SW } -SWIGINTERN PyObject *MixedScalarCrossProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MixedScalarCrossProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MixedScalarCrossGradIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedScalarCrossGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MixedScalarCrossProductIntegrator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + try { + result = (mfem::MixedScalarCrossProductIntegrator *)new mfem::MixedScalarCrossProductIntegrator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + { + try { + result = (bool)((mfem::MixedScalarCrossProductIntegrator const *)arg1)->VerifyFiniteElementTypes((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); + { + try { + result = (char *)((mfem::MixedScalarCrossProductIntegrator const *)arg1)->FiniteElementTypeFailureMessage(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MixedScalarCrossProductIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MixedScalarCrossProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; @@ -16885,14 +17719,14 @@ SWIGINTERN PyObject *MixedVectorWeakDivergenceIntegrator_swiginit(PyObject *SWIG return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *result = 0 ; + mfem::GradientIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(); + result = (mfem::GradientIntegrator *)new mfem::GradientIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16909,32 +17743,29 @@ SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DiffusionIntegrator *result = 0 ; + mfem::GradientIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); + result = (mfem::GradientIntegrator *)new mfem::GradientIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16951,32 +17782,32 @@ SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DiffusionIntegrator *result = 0 ; + mfem::GradientIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GradientIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); + result = (mfem::GradientIntegrator *)new mfem::GradientIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16993,59 +17824,60 @@ SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GradientIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiffusionIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GradientIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_DiffusionIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_GradientIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_DiffusionIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_GradientIntegrator__SWIG_1(self, argc, argv); } } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_DiffusionIntegrator__SWIG_2(self, argc, argv); + return _wrap_new_GradientIntegrator__SWIG_2(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiffusionIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GradientIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::DiffusionIntegrator()\n" - " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::Coefficient &)\n" - " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::GradientIntegrator::GradientIntegrator()\n" + " mfem::GradientIntegrator::GradientIntegrator(mfem::Coefficient *)\n" + " mfem::GradientIntegrator::GradientIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -17054,41 +17886,51 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17112,66 +17954,43 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17195,66 +18014,79 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GradientIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GradientIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GradientIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GradientIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GradientIntegrator::AssemblePA()\n" + " mfem::GradientIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + ((mfem::GradientIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17278,83 +18110,44 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - int arg7 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + ((mfem::GradientIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17378,76 +18171,48 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObje } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + result = (mfem::IntegrationRule *) &mfem::GradientIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17464,162 +18229,30 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeElementFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,int)\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_GradientIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + PyObject *swig_obj[1] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GradientIntegrator" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17636,62 +18269,32 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObjec SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *GradientIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GradientIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GradientIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; + mfem::DiffusionIntegrator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17708,109 +18311,32 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::DiffusionIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssemblePA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17827,51 +18353,32 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + mfem::DiffusionIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator const *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - ((mfem::DiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + result = (mfem::DiffusionIntegrator *)new mfem::DiffusionIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17888,44 +18395,70 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DiffusionIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DiffusionIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_DiffusionIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_DiffusionIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_DiffusionIntegrator__SWIG_2(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DiffusionIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DiffusionIntegrator::DiffusionIntegrator()\n" + " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::Coefficient &)\n" + " mfem::DiffusionIntegrator::DiffusionIntegrator(mfem::MatrixCoefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_DiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::FiniteElement *arg1 = 0 ; - mfem::FiniteElement *arg2 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - mfem::IntegrationRule *result = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); { try { - result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17942,30 +18475,62 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_DiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiffusionIntegrator" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17989,33 +18554,66 @@ SWIGINTERN PyObject *_wrap_delete_DiffusionIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *DiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18032,21 +18630,73 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MassIntegrator *result = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(); + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18063,40 +18713,91 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::MassIntegrator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18113,116 +18814,201 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::MassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + { + try { + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MassIntegrator", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); - } - } - if (argc == 1) { + if (argc == 6) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MassIntegrator__SWIG_3(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); + } + } + } + } + } } } - if (argc == 2) { + if (argc == 7) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MassIntegrator__SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); + } + } + } + } + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MassIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeElementFlux'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MassIntegrator::MassIntegrator(mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator()\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &)\n"); + " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" + " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -18231,41 +19017,48 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp5 = 0 ; + int res5 = 0 ; + double result; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18282,20 +19075,19 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -18304,51 +19096,41 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + double result; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18365,35 +19147,103 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssemblePA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeFluxEnergy'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" + " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { @@ -18422,44 +19272,64 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DiffusionIntegrator::AssemblePA()\n" + " mfem::DiffusionIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::MassIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + (arg1)->AssembleDiagonalPA(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18483,11 +19353,11 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::FiniteElement *arg1 = 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -18495,36 +19365,32 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self) void *argp3 = 0 ; int res3 = 0 ; PyObject *swig_obj[3] ; - mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::IntegrationRule *) &mfem::MassIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); + ((mfem::DiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18541,30 +19407,44 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_MassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::IntegrationRule *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassIntegrator" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); { try { - delete arg1; + result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18581,45 +19461,47 @@ SWIGINTERN PyObject *_wrap_delete_MassIntegrator(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MassIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::BoundaryMassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); { try { - result = (mfem::BoundaryMassIntegrator *)new mfem::BoundaryMassIntegrator(*arg1); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18636,72 +19518,39 @@ SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18725,76 +19574,114 @@ SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(P } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DiffusionIntegrator_SetupPA__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DiffusionIntegrator_SetupPA__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_SetupPA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" + " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *DiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + mfem::MassIntegrator *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); + { + try { + result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::MassIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18811,72 +19698,40 @@ SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + mfem::MassIntegrator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18893,131 +19748,124 @@ SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::MassIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BoundaryMassIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MassIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 0) { + return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); + } + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } + return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); } } - if (argc == 5) { + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } + return _wrap_new_MassIntegrator__SWIG_3(self, argc, argv); } } - if (argc == 6) { + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } + return _wrap_new_MassIntegrator__SWIG_2(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoundaryMassIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MassIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::BoundaryMassIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::MassIntegrator::MassIntegrator(mfem::IntegrationRule const *)\n" + " mfem::MassIntegrator::MassIntegrator()\n" + " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" + " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_MassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MassIntegrator" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); { try { delete arg1; @@ -19044,44 +19892,55 @@ SWIGINTERN PyObject *_wrap_delete_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *BoundaryMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BoundaryMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::ConvectionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19098,36 +19957,77 @@ SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ConvectionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); s = s + s2; SWIG_exception(SWIG_RuntimeError, s.c_str()); } @@ -19140,107 +20040,120 @@ SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvectionIntegrator", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MassIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_1(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_0(self, argc, argv); + return _wrap_MassIntegrator_AssemblePA__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvectionIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MassIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &)\n"); + " mfem::MassIntegrator::AssemblePA()\n" + " mfem::MassIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleDiagonalPA(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19264,23 +20177,44 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_delete_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::MassIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - delete arg1; + ((mfem::MassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19304,44 +20238,48 @@ SWIGINTERN PyObject *_wrap_delete_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *ConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::GroupConvectionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); { try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); + result = (mfem::IntegrationRule *) &mfem::MassIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19358,32 +20296,47 @@ SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::GroupConvectionIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MassIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); { try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19400,107 +20353,39 @@ SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GroupConvectionIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GroupConvectionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "GroupConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19524,23 +20409,88 @@ SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObj } -SWIGINTERN PyObject *_wrap_delete_GroupConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MassIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MassIntegrator_SetupPA__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MassIntegrator_SetupPA__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MassIntegrator_SetupPA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" + " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *MassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + mfem::BoundaryMassIntegrator *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - delete arg1; + result = (mfem::BoundaryMassIntegrator *)new mfem::BoundaryMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19557,32 +20507,72 @@ SWIGINTERN PyObject *_wrap_delete_GroupConvectionIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *GroupConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *GroupConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *result = 0 ; + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19599,81 +20589,83 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19690,131 +20682,72 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryMassIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19831,39 +20764,195 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - int arg2 ; +SWIGINTERN PyObject *_wrap_BoundaryMassIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BoundaryMassIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BoundaryMassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BoundaryMassIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BoundaryMassIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::BoundaryMassIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BoundaryMassIntegrator *arg1 = (mfem::BoundaryMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *BoundaryMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BoundaryMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::ConvectionIntegrator *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); + result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19880,32 +20969,32 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; + mfem::ConvectionIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19922,49 +21011,28 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorMassIntegrator", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvectionIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_VectorMassIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); - } - } if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_5(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_7(self, argc, argv); + return _wrap_new_ConvectionIntegrator__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -19974,104 +21042,76 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; + if (PyFloat_Check(argv[1])){ + _v = 1; } else { - _v = 1; + _v = 0; } } if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_6(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_ConvectionIntegrator__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorMassIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvectionIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator()\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &,double)\n" + " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_GetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_GetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (int)((mfem::VectorMassIntegrator const *)arg1)->GetVDim(); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20088,36 +21128,39 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_GetVDim(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; - int arg2 ; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_SetVDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_SetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->SetVDim(arg2); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20141,55 +21184,75 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ConvectionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ConvectionIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConvectionIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ConvectionIntegrator::AssemblePA()\n" + " mfem::ConvectionIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::ConvectionIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + ((mfem::ConvectionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20213,66 +21276,36 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_GetRule__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::IntegrationRule *) &mfem::ConvectionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20289,27 +21322,139 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_VectorMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_GetRule__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + mfem::IntegrationRule *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + { + try { + result = (mfem::IntegrationRule *) &mfem::ConvectionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_GetRule(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_GetRule", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ConvectionIntegrator_GetRule__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ConvectionIntegrator_GetRule__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConvectionIntegrator_GetRule'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ConvectionIntegrator::GetRule(mfem::FiniteElement const &,mfem::ElementTransformation &)\n" + " mfem::ConvectionIntegrator::GetRule(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::ElementTransformation &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); { try { delete arg1; @@ -20336,25 +21481,44 @@ SWIGINTERN PyObject *_wrap_delete_VectorMassIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *VectorMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *result = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::GroupConvectionIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(); + result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20371,32 +21535,32 @@ SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_0(PyObject *SW SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEDivergenceIntegrator *result = 0 ; + mfem::GroupConvectionIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(*arg1); + result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20413,46 +21577,61 @@ SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_1(PyObject *SW SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEDivergenceIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GroupConvectionIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_VectorFEDivergenceIntegrator__SWIG_0(self, argc, argv); - } if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFEDivergenceIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_GroupConvectionIntegrator__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_GroupConvectionIntegrator__SWIG_0(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEDivergenceIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GroupConvectionIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator()\n" - " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator(mfem::Coefficient &)\n"); + " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &,double)\n" + " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; + mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -20466,34 +21645,34 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GroupConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -20522,66 +21701,23 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py } -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_GroupConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20605,23 +21741,25 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P } -SWIGINTERN PyObject *_wrap_delete_VectorFEDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GroupConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GroupConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - delete arg1; + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20638,32 +21776,39 @@ SWIGINTERN PyObject *_wrap_delete_VectorFEDivergenceIntegrator(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; + mfem::Coefficient *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20680,32 +21825,32 @@ SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; + mfem::VectorMassIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(*arg1); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20722,92 +21867,40 @@ SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEWeakDivergenceIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEWeakDivergenceIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator()\n" - " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20824,73 +21917,39 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20907,30 +21966,32 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_VectorFEWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::VectorMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - delete arg1; + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20947,32 +22008,39 @@ SWIGINTERN PyObject *_wrap_delete_VectorFEWeakDivergenceIntegrator(PyObject *SWI SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *result = 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20989,32 +22057,32 @@ SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFECurlIntegrator *result = 0 ; + mfem::VectorMassIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(*arg1); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21031,23 +22099,23 @@ SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFECurlIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorMassIntegrator", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_VectorFECurlIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -21055,68 +22123,132 @@ SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFECurlIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_5(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_7(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_6(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFECurlIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorMassIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator()\n" - " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator(mfem::Coefficient &)\n"); + " mfem::VectorMassIntegrator::VectorMassIntegrator()\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,int)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &,int)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n" + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_GetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; + int result; - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_GetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (int)((mfem::VectorMassIntegrator const *)arg1)->GetVDim(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21133,165 +22265,27 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_VectorFECurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorFECurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorFECurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - int arg2 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; - mfem::DerivativeIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DerivativeIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_SetVDim", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_SetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -21300,7 +22294,7 @@ SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(sel } { try { - result = (mfem::DerivativeIntegrator *)new mfem::DerivativeIntegrator(*arg1,arg2); + (arg1)->SetVDim(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21317,16 +22311,16 @@ SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -21340,34 +22334,34 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -21396,9 +22390,9 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; mfem::ElementTransformation *arg4 = 0 ; @@ -21415,42 +22409,42 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject int res5 = 0 ; PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { @@ -21479,23 +22473,32 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_delete_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - delete arg1; + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21519,25 +22522,64 @@ SWIGINTERN PyObject *_wrap_delete_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *DerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorMassIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorMassIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorMassIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorMassIntegrator::AssemblePA()\n" + " mfem::VectorMassIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; } -SWIGINTERN PyObject *DerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *result = 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + (arg1)->AssembleDiagonalPA(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21554,32 +22596,51 @@ SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::CurlCurlIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); + ((mfem::VectorMassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21596,32 +22657,114 @@ SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_VectorMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; + mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::CurlCurlIntegrator *result = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorFEDivergenceIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorFEDivergenceIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); + result = (mfem::VectorFEDivergenceIntegrator *)new mfem::VectorFEDivergenceIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21638,23 +22781,23 @@ SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_2(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_CurlCurlIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEDivergenceIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_CurlCurlIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_VectorFEDivergenceIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -21662,32 +22805,22 @@ SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_CurlCurlIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_CurlCurlIntegrator__SWIG_2(self, argc, argv); + return _wrap_new_VectorFEDivergenceIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CurlCurlIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEDivergenceIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::CurlCurlIntegrator::CurlCurlIntegrator()\n" - " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::Coefficient &)\n" - " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator()\n" + " mfem::VectorFEDivergenceIntegrator::VectorFEDivergenceIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -21701,34 +22834,34 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -21757,15 +22890,13 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - int arg7 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -21776,65 +22907,89 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject *swig_obj[7] ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeElementFlux", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorFEDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } + arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21858,13 +23013,126 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorFEDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorFEWeakDivergenceIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorFEWeakDivergenceIntegrator *)new mfem::VectorFEWeakDivergenceIntegrator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEWeakDivergenceIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEWeakDivergenceIntegrator__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEWeakDivergenceIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator()\n" + " mfem::VectorFEWeakDivergenceIntegrator::VectorFEWeakDivergenceIntegrator(mfem::Coefficient &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -21873,48 +23141,41 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + PyObject *swig_obj[4] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21931,19 +23192,20 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -21952,41 +23214,51 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - double result; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22003,96 +23275,27 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_CurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorFEWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); { try { delete arg1; @@ -22119,25 +23322,25 @@ SWIGINTERN PyObject *_wrap_delete_CurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *CurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *CurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFEWeakDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *result = 0 ; + mfem::VectorFECurlIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(); + result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22154,32 +23357,32 @@ SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_0(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorCurlCurlIntegrator *result = 0 ; + mfem::VectorFECurlIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(*arg1); + result = (mfem::VectorFECurlIntegrator *)new mfem::VectorFECurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22196,23 +23399,23 @@ SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_1(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorCurlCurlIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFECurlIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_VectorCurlCurlIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_VectorFECurlIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -22220,22 +23423,22 @@ SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorCurlCurlIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_VectorFECurlIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorCurlCurlIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFECurlIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator()\n" - " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator(mfem::Coefficient &)\n"); + " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator()\n" + " mfem::VectorFECurlIntegrator::VectorFECurlIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; + mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -22249,34 +23452,34 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -22305,12 +23508,13 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; + mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -22319,42 +23523,51 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; - double result; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (double)(arg1)->GetElementEnergy((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22371,27 +23584,27 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_VectorCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorFECurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; + mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFECurlIntegrator" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); { try { delete arg1; @@ -22418,25 +23631,44 @@ SWIGINTERN PyObject *_wrap_delete_VectorCurlCurlIntegrator(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *VectorCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFECurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFECurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFECurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::Coefficient *arg1 = 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + mfem::DerivativeIntegrator *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_DerivativeIntegrator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(); + result = (mfem::DerivativeIntegrator *)new mfem::DerivativeIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22453,29 +23685,62 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; + mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22492,32 +23757,73 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22534,29 +23840,30 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_2(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = (mfem::VectorCoefficient *) 0 ; + mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22573,32 +23880,32 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_3(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *DerivativeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DerivativeIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DerivativeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::CurlCurlIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); + result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22615,29 +23922,32 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_4(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::CurlCurlIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); + result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22654,32 +23964,32 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_5(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorFEMassIntegrator *result = 0 ; + mfem::CurlCurlIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); + result = (mfem::CurlCurlIntegrator *)new mfem::CurlCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22696,32 +24006,23 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_6(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEMassIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_CurlCurlIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_VectorFEMassIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_1(self, argc, argv); - } + return _wrap_new_CurlCurlIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -22729,34 +24030,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_3(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_4(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_5(self, argc, argv); + return _wrap_new_CurlCurlIntegrator__SWIG_1(self, argc, argv); } } if (argc == 1) { @@ -22765,27 +24039,23 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFEMassIntegrator__SWIG_6(self, argc, argv); + return _wrap_new_CurlCurlIntegrator__SWIG_2(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEMassIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CurlCurlIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator()\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient *)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient &)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient *)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient &)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient *)\n" - " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::CurlCurlIntegrator::CurlCurlIntegrator()\n" + " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::Coefficient &)\n" + " mfem::CurlCurlIntegrator::CurlCurlIntegrator(mfem::MatrixCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -22799,34 +24069,34 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -22855,13 +24125,15 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -22872,49 +24144,66 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject *swig_obj[7] ; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeElementFlux", 7, 7, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22938,104 +24227,63 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec } -SWIGINTERN PyObject *_wrap_delete_VectorFEMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorFEMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorFEMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::VectorDivergenceIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorDivergenceIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(arg1); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23052,32 +24300,62 @@ SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_1(PyObject *SWIG SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorDivergenceIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(*arg1); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23094,113 +24372,250 @@ SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_2(PyObject *SWIG SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDivergenceIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_VectorDivergenceIntegrator__SWIG_0(self, argc, argv); + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); + } + } + } + } } - if (argc == 1) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorDivergenceIntegrator__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); + } + } + } + } } } - if (argc == 1) { + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_ComputeFluxEnergy'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" + " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + { + try { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorDivergenceIntegrator__SWIG_2(self, argc, argv); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CurlCurlIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDivergenceIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator()\n" - " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient *)\n" - " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient &)\n"); + " mfem::CurlCurlIntegrator::AssemblePA()\n" + " mfem::CurlCurlIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::CurlCurlIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleDiagonalPA(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23224,20 +24639,20 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO } -SWIGINTERN PyObject *_wrap_delete_VectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_CurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlCurlIntegrator" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); { try { delete arg1; @@ -23264,25 +24679,25 @@ SWIGINTERN PyObject *_wrap_delete_VectorDivergenceIntegrator(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *VectorDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *CurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *CurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::DivDivIntegrator *result = 0 ; + mfem::VectorCurlCurlIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(); + result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23299,32 +24714,32 @@ SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DivDivIntegrator *result = 0 ; + mfem::VectorCurlCurlIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(*arg1); + result = (mfem::VectorCurlCurlIntegrator *)new mfem::VectorCurlCurlIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23341,23 +24756,23 @@ SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DivDivIntegrator", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorCurlCurlIntegrator", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_DivDivIntegrator__SWIG_0(self, argc, argv); + return _wrap_new_VectorCurlCurlIntegrator__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; @@ -23365,22 +24780,22 @@ SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_DivDivIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_VectorCurlCurlIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DivDivIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorCurlCurlIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DivDivIntegrator::DivDivIntegrator()\n" - " mfem::DivDivIntegrator::DivDivIntegrator(mfem::Coefficient &)\n"); + " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator()\n" + " mfem::VectorCurlCurlIntegrator::VectorCurlCurlIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; + mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -23394,34 +24809,34 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "DivDivIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -23450,20 +24865,93 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_delete_DivDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; + mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + result = (double)(arg1)->GetElementEnergy((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivDivIntegrator" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); { try { delete arg1; @@ -23490,25 +24978,25 @@ SWIGINTERN PyObject *_wrap_delete_DivDivIntegrator(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *DivDivIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorCurlCurlIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *DivDivIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *result = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23525,32 +25013,29 @@ SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_0(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::VectorDiffusionIntegrator *result = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(*arg1); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23567,92 +25052,71 @@ SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_1(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDiffusionIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_VectorDiffusionIntegrator__SWIG_0(self, argc, argv); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorDiffusionIntegrator__SWIG_1(self, argc, argv); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDiffusionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator()\n" - " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator(mfem::Coefficient &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::VectorCoefficient *arg1 = (mfem::VectorCoefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::VectorFEMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient *""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23669,113 +25133,32 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + mfem::VectorFEMassIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_VectorDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - delete arg1; + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23792,54 +25175,29 @@ SWIGINTERN PyObject *_wrap_delete_VectorDiffusionIntegrator(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *VectorDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; + mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ElasticityIntegrator *result = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,*arg2); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23856,48 +25214,32 @@ SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; + mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::ElasticityIntegrator *result = 0 ; + mfem::VectorFEMassIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ElasticityIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,arg2,arg3); + result = (mfem::VectorFEMassIntegrator *)new mfem::VectorFEMassIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23914,75 +25256,96 @@ SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ElasticityIntegrator", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEMassIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 0) { + return _wrap_new_VectorFEMassIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ElasticityIntegrator__SWIG_0(self, argc, argv); - } + return _wrap_new_VectorFEMassIntegrator__SWIG_1(self, argc, argv); } } - if (argc == 3) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_ElasticityIntegrator__SWIG_1(self, argc, argv); - } - } + return _wrap_new_VectorFEMassIntegrator__SWIG_2(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEMassIntegrator__SWIG_3(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEMassIntegrator__SWIG_4(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEMassIntegrator__SWIG_5(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEMassIntegrator__SWIG_6(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ElasticityIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEMassIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &)\n" - " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,double,double)\n"); + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator()\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient *)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::Coefficient &)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient *)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::VectorCoefficient &)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient *)\n" + " mfem::VectorFEMassIntegrator::VectorFEMassIntegrator(mfem::MatrixCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; @@ -23996,34 +25359,34 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * int res4 = 0 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { @@ -24052,15 +25415,13 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - int arg7 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -24071,64 +25432,49 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObj int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24152,76 +25498,32 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24245,155 +25547,75 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssemblePA(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } + return _wrap_VectorFEMassIntegrator_AssemblePA__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeElementFlux'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorFEMassIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,int)\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); + " mfem::VectorFEMassIntegrator::AssemblePA()\n" + " mfem::VectorFEMassIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + PyObject *swig_obj[3] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + ((mfem::VectorFEMassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24410,62 +25632,40 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; + PyObject *swig_obj[2] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + (arg1)->AssembleDiagonalPA(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24482,96 +25682,27 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorFEMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; + mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorFEMassIntegrator" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); { try { delete arg1; @@ -24598,52 +25729,64 @@ SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *ElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFEMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorFEMassIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorFEMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; + mfem::VectorDivergenceIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DGTraceIntegrator *result = 0 ; + mfem::VectorDivergenceIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,arg2,arg3); + result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24660,59 +25803,32 @@ SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - double val4 ; - int ecode4 = 0 ; - mfem::DGTraceIntegrator *result = 0 ; + mfem::VectorDivergenceIntegrator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGTraceIntegrator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,*arg2,arg3,arg4); + result = (mfem::VectorDivergenceIntegrator *)new mfem::VectorDivergenceIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24729,96 +25845,59 @@ SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGTraceIntegrator", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDivergenceIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 3) { + if (argc == 0) { + return _wrap_new_VectorDivergenceIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_DGTraceIntegrator__SWIG_0(self, argc, argv); - } - } + return _wrap_new_VectorDivergenceIntegrator__SWIG_1(self, argc, argv); } } - if (argc == 4) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_DGTraceIntegrator__SWIG_1(self, argc, argv); - } - } - } + return _wrap_new_VectorDivergenceIntegrator__SWIG_2(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGTraceIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDivergenceIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::VectorCoefficient &,double,double)\n" - " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::Coefficient &,mfem::VectorCoefficient &,double,double)\n"); + " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator()\n" + " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient *)\n" + " mfem::VectorDivergenceIntegrator::VectorDivergenceIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -24830,48 +25909,49 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObje int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24895,76 +25975,43 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObje } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24988,65 +26035,79 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObje } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorDivergenceIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorDivergenceIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorDivergenceIntegrator::AssemblePA()\n" + " mfem::VectorDivergenceIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + ((mfem::VectorDivergenceIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25070,124 +26131,146 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::VectorDivergenceIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; + if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + { + try { + result = (mfem::IntegrationRule *) &mfem::VectorDivergenceIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGTraceIntegrator_AssembleFaceMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::DGTraceIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_delete_DGTraceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); { try { delete arg1; @@ -25214,41 +26297,25 @@ SWIGINTERN PyObject *_wrap_delete_DGTraceIntegrator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *DGTraceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorDivergenceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDivergenceIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *DGTraceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorDivergenceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - double arg1 ; - double arg2 ; - double val1 ; - int ecode1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::DGDiffusionIntegrator *result = 0 ; + mfem::DivDivIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(arg1,arg2); + result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25265,48 +26332,32 @@ SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_DivDivIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DGDiffusionIntegrator *result = 0 ; + mfem::DivDivIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DivDivIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { - result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); + result = (mfem::DivDivIntegrator *)new mfem::DivDivIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25323,173 +26374,49 @@ SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - double arg2 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DGDiffusionIntegrator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGDiffusionIntegrator", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DivDivIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - { - if (PyFloat_Check(argv[0])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_DGDiffusionIntegrator__SWIG_0(self, argc, argv); - } - } + if (argc == 0) { + return _wrap_new_DivDivIntegrator__SWIG_0(self, argc, argv); } - if (argc == 3) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_DGDiffusionIntegrator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_DGDiffusionIntegrator__SWIG_2(self, argc, argv); - } - } + return _wrap_new_DivDivIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGDiffusionIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DivDivIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(double const,double const)\n" - " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::Coefficient &,double const,double const)\n" - " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::MatrixCoefficient &,double const,double const)\n"); + " mfem::DivDivIntegrator::DivDivIntegrator()\n" + " mfem::DivDivIntegrator::DivDivIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; + mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -25498,50 +26425,41 @@ SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(Py int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DivDivIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25565,76 +26483,23 @@ SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(Py } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_DivDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivDivIntegrator" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25658,65 +26523,67 @@ SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(Py } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; +SWIGINTERN PyObject *DivDivIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivDivIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DivDivIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorDiffusionIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + mfem::VectorDiffusionIntegrator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::VectorDiffusionIntegrator *)new mfem::VectorDiffusionIntegrator(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25733,134 +26600,92 @@ SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DGDiffusionIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorDiffusionIntegrator", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } + if (argc == 0) { + return _wrap_new_VectorDiffusionIntegrator__SWIG_0(self, argc, argv); } - if (argc == 6) { + if (argc == 1) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } - } + return _wrap_new_VectorDiffusionIntegrator__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGDiffusionIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorDiffusionIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::DGDiffusionIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator()\n" + " mfem::VectorDiffusionIntegrator::VectorDiffusionIntegrator(mfem::Coefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_DGDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - delete arg1; + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25884,41 +26709,66 @@ SWIGINTERN PyObject *_wrap_delete_DGDiffusionIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *DGDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DGDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - double arg1 ; - double arg2 ; - double val1 ; - int ecode1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::DGElasticityIntegrator *result = 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(arg1,arg2); + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -25935,59 +26785,39 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - double val4 ; - int ecode4 = 0 ; - mfem::DGElasticityIntegrator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGElasticityIntegrator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGElasticityIntegrator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(*arg1,*arg2,arg3,arg4); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26004,144 +26834,71 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssemblePA(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGElasticityIntegrator", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssemblePA", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { - int _v; - { - if (PyFloat_Check(argv[0])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_DGElasticityIntegrator__SWIG_0(self, argc, argv); - } - } - } - if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_DGElasticityIntegrator__SWIG_1(self, argc, argv); - } - } + return _wrap_VectorDiffusionIntegrator_AssemblePA__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGElasticityIntegrator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorDiffusionIntegrator_AssemblePA'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DGElasticityIntegrator::DGElasticityIntegrator(double,double)\n" - " mfem::DGElasticityIntegrator::DGElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &,double,double)\n"); + " mfem::VectorDiffusionIntegrator::AssemblePA()\n" + " mfem::VectorDiffusionIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleDiagonalPA(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26165,76 +26922,44 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(P } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + ((mfem::VectorDiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26258,65 +26983,23 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(P } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_VectorDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorDiffusionIntegrator" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26340,127 +27023,47 @@ SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(PyO } -SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DGElasticityIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGElasticityIntegrator_AssembleFaceMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::DGElasticityIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); - return 0; +SWIGINTERN PyObject *VectorDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorDiffusionIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } +SWIGINTERN PyObject *VectorDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} -SWIGINTERN PyObject *_wrap_delete_DGElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::Coefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::ElasticityIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - delete arg1; + result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26477,32 +27080,48 @@ SWIGINTERN PyObject *_wrap_delete_DGElasticityIntegrator(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *DGElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DGElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *result = 0 ; + mfem::Coefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::ElasticityIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_TraceJumpIntegrator", 0, 0, 0)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElasticityIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ElasticityIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::TraceJumpIntegrator *)new mfem::TraceJumpIntegrator(); + result = (mfem::ElasticityIntegrator *)new mfem::ElasticityIntegrator(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26519,20 +27138,78 @@ SWIGINTERN PyObject *_wrap_new_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ElasticityIntegrator", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ElasticityIntegrator__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_ElasticityIntegrator__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ElasticityIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &)\n" + " mfem::ElasticityIntegrator::ElasticityIntegrator(mfem::Coefficient &,double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -26541,50 +27218,41 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26608,14 +27276,15 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyOb } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -26628,56 +27297,63 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyOb int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26701,14 +27377,14 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyOb } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -26723,54 +27399,54 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObje int res6 = 0 ; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26794,65 +27470,39 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "TraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 6) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); } } } @@ -26860,30 +27510,37 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix(PyObject *self } } } - if (argc == 6) { + if (argc == 7) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); + } } } } @@ -26893,104 +27550,21 @@ SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix(PyObject *self } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TraceJumpIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeElementFlux'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::TraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" + " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TraceJumpIntegrator" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *TraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_NormalTraceJumpIntegrator", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::NormalTraceJumpIntegrator *)new mfem::NormalTraceJumpIntegrator(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FaceElementTransformations *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -27001,48 +27575,46 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_ int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + double result; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27059,21 +27631,19 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -27082,153 +27652,41 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_ int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + double result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); - { - try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::FiniteElement *arg4 = 0 ; - mfem::FaceElementTransformations *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27245,104 +27703,66 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "NormalTraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); - } - } + return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); } } } } } - if (argc == 6) { + if (argc == 5) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); - } + return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); } } } @@ -27351,29 +27771,28 @@ SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix(PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NormalTraceJumpIntegrator_AssembleFaceMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeFluxEnergy'.\n" " Possible C/C++ prototypes are:\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" - " mfem::NormalTraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" + " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalTraceJumpIntegrator" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElasticityIntegrator" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); { try { delete arg1; @@ -27400,25 +27819,52 @@ SWIGINTERN PyObject *_wrap_delete_NormalTraceJumpIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *NormalTraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElasticityIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *NormalTraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DiscreteInterpolator *result = 0 ; + mfem::VectorCoefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::DGTraceIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DiscreteInterpolator", 0, 0, 0)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::DiscreteInterpolator *)new mfem::DiscreteInterpolator(); + result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27435,30 +27881,59 @@ SWIGINTERN PyObject *_wrap_new_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DiscreteInterpolator *arg1 = (mfem::DiscreteInterpolator *) 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + double arg3 ; + double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + double val4 ; + int ecode4 = 0 ; + mfem::DGTraceIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteInterpolator" "', argument " "1"" of type '" "mfem::DiscreteInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::DiscreteInterpolator * >(argp1); - { - try { - delete arg1; + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGTraceIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGTraceIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGTraceIntegrator" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + result = (mfem::DGTraceIntegrator *)new mfem::DGTraceIntegrator(*arg1,*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27475,30 +27950,96 @@ SWIGINTERN PyObject *_wrap_delete_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *DiscreteInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_new_DGTraceIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGTraceIntegrator", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_DGTraceIntegrator__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + { + if (PyFloat_Check(argv[3])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_DGTraceIntegrator__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGTraceIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::VectorCoefficient &,double,double)\n" + " mfem::DGTraceIntegrator::DGTraceIntegrator(mfem::Coefficient &,mfem::VectorCoefficient &,double,double)\n"); + return 0; } -SWIGINTERN PyObject *DiscreteInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27510,49 +28051,48 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "GradientInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27576,14 +28116,76 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_new_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GradientInterpolator *result = 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_GradientInterpolator", 0, 0, 0)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::GradientInterpolator *)new mfem::GradientInterpolator(); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27600,124 +28202,72 @@ SWIGINTERN PyObject *_wrap_new_GradientInterpolator(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GradientInterpolator" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *GradientInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GradientInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *GradientInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "IdentityInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27741,14 +28291,137 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_new_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGTraceIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGTraceIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGTraceIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::DGTraceIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::IdentityInterpolator *result = 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "new_IdentityInterpolator", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::IdentityInterpolator *)new mfem::IdentityInterpolator(); + (arg1)->AssemblePAInteriorFaces((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27765,30 +28438,40 @@ SWIGINTERN PyObject *_wrap_new_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentityInterpolator" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - delete arg1; + (arg1)->AssemblePABoundaryFaces((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27812,77 +28495,44 @@ SWIGINTERN PyObject *_wrap_delete_IdentityInterpolator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *IdentityInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *IdentityInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "CurlInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + ((mfem::DGTraceIntegrator const *)arg1)->AddMultTransposePA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27906,14 +28556,44 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI } -SWIGINTERN PyObject *_wrap_new_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlInterpolator *result = 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "new_CurlInterpolator", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); + } + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::CurlInterpolator *)new mfem::CurlInterpolator(); + ((mfem::DGTraceIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27930,30 +28610,48 @@ SWIGINTERN PyObject *_wrap_new_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::Geometry::Type arg1 ; + int arg2 ; + mfem::FaceElementTransformations *arg3 = 0 ; + int val1 ; + int ecode1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + mfem::IntegrationRule *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlInterpolator" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DGTraceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::Geometry::Type""'"); + } + arg1 = static_cast< mfem::Geometry::Type >(val1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg3 = reinterpret_cast< mfem::FaceElementTransformations * >(argp3); { try { - delete arg1; + result = (mfem::IntegrationRule *) &mfem::DGTraceIntegrator::GetRule(arg1,arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27970,84 +28668,30 @@ SWIGINTERN PyObject *_wrap_delete_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *CurlInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *CurlInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_DGTraceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "DivergenceInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGTraceIntegrator" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28071,14 +28715,41 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec } -SWIGINTERN PyObject *_wrap_new_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGTraceIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGTraceIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DGTraceIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DivergenceInterpolator *result = 0 ; + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::DGDiffusionIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DivergenceInterpolator", 0, 0, 0)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (mfem::DivergenceInterpolator *)new mfem::DivergenceInterpolator(); + result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28095,30 +28766,48 @@ SWIGINTERN PyObject *_wrap_new_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; + mfem::Coefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::DGDiffusionIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivergenceInterpolator" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - delete arg1; + result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28135,84 +28824,48 @@ SWIGINTERN PyObject *_wrap_delete_DivergenceInterpolator(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *DivergenceInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DivergenceInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + mfem::MatrixCoefficient *arg1 = 0 ; + double arg2 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::DGDiffusionIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NormalInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGDiffusionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGDiffusionIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + result = (mfem::DGDiffusionIntegrator *)new mfem::DGDiffusionIntegrator(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28229,61 +28882,167 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NormalInterpolator *result = 0 ; +SWIGINTERN PyObject *_wrap_new_DGDiffusionIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "new_NormalInterpolator", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::NormalInterpolator *)new mfem::NormalInterpolator(); + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGDiffusionIntegrator", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + if (PyFloat_Check(argv[0])){ + _v = 1; + } else { + _v = 0; + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_DGDiffusionIntegrator__SWIG_0(self, argc, argv); + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_DGDiffusionIntegrator__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_DGDiffusionIntegrator__SWIG_2(self, argc, argv); + } + } + } + } + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGDiffusionIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(double const,double const)\n" + " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::Coefficient &,double const,double const)\n" + " mfem::DGDiffusionIntegrator::DGDiffusionIntegrator(mfem::MatrixCoefficient &,double const,double const)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_delete_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalInterpolator" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - delete arg1; + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28307,38 +29066,76 @@ SWIGINTERN PyObject *_wrap_delete_NormalInterpolator(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *NormalInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *NormalInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::ScalarProductInterpolator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::ScalarProductInterpolator *)new mfem::ScalarProductInterpolator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28355,19 +29152,19 @@ SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28379,49 +29176,48 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "ScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGDiffusionIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28445,20 +29241,124 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb } -SWIGINTERN PyObject *_wrap_delete_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGDiffusionIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DGDiffusionIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGDiffusionIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGDiffusionIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGDiffusionIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::DGDiffusionIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_DGDiffusionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + mfem::DGDiffusionIntegrator *arg1 = (mfem::DGDiffusionIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGDiffusionIntegrator" "', argument " "1"" of type '" "mfem::DGDiffusionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGDiffusionIntegrator * >(argp1); { try { delete arg1; @@ -28485,38 +29385,41 @@ SWIGINTERN PyObject *_wrap_delete_ScalarProductInterpolator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *ScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGDiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGDiffusionIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGDiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::ScalarVectorProductInterpolator *result = 0 ; + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::DGElasticityIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { try { - result = (mfem::ScalarVectorProductInterpolator *)new mfem::ScalarVectorProductInterpolator(*arg1); + result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28533,19 +29436,160 @@ SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + mfem::Coefficient *arg1 = 0 ; + mfem::Coefficient *arg2 = 0 ; + double arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + double val4 ; + int ecode4 = 0 ; + mfem::DGElasticityIntegrator *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DGElasticityIntegrator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGElasticityIntegrator" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + result = (mfem::DGElasticityIntegrator *)new mfem::DGElasticityIntegrator(*arg1,*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DGElasticityIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_DGElasticityIntegrator", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + if (PyFloat_Check(argv[0])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_DGElasticityIntegrator__SWIG_0(self, argc, argv); + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + { + if (PyFloat_Check(argv[3])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_DGElasticityIntegrator__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DGElasticityIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DGElasticityIntegrator::DGElasticityIntegrator(double,double)\n" + " mfem::DGElasticityIntegrator::DGElasticityIntegrator(mfem::Coefficient &,mfem::Coefficient &,double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28557,49 +29601,48 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "ScalarVectorProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28623,78 +29666,76 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix } -SWIGINTERN PyObject *_wrap_delete_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ScalarVectorProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ScalarVectorProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::VectorScalarProductInterpolator *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::VectorScalarProductInterpolator *)new mfem::VectorScalarProductInterpolator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28711,19 +29752,19 @@ SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28735,49 +29776,48 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGElasticityIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28801,20 +29841,124 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix } -SWIGINTERN PyObject *_wrap_delete_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGElasticityIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DGElasticityIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DGElasticityIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DGElasticityIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DGElasticityIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::DGElasticityIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_DGElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; + mfem::DGElasticityIntegrator *arg1 = (mfem::DGElasticityIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DGElasticityIntegrator" "', argument " "1"" of type '" "mfem::DGElasticityIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::DGElasticityIntegrator * >(argp1); { try { delete arg1; @@ -28841,38 +29985,25 @@ SWIGINTERN PyObject *_wrap_delete_VectorScalarProductInterpolator(PyObject *SWIG } -SWIGINTERN PyObject *VectorScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGElasticityIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DGElasticityIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *VectorScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DGElasticityIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::VectorCrossProductInterpolator *result = 0 ; + mfem::TraceJumpIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (!SWIG_Python_UnpackTuple(args, "new_TraceJumpIntegrator", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::VectorCrossProductInterpolator *)new mfem::VectorCrossProductInterpolator(*arg1); + result = (mfem::TraceJumpIntegrator *)new mfem::TraceJumpIntegrator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28889,19 +30020,19 @@ SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -28913,49 +30044,48 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "VectorCrossProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28979,78 +30109,76 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 } -SWIGINTERN PyObject *_wrap_delete_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *VectorCrossProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorCrossProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::VectorInnerProductInterpolator *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (mfem::VectorInnerProductInterpolator *)new mfem::VectorInnerProductInterpolator(*arg1); + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -29067,20 +30195,21 @@ SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::FiniteElement *arg3 = 0 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -29091,89 +30220,58 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + void *argp6 = 0 ; + int res6 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorInnerProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } - arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - delete arg1; + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -29197,74 +30295,3186 @@ SWIGINTERN PyObject *_wrap_delete_VectorInnerProductInterpolator(PyObject *SWIGU } -SWIGINTERN PyObject *VectorInnerProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *VectorInnerProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} +SWIGINTERN PyObject *_wrap_TraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "TraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__TraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_TraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'TraceJumpIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::TraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_TraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TraceJumpIntegrator *arg1 = (mfem::TraceJumpIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TraceJumpIntegrator" "', argument " "1"" of type '" "mfem::TraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::TraceJumpIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TraceJumpIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_NormalTraceJumpIntegrator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::NormalTraceJumpIntegrator *)new mfem::NormalTraceJumpIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FaceElementTransformations *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::FiniteElement *arg4 = 0 ; + mfem::FaceElementTransformations *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "4"" of type '" "mfem::FiniteElement const &""'"); + } + arg4 = reinterpret_cast< mfem::FiniteElement * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "5"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg5 = reinterpret_cast< mfem::FaceElementTransformations * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalTraceJumpIntegrator_AssembleFaceMatrix" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + try { + (arg1)->AssembleFaceMatrix((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,(mfem::FiniteElement const &)*arg4,*arg5,*arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "NormalTraceJumpIntegrator_AssembleFaceMatrix", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_0_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__FaceElementTransformations, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NormalTraceJumpIntegrator_AssembleFaceMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n" + " mfem::NormalTraceJumpIntegrator::AssembleFaceMatrix(mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FiniteElement const &,mfem::FaceElementTransformations &,mfem::DenseMatrix &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_NormalTraceJumpIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalTraceJumpIntegrator *arg1 = (mfem::NormalTraceJumpIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalTraceJumpIntegrator" "', argument " "1"" of type '" "mfem::NormalTraceJumpIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalTraceJumpIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *NormalTraceJumpIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalTraceJumpIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NormalTraceJumpIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DiscreteInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_DiscreteInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::DiscreteInterpolator *)new mfem::DiscreteInterpolator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_DiscreteInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DiscreteInterpolator *arg1 = (mfem::DiscreteInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DiscreteInterpolator" "', argument " "1"" of type '" "mfem::DiscreteInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::DiscreteInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *DiscreteInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiscreteInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DiscreteInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "GradientInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GradientInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_GradientInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::GradientInterpolator *)new mfem::GradientInterpolator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GradientInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GradientInterpolator" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GradientInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GradientInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GradientInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "IdentityInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_IdentityInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::IdentityInterpolator *)new mfem::IdentityInterpolator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_IdentityInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentityInterpolator" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IdentityInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *IdentityInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "CurlInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_CurlInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::CurlInterpolator *)new mfem::CurlInterpolator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CurlInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CurlInterpolator" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CurlInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CurlInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CurlInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "DivergenceInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DivergenceInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_DivergenceInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::DivergenceInterpolator *)new mfem::DivergenceInterpolator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_DivergenceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DivergenceInterpolator" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *DivergenceInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DivergenceInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DivergenceInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "NormalInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_NormalInterpolator", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::NormalInterpolator *)new mfem::NormalInterpolator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_NormalInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NormalInterpolator" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *NormalInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NormalInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NormalInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::ScalarProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::ScalarProductInterpolator *)new mfem::ScalarProductInterpolator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "ScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::ScalarVectorProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::ScalarVectorProductInterpolator *)new mfem::ScalarVectorProductInterpolator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "ScalarVectorProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ScalarVectorProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ScalarVectorProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::VectorScalarProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + try { + result = (mfem::VectorScalarProductInterpolator *)new mfem::VectorScalarProductInterpolator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorScalarProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorScalarProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::VectorCrossProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + try { + result = (mfem::VectorCrossProductInterpolator *)new mfem::VectorCrossProductInterpolator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorCrossProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorCrossProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorCrossProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorCrossProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorCoefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::VectorInnerProductInterpolator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + { + try { + result = (mfem::VectorInnerProductInterpolator *)new mfem::VectorInnerProductInterpolator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FiniteElement *arg3 = 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorInnerProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementMatrix2((mfem::FiniteElement const &)*arg2,(mfem::FiniteElement const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorInnerProductInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorInnerProductInterpolator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorInnerProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, + { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(BilinearFormIntegrator self)\n" + "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" + "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "BilinearFormIntegrator_AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, + { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, + { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, + { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, + { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "TransposeIntegrator_AssemblePA", _wrap_TransposeIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "TransposeIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "TransposeIntegrator_AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "TransposeIntegrator_AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "TransposeIntegrator_AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "TransposeIntegrator_AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, + { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, + { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, + { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, + { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, + { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, + { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, + { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, + { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, + { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, + { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, + { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, + { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, + { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, + { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, + { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, + { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, + { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" + "MixedScalarMassIntegrator()\n" + "new_MixedScalarMassIntegrator(Coefficient q) -> MixedScalarMassIntegrator\n" + ""}, + { "delete_MixedScalarMassIntegrator", _wrap_delete_MixedScalarMassIntegrator, METH_O, "delete_MixedScalarMassIntegrator(MixedScalarMassIntegrator self)"}, + { "MixedScalarMassIntegrator_swigregister", MixedScalarMassIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarMassIntegrator_swiginit", MixedScalarMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorProductIntegrator", _wrap_new_MixedVectorProductIntegrator, METH_O, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, + { "delete_MixedVectorProductIntegrator", _wrap_delete_MixedVectorProductIntegrator, METH_O, "delete_MixedVectorProductIntegrator(MixedVectorProductIntegrator self)"}, + { "MixedVectorProductIntegrator_swigregister", MixedVectorProductIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorProductIntegrator_swiginit", MixedVectorProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarDerivativeIntegrator", _wrap_new_MixedScalarDerivativeIntegrator, METH_VARARGS, "\n" + "MixedScalarDerivativeIntegrator()\n" + "new_MixedScalarDerivativeIntegrator(Coefficient q) -> MixedScalarDerivativeIntegrator\n" + ""}, + { "delete_MixedScalarDerivativeIntegrator", _wrap_delete_MixedScalarDerivativeIntegrator, METH_O, "delete_MixedScalarDerivativeIntegrator(MixedScalarDerivativeIntegrator self)"}, + { "MixedScalarDerivativeIntegrator_swigregister", MixedScalarDerivativeIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarDerivativeIntegrator_swiginit", MixedScalarDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakDerivativeIntegrator", _wrap_new_MixedScalarWeakDerivativeIntegrator, METH_VARARGS, "\n" + "MixedScalarWeakDerivativeIntegrator()\n" + "new_MixedScalarWeakDerivativeIntegrator(Coefficient q) -> MixedScalarWeakDerivativeIntegrator\n" + ""}, + { "delete_MixedScalarWeakDerivativeIntegrator", _wrap_delete_MixedScalarWeakDerivativeIntegrator, METH_O, "delete_MixedScalarWeakDerivativeIntegrator(MixedScalarWeakDerivativeIntegrator self)"}, + { "MixedScalarWeakDerivativeIntegrator_swigregister", MixedScalarWeakDerivativeIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakDerivativeIntegrator_swiginit", MixedScalarWeakDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarDivergenceIntegrator", _wrap_new_MixedScalarDivergenceIntegrator, METH_VARARGS, "\n" + "MixedScalarDivergenceIntegrator()\n" + "new_MixedScalarDivergenceIntegrator(Coefficient q) -> MixedScalarDivergenceIntegrator\n" + ""}, + { "delete_MixedScalarDivergenceIntegrator", _wrap_delete_MixedScalarDivergenceIntegrator, METH_O, "delete_MixedScalarDivergenceIntegrator(MixedScalarDivergenceIntegrator self)"}, + { "MixedScalarDivergenceIntegrator_swigregister", MixedScalarDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarDivergenceIntegrator_swiginit", MixedScalarDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorDivergenceIntegrator", _wrap_new_MixedVectorDivergenceIntegrator, METH_O, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, + { "delete_MixedVectorDivergenceIntegrator", _wrap_delete_MixedVectorDivergenceIntegrator, METH_O, "delete_MixedVectorDivergenceIntegrator(MixedVectorDivergenceIntegrator self)"}, + { "MixedVectorDivergenceIntegrator_swigregister", MixedVectorDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorDivergenceIntegrator_swiginit", MixedVectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakGradientIntegrator", _wrap_new_MixedScalarWeakGradientIntegrator, METH_VARARGS, "\n" + "MixedScalarWeakGradientIntegrator()\n" + "new_MixedScalarWeakGradientIntegrator(Coefficient q) -> MixedScalarWeakGradientIntegrator\n" + ""}, + { "delete_MixedScalarWeakGradientIntegrator", _wrap_delete_MixedScalarWeakGradientIntegrator, METH_O, "delete_MixedScalarWeakGradientIntegrator(MixedScalarWeakGradientIntegrator self)"}, + { "MixedScalarWeakGradientIntegrator_swigregister", MixedScalarWeakGradientIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakGradientIntegrator_swiginit", MixedScalarWeakGradientIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCurlIntegrator", _wrap_new_MixedScalarCurlIntegrator, METH_VARARGS, "\n" + "MixedScalarCurlIntegrator()\n" + "new_MixedScalarCurlIntegrator(Coefficient q) -> MixedScalarCurlIntegrator\n" + ""}, + { "delete_MixedScalarCurlIntegrator", _wrap_delete_MixedScalarCurlIntegrator, METH_O, "delete_MixedScalarCurlIntegrator(MixedScalarCurlIntegrator self)"}, + { "MixedScalarCurlIntegrator_swigregister", MixedScalarCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCurlIntegrator_swiginit", MixedScalarCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakCurlIntegrator", _wrap_new_MixedScalarWeakCurlIntegrator, METH_VARARGS, "\n" + "MixedScalarWeakCurlIntegrator()\n" + "new_MixedScalarWeakCurlIntegrator(Coefficient q) -> MixedScalarWeakCurlIntegrator\n" + ""}, + { "delete_MixedScalarWeakCurlIntegrator", _wrap_delete_MixedScalarWeakCurlIntegrator, METH_O, "delete_MixedScalarWeakCurlIntegrator(MixedScalarWeakCurlIntegrator self)"}, + { "MixedScalarWeakCurlIntegrator_swigregister", MixedScalarWeakCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakCurlIntegrator_swiginit", MixedScalarWeakCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorMassIntegrator", _wrap_new_MixedVectorMassIntegrator, METH_VARARGS, "\n" + "MixedVectorMassIntegrator()\n" + "MixedVectorMassIntegrator(Coefficient q)\n" + "MixedVectorMassIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorMassIntegrator(MatrixCoefficient mq) -> MixedVectorMassIntegrator\n" + ""}, + { "delete_MixedVectorMassIntegrator", _wrap_delete_MixedVectorMassIntegrator, METH_O, "delete_MixedVectorMassIntegrator(MixedVectorMassIntegrator self)"}, + { "MixedVectorMassIntegrator_swigregister", MixedVectorMassIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorMassIntegrator_swiginit", MixedVectorMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossProductIntegrator", _wrap_new_MixedCrossProductIntegrator, METH_O, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, + { "delete_MixedCrossProductIntegrator", _wrap_delete_MixedCrossProductIntegrator, METH_O, "delete_MixedCrossProductIntegrator(MixedCrossProductIntegrator self)"}, + { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDotProductIntegrator_FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, + { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, + { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, + { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, + { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, + { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, + { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, + { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, + { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedGradGradIntegrator", _wrap_new_MixedGradGradIntegrator, METH_VARARGS, "\n" + "MixedGradGradIntegrator()\n" + "MixedGradGradIntegrator(Coefficient q)\n" + "MixedGradGradIntegrator(VectorCoefficient dq)\n" + "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" + ""}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradGradIntegrator_FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, + { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, + { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, + { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCurlCurlIntegrator", _wrap_new_MixedCurlCurlIntegrator, METH_VARARGS, "\n" + "MixedCurlCurlIntegrator()\n" + "MixedCurlCurlIntegrator(Coefficient q)\n" + "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" + "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" + ""}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, + { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, + { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, + { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, + { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, + { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, + { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, + { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, + { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, + { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, + { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, + { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, + { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, + { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, + { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, + { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, + { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, + { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradDivIntegrator_FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, + { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, + { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, + { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDivGradIntegrator_FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, + { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, + { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, + { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, + { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorGradientIntegrator", _wrap_new_MixedVectorGradientIntegrator, METH_VARARGS, "\n" + "MixedVectorGradientIntegrator()\n" + "MixedVectorGradientIntegrator(Coefficient q)\n" + "MixedVectorGradientIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorGradientIntegrator(MatrixCoefficient mq) -> MixedVectorGradientIntegrator\n" + ""}, + { "delete_MixedVectorGradientIntegrator", _wrap_delete_MixedVectorGradientIntegrator, METH_O, "delete_MixedVectorGradientIntegrator(MixedVectorGradientIntegrator self)"}, + { "MixedVectorGradientIntegrator_swigregister", MixedVectorGradientIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorGradientIntegrator_swiginit", MixedVectorGradientIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorCurlIntegrator", _wrap_new_MixedVectorCurlIntegrator, METH_VARARGS, "\n" + "MixedVectorCurlIntegrator()\n" + "MixedVectorCurlIntegrator(Coefficient q)\n" + "MixedVectorCurlIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorCurlIntegrator(MatrixCoefficient mq) -> MixedVectorCurlIntegrator\n" + ""}, + { "delete_MixedVectorCurlIntegrator", _wrap_delete_MixedVectorCurlIntegrator, METH_O, "delete_MixedVectorCurlIntegrator(MixedVectorCurlIntegrator self)"}, + { "MixedVectorCurlIntegrator_swigregister", MixedVectorCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorCurlIntegrator_swiginit", MixedVectorCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorWeakCurlIntegrator", _wrap_new_MixedVectorWeakCurlIntegrator, METH_VARARGS, "\n" + "MixedVectorWeakCurlIntegrator()\n" + "MixedVectorWeakCurlIntegrator(Coefficient q)\n" + "MixedVectorWeakCurlIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorWeakCurlIntegrator(MatrixCoefficient mq) -> MixedVectorWeakCurlIntegrator\n" + ""}, + { "delete_MixedVectorWeakCurlIntegrator", _wrap_delete_MixedVectorWeakCurlIntegrator, METH_O, "delete_MixedVectorWeakCurlIntegrator(MixedVectorWeakCurlIntegrator self)"}, + { "MixedVectorWeakCurlIntegrator_swigregister", MixedVectorWeakCurlIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorWeakCurlIntegrator_swiginit", MixedVectorWeakCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MixedVectorWeakDivergenceIntegrator", _wrap_new_MixedVectorWeakDivergenceIntegrator, METH_VARARGS, "\n" + "MixedVectorWeakDivergenceIntegrator()\n" + "MixedVectorWeakDivergenceIntegrator(Coefficient q)\n" + "MixedVectorWeakDivergenceIntegrator(VectorCoefficient dq)\n" + "new_MixedVectorWeakDivergenceIntegrator(MatrixCoefficient mq) -> MixedVectorWeakDivergenceIntegrator\n" + ""}, + { "delete_MixedVectorWeakDivergenceIntegrator", _wrap_delete_MixedVectorWeakDivergenceIntegrator, METH_O, "delete_MixedVectorWeakDivergenceIntegrator(MixedVectorWeakDivergenceIntegrator self)"}, + { "MixedVectorWeakDivergenceIntegrator_swigregister", MixedVectorWeakDivergenceIntegrator_swigregister, METH_O, NULL}, + { "MixedVectorWeakDivergenceIntegrator_swiginit", MixedVectorWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_GradientIntegrator", _wrap_new_GradientIntegrator, METH_VARARGS, "\n" + "GradientIntegrator()\n" + "GradientIntegrator(Coefficient _q)\n" + "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" + ""}, + { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "GradientIntegrator_AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "GradientIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "GradientIntegrator_AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "GradientIntegrator_AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, + { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, + { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DiffusionIntegrator", _wrap_new_DiffusionIntegrator, METH_VARARGS, "\n" + "DiffusionIntegrator()\n" + "DiffusionIntegrator(Coefficient q)\n" + "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" + ""}, + { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, + { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "DiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "DiffusionIntegrator_AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "DiffusionIntegrator_SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, + { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" + "MassIntegrator(IntegrationRule ir=None)\n" + "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" + ""}, + { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, + { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "MassIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "MassIntegrator_AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "MassIntegrator_SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, + { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, + { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, + { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, + { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, + { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "ConvectionIntegrator_AssemblePA(FiniteElementSpace arg1)\n" + ""}, + { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "ConvectionIntegrator_AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" + "ConvectionIntegrator_GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" + "ConvectionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" + ""}, + { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, + { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, + { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, + { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, + { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorMassIntegrator", _wrap_new_VectorMassIntegrator, METH_VARARGS, "\n" + "VectorMassIntegrator()\n" + "VectorMassIntegrator(Coefficient q, int qo=0)\n" + "VectorMassIntegrator(Coefficient q, IntegrationRule ir)\n" + "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" + "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" + ""}, + { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "VectorMassIntegrator_GetVDim(VectorMassIntegrator self) -> int"}, + { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorMassIntegrator_AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "VectorMassIntegrator_AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, + { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, + { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, + { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEDivergenceIntegrator", _wrap_new_VectorFEDivergenceIntegrator, METH_VARARGS, "\n" + "VectorFEDivergenceIntegrator()\n" + "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" + ""}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, + { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, + { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEWeakDivergenceIntegrator", _wrap_new_VectorFEWeakDivergenceIntegrator, METH_VARARGS, "\n" + "VectorFEWeakDivergenceIntegrator()\n" + "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" + ""}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, + { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, + { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFECurlIntegrator", _wrap_new_VectorFECurlIntegrator, METH_VARARGS, "\n" + "VectorFECurlIntegrator()\n" + "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" + ""}, + { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, + { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, + { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, + { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, + { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, + { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_CurlCurlIntegrator", _wrap_new_CurlCurlIntegrator, METH_VARARGS, "\n" + "CurlCurlIntegrator()\n" + "CurlCurlIntegrator(Coefficient q)\n" + "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" + ""}, + { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "CurlCurlIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "CurlCurlIntegrator_AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "CurlCurlIntegrator_AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, + { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, + { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, + { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorCurlCurlIntegrator", _wrap_new_VectorCurlCurlIntegrator, METH_VARARGS, "\n" + "VectorCurlCurlIntegrator()\n" + "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" + ""}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, + { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, + { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEMassIntegrator", _wrap_new_VectorFEMassIntegrator, METH_VARARGS, "\n" + "VectorFEMassIntegrator()\n" + "VectorFEMassIntegrator(Coefficient _q)\n" + "VectorFEMassIntegrator(Coefficient q)\n" + "VectorFEMassIntegrator(VectorCoefficient _vq)\n" + "VectorFEMassIntegrator(VectorCoefficient vq)\n" + "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" + "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" + ""}, + { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorFEMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "VectorFEMassIntegrator_AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorFEMassIntegrator_AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, + { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, + { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, + { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorDivergenceIntegrator", _wrap_new_VectorDivergenceIntegrator, METH_VARARGS, "\n" + "VectorDivergenceIntegrator()\n" + "VectorDivergenceIntegrator(Coefficient _q)\n" + "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" + ""}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorDivergenceIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, + { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, + { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DivDivIntegrator", _wrap_new_DivDivIntegrator, METH_VARARGS, "\n" + "DivDivIntegrator()\n" + "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" + ""}, + { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, + { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, + { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorDiffusionIntegrator", _wrap_new_VectorDiffusionIntegrator, METH_VARARGS, "\n" + "VectorDiffusionIntegrator()\n" + "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" + ""}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "VectorDiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorDiffusionIntegrator_AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "VectorDiffusionIntegrator_AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, + { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, + { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, + { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_ElasticityIntegrator", _wrap_new_ElasticityIntegrator, METH_VARARGS, "\n" + "ElasticityIntegrator(Coefficient l, Coefficient m)\n" + "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" + ""}, + { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, + { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, + { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGTraceIntegrator", _wrap_new_DGTraceIntegrator, METH_VARARGS, "\n" + "DGTraceIntegrator(VectorCoefficient _u, double a, double b)\n" + "new_DGTraceIntegrator(Coefficient _rho, VectorCoefficient _u, double a, double b) -> DGTraceIntegrator\n" + ""}, + { "DGTraceIntegrator_AssembleFaceMatrix", _wrap_DGTraceIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "DGTraceIntegrator_AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "DGTraceIntegrator_AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, + { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, + { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, + { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGDiffusionIntegrator", _wrap_new_DGDiffusionIntegrator, METH_VARARGS, "\n" + "DGDiffusionIntegrator(double const s, double const k)\n" + "DGDiffusionIntegrator(Coefficient q, double const s, double const k)\n" + "new_DGDiffusionIntegrator(MatrixCoefficient q, double const s, double const k) -> DGDiffusionIntegrator\n" + ""}, + { "DGDiffusionIntegrator_AssembleFaceMatrix", _wrap_DGDiffusionIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_DGDiffusionIntegrator", _wrap_delete_DGDiffusionIntegrator, METH_O, "delete_DGDiffusionIntegrator(DGDiffusionIntegrator self)"}, + { "DGDiffusionIntegrator_swigregister", DGDiffusionIntegrator_swigregister, METH_O, NULL}, + { "DGDiffusionIntegrator_swiginit", DGDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGElasticityIntegrator", _wrap_new_DGElasticityIntegrator, METH_VARARGS, "\n" + "DGElasticityIntegrator(double alpha_, double kappa_)\n" + "new_DGElasticityIntegrator(Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityIntegrator\n" + ""}, + { "DGElasticityIntegrator_AssembleFaceMatrix", _wrap_DGElasticityIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_DGElasticityIntegrator", _wrap_delete_DGElasticityIntegrator, METH_O, "delete_DGElasticityIntegrator(DGElasticityIntegrator self)"}, + { "DGElasticityIntegrator_swigregister", DGElasticityIntegrator_swigregister, METH_O, NULL}, + { "DGElasticityIntegrator_swiginit", DGElasticityIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_TraceJumpIntegrator", _wrap_new_TraceJumpIntegrator, METH_NOARGS, "new_TraceJumpIntegrator() -> TraceJumpIntegrator"}, + { "TraceJumpIntegrator_AssembleFaceMatrix", _wrap_TraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_TraceJumpIntegrator", _wrap_delete_TraceJumpIntegrator, METH_O, "delete_TraceJumpIntegrator(TraceJumpIntegrator self)"}, + { "TraceJumpIntegrator_swigregister", TraceJumpIntegrator_swigregister, METH_O, NULL}, + { "TraceJumpIntegrator_swiginit", TraceJumpIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_NormalTraceJumpIntegrator", _wrap_new_NormalTraceJumpIntegrator, METH_NOARGS, "new_NormalTraceJumpIntegrator() -> NormalTraceJumpIntegrator"}, + { "NormalTraceJumpIntegrator_AssembleFaceMatrix", _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" + "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "delete_NormalTraceJumpIntegrator", _wrap_delete_NormalTraceJumpIntegrator, METH_O, "delete_NormalTraceJumpIntegrator(NormalTraceJumpIntegrator self)"}, + { "NormalTraceJumpIntegrator_swigregister", NormalTraceJumpIntegrator_swigregister, METH_O, NULL}, + { "NormalTraceJumpIntegrator_swiginit", NormalTraceJumpIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DiscreteInterpolator", _wrap_new_DiscreteInterpolator, METH_NOARGS, "new_DiscreteInterpolator() -> DiscreteInterpolator"}, + { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, + { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, + { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, + { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, + { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, + { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, + { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, + { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, + { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, + { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, + { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, + { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, + { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, + { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, + { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, + { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, + { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, + { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, + { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, + { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, + { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, + { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, + { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, + { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, + { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, + { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, + { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, + { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, + { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, + { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, + { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, + { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, + { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, + { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, + { NULL, NULL, 0, NULL } +}; -static PyMethodDef SwigMethods[] = { +static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, - { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(BilinearFormIntegrator self)\n" + "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" + "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)"}, - { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + ""}, + { "TransposeIntegrator_AssemblePA", _wrap_TransposeIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" ""}, + { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, - { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, - { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, - { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, - { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, - { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, - { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" @@ -29338,22 +33548,22 @@ static PyMethodDef SwigMethods[] = { { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, - { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDotProductIntegrator_FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, - { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, - { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, + { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, - { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, - { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29363,19 +33573,19 @@ static PyMethodDef SwigMethods[] = { "MixedGradGradIntegrator(VectorCoefficient dq)\n" "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" ""}, - { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradGradIntegrator_FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, - { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, - { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, - { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, - { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29385,120 +33595,120 @@ static PyMethodDef SwigMethods[] = { "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" ""}, - { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, - { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, - { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, - { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, - { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, - { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, - { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, - { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, - { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, - { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, - { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, + { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, - { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, - { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, - { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, - { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, - { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, - { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, - { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, - { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, - { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, - { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, - { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradDivIntegrator_FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, - { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, + { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, - { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDivGradIntegrator_FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, - { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, + { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, - { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, - { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, - { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29538,50 +33748,85 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedVectorWeakDivergenceIntegrator", _wrap_delete_MixedVectorWeakDivergenceIntegrator, METH_O, "delete_MixedVectorWeakDivergenceIntegrator(MixedVectorWeakDivergenceIntegrator self)"}, { "MixedVectorWeakDivergenceIntegrator_swigregister", MixedVectorWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedVectorWeakDivergenceIntegrator_swiginit", MixedVectorWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_GradientIntegrator", _wrap_new_GradientIntegrator, METH_VARARGS, "\n" + "GradientIntegrator()\n" + "GradientIntegrator(Coefficient _q)\n" + "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" + ""}, + { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, + { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, + { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, { "new_DiffusionIntegrator", _wrap_new_DiffusionIntegrator, METH_VARARGS, "\n" "DiffusionIntegrator()\n" "DiffusionIntegrator(Coefficient q)\n" "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" ""}, - { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)"}, - { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, - { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "DiffusionIntegrator_AssemblePA(DiffusionIntegrator self, FiniteElementSpace arg2)"}, - { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, - { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, + { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" "MassIntegrator(IntegrationRule ir=None)\n" "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" ""}, - { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "MassIntegrator_AssemblePA(MassIntegrator self, FiniteElementSpace arg2)"}, - { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, - { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, + { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace arg1)\n" + ""}, + { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" + "GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" + "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" + ""}, { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29592,10 +33837,16 @@ static PyMethodDef SwigMethods[] = { "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" ""}, - { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "VectorMassIntegrator_GetVDim(VectorMassIntegrator self) -> int"}, - { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, - { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "GetVDim(VectorMassIntegrator self) -> int"}, + { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29603,8 +33854,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEDivergenceIntegrator()\n" "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" ""}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29612,8 +33863,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEWeakDivergenceIntegrator()\n" "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" ""}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29621,14 +33872,14 @@ static PyMethodDef SwigMethods[] = { "VectorFECurlIntegrator()\n" "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" ""}, - { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, - { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29637,9 +33888,15 @@ static PyMethodDef SwigMethods[] = { "CurlCurlIntegrator(Coefficient q)\n" "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" ""}, - { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef)"}, - { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29647,8 +33904,8 @@ static PyMethodDef SwigMethods[] = { "VectorCurlCurlIntegrator()\n" "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" ""}, - { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29661,8 +33918,14 @@ static PyMethodDef SwigMethods[] = { "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" ""}, - { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29671,7 +33934,14 @@ static PyMethodDef SwigMethods[] = { "VectorDivergenceIntegrator(Coefficient _q)\n" "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" ""}, - { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29679,7 +33949,7 @@ static PyMethodDef SwigMethods[] = { "DivDivIntegrator()\n" "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" ""}, - { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29687,8 +33957,14 @@ static PyMethodDef SwigMethods[] = { "VectorDiffusionIntegrator()\n" "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" ""}, - { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA()\n" + "AssemblePA(FiniteElementSpace fes)\n" + ""}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29696,9 +33972,9 @@ static PyMethodDef SwigMethods[] = { "ElasticityIntegrator(Coefficient l, Coefficient m)\n" "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" ""}, - { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, - { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, int with_coef=1)"}, - { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29707,10 +33983,15 @@ static PyMethodDef SwigMethods[] = { "new_DGTraceIntegrator(Coefficient _rho, VectorCoefficient _u, double a, double b) -> DGTraceIntegrator\n" ""}, { "DGTraceIntegrator_AssembleFaceMatrix", _wrap_DGTraceIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29720,9 +34001,9 @@ static PyMethodDef SwigMethods[] = { "new_DGDiffusionIntegrator(MatrixCoefficient q, double const s, double const k) -> DGDiffusionIntegrator\n" ""}, { "DGDiffusionIntegrator_AssembleFaceMatrix", _wrap_DGDiffusionIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGDiffusionIntegrator_AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGDiffusionIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_DGDiffusionIntegrator", _wrap_delete_DGDiffusionIntegrator, METH_O, "delete_DGDiffusionIntegrator(DGDiffusionIntegrator self)"}, { "DGDiffusionIntegrator_swigregister", DGDiffusionIntegrator_swigregister, METH_O, NULL}, @@ -29732,27 +34013,27 @@ static PyMethodDef SwigMethods[] = { "new_DGElasticityIntegrator(Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityIntegrator\n" ""}, { "DGElasticityIntegrator_AssembleFaceMatrix", _wrap_DGElasticityIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "DGElasticityIntegrator_AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(DGElasticityIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_DGElasticityIntegrator", _wrap_delete_DGElasticityIntegrator, METH_O, "delete_DGElasticityIntegrator(DGElasticityIntegrator self)"}, { "DGElasticityIntegrator_swigregister", DGElasticityIntegrator_swigregister, METH_O, NULL}, { "DGElasticityIntegrator_swiginit", DGElasticityIntegrator_swiginit, METH_VARARGS, NULL}, { "new_TraceJumpIntegrator", _wrap_new_TraceJumpIntegrator, METH_NOARGS, "new_TraceJumpIntegrator() -> TraceJumpIntegrator"}, { "TraceJumpIntegrator_AssembleFaceMatrix", _wrap_TraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "TraceJumpIntegrator_AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(TraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_TraceJumpIntegrator", _wrap_delete_TraceJumpIntegrator, METH_O, "delete_TraceJumpIntegrator(TraceJumpIntegrator self)"}, { "TraceJumpIntegrator_swigregister", TraceJumpIntegrator_swigregister, METH_O, NULL}, { "TraceJumpIntegrator_swiginit", TraceJumpIntegrator_swiginit, METH_VARARGS, NULL}, { "new_NormalTraceJumpIntegrator", _wrap_new_NormalTraceJumpIntegrator, METH_NOARGS, "new_NormalTraceJumpIntegrator() -> NormalTraceJumpIntegrator"}, { "NormalTraceJumpIntegrator_AssembleFaceMatrix", _wrap_NormalTraceJumpIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" - "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" - "NormalTraceJumpIntegrator_AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" + "AssembleFaceMatrix(NormalTraceJumpIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, { "delete_NormalTraceJumpIntegrator", _wrap_delete_NormalTraceJumpIntegrator, METH_O, "delete_NormalTraceJumpIntegrator(NormalTraceJumpIntegrator self)"}, { "NormalTraceJumpIntegrator_swigregister", NormalTraceJumpIntegrator_swigregister, METH_O, NULL}, @@ -29761,63 +34042,59 @@ static PyMethodDef SwigMethods[] = { { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, - { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, - { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, - { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, - { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, - { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, - { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, - { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, - { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, - { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, - { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; -static PyMethodDef SwigMethods_proxydocs[] = { - { NULL, NULL, 0, NULL } -}; - /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ @@ -30133,6 +34410,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -30262,9 +34542,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -30289,6 +34566,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -30325,12 +34605,6 @@ static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__DiscreteInterpola static void *_p_mfem__VectorInnerProductInterpolatorTo_p_mfem__DiscreteInterpolator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::DiscreteInterpolator *) ((mfem::VectorInnerProductInterpolator *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -30364,6 +34638,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -30379,6 +34656,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -30547,6 +34827,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -30590,10 +34876,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -30617,6 +34903,7 @@ static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NURBSFiniteElement *) ((mfem::NURBS3DFiniteElement *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -30672,13 +34959,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -30690,6 +34975,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -30731,6 +35018,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -30755,6 +35044,7 @@ static swig_type_info _swigt__p_mfem__NURBS1DFiniteElement = {"_p_mfem__NURBS1DF static swig_type_info _swigt__p_mfem__NURBS2DFiniteElement = {"_p_mfem__NURBS2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS3DFiniteElement = {"_p_mfem__NURBS3DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", "mfem::GradientIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", "mfem::GradientInterpolator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GroupConvectionIntegrator = {"_p_mfem__GroupConvectionIntegrator", "mfem::GroupConvectionIntegrator *", 0, 0, (void*)0, 0}; @@ -30860,6 +35150,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, @@ -30908,6 +35199,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__GaussLinear2DFiniteElement, &_swigt__p_mfem__GaussQuad2DFiniteElement, &_swigt__p_mfem__GradientGridFunctionCoefficient, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GridFunctionCoefficient, @@ -30918,6 +35210,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -31095,6 +35388,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorRotProductCoefficient, &_swigt__p_mfem__VectorScalarProductInterpolator, &_swigt__p_mfem__VectorSumCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -31103,11 +35397,12 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = { {&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyCoefficientBase[] = {{&_swigt__p_mfem__PyCoefficientBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DeterminantCoefficient[] = {{&_swigt__p_mfem__DeterminantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; @@ -31157,13 +35452,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -31175,6 +35468,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -31216,6 +35511,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -31239,8 +35536,9 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = { {&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = { {&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GroupConvectionIntegrator[] = { {&_swigt__p_mfem__GroupConvectionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -31346,6 +35644,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, @@ -31394,6 +35693,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__GaussLinear2DFiniteElement, _swigc__p_mfem__GaussQuad2DFiniteElement, _swigc__p_mfem__GradientGridFunctionCoefficient, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GridFunctionCoefficient, @@ -31404,6 +35704,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -31581,6 +35882,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorRotProductCoefficient, _swigc__p_mfem__VectorScalarProductInterpolator, _swigc__p_mfem__VectorSumCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_ser/bilininteg_wrap.h b/mfem/_ser/bilininteg_wrap.h index 1ab9d76a..3361ff37 100644 --- a/mfem/_ser/bilininteg_wrap.h +++ b/mfem/_ser/bilininteg_wrap.h @@ -20,6 +20,10 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, public: SwigDirector_BilinearFormIntegrator(PyObject *self, mfem::IntegrationRule const *ir = NULL); virtual void AssemblePA(mfem::FiniteElementSpace const &fes); + virtual void AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes); + virtual void AssemblePAInteriorFaces(mfem::FiniteElementSpace const &fes); + virtual void AssemblePABoundaryFaces(mfem::FiniteElementSpace const &fes); + virtual void AssembleDiagonalPA(mfem::Vector &diag); virtual void AddMultPA(mfem::Vector const &x, mfem::Vector &y) const; virtual void AddMultTransposePA(mfem::Vector const &x, mfem::Vector &y) const; virtual void AssembleElementMatrix(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::DenseMatrix &elmat); @@ -29,7 +33,7 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, virtual void AssembleElementVector(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun, mfem::Vector &elvect); virtual void AssembleElementGrad(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); virtual void AssembleFaceGrad(mfem::FiniteElement const &el1, mfem::FiniteElement const &el2, mfem::FaceElementTransformations &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); - virtual void ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, int with_coef = 1); + virtual void ComputeElementFlux(mfem::FiniteElement const &el, mfem::ElementTransformation &Trans, mfem::Vector &u, mfem::FiniteElement const &fluxelem, mfem::Vector &flux, bool with_coef = true); virtual double ComputeFluxEnergy(mfem::FiniteElement const &fluxelem, mfem::ElementTransformation &Trans, mfem::Vector &flux, mfem::Vector *d_energy = NULL); virtual ~SwigDirector_BilinearFormIntegrator(); @@ -62,7 +66,7 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, return method; } private: - mutable swig::SwigVar_PyObject vtable[14]; + mutable swig::SwigVar_PyObject vtable[18]; #endif }; diff --git a/mfem/_ser/blockmatrix.py b/mfem/_ser/blockmatrix.py index 0f80ca12..29cd0397 100644 --- a/mfem/_ser/blockmatrix.py +++ b/mfem/_ser/blockmatrix.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _blockmatrix.SWIG_PyInstanceMethod_New +_swig_new_static_method = _blockmatrix.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -110,10 +113,12 @@ def SetBlock(self, i, j, mat): def NumRowBlocks(self): r"""NumRowBlocks(BlockMatrix self) -> int""" return _blockmatrix.BlockMatrix_NumRowBlocks(self) + NumRowBlocks = _swig_new_instance_method(_blockmatrix.BlockMatrix_NumRowBlocks) def NumColBlocks(self): r"""NumColBlocks(BlockMatrix self) -> int""" return _blockmatrix.BlockMatrix_NumColBlocks(self) + NumColBlocks = _swig_new_instance_method(_blockmatrix.BlockMatrix_NumColBlocks) def GetBlock(self, *args): r""" @@ -121,10 +126,12 @@ def GetBlock(self, *args): GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix """ return _blockmatrix.BlockMatrix_GetBlock(self, *args) + GetBlock = _swig_new_instance_method(_blockmatrix.BlockMatrix_GetBlock) def IsZeroBlock(self, i, j): r"""IsZeroBlock(BlockMatrix self, int i, int j) -> int""" return _blockmatrix.BlockMatrix_IsZeroBlock(self, i, j) + IsZeroBlock = _swig_new_instance_method(_blockmatrix.BlockMatrix_IsZeroBlock) def RowOffsets(self, *args): r""" @@ -132,6 +139,7 @@ def RowOffsets(self, *args): RowOffsets(BlockMatrix self) -> intArray """ return _blockmatrix.BlockMatrix_RowOffsets(self, *args) + RowOffsets = _swig_new_instance_method(_blockmatrix.BlockMatrix_RowOffsets) def ColOffsets(self, *args): r""" @@ -139,10 +147,12 @@ def ColOffsets(self, *args): ColOffsets(BlockMatrix self) -> intArray """ return _blockmatrix.BlockMatrix_ColOffsets(self, *args) + ColOffsets = _swig_new_instance_method(_blockmatrix.BlockMatrix_ColOffsets) def RowSize(self, i): r"""RowSize(BlockMatrix self, int const i) -> int""" return _blockmatrix.BlockMatrix_RowSize(self, i) + RowSize = _swig_new_instance_method(_blockmatrix.BlockMatrix_RowSize) def EliminateRowCol(self, *args): r""" @@ -150,6 +160,7 @@ def EliminateRowCol(self, *args): EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs) """ return _blockmatrix.BlockMatrix_EliminateRowCol(self, *args) + EliminateRowCol = _swig_new_instance_method(_blockmatrix.BlockMatrix_EliminateRowCol) def Finalize(self, *args): r""" @@ -157,10 +168,12 @@ def Finalize(self, *args): Finalize(BlockMatrix self, int skip_zeros, bool fix_empty_rows) """ return _blockmatrix.BlockMatrix_Finalize(self, *args) + Finalize = _swig_new_instance_method(_blockmatrix.BlockMatrix_Finalize) def CreateMonolithic(self): r"""CreateMonolithic(BlockMatrix self) -> SparseMatrix""" return _blockmatrix.BlockMatrix_CreateMonolithic(self) + CreateMonolithic = _swig_new_instance_method(_blockmatrix.BlockMatrix_CreateMonolithic) def Elem(self, *args): r""" @@ -168,38 +181,47 @@ def Elem(self, *args): Elem(BlockMatrix self, int i, int j) -> double const & """ return _blockmatrix.BlockMatrix_Elem(self, *args) + Elem = _swig_new_instance_method(_blockmatrix.BlockMatrix_Elem) def Inverse(self): r"""Inverse(BlockMatrix self) -> MatrixInverse""" return _blockmatrix.BlockMatrix_Inverse(self) + Inverse = _swig_new_instance_method(_blockmatrix.BlockMatrix_Inverse) def NumNonZeroElems(self): r"""NumNonZeroElems(BlockMatrix self) -> int""" return _blockmatrix.BlockMatrix_NumNonZeroElems(self) + NumNonZeroElems = _swig_new_instance_method(_blockmatrix.BlockMatrix_NumNonZeroElems) def GetRow(self, row, cols, srow): r"""GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int""" return _blockmatrix.BlockMatrix_GetRow(self, row, cols, srow) + GetRow = _swig_new_instance_method(_blockmatrix.BlockMatrix_GetRow) def EliminateZeroRows(self, threshold=1e-12): r"""EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)""" return _blockmatrix.BlockMatrix_EliminateZeroRows(self, threshold) + EliminateZeroRows = _swig_new_instance_method(_blockmatrix.BlockMatrix_EliminateZeroRows) def Mult(self, x, y): r"""Mult(BlockMatrix self, Vector x, Vector y)""" return _blockmatrix.BlockMatrix_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockmatrix.BlockMatrix_Mult) def AddMult(self, x, y, val=1.): r"""AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)""" return _blockmatrix.BlockMatrix_AddMult(self, x, y, val) + AddMult = _swig_new_instance_method(_blockmatrix.BlockMatrix_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(BlockMatrix self, Vector x, Vector y)""" return _blockmatrix.BlockMatrix_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockmatrix.BlockMatrix_MultTranspose) def AddMultTranspose(self, x, y, val=1.): r"""AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)""" return _blockmatrix.BlockMatrix_AddMultTranspose(self, x, y, val) + AddMultTranspose = _swig_new_instance_method(_blockmatrix.BlockMatrix_AddMultTranspose) __swig_destroy__ = _blockmatrix.delete_BlockMatrix owns_blocks = property(_blockmatrix.BlockMatrix_owns_blocks_get, _blockmatrix.BlockMatrix_owns_blocks_set, doc=r"""owns_blocks : int""") @@ -209,6 +231,7 @@ def PrintMatlab(self, *args): PrintMatlab(BlockMatrix self, char const * file, int precision=8) """ return _blockmatrix.BlockMatrix_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_blockmatrix.BlockMatrix_PrintMatlab) # Register BlockMatrix in _blockmatrix: _blockmatrix.BlockMatrix_swigregister(BlockMatrix) diff --git a/mfem/_ser/blockmatrix_wrap.cxx b/mfem/_ser/blockmatrix_wrap.cxx index 3dbe7159..7007fb39 100644 --- a/mfem/_ser/blockmatrix_wrap.cxx +++ b/mfem/_ser/blockmatrix_wrap.cxx @@ -3082,14 +3082,17 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[14] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[15] #define SWIGTYPE_p_mfem__RAPOperator swig_types[16] -#define SWIGTYPE_p_mfem__Solver swig_types[17] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[18] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[19] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[20] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[21] -#define SWIGTYPE_p_mfem__Vector swig_types[22] -static swig_type_info *swig_types[24]; -static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[17] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[18] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[19] +#define SWIGTYPE_p_mfem__Solver swig_types[20] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[21] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[22] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[23] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[24] +#define SWIGTYPE_p_mfem__Vector swig_types[25] +static swig_type_info *swig_types[27]; +static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -6167,6 +6170,7 @@ SWIGINTERN PyObject *BlockMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_BlockMatrix", _wrap_new_BlockMatrix, METH_VARARGS, "\n" "BlockMatrix(intArray offsets)\n" "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" @@ -6222,6 +6226,59 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_BlockMatrix", _wrap_new_BlockMatrix, METH_VARARGS, "\n" + "BlockMatrix(intArray offsets)\n" + "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" + ""}, + { "BlockMatrix_SetBlock", _wrap_BlockMatrix_SetBlock, METH_VARARGS, "SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, + { "BlockMatrix_NumRowBlocks", _wrap_BlockMatrix_NumRowBlocks, METH_O, "NumRowBlocks(BlockMatrix self) -> int"}, + { "BlockMatrix_NumColBlocks", _wrap_BlockMatrix_NumColBlocks, METH_O, "NumColBlocks(BlockMatrix self) -> int"}, + { "BlockMatrix_GetBlock", _wrap_BlockMatrix_GetBlock, METH_VARARGS, "\n" + "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" + "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" + ""}, + { "BlockMatrix_IsZeroBlock", _wrap_BlockMatrix_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, + { "BlockMatrix_RowOffsets", _wrap_BlockMatrix_RowOffsets, METH_VARARGS, "\n" + "RowOffsets(BlockMatrix self) -> intArray\n" + "RowOffsets(BlockMatrix self) -> intArray\n" + ""}, + { "BlockMatrix_ColOffsets", _wrap_BlockMatrix_ColOffsets, METH_VARARGS, "\n" + "ColOffsets(BlockMatrix self) -> intArray\n" + "ColOffsets(BlockMatrix self) -> intArray\n" + ""}, + { "BlockMatrix_RowSize", _wrap_BlockMatrix_RowSize, METH_VARARGS, "RowSize(BlockMatrix self, int const i) -> int"}, + { "BlockMatrix_EliminateRowCol", _wrap_BlockMatrix_EliminateRowCol, METH_VARARGS, "\n" + "EliminateRowCol(BlockMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs)\n" + ""}, + { "BlockMatrix_Finalize", _wrap_BlockMatrix_Finalize, METH_VARARGS, "\n" + "Finalize(BlockMatrix self, int skip_zeros=1)\n" + "Finalize(BlockMatrix self, int skip_zeros, bool fix_empty_rows)\n" + ""}, + { "BlockMatrix_CreateMonolithic", _wrap_BlockMatrix_CreateMonolithic, METH_O, "CreateMonolithic(BlockMatrix self) -> SparseMatrix"}, + { "BlockMatrix_Elem", _wrap_BlockMatrix_Elem, METH_VARARGS, "\n" + "Elem(BlockMatrix self, int i, int j) -> double\n" + "Elem(BlockMatrix self, int i, int j) -> double const &\n" + ""}, + { "BlockMatrix_Inverse", _wrap_BlockMatrix_Inverse, METH_O, "Inverse(BlockMatrix self) -> MatrixInverse"}, + { "BlockMatrix_NumNonZeroElems", _wrap_BlockMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(BlockMatrix self) -> int"}, + { "BlockMatrix_GetRow", _wrap_BlockMatrix_GetRow, METH_VARARGS, "GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "BlockMatrix_EliminateZeroRows", _wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, + { "BlockMatrix_Mult", _wrap_BlockMatrix_Mult, METH_VARARGS, "Mult(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMult", _wrap_BlockMatrix_AddMult, METH_VARARGS, "AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_MultTranspose", _wrap_BlockMatrix_MultTranspose, METH_VARARGS, "MultTranspose(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMultTranspose", _wrap_BlockMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "delete_BlockMatrix", _wrap_delete_BlockMatrix, METH_O, "delete_BlockMatrix(BlockMatrix self)"}, + { "BlockMatrix_owns_blocks_set", _wrap_BlockMatrix_owns_blocks_set, METH_VARARGS, "BlockMatrix_owns_blocks_set(BlockMatrix self, int owns_blocks)"}, + { "BlockMatrix_owns_blocks_get", _wrap_BlockMatrix_owns_blocks_get, METH_O, "BlockMatrix_owns_blocks_get(BlockMatrix self) -> int"}, + { "BlockMatrix_PrintMatlab", _wrap_BlockMatrix_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(BlockMatrix self, std::ostream & os=mfem::out)\n" + "PrintMatlab(BlockMatrix self, char const * file, int precision=8)\n" + ""}, + { "BlockMatrix_swigregister", BlockMatrix_swigregister, METH_O, NULL}, + { "BlockMatrix_swiginit", BlockMatrix_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6264,12 +6321,12 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } @@ -6279,6 +6336,9 @@ static void *_p_mfem__BlockMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPAR static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -6294,9 +6354,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -6314,12 +6380,15 @@ static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Op static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -6342,6 +6411,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -6363,14 +6435,17 @@ static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__Mat static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockMatrix, _p_mfem__BlockMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockMatrix, _p_mfem__BlockMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -6392,6 +6467,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_ser/blockoperator.py b/mfem/_ser/blockoperator.py index aec0ff63..360a1714 100644 --- a/mfem/_ser/blockoperator.py +++ b/mfem/_ser/blockoperator.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _blockoperator.SWIG_PyInstanceMethod_New +_swig_new_static_method = _blockoperator.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -71,10 +74,12 @@ class _SwigNonDynamicMeta(type): def Opr2BlockOpr(op): r"""Opr2BlockOpr(Operator op) -> BlockOperator""" return _blockoperator.Opr2BlockOpr(op) +Opr2BlockOpr = _blockoperator.Opr2BlockOpr def Opr2SparseMat(op): r"""Opr2SparseMat(Operator op) -> mfem::SparseMatrix *""" return _blockoperator.Opr2SparseMat(op) +Opr2SparseMat = _blockoperator.Opr2SparseMat class BlockOperator(mfem._ser.operators.Operator): r"""Proxy of C++ mfem::BlockOperator class.""" @@ -127,42 +132,52 @@ def SetBlock(self, iRow, iCol, op, c=1.0): def NumRowBlocks(self): r"""NumRowBlocks(BlockOperator self) -> int""" return _blockoperator.BlockOperator_NumRowBlocks(self) + NumRowBlocks = _swig_new_instance_method(_blockoperator.BlockOperator_NumRowBlocks) def NumColBlocks(self): r"""NumColBlocks(BlockOperator self) -> int""" return _blockoperator.BlockOperator_NumColBlocks(self) + NumColBlocks = _swig_new_instance_method(_blockoperator.BlockOperator_NumColBlocks) def IsZeroBlock(self, i, j): r"""IsZeroBlock(BlockOperator self, int i, int j) -> int""" return _blockoperator.BlockOperator_IsZeroBlock(self, i, j) + IsZeroBlock = _swig_new_instance_method(_blockoperator.BlockOperator_IsZeroBlock) def GetBlock(self, i, j): r"""GetBlock(BlockOperator self, int i, int j) -> Operator""" return _blockoperator.BlockOperator_GetBlock(self, i, j) + GetBlock = _swig_new_instance_method(_blockoperator.BlockOperator_GetBlock) def GetBlockCoef(self, i, j): r"""GetBlockCoef(BlockOperator self, int i, int j) -> double""" return _blockoperator.BlockOperator_GetBlockCoef(self, i, j) + GetBlockCoef = _swig_new_instance_method(_blockoperator.BlockOperator_GetBlockCoef) def SetBlockCoef(self, i, j, c): r"""SetBlockCoef(BlockOperator self, int i, int j, double c)""" return _blockoperator.BlockOperator_SetBlockCoef(self, i, j, c) + SetBlockCoef = _swig_new_instance_method(_blockoperator.BlockOperator_SetBlockCoef) def RowOffsets(self): r"""RowOffsets(BlockOperator self) -> intArray""" return _blockoperator.BlockOperator_RowOffsets(self) + RowOffsets = _swig_new_instance_method(_blockoperator.BlockOperator_RowOffsets) def ColOffsets(self): r"""ColOffsets(BlockOperator self) -> intArray""" return _blockoperator.BlockOperator_ColOffsets(self) + ColOffsets = _swig_new_instance_method(_blockoperator.BlockOperator_ColOffsets) def Mult(self, x, y): r"""Mult(BlockOperator self, Vector x, Vector y)""" return _blockoperator.BlockOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockoperator.BlockOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(BlockOperator self, Vector x, Vector y)""" return _blockoperator.BlockOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockoperator.BlockOperator_MultTranspose) __swig_destroy__ = _blockoperator.delete_BlockOperator owns_blocks = property(_blockoperator.BlockOperator_owns_blocks_get, _blockoperator.BlockOperator_owns_blocks_set, doc=r"""owns_blocks : int""") @@ -199,26 +214,32 @@ def SetDiagonalBlock(self, iblock, op): def SetOperator(self, op): r"""SetOperator(BlockDiagonalPreconditioner self, Operator op)""" return _blockoperator.BlockDiagonalPreconditioner_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_SetOperator) def NumBlocks(self): r"""NumBlocks(BlockDiagonalPreconditioner self) -> int""" return _blockoperator.BlockDiagonalPreconditioner_NumBlocks(self) + NumBlocks = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_NumBlocks) def GetDiagonalBlock(self, iblock): r"""GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator""" return _blockoperator.BlockDiagonalPreconditioner_GetDiagonalBlock(self, iblock) + GetDiagonalBlock = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_GetDiagonalBlock) def Offsets(self): r"""Offsets(BlockDiagonalPreconditioner self) -> intArray""" return _blockoperator.BlockDiagonalPreconditioner_Offsets(self) + Offsets = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_Offsets) def Mult(self, x, y): r"""Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockDiagonalPreconditioner_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_Mult) def MultTranspose(self, x, y): r"""MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockDiagonalPreconditioner_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockoperator.BlockDiagonalPreconditioner_MultTranspose) __swig_destroy__ = _blockoperator.delete_BlockDiagonalPreconditioner owns_blocks = property(_blockoperator.BlockDiagonalPreconditioner_owns_blocks_get, _blockoperator.BlockDiagonalPreconditioner_owns_blocks_set, doc=r"""owns_blocks : int""") @@ -273,26 +294,32 @@ def SetBlock(self, iRow, iCol, op): def SetOperator(self, op): r"""SetOperator(BlockLowerTriangularPreconditioner self, Operator op)""" return _blockoperator.BlockLowerTriangularPreconditioner_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_SetOperator) def NumBlocks(self): r"""NumBlocks(BlockLowerTriangularPreconditioner self) -> int""" return _blockoperator.BlockLowerTriangularPreconditioner_NumBlocks(self) + NumBlocks = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_NumBlocks) def GetBlock(self, iblock, jblock): r"""GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator""" return _blockoperator.BlockLowerTriangularPreconditioner_GetBlock(self, iblock, jblock) + GetBlock = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_GetBlock) def Offsets(self): r"""Offsets(BlockLowerTriangularPreconditioner self) -> intArray""" return _blockoperator.BlockLowerTriangularPreconditioner_Offsets(self) + Offsets = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_Offsets) def Mult(self, x, y): r"""Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockLowerTriangularPreconditioner_Mult(self, x, y) + Mult = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_Mult) def MultTranspose(self, x, y): r"""MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)""" return _blockoperator.BlockLowerTriangularPreconditioner_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_blockoperator.BlockLowerTriangularPreconditioner_MultTranspose) __swig_destroy__ = _blockoperator.delete_BlockLowerTriangularPreconditioner owns_blocks = property(_blockoperator.BlockLowerTriangularPreconditioner_owns_blocks_get, _blockoperator.BlockLowerTriangularPreconditioner_owns_blocks_set, doc=r"""owns_blocks : int""") diff --git a/mfem/_ser/blockoperator_wrap.cxx b/mfem/_ser/blockoperator_wrap.cxx index bb7f4755..09ac105f 100644 --- a/mfem/_ser/blockoperator_wrap.cxx +++ b/mfem/_ser/blockoperator_wrap.cxx @@ -3078,14 +3078,17 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[10] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[11] #define SWIGTYPE_p_mfem__RAPOperator swig_types[12] -#define SWIGTYPE_p_mfem__Solver swig_types[13] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[14] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[15] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[16] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[17] -#define SWIGTYPE_p_mfem__Vector swig_types[18] -static swig_type_info *swig_types[20]; -static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[13] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[14] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[15] +#define SWIGTYPE_p_mfem__Solver swig_types[16] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[17] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[18] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[19] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[20] +#define SWIGTYPE_p_mfem__Vector swig_types[21] +static swig_type_info *swig_types[23]; +static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5574,6 +5577,7 @@ SWIGINTERN PyObject *BlockLowerTriangularPreconditioner_swiginit(PyObject *SWIGU static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, { "new_BlockOperator", _wrap_new_BlockOperator, METH_VARARGS, "\n" @@ -5628,6 +5632,58 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, + { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, + { "new_BlockOperator", _wrap_new_BlockOperator, METH_VARARGS, "\n" + "BlockOperator(intArray offsets)\n" + "new_BlockOperator(intArray row_offsets, intArray col_offsets) -> BlockOperator\n" + ""}, + { "BlockOperator_SetDiagonalBlock", _wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, + { "BlockOperator_SetBlock", _wrap_BlockOperator_SetBlock, METH_VARARGS, "SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, + { "BlockOperator_NumRowBlocks", _wrap_BlockOperator_NumRowBlocks, METH_O, "NumRowBlocks(BlockOperator self) -> int"}, + { "BlockOperator_NumColBlocks", _wrap_BlockOperator_NumColBlocks, METH_O, "NumColBlocks(BlockOperator self) -> int"}, + { "BlockOperator_IsZeroBlock", _wrap_BlockOperator_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockOperator self, int i, int j) -> int"}, + { "BlockOperator_GetBlock", _wrap_BlockOperator_GetBlock, METH_VARARGS, "GetBlock(BlockOperator self, int i, int j) -> Operator"}, + { "BlockOperator_GetBlockCoef", _wrap_BlockOperator_GetBlockCoef, METH_VARARGS, "GetBlockCoef(BlockOperator self, int i, int j) -> double"}, + { "BlockOperator_SetBlockCoef", _wrap_BlockOperator_SetBlockCoef, METH_VARARGS, "SetBlockCoef(BlockOperator self, int i, int j, double c)"}, + { "BlockOperator_RowOffsets", _wrap_BlockOperator_RowOffsets, METH_O, "RowOffsets(BlockOperator self) -> intArray"}, + { "BlockOperator_ColOffsets", _wrap_BlockOperator_ColOffsets, METH_O, "ColOffsets(BlockOperator self) -> intArray"}, + { "BlockOperator_Mult", _wrap_BlockOperator_Mult, METH_VARARGS, "Mult(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_MultTranspose", _wrap_BlockOperator_MultTranspose, METH_VARARGS, "MultTranspose(BlockOperator self, Vector x, Vector y)"}, + { "delete_BlockOperator", _wrap_delete_BlockOperator, METH_O, "delete_BlockOperator(BlockOperator self)"}, + { "BlockOperator_owns_blocks_set", _wrap_BlockOperator_owns_blocks_set, METH_VARARGS, "BlockOperator_owns_blocks_set(BlockOperator self, int owns_blocks)"}, + { "BlockOperator_owns_blocks_get", _wrap_BlockOperator_owns_blocks_get, METH_O, "BlockOperator_owns_blocks_get(BlockOperator self) -> int"}, + { "BlockOperator_swigregister", BlockOperator_swigregister, METH_O, NULL}, + { "BlockOperator_swiginit", BlockOperator_swiginit, METH_VARARGS, NULL}, + { "new_BlockDiagonalPreconditioner", _wrap_new_BlockDiagonalPreconditioner, METH_O, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, + { "BlockDiagonalPreconditioner_SetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, + { "BlockDiagonalPreconditioner_SetOperator", _wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, + { "BlockDiagonalPreconditioner_NumBlocks", _wrap_BlockDiagonalPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockDiagonalPreconditioner self) -> int"}, + { "BlockDiagonalPreconditioner_GetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS, "GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, + { "BlockDiagonalPreconditioner_Offsets", _wrap_BlockDiagonalPreconditioner_Offsets, METH_O, "Offsets(BlockDiagonalPreconditioner self) -> intArray"}, + { "BlockDiagonalPreconditioner_Mult", _wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS, "Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_MultTranspose", _wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "delete_BlockDiagonalPreconditioner", _wrap_delete_BlockDiagonalPreconditioner, METH_O, "delete_BlockDiagonalPreconditioner(BlockDiagonalPreconditioner self)"}, + { "BlockDiagonalPreconditioner_owns_blocks_set", _wrap_BlockDiagonalPreconditioner_owns_blocks_set, METH_VARARGS, "BlockDiagonalPreconditioner_owns_blocks_set(BlockDiagonalPreconditioner self, int owns_blocks)"}, + { "BlockDiagonalPreconditioner_owns_blocks_get", _wrap_BlockDiagonalPreconditioner_owns_blocks_get, METH_O, "BlockDiagonalPreconditioner_owns_blocks_get(BlockDiagonalPreconditioner self) -> int"}, + { "BlockDiagonalPreconditioner_swigregister", BlockDiagonalPreconditioner_swigregister, METH_O, NULL}, + { "BlockDiagonalPreconditioner_swiginit", BlockDiagonalPreconditioner_swiginit, METH_VARARGS, NULL}, + { "new_BlockLowerTriangularPreconditioner", _wrap_new_BlockLowerTriangularPreconditioner, METH_O, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, + { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", _wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetBlock", _wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS, "SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetOperator", _wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, + { "BlockLowerTriangularPreconditioner_NumBlocks", _wrap_BlockLowerTriangularPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockLowerTriangularPreconditioner self) -> int"}, + { "BlockLowerTriangularPreconditioner_GetBlock", _wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS, "GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, + { "BlockLowerTriangularPreconditioner_Offsets", _wrap_BlockLowerTriangularPreconditioner_Offsets, METH_O, "Offsets(BlockLowerTriangularPreconditioner self) -> intArray"}, + { "BlockLowerTriangularPreconditioner_Mult", _wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS, "Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_MultTranspose", _wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "delete_BlockLowerTriangularPreconditioner", _wrap_delete_BlockLowerTriangularPreconditioner, METH_O, "delete_BlockLowerTriangularPreconditioner(BlockLowerTriangularPreconditioner self)"}, + { "BlockLowerTriangularPreconditioner_owns_blocks_set", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_set, METH_VARARGS, "BlockLowerTriangularPreconditioner_owns_blocks_set(BlockLowerTriangularPreconditioner self, int owns_blocks)"}, + { "BlockLowerTriangularPreconditioner_owns_blocks_get", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_get, METH_O, "BlockLowerTriangularPreconditioner_owns_blocks_get(BlockLowerTriangularPreconditioner self) -> int"}, + { "BlockLowerTriangularPreconditioner_swigregister", BlockLowerTriangularPreconditioner_swigregister, METH_O, NULL}, + { "BlockLowerTriangularPreconditioner_swiginit", BlockLowerTriangularPreconditioner_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5640,6 +5696,12 @@ static void *_p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Solver(void *x, int static void *_p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) ((mfem::BlockLowerTriangularPreconditioner *) x)); } +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } @@ -5649,35 +5711,38 @@ static void *_p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator(void *x, in static void *_p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::BlockLowerTriangularPreconditioner *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__BlockOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::BlockOperator *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); } static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__BlockOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::BlockOperator *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; @@ -5686,15 +5751,18 @@ static swig_type_info _swigt__p_mfem__BlockDiagonalPreconditioner = {"_p_mfem__B static swig_type_info _swigt__p_mfem__BlockLowerTriangularPreconditioner = {"_p_mfem__BlockLowerTriangularPreconditioner", "mfem::BlockLowerTriangularPreconditioner *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BlockOperator = {"_p_mfem__BlockOperator", "mfem::BlockOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -5713,6 +5781,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -5727,16 +5798,19 @@ static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__Arra static swig_cast_info _swigc__p_mfem__BlockDiagonalPreconditioner[] = { {&_swigt__p_mfem__BlockDiagonalPreconditioner, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockLowerTriangularPreconditioner[] = { {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockOperator[] = { {&_swigt__p_mfem__BlockOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockOperator, _p_mfem__BlockOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockOperator, _p_mfem__BlockOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__BlockDiagonalPreconditioner, _p_mfem__BlockDiagonalPreconditionerTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__BlockLowerTriangularPreconditioner, _p_mfem__BlockLowerTriangularPreconditionerTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -5755,6 +5829,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_ser/blockvector.py b/mfem/_ser/blockvector.py index 931c83b4..b7caf85c 100644 --- a/mfem/_ser/blockvector.py +++ b/mfem/_ser/blockvector.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _blockvector.SWIG_PyInstanceMethod_New +_swig_new_static_method = _blockvector.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,14 +90,17 @@ def GetBlock(self, *args): GetBlock(BlockVector self, int i) -> Vector """ return _blockvector.BlockVector_GetBlock(self, *args) + GetBlock = _swig_new_instance_method(_blockvector.BlockVector_GetBlock) def GetBlockView(self, i, blockView): r"""GetBlockView(BlockVector self, int i, Vector blockView)""" return _blockvector.BlockVector_GetBlockView(self, i, blockView) + GetBlockView = _swig_new_instance_method(_blockvector.BlockVector_GetBlockView) def BlockSize(self, i): r"""BlockSize(BlockVector self, int i) -> int""" return _blockvector.BlockVector_BlockSize(self, i) + BlockSize = _swig_new_instance_method(_blockvector.BlockVector_BlockSize) def Update(self, *args): r""" @@ -103,6 +109,7 @@ def Update(self, *args): Update(BlockVector self, intArray bOffsets, mfem::MemoryType mt) """ return _blockvector.BlockVector_Update(self, *args) + Update = _swig_new_instance_method(_blockvector.BlockVector_Update) # Register BlockVector in _blockvector: _blockvector.BlockVector_swigregister(BlockVector) diff --git a/mfem/_ser/blockvector_wrap.cxx b/mfem/_ser/blockvector_wrap.cxx index 4738d95a..042aeb1b 100644 --- a/mfem/_ser/blockvector_wrap.cxx +++ b/mfem/_ser/blockvector_wrap.cxx @@ -3715,6 +3715,7 @@ SWIGINTERN PyObject *BlockVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_BlockVector", _wrap_new_BlockVector, METH_VARARGS, "\n" "BlockVector()\n" "BlockVector(intArray bOffsets)\n" @@ -3740,6 +3741,29 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_BlockVector", _wrap_new_BlockVector, METH_VARARGS, "\n" + "BlockVector()\n" + "BlockVector(intArray bOffsets)\n" + "BlockVector(intArray bOffsets, mfem::MemoryType mt)\n" + "BlockVector(BlockVector block)\n" + "new_BlockVector(double * data, intArray bOffsets) -> BlockVector\n" + ""}, + { "delete_BlockVector", _wrap_delete_BlockVector, METH_O, "delete_BlockVector(BlockVector self)"}, + { "BlockVector_GetBlock", _wrap_BlockVector_GetBlock, METH_VARARGS, "\n" + "GetBlock(BlockVector self, int i) -> Vector\n" + "GetBlock(BlockVector self, int i) -> Vector\n" + ""}, + { "BlockVector_GetBlockView", _wrap_BlockVector_GetBlockView, METH_VARARGS, "GetBlockView(BlockVector self, int i, Vector blockView)"}, + { "BlockVector_BlockSize", _wrap_BlockVector_BlockSize, METH_VARARGS, "BlockSize(BlockVector self, int i) -> int"}, + { "BlockVector_Update", _wrap_BlockVector_Update, METH_VARARGS, "\n" + "Update(BlockVector self, double * data, intArray bOffsets)\n" + "Update(BlockVector self, intArray bOffsets)\n" + "Update(BlockVector self, intArray bOffsets, mfem::MemoryType mt)\n" + ""}, + { "BlockVector_swigregister", BlockVector_swigregister, METH_O, NULL}, + { "BlockVector_swiginit", BlockVector_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/coefficient.i b/mfem/_ser/coefficient.i index 1212d780..dc451505 100644 --- a/mfem/_ser/coefficient.i +++ b/mfem/_ser/coefficient.i @@ -310,7 +310,7 @@ class MatrixPyCoefficient(MatrixPyCoefficientBase): K.Assign(k) def EvalValue(self, x): - return np.array([[0,0,0], [0,0,0] [0,0,0]]) + return np.array([[0,0,0], [0,0,0], [0,0,0]]) class MatrixPyCoefficientT(MatrixPyCoefficientBase): def __init__(self, dim): @@ -321,7 +321,7 @@ class MatrixPyCoefficientT(MatrixPyCoefficientBase): K.Assign(k) def EvalValue(self, x, t): - return np.array([[0,0,0], [0,0,0] [0,0,0]]) + return np.array([[0,0,0], [0,0,0], [0,0,0]]) %} diff --git a/mfem/_ser/coefficient.py b/mfem/_ser/coefficient.py index c0b6df52..ed6e32a9 100644 --- a/mfem/_ser/coefficient.py +++ b/mfem/_ser/coefficient.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _coefficient.SWIG_PyInstanceMethod_New +_swig_new_static_method = _coefficient.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -86,10 +89,12 @@ def __init__(self, *args, **kwargs): def SetTime(self, t): r"""SetTime(Coefficient self, double t)""" return _coefficient.Coefficient_SetTime(self, t) + SetTime = _swig_new_instance_method(_coefficient.Coefficient_SetTime) def GetTime(self): r"""GetTime(Coefficient self) -> double""" return _coefficient.Coefficient_GetTime(self) + GetTime = _swig_new_instance_method(_coefficient.Coefficient_GetTime) def Eval(self, *args): r""" @@ -97,6 +102,7 @@ def Eval(self, *args): Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip, double t) -> double """ return _coefficient.Coefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.Coefficient_Eval) __swig_destroy__ = _coefficient.delete_Coefficient # Register Coefficient in _coefficient: @@ -116,6 +122,7 @@ def __init__(self, c=1.0): def Eval(self, T, ip): r"""Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.ConstantCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.ConstantCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ConstantCoefficient # Register ConstantCoefficient in _coefficient: @@ -137,18 +144,22 @@ def __init__(self, *args): def UpdateConstants(self, c): r"""UpdateConstants(PWConstCoefficient self, Vector c)""" return _coefficient.PWConstCoefficient_UpdateConstants(self, c) + UpdateConstants = _swig_new_instance_method(_coefficient.PWConstCoefficient_UpdateConstants) def __call__(self, i): r"""__call__(PWConstCoefficient self, int i) -> double &""" return _coefficient.PWConstCoefficient___call__(self, i) + __call__ = _swig_new_instance_method(_coefficient.PWConstCoefficient___call__) def GetNConst(self): r"""GetNConst(PWConstCoefficient self) -> int""" return _coefficient.PWConstCoefficient_GetNConst(self) + GetNConst = _swig_new_instance_method(_coefficient.PWConstCoefficient_GetNConst) def Eval(self, T, ip): r"""Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.PWConstCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.PWConstCoefficient_Eval) __swig_destroy__ = _coefficient.delete_PWConstCoefficient # Register PWConstCoefficient in _coefficient: @@ -172,6 +183,7 @@ def __init__(self, *args): def Eval(self, T, ip): r"""Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.FunctionCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.FunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_FunctionCoefficient # Register FunctionCoefficient in _coefficient: @@ -193,14 +205,17 @@ def __init__(self, *args): def SetGridFunction(self, gf): r"""SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.GridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.GridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_GetGridFunction) def Eval(self, T, ip): r"""Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.GridFunctionCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.GridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_GridFunctionCoefficient # Register GridFunctionCoefficient in _coefficient: @@ -222,6 +237,7 @@ def __init__(self, *args): def Eval(self, T, ip): r"""Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.TransformedCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.TransformedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_TransformedCoefficient # Register TransformedCoefficient in _coefficient: @@ -245,18 +261,22 @@ def __init__(self, *args): def SetDeltaCenter(self, center): r"""SetDeltaCenter(DeltaCoefficient self, Vector center)""" return _coefficient.DeltaCoefficient_SetDeltaCenter(self, center) + SetDeltaCenter = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetDeltaCenter) def SetScale(self, _s): r"""SetScale(DeltaCoefficient self, double _s)""" return _coefficient.DeltaCoefficient_SetScale(self, _s) + SetScale = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetScale) def SetFunction(self, f): r"""SetFunction(DeltaCoefficient self, double (*)(double) f)""" return _coefficient.DeltaCoefficient_SetFunction(self, f) + SetFunction = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetFunction) def SetTol(self, _tol): r"""SetTol(DeltaCoefficient self, double _tol)""" return _coefficient.DeltaCoefficient_SetTol(self, _tol) + SetTol = _swig_new_instance_method(_coefficient.DeltaCoefficient_SetTol) def SetWeight(self, w): r"""SetWeight(DeltaCoefficient self, Coefficient w)""" @@ -270,30 +290,37 @@ def SetWeight(self, w): def Center(self): r"""Center(DeltaCoefficient self) -> double const *""" return _coefficient.DeltaCoefficient_Center(self) + Center = _swig_new_instance_method(_coefficient.DeltaCoefficient_Center) def Scale(self): r"""Scale(DeltaCoefficient self) -> double""" return _coefficient.DeltaCoefficient_Scale(self) + Scale = _swig_new_instance_method(_coefficient.DeltaCoefficient_Scale) def Tol(self): r"""Tol(DeltaCoefficient self) -> double""" return _coefficient.DeltaCoefficient_Tol(self) + Tol = _swig_new_instance_method(_coefficient.DeltaCoefficient_Tol) def Weight(self): r"""Weight(DeltaCoefficient self) -> Coefficient""" return _coefficient.DeltaCoefficient_Weight(self) + Weight = _swig_new_instance_method(_coefficient.DeltaCoefficient_Weight) def GetDeltaCenter(self, center): r"""GetDeltaCenter(DeltaCoefficient self, Vector center)""" return _coefficient.DeltaCoefficient_GetDeltaCenter(self, center) + GetDeltaCenter = _swig_new_instance_method(_coefficient.DeltaCoefficient_GetDeltaCenter) def EvalDelta(self, T, ip): r"""EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DeltaCoefficient_EvalDelta(self, T, ip) + EvalDelta = _swig_new_instance_method(_coefficient.DeltaCoefficient_EvalDelta) def Eval(self, T, ip): r"""Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DeltaCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.DeltaCoefficient_Eval) __swig_destroy__ = _coefficient.delete_DeltaCoefficient # Register DeltaCoefficient in _coefficient: @@ -317,6 +344,7 @@ def __init__(self, _c, attr): def Eval(self, T, ip): r"""Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.RestrictedCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.RestrictedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_RestrictedCoefficient # Register RestrictedCoefficient in _coefficient: @@ -334,14 +362,17 @@ def __init__(self, *args, **kwargs): def SetTime(self, t): r"""SetTime(VectorCoefficient self, double t)""" return _coefficient.VectorCoefficient_SetTime(self, t) + SetTime = _swig_new_instance_method(_coefficient.VectorCoefficient_SetTime) def GetTime(self): r"""GetTime(VectorCoefficient self) -> double""" return _coefficient.VectorCoefficient_GetTime(self) + GetTime = _swig_new_instance_method(_coefficient.VectorCoefficient_GetTime) def GetVDim(self): r"""GetVDim(VectorCoefficient self) -> int""" return _coefficient.VectorCoefficient_GetVDim(self) + GetVDim = _swig_new_instance_method(_coefficient.VectorCoefficient_GetVDim) def Eval(self, *args): r""" @@ -349,6 +380,7 @@ def Eval(self, *args): Eval(VectorCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorCoefficient # Register VectorCoefficient in _coefficient: @@ -386,6 +418,12 @@ def Eval(self, *args): Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorConstantCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorConstantCoefficient_Eval) + + def GetVec(self): + r"""GetVec(VectorConstantCoefficient self) -> Vector""" + return _coefficient.VectorConstantCoefficient_GetVec(self) + GetVec = _swig_new_instance_method(_coefficient.VectorConstantCoefficient_GetVec) __swig_destroy__ = _coefficient.delete_VectorConstantCoefficient # Register VectorConstantCoefficient in _coefficient: @@ -411,6 +449,7 @@ def Eval(self, *args): Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorFunctionCoefficient # Register VectorFunctionCoefficient in _coefficient: @@ -429,10 +468,12 @@ def __init__(self, dim): def GetCoeff(self, i): r"""GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient""" return _coefficient.VectorArrayCoefficient_GetCoeff(self, i) + GetCoeff = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_GetCoeff) def GetCoeffs(self): r"""GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **""" return _coefficient.VectorArrayCoefficient_GetCoeffs(self) + GetCoeffs = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_GetCoeffs) def Set(self, i, c, own=True): r"""Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)""" @@ -451,6 +492,7 @@ def Eval(self, *args): Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorArrayCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorArrayCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorArrayCoefficient # Register VectorArrayCoefficient in _coefficient: @@ -472,10 +514,12 @@ def __init__(self, *args): def SetGridFunction(self, gf): r"""SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.VectorGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.VectorGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_GetGridFunction) def Eval(self, *args): r""" @@ -483,6 +527,7 @@ def Eval(self, *args): Eval(VectorGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorGridFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorGridFunctionCoefficient # Register VectorGridFunctionCoefficient in _coefficient: @@ -501,10 +546,12 @@ def __init__(self, gf): def SetGridFunction(self, gf): r"""SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.GradientGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.GradientGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_GetGridFunction) def Eval(self, *args): r""" @@ -512,6 +559,7 @@ def Eval(self, *args): Eval(GradientGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.GradientGridFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.GradientGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_GradientGridFunctionCoefficient # Register GradientGridFunctionCoefficient in _coefficient: @@ -529,10 +577,12 @@ def __init__(self, *args, **kwargs): def SetGridFunction(self, gf): r"""SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.CurlGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.CurlGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_GetGridFunction) def Eval(self, *args): r""" @@ -541,6 +591,7 @@ def Eval(self, *args): Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.CurlGridFunctionCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.CurlGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_CurlGridFunctionCoefficient # Register CurlGridFunctionCoefficient in _coefficient: @@ -559,14 +610,17 @@ def __init__(self, gf): def SetGridFunction(self, gf): r"""SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)""" return _coefficient.DivergenceGridFunctionCoefficient_SetGridFunction(self, gf) + SetGridFunction = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_SetGridFunction) def GetGridFunction(self): r"""GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *""" return _coefficient.DivergenceGridFunctionCoefficient_GetGridFunction(self) + GetGridFunction = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_GetGridFunction) def Eval(self, T, ip): r"""Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DivergenceGridFunctionCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.DivergenceGridFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_DivergenceGridFunctionCoefficient # Register DivergenceGridFunctionCoefficient in _coefficient: @@ -591,30 +645,37 @@ def __init__(self, *args): def SetDeltaCoefficient(self, _d): r"""SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)""" return _coefficient.VectorDeltaCoefficient_SetDeltaCoefficient(self, _d) + SetDeltaCoefficient = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDeltaCoefficient) def GetDeltaCoefficient(self): r"""GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient""" return _coefficient.VectorDeltaCoefficient_GetDeltaCoefficient(self) + GetDeltaCoefficient = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_GetDeltaCoefficient) def SetScale(self, s): r"""SetScale(VectorDeltaCoefficient self, double s)""" return _coefficient.VectorDeltaCoefficient_SetScale(self, s) + SetScale = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetScale) def SetDirection(self, _d): r"""SetDirection(VectorDeltaCoefficient self, Vector _d)""" return _coefficient.VectorDeltaCoefficient_SetDirection(self, _d) + SetDirection = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDirection) def SetDeltaCenter(self, center): r"""SetDeltaCenter(VectorDeltaCoefficient self, Vector center)""" return _coefficient.VectorDeltaCoefficient_SetDeltaCenter(self, center) + SetDeltaCenter = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_SetDeltaCenter) def GetDeltaCenter(self, center): r"""GetDeltaCenter(VectorDeltaCoefficient self, Vector center)""" return _coefficient.VectorDeltaCoefficient_GetDeltaCenter(self, center) + GetDeltaCenter = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_GetDeltaCenter) def EvalDelta(self, V, T, ip): r"""EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.VectorDeltaCoefficient_EvalDelta(self, V, T, ip) + EvalDelta = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_EvalDelta) def Eval(self, *args): r""" @@ -623,6 +684,7 @@ def Eval(self, *args): Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorDeltaCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorDeltaCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorDeltaCoefficient # Register VectorDeltaCoefficient in _coefficient: @@ -649,6 +711,7 @@ def Eval(self, *args): Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorRestrictedCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorRestrictedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorRestrictedCoefficient # Register VectorRestrictedCoefficient in _coefficient: @@ -666,26 +729,32 @@ def __init__(self, *args, **kwargs): def SetTime(self, t): r"""SetTime(MatrixCoefficient self, double t)""" return _coefficient.MatrixCoefficient_SetTime(self, t) + SetTime = _swig_new_instance_method(_coefficient.MatrixCoefficient_SetTime) def GetTime(self): r"""GetTime(MatrixCoefficient self) -> double""" return _coefficient.MatrixCoefficient_GetTime(self) + GetTime = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetTime) def GetHeight(self): r"""GetHeight(MatrixCoefficient self) -> int""" return _coefficient.MatrixCoefficient_GetHeight(self) + GetHeight = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetHeight) def GetWidth(self): r"""GetWidth(MatrixCoefficient self) -> int""" return _coefficient.MatrixCoefficient_GetWidth(self) + GetWidth = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetWidth) def GetVDim(self): r"""GetVDim(MatrixCoefficient self) -> int""" return _coefficient.MatrixCoefficient_GetVDim(self) + GetVDim = _swig_new_instance_method(_coefficient.MatrixCoefficient_GetVDim) def Eval(self, K, T, ip): r"""Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixCoefficient_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixCoefficient # Register MatrixCoefficient in _coefficient: @@ -723,6 +792,7 @@ def Eval(self, *args): Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.MatrixConstantCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.MatrixConstantCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixConstantCoefficient # Register MatrixConstantCoefficient in _coefficient: @@ -745,6 +815,7 @@ def __init__(self, *args): def Eval(self, K, T, ip): r"""Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixFunctionCoefficient_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixFunctionCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixFunctionCoefficient # Register MatrixFunctionCoefficient in _coefficient: @@ -763,6 +834,7 @@ def __init__(self, dim): def GetCoeff(self, i, j): r"""GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient""" return _coefficient.MatrixArrayCoefficient_GetCoeff(self, i, j) + GetCoeff = _swig_new_instance_method(_coefficient.MatrixArrayCoefficient_GetCoeff) def Set(self, i, j, c, own=True): r"""Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)""" @@ -779,6 +851,7 @@ def Eval(self, *args): Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.MatrixArrayCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.MatrixArrayCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixArrayCoefficient # Register MatrixArrayCoefficient in _coefficient: @@ -802,6 +875,7 @@ def __init__(self, mc, attr): def Eval(self, K, T, ip): r"""Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixRestrictedCoefficient_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixRestrictedCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixRestrictedCoefficient # Register MatrixRestrictedCoefficient in _coefficient: @@ -820,6 +894,7 @@ def __init__(self, A, B, _alpha=1.0, _beta=1.0): def Eval(self, T, ip): r"""Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.SumCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.SumCoefficient_Eval) __swig_destroy__ = _coefficient.delete_SumCoefficient # Register SumCoefficient in _coefficient: @@ -838,6 +913,7 @@ def __init__(self, A, B): def Eval(self, T, ip): r"""Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.ProductCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.ProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ProductCoefficient # Register ProductCoefficient in _coefficient: @@ -856,6 +932,7 @@ def __init__(self, A, _p): def Eval(self, T, ip): r"""Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.PowerCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.PowerCoefficient_Eval) __swig_destroy__ = _coefficient.delete_PowerCoefficient # Register PowerCoefficient in _coefficient: @@ -874,6 +951,7 @@ def __init__(self, A, B): def Eval(self, T, ip): r"""Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.InnerProductCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.InnerProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_InnerProductCoefficient # Register InnerProductCoefficient in _coefficient: @@ -892,6 +970,7 @@ def __init__(self, A, B): def Eval(self, T, ip): r"""Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.VectorRotProductCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.VectorRotProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorRotProductCoefficient # Register VectorRotProductCoefficient in _coefficient: @@ -910,6 +989,7 @@ def __init__(self, A): def Eval(self, T, ip): r"""Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.DeterminantCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.DeterminantCoefficient_Eval) __swig_destroy__ = _coefficient.delete_DeterminantCoefficient # Register DeterminantCoefficient in _coefficient: @@ -931,6 +1011,7 @@ def Eval(self, *args): Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorSumCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorSumCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorSumCoefficient # Register VectorSumCoefficient in _coefficient: @@ -952,6 +1033,7 @@ def Eval(self, *args): Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.ScalarVectorProductCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.ScalarVectorProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ScalarVectorProductCoefficient # Register ScalarVectorProductCoefficient in _coefficient: @@ -973,6 +1055,7 @@ def Eval(self, *args): Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.VectorCrossProductCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorCrossProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_VectorCrossProductCoefficient # Register VectorCrossProductCoefficient in _coefficient: @@ -994,6 +1077,7 @@ def Eval(self, *args): Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir) """ return _coefficient.MatVecCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.MatVecCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatVecCoefficient # Register MatVecCoefficient in _coefficient: @@ -1012,6 +1096,7 @@ def __init__(self, d): def Eval(self, M, T, ip): r"""Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.IdentityMatrixCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.IdentityMatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_IdentityMatrixCoefficient # Register IdentityMatrixCoefficient in _coefficient: @@ -1030,6 +1115,7 @@ def __init__(self, A, B, _alpha=1.0, _beta=1.0): def Eval(self, M, T, ip): r"""Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixSumCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixSumCoefficient_Eval) __swig_destroy__ = _coefficient.delete_MatrixSumCoefficient # Register MatrixSumCoefficient in _coefficient: @@ -1048,6 +1134,7 @@ def __init__(self, A, B): def Eval(self, M, T, ip): r"""Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.ScalarMatrixProductCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.ScalarMatrixProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_ScalarMatrixProductCoefficient # Register ScalarMatrixProductCoefficient in _coefficient: @@ -1066,6 +1153,7 @@ def __init__(self, A): def Eval(self, M, T, ip): r"""Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.TransposeMatrixCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.TransposeMatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_TransposeMatrixCoefficient # Register TransposeMatrixCoefficient in _coefficient: @@ -1084,6 +1172,7 @@ def __init__(self, A): def Eval(self, M, T, ip): r"""Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.InverseMatrixCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.InverseMatrixCoefficient_Eval) __swig_destroy__ = _coefficient.delete_InverseMatrixCoefficient # Register InverseMatrixCoefficient in _coefficient: @@ -1102,6 +1191,7 @@ def __init__(self, A, B): def Eval(self, M, T, ip): r"""Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.OuterProductCoefficient_Eval(self, M, T, ip) + Eval = _swig_new_instance_method(_coefficient.OuterProductCoefficient_Eval) __swig_destroy__ = _coefficient.delete_OuterProductCoefficient # Register OuterProductCoefficient in _coefficient: @@ -1114,18 +1204,22 @@ def ComputeLpNorm(*args): ComputeLpNorm(double p, VectorCoefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double """ return _coefficient.ComputeLpNorm(*args) +ComputeLpNorm = _coefficient.ComputeLpNorm def fake_func(x): r"""fake_func(Vector x) -> double""" return _coefficient.fake_func(x) +fake_func = _coefficient.fake_func def fake_func_vec(x, Ht): r"""fake_func_vec(Vector x, Vector Ht)""" return _coefficient.fake_func_vec(x, Ht) +fake_func_vec = _coefficient.fake_func_vec def fake_func_mat(x, Kt): r"""fake_func_mat(Vector x, DenseMatrix Kt)""" return _coefficient.fake_func_mat(x, Kt) +fake_func_mat = _coefficient.fake_func_mat class PyCoefficientBase(FunctionCoefficient): r"""Proxy of C++ mfem::PyCoefficientBase class.""" @@ -1143,14 +1237,17 @@ def __init__(self, tdep): def Eval(self, T, ip): r"""Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double""" return _coefficient.PyCoefficientBase_Eval(self, T, ip) + Eval = _swig_new_instance_method(_coefficient.PyCoefficientBase_Eval) def _EvalPy(self, arg0): r"""_EvalPy(PyCoefficientBase self, Vector arg0) -> double""" return _coefficient.PyCoefficientBase__EvalPy(self, arg0) + _EvalPy = _swig_new_instance_method(_coefficient.PyCoefficientBase__EvalPy) def _EvalPyT(self, arg0, arg1): r"""_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double""" return _coefficient.PyCoefficientBase__EvalPyT(self, arg0, arg1) + _EvalPyT = _swig_new_instance_method(_coefficient.PyCoefficientBase__EvalPyT) __swig_destroy__ = _coefficient.delete_PyCoefficientBase def __disown__(self): self.this.disown() @@ -1180,14 +1277,17 @@ def Eval(self, *args): Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _coefficient.VectorPyCoefficientBase_Eval(self, *args) + Eval = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase_Eval) def _EvalPy(self, arg0, arg1): r"""_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)""" return _coefficient.VectorPyCoefficientBase__EvalPy(self, arg0, arg1) + _EvalPy = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase__EvalPy) def _EvalPyT(self, arg0, arg1, arg2): r"""_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)""" return _coefficient.VectorPyCoefficientBase__EvalPyT(self, arg0, arg1, arg2) + _EvalPyT = _swig_new_instance_method(_coefficient.VectorPyCoefficientBase__EvalPyT) __swig_destroy__ = _coefficient.delete_VectorPyCoefficientBase def __disown__(self): self.this.disown() @@ -1214,14 +1314,17 @@ def __init__(self, dim, tdep): def Eval(self, K, T, ip): r"""Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)""" return _coefficient.MatrixPyCoefficientBase_Eval(self, K, T, ip) + Eval = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase_Eval) def _EvalPy(self, arg0, arg1): r"""_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)""" return _coefficient.MatrixPyCoefficientBase__EvalPy(self, arg0, arg1) + _EvalPy = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase__EvalPy) def _EvalPyT(self, arg0, arg1, arg2): r"""_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)""" return _coefficient.MatrixPyCoefficientBase__EvalPyT(self, arg0, arg1, arg2) + _EvalPyT = _swig_new_instance_method(_coefficient.MatrixPyCoefficientBase__EvalPyT) __swig_destroy__ = _coefficient.delete_MatrixPyCoefficientBase def __disown__(self): self.this.disown() @@ -1287,7 +1390,7 @@ def _EvalPy(self, x, K): K.Assign(k) def EvalValue(self, x): - return np.array([[0,0,0], [0,0,0] [0,0,0]]) + return np.array([[0,0,0], [0,0,0], [0,0,0]]) class MatrixPyCoefficientT(MatrixPyCoefficientBase): def __init__(self, dim): @@ -1298,7 +1401,7 @@ def _EvalPyT(self, x, t, K): K.Assign(k) def EvalValue(self, x, t): - return np.array([[0,0,0], [0,0,0] [0,0,0]]) + return np.array([[0,0,0], [0,0,0], [0,0,0]]) diff --git a/mfem/_ser/coefficient_wrap.cxx b/mfem/_ser/coefficient_wrap.cxx index 9168a2be..a963fde2 100644 --- a/mfem/_ser/coefficient_wrap.cxx +++ b/mfem/_ser/coefficient_wrap.cxx @@ -7624,6 +7624,47 @@ SWIGINTERN PyObject *_wrap_VectorConstantCoefficient_Eval(PyObject *self, PyObje } +SWIGINTERN PyObject *_wrap_VectorConstantCoefficient_GetVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConstantCoefficient *arg1 = (mfem::VectorConstantCoefficient *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConstantCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConstantCoefficient_GetVec" "', argument " "1"" of type '" "mfem::VectorConstantCoefficient *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConstantCoefficient * >(argp1); + { + try { + result = (mfem::Vector *) &(arg1)->GetVec(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_VectorConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorConstantCoefficient *arg1 = (mfem::VectorConstantCoefficient *) 0 ; @@ -19540,6 +19581,7 @@ SWIGINTERN PyObject *MatrixPyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(s static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "Coefficient_SetTime(Coefficient self, double t)"}, { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "Coefficient_GetTime(Coefficient self) -> double"}, { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" @@ -19635,6 +19677,7 @@ static PyMethodDef SwigMethods[] = { "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" ""}, + { "VectorConstantCoefficient_GetVec", _wrap_VectorConstantCoefficient_GetVec, METH_O, "VectorConstantCoefficient_GetVec(VectorConstantCoefficient self) -> Vector"}, { "delete_VectorConstantCoefficient", _wrap_delete_VectorConstantCoefficient, METH_O, "delete_VectorConstantCoefficient(VectorConstantCoefficient self)"}, { "VectorConstantCoefficient_swigregister", VectorConstantCoefficient_swigregister, METH_O, NULL}, { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19902,6 +19945,367 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "SetTime(Coefficient self, double t)"}, + { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "GetTime(Coefficient self) -> double"}, + { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" + "Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip) -> double\n" + "Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip, double t) -> double\n" + ""}, + { "delete_Coefficient", _wrap_delete_Coefficient, METH_O, "delete_Coefficient(Coefficient self)"}, + { "Coefficient_swigregister", Coefficient_swigregister, METH_O, NULL}, + { "ConstantCoefficient_constant_set", _wrap_ConstantCoefficient_constant_set, METH_VARARGS, "ConstantCoefficient_constant_set(ConstantCoefficient self, double constant)"}, + { "ConstantCoefficient_constant_get", _wrap_ConstantCoefficient_constant_get, METH_O, "ConstantCoefficient_constant_get(ConstantCoefficient self) -> double"}, + { "new_ConstantCoefficient", _wrap_new_ConstantCoefficient, METH_VARARGS, "ConstantCoefficient(double c=1.0)"}, + { "ConstantCoefficient_Eval", _wrap_ConstantCoefficient_Eval, METH_VARARGS, "Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_ConstantCoefficient", _wrap_delete_ConstantCoefficient, METH_O, "delete_ConstantCoefficient(ConstantCoefficient self)"}, + { "ConstantCoefficient_swigregister", ConstantCoefficient_swigregister, METH_O, NULL}, + { "ConstantCoefficient_swiginit", ConstantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_PWConstCoefficient", _wrap_new_PWConstCoefficient, METH_VARARGS, "\n" + "PWConstCoefficient(int NumOfSubD=0)\n" + "new_PWConstCoefficient(Vector c) -> PWConstCoefficient\n" + ""}, + { "PWConstCoefficient_UpdateConstants", _wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS, "UpdateConstants(PWConstCoefficient self, Vector c)"}, + { "PWConstCoefficient___call__", _wrap_PWConstCoefficient___call__, METH_VARARGS, "__call__(PWConstCoefficient self, int i) -> double &"}, + { "PWConstCoefficient_GetNConst", _wrap_PWConstCoefficient_GetNConst, METH_O, "GetNConst(PWConstCoefficient self) -> int"}, + { "PWConstCoefficient_Eval", _wrap_PWConstCoefficient_Eval, METH_VARARGS, "Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_PWConstCoefficient", _wrap_delete_PWConstCoefficient, METH_O, "delete_PWConstCoefficient(PWConstCoefficient self)"}, + { "PWConstCoefficient_swigregister", PWConstCoefficient_swigregister, METH_O, NULL}, + { "PWConstCoefficient_swiginit", PWConstCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_FunctionCoefficient", _wrap_new_FunctionCoefficient, METH_VARARGS, "\n" + "FunctionCoefficient(double (*)(mfem::Vector const &) f)\n" + "FunctionCoefficient(double (*)(mfem::Vector const &,double) tdf)\n" + "FunctionCoefficient(double (*)(mfem::Vector &) f)\n" + "new_FunctionCoefficient(double (*)(mfem::Vector &,double) tdf) -> FunctionCoefficient\n" + ""}, + { "FunctionCoefficient_Eval", _wrap_FunctionCoefficient_Eval, METH_VARARGS, "Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_FunctionCoefficient", _wrap_delete_FunctionCoefficient, METH_O, "delete_FunctionCoefficient(FunctionCoefficient self)"}, + { "FunctionCoefficient_swigregister", FunctionCoefficient_swigregister, METH_O, NULL}, + { "FunctionCoefficient_swiginit", FunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_GridFunctionCoefficient", _wrap_new_GridFunctionCoefficient, METH_VARARGS, "\n" + "GridFunctionCoefficient()\n" + "GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1)\n" + ""}, + { "GridFunctionCoefficient_SetGridFunction", _wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GridFunctionCoefficient_GetGridFunction", _wrap_GridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "GridFunctionCoefficient_Eval", _wrap_GridFunctionCoefficient_Eval, METH_VARARGS, "Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_GridFunctionCoefficient", _wrap_delete_GridFunctionCoefficient, METH_O, "delete_GridFunctionCoefficient(GridFunctionCoefficient self)"}, + { "GridFunctionCoefficient_swigregister", GridFunctionCoefficient_swigregister, METH_O, NULL}, + { "GridFunctionCoefficient_swiginit", GridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_TransformedCoefficient", _wrap_new_TransformedCoefficient, METH_VARARGS, "\n" + "TransformedCoefficient(Coefficient q, double (*)(double) F)\n" + "new_TransformedCoefficient(Coefficient q1, Coefficient q2, double (*)(double,double) F) -> TransformedCoefficient\n" + ""}, + { "TransformedCoefficient_Eval", _wrap_TransformedCoefficient_Eval, METH_VARARGS, "Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_TransformedCoefficient", _wrap_delete_TransformedCoefficient, METH_O, "delete_TransformedCoefficient(TransformedCoefficient self)"}, + { "TransformedCoefficient_swigregister", TransformedCoefficient_swigregister, METH_O, NULL}, + { "TransformedCoefficient_swiginit", TransformedCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_DeltaCoefficient", _wrap_new_DeltaCoefficient, METH_VARARGS, "\n" + "DeltaCoefficient()\n" + "DeltaCoefficient(double x, double s)\n" + "DeltaCoefficient(double x, double y, double s)\n" + "new_DeltaCoefficient(double x, double y, double z, double s) -> DeltaCoefficient\n" + ""}, + { "DeltaCoefficient_SetDeltaCenter", _wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_SetScale", _wrap_DeltaCoefficient_SetScale, METH_VARARGS, "SetScale(DeltaCoefficient self, double _s)"}, + { "DeltaCoefficient_SetFunction", _wrap_DeltaCoefficient_SetFunction, METH_VARARGS, "SetFunction(DeltaCoefficient self, double (*)(double) f)"}, + { "DeltaCoefficient_SetTol", _wrap_DeltaCoefficient_SetTol, METH_VARARGS, "SetTol(DeltaCoefficient self, double _tol)"}, + { "DeltaCoefficient_SetWeight", _wrap_DeltaCoefficient_SetWeight, METH_VARARGS, "SetWeight(DeltaCoefficient self, Coefficient w)"}, + { "DeltaCoefficient_Center", _wrap_DeltaCoefficient_Center, METH_O, "Center(DeltaCoefficient self) -> double const *"}, + { "DeltaCoefficient_Scale", _wrap_DeltaCoefficient_Scale, METH_O, "Scale(DeltaCoefficient self) -> double"}, + { "DeltaCoefficient_Tol", _wrap_DeltaCoefficient_Tol, METH_O, "Tol(DeltaCoefficient self) -> double"}, + { "DeltaCoefficient_Weight", _wrap_DeltaCoefficient_Weight, METH_O, "Weight(DeltaCoefficient self) -> Coefficient"}, + { "DeltaCoefficient_GetDeltaCenter", _wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_EvalDelta", _wrap_DeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_Eval", _wrap_DeltaCoefficient_Eval, METH_VARARGS, "Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_DeltaCoefficient", _wrap_delete_DeltaCoefficient, METH_O, "delete_DeltaCoefficient(DeltaCoefficient self)"}, + { "DeltaCoefficient_swigregister", DeltaCoefficient_swigregister, METH_O, NULL}, + { "DeltaCoefficient_swiginit", DeltaCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_RestrictedCoefficient", _wrap_new_RestrictedCoefficient, METH_VARARGS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, + { "RestrictedCoefficient_Eval", _wrap_RestrictedCoefficient_Eval, METH_VARARGS, "Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_RestrictedCoefficient", _wrap_delete_RestrictedCoefficient, METH_O, "delete_RestrictedCoefficient(RestrictedCoefficient self)"}, + { "RestrictedCoefficient_swigregister", RestrictedCoefficient_swigregister, METH_O, NULL}, + { "RestrictedCoefficient_swiginit", RestrictedCoefficient_swiginit, METH_VARARGS, NULL}, + { "VectorCoefficient_SetTime", _wrap_VectorCoefficient_SetTime, METH_VARARGS, "SetTime(VectorCoefficient self, double t)"}, + { "VectorCoefficient_GetTime", _wrap_VectorCoefficient_GetTime, METH_O, "GetTime(VectorCoefficient self) -> double"}, + { "VectorCoefficient_GetVDim", _wrap_VectorCoefficient_GetVDim, METH_O, "GetVDim(VectorCoefficient self) -> int"}, + { "VectorCoefficient_Eval", _wrap_VectorCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorCoefficient", _wrap_delete_VectorCoefficient, METH_O, "delete_VectorCoefficient(VectorCoefficient self)"}, + { "VectorCoefficient_swigregister", VectorCoefficient_swigregister, METH_O, NULL}, + { "new_VectorConstantCoefficient", _wrap_new_VectorConstantCoefficient, METH_O, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, + { "VectorConstantCoefficient_Eval", _wrap_VectorConstantCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "VectorConstantCoefficient_GetVec", _wrap_VectorConstantCoefficient_GetVec, METH_O, "GetVec(VectorConstantCoefficient self) -> Vector"}, + { "delete_VectorConstantCoefficient", _wrap_delete_VectorConstantCoefficient, METH_O, "delete_VectorConstantCoefficient(VectorConstantCoefficient self)"}, + { "VectorConstantCoefficient_swigregister", VectorConstantCoefficient_swigregister, METH_O, NULL}, + { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorFunctionCoefficient", _wrap_new_VectorFunctionCoefficient, METH_VARARGS, "\n" + "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::Vector &) F, Coefficient q=None)\n" + "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None)\n" + ""}, + { "VectorFunctionCoefficient_Eval", _wrap_VectorFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_VectorFunctionCoefficient", _wrap_delete_VectorFunctionCoefficient, METH_O, "delete_VectorFunctionCoefficient(VectorFunctionCoefficient self)"}, + { "VectorFunctionCoefficient_swigregister", VectorFunctionCoefficient_swigregister, METH_O, NULL}, + { "VectorFunctionCoefficient_swiginit", VectorFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorArrayCoefficient", _wrap_new_VectorArrayCoefficient, METH_O, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, + { "VectorArrayCoefficient_GetCoeff", _wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, + { "VectorArrayCoefficient_GetCoeffs", _wrap_VectorArrayCoefficient_GetCoeffs, METH_O, "GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **"}, + { "VectorArrayCoefficient_Set", _wrap_VectorArrayCoefficient_Set, METH_VARARGS, "Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, + { "VectorArrayCoefficient_Eval", _wrap_VectorArrayCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorArrayCoefficient self, int i, ElementTransformation T, IntegrationPoint ip) -> double\n" + "Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorArrayCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_VectorArrayCoefficient", _wrap_delete_VectorArrayCoefficient, METH_O, "delete_VectorArrayCoefficient(VectorArrayCoefficient self)"}, + { "VectorArrayCoefficient_swigregister", VectorArrayCoefficient_swigregister, METH_O, NULL}, + { "VectorArrayCoefficient_swiginit", VectorArrayCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorGridFunctionCoefficient", _wrap_new_VectorGridFunctionCoefficient, METH_VARARGS, "\n" + "VectorGridFunctionCoefficient()\n" + "new_VectorGridFunctionCoefficient(mfem::GridFunction * gf) -> VectorGridFunctionCoefficient\n" + ""}, + { "VectorGridFunctionCoefficient_SetGridFunction", _wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "VectorGridFunctionCoefficient_GetGridFunction", _wrap_VectorGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "VectorGridFunctionCoefficient_Eval", _wrap_VectorGridFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorGridFunctionCoefficient", _wrap_delete_VectorGridFunctionCoefficient, METH_O, "delete_VectorGridFunctionCoefficient(VectorGridFunctionCoefficient self)"}, + { "VectorGridFunctionCoefficient_swigregister", VectorGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "VectorGridFunctionCoefficient_swiginit", VectorGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_GradientGridFunctionCoefficient", _wrap_new_GradientGridFunctionCoefficient, METH_O, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, + { "GradientGridFunctionCoefficient_SetGridFunction", _wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GradientGridFunctionCoefficient_GetGridFunction", _wrap_GradientGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "GradientGridFunctionCoefficient_Eval", _wrap_GradientGridFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(GradientGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(GradientGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_GradientGridFunctionCoefficient", _wrap_delete_GradientGridFunctionCoefficient, METH_O, "delete_GradientGridFunctionCoefficient(GradientGridFunctionCoefficient self)"}, + { "GradientGridFunctionCoefficient_swigregister", GradientGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "GradientGridFunctionCoefficient_swiginit", GradientGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "CurlGridFunctionCoefficient_SetGridFunction", _wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "CurlGridFunctionCoefficient_GetGridFunction", _wrap_CurlGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "CurlGridFunctionCoefficient_Eval", _wrap_CurlGridFunctionCoefficient_Eval, METH_VARARGS, "\n" + "Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(CurlGridFunctionCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_CurlGridFunctionCoefficient", _wrap_delete_CurlGridFunctionCoefficient, METH_O, "delete_CurlGridFunctionCoefficient(CurlGridFunctionCoefficient self)"}, + { "CurlGridFunctionCoefficient_swigregister", CurlGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "new_DivergenceGridFunctionCoefficient", _wrap_new_DivergenceGridFunctionCoefficient, METH_O, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, + { "DivergenceGridFunctionCoefficient_SetGridFunction", _wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "DivergenceGridFunctionCoefficient_GetGridFunction", _wrap_DivergenceGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *"}, + { "DivergenceGridFunctionCoefficient_Eval", _wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS, "Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_DivergenceGridFunctionCoefficient", _wrap_delete_DivergenceGridFunctionCoefficient, METH_O, "delete_DivergenceGridFunctionCoefficient(DivergenceGridFunctionCoefficient self)"}, + { "DivergenceGridFunctionCoefficient_swigregister", DivergenceGridFunctionCoefficient_swigregister, METH_O, NULL}, + { "DivergenceGridFunctionCoefficient_swiginit", DivergenceGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorDeltaCoefficient", _wrap_new_VectorDeltaCoefficient, METH_VARARGS, "\n" + "VectorDeltaCoefficient(int _vdim)\n" + "VectorDeltaCoefficient(Vector _dir)\n" + "VectorDeltaCoefficient(Vector _dir, double x, double s)\n" + "VectorDeltaCoefficient(Vector _dir, double x, double y, double s)\n" + "new_VectorDeltaCoefficient(Vector _dir, double x, double y, double z, double s) -> VectorDeltaCoefficient\n" + ""}, + { "VectorDeltaCoefficient_SetDeltaCoefficient", _wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS, "SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, + { "VectorDeltaCoefficient_GetDeltaCoefficient", _wrap_VectorDeltaCoefficient_GetDeltaCoefficient, METH_O, "GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient"}, + { "VectorDeltaCoefficient_SetScale", _wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS, "SetScale(VectorDeltaCoefficient self, double s)"}, + { "VectorDeltaCoefficient_SetDirection", _wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS, "SetDirection(VectorDeltaCoefficient self, Vector _d)"}, + { "VectorDeltaCoefficient_SetDeltaCenter", _wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_GetDeltaCenter", _wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_EvalDelta", _wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, + { "VectorDeltaCoefficient_Eval", _wrap_VectorDeltaCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorDeltaCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_VectorDeltaCoefficient", _wrap_delete_VectorDeltaCoefficient, METH_O, "delete_VectorDeltaCoefficient(VectorDeltaCoefficient self)"}, + { "VectorDeltaCoefficient_swigregister", VectorDeltaCoefficient_swigregister, METH_O, NULL}, + { "VectorDeltaCoefficient_swiginit", VectorDeltaCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorRestrictedCoefficient", _wrap_new_VectorRestrictedCoefficient, METH_VARARGS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, + { "VectorRestrictedCoefficient_Eval", _wrap_VectorRestrictedCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorRestrictedCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorRestrictedCoefficient", _wrap_delete_VectorRestrictedCoefficient, METH_O, "delete_VectorRestrictedCoefficient(VectorRestrictedCoefficient self)"}, + { "VectorRestrictedCoefficient_swigregister", VectorRestrictedCoefficient_swigregister, METH_O, NULL}, + { "VectorRestrictedCoefficient_swiginit", VectorRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, + { "MatrixCoefficient_SetTime", _wrap_MatrixCoefficient_SetTime, METH_VARARGS, "SetTime(MatrixCoefficient self, double t)"}, + { "MatrixCoefficient_GetTime", _wrap_MatrixCoefficient_GetTime, METH_O, "GetTime(MatrixCoefficient self) -> double"}, + { "MatrixCoefficient_GetHeight", _wrap_MatrixCoefficient_GetHeight, METH_O, "GetHeight(MatrixCoefficient self) -> int"}, + { "MatrixCoefficient_GetWidth", _wrap_MatrixCoefficient_GetWidth, METH_O, "GetWidth(MatrixCoefficient self) -> int"}, + { "MatrixCoefficient_GetVDim", _wrap_MatrixCoefficient_GetVDim, METH_O, "GetVDim(MatrixCoefficient self) -> int"}, + { "MatrixCoefficient_Eval", _wrap_MatrixCoefficient_Eval, METH_VARARGS, "Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixCoefficient", _wrap_delete_MatrixCoefficient, METH_O, "delete_MatrixCoefficient(MatrixCoefficient self)"}, + { "MatrixCoefficient_swigregister", MatrixCoefficient_swigregister, METH_O, NULL}, + { "new_MatrixConstantCoefficient", _wrap_new_MatrixConstantCoefficient, METH_O, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, + { "MatrixConstantCoefficient_Eval", _wrap_MatrixConstantCoefficient_Eval, METH_VARARGS, "\n" + "Eval(MatrixConstantCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_MatrixConstantCoefficient", _wrap_delete_MatrixConstantCoefficient, METH_O, "delete_MatrixConstantCoefficient(MatrixConstantCoefficient self)"}, + { "MatrixConstantCoefficient_swigregister", MatrixConstantCoefficient_swigregister, METH_O, NULL}, + { "MatrixConstantCoefficient_swiginit", MatrixConstantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixFunctionCoefficient", _wrap_new_MatrixFunctionCoefficient, METH_VARARGS, "\n" + "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::DenseMatrix &) F, Coefficient q=None)\n" + "MatrixFunctionCoefficient(DenseMatrix m, Coefficient q)\n" + "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None)\n" + ""}, + { "MatrixFunctionCoefficient_Eval", _wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS, "Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixFunctionCoefficient", _wrap_delete_MatrixFunctionCoefficient, METH_O, "delete_MatrixFunctionCoefficient(MatrixFunctionCoefficient self)"}, + { "MatrixFunctionCoefficient_swigregister", MatrixFunctionCoefficient_swigregister, METH_O, NULL}, + { "MatrixFunctionCoefficient_swiginit", MatrixFunctionCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixArrayCoefficient", _wrap_new_MatrixArrayCoefficient, METH_O, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, + { "MatrixArrayCoefficient_GetCoeff", _wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, + { "MatrixArrayCoefficient_Set", _wrap_MatrixArrayCoefficient_Set, METH_VARARGS, "Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, + { "MatrixArrayCoefficient_Eval", _wrap_MatrixArrayCoefficient_Eval, METH_VARARGS, "\n" + "Eval(MatrixArrayCoefficient self, int i, int j, ElementTransformation T, IntegrationPoint ip) -> double\n" + "Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_MatrixArrayCoefficient", _wrap_delete_MatrixArrayCoefficient, METH_O, "delete_MatrixArrayCoefficient(MatrixArrayCoefficient self)"}, + { "MatrixArrayCoefficient_swigregister", MatrixArrayCoefficient_swigregister, METH_O, NULL}, + { "MatrixArrayCoefficient_swiginit", MatrixArrayCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixRestrictedCoefficient", _wrap_new_MatrixRestrictedCoefficient, METH_VARARGS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, + { "MatrixRestrictedCoefficient_Eval", _wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS, "Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixRestrictedCoefficient", _wrap_delete_MatrixRestrictedCoefficient, METH_O, "delete_MatrixRestrictedCoefficient(MatrixRestrictedCoefficient self)"}, + { "MatrixRestrictedCoefficient_swigregister", MatrixRestrictedCoefficient_swigregister, METH_O, NULL}, + { "MatrixRestrictedCoefficient_swiginit", MatrixRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_SumCoefficient", _wrap_new_SumCoefficient, METH_VARARGS, "SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "SumCoefficient_Eval", _wrap_SumCoefficient_Eval, METH_VARARGS, "Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_SumCoefficient", _wrap_delete_SumCoefficient, METH_O, "delete_SumCoefficient(SumCoefficient self)"}, + { "SumCoefficient_swigregister", SumCoefficient_swigregister, METH_O, NULL}, + { "SumCoefficient_swiginit", SumCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_ProductCoefficient", _wrap_new_ProductCoefficient, METH_VARARGS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, + { "ProductCoefficient_Eval", _wrap_ProductCoefficient_Eval, METH_VARARGS, "Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_ProductCoefficient", _wrap_delete_ProductCoefficient, METH_O, "delete_ProductCoefficient(ProductCoefficient self)"}, + { "ProductCoefficient_swigregister", ProductCoefficient_swigregister, METH_O, NULL}, + { "ProductCoefficient_swiginit", ProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_PowerCoefficient", _wrap_new_PowerCoefficient, METH_VARARGS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, + { "PowerCoefficient_Eval", _wrap_PowerCoefficient_Eval, METH_VARARGS, "Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_PowerCoefficient", _wrap_delete_PowerCoefficient, METH_O, "delete_PowerCoefficient(PowerCoefficient self)"}, + { "PowerCoefficient_swigregister", PowerCoefficient_swigregister, METH_O, NULL}, + { "PowerCoefficient_swiginit", PowerCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_InnerProductCoefficient", _wrap_new_InnerProductCoefficient, METH_VARARGS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, + { "InnerProductCoefficient_Eval", _wrap_InnerProductCoefficient_Eval, METH_VARARGS, "Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_InnerProductCoefficient", _wrap_delete_InnerProductCoefficient, METH_O, "delete_InnerProductCoefficient(InnerProductCoefficient self)"}, + { "InnerProductCoefficient_swigregister", InnerProductCoefficient_swigregister, METH_O, NULL}, + { "InnerProductCoefficient_swiginit", InnerProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorRotProductCoefficient", _wrap_new_VectorRotProductCoefficient, METH_VARARGS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, + { "VectorRotProductCoefficient_Eval", _wrap_VectorRotProductCoefficient_Eval, METH_VARARGS, "Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_VectorRotProductCoefficient", _wrap_delete_VectorRotProductCoefficient, METH_O, "delete_VectorRotProductCoefficient(VectorRotProductCoefficient self)"}, + { "VectorRotProductCoefficient_swigregister", VectorRotProductCoefficient_swigregister, METH_O, NULL}, + { "VectorRotProductCoefficient_swiginit", VectorRotProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_DeterminantCoefficient", _wrap_new_DeterminantCoefficient, METH_O, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, + { "DeterminantCoefficient_Eval", _wrap_DeterminantCoefficient_Eval, METH_VARARGS, "Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_DeterminantCoefficient", _wrap_delete_DeterminantCoefficient, METH_O, "delete_DeterminantCoefficient(DeterminantCoefficient self)"}, + { "DeterminantCoefficient_swigregister", DeterminantCoefficient_swigregister, METH_O, NULL}, + { "DeterminantCoefficient_swiginit", DeterminantCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorSumCoefficient", _wrap_new_VectorSumCoefficient, METH_VARARGS, "VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "VectorSumCoefficient_Eval", _wrap_VectorSumCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorSumCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorSumCoefficient", _wrap_delete_VectorSumCoefficient, METH_O, "delete_VectorSumCoefficient(VectorSumCoefficient self)"}, + { "VectorSumCoefficient_swigregister", VectorSumCoefficient_swigregister, METH_O, NULL}, + { "VectorSumCoefficient_swiginit", VectorSumCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_ScalarVectorProductCoefficient", _wrap_new_ScalarVectorProductCoefficient, METH_VARARGS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, + { "ScalarVectorProductCoefficient_Eval", _wrap_ScalarVectorProductCoefficient_Eval, METH_VARARGS, "\n" + "Eval(ScalarVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_ScalarVectorProductCoefficient", _wrap_delete_ScalarVectorProductCoefficient, METH_O, "delete_ScalarVectorProductCoefficient(ScalarVectorProductCoefficient self)"}, + { "ScalarVectorProductCoefficient_swigregister", ScalarVectorProductCoefficient_swigregister, METH_O, NULL}, + { "ScalarVectorProductCoefficient_swiginit", ScalarVectorProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_VectorCrossProductCoefficient", _wrap_new_VectorCrossProductCoefficient, METH_VARARGS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, + { "VectorCrossProductCoefficient_Eval", _wrap_VectorCrossProductCoefficient_Eval, METH_VARARGS, "\n" + "Eval(VectorCrossProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_VectorCrossProductCoefficient", _wrap_delete_VectorCrossProductCoefficient, METH_O, "delete_VectorCrossProductCoefficient(VectorCrossProductCoefficient self)"}, + { "VectorCrossProductCoefficient_swigregister", VectorCrossProductCoefficient_swigregister, METH_O, NULL}, + { "VectorCrossProductCoefficient_swiginit", VectorCrossProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatVecCoefficient", _wrap_new_MatVecCoefficient, METH_VARARGS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, + { "MatVecCoefficient_Eval", _wrap_MatVecCoefficient_Eval, METH_VARARGS, "\n" + "Eval(MatVecCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + ""}, + { "delete_MatVecCoefficient", _wrap_delete_MatVecCoefficient, METH_O, "delete_MatVecCoefficient(MatVecCoefficient self)"}, + { "MatVecCoefficient_swigregister", MatVecCoefficient_swigregister, METH_O, NULL}, + { "MatVecCoefficient_swiginit", MatVecCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_IdentityMatrixCoefficient", _wrap_new_IdentityMatrixCoefficient, METH_O, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, + { "IdentityMatrixCoefficient_Eval", _wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS, "Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_IdentityMatrixCoefficient", _wrap_delete_IdentityMatrixCoefficient, METH_O, "delete_IdentityMatrixCoefficient(IdentityMatrixCoefficient self)"}, + { "IdentityMatrixCoefficient_swigregister", IdentityMatrixCoefficient_swigregister, METH_O, NULL}, + { "IdentityMatrixCoefficient_swiginit", IdentityMatrixCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_MatrixSumCoefficient", _wrap_new_MatrixSumCoefficient, METH_VARARGS, "MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "MatrixSumCoefficient_Eval", _wrap_MatrixSumCoefficient_Eval, METH_VARARGS, "Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_MatrixSumCoefficient", _wrap_delete_MatrixSumCoefficient, METH_O, "delete_MatrixSumCoefficient(MatrixSumCoefficient self)"}, + { "MatrixSumCoefficient_swigregister", MatrixSumCoefficient_swigregister, METH_O, NULL}, + { "MatrixSumCoefficient_swiginit", MatrixSumCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_ScalarMatrixProductCoefficient", _wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, + { "ScalarMatrixProductCoefficient_Eval", _wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS, "Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_ScalarMatrixProductCoefficient", _wrap_delete_ScalarMatrixProductCoefficient, METH_O, "delete_ScalarMatrixProductCoefficient(ScalarMatrixProductCoefficient self)"}, + { "ScalarMatrixProductCoefficient_swigregister", ScalarMatrixProductCoefficient_swigregister, METH_O, NULL}, + { "ScalarMatrixProductCoefficient_swiginit", ScalarMatrixProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_TransposeMatrixCoefficient", _wrap_new_TransposeMatrixCoefficient, METH_O, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, + { "TransposeMatrixCoefficient_Eval", _wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS, "Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_TransposeMatrixCoefficient", _wrap_delete_TransposeMatrixCoefficient, METH_O, "delete_TransposeMatrixCoefficient(TransposeMatrixCoefficient self)"}, + { "TransposeMatrixCoefficient_swigregister", TransposeMatrixCoefficient_swigregister, METH_O, NULL}, + { "TransposeMatrixCoefficient_swiginit", TransposeMatrixCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_InverseMatrixCoefficient", _wrap_new_InverseMatrixCoefficient, METH_O, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, + { "InverseMatrixCoefficient_Eval", _wrap_InverseMatrixCoefficient_Eval, METH_VARARGS, "Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_InverseMatrixCoefficient", _wrap_delete_InverseMatrixCoefficient, METH_O, "delete_InverseMatrixCoefficient(InverseMatrixCoefficient self)"}, + { "InverseMatrixCoefficient_swigregister", InverseMatrixCoefficient_swigregister, METH_O, NULL}, + { "InverseMatrixCoefficient_swiginit", InverseMatrixCoefficient_swiginit, METH_VARARGS, NULL}, + { "new_OuterProductCoefficient", _wrap_new_OuterProductCoefficient, METH_VARARGS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, + { "OuterProductCoefficient_Eval", _wrap_OuterProductCoefficient_Eval, METH_VARARGS, "Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "delete_OuterProductCoefficient", _wrap_delete_OuterProductCoefficient, METH_O, "delete_OuterProductCoefficient(OuterProductCoefficient self)"}, + { "OuterProductCoefficient_swigregister", OuterProductCoefficient_swigregister, METH_O, NULL}, + { "OuterProductCoefficient_swiginit", OuterProductCoefficient_swiginit, METH_VARARGS, NULL}, + { "ComputeLpNorm", _wrap_ComputeLpNorm, METH_VARARGS, "\n" + "ComputeLpNorm(double p, Coefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" + "ComputeLpNorm(double p, VectorCoefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" + ""}, + { "fake_func", _wrap_fake_func, METH_O, "fake_func(Vector x) -> double"}, + { "fake_func_vec", _wrap_fake_func_vec, METH_VARARGS, "fake_func_vec(Vector x, Vector Ht)"}, + { "fake_func_mat", _wrap_fake_func_mat, METH_VARARGS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, + { "new_PyCoefficientBase", _wrap_new_PyCoefficientBase, METH_VARARGS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, + { "PyCoefficientBase_Eval", _wrap_PyCoefficientBase_Eval, METH_VARARGS, "Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PyCoefficientBase__EvalPy", _wrap_PyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, + { "PyCoefficientBase__EvalPyT", _wrap_PyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, + { "delete_PyCoefficientBase", _wrap_delete_PyCoefficientBase, METH_O, "delete_PyCoefficientBase(PyCoefficientBase self)"}, + { "disown_PyCoefficientBase", _wrap_disown_PyCoefficientBase, METH_O, NULL}, + { "PyCoefficientBase_swigregister", PyCoefficientBase_swigregister, METH_O, NULL}, + { "PyCoefficientBase_swiginit", PyCoefficientBase_swiginit, METH_VARARGS, NULL}, + { "new_VectorPyCoefficientBase", _wrap_new_VectorPyCoefficientBase, METH_VARARGS, "VectorPyCoefficientBase(int dim, int tdep, Coefficient q=None)"}, + { "VectorPyCoefficientBase_Eval", _wrap_VectorPyCoefficientBase_Eval, METH_VARARGS, "\n" + "Eval(VectorPyCoefficientBase self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "VectorPyCoefficientBase__EvalPy", _wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, + { "VectorPyCoefficientBase__EvalPyT", _wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, + { "delete_VectorPyCoefficientBase", _wrap_delete_VectorPyCoefficientBase, METH_O, "delete_VectorPyCoefficientBase(VectorPyCoefficientBase self)"}, + { "disown_VectorPyCoefficientBase", _wrap_disown_VectorPyCoefficientBase, METH_O, NULL}, + { "VectorPyCoefficientBase_swigregister", VectorPyCoefficientBase_swigregister, METH_O, NULL}, + { "VectorPyCoefficientBase_swiginit", VectorPyCoefficientBase_swiginit, METH_VARARGS, NULL}, + { "new_MatrixPyCoefficientBase", _wrap_new_MatrixPyCoefficientBase, METH_VARARGS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, + { "MatrixPyCoefficientBase_Eval", _wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS, "Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixPyCoefficientBase__EvalPy", _wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, + { "MatrixPyCoefficientBase__EvalPyT", _wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, + { "delete_MatrixPyCoefficientBase", _wrap_delete_MatrixPyCoefficientBase, METH_O, "delete_MatrixPyCoefficientBase(MatrixPyCoefficientBase self)"}, + { "disown_MatrixPyCoefficientBase", _wrap_disown_MatrixPyCoefficientBase, METH_O, NULL}, + { "MatrixPyCoefficientBase_swigregister", MatrixPyCoefficientBase_swigregister, METH_O, NULL}, + { "MatrixPyCoefficientBase_swiginit", MatrixPyCoefficientBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/common_functions.py b/mfem/_ser/common_functions.py index 5efe41b6..583cf7c8 100644 --- a/mfem/_ser/common_functions.py +++ b/mfem/_ser/common_functions.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _common_functions.SWIG_PyInstanceMethod_New +_swig_new_static_method = _common_functions.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -67,6 +70,7 @@ class _SwigNonDynamicMeta(type): def InnerProduct(x, y): r"""InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double""" return _common_functions.InnerProduct(x, y) +InnerProduct = _common_functions.InnerProduct def RAP(*args): r""" @@ -76,6 +80,7 @@ def RAP(*args): RAP(mfem::SparseMatrix const & Rt, mfem::SparseMatrix const & A, mfem::SparseMatrix const & P) -> mfem::SparseMatrix * """ return _common_functions.RAP(*args) +RAP = _common_functions.RAP def Add(*args): r""" @@ -88,6 +93,7 @@ def Add(*args): Add(mfem::SparseMatrix const & A, double alpha, mfem::DenseMatrix & B) """ return _common_functions.Add(*args) +Add = _common_functions.Add def Transpose(*args): r""" @@ -98,6 +104,7 @@ def Transpose(*args): Transpose(mfem::BlockMatrix const & A) -> mfem::BlockMatrix * """ return _common_functions.Transpose(*args) +Transpose = _common_functions.Transpose def Mult(*args): r""" @@ -109,5 +116,6 @@ def Mult(*args): Mult(mfem::BlockMatrix const & A, mfem::BlockMatrix const & B) -> mfem::BlockMatrix * """ return _common_functions.Mult(*args) +Mult = _common_functions.Mult diff --git a/mfem/_ser/common_functions_wrap.cxx b/mfem/_ser/common_functions_wrap.cxx index 0c51b967..5df0e673 100644 --- a/mfem/_ser/common_functions_wrap.cxx +++ b/mfem/_ser/common_functions_wrap.cxx @@ -4891,6 +4891,7 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "InnerProduct", _wrap_InnerProduct, METH_VARARGS, "InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double"}, { "RAP", _wrap_RAP, METH_VARARGS, "\n" "RAP(mfem::SparseMatrix const & A, mfem::DenseMatrix & P) -> mfem::DenseMatrix\n" @@ -4926,6 +4927,39 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "InnerProduct", _wrap_InnerProduct, METH_VARARGS, "InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double"}, + { "RAP", _wrap_RAP, METH_VARARGS, "\n" + "RAP(mfem::SparseMatrix const & A, mfem::DenseMatrix & P) -> mfem::DenseMatrix\n" + "RAP(mfem::DenseMatrix & A, mfem::SparseMatrix const & P) -> mfem::DenseMatrix\n" + "RAP(mfem::SparseMatrix const & A, mfem::SparseMatrix const & R, mfem::SparseMatrix * ORAP=None) -> mfem::SparseMatrix\n" + "RAP(mfem::SparseMatrix const & Rt, mfem::SparseMatrix const & A, mfem::SparseMatrix const & P) -> mfem::SparseMatrix *\n" + ""}, + { "Add", _wrap_Add, METH_VARARGS, "\n" + "Add(mfem::DenseMatrix const & A, mfem::DenseMatrix const & B, double alpha, mfem::DenseMatrix & C)\n" + "Add(double alpha, double const * A, double beta, double const * B, mfem::DenseMatrix & C)\n" + "Add(double alpha, mfem::DenseMatrix const & A, double beta, mfem::DenseMatrix const & B, mfem::DenseMatrix & C)\n" + "Add(mfem::SparseMatrix const & A, mfem::SparseMatrix const & B) -> mfem::SparseMatrix\n" + "Add(double a, mfem::SparseMatrix const & A, double b, mfem::SparseMatrix const & B) -> mfem::SparseMatrix\n" + "Add(mfem::Array< mfem::SparseMatrix * > & Ai) -> mfem::SparseMatrix\n" + "Add(mfem::SparseMatrix const & A, double alpha, mfem::DenseMatrix & B)\n" + ""}, + { "Transpose", _wrap_Transpose, METH_VARARGS, "\n" + "Transpose(mfem::Table const & A, mfem::Table & At, int _ncols_A=-1)\n" + "Transpose(mfem::Table const & A) -> mfem::Table\n" + "Transpose(intArray A, mfem::Table & At, int _ncols_A=-1)\n" + "Transpose(mfem::SparseMatrix const & A) -> mfem::SparseMatrix\n" + "Transpose(mfem::BlockMatrix const & A) -> mfem::BlockMatrix *\n" + ""}, + { "Mult", _wrap_Mult, METH_VARARGS, "\n" + "Mult(mfem::Table const & A, mfem::Table const & B, mfem::Table & C)\n" + "Mult(mfem::Table const & A, mfem::Table const & B) -> mfem::Table\n" + "Mult(mfem::DenseMatrix const & b, mfem::DenseMatrix const & c, mfem::DenseMatrix & a)\n" + "Mult(mfem::SparseMatrix const & A, mfem::SparseMatrix const & B, mfem::SparseMatrix * OAB=None) -> mfem::SparseMatrix\n" + "Mult(mfem::SparseMatrix const & A, mfem::DenseMatrix & B) -> mfem::DenseMatrix\n" + "Mult(mfem::BlockMatrix const & A, mfem::BlockMatrix const & B) -> mfem::BlockMatrix *\n" + ""}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/complex_operator.py b/mfem/_ser/complex_operator.py index a947d4ef..5de9f9aa 100644 --- a/mfem/_ser/complex_operator.py +++ b/mfem/_ser/complex_operator.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _complex_operator.SWIG_PyInstanceMethod_New +_swig_new_static_method = _complex_operator.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -81,13 +84,46 @@ class ComplexOperator(mfem._ser.operators.Operator): __swig_destroy__ = _complex_operator.delete_ComplexOperator + def hasRealPart(self): + r"""hasRealPart(ComplexOperator self) -> bool""" + return _complex_operator.ComplexOperator_hasRealPart(self) + hasRealPart = _swig_new_instance_method(_complex_operator.ComplexOperator_hasRealPart) + + def hasImagPart(self): + r"""hasImagPart(ComplexOperator self) -> bool""" + return _complex_operator.ComplexOperator_hasImagPart(self) + hasImagPart = _swig_new_instance_method(_complex_operator.ComplexOperator_hasImagPart) + + def real(self, *args): + r""" + real(ComplexOperator self) -> Operator + real(ComplexOperator self) -> Operator + """ + return _complex_operator.ComplexOperator_real(self, *args) + real = _swig_new_instance_method(_complex_operator.ComplexOperator_real) + + def imag(self, *args): + r""" + imag(ComplexOperator self) -> Operator + imag(ComplexOperator self) -> Operator + """ + return _complex_operator.ComplexOperator_imag(self, *args) + imag = _swig_new_instance_method(_complex_operator.ComplexOperator_imag) + def Mult(self, x, y): r"""Mult(ComplexOperator self, Vector x, Vector y)""" return _complex_operator.ComplexOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_complex_operator.ComplexOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(ComplexOperator self, Vector x, Vector y)""" return _complex_operator.ComplexOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_complex_operator.ComplexOperator_MultTranspose) + + def GetType(self): + r"""GetType(ComplexOperator self) -> mfem::Operator::Type""" + return _complex_operator.ComplexOperator_GetType(self) + GetType = _swig_new_instance_method(_complex_operator.ComplexOperator_GetType) def __init__(self, Op_Real, Op_Imag, ownReal=False, ownImag=False, hermitan=True): r"""__init__(ComplexOperator self, Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True) -> ComplexOperator""" @@ -116,9 +152,31 @@ def __init__(self, *args): r"""__init__(ComplexSparseMatrix self, SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix""" _complex_operator.ComplexSparseMatrix_swiginit(self, _complex_operator.new_ComplexSparseMatrix(*args)) + def real(self, *args): + r""" + real(ComplexSparseMatrix self) -> SparseMatrix + real(ComplexSparseMatrix self) -> SparseMatrix + """ + return _complex_operator.ComplexSparseMatrix_real(self, *args) + real = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_real) + + def imag(self, *args): + r""" + imag(ComplexSparseMatrix self) -> SparseMatrix + imag(ComplexSparseMatrix self) -> SparseMatrix + """ + return _complex_operator.ComplexSparseMatrix_imag(self, *args) + imag = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_imag) + def GetSystemMatrix(self): r"""GetSystemMatrix(ComplexSparseMatrix self) -> SparseMatrix""" return _complex_operator.ComplexSparseMatrix_GetSystemMatrix(self) + GetSystemMatrix = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_GetSystemMatrix) + + def GetType(self): + r"""GetType(ComplexSparseMatrix self) -> mfem::Operator::Type""" + return _complex_operator.ComplexSparseMatrix_GetType(self) + GetType = _swig_new_instance_method(_complex_operator.ComplexSparseMatrix_GetType) __swig_destroy__ = _complex_operator.delete_ComplexSparseMatrix # Register ComplexSparseMatrix in _complex_operator: diff --git a/mfem/_ser/complex_operator_wrap.cxx b/mfem/_ser/complex_operator_wrap.cxx index eb873973..36ed4eee 100644 --- a/mfem/_ser/complex_operator_wrap.cxx +++ b/mfem/_ser/complex_operator_wrap.cxx @@ -3081,14 +3081,17 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[13] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[14] #define SWIGTYPE_p_mfem__RAPOperator swig_types[15] -#define SWIGTYPE_p_mfem__Solver swig_types[16] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[17] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[18] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[19] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[20] -#define SWIGTYPE_p_mfem__Vector swig_types[21] -static swig_type_info *swig_types[23]; -static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[16] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[17] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[18] +#define SWIGTYPE_p_mfem__Solver swig_types[19] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[20] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[21] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[22] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[23] +#define SWIGTYPE_p_mfem__Vector swig_types[24] +static swig_type_info *swig_types[26]; +static swig_module_info swig_module = {swig_types, 25, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3204,6 +3207,13 @@ SWIGINTERNINLINE PyObject* } +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + SWIGINTERN int SWIG_AsVal_double (PyObject *obj, double *val) { @@ -3428,6 +3438,316 @@ SWIGINTERN PyObject *_wrap_delete_ComplexOperator(PyObject *SWIGUNUSEDPARM(self) } +SWIGINTERN PyObject *_wrap_ComplexOperator_hasRealPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_hasRealPart" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (bool)((mfem::ComplexOperator const *)arg1)->hasRealPart(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_hasImagPart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_hasImagPart" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (bool)((mfem::ComplexOperator const *)arg1)->hasImagPart(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_real__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_real" "', argument " "1"" of type '" "mfem::ComplexOperator *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &(arg1)->real(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_imag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_imag" "', argument " "1"" of type '" "mfem::ComplexOperator *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &(arg1)->imag(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_real__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_real" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &((mfem::ComplexOperator const *)arg1)->real(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_real(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexOperator_real", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_real__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_real__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexOperator_real'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexOperator::real()\n" + " mfem::ComplexOperator::real() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_imag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_imag" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); + { + try { + result = (mfem::Operator *) &((mfem::ComplexOperator const *)arg1)->imag(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_imag(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexOperator_imag", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_imag__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexOperator_imag__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexOperator_imag'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexOperator::imag()\n" + " mfem::ComplexOperator::imag() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; @@ -3523,10 +3843,51 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPAR if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComplexOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ComplexOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexOperator_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator::Type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_GetType" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); { try { - ((mfem::ComplexOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + result = (mfem::Operator::Type)((mfem::ComplexOperator const *)arg1)->GetType(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3543,7 +3904,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; @@ -4119,6 +4480,234 @@ SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix(PyObject *self, PyObject *arg } +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_real" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &(arg1)->real(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_imag__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_imag" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &(arg1)->imag(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_real" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &((mfem::ComplexSparseMatrix const *)arg1)->real(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexSparseMatrix_real", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_real__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_real__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexSparseMatrix_real'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexSparseMatrix::real()\n" + " mfem::ComplexSparseMatrix::real() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_imag__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::SparseMatrix *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_imag" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::SparseMatrix *) &((mfem::ComplexSparseMatrix const *)arg1)->imag(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_imag(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ComplexSparseMatrix_imag", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_imag__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ComplexSparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ComplexSparseMatrix_imag__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ComplexSparseMatrix_imag'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ComplexSparseMatrix::imag()\n" + " mfem::ComplexSparseMatrix::imag() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_GetSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; @@ -4160,6 +4749,47 @@ SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_GetSystemMatrix(PyObject *SWIGUNU } +SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator::Type result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexSparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexSparseMatrix_GetType" "', argument " "1"" of type '" "mfem::ComplexSparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::ComplexSparseMatrix * >(argp1); + { + try { + result = (mfem::Operator::Type)((mfem::ComplexSparseMatrix const *)arg1)->GetType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_ComplexSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; @@ -4213,14 +4843,35 @@ SWIGINTERN PyObject *ComplexSparseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self) static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "delete_ComplexOperator", _wrap_delete_ComplexOperator, METH_O, "delete_ComplexOperator(ComplexOperator self)"}, + { "ComplexOperator_hasRealPart", _wrap_ComplexOperator_hasRealPart, METH_O, "ComplexOperator_hasRealPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_hasImagPart", _wrap_ComplexOperator_hasImagPart, METH_O, "ComplexOperator_hasImagPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_real", _wrap_ComplexOperator_real, METH_VARARGS, "\n" + "ComplexOperator_real(ComplexOperator self) -> Operator\n" + "ComplexOperator_real(ComplexOperator self) -> Operator\n" + ""}, + { "ComplexOperator_imag", _wrap_ComplexOperator_imag, METH_VARARGS, "\n" + "ComplexOperator_imag(ComplexOperator self) -> Operator\n" + "ComplexOperator_imag(ComplexOperator self) -> Operator\n" + ""}, { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "ComplexOperator_Mult(ComplexOperator self, Vector x, Vector y)"}, { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "ComplexOperator_MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "ComplexOperator_GetType(ComplexOperator self) -> mfem::Operator::Type"}, { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" + "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" + "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, + { "ComplexSparseMatrix_imag", _wrap_ComplexSparseMatrix_imag, METH_VARARGS, "\n" + "ComplexSparseMatrix_imag(ComplexSparseMatrix self) -> SparseMatrix\n" + "ComplexSparseMatrix_imag(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, { "ComplexSparseMatrix_GetSystemMatrix", _wrap_ComplexSparseMatrix_GetSystemMatrix, METH_O, "ComplexSparseMatrix_GetSystemMatrix(ComplexSparseMatrix self) -> SparseMatrix"}, + { "ComplexSparseMatrix_GetType", _wrap_ComplexSparseMatrix_GetType, METH_O, "ComplexSparseMatrix_GetType(ComplexSparseMatrix self) -> mfem::Operator::Type"}, { "delete_ComplexSparseMatrix", _wrap_delete_ComplexSparseMatrix, METH_O, "delete_ComplexSparseMatrix(ComplexSparseMatrix self)"}, { "ComplexSparseMatrix_swigregister", ComplexSparseMatrix_swigregister, METH_O, NULL}, { "ComplexSparseMatrix_swiginit", ComplexSparseMatrix_swiginit, METH_VARARGS, NULL}, @@ -4228,6 +4879,39 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "delete_ComplexOperator", _wrap_delete_ComplexOperator, METH_O, "delete_ComplexOperator(ComplexOperator self)"}, + { "ComplexOperator_hasRealPart", _wrap_ComplexOperator_hasRealPart, METH_O, "hasRealPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_hasImagPart", _wrap_ComplexOperator_hasImagPart, METH_O, "hasImagPart(ComplexOperator self) -> bool"}, + { "ComplexOperator_real", _wrap_ComplexOperator_real, METH_VARARGS, "\n" + "real(ComplexOperator self) -> Operator\n" + "real(ComplexOperator self) -> Operator\n" + ""}, + { "ComplexOperator_imag", _wrap_ComplexOperator_imag, METH_VARARGS, "\n" + "imag(ComplexOperator self) -> Operator\n" + "imag(ComplexOperator self) -> Operator\n" + ""}, + { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "Mult(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "GetType(ComplexOperator self) -> mfem::Operator::Type"}, + { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, + { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, + { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, + { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" + "real(ComplexSparseMatrix self) -> SparseMatrix\n" + "real(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, + { "ComplexSparseMatrix_imag", _wrap_ComplexSparseMatrix_imag, METH_VARARGS, "\n" + "imag(ComplexSparseMatrix self) -> SparseMatrix\n" + "imag(ComplexSparseMatrix self) -> SparseMatrix\n" + ""}, + { "ComplexSparseMatrix_GetSystemMatrix", _wrap_ComplexSparseMatrix_GetSystemMatrix, METH_O, "GetSystemMatrix(ComplexSparseMatrix self) -> SparseMatrix"}, + { "ComplexSparseMatrix_GetType", _wrap_ComplexSparseMatrix_GetType, METH_O, "GetType(ComplexSparseMatrix self) -> mfem::Operator::Type"}, + { "delete_ComplexSparseMatrix", _wrap_delete_ComplexSparseMatrix, METH_O, "delete_ComplexSparseMatrix(ComplexSparseMatrix self)"}, + { "ComplexSparseMatrix_swigregister", ComplexSparseMatrix_swigregister, METH_O, NULL}, + { "ComplexSparseMatrix_swiginit", ComplexSparseMatrix_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4249,12 +4933,12 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } @@ -4264,6 +4948,9 @@ static void *_p_mfem__ComplexSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGU static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -4279,9 +4966,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -4301,15 +4994,18 @@ static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -4331,6 +5027,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -4348,17 +5047,20 @@ static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOp static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexSparseMatrix, _p_mfem__ComplexSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexOperator, _p_mfem__ComplexOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexSparseMatrix, _p_mfem__ComplexSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ComplexOperator, _p_mfem__ComplexOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -4379,6 +5081,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_ser/densemat.py b/mfem/_ser/densemat.py index 96bad7dd..4717d807 100644 --- a/mfem/_ser/densemat.py +++ b/mfem/_ser/densemat.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _densemat.SWIG_PyInstanceMethod_New +_swig_new_static_method = _densemat.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -88,22 +91,27 @@ def __init__(self, *args): def UseExternalData(self, d, h, w): r"""UseExternalData(DenseMatrix self, double * d, int h, int w)""" return _densemat.DenseMatrix_UseExternalData(self, d, h, w) + UseExternalData = _swig_new_instance_method(_densemat.DenseMatrix_UseExternalData) def Reset(self, d, h, w): r"""Reset(DenseMatrix self, double * d, int h, int w)""" return _densemat.DenseMatrix_Reset(self, d, h, w) + Reset = _swig_new_instance_method(_densemat.DenseMatrix_Reset) def ClearExternalData(self): r"""ClearExternalData(DenseMatrix self)""" return _densemat.DenseMatrix_ClearExternalData(self) + ClearExternalData = _swig_new_instance_method(_densemat.DenseMatrix_ClearExternalData) def Clear(self): r"""Clear(DenseMatrix self)""" return _densemat.DenseMatrix_Clear(self) + Clear = _swig_new_instance_method(_densemat.DenseMatrix_Clear) def Size(self): r"""Size(DenseMatrix self) -> int""" return _densemat.DenseMatrix_Size(self) + Size = _swig_new_instance_method(_densemat.DenseMatrix_Size) def SetSize(self, *args): r""" @@ -111,18 +119,30 @@ def SetSize(self, *args): SetSize(DenseMatrix self, int h, int w) """ return _densemat.DenseMatrix_SetSize(self, *args) + SetSize = _swig_new_instance_method(_densemat.DenseMatrix_SetSize) def Data(self): r"""Data(DenseMatrix self) -> double *""" return _densemat.DenseMatrix_Data(self) + Data = _swig_new_instance_method(_densemat.DenseMatrix_Data) def GetData(self): r"""GetData(DenseMatrix self) -> double *""" return _densemat.DenseMatrix_GetData(self) + GetData = _swig_new_instance_method(_densemat.DenseMatrix_GetData) + + def GetMemory(self, *args): + r""" + GetMemory(DenseMatrix self) -> mfem::Memory< double > + GetMemory(DenseMatrix self) -> mfem::Memory< double > const & + """ + return _densemat.DenseMatrix_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_densemat.DenseMatrix_GetMemory) def OwnsData(self): r"""OwnsData(DenseMatrix self) -> bool""" return _densemat.DenseMatrix_OwnsData(self) + OwnsData = _swig_new_instance_method(_densemat.DenseMatrix_OwnsData) def __call__(self, *args): r""" @@ -130,14 +150,17 @@ def __call__(self, *args): __call__(DenseMatrix self, int i, int j) -> double const & """ return _densemat.DenseMatrix___call__(self, *args) + __call__ = _swig_new_instance_method(_densemat.DenseMatrix___call__) def __mul__(self, m): r"""__mul__(DenseMatrix self, DenseMatrix m) -> double""" return _densemat.DenseMatrix___mul__(self, m) + __mul__ = _swig_new_instance_method(_densemat.DenseMatrix___mul__) def Trace(self): r"""Trace(DenseMatrix self) -> double""" return _densemat.DenseMatrix_Trace(self) + Trace = _swig_new_instance_method(_densemat.DenseMatrix_Trace) def Elem(self, *args): r""" @@ -145,6 +168,7 @@ def Elem(self, *args): Elem(DenseMatrix self, int i, int j) -> double const & """ return _densemat.DenseMatrix_Elem(self, *args) + Elem = _swig_new_instance_method(_densemat.DenseMatrix_Elem) def Mult(self, *args): r""" @@ -152,6 +176,7 @@ def Mult(self, *args): Mult(DenseMatrix self, Vector x, Vector y) """ return _densemat.DenseMatrix_Mult(self, *args) + Mult = _swig_new_instance_method(_densemat.DenseMatrix_Mult) def MultTranspose(self, *args): r""" @@ -159,46 +184,57 @@ def MultTranspose(self, *args): MultTranspose(DenseMatrix self, Vector x, Vector y) """ return _densemat.DenseMatrix_MultTranspose(self, *args) + MultTranspose = _swig_new_instance_method(_densemat.DenseMatrix_MultTranspose) def AddMult(self, x, y): r"""AddMult(DenseMatrix self, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMult(self, x, y) + AddMult = _swig_new_instance_method(_densemat.DenseMatrix_AddMult) def AddMultTranspose(self, x, y): r"""AddMultTranspose(DenseMatrix self, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMultTranspose(self, x, y) + AddMultTranspose = _swig_new_instance_method(_densemat.DenseMatrix_AddMultTranspose) def AddMult_a(self, a, x, y): r"""AddMult_a(DenseMatrix self, double a, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMult_a(self, a, x, y) + AddMult_a = _swig_new_instance_method(_densemat.DenseMatrix_AddMult_a) def AddMultTranspose_a(self, a, x, y): r"""AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)""" return _densemat.DenseMatrix_AddMultTranspose_a(self, a, x, y) + AddMultTranspose_a = _swig_new_instance_method(_densemat.DenseMatrix_AddMultTranspose_a) def LeftScaling(self, s): r"""LeftScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_LeftScaling(self, s) + LeftScaling = _swig_new_instance_method(_densemat.DenseMatrix_LeftScaling) def InvLeftScaling(self, s): r"""InvLeftScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_InvLeftScaling(self, s) + InvLeftScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvLeftScaling) def RightScaling(self, s): r"""RightScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_RightScaling(self, s) + RightScaling = _swig_new_instance_method(_densemat.DenseMatrix_RightScaling) def InvRightScaling(self, s): r"""InvRightScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_InvRightScaling(self, s) + InvRightScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvRightScaling) def SymmetricScaling(self, s): r"""SymmetricScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_SymmetricScaling(self, s) + SymmetricScaling = _swig_new_instance_method(_densemat.DenseMatrix_SymmetricScaling) def InvSymmetricScaling(self, s): r"""InvSymmetricScaling(DenseMatrix self, Vector s)""" return _densemat.DenseMatrix_InvSymmetricScaling(self, s) + InvSymmetricScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvSymmetricScaling) def InnerProduct(self, *args): r""" @@ -206,26 +242,32 @@ def InnerProduct(self, *args): InnerProduct(DenseMatrix self, Vector x, Vector y) -> double """ return _densemat.DenseMatrix_InnerProduct(self, *args) + InnerProduct = _swig_new_instance_method(_densemat.DenseMatrix_InnerProduct) def Inverse(self): r"""Inverse(DenseMatrix self) -> MatrixInverse""" return _densemat.DenseMatrix_Inverse(self) + Inverse = _swig_new_instance_method(_densemat.DenseMatrix_Inverse) def Invert(self): r"""Invert(DenseMatrix self)""" return _densemat.DenseMatrix_Invert(self) + Invert = _swig_new_instance_method(_densemat.DenseMatrix_Invert) def SquareRootInverse(self): r"""SquareRootInverse(DenseMatrix self)""" return _densemat.DenseMatrix_SquareRootInverse(self) + SquareRootInverse = _swig_new_instance_method(_densemat.DenseMatrix_SquareRootInverse) def Det(self): r"""Det(DenseMatrix self) -> double""" return _densemat.DenseMatrix_Det(self) + Det = _swig_new_instance_method(_densemat.DenseMatrix_Det) def Weight(self): r"""Weight(DenseMatrix self) -> double""" return _densemat.DenseMatrix_Weight(self) + Weight = _swig_new_instance_method(_densemat.DenseMatrix_Weight) def Set(self, *args): r""" @@ -233,10 +275,12 @@ def Set(self, *args): Set(DenseMatrix self, double alpha, DenseMatrix A) """ return _densemat.DenseMatrix_Set(self, *args) + Set = _swig_new_instance_method(_densemat.DenseMatrix_Set) def Add(self, c, A): r"""Add(DenseMatrix self, double const c, DenseMatrix A)""" return _densemat.DenseMatrix_Add(self, c, A) + Add = _swig_new_instance_method(_densemat.DenseMatrix_Add) def __iadd__(self, v): ret = _densmat.DenseMatrix___iadd__(self, v) @@ -265,22 +309,27 @@ def __imul__(self, v): def Neg(self): r"""Neg(DenseMatrix self)""" return _densemat.DenseMatrix_Neg(self) + Neg = _swig_new_instance_method(_densemat.DenseMatrix_Neg) def Norm2(self, v): r"""Norm2(DenseMatrix self, double * v)""" return _densemat.DenseMatrix_Norm2(self, v) + Norm2 = _swig_new_instance_method(_densemat.DenseMatrix_Norm2) def MaxMaxNorm(self): r"""MaxMaxNorm(DenseMatrix self) -> double""" return _densemat.DenseMatrix_MaxMaxNorm(self) + MaxMaxNorm = _swig_new_instance_method(_densemat.DenseMatrix_MaxMaxNorm) def FNorm(self): r"""FNorm(DenseMatrix self) -> double""" return _densemat.DenseMatrix_FNorm(self) + FNorm = _swig_new_instance_method(_densemat.DenseMatrix_FNorm) def FNorm2(self): r"""FNorm2(DenseMatrix self) -> double""" return _densemat.DenseMatrix_FNorm2(self) + FNorm2 = _swig_new_instance_method(_densemat.DenseMatrix_FNorm2) def Eigenvalues(self, *args): r""" @@ -290,6 +339,7 @@ def Eigenvalues(self, *args): Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect) """ return _densemat.DenseMatrix_Eigenvalues(self, *args) + Eigenvalues = _swig_new_instance_method(_densemat.DenseMatrix_Eigenvalues) def Eigensystem(self, *args): r""" @@ -297,26 +347,32 @@ def Eigensystem(self, *args): Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect) """ return _densemat.DenseMatrix_Eigensystem(self, *args) + Eigensystem = _swig_new_instance_method(_densemat.DenseMatrix_Eigensystem) def SingularValues(self, sv): r"""SingularValues(DenseMatrix self, Vector sv)""" return _densemat.DenseMatrix_SingularValues(self, sv) + SingularValues = _swig_new_instance_method(_densemat.DenseMatrix_SingularValues) def Rank(self, tol): r"""Rank(DenseMatrix self, double tol) -> int""" return _densemat.DenseMatrix_Rank(self, tol) + Rank = _swig_new_instance_method(_densemat.DenseMatrix_Rank) def CalcSingularvalue(self, i): r"""CalcSingularvalue(DenseMatrix self, int const i) -> double""" return _densemat.DenseMatrix_CalcSingularvalue(self, i) + CalcSingularvalue = _swig_new_instance_method(_densemat.DenseMatrix_CalcSingularvalue) def CalcEigenvalues(self, _lambda, vec): r"""CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)""" return _densemat.DenseMatrix_CalcEigenvalues(self, _lambda, vec) + CalcEigenvalues = _swig_new_instance_method(_densemat.DenseMatrix_CalcEigenvalues) def GetRow(self, r, row): r"""GetRow(DenseMatrix self, int r, Vector row)""" return _densemat.DenseMatrix_GetRow(self, r, row) + GetRow = _swig_new_instance_method(_densemat.DenseMatrix_GetRow) def GetColumn(self, *args): r""" @@ -325,36 +381,45 @@ def GetColumn(self, *args): GetColumn(DenseMatrix self, int col) -> double const * """ return _densemat.DenseMatrix_GetColumn(self, *args) + GetColumn = _swig_new_instance_method(_densemat.DenseMatrix_GetColumn) def GetColumnReference(self, c, col): r"""GetColumnReference(DenseMatrix self, int c, Vector col)""" return _densemat.DenseMatrix_GetColumnReference(self, c, col) + GetColumnReference = _swig_new_instance_method(_densemat.DenseMatrix_GetColumnReference) def SetRow(self, *args): r""" + SetRow(DenseMatrix self, int r, double const * row) SetRow(DenseMatrix self, int r, Vector row) SetRow(DenseMatrix self, int row, double value) """ return _densemat.DenseMatrix_SetRow(self, *args) + SetRow = _swig_new_instance_method(_densemat.DenseMatrix_SetRow) def SetCol(self, *args): r""" + SetCol(DenseMatrix self, int c, double const * col) SetCol(DenseMatrix self, int c, Vector col) SetCol(DenseMatrix self, int col, double value) """ return _densemat.DenseMatrix_SetCol(self, *args) + SetCol = _swig_new_instance_method(_densemat.DenseMatrix_SetCol) def GetDiag(self, d): r"""GetDiag(DenseMatrix self, Vector d)""" return _densemat.DenseMatrix_GetDiag(self, d) + GetDiag = _swig_new_instance_method(_densemat.DenseMatrix_GetDiag) def Getl1Diag(self, l): r"""Getl1Diag(DenseMatrix self, Vector l)""" return _densemat.DenseMatrix_Getl1Diag(self, l) + Getl1Diag = _swig_new_instance_method(_densemat.DenseMatrix_Getl1Diag) def GetRowSums(self, l): r"""GetRowSums(DenseMatrix self, Vector l)""" return _densemat.DenseMatrix_GetRowSums(self, l) + GetRowSums = _swig_new_instance_method(_densemat.DenseMatrix_GetRowSums) def Diag(self, *args): r""" @@ -362,6 +427,7 @@ def Diag(self, *args): Diag(DenseMatrix self, double * diag, int n) """ return _densemat.DenseMatrix_Diag(self, *args) + Diag = _swig_new_instance_method(_densemat.DenseMatrix_Diag) def Transpose(self, *args): r""" @@ -369,34 +435,42 @@ def Transpose(self, *args): Transpose(DenseMatrix self, DenseMatrix A) """ return _densemat.DenseMatrix_Transpose(self, *args) + Transpose = _swig_new_instance_method(_densemat.DenseMatrix_Transpose) def Symmetrize(self): r"""Symmetrize(DenseMatrix self)""" return _densemat.DenseMatrix_Symmetrize(self) + Symmetrize = _swig_new_instance_method(_densemat.DenseMatrix_Symmetrize) def Lump(self): r"""Lump(DenseMatrix self)""" return _densemat.DenseMatrix_Lump(self) + Lump = _swig_new_instance_method(_densemat.DenseMatrix_Lump) def GradToCurl(self, curl): r"""GradToCurl(DenseMatrix self, DenseMatrix curl)""" return _densemat.DenseMatrix_GradToCurl(self, curl) + GradToCurl = _swig_new_instance_method(_densemat.DenseMatrix_GradToCurl) def GradToDiv(self, div): r"""GradToDiv(DenseMatrix self, Vector div)""" return _densemat.DenseMatrix_GradToDiv(self, div) + GradToDiv = _swig_new_instance_method(_densemat.DenseMatrix_GradToDiv) def CopyRows(self, A, row1, row2): r"""CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)""" return _densemat.DenseMatrix_CopyRows(self, A, row1, row2) + CopyRows = _swig_new_instance_method(_densemat.DenseMatrix_CopyRows) def CopyCols(self, A, col1, col2): r"""CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)""" return _densemat.DenseMatrix_CopyCols(self, A, col1, col2) + CopyCols = _swig_new_instance_method(_densemat.DenseMatrix_CopyCols) def CopyMNt(self, A, row_offset, col_offset): r"""CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)""" return _densemat.DenseMatrix_CopyMNt(self, A, row_offset, col_offset) + CopyMNt = _swig_new_instance_method(_densemat.DenseMatrix_CopyMNt) def CopyMN(self, *args): r""" @@ -405,6 +479,7 @@ def CopyMN(self, *args): CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco, int row_offset, int col_offset) """ return _densemat.DenseMatrix_CopyMN(self, *args) + CopyMN = _swig_new_instance_method(_densemat.DenseMatrix_CopyMN) def CopyMNDiag(self, *args): r""" @@ -412,10 +487,12 @@ def CopyMNDiag(self, *args): CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset) """ return _densemat.DenseMatrix_CopyMNDiag(self, *args) + CopyMNDiag = _swig_new_instance_method(_densemat.DenseMatrix_CopyMNDiag) def CopyExceptMN(self, A, m, n): r"""CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)""" return _densemat.DenseMatrix_CopyExceptMN(self, A, m, n) + CopyExceptMN = _swig_new_instance_method(_densemat.DenseMatrix_CopyExceptMN) def AddMatrix(self, *args): r""" @@ -423,34 +500,72 @@ def AddMatrix(self, *args): AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co) """ return _densemat.DenseMatrix_AddMatrix(self, *args) + AddMatrix = _swig_new_instance_method(_densemat.DenseMatrix_AddMatrix) def AddToVector(self, offset, v): r"""AddToVector(DenseMatrix self, int offset, Vector v)""" return _densemat.DenseMatrix_AddToVector(self, offset, v) + AddToVector = _swig_new_instance_method(_densemat.DenseMatrix_AddToVector) def GetFromVector(self, offset, v): r"""GetFromVector(DenseMatrix self, int offset, Vector v)""" return _densemat.DenseMatrix_GetFromVector(self, offset, v) + GetFromVector = _swig_new_instance_method(_densemat.DenseMatrix_GetFromVector) def AdjustDofDirection(self, dofs): r"""AdjustDofDirection(DenseMatrix self, intArray dofs)""" return _densemat.DenseMatrix_AdjustDofDirection(self, dofs) + AdjustDofDirection = _swig_new_instance_method(_densemat.DenseMatrix_AdjustDofDirection) def Threshold(self, eps): r"""Threshold(DenseMatrix self, double eps)""" return _densemat.DenseMatrix_Threshold(self, eps) + Threshold = _swig_new_instance_method(_densemat.DenseMatrix_Threshold) def CheckFinite(self): r"""CheckFinite(DenseMatrix self) -> int""" return _densemat.DenseMatrix_CheckFinite(self) + CheckFinite = _swig_new_instance_method(_densemat.DenseMatrix_CheckFinite) def TestInversion(self): r"""TestInversion(DenseMatrix self)""" return _densemat.DenseMatrix_TestInversion(self) + TestInversion = _swig_new_instance_method(_densemat.DenseMatrix_TestInversion) def MemoryUsage(self): r"""MemoryUsage(DenseMatrix self) -> long""" return _densemat.DenseMatrix_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_densemat.DenseMatrix_MemoryUsage) + + def Read(self, on_dev=True): + r"""Read(DenseMatrix self, bool on_dev=True) -> double const""" + return _densemat.DenseMatrix_Read(self, on_dev) + Read = _swig_new_instance_method(_densemat.DenseMatrix_Read) + + def HostRead(self): + r"""HostRead(DenseMatrix self) -> double const *""" + return _densemat.DenseMatrix_HostRead(self) + HostRead = _swig_new_instance_method(_densemat.DenseMatrix_HostRead) + + def Write(self, on_dev=True): + r"""Write(DenseMatrix self, bool on_dev=True) -> double""" + return _densemat.DenseMatrix_Write(self, on_dev) + Write = _swig_new_instance_method(_densemat.DenseMatrix_Write) + + def HostWrite(self): + r"""HostWrite(DenseMatrix self) -> double *""" + return _densemat.DenseMatrix_HostWrite(self) + HostWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostWrite) + + def ReadWrite(self, on_dev=True): + r"""ReadWrite(DenseMatrix self, bool on_dev=True) -> double""" + return _densemat.DenseMatrix_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_ReadWrite) + + def HostReadWrite(self): + r"""HostReadWrite(DenseMatrix self) -> double *""" + return _densemat.DenseMatrix_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostReadWrite) __swig_destroy__ = _densemat.delete_DenseMatrix def Assign(self, *args): @@ -496,6 +611,7 @@ def __setitem__(self, *args): def GetDataArray(self): r"""GetDataArray(DenseMatrix self) -> PyObject *""" return _densemat.DenseMatrix_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_densemat.DenseMatrix_GetDataArray) def Print(self, *args): r""" @@ -503,6 +619,7 @@ def Print(self, *args): Print(DenseMatrix self, char const * file, int precision=8) """ return _densemat.DenseMatrix_Print(self, *args) + Print = _swig_new_instance_method(_densemat.DenseMatrix_Print) def PrintT(self, *args): r""" @@ -510,6 +627,7 @@ def PrintT(self, *args): PrintT(DenseMatrix self, char const * file, int precision=8) """ return _densemat.DenseMatrix_PrintT(self, *args) + PrintT = _swig_new_instance_method(_densemat.DenseMatrix_PrintT) def PrintMatlab(self, *args): r""" @@ -517,102 +635,136 @@ def PrintMatlab(self, *args): PrintMatlab(DenseMatrix self, char const * file, int precision=8) """ return _densemat.DenseMatrix_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_densemat.DenseMatrix_PrintMatlab) # Register DenseMatrix in _densemat: _densemat.DenseMatrix_swigregister(DenseMatrix) +def LinearSolve(A, X, TOL=1.e-9): + r"""LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool""" + return _densemat.LinearSolve(A, X, TOL) +LinearSolve = _densemat.LinearSolve + def AddMult(b, c, a): r"""AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)""" return _densemat.AddMult(b, c, a) +AddMult = _densemat.AddMult + +def AddMult_a(alpha, b, c, a): + r"""AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)""" + return _densemat.AddMult_a(alpha, b, c, a) +AddMult_a = _densemat.AddMult_a def CalcAdjugate(a, adja): r"""CalcAdjugate(DenseMatrix a, DenseMatrix adja)""" return _densemat.CalcAdjugate(a, adja) +CalcAdjugate = _densemat.CalcAdjugate def CalcAdjugateTranspose(a, adjat): r"""CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)""" return _densemat.CalcAdjugateTranspose(a, adjat) +CalcAdjugateTranspose = _densemat.CalcAdjugateTranspose def CalcInverse(a, inva): r"""CalcInverse(DenseMatrix a, DenseMatrix inva)""" return _densemat.CalcInverse(a, inva) +CalcInverse = _densemat.CalcInverse def CalcInverseTranspose(a, inva): r"""CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)""" return _densemat.CalcInverseTranspose(a, inva) +CalcInverseTranspose = _densemat.CalcInverseTranspose def CalcOrtho(J, n): r"""CalcOrtho(DenseMatrix J, Vector n)""" return _densemat.CalcOrtho(J, n) +CalcOrtho = _densemat.CalcOrtho def MultAAt(a, aat): r"""MultAAt(DenseMatrix a, DenseMatrix aat)""" return _densemat.MultAAt(a, aat) +MultAAt = _densemat.MultAAt def MultADAt(A, D, ADAt): r"""MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)""" return _densemat.MultADAt(A, D, ADAt) +MultADAt = _densemat.MultADAt def AddMultADAt(A, D, ADAt): r"""AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)""" return _densemat.AddMultADAt(A, D, ADAt) +AddMultADAt = _densemat.AddMultADAt def MultABt(A, B, ABt): r"""MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)""" return _densemat.MultABt(A, B, ABt) +MultABt = _densemat.MultABt def MultADBt(A, D, B, ADBt): r"""MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)""" return _densemat.MultADBt(A, D, B, ADBt) +MultADBt = _densemat.MultADBt def AddMultABt(A, B, ABt): r"""AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)""" return _densemat.AddMultABt(A, B, ABt) +AddMultABt = _densemat.AddMultABt def AddMultADBt(A, D, B, ADBt): r"""AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)""" return _densemat.AddMultADBt(A, D, B, ADBt) +AddMultADBt = _densemat.AddMultADBt def AddMult_a_ABt(a, A, B, ABt): r"""AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)""" return _densemat.AddMult_a_ABt(a, A, B, ABt) +AddMult_a_ABt = _densemat.AddMult_a_ABt def MultAtB(A, B, AtB): r"""MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)""" return _densemat.MultAtB(A, B, AtB) +MultAtB = _densemat.MultAtB def AddMult_a_AAt(a, A, AAt): r"""AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)""" return _densemat.AddMult_a_AAt(a, A, AAt) +AddMult_a_AAt = _densemat.AddMult_a_AAt def Mult_a_AAt(a, A, AAt): r"""Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)""" return _densemat.Mult_a_AAt(a, A, AAt) +Mult_a_AAt = _densemat.Mult_a_AAt def MultVVt(v, vvt): r"""MultVVt(Vector v, DenseMatrix vvt)""" return _densemat.MultVVt(v, vvt) +MultVVt = _densemat.MultVVt def MultVWt(v, w, VWt): r"""MultVWt(Vector v, Vector w, DenseMatrix VWt)""" return _densemat.MultVWt(v, w, VWt) +MultVWt = _densemat.MultVWt def AddMultVWt(v, w, VWt): r"""AddMultVWt(Vector v, Vector w, DenseMatrix VWt)""" return _densemat.AddMultVWt(v, w, VWt) +AddMultVWt = _densemat.AddMultVWt def AddMultVVt(v, VWt): r"""AddMultVVt(Vector v, DenseMatrix VWt)""" return _densemat.AddMultVVt(v, VWt) +AddMultVVt = _densemat.AddMultVVt def AddMult_a_VWt(a, v, w, VWt): r"""AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)""" return _densemat.AddMult_a_VWt(a, v, w, VWt) +AddMult_a_VWt = _densemat.AddMult_a_VWt def AddMult_a_VVt(a, v, VVt): r"""AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)""" return _densemat.AddMult_a_VVt(a, v, VVt) +AddMult_a_VVt = _densemat.AddMult_a_VVt class LUFactors(object): r"""Proxy of C++ mfem::LUFactors class.""" @@ -630,50 +782,66 @@ def __init__(self, *args): """ _densemat.LUFactors_swiginit(self, _densemat.new_LUFactors(*args)) - def Factor(self, m): - r"""Factor(LUFactors self, int m)""" - return _densemat.LUFactors_Factor(self, m) + def Factor(self, m, TOL=0.0): + r"""Factor(LUFactors self, int m, double TOL=0.0) -> bool""" + return _densemat.LUFactors_Factor(self, m, TOL) + Factor = _swig_new_instance_method(_densemat.LUFactors_Factor) def Det(self, m): r"""Det(LUFactors self, int m) -> double""" return _densemat.LUFactors_Det(self, m) + Det = _swig_new_instance_method(_densemat.LUFactors_Det) def Mult(self, m, n, X): r"""Mult(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_Mult(self, m, n, X) + Mult = _swig_new_instance_method(_densemat.LUFactors_Mult) def LSolve(self, m, n, X): r"""LSolve(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_LSolve(self, m, n, X) + LSolve = _swig_new_instance_method(_densemat.LUFactors_LSolve) def USolve(self, m, n, X): r"""USolve(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_USolve(self, m, n, X) + USolve = _swig_new_instance_method(_densemat.LUFactors_USolve) def Solve(self, m, n, X): r"""Solve(LUFactors self, int m, int n, double * X)""" return _densemat.LUFactors_Solve(self, m, n, X) + Solve = _swig_new_instance_method(_densemat.LUFactors_Solve) + + def RightSolve(self, m, n, X): + r"""RightSolve(LUFactors self, int m, int n, double * X)""" + return _densemat.LUFactors_RightSolve(self, m, n, X) + RightSolve = _swig_new_instance_method(_densemat.LUFactors_RightSolve) def GetInverseMatrix(self, m, X): r"""GetInverseMatrix(LUFactors self, int m, double * X)""" return _densemat.LUFactors_GetInverseMatrix(self, m, X) + GetInverseMatrix = _swig_new_instance_method(_densemat.LUFactors_GetInverseMatrix) @staticmethod def SubMult(m, n, r, A21, X1, X2): r"""SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)""" return _densemat.LUFactors_SubMult(m, n, r, A21, X1, X2) + SubMult = _swig_new_static_method(_densemat.LUFactors_SubMult) def BlockFactor(self, m, n, A12, A21, A22): r"""BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)""" return _densemat.LUFactors_BlockFactor(self, m, n, A12, A21, A22) + BlockFactor = _swig_new_instance_method(_densemat.LUFactors_BlockFactor) def BlockForwSolve(self, m, n, r, L21, B1, B2): r"""BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)""" return _densemat.LUFactors_BlockForwSolve(self, m, n, r, L21, B1, B2) + BlockForwSolve = _swig_new_instance_method(_densemat.LUFactors_BlockForwSolve) def BlockBackSolve(self, m, n, r, U12, X2, Y1): r"""BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)""" return _densemat.LUFactors_BlockBackSolve(self, m, n, r, U12, X2, Y1) + BlockBackSolve = _swig_new_instance_method(_densemat.LUFactors_BlockBackSolve) __swig_destroy__ = _densemat.delete_LUFactors # Register LUFactors in _densemat: @@ -682,6 +850,7 @@ def BlockBackSolve(self, m, n, r, U12, X2, Y1): def LUFactors_SubMult(m, n, r, A21, X1, X2): r"""LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)""" return _densemat.LUFactors_SubMult(m, n, r, A21, X1, X2) +LUFactors_SubMult = _densemat.LUFactors_SubMult class DenseMatrixInverse(mfem._ser.matrix.MatrixInverse): r"""Proxy of C++ mfem::DenseMatrixInverse class.""" @@ -700,6 +869,7 @@ def __init__(self, *args): def Size(self): r"""Size(DenseMatrixInverse self) -> int""" return _densemat.DenseMatrixInverse_Size(self) + Size = _swig_new_instance_method(_densemat.DenseMatrixInverse_Size) def Factor(self, *args): r""" @@ -707,10 +877,12 @@ def Factor(self, *args): Factor(DenseMatrixInverse self, DenseMatrix mat) """ return _densemat.DenseMatrixInverse_Factor(self, *args) + Factor = _swig_new_instance_method(_densemat.DenseMatrixInverse_Factor) def SetOperator(self, op): r"""SetOperator(DenseMatrixInverse self, Operator op)""" return _densemat.DenseMatrixInverse_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_densemat.DenseMatrixInverse_SetOperator) def Mult(self, *args): r""" @@ -719,18 +891,22 @@ def Mult(self, *args): Mult(DenseMatrixInverse self, DenseMatrix X) """ return _densemat.DenseMatrixInverse_Mult(self, *args) + Mult = _swig_new_instance_method(_densemat.DenseMatrixInverse_Mult) def GetInverseMatrix(self, Ainv): r"""GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)""" return _densemat.DenseMatrixInverse_GetInverseMatrix(self, Ainv) + GetInverseMatrix = _swig_new_instance_method(_densemat.DenseMatrixInverse_GetInverseMatrix) def Det(self): r"""Det(DenseMatrixInverse self) -> double""" return _densemat.DenseMatrixInverse_Det(self) + Det = _swig_new_instance_method(_densemat.DenseMatrixInverse_Det) def TestInversion(self): r"""TestInversion(DenseMatrixInverse self)""" return _densemat.DenseMatrixInverse_TestInversion(self) + TestInversion = _swig_new_instance_method(_densemat.DenseMatrixInverse_TestInversion) __swig_destroy__ = _densemat.delete_DenseMatrixInverse # Register DenseMatrixInverse in _densemat: @@ -752,22 +928,27 @@ def __init__(self, *args): def Eval(self): r"""Eval(DenseMatrixEigensystem self)""" return _densemat.DenseMatrixEigensystem_Eval(self) + Eval = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eval) def Eigenvalues(self): r"""Eigenvalues(DenseMatrixEigensystem self) -> Vector""" return _densemat.DenseMatrixEigensystem_Eigenvalues(self) + Eigenvalues = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvalues) def Eigenvectors(self): r"""Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix""" return _densemat.DenseMatrixEigensystem_Eigenvectors(self) + Eigenvectors = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvectors) def Eigenvalue(self, i): r"""Eigenvalue(DenseMatrixEigensystem self, int i) -> double""" return _densemat.DenseMatrixEigensystem_Eigenvalue(self, i) + Eigenvalue = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvalue) def Eigenvector(self, i): r"""Eigenvector(DenseMatrixEigensystem self, int i) -> Vector""" return _densemat.DenseMatrixEigensystem_Eigenvector(self, i) + Eigenvector = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvector) __swig_destroy__ = _densemat.delete_DenseMatrixEigensystem # Register DenseMatrixEigensystem in _densemat: @@ -789,14 +970,17 @@ def __init__(self, *args): def Eval(self, M): r"""Eval(DenseMatrixSVD self, DenseMatrix M)""" return _densemat.DenseMatrixSVD_Eval(self, M) + Eval = _swig_new_instance_method(_densemat.DenseMatrixSVD_Eval) def Singularvalues(self): r"""Singularvalues(DenseMatrixSVD self) -> Vector""" return _densemat.DenseMatrixSVD_Singularvalues(self) + Singularvalues = _swig_new_instance_method(_densemat.DenseMatrixSVD_Singularvalues) def Singularvalue(self, i): r"""Singularvalue(DenseMatrixSVD self, int i) -> double""" return _densemat.DenseMatrixSVD_Singularvalue(self, i) + Singularvalue = _swig_new_instance_method(_densemat.DenseMatrixSVD_Singularvalue) __swig_destroy__ = _densemat.delete_DenseMatrixSVD # Register DenseMatrixSVD in _densemat: @@ -819,26 +1003,32 @@ def __init__(self, *args): def SizeI(self): r"""SizeI(DenseTensor self) -> int""" return _densemat.DenseTensor_SizeI(self) + SizeI = _swig_new_instance_method(_densemat.DenseTensor_SizeI) def SizeJ(self): r"""SizeJ(DenseTensor self) -> int""" return _densemat.DenseTensor_SizeJ(self) + SizeJ = _swig_new_instance_method(_densemat.DenseTensor_SizeJ) def SizeK(self): r"""SizeK(DenseTensor self) -> int""" return _densemat.DenseTensor_SizeK(self) + SizeK = _swig_new_instance_method(_densemat.DenseTensor_SizeK) def TotalSize(self): r"""TotalSize(DenseTensor self) -> int""" return _densemat.DenseTensor_TotalSize(self) + TotalSize = _swig_new_instance_method(_densemat.DenseTensor_TotalSize) def SetSize(self, i, j, k): r"""SetSize(DenseTensor self, int i, int j, int k)""" return _densemat.DenseTensor_SetSize(self, i, j, k) + SetSize = _swig_new_instance_method(_densemat.DenseTensor_SetSize) def UseExternalData(self, ext_data, i, j, k): r"""UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)""" return _densemat.DenseTensor_UseExternalData(self, ext_data, i, j, k) + UseExternalData = _swig_new_instance_method(_densemat.DenseTensor_UseExternalData) def __call__(self, *args): r""" @@ -848,10 +1038,12 @@ def __call__(self, *args): __call__(DenseTensor self, int i, int j, int k) -> double const & """ return _densemat.DenseTensor___call__(self, *args) + __call__ = _swig_new_instance_method(_densemat.DenseTensor___call__) def GetData(self, k): r"""GetData(DenseTensor self, int k) -> double *""" return _densemat.DenseTensor_GetData(self, k) + GetData = _swig_new_instance_method(_densemat.DenseTensor_GetData) def Data(self, *args): r""" @@ -859,6 +1051,7 @@ def Data(self, *args): Data(DenseTensor self) -> double const * """ return _densemat.DenseTensor_Data(self, *args) + Data = _swig_new_instance_method(_densemat.DenseTensor_Data) def GetMemory(self, *args): r""" @@ -866,18 +1059,52 @@ def GetMemory(self, *args): GetMemory(DenseTensor self) -> mfem::Memory< double > const & """ return _densemat.DenseTensor_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_densemat.DenseTensor_GetMemory) def AddMult(self, elem_dof, x, y): r"""AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)""" return _densemat.DenseTensor_AddMult(self, elem_dof, x, y) + AddMult = _swig_new_instance_method(_densemat.DenseTensor_AddMult) def Clear(self): r"""Clear(DenseTensor self)""" return _densemat.DenseTensor_Clear(self) + Clear = _swig_new_instance_method(_densemat.DenseTensor_Clear) def MemoryUsage(self): r"""MemoryUsage(DenseTensor self) -> long""" return _densemat.DenseTensor_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_densemat.DenseTensor_MemoryUsage) + + def Read(self, on_dev=True): + r"""Read(DenseTensor self, bool on_dev=True) -> double const""" + return _densemat.DenseTensor_Read(self, on_dev) + Read = _swig_new_instance_method(_densemat.DenseTensor_Read) + + def HostRead(self): + r"""HostRead(DenseTensor self) -> double const *""" + return _densemat.DenseTensor_HostRead(self) + HostRead = _swig_new_instance_method(_densemat.DenseTensor_HostRead) + + def Write(self, on_dev=True): + r"""Write(DenseTensor self, bool on_dev=True) -> double""" + return _densemat.DenseTensor_Write(self, on_dev) + Write = _swig_new_instance_method(_densemat.DenseTensor_Write) + + def HostWrite(self): + r"""HostWrite(DenseTensor self) -> double *""" + return _densemat.DenseTensor_HostWrite(self) + HostWrite = _swig_new_instance_method(_densemat.DenseTensor_HostWrite) + + def ReadWrite(self, on_dev=True): + r"""ReadWrite(DenseTensor self, bool on_dev=True) -> double""" + return _densemat.DenseTensor_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_densemat.DenseTensor_ReadWrite) + + def HostReadWrite(self): + r"""HostReadWrite(DenseTensor self) -> double *""" + return _densemat.DenseTensor_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_densemat.DenseTensor_HostReadWrite) __swig_destroy__ = _densemat.delete_DenseTensor def Assign(self, c): @@ -916,6 +1143,7 @@ def __setitem__(self, *args): def GetDataArray(self): r"""GetDataArray(DenseTensor self) -> PyObject *""" return _densemat.DenseTensor_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_densemat.DenseTensor_GetDataArray) # Register DenseTensor in _densemat: _densemat.DenseTensor_swigregister(DenseTensor) diff --git a/mfem/_ser/densemat_wrap.cxx b/mfem/_ser/densemat_wrap.cxx index fd7747a0..df896a45 100644 --- a/mfem/_ser/densemat_wrap.cxx +++ b/mfem/_ser/densemat_wrap.cxx @@ -3087,15 +3087,18 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[19] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[20] #define SWIGTYPE_p_mfem__RAPOperator swig_types[21] -#define SWIGTYPE_p_mfem__Solver swig_types[22] -#define SWIGTYPE_p_mfem__Table swig_types[23] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[24] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[25] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[26] -#define SWIGTYPE_p_mfem__Vector swig_types[27] -#define SWIGTYPE_p_void swig_types[28] -static swig_type_info *swig_types[30]; -static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[22] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[23] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[24] +#define SWIGTYPE_p_mfem__Solver swig_types[25] +#define SWIGTYPE_p_mfem__Table swig_types[26] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[27] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[28] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[29] +#define SWIGTYPE_p_mfem__Vector swig_types[30] +#define SWIGTYPE_p_void swig_types[31] +static swig_type_info *swig_types[33]; +static swig_module_info swig_module = {swig_types, 32, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3525,6 +3528,20 @@ SWIGINTERNINLINE PyObject* #define SWIG_From_long PyInt_FromLong + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + SWIGINTERN void mfem_DenseMatrix_Assign__SWIG_0(mfem::DenseMatrix *self,double const v){ (* self) = v; } @@ -4499,6 +4516,120 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetData(PyObject *SWIGUNUSEDPARM(self), P } +SWIGINTERN PyObject *_wrap_DenseMatrix_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetMemory" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &(arg1)->GetMemory(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetMemory" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &((mfem::DenseMatrix const *)arg1)->GetMemory(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_GetMemory(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_GetMemory", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_GetMemory__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_GetMemory__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_GetMemory'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::GetMemory()\n" + " mfem::DenseMatrix::GetMemory() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_DenseMatrix_OwnsData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; @@ -8018,6 +8149,59 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SetRow" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_SetRow" "', argument " "3"" of type '" "double const *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + { + try { + (arg1)->SetRow(arg2,(double const *)arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -8074,6 +8258,59 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + double *arg3 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SetCol" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_SetCol" "', argument " "3"" of type '" "double const *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + { + try { + (arg1)->SetCol(arg2,(double const *)arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -8129,7 +8366,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -8205,7 +8442,8 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_DenseMatrix_SetRow__SWIG_0(self, argc, argv); @@ -8213,6 +8451,29 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { } } } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_SetRow__SWIG_1(self, argc, argv); + } + } + } + } if (argc == 3) { int _v; void *vptr = 0; @@ -8233,7 +8494,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DenseMatrix_SetRow__SWIG_1(self, argc, argv); + return _wrap_DenseMatrix_SetRow__SWIG_2(self, argc, argv); } } } @@ -8242,13 +8503,14 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetRow(PyObject *self, PyObject *args) { fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_SetRow'.\n" " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::SetRow(int,double const *)\n" " mfem::DenseMatrix::SetRow(int,mfem::Vector const &)\n" " mfem::DenseMatrix::SetRow(int,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -8324,7 +8586,8 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { return _wrap_DenseMatrix_SetCol__SWIG_0(self, argc, argv); @@ -8347,22 +8610,46 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { } } if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { return _wrap_DenseMatrix_SetCol__SWIG_1(self, argc, argv); } } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_SetCol'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::SetCol(int,mfem::Vector const &)\n" - " mfem::DenseMatrix::SetCol(int,double)\n"); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseMatrix_SetCol__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_SetCol'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::SetCol(int,double const *)\n" + " mfem::DenseMatrix::SetCol(int,mfem::Vector const &)\n" + " mfem::DenseMatrix::SetCol(int,double)\n"); return 0; } @@ -10919,23 +11206,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_delete_DenseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DenseMatrix" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - delete arg1; + result = (double *)((mfem::DenseMatrix const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10952,36 +11246,29 @@ SWIGINTERN PyObject *_wrap_delete_DenseMatrix(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); { try { - mfem_DenseMatrix_Assign__SWIG_0(arg1,arg2); + result = (double *)((mfem::DenseMatrix const *)arg1)->Read(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10998,39 +11285,120 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Read", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_Read__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseMatrix_Read__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Read'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::Read(bool) const\n" + " mfem::DenseMatrix::Read() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostRead" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + { + try { + result = (double *)((mfem::DenseMatrix const *)arg1)->HostRead(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - mfem_DenseMatrix_Assign__SWIG_1(arg1,(mfem::DenseMatrix const &)*arg2); + result = (double *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11047,30 +11415,29 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - PyObject *arg2 = (PyObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - arg2 = swig_obj[1]; { try { - mfem_DenseMatrix_Assign__SWIG_2(arg1,arg2); + result = (double *)(arg1)->Write(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11087,32 +11454,28 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Write(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Assign", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Write", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Assign__SWIG_1(self, argc, argv); - } + return _wrap_DenseMatrix_Write__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -11122,68 +11485,42 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_double(argv[1], NULL); + int res = SWIG_AsVal_bool(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DenseMatrix_Assign__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - _v = (argv[1] != 0); - if (_v) { - return _wrap_DenseMatrix_Assign__SWIG_2(self, argc, argv); + return _wrap_DenseMatrix_Write__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Assign'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Write'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::Assign(double const)\n" - " mfem::DenseMatrix::Assign(mfem::DenseMatrix const &)\n" - " mfem::DenseMatrix::Assign(PyObject *)\n"); + " mfem::DenseMatrix::Write(bool)\n" + " mfem::DenseMatrix::Write()\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; - double result; + PyObject *swig_obj[1] ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___getitem__", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___getitem__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (double)mfem_DenseMatrix___getitem__((mfem::DenseMatrix const *)arg1,arg2,arg3); + result = (double *)(arg1)->HostWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11200,51 +11537,37 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - int arg2 ; - int arg3 ; - double arg4 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - PyObject *swig_obj[4] ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___setitem__", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___setitem__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DenseMatrix___setitem__" "', argument " "4"" of type '" "double""'"); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_ReadWrite" "', argument " "2"" of type '" "bool""'"); } - arg4 = static_cast< double >(val4); + arg2 = static_cast< bool >(val2); { try { - mfem_DenseMatrix___setitem__(arg1,arg2,arg3,arg4); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11261,31 +11584,29 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - PyObject *result = 0 ; + double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetDataArray" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { try { - result = (PyObject *)mfem_DenseMatrix_GetDataArray((mfem::DenseMatrix const *)arg1); + result = (double *)(arg1)->ReadWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11302,7 +11623,480 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = result; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_ReadWrite", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_ReadWrite__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseMatrix_ReadWrite__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_ReadWrite'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::ReadWrite(bool)\n" + " mfem::DenseMatrix::ReadWrite()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->HostReadWrite(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_DenseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DenseMatrix" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + mfem_DenseMatrix_Assign__SWIG_0(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_Assign" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + { + try { + mfem_DenseMatrix_Assign__SWIG_1(arg1,(mfem::DenseMatrix const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + PyObject *arg2 = (PyObject *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Assign" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + arg2 = swig_obj[1]; + { + try { + mfem_DenseMatrix_Assign__SWIG_2(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Assign", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseMatrix_Assign__SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseMatrix_Assign__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + _v = (argv[1] != 0); + if (_v) { + return _wrap_DenseMatrix_Assign__SWIG_2(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Assign'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::Assign(double const)\n" + " mfem::DenseMatrix::Assign(mfem::DenseMatrix const &)\n" + " mfem::DenseMatrix::Assign(PyObject *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[3] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___getitem__", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___getitem__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + result = (double)mfem_DenseMatrix___getitem__((mfem::DenseMatrix const *)arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + int arg2 ; + int arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___setitem__", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___setitem__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DenseMatrix___setitem__" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + mfem_DenseMatrix___setitem__(arg1,arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetDataArray" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + { + try { + result = (PyObject *)mfem_DenseMatrix_GetDataArray((mfem::DenseMatrix const *)arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = result; return resultobj; fail: return NULL; @@ -11912,46 +12706,206 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_DenseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintMatlab'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::PrintMatlab(std::ostream &) const\n" + " mfem::DenseMatrix::PrintMatlab() const\n" + " mfem::DenseMatrix::PrintMatlab(char const *,int)\n" + " mfem::DenseMatrix::PrintMatlab(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *DenseMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DenseMatrix, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DenseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = 0 ; + double *arg2 = (double *) 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearSolve" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + result = (bool)mfem::LinearSolve(*arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = 0 ; + double *arg2 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (bool)mfem::LinearSolve(*arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LinearSolve(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "LinearSolve", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_LinearSolve__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); } if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_LinearSolve__SWIG_0(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintMatlab'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearSolve'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::DenseMatrix::PrintMatlab() const\n" - " mfem::DenseMatrix::PrintMatlab(char const *,int)\n" - " mfem::DenseMatrix::PrintMatlab(char const *)\n"); + " mfem::LinearSolve(mfem::DenseMatrix &,double *,double)\n" + " mfem::LinearSolve(mfem::DenseMatrix &,double *)\n"); return 0; } -SWIGINTERN PyObject *DenseMatrix_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DenseMatrix, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DenseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; @@ -12016,6 +12970,78 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } +SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double arg1 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + double val1 ; + int ecode1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "AddMult_a", 4, 4, swig_obj)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + mfem::AddMult_a(arg1,(mfem::DenseMatrix const &)*arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; @@ -13582,15 +14608,18 @@ SWIGINTERN PyObject *_wrap_new_LUFactors(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + double val3 ; + int ecode3 = 0 ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Factor", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); @@ -13602,9 +14631,14 @@ SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyOb }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LUFactors_Factor" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - (arg1)->Factor(arg2); + result = (bool)(arg1)->Factor(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13621,13 +14655,121 @@ SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); + } + arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (bool)(arg1)->Factor(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } +SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "LUFactors_Factor", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_LUFactors_Factor__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_LUFactors_Factor__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LUFactors_Factor'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::LUFactors::Factor(int,double)\n" + " mfem::LUFactors::Factor(int)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; @@ -13919,6 +15061,67 @@ SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObj } +SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; + int arg2 ; + int arg3 ; + double *arg4 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "LUFactors_RightSolve", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_RightSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); + } + arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_RightSolve" "', argument " "4"" of type '" "double *""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + { + try { + ((mfem::LUFactors const *)arg1)->RightSolve(arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; @@ -16091,10 +17294,266 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SizeJ(PyObject *SWIGUNUSEDPARM(self), PyO if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_SizeJ" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } - arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (int)((mfem::DenseTensor const *)arg1)->SizeJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_SizeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_SizeK" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (int)((mfem::DenseTensor const *)arg1)->SizeK(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_TotalSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_TotalSize" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (int)((mfem::DenseTensor const *)arg1)->TotalSize(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "DenseTensor_SetSize", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_SetSize" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->SetSize(arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + double *arg2 = (double *) 0 ; + int arg3 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "DenseTensor_UseExternalData", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_UseExternalData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_UseExternalData" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + (arg1)->UseExternalData(arg2,arg3,arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::DenseMatrix *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (int)((mfem::DenseTensor const *)arg1)->SizeJ(); + result = (mfem::DenseMatrix *) &(arg1)->operator ()(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16111,31 +17570,36 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SizeJ(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_SizeK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + mfem::DenseMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_SizeK" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (int)((mfem::DenseTensor const *)arg1)->SizeK(); + result = (mfem::DenseMatrix *) &((mfem::DenseTensor const *)arg1)->operator ()(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16152,31 +17616,50 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SizeK(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_TotalSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + int arg2 ; + int arg3 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_TotalSize" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } { try { - result = (int)((mfem::DenseTensor const *)arg1)->TotalSize(); + result = (double *) &(arg1)->operator ()(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16193,14 +17676,14 @@ SWIGINTERN PyObject *_wrap_DenseTensor_TotalSize(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; int arg2 ; @@ -16208,12 +17691,12 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), P int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[4] ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_SetSize", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_SetSize" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { @@ -16236,7 +17719,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), P } { try { - (arg1)->SetSize(arg2,arg3,arg4); + result = (double *) &((mfem::DenseTensor const *)arg1)->operator ()(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16253,58 +17736,173 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor___call__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor___call__", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_DenseTensor___call____SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_DenseTensor___call____SWIG_1(self, argc, argv); + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_DenseTensor___call____SWIG_2(self, argc, argv); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_DenseTensor___call____SWIG_3(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor___call__'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::operator ()(int)\n" + " mfem::DenseTensor::operator ()(int) const\n" + " mfem::DenseTensor::operator ()(int,int,int)\n" + " mfem::DenseTensor::operator ()(int,int,int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - double *arg2 = (double *) 0 ; - int arg3 ; - int arg4 ; - int arg5 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[2] ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_UseExternalData", 5, 5, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "DenseTensor_GetData", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_UseExternalData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_UseExternalData" "', argument " "2"" of type '" "double *""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - (arg1)->UseExternalData(arg2,arg3,arg4,arg5); + result = (double *)(arg1)->GetData(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16321,36 +17919,29 @@ SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DenseMatrix *result = 0 ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::DenseMatrix *) &(arg1)->operator ()(arg2); + result = (double *)(arg1)->Data(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16367,36 +17958,29 @@ SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::DenseMatrix *result = 0 ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::DenseMatrix *) &((mfem::DenseTensor const *)arg1)->operator ()(arg2); + result = (double *)((mfem::DenseTensor const *)arg1)->Data(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16413,50 +17997,65 @@ SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Data(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Data", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_Data__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_Data__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Data'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::Data()\n" + " mfem::DenseTensor::Data() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - int arg2 ; - int arg3 ; - int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + mfem::Memory< double > *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { try { - result = (double *) &(arg1)->operator ()(arg2,arg3,arg4); + result = (mfem::Memory< double > *) &(arg1)->GetMemory(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16473,50 +18072,29 @@ SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_2(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - int arg2 ; - int arg3 ; - int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + mfem::Memory< double > *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___call__" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { try { - result = (double *) &((mfem::DenseTensor const *)arg1)->operator ()(arg2,arg3,arg4); + result = (mfem::Memory< double > *) &((mfem::DenseTensor const *)arg1)->GetMemory(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16533,173 +18111,179 @@ SWIGINTERN PyObject *_wrap_DenseTensor___call____SWIG_3(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(*result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor___call__(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor___call__", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_GetMemory", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DenseTensor___call____SWIG_0(self, argc, argv); - } + return _wrap_DenseTensor_GetMemory__SWIG_0(self, argc, argv); } } - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DenseTensor___call____SWIG_1(self, argc, argv); - } + return _wrap_DenseTensor_GetMemory__SWIG_1(self, argc, argv); } } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DenseTensor___call____SWIG_2(self, argc, argv); - } - } - } - } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_GetMemory'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::GetMemory()\n" + " mfem::DenseTensor::GetMemory() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + mfem::Table *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "DenseTensor_AddMult", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_AddMult" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + arg2 = reinterpret_cast< mfem::Table * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DenseTensor___call____SWIG_3(self, argc, argv); - } - } - } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::DenseTensor const *)arg1)->AddMult((mfem::Table const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor___call__'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::operator ()(int)\n" - " mfem::DenseTensor::operator ()(int) const\n" - " mfem::DenseTensor::operator ()(int,int,int)\n" - " mfem::DenseTensor::operator ()(int,int,int) const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - double *result = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_GetData", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Clear" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + (arg1)->Clear(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + long result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_MemoryUsage" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)(arg1)->GetData(arg2); + result = (long)((mfem::DenseTensor const *)arg1)->MemoryUsage(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16716,29 +18300,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - result = (double *)(arg1)->Data(); + result = (double *)((mfem::DenseTensor const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16762,7 +18354,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; @@ -16772,12 +18364,12 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(sel if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Data" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)((mfem::DenseTensor const *)arg1)->Data(); + result = (double *)((mfem::DenseTensor const *)arg1)->Read(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16801,13 +18393,13 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseTensor_Data(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_Read(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Data", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Read", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) { int _v; @@ -16815,44 +18407,52 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Data(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_Data__SWIG_0(self, argc, argv); + return _wrap_DenseTensor_Read__SWIG_1(self, argc, argv); } } - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_Data__SWIG_1(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseTensor_Read__SWIG_0(self, argc, argv); + } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Data'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Read'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::Data()\n" - " mfem::DenseTensor::Data() const\n"); + " mfem::DenseTensor::Read(bool) const\n" + " mfem::DenseTensor::Read() const\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< double > *result = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_HostRead" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (mfem::Memory< double > *) &(arg1)->GetMemory(); + result = (double *)((mfem::DenseTensor const *)arg1)->HostRead(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16869,29 +18469,76 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< double > *result = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)(arg1)->Write(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetMemory" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (mfem::Memory< double > *) &((mfem::DenseTensor const *)arg1)->GetMemory(); + result = (double *)(arg1)->Write(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16908,20 +18555,20 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_Write(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[2] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_GetMemory", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Write", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) { int _v; @@ -16929,77 +18576,99 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_GetMemory__SWIG_0(self, argc, argv); + return _wrap_DenseTensor_Write__SWIG_1(self, argc, argv); } } - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_DenseTensor_GetMemory__SWIG_1(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseTensor_Write__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Write'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::Write(bool)\n" + " mfem::DenseTensor::Write()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_HostWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + } + arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); + { + try { + result = (double *)(arg1)->HostWrite(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_GetMemory'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::GetMemory()\n" - " mfem::DenseTensor::GetMemory() const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - mfem::Table *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_AddMult", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_AddMult" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - ((mfem::DenseTensor const *)arg1)->AddMult((mfem::Table const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17016,30 +18685,29 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Clear" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - (arg1)->Clear(); + result = (double *)(arg1)->ReadWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17056,31 +18724,73 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Clear(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_ReadWrite", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_DenseTensor_ReadWrite__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_DenseTensor_ReadWrite__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_ReadWrite'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseTensor::ReadWrite(bool)\n" + " mfem::DenseTensor::ReadWrite()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_DenseTensor_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - long result; + double *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_MemoryUsage" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_HostReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (long)((mfem::DenseTensor const *)arg1)->MemoryUsage(); + result = (double *)(arg1)->HostReadWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17097,7 +18807,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_long(static_cast< long >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; @@ -17495,6 +19205,7 @@ SWIGINTERN PyObject *DenseTensor_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_DenseMatrix", _wrap_new_DenseMatrix, METH_VARARGS, "\n" "DenseMatrix()\n" "DenseMatrix(DenseMatrix arg1)\n" @@ -17514,6 +19225,10 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_Data", _wrap_DenseMatrix_Data, METH_O, "DenseMatrix_Data(DenseMatrix self) -> double *"}, { "DenseMatrix_GetData", _wrap_DenseMatrix_GetData, METH_O, "DenseMatrix_GetData(DenseMatrix self) -> double *"}, + { "DenseMatrix_GetMemory", _wrap_DenseMatrix_GetMemory, METH_VARARGS, "\n" + "DenseMatrix_GetMemory(DenseMatrix self) -> mfem::Memory< double >\n" + "DenseMatrix_GetMemory(DenseMatrix self) -> mfem::Memory< double > const &\n" + ""}, { "DenseMatrix_OwnsData", _wrap_DenseMatrix_OwnsData, METH_O, "DenseMatrix_OwnsData(DenseMatrix self) -> bool"}, { "DenseMatrix___call__", _wrap_DenseMatrix___call__, METH_VARARGS, "\n" "DenseMatrix___call__(DenseMatrix self, int i, int j) -> double\n" @@ -17590,10 +19305,12 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "DenseMatrix_GetColumnReference(DenseMatrix self, int c, Vector col)"}, { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" + "DenseMatrix_SetRow(DenseMatrix self, int r, double const * row)\n" "DenseMatrix_SetRow(DenseMatrix self, int r, Vector row)\n" "DenseMatrix_SetRow(DenseMatrix self, int row, double value)\n" ""}, { "DenseMatrix_SetCol", _wrap_DenseMatrix_SetCol, METH_VARARGS, "\n" + "DenseMatrix_SetCol(DenseMatrix self, int c, double const * col)\n" "DenseMatrix_SetCol(DenseMatrix self, int c, Vector col)\n" "DenseMatrix_SetCol(DenseMatrix self, int col, double value)\n" ""}, @@ -17636,6 +19353,12 @@ static PyMethodDef SwigMethods[] = { { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "DenseMatrix_CheckFinite(DenseMatrix self) -> int"}, { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "DenseMatrix_TestInversion(DenseMatrix self)"}, { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "DenseMatrix_MemoryUsage(DenseMatrix self) -> long"}, + { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "DenseMatrix_Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "DenseMatrix_HostRead(DenseMatrix self) -> double const *"}, + { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "DenseMatrix_Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "DenseMatrix_HostWrite(DenseMatrix self) -> double *"}, + { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "DenseMatrix_ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "DenseMatrix_HostReadWrite(DenseMatrix self) -> double *"}, { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" "DenseMatrix_Assign(DenseMatrix self, double const v)\n" @@ -17659,7 +19382,9 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, + { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, @@ -17690,12 +19415,13 @@ static PyMethodDef SwigMethods[] = { "LUFactors()\n" "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" ""}, - { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "LUFactors_Factor(LUFactors self, int m)"}, + { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "LUFactors_Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "LUFactors_Det(LUFactors self, int m) -> double"}, { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "LUFactors_Mult(LUFactors self, int m, int n, double * X)"}, { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LUFactors_LSolve(LUFactors self, int m, int n, double * X)"}, { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "LUFactors_USolve(LUFactors self, int m, int n, double * X)"}, { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "LUFactors_Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "LUFactors_RightSolve(LUFactors self, int m, int n, double * X)"}, { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "LUFactors_GetInverseMatrix(LUFactors self, int m, double * X)"}, { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "LUFactors_BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, @@ -17777,6 +19503,12 @@ static PyMethodDef SwigMethods[] = { { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "DenseTensor_AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "DenseTensor_Clear(DenseTensor self)"}, { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "DenseTensor_MemoryUsage(DenseTensor self) -> long"}, + { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "DenseTensor_Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "DenseTensor_HostRead(DenseTensor self) -> double const *"}, + { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "DenseTensor_Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "DenseTensor_HostWrite(DenseTensor self) -> double *"}, + { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "DenseTensor_ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "DenseTensor_HostReadWrite(DenseTensor self) -> double *"}, { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "DenseTensor_Assign(DenseTensor self, double const c)"}, { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" @@ -17791,6 +19523,321 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_DenseMatrix", _wrap_new_DenseMatrix, METH_VARARGS, "\n" + "DenseMatrix()\n" + "DenseMatrix(DenseMatrix arg1)\n" + "DenseMatrix(int s)\n" + "DenseMatrix(int m, int n)\n" + "DenseMatrix(DenseMatrix mat, char ch)\n" + "new_DenseMatrix(double * d, int h, int w) -> DenseMatrix\n" + ""}, + { "DenseMatrix_UseExternalData", _wrap_DenseMatrix_UseExternalData, METH_VARARGS, "UseExternalData(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_Reset", _wrap_DenseMatrix_Reset, METH_VARARGS, "Reset(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_ClearExternalData", _wrap_DenseMatrix_ClearExternalData, METH_O, "ClearExternalData(DenseMatrix self)"}, + { "DenseMatrix_Clear", _wrap_DenseMatrix_Clear, METH_O, "Clear(DenseMatrix self)"}, + { "DenseMatrix_Size", _wrap_DenseMatrix_Size, METH_O, "Size(DenseMatrix self) -> int"}, + { "DenseMatrix_SetSize", _wrap_DenseMatrix_SetSize, METH_VARARGS, "\n" + "SetSize(DenseMatrix self, int s)\n" + "SetSize(DenseMatrix self, int h, int w)\n" + ""}, + { "DenseMatrix_Data", _wrap_DenseMatrix_Data, METH_O, "Data(DenseMatrix self) -> double *"}, + { "DenseMatrix_GetData", _wrap_DenseMatrix_GetData, METH_O, "GetData(DenseMatrix self) -> double *"}, + { "DenseMatrix_GetMemory", _wrap_DenseMatrix_GetMemory, METH_VARARGS, "\n" + "GetMemory(DenseMatrix self) -> mfem::Memory< double >\n" + "GetMemory(DenseMatrix self) -> mfem::Memory< double > const &\n" + ""}, + { "DenseMatrix_OwnsData", _wrap_DenseMatrix_OwnsData, METH_O, "OwnsData(DenseMatrix self) -> bool"}, + { "DenseMatrix___call__", _wrap_DenseMatrix___call__, METH_VARARGS, "\n" + "__call__(DenseMatrix self, int i, int j) -> double\n" + "__call__(DenseMatrix self, int i, int j) -> double const &\n" + ""}, + { "DenseMatrix___mul__", _wrap_DenseMatrix___mul__, METH_VARARGS, "__mul__(DenseMatrix self, DenseMatrix m) -> double"}, + { "DenseMatrix_Trace", _wrap_DenseMatrix_Trace, METH_O, "Trace(DenseMatrix self) -> double"}, + { "DenseMatrix_Elem", _wrap_DenseMatrix_Elem, METH_VARARGS, "\n" + "Elem(DenseMatrix self, int i, int j) -> double\n" + "Elem(DenseMatrix self, int i, int j) -> double const &\n" + ""}, + { "DenseMatrix_Mult", _wrap_DenseMatrix_Mult, METH_VARARGS, "\n" + "Mult(DenseMatrix self, double const * x, double * y)\n" + "Mult(DenseMatrix self, Vector x, Vector y)\n" + ""}, + { "DenseMatrix_MultTranspose", _wrap_DenseMatrix_MultTranspose, METH_VARARGS, "\n" + "MultTranspose(DenseMatrix self, double const * x, double * y)\n" + "MultTranspose(DenseMatrix self, Vector x, Vector y)\n" + ""}, + { "DenseMatrix_AddMult", _wrap_DenseMatrix_AddMult, METH_VARARGS, "AddMult(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose", _wrap_DenseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMult_a", _wrap_DenseMatrix_AddMult_a, METH_VARARGS, "AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose_a", _wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS, "AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_LeftScaling", _wrap_DenseMatrix_LeftScaling, METH_VARARGS, "LeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvLeftScaling", _wrap_DenseMatrix_InvLeftScaling, METH_VARARGS, "InvLeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_RightScaling", _wrap_DenseMatrix_RightScaling, METH_VARARGS, "RightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvRightScaling", _wrap_DenseMatrix_InvRightScaling, METH_VARARGS, "InvRightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_SymmetricScaling", _wrap_DenseMatrix_SymmetricScaling, METH_VARARGS, "SymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvSymmetricScaling", _wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS, "InvSymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InnerProduct", _wrap_DenseMatrix_InnerProduct, METH_VARARGS, "\n" + "InnerProduct(DenseMatrix self, double const * x, double const * y) -> double\n" + "InnerProduct(DenseMatrix self, Vector x, Vector y) -> double\n" + ""}, + { "DenseMatrix_Inverse", _wrap_DenseMatrix_Inverse, METH_O, "Inverse(DenseMatrix self) -> MatrixInverse"}, + { "DenseMatrix_Invert", _wrap_DenseMatrix_Invert, METH_O, "Invert(DenseMatrix self)"}, + { "DenseMatrix_SquareRootInverse", _wrap_DenseMatrix_SquareRootInverse, METH_O, "SquareRootInverse(DenseMatrix self)"}, + { "DenseMatrix_Det", _wrap_DenseMatrix_Det, METH_O, "Det(DenseMatrix self) -> double"}, + { "DenseMatrix_Weight", _wrap_DenseMatrix_Weight, METH_O, "Weight(DenseMatrix self) -> double"}, + { "DenseMatrix_Set", _wrap_DenseMatrix_Set, METH_VARARGS, "\n" + "Set(DenseMatrix self, double alpha, double const * A)\n" + "Set(DenseMatrix self, double alpha, DenseMatrix A)\n" + ""}, + { "DenseMatrix_Add", _wrap_DenseMatrix_Add, METH_VARARGS, "Add(DenseMatrix self, double const c, DenseMatrix A)"}, + { "DenseMatrix___iadd__", _wrap_DenseMatrix___iadd__, METH_VARARGS, "\n" + "__iadd__(DenseMatrix self, double const * m) -> DenseMatrix\n" + "__iadd__(DenseMatrix self, DenseMatrix m) -> DenseMatrix\n" + ""}, + { "DenseMatrix___isub__", _wrap_DenseMatrix___isub__, METH_VARARGS, "__isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, + { "DenseMatrix___imul__", _wrap_DenseMatrix___imul__, METH_VARARGS, "__imul__(DenseMatrix self, double c) -> DenseMatrix"}, + { "DenseMatrix_Neg", _wrap_DenseMatrix_Neg, METH_O, "Neg(DenseMatrix self)"}, + { "DenseMatrix_Norm2", _wrap_DenseMatrix_Norm2, METH_VARARGS, "Norm2(DenseMatrix self, double * v)"}, + { "DenseMatrix_MaxMaxNorm", _wrap_DenseMatrix_MaxMaxNorm, METH_O, "MaxMaxNorm(DenseMatrix self) -> double"}, + { "DenseMatrix_FNorm", _wrap_DenseMatrix_FNorm, METH_O, "FNorm(DenseMatrix self) -> double"}, + { "DenseMatrix_FNorm2", _wrap_DenseMatrix_FNorm2, METH_O, "FNorm2(DenseMatrix self) -> double"}, + { "DenseMatrix_Eigenvalues", _wrap_DenseMatrix_Eigenvalues, METH_VARARGS, "\n" + "Eigenvalues(DenseMatrix self, Vector ev)\n" + "Eigenvalues(DenseMatrix self, Vector ev, DenseMatrix evect)\n" + "Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev)\n" + "Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" + ""}, + { "DenseMatrix_Eigensystem", _wrap_DenseMatrix_Eigensystem, METH_VARARGS, "\n" + "Eigensystem(DenseMatrix self, Vector ev, DenseMatrix evect)\n" + "Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" + ""}, + { "DenseMatrix_SingularValues", _wrap_DenseMatrix_SingularValues, METH_VARARGS, "SingularValues(DenseMatrix self, Vector sv)"}, + { "DenseMatrix_Rank", _wrap_DenseMatrix_Rank, METH_VARARGS, "Rank(DenseMatrix self, double tol) -> int"}, + { "DenseMatrix_CalcSingularvalue", _wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS, "CalcSingularvalue(DenseMatrix self, int const i) -> double"}, + { "DenseMatrix_CalcEigenvalues", _wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS, "CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, + { "DenseMatrix_GetRow", _wrap_DenseMatrix_GetRow, METH_VARARGS, "GetRow(DenseMatrix self, int r, Vector row)"}, + { "DenseMatrix_GetColumn", _wrap_DenseMatrix_GetColumn, METH_VARARGS, "\n" + "GetColumn(DenseMatrix self, int c, Vector col)\n" + "GetColumn(DenseMatrix self, int col) -> double\n" + "GetColumn(DenseMatrix self, int col) -> double const *\n" + ""}, + { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "GetColumnReference(DenseMatrix self, int c, Vector col)"}, + { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" + "SetRow(DenseMatrix self, int r, double const * row)\n" + "SetRow(DenseMatrix self, int r, Vector row)\n" + "SetRow(DenseMatrix self, int row, double value)\n" + ""}, + { "DenseMatrix_SetCol", _wrap_DenseMatrix_SetCol, METH_VARARGS, "\n" + "SetCol(DenseMatrix self, int c, double const * col)\n" + "SetCol(DenseMatrix self, int c, Vector col)\n" + "SetCol(DenseMatrix self, int col, double value)\n" + ""}, + { "DenseMatrix_GetDiag", _wrap_DenseMatrix_GetDiag, METH_VARARGS, "GetDiag(DenseMatrix self, Vector d)"}, + { "DenseMatrix_Getl1Diag", _wrap_DenseMatrix_Getl1Diag, METH_VARARGS, "Getl1Diag(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetRowSums", _wrap_DenseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(DenseMatrix self, Vector l)"}, + { "DenseMatrix_Diag", _wrap_DenseMatrix_Diag, METH_VARARGS, "\n" + "Diag(DenseMatrix self, double c, int n)\n" + "Diag(DenseMatrix self, double * diag, int n)\n" + ""}, + { "DenseMatrix_Transpose", _wrap_DenseMatrix_Transpose, METH_VARARGS, "\n" + "Transpose(DenseMatrix self)\n" + "Transpose(DenseMatrix self, DenseMatrix A)\n" + ""}, + { "DenseMatrix_Symmetrize", _wrap_DenseMatrix_Symmetrize, METH_O, "Symmetrize(DenseMatrix self)"}, + { "DenseMatrix_Lump", _wrap_DenseMatrix_Lump, METH_O, "Lump(DenseMatrix self)"}, + { "DenseMatrix_GradToCurl", _wrap_DenseMatrix_GradToCurl, METH_VARARGS, "GradToCurl(DenseMatrix self, DenseMatrix curl)"}, + { "DenseMatrix_GradToDiv", _wrap_DenseMatrix_GradToDiv, METH_VARARGS, "GradToDiv(DenseMatrix self, Vector div)"}, + { "DenseMatrix_CopyRows", _wrap_DenseMatrix_CopyRows, METH_VARARGS, "CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, + { "DenseMatrix_CopyCols", _wrap_DenseMatrix_CopyCols, METH_VARARGS, "CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, + { "DenseMatrix_CopyMNt", _wrap_DenseMatrix_CopyMNt, METH_VARARGS, "CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, + { "DenseMatrix_CopyMN", _wrap_DenseMatrix_CopyMN, METH_VARARGS, "\n" + "CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco)\n" + "CopyMN(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)\n" + "CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco, int row_offset, int col_offset)\n" + ""}, + { "DenseMatrix_CopyMNDiag", _wrap_DenseMatrix_CopyMNDiag, METH_VARARGS, "\n" + "CopyMNDiag(DenseMatrix self, double c, int n, int row_offset, int col_offset)\n" + "CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset)\n" + ""}, + { "DenseMatrix_CopyExceptMN", _wrap_DenseMatrix_CopyExceptMN, METH_VARARGS, "CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, + { "DenseMatrix_AddMatrix", _wrap_DenseMatrix_AddMatrix, METH_VARARGS, "\n" + "AddMatrix(DenseMatrix self, DenseMatrix A, int ro, int co)\n" + "AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co)\n" + ""}, + { "DenseMatrix_AddToVector", _wrap_DenseMatrix_AddToVector, METH_VARARGS, "AddToVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_GetFromVector", _wrap_DenseMatrix_GetFromVector, METH_VARARGS, "GetFromVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_AdjustDofDirection", _wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS, "AdjustDofDirection(DenseMatrix self, intArray dofs)"}, + { "DenseMatrix_Threshold", _wrap_DenseMatrix_Threshold, METH_VARARGS, "Threshold(DenseMatrix self, double eps)"}, + { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "CheckFinite(DenseMatrix self) -> int"}, + { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "TestInversion(DenseMatrix self)"}, + { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "MemoryUsage(DenseMatrix self) -> long"}, + { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "HostRead(DenseMatrix self) -> double const *"}, + { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "HostWrite(DenseMatrix self) -> double *"}, + { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "HostReadWrite(DenseMatrix self) -> double *"}, + { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, + { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" + "Assign(DenseMatrix self, double const v)\n" + "Assign(DenseMatrix self, DenseMatrix m)\n" + "Assign(DenseMatrix self, PyObject * numpymat)\n" + ""}, + { "DenseMatrix___getitem__", _wrap_DenseMatrix___getitem__, METH_VARARGS, "__getitem__(DenseMatrix self, int const i, int const j) -> double const"}, + { "DenseMatrix___setitem__", _wrap_DenseMatrix___setitem__, METH_VARARGS, "__setitem__(DenseMatrix self, int i, int j, double const v)"}, + { "DenseMatrix_GetDataArray", _wrap_DenseMatrix_GetDataArray, METH_O, "GetDataArray(DenseMatrix self) -> PyObject *"}, + { "DenseMatrix_Print", _wrap_DenseMatrix_Print, METH_VARARGS, "\n" + "Print(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" + "Print(DenseMatrix self, char const * file, int precision=8)\n" + ""}, + { "DenseMatrix_PrintT", _wrap_DenseMatrix_PrintT, METH_VARARGS, "\n" + "PrintT(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" + "PrintT(DenseMatrix self, char const * file, int precision=8)\n" + ""}, + { "DenseMatrix_PrintMatlab", _wrap_DenseMatrix_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(DenseMatrix self, std::ostream & out=mfem::out)\n" + "PrintMatlab(DenseMatrix self, char const * file, int precision=8)\n" + ""}, + { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, + { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, + { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, + { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, + { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, + { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, + { "CalcInverseTranspose", _wrap_CalcInverseTranspose, METH_VARARGS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, + { "CalcOrtho", _wrap_CalcOrtho, METH_VARARGS, "CalcOrtho(DenseMatrix J, Vector n)"}, + { "MultAAt", _wrap_MultAAt, METH_VARARGS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, + { "MultADAt", _wrap_MultADAt, METH_VARARGS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "AddMultADAt", _wrap_AddMultADAt, METH_VARARGS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "MultABt", _wrap_MultABt, METH_VARARGS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultADBt", _wrap_MultADBt, METH_VARARGS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMultABt", _wrap_AddMultABt, METH_VARARGS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "AddMultADBt", _wrap_AddMultADBt, METH_VARARGS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMult_a_ABt", _wrap_AddMult_a_ABt, METH_VARARGS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultAtB", _wrap_MultAtB, METH_VARARGS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, + { "AddMult_a_AAt", _wrap_AddMult_a_AAt, METH_VARARGS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "Mult_a_AAt", _wrap_Mult_a_AAt, METH_VARARGS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "MultVVt", _wrap_MultVVt, METH_VARARGS, "MultVVt(Vector v, DenseMatrix vvt)"}, + { "MultVWt", _wrap_MultVWt, METH_VARARGS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVWt", _wrap_AddMultVWt, METH_VARARGS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVVt", _wrap_AddMultVVt, METH_VARARGS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, + { "AddMult_a_VWt", _wrap_AddMult_a_VWt, METH_VARARGS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMult_a_VVt", _wrap_AddMult_a_VVt, METH_VARARGS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, + { "LUFactors_data_set", _wrap_LUFactors_data_set, METH_VARARGS, "LUFactors_data_set(LUFactors self, double * data)"}, + { "LUFactors_data_get", _wrap_LUFactors_data_get, METH_O, "LUFactors_data_get(LUFactors self) -> double *"}, + { "LUFactors_ipiv_set", _wrap_LUFactors_ipiv_set, METH_VARARGS, "LUFactors_ipiv_set(LUFactors self, int * ipiv)"}, + { "LUFactors_ipiv_get", _wrap_LUFactors_ipiv_get, METH_O, "LUFactors_ipiv_get(LUFactors self) -> int *"}, + { "new_LUFactors", _wrap_new_LUFactors, METH_VARARGS, "\n" + "LUFactors()\n" + "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" + ""}, + { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, + { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "Det(LUFactors self, int m) -> double"}, + { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "Mult(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "USolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "RightSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(LUFactors self, int m, double * X)"}, + { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, + { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, + { "LUFactors_BlockForwSolve", _wrap_LUFactors_BlockForwSolve, METH_VARARGS, "BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, + { "LUFactors_BlockBackSolve", _wrap_LUFactors_BlockBackSolve, METH_VARARGS, "BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, + { "delete_LUFactors", _wrap_delete_LUFactors, METH_O, "delete_LUFactors(LUFactors self)"}, + { "LUFactors_swigregister", LUFactors_swigregister, METH_O, NULL}, + { "LUFactors_swiginit", LUFactors_swiginit, METH_VARARGS, NULL}, + { "new_DenseMatrixInverse", _wrap_new_DenseMatrixInverse, METH_VARARGS, "\n" + "DenseMatrixInverse()\n" + "DenseMatrixInverse(DenseMatrix mat)\n" + "new_DenseMatrixInverse(DenseMatrix mat) -> DenseMatrixInverse\n" + ""}, + { "DenseMatrixInverse_Size", _wrap_DenseMatrixInverse_Size, METH_O, "Size(DenseMatrixInverse self) -> int"}, + { "DenseMatrixInverse_Factor", _wrap_DenseMatrixInverse_Factor, METH_VARARGS, "\n" + "Factor(DenseMatrixInverse self)\n" + "Factor(DenseMatrixInverse self, DenseMatrix mat)\n" + ""}, + { "DenseMatrixInverse_SetOperator", _wrap_DenseMatrixInverse_SetOperator, METH_VARARGS, "SetOperator(DenseMatrixInverse self, Operator op)"}, + { "DenseMatrixInverse_Mult", _wrap_DenseMatrixInverse_Mult, METH_VARARGS, "\n" + "Mult(DenseMatrixInverse self, Vector x, Vector y)\n" + "Mult(DenseMatrixInverse self, DenseMatrix B, DenseMatrix X)\n" + "Mult(DenseMatrixInverse self, DenseMatrix X)\n" + ""}, + { "DenseMatrixInverse_GetInverseMatrix", _wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, + { "DenseMatrixInverse_Det", _wrap_DenseMatrixInverse_Det, METH_O, "Det(DenseMatrixInverse self) -> double"}, + { "DenseMatrixInverse_TestInversion", _wrap_DenseMatrixInverse_TestInversion, METH_O, "TestInversion(DenseMatrixInverse self)"}, + { "delete_DenseMatrixInverse", _wrap_delete_DenseMatrixInverse, METH_O, "delete_DenseMatrixInverse(DenseMatrixInverse self)"}, + { "DenseMatrixInverse_swigregister", DenseMatrixInverse_swigregister, METH_O, NULL}, + { "DenseMatrixInverse_swiginit", DenseMatrixInverse_swiginit, METH_VARARGS, NULL}, + { "new_DenseMatrixEigensystem", _wrap_new_DenseMatrixEigensystem, METH_VARARGS, "\n" + "DenseMatrixEigensystem(DenseMatrix m)\n" + "new_DenseMatrixEigensystem(DenseMatrixEigensystem other) -> DenseMatrixEigensystem\n" + ""}, + { "DenseMatrixEigensystem_Eval", _wrap_DenseMatrixEigensystem_Eval, METH_O, "Eval(DenseMatrixEigensystem self)"}, + { "DenseMatrixEigensystem_Eigenvalues", _wrap_DenseMatrixEigensystem_Eigenvalues, METH_O, "Eigenvalues(DenseMatrixEigensystem self) -> Vector"}, + { "DenseMatrixEigensystem_Eigenvectors", _wrap_DenseMatrixEigensystem_Eigenvectors, METH_O, "Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix"}, + { "DenseMatrixEigensystem_Eigenvalue", _wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS, "Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, + { "DenseMatrixEigensystem_Eigenvector", _wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS, "Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, + { "delete_DenseMatrixEigensystem", _wrap_delete_DenseMatrixEigensystem, METH_O, "delete_DenseMatrixEigensystem(DenseMatrixEigensystem self)"}, + { "DenseMatrixEigensystem_swigregister", DenseMatrixEigensystem_swigregister, METH_O, NULL}, + { "DenseMatrixEigensystem_swiginit", DenseMatrixEigensystem_swiginit, METH_VARARGS, NULL}, + { "new_DenseMatrixSVD", _wrap_new_DenseMatrixSVD, METH_VARARGS, "\n" + "DenseMatrixSVD(DenseMatrix M)\n" + "new_DenseMatrixSVD(int h, int w) -> DenseMatrixSVD\n" + ""}, + { "DenseMatrixSVD_Eval", _wrap_DenseMatrixSVD_Eval, METH_VARARGS, "Eval(DenseMatrixSVD self, DenseMatrix M)"}, + { "DenseMatrixSVD_Singularvalues", _wrap_DenseMatrixSVD_Singularvalues, METH_O, "Singularvalues(DenseMatrixSVD self) -> Vector"}, + { "DenseMatrixSVD_Singularvalue", _wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS, "Singularvalue(DenseMatrixSVD self, int i) -> double"}, + { "delete_DenseMatrixSVD", _wrap_delete_DenseMatrixSVD, METH_O, "delete_DenseMatrixSVD(DenseMatrixSVD self)"}, + { "DenseMatrixSVD_swigregister", DenseMatrixSVD_swigregister, METH_O, NULL}, + { "DenseMatrixSVD_swiginit", DenseMatrixSVD_swiginit, METH_VARARGS, NULL}, + { "new_DenseTensor", _wrap_new_DenseTensor, METH_VARARGS, "\n" + "DenseTensor()\n" + "DenseTensor(int i, int j, int k)\n" + "new_DenseTensor(DenseTensor other) -> DenseTensor\n" + ""}, + { "DenseTensor_SizeI", _wrap_DenseTensor_SizeI, METH_O, "SizeI(DenseTensor self) -> int"}, + { "DenseTensor_SizeJ", _wrap_DenseTensor_SizeJ, METH_O, "SizeJ(DenseTensor self) -> int"}, + { "DenseTensor_SizeK", _wrap_DenseTensor_SizeK, METH_O, "SizeK(DenseTensor self) -> int"}, + { "DenseTensor_TotalSize", _wrap_DenseTensor_TotalSize, METH_O, "TotalSize(DenseTensor self) -> int"}, + { "DenseTensor_SetSize", _wrap_DenseTensor_SetSize, METH_VARARGS, "SetSize(DenseTensor self, int i, int j, int k)"}, + { "DenseTensor_UseExternalData", _wrap_DenseTensor_UseExternalData, METH_VARARGS, "UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, + { "DenseTensor___call__", _wrap_DenseTensor___call__, METH_VARARGS, "\n" + "__call__(DenseTensor self, int k) -> DenseMatrix\n" + "__call__(DenseTensor self, int k) -> DenseMatrix\n" + "__call__(DenseTensor self, int i, int j, int k) -> double\n" + "__call__(DenseTensor self, int i, int j, int k) -> double const &\n" + ""}, + { "DenseTensor_GetData", _wrap_DenseTensor_GetData, METH_VARARGS, "GetData(DenseTensor self, int k) -> double *"}, + { "DenseTensor_Data", _wrap_DenseTensor_Data, METH_VARARGS, "\n" + "Data(DenseTensor self) -> double\n" + "Data(DenseTensor self) -> double const *\n" + ""}, + { "DenseTensor_GetMemory", _wrap_DenseTensor_GetMemory, METH_VARARGS, "\n" + "GetMemory(DenseTensor self) -> mfem::Memory< double >\n" + "GetMemory(DenseTensor self) -> mfem::Memory< double > const &\n" + ""}, + { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, + { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "Clear(DenseTensor self)"}, + { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "MemoryUsage(DenseTensor self) -> long"}, + { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "HostRead(DenseTensor self) -> double const *"}, + { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "HostWrite(DenseTensor self) -> double *"}, + { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "HostReadWrite(DenseTensor self) -> double *"}, + { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, + { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "Assign(DenseTensor self, double const c)"}, + { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" + "__getitem__(DenseTensor self, int const i, int const j, int const k) -> double const\n" + "__getitem__(DenseTensor self, int const k) -> DenseMatrix\n" + ""}, + { "DenseTensor___setitem__", _wrap_DenseTensor___setitem__, METH_VARARGS, "__setitem__(DenseTensor self, int i, int j, int k, double const v)"}, + { "DenseTensor_GetDataArray", _wrap_DenseTensor_GetDataArray, METH_O, "GetDataArray(DenseTensor self) -> PyObject *"}, + { "DenseTensor_swigregister", DenseTensor_swigregister, METH_O, NULL}, + { "DenseTensor_swiginit", DenseTensor_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -17827,15 +19874,18 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -17851,9 +19901,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -17875,12 +19931,15 @@ static swig_type_info _swigt__p_mfem__MemoryT_double_t = {"_p_mfem__MemoryT_doub static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Table = {"_p_mfem__Table", "mfem::Table *", 0, 0, (void*)0, 0}; @@ -17910,6 +19969,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__Table, &_swigt__p_mfem__TimeDependentOperator, @@ -17936,14 +19998,17 @@ static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__Mat static swig_cast_info _swigc__p_mfem__MemoryT_double_t[] = { {&_swigt__p_mfem__MemoryT_double_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Table[] = { {&_swigt__p_mfem__Table, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -17972,6 +20037,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__Table, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_ser/device.py b/mfem/_ser/device.py index 9f708ec5..2843896a 100644 --- a/mfem/_ser/device.py +++ b/mfem/_ser/device.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _device.SWIG_PyInstanceMethod_New +_swig_new_static_method = _device.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -68,16 +71,22 @@ class Backend(object): CPU = _device.Backend_CPU OMP = _device.Backend_OMP CUDA = _device.Backend_CUDA + HIP = _device.Backend_HIP RAJA_CPU = _device.Backend_RAJA_CPU RAJA_OMP = _device.Backend_RAJA_OMP RAJA_CUDA = _device.Backend_RAJA_CUDA OCCA_CPU = _device.Backend_OCCA_CPU OCCA_OMP = _device.Backend_OCCA_OMP OCCA_CUDA = _device.Backend_OCCA_CUDA + CEED_CPU = _device.Backend_CEED_CPU + CEED_CUDA = _device.Backend_CEED_CUDA + DEBUG = _device.Backend_DEBUG NUM_BACKENDS = _device.Backend_NUM_BACKENDS CPU_MASK = _device.Backend_CPU_MASK CUDA_MASK = _device.Backend_CUDA_MASK + HIP_MASK = _device.Backend_HIP_MASK OMP_MASK = _device.Backend_OMP_MASK + CEED_MASK = _device.Backend_CEED_MASK DEVICE_MASK = _device.Backend_DEVICE_MASK RAJA_MASK = _device.Backend_RAJA_MASK OCCA_MASK = _device.Backend_OCCA_MASK @@ -99,61 +108,131 @@ def __init__(self, *args): def Configure(self, device, dev=0): return _device.Device_Configure(self, device, dev) + Configure = _swig_new_instance_method(_device.Device_Configure) def Print(self, *args): return _device.Device_Print(self, *args) + Print = _swig_new_instance_method(_device.Device_Print) @staticmethod def IsConfigured(): return _device.Device_IsConfigured() + IsConfigured = _swig_new_static_method(_device.Device_IsConfigured) @staticmethod def IsAvailable(): return _device.Device_IsAvailable() + IsAvailable = _swig_new_static_method(_device.Device_IsAvailable) @staticmethod def IsEnabled(): return _device.Device_IsEnabled() + IsEnabled = _swig_new_static_method(_device.Device_IsEnabled) @staticmethod def IsDisabled(): return _device.Device_IsDisabled() + IsDisabled = _swig_new_static_method(_device.Device_IsDisabled) @staticmethod def Allows(b_mask): return _device.Device_Allows(b_mask) + Allows = _swig_new_static_method(_device.Device_Allows) + + @staticmethod + def GetHostMemoryType(): + return _device.Device_GetHostMemoryType() + GetHostMemoryType = _swig_new_static_method(_device.Device_GetHostMemoryType) + + @staticmethod + def GetHostMemoryClass(): + return _device.Device_GetHostMemoryClass() + GetHostMemoryClass = _swig_new_static_method(_device.Device_GetHostMemoryClass) + + @staticmethod + def GetDeviceMemoryType(): + return _device.Device_GetDeviceMemoryType() + GetDeviceMemoryType = _swig_new_static_method(_device.Device_GetDeviceMemoryType) @staticmethod def GetMemoryType(): return _device.Device_GetMemoryType() + GetMemoryType = _swig_new_static_method(_device.Device_GetMemoryType) + + @staticmethod + def GetDeviceMemoryClass(): + return _device.Device_GetDeviceMemoryClass() + GetDeviceMemoryClass = _swig_new_static_method(_device.Device_GetDeviceMemoryClass) @staticmethod def GetMemoryClass(): return _device.Device_GetMemoryClass() + GetMemoryClass = _swig_new_static_method(_device.Device_GetMemoryClass) + + @staticmethod + def SetGPUAwareMPI(force=True): + return _device.Device_SetGPUAwareMPI(force) + SetGPUAwareMPI = _swig_new_static_method(_device.Device_SetGPUAwareMPI) + + @staticmethod + def GetGPUAwareMPI(): + return _device.Device_GetGPUAwareMPI() + GetGPUAwareMPI = _swig_new_static_method(_device.Device_GetGPUAwareMPI) # Register Device in _device: _device.Device_swigregister(Device) def Device_IsConfigured(): return _device.Device_IsConfigured() +Device_IsConfigured = _device.Device_IsConfigured def Device_IsAvailable(): return _device.Device_IsAvailable() +Device_IsAvailable = _device.Device_IsAvailable def Device_IsEnabled(): return _device.Device_IsEnabled() +Device_IsEnabled = _device.Device_IsEnabled def Device_IsDisabled(): return _device.Device_IsDisabled() +Device_IsDisabled = _device.Device_IsDisabled def Device_Allows(b_mask): return _device.Device_Allows(b_mask) +Device_Allows = _device.Device_Allows + +def Device_GetHostMemoryType(): + return _device.Device_GetHostMemoryType() +Device_GetHostMemoryType = _device.Device_GetHostMemoryType + +def Device_GetHostMemoryClass(): + return _device.Device_GetHostMemoryClass() +Device_GetHostMemoryClass = _device.Device_GetHostMemoryClass + +def Device_GetDeviceMemoryType(): + return _device.Device_GetDeviceMemoryType() +Device_GetDeviceMemoryType = _device.Device_GetDeviceMemoryType def Device_GetMemoryType(): return _device.Device_GetMemoryType() +Device_GetMemoryType = _device.Device_GetMemoryType + +def Device_GetDeviceMemoryClass(): + return _device.Device_GetDeviceMemoryClass() +Device_GetDeviceMemoryClass = _device.Device_GetDeviceMemoryClass def Device_GetMemoryClass(): return _device.Device_GetMemoryClass() +Device_GetMemoryClass = _device.Device_GetMemoryClass + +def Device_SetGPUAwareMPI(force=True): + return _device.Device_SetGPUAwareMPI(force) +Device_SetGPUAwareMPI = _device.Device_SetGPUAwareMPI + +def Device_GetGPUAwareMPI(): + return _device.Device_GetGPUAwareMPI() +Device_GetGPUAwareMPI = _device.Device_GetGPUAwareMPI diff --git a/mfem/_ser/device_wrap.cxx b/mfem/_ser/device_wrap.cxx index 32f3da27..8b6f5deb 100644 --- a/mfem/_ser/device_wrap.cxx +++ b/mfem/_ser/device_wrap.cxx @@ -2987,6 +2987,20 @@ SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) return SWIG_TypeError; } + +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + #ifdef __cplusplus extern "C" { #endif @@ -3683,6 +3697,90 @@ SWIGINTERN PyObject *_wrap_Device_Allows(PyObject *SWIGUNUSEDPARM(self), PyObjec } +SWIGINTERN PyObject *_wrap_Device_GetHostMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetHostMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::Device::GetHostMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_GetHostMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryClass result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetHostMemoryClass", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryClass)mfem::Device::GetHostMemoryClass(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_GetDeviceMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetDeviceMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::Device::GetDeviceMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Device_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryType result; @@ -3711,6 +3809,34 @@ SWIGINTERN PyObject *_wrap_Device_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_Device_GetDeviceMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryClass result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetDeviceMemoryClass", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryClass)mfem::Device::GetDeviceMemoryClass(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Device_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryClass result; @@ -3739,6 +3865,127 @@ SWIGINTERN PyObject *_wrap_Device_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + bool arg1 ; + bool val1 ; + int ecode1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_SetGPUAwareMPI" "', argument " "1"" of type '" "bool""'"); + } + arg1 = static_cast< bool >(val1); + { + try { + mfem::Device::SetGPUAwareMPI(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + mfem::Device::SetGPUAwareMPI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Device_SetGPUAwareMPI", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_Device_SetGPUAwareMPI__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_bool(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Device_SetGPUAwareMPI__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_SetGPUAwareMPI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Device::SetGPUAwareMPI(bool const)\n" + " mfem::Device::SetGPUAwareMPI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Device_GetGPUAwareMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "Device_GetGPUAwareMPI", 0, 0, 0)) SWIG_fail; + { + try { + result = (bool)mfem::Device::GetGPUAwareMPI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *Device_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -3752,6 +3999,7 @@ SWIGINTERN PyObject *Device_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Backend", _wrap_new_Backend, METH_NOARGS, NULL}, { "delete_Backend", _wrap_delete_Backend, METH_O, NULL}, { "Backend_swigregister", Backend_swigregister, METH_O, NULL}, @@ -3765,14 +4013,45 @@ static PyMethodDef SwigMethods[] = { { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, + { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, + { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, { "Device_swigregister", Device_swigregister, METH_O, NULL}, { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Backend", _wrap_new_Backend, METH_NOARGS, NULL}, + { "delete_Backend", _wrap_delete_Backend, METH_O, NULL}, + { "Backend_swigregister", Backend_swigregister, METH_O, NULL}, + { "Backend_swiginit", Backend_swiginit, METH_VARARGS, NULL}, + { "new_Device", _wrap_new_Device, METH_VARARGS, NULL}, + { "delete_Device", _wrap_delete_Device, METH_O, NULL}, + { "Device_Configure", _wrap_Device_Configure, METH_VARARGS, NULL}, + { "Device_Print", _wrap_Device_Print, METH_VARARGS, NULL}, + { "Device_IsConfigured", _wrap_Device_IsConfigured, METH_NOARGS, NULL}, + { "Device_IsAvailable", _wrap_Device_IsAvailable, METH_NOARGS, NULL}, + { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, + { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, + { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, + { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, + { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, + { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, + { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, + { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, + { "Device_swigregister", Device_swigregister, METH_O, NULL}, + { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4540,16 +4819,22 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Backend_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::CPU))); SWIG_Python_SetConstant(d, "Backend_OMP",SWIG_From_int(static_cast< int >(mfem::Backend::OMP))); SWIG_Python_SetConstant(d, "Backend_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::CUDA))); + SWIG_Python_SetConstant(d, "Backend_HIP",SWIG_From_int(static_cast< int >(mfem::Backend::HIP))); SWIG_Python_SetConstant(d, "Backend_RAJA_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_CPU))); SWIG_Python_SetConstant(d, "Backend_RAJA_OMP",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_OMP))); SWIG_Python_SetConstant(d, "Backend_RAJA_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_CUDA))); SWIG_Python_SetConstant(d, "Backend_OCCA_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_CPU))); SWIG_Python_SetConstant(d, "Backend_OCCA_OMP",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_OMP))); SWIG_Python_SetConstant(d, "Backend_OCCA_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_CUDA))); + SWIG_Python_SetConstant(d, "Backend_CEED_CPU",SWIG_From_int(static_cast< int >(mfem::Backend::CEED_CPU))); + SWIG_Python_SetConstant(d, "Backend_CEED_CUDA",SWIG_From_int(static_cast< int >(mfem::Backend::CEED_CUDA))); + SWIG_Python_SetConstant(d, "Backend_DEBUG",SWIG_From_int(static_cast< int >(mfem::Backend::DEBUG))); SWIG_Python_SetConstant(d, "Backend_NUM_BACKENDS",SWIG_From_int(static_cast< int >(mfem::Backend::NUM_BACKENDS))); SWIG_Python_SetConstant(d, "Backend_CPU_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::CPU_MASK))); SWIG_Python_SetConstant(d, "Backend_CUDA_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::CUDA_MASK))); + SWIG_Python_SetConstant(d, "Backend_HIP_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::HIP_MASK))); SWIG_Python_SetConstant(d, "Backend_OMP_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::OMP_MASK))); + SWIG_Python_SetConstant(d, "Backend_CEED_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::CEED_MASK))); SWIG_Python_SetConstant(d, "Backend_DEVICE_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::DEVICE_MASK))); SWIG_Python_SetConstant(d, "Backend_RAJA_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::RAJA_MASK))); SWIG_Python_SetConstant(d, "Backend_OCCA_MASK",SWIG_From_int(static_cast< int >(mfem::Backend::OCCA_MASK))); diff --git a/mfem/_ser/element.py b/mfem/_ser/element.py index 987b734b..f21fe380 100644 --- a/mfem/_ser/element.py +++ b/mfem/_ser/element.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _element.SWIG_PyInstanceMethod_New +_swig_new_static_method = _element.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -99,22 +102,27 @@ def __init__(self, *args, **kwargs): def GetType(self): r"""GetType(Element self) -> mfem::Element::Type""" return _element.Element_GetType(self) + GetType = _swig_new_instance_method(_element.Element_GetType) def GetGeometryType(self): r"""GetGeometryType(Element self) -> mfem::Geometry::Type""" return _element.Element_GetGeometryType(self) + GetGeometryType = _swig_new_instance_method(_element.Element_GetGeometryType) def GetAttribute(self): r"""GetAttribute(Element self) -> int""" return _element.Element_GetAttribute(self) + GetAttribute = _swig_new_instance_method(_element.Element_GetAttribute) def SetAttribute(self, attr): r"""SetAttribute(Element self, int const attr)""" return _element.Element_SetAttribute(self, attr) + SetAttribute = _swig_new_instance_method(_element.Element_SetAttribute) def SetVertices(self, ind): r"""SetVertices(Element self, int const * ind)""" return _element.Element_SetVertices(self, ind) + SetVertices = _swig_new_instance_method(_element.Element_SetVertices) def GetVertices(self, *args): r""" @@ -123,55 +131,76 @@ def GetVertices(self, *args): GetVertices(Element self) -> int const * """ return _element.Element_GetVertices(self, *args) + GetVertices = _swig_new_instance_method(_element.Element_GetVertices) def GetNVertices(self): r"""GetNVertices(Element self) -> int""" return _element.Element_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_element.Element_GetNVertices) def GetNEdges(self): r"""GetNEdges(Element self) -> int""" return _element.Element_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_element.Element_GetNEdges) def GetEdgeVertices(self, arg2): r"""GetEdgeVertices(Element self, int arg2) -> int const *""" return _element.Element_GetEdgeVertices(self, arg2) + GetEdgeVertices = _swig_new_instance_method(_element.Element_GetEdgeVertices) + + def GetNFaces(self, *args): + r""" + GetNFaces(Element self, int & nFaceVertices) -> int + GetNFaces(Element self) -> int + """ + return _element.Element_GetNFaces(self, *args) + GetNFaces = _swig_new_instance_method(_element.Element_GetNFaces) - def GetNFaces(self, nFaceVertices): - r"""GetNFaces(Element self, int & nFaceVertices) -> int""" - return _element.Element_GetNFaces(self, nFaceVertices) + def GetNFaceVertices(self, fi): + r"""GetNFaceVertices(Element self, int fi) -> int""" + return _element.Element_GetNFaceVertices(self, fi) + GetNFaceVertices = _swig_new_instance_method(_element.Element_GetNFaceVertices) def GetFaceVertices(self, fi): r"""GetFaceVertices(Element self, int fi) -> int const *""" return _element.Element_GetFaceVertices(self, fi) + GetFaceVertices = _swig_new_instance_method(_element.Element_GetFaceVertices) def MarkEdge(self, v_to_v, length): r"""MarkEdge(Element self, DSTable v_to_v, int const * length)""" return _element.Element_MarkEdge(self, v_to_v, length) + MarkEdge = _swig_new_instance_method(_element.Element_MarkEdge) def NeedRefinement(self, v_to_v): r"""NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int""" return _element.Element_NeedRefinement(self, v_to_v) + NeedRefinement = _swig_new_instance_method(_element.Element_NeedRefinement) def ResetTransform(self, tr): r"""ResetTransform(Element self, int tr)""" return _element.Element_ResetTransform(self, tr) + ResetTransform = _swig_new_instance_method(_element.Element_ResetTransform) def PushTransform(self, tr): r"""PushTransform(Element self, int tr)""" return _element.Element_PushTransform(self, tr) + PushTransform = _swig_new_instance_method(_element.Element_PushTransform) def GetTransform(self): r"""GetTransform(Element self) -> unsigned int""" return _element.Element_GetTransform(self) + GetTransform = _swig_new_instance_method(_element.Element_GetTransform) def Duplicate(self, m): r"""Duplicate(Element self, mfem::Mesh * m) -> Element""" return _element.Element_Duplicate(self, m) + Duplicate = _swig_new_instance_method(_element.Element_Duplicate) __swig_destroy__ = _element.delete_Element def GetVerticesArray(self): r"""GetVerticesArray(Element self) -> PyObject *""" return _element.Element_GetVerticesArray(self) + GetVerticesArray = _swig_new_instance_method(_element.Element_GetVerticesArray) # Register Element in _element: _element.Element_swigregister(Element) diff --git a/mfem/_ser/element_wrap.cxx b/mfem/_ser/element_wrap.cxx index 0e8fc225..505f6f66 100644 --- a/mfem/_ser/element_wrap.cxx +++ b/mfem/_ser/element_wrap.cxx @@ -3745,7 +3745,7 @@ SWIGINTERN PyObject *_wrap_Element_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetNFaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int *arg2 = 0 ; @@ -3753,10 +3753,9 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; int result; - if (!SWIG_Python_UnpackTuple(args, "Element_GetNFaces", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaces" "', argument " "1"" of type '" "mfem::Element const *""'"); @@ -3796,6 +3795,133 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO } +SWIGINTERN PyObject *_wrap_Element_GetNFaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Element *arg1 = (mfem::Element *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaces" "', argument " "1"" of type '" "mfem::Element const *""'"); + } + arg1 = reinterpret_cast< mfem::Element * >(argp1); + { + try { + result = (int)((mfem::Element const *)arg1)->GetNFaces(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Element_GetNFaces", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Element, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Element_GetNFaces__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Element, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Element_GetNFaces__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Element_GetNFaces'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Element::GetNFaces(int &) const\n" + " mfem::Element::GetNFaces() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Element *arg1 = (mfem::Element *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Element_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); + } + arg1 = reinterpret_cast< mfem::Element * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::Element const *)arg1)->GetNFaceVertices(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; @@ -4223,6 +4349,7 @@ SWIGINTERN PyObject *Element_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObje static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Element_GetType", _wrap_Element_GetType, METH_O, "Element_GetType(Element self) -> mfem::Element::Type"}, { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "Element_GetGeometryType(Element self) -> mfem::Geometry::Type"}, { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "Element_GetAttribute(Element self) -> int"}, @@ -4236,7 +4363,11 @@ static PyMethodDef SwigMethods[] = { { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "Element_GetNVertices(Element self) -> int"}, { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "Element_GetNEdges(Element self) -> int"}, { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "Element_GetEdgeVertices(Element self, int arg2) -> int const *"}, - { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "Element_GetNFaces(Element self, int & nFaceVertices) -> int"}, + { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" + "Element_GetNFaces(Element self, int & nFaceVertices) -> int\n" + "Element_GetNFaces(Element self) -> int\n" + ""}, + { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "Element_GetNFaceVertices(Element self, int fi) -> int"}, { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "Element_GetFaceVertices(Element self, int fi) -> int const *"}, { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "Element_MarkEdge(Element self, DSTable v_to_v, int const * length)"}, { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "Element_NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, @@ -4251,6 +4382,36 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Element_GetType", _wrap_Element_GetType, METH_O, "GetType(Element self) -> mfem::Element::Type"}, + { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "GetGeometryType(Element self) -> mfem::Geometry::Type"}, + { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "GetAttribute(Element self) -> int"}, + { "Element_SetAttribute", _wrap_Element_SetAttribute, METH_VARARGS, "SetAttribute(Element self, int const attr)"}, + { "Element_SetVertices", _wrap_Element_SetVertices, METH_VARARGS, "SetVertices(Element self, int const * ind)"}, + { "Element_GetVertices", _wrap_Element_GetVertices, METH_VARARGS, "\n" + "GetVertices(Element self, intArray v)\n" + "GetVertices(Element self) -> int\n" + "GetVertices(Element self) -> int const *\n" + ""}, + { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "GetNVertices(Element self) -> int"}, + { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "GetNEdges(Element self) -> int"}, + { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Element self, int arg2) -> int const *"}, + { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" + "GetNFaces(Element self, int & nFaceVertices) -> int\n" + "GetNFaces(Element self) -> int\n" + ""}, + { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Element self, int fi) -> int"}, + { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Element self, int fi) -> int const *"}, + { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "MarkEdge(Element self, DSTable v_to_v, int const * length)"}, + { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, + { "Element_ResetTransform", _wrap_Element_ResetTransform, METH_VARARGS, "ResetTransform(Element self, int tr)"}, + { "Element_PushTransform", _wrap_Element_PushTransform, METH_VARARGS, "PushTransform(Element self, int tr)"}, + { "Element_GetTransform", _wrap_Element_GetTransform, METH_O, "GetTransform(Element self) -> unsigned int"}, + { "Element_Duplicate", _wrap_Element_Duplicate, METH_VARARGS, "Duplicate(Element self, mfem::Mesh * m) -> Element"}, + { "delete_Element", _wrap_delete_Element, METH_O, "delete_Element(Element self)"}, + { "Element_GetVerticesArray", _wrap_Element_GetVerticesArray, METH_O, "GetVerticesArray(Element self) -> PyObject *"}, + { "Element_swigregister", Element_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/eltrans.py b/mfem/_ser/eltrans.py index d588aac6..3d5282fb 100644 --- a/mfem/_ser/eltrans.py +++ b/mfem/_ser/eltrans.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _eltrans.SWIG_PyInstanceMethod_New +_swig_new_static_method = _eltrans.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,10 +90,12 @@ def __init__(self, *args, **kwargs): def SetIntPoint(self, ip): r"""SetIntPoint(ElementTransformation self, IntegrationPoint ip)""" return _eltrans.ElementTransformation_SetIntPoint(self, ip) + SetIntPoint = _swig_new_instance_method(_eltrans.ElementTransformation_SetIntPoint) def GetIntPoint(self): r"""GetIntPoint(ElementTransformation self) -> IntegrationPoint""" return _eltrans.ElementTransformation_GetIntPoint(self) + GetIntPoint = _swig_new_instance_method(_eltrans.ElementTransformation_GetIntPoint) def Transform(self, *args): from .vector import Vector @@ -108,50 +113,67 @@ def Transform(self, *args): def Jacobian(self): r"""Jacobian(ElementTransformation self) -> DenseMatrix""" return _eltrans.ElementTransformation_Jacobian(self) + Jacobian = _swig_new_instance_method(_eltrans.ElementTransformation_Jacobian) + + def Hessian(self): + r"""Hessian(ElementTransformation self) -> DenseMatrix""" + return _eltrans.ElementTransformation_Hessian(self) + Hessian = _swig_new_instance_method(_eltrans.ElementTransformation_Hessian) def Weight(self): r"""Weight(ElementTransformation self) -> double""" return _eltrans.ElementTransformation_Weight(self) + Weight = _swig_new_instance_method(_eltrans.ElementTransformation_Weight) def AdjugateJacobian(self): r"""AdjugateJacobian(ElementTransformation self) -> DenseMatrix""" return _eltrans.ElementTransformation_AdjugateJacobian(self) + AdjugateJacobian = _swig_new_instance_method(_eltrans.ElementTransformation_AdjugateJacobian) def InverseJacobian(self): r"""InverseJacobian(ElementTransformation self) -> DenseMatrix""" return _eltrans.ElementTransformation_InverseJacobian(self) + InverseJacobian = _swig_new_instance_method(_eltrans.ElementTransformation_InverseJacobian) def Order(self): r"""Order(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_Order(self) + Order = _swig_new_instance_method(_eltrans.ElementTransformation_Order) def OrderJ(self): r"""OrderJ(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_OrderJ(self) + OrderJ = _swig_new_instance_method(_eltrans.ElementTransformation_OrderJ) def OrderW(self): r"""OrderW(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_OrderW(self) + OrderW = _swig_new_instance_method(_eltrans.ElementTransformation_OrderW) def OrderGrad(self, fe): r"""OrderGrad(ElementTransformation self, FiniteElement fe) -> int""" return _eltrans.ElementTransformation_OrderGrad(self, fe) + OrderGrad = _swig_new_instance_method(_eltrans.ElementTransformation_OrderGrad) def GetGeometryType(self): r"""GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type""" return _eltrans.ElementTransformation_GetGeometryType(self) + GetGeometryType = _swig_new_instance_method(_eltrans.ElementTransformation_GetGeometryType) def GetDimension(self): r"""GetDimension(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_GetDimension(self) + GetDimension = _swig_new_instance_method(_eltrans.ElementTransformation_GetDimension) def GetSpaceDim(self): r"""GetSpaceDim(ElementTransformation self) -> int""" return _eltrans.ElementTransformation_GetSpaceDim(self) + GetSpaceDim = _swig_new_instance_method(_eltrans.ElementTransformation_GetSpaceDim) def TransformBack(self, pt, ip): r"""TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int""" return _eltrans.ElementTransformation_TransformBack(self, pt, ip) + TransformBack = _swig_new_instance_method(_eltrans.ElementTransformation_TransformBack) __swig_destroy__ = _eltrans.delete_ElementTransformation # Register ElementTransformation in _eltrans: @@ -191,58 +213,72 @@ def __init__(self, Trans=None): def SetTransformation(self, Trans): r"""SetTransformation(InverseElementTransformation self, ElementTransformation Trans)""" return _eltrans.InverseElementTransformation_SetTransformation(self, Trans) + SetTransformation = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetTransformation) def SetInitialGuessType(self, itype): r"""SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)""" return _eltrans.InverseElementTransformation_SetInitialGuessType(self, itype) + SetInitialGuessType = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitialGuessType) def SetInitialGuess(self, init_ip): r"""SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)""" return _eltrans.InverseElementTransformation_SetInitialGuess(self, init_ip) + SetInitialGuess = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitialGuess) def SetInitGuessPointsType(self, q_type): r"""SetInitGuessPointsType(InverseElementTransformation self, int q_type)""" return _eltrans.InverseElementTransformation_SetInitGuessPointsType(self, q_type) + SetInitGuessPointsType = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitGuessPointsType) def SetInitGuessRelOrder(self, order): r"""SetInitGuessRelOrder(InverseElementTransformation self, int order)""" return _eltrans.InverseElementTransformation_SetInitGuessRelOrder(self, order) + SetInitGuessRelOrder = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetInitGuessRelOrder) def SetSolverType(self, stype): r"""SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)""" return _eltrans.InverseElementTransformation_SetSolverType(self, stype) + SetSolverType = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetSolverType) def SetMaxIter(self, max_it): r"""SetMaxIter(InverseElementTransformation self, int max_it)""" return _eltrans.InverseElementTransformation_SetMaxIter(self, max_it) + SetMaxIter = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetMaxIter) def SetReferenceTol(self, ref_sp_tol): r"""SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)""" return _eltrans.InverseElementTransformation_SetReferenceTol(self, ref_sp_tol) + SetReferenceTol = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetReferenceTol) def SetPhysicalRelTol(self, phys_rel_tol): r"""SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)""" return _eltrans.InverseElementTransformation_SetPhysicalRelTol(self, phys_rel_tol) + SetPhysicalRelTol = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetPhysicalRelTol) def SetElementTol(self, el_tol): r"""SetElementTol(InverseElementTransformation self, double el_tol)""" return _eltrans.InverseElementTransformation_SetElementTol(self, el_tol) + SetElementTol = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetElementTol) def SetPrintLevel(self, pr_level): r"""SetPrintLevel(InverseElementTransformation self, int pr_level)""" return _eltrans.InverseElementTransformation_SetPrintLevel(self, pr_level) + SetPrintLevel = _swig_new_instance_method(_eltrans.InverseElementTransformation_SetPrintLevel) def FindClosestPhysPoint(self, pt, ir): r"""FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int""" return _eltrans.InverseElementTransformation_FindClosestPhysPoint(self, pt, ir) + FindClosestPhysPoint = _swig_new_instance_method(_eltrans.InverseElementTransformation_FindClosestPhysPoint) def FindClosestRefPoint(self, pt, ir): r"""FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int""" return _eltrans.InverseElementTransformation_FindClosestRefPoint(self, pt, ir) + FindClosestRefPoint = _swig_new_instance_method(_eltrans.InverseElementTransformation_FindClosestRefPoint) def Transform(self, pt, ip): r"""Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int""" return _eltrans.InverseElementTransformation_Transform(self, pt, ip) + Transform = _swig_new_instance_method(_eltrans.InverseElementTransformation_Transform) # Register InverseElementTransformation in _eltrans: _eltrans.InverseElementTransformation_swigregister(InverseElementTransformation) @@ -256,22 +292,27 @@ class IsoparametricTransformation(ElementTransformation): def SetFE(self, FE): r"""SetFE(IsoparametricTransformation self, FiniteElement FE)""" return _eltrans.IsoparametricTransformation_SetFE(self, FE) + SetFE = _swig_new_instance_method(_eltrans.IsoparametricTransformation_SetFE) def GetFE(self): r"""GetFE(IsoparametricTransformation self) -> FiniteElement""" return _eltrans.IsoparametricTransformation_GetFE(self) + GetFE = _swig_new_instance_method(_eltrans.IsoparametricTransformation_GetFE) def GetPointMat(self): r"""GetPointMat(IsoparametricTransformation self) -> DenseMatrix""" return _eltrans.IsoparametricTransformation_GetPointMat(self) + GetPointMat = _swig_new_instance_method(_eltrans.IsoparametricTransformation_GetPointMat) def FinalizeTransformation(self): r"""FinalizeTransformation(IsoparametricTransformation self)""" return _eltrans.IsoparametricTransformation_FinalizeTransformation(self) + FinalizeTransformation = _swig_new_instance_method(_eltrans.IsoparametricTransformation_FinalizeTransformation) def SetIdentityTransformation(self, GeomType): r"""SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)""" return _eltrans.IsoparametricTransformation_SetIdentityTransformation(self, GeomType) + SetIdentityTransformation = _swig_new_instance_method(_eltrans.IsoparametricTransformation_SetIdentityTransformation) def Transform(self, *args): from .vector import Vector @@ -289,22 +330,27 @@ def Transform(self, *args): def Order(self): r"""Order(IsoparametricTransformation self) -> int""" return _eltrans.IsoparametricTransformation_Order(self) + Order = _swig_new_instance_method(_eltrans.IsoparametricTransformation_Order) def OrderJ(self): r"""OrderJ(IsoparametricTransformation self) -> int""" return _eltrans.IsoparametricTransformation_OrderJ(self) + OrderJ = _swig_new_instance_method(_eltrans.IsoparametricTransformation_OrderJ) def OrderW(self): r"""OrderW(IsoparametricTransformation self) -> int""" return _eltrans.IsoparametricTransformation_OrderW(self) + OrderW = _swig_new_instance_method(_eltrans.IsoparametricTransformation_OrderW) def OrderGrad(self, fe): r"""OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int""" return _eltrans.IsoparametricTransformation_OrderGrad(self, fe) + OrderGrad = _swig_new_instance_method(_eltrans.IsoparametricTransformation_OrderGrad) def TransformBack(self, v, ip): r"""TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int""" return _eltrans.IsoparametricTransformation_TransformBack(self, v, ip) + TransformBack = _swig_new_instance_method(_eltrans.IsoparametricTransformation_TransformBack) __swig_destroy__ = _eltrans.delete_IsoparametricTransformation def __init__(self): @@ -327,6 +373,7 @@ def Transform(self, *args): Transform(IntegrationPointTransformation self, IntegrationRule arg2, IntegrationRule arg3) """ return _eltrans.IntegrationPointTransformation_Transform(self, *args) + Transform = _swig_new_instance_method(_eltrans.IntegrationPointTransformation_Transform) def __init__(self): r"""__init__(IntegrationPointTransformation self) -> IntegrationPointTransformation""" diff --git a/mfem/_ser/eltrans_wrap.cxx b/mfem/_ser/eltrans_wrap.cxx index 59035a17..f4b7972c 100644 --- a/mfem/_ser/eltrans_wrap.cxx +++ b/mfem/_ser/eltrans_wrap.cxx @@ -3093,89 +3093,91 @@ namespace Swig { #define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[25] #define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[26] #define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[27] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[28] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[29] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[30] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[31] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[32] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[33] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[34] -#define SWIGTYPE_p_mfem__IntegrationPointTransformation swig_types[35] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[36] -#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[37] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[38] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[39] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[40] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[41] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[42] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[43] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[44] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[45] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[46] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[47] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[48] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[49] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[50] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[51] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[52] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[53] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[54] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[55] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[56] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[57] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[58] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[59] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[60] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[61] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[62] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[63] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[64] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[65] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[66] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[67] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[68] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[69] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[70] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[76] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[77] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[78] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[79] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[80] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[81] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[82] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[83] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[95] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[96] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[97] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[98] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__Vector swig_types[107] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[108] -static swig_type_info *swig_types[110]; -static swig_module_info swig_module = {swig_types, 109, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[28] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[29] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[30] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[31] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[32] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[33] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[34] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[35] +#define SWIGTYPE_p_mfem__IntegrationPointTransformation swig_types[36] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[37] +#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[38] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[39] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[40] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[41] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[42] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[43] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[44] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[45] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[46] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[47] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[48] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[49] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[50] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[51] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[52] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[53] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[54] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[55] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[56] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[57] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[58] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[59] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[60] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[61] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[62] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[63] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[64] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[65] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[66] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[67] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[70] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[71] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[72] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[73] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[74] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[75] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[79] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[80] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[81] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[82] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[83] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[84] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[85] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[86] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[96] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[97] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[98] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[99] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[106] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__Vector swig_types[108] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[110] +static swig_type_info *swig_types[112]; +static swig_module_info swig_module = {swig_types, 111, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3940,6 +3942,47 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_Jacobian(PyObject *SWIGUNUSEDPA } +SWIGINTERN PyObject *_wrap_ElementTransformation_Hessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::DenseMatrix *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_Hessian" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); + } + arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); + { + try { + result = (mfem::DenseMatrix *) &(arg1)->Hessian(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_ElementTransformation_Weight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; @@ -6911,6 +6954,7 @@ SWIGINTERN PyObject *FaceElementTransformations_swiginit(PyObject *SWIGUNUSEDPAR static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "ElementTransformation_Attribute_set", _wrap_ElementTransformation_Attribute_set, METH_VARARGS, "ElementTransformation_Attribute_set(ElementTransformation self, int Attribute)"}, { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, @@ -6923,6 +6967,7 @@ static PyMethodDef SwigMethods[] = { "ElementTransformation_Transform(ElementTransformation self, DenseMatrix matrix, DenseMatrix result)\n" ""}, { "ElementTransformation_Jacobian", _wrap_ElementTransformation_Jacobian, METH_O, "ElementTransformation_Jacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Hessian", _wrap_ElementTransformation_Hessian, METH_O, "ElementTransformation_Hessian(ElementTransformation self) -> DenseMatrix"}, { "ElementTransformation_Weight", _wrap_ElementTransformation_Weight, METH_O, "ElementTransformation_Weight(ElementTransformation self) -> double"}, { "ElementTransformation_AdjugateJacobian", _wrap_ElementTransformation_AdjugateJacobian, METH_O, "ElementTransformation_AdjugateJacobian(ElementTransformation self) -> DenseMatrix"}, { "ElementTransformation_InverseJacobian", _wrap_ElementTransformation_InverseJacobian, METH_O, "ElementTransformation_InverseJacobian(ElementTransformation self) -> DenseMatrix"}, @@ -7007,6 +7052,101 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "ElementTransformation_Attribute_set", _wrap_ElementTransformation_Attribute_set, METH_VARARGS, "ElementTransformation_Attribute_set(ElementTransformation self, int Attribute)"}, + { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, + { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, + { "ElementTransformation_ElementNo_get", _wrap_ElementTransformation_ElementNo_get, METH_O, "ElementTransformation_ElementNo_get(ElementTransformation self) -> int"}, + { "ElementTransformation_SetIntPoint", _wrap_ElementTransformation_SetIntPoint, METH_VARARGS, "SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, + { "ElementTransformation_GetIntPoint", _wrap_ElementTransformation_GetIntPoint, METH_O, "GetIntPoint(ElementTransformation self) -> IntegrationPoint"}, + { "ElementTransformation_Transform", _wrap_ElementTransformation_Transform, METH_VARARGS, "\n" + "Transform(ElementTransformation self, IntegrationPoint arg2, Vector arg3)\n" + "Transform(ElementTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" + "Transform(ElementTransformation self, DenseMatrix matrix, DenseMatrix result)\n" + ""}, + { "ElementTransformation_Jacobian", _wrap_ElementTransformation_Jacobian, METH_O, "Jacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Hessian", _wrap_ElementTransformation_Hessian, METH_O, "Hessian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Weight", _wrap_ElementTransformation_Weight, METH_O, "Weight(ElementTransformation self) -> double"}, + { "ElementTransformation_AdjugateJacobian", _wrap_ElementTransformation_AdjugateJacobian, METH_O, "AdjugateJacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_InverseJacobian", _wrap_ElementTransformation_InverseJacobian, METH_O, "InverseJacobian(ElementTransformation self) -> DenseMatrix"}, + { "ElementTransformation_Order", _wrap_ElementTransformation_Order, METH_O, "Order(ElementTransformation self) -> int"}, + { "ElementTransformation_OrderJ", _wrap_ElementTransformation_OrderJ, METH_O, "OrderJ(ElementTransformation self) -> int"}, + { "ElementTransformation_OrderW", _wrap_ElementTransformation_OrderW, METH_O, "OrderW(ElementTransformation self) -> int"}, + { "ElementTransformation_OrderGrad", _wrap_ElementTransformation_OrderGrad, METH_VARARGS, "OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, + { "ElementTransformation_GetGeometryType", _wrap_ElementTransformation_GetGeometryType, METH_O, "GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type"}, + { "ElementTransformation_GetDimension", _wrap_ElementTransformation_GetDimension, METH_O, "GetDimension(ElementTransformation self) -> int"}, + { "ElementTransformation_GetSpaceDim", _wrap_ElementTransformation_GetSpaceDim, METH_O, "GetSpaceDim(ElementTransformation self) -> int"}, + { "ElementTransformation_TransformBack", _wrap_ElementTransformation_TransformBack, METH_VARARGS, "TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "delete_ElementTransformation", _wrap_delete_ElementTransformation, METH_O, "delete_ElementTransformation(ElementTransformation self)"}, + { "ElementTransformation_swigregister", ElementTransformation_swigregister, METH_O, NULL}, + { "new_InverseElementTransformation", _wrap_new_InverseElementTransformation, METH_VARARGS, "InverseElementTransformation(ElementTransformation Trans=None)"}, + { "delete_InverseElementTransformation", _wrap_delete_InverseElementTransformation, METH_O, "delete_InverseElementTransformation(InverseElementTransformation self)"}, + { "InverseElementTransformation_SetTransformation", _wrap_InverseElementTransformation_SetTransformation, METH_VARARGS, "SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, + { "InverseElementTransformation_SetInitialGuessType", _wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS, "SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, + { "InverseElementTransformation_SetInitialGuess", _wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS, "SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, + { "InverseElementTransformation_SetInitGuessPointsType", _wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS, "SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, + { "InverseElementTransformation_SetInitGuessRelOrder", _wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS, "SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, + { "InverseElementTransformation_SetSolverType", _wrap_InverseElementTransformation_SetSolverType, METH_VARARGS, "SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, + { "InverseElementTransformation_SetMaxIter", _wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS, "SetMaxIter(InverseElementTransformation self, int max_it)"}, + { "InverseElementTransformation_SetReferenceTol", _wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS, "SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, + { "InverseElementTransformation_SetPhysicalRelTol", _wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS, "SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, + { "InverseElementTransformation_SetElementTol", _wrap_InverseElementTransformation_SetElementTol, METH_VARARGS, "SetElementTol(InverseElementTransformation self, double el_tol)"}, + { "InverseElementTransformation_SetPrintLevel", _wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS, "SetPrintLevel(InverseElementTransformation self, int pr_level)"}, + { "InverseElementTransformation_FindClosestPhysPoint", _wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS, "FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_FindClosestRefPoint", _wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS, "FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_Transform", _wrap_InverseElementTransformation_Transform, METH_VARARGS, "Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "InverseElementTransformation_swigregister", InverseElementTransformation_swigregister, METH_O, NULL}, + { "InverseElementTransformation_swiginit", InverseElementTransformation_swiginit, METH_VARARGS, NULL}, + { "IsoparametricTransformation_SetFE", _wrap_IsoparametricTransformation_SetFE, METH_VARARGS, "SetFE(IsoparametricTransformation self, FiniteElement FE)"}, + { "IsoparametricTransformation_GetFE", _wrap_IsoparametricTransformation_GetFE, METH_O, "GetFE(IsoparametricTransformation self) -> FiniteElement"}, + { "IsoparametricTransformation_GetPointMat", _wrap_IsoparametricTransformation_GetPointMat, METH_O, "GetPointMat(IsoparametricTransformation self) -> DenseMatrix"}, + { "IsoparametricTransformation_FinalizeTransformation", _wrap_IsoparametricTransformation_FinalizeTransformation, METH_O, "FinalizeTransformation(IsoparametricTransformation self)"}, + { "IsoparametricTransformation_SetIdentityTransformation", _wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS, "SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, + { "IsoparametricTransformation_Transform", _wrap_IsoparametricTransformation_Transform, METH_VARARGS, "\n" + "Transform(IsoparametricTransformation self, IntegrationPoint arg2, Vector arg3)\n" + "Transform(IsoparametricTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" + "Transform(IsoparametricTransformation self, DenseMatrix matrix, DenseMatrix result)\n" + ""}, + { "IsoparametricTransformation_Order", _wrap_IsoparametricTransformation_Order, METH_O, "Order(IsoparametricTransformation self) -> int"}, + { "IsoparametricTransformation_OrderJ", _wrap_IsoparametricTransformation_OrderJ, METH_O, "OrderJ(IsoparametricTransformation self) -> int"}, + { "IsoparametricTransformation_OrderW", _wrap_IsoparametricTransformation_OrderW, METH_O, "OrderW(IsoparametricTransformation self) -> int"}, + { "IsoparametricTransformation_OrderGrad", _wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS, "OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, + { "IsoparametricTransformation_TransformBack", _wrap_IsoparametricTransformation_TransformBack, METH_VARARGS, "TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, + { "delete_IsoparametricTransformation", _wrap_delete_IsoparametricTransformation, METH_O, "delete_IsoparametricTransformation(IsoparametricTransformation self)"}, + { "new_IsoparametricTransformation", _wrap_new_IsoparametricTransformation, METH_NOARGS, "new_IsoparametricTransformation() -> IsoparametricTransformation"}, + { "IsoparametricTransformation_swigregister", IsoparametricTransformation_swigregister, METH_O, NULL}, + { "IsoparametricTransformation_swiginit", IsoparametricTransformation_swiginit, METH_VARARGS, NULL}, + { "IntegrationPointTransformation_Transf_set", _wrap_IntegrationPointTransformation_Transf_set, METH_VARARGS, "IntegrationPointTransformation_Transf_set(IntegrationPointTransformation self, IsoparametricTransformation Transf)"}, + { "IntegrationPointTransformation_Transf_get", _wrap_IntegrationPointTransformation_Transf_get, METH_O, "IntegrationPointTransformation_Transf_get(IntegrationPointTransformation self) -> IsoparametricTransformation"}, + { "IntegrationPointTransformation_Transform", _wrap_IntegrationPointTransformation_Transform, METH_VARARGS, "\n" + "Transform(IntegrationPointTransformation self, IntegrationPoint arg2, IntegrationPoint arg3)\n" + "Transform(IntegrationPointTransformation self, IntegrationRule arg2, IntegrationRule arg3)\n" + ""}, + { "new_IntegrationPointTransformation", _wrap_new_IntegrationPointTransformation, METH_NOARGS, "new_IntegrationPointTransformation() -> IntegrationPointTransformation"}, + { "delete_IntegrationPointTransformation", _wrap_delete_IntegrationPointTransformation, METH_O, "delete_IntegrationPointTransformation(IntegrationPointTransformation self)"}, + { "IntegrationPointTransformation_swigregister", IntegrationPointTransformation_swigregister, METH_O, NULL}, + { "IntegrationPointTransformation_swiginit", IntegrationPointTransformation_swiginit, METH_VARARGS, NULL}, + { "FaceElementTransformations_Elem1No_set", _wrap_FaceElementTransformations_Elem1No_set, METH_VARARGS, "FaceElementTransformations_Elem1No_set(FaceElementTransformations self, int Elem1No)"}, + { "FaceElementTransformations_Elem1No_get", _wrap_FaceElementTransformations_Elem1No_get, METH_O, "FaceElementTransformations_Elem1No_get(FaceElementTransformations self) -> int"}, + { "FaceElementTransformations_Elem2No_set", _wrap_FaceElementTransformations_Elem2No_set, METH_VARARGS, "FaceElementTransformations_Elem2No_set(FaceElementTransformations self, int Elem2No)"}, + { "FaceElementTransformations_Elem2No_get", _wrap_FaceElementTransformations_Elem2No_get, METH_O, "FaceElementTransformations_Elem2No_get(FaceElementTransformations self) -> int"}, + { "FaceElementTransformations_FaceGeom_set", _wrap_FaceElementTransformations_FaceGeom_set, METH_VARARGS, "FaceElementTransformations_FaceGeom_set(FaceElementTransformations self, int FaceGeom)"}, + { "FaceElementTransformations_FaceGeom_get", _wrap_FaceElementTransformations_FaceGeom_get, METH_O, "FaceElementTransformations_FaceGeom_get(FaceElementTransformations self) -> int"}, + { "FaceElementTransformations_Elem1_set", _wrap_FaceElementTransformations_Elem1_set, METH_VARARGS, "FaceElementTransformations_Elem1_set(FaceElementTransformations self, ElementTransformation Elem1)"}, + { "FaceElementTransformations_Elem1_get", _wrap_FaceElementTransformations_Elem1_get, METH_O, "FaceElementTransformations_Elem1_get(FaceElementTransformations self) -> ElementTransformation"}, + { "FaceElementTransformations_Elem2_set", _wrap_FaceElementTransformations_Elem2_set, METH_VARARGS, "FaceElementTransformations_Elem2_set(FaceElementTransformations self, ElementTransformation Elem2)"}, + { "FaceElementTransformations_Elem2_get", _wrap_FaceElementTransformations_Elem2_get, METH_O, "FaceElementTransformations_Elem2_get(FaceElementTransformations self) -> ElementTransformation"}, + { "FaceElementTransformations_Face_set", _wrap_FaceElementTransformations_Face_set, METH_VARARGS, "FaceElementTransformations_Face_set(FaceElementTransformations self, ElementTransformation Face)"}, + { "FaceElementTransformations_Face_get", _wrap_FaceElementTransformations_Face_get, METH_O, "FaceElementTransformations_Face_get(FaceElementTransformations self) -> ElementTransformation"}, + { "FaceElementTransformations_Loc1_set", _wrap_FaceElementTransformations_Loc1_set, METH_VARARGS, "FaceElementTransformations_Loc1_set(FaceElementTransformations self, IntegrationPointTransformation Loc1)"}, + { "FaceElementTransformations_Loc1_get", _wrap_FaceElementTransformations_Loc1_get, METH_O, "FaceElementTransformations_Loc1_get(FaceElementTransformations self) -> IntegrationPointTransformation"}, + { "FaceElementTransformations_Loc2_set", _wrap_FaceElementTransformations_Loc2_set, METH_VARARGS, "FaceElementTransformations_Loc2_set(FaceElementTransformations self, IntegrationPointTransformation Loc2)"}, + { "FaceElementTransformations_Loc2_get", _wrap_FaceElementTransformations_Loc2_get, METH_O, "FaceElementTransformations_Loc2_get(FaceElementTransformations self) -> IntegrationPointTransformation"}, + { "new_FaceElementTransformations", _wrap_new_FaceElementTransformations, METH_NOARGS, "new_FaceElementTransformations() -> FaceElementTransformations"}, + { "delete_FaceElementTransformations", _wrap_delete_FaceElementTransformations, METH_O, "delete_FaceElementTransformations(FaceElementTransformations self)"}, + { "FaceElementTransformations_swigregister", FaceElementTransformations_swigregister, METH_O, NULL}, + { "FaceElementTransformations_swiginit", FaceElementTransformations_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -7016,12 +7156,6 @@ static PyMethodDef SwigMethods_proxydocs[] = { static void *_p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ElementTransformation *) ((mfem::IsoparametricTransformation *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -7055,6 +7189,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -7070,6 +7207,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -7238,6 +7378,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -7281,10 +7427,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -7328,13 +7474,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -7346,6 +7490,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -7387,6 +7533,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -7446,6 +7594,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -7527,6 +7676,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__Vector, &_swigt__p_mfem__VectorFiniteElement, + &_swigt__p_mfem__VectorTensorFiniteElement, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; @@ -7549,13 +7699,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7567,6 +7715,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7608,6 +7758,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7631,7 +7783,7 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationPoint[] = { {&_swigt__p_mfem__IntegrationPoint, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationPointTransformation[] = { {&_swigt__p_mfem__IntegrationPointTransformation, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; @@ -7668,6 +7820,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -7749,6 +7902,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__Vector, _swigc__p_mfem__VectorFiniteElement, + _swigc__p_mfem__VectorTensorFiniteElement, }; diff --git a/mfem/_ser/error.py b/mfem/_ser/error.py index d5b808b4..ff321cad 100644 --- a/mfem/_ser/error.py +++ b/mfem/_ser/error.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _error.SWIG_PyInstanceMethod_New +_swig_new_static_method = _error.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -66,17 +69,22 @@ class _SwigNonDynamicMeta(type): def set_error_action(action): return _error.set_error_action(action) +set_error_action = _error.set_error_action def get_error_action(): return _error.get_error_action() +get_error_action = _error.get_error_action def mfem_backtrace(mode=0, depth=-1): return _error.mfem_backtrace(mode, depth) +mfem_backtrace = _error.mfem_backtrace def mfem_error(msg=None): return _error.mfem_error(msg) +mfem_error = _error.mfem_error def mfem_warning(msg=None): return _error.mfem_warning(msg) +mfem_warning = _error.mfem_warning diff --git a/mfem/_ser/error_wrap.cxx b/mfem/_ser/error_wrap.cxx index 5ac4579d..6245645f 100644 --- a/mfem/_ser/error_wrap.cxx +++ b/mfem/_ser/error_wrap.cxx @@ -3463,6 +3463,7 @@ SWIGINTERN PyObject *_wrap_mfem_warning(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "set_error_action", _wrap_set_error_action, METH_O, NULL}, { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, @@ -3472,6 +3473,13 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "set_error_action", _wrap_set_error_action, METH_O, NULL}, + { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, + { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, + { "mfem_error", _wrap_mfem_error, METH_VARARGS, NULL}, + { "mfem_warning", _wrap_mfem_warning, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/estimators.py b/mfem/_ser/estimators.py index 7fd06b00..9a4685e4 100644 --- a/mfem/_ser/estimators.py +++ b/mfem/_ser/estimators.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _estimators.SWIG_PyInstanceMethod_New +_swig_new_static_method = _estimators.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,7 +90,9 @@ class _SwigNonDynamicMeta(type): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.handle +import mfem._ser.restriction import mfem._ser.bilinearform class AbstractErrorEstimator(object): r"""Proxy of C++ mfem::AbstractErrorEstimator class.""" @@ -115,10 +120,12 @@ def __init__(self, *args, **kwargs): def GetLocalErrors(self): r"""GetLocalErrors(ErrorEstimator self) -> Vector""" return _estimators.ErrorEstimator_GetLocalErrors(self) + GetLocalErrors = _swig_new_instance_method(_estimators.ErrorEstimator_GetLocalErrors) def Reset(self): r"""Reset(ErrorEstimator self)""" return _estimators.ErrorEstimator_Reset(self) + Reset = _swig_new_instance_method(_estimators.ErrorEstimator_Reset) __swig_destroy__ = _estimators.delete_ErrorEstimator # Register ErrorEstimator in _estimators: @@ -136,6 +143,7 @@ def __init__(self, *args, **kwargs): def GetAnisotropicFlags(self): r"""GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray""" return _estimators.AnisotropicErrorEstimator_GetAnisotropicFlags(self) + GetAnisotropicFlags = _swig_new_instance_method(_estimators.AnisotropicErrorEstimator_GetAnisotropicFlags) __swig_destroy__ = _estimators.delete_AnisotropicErrorEstimator # Register AnisotropicErrorEstimator in _estimators: @@ -147,29 +155,40 @@ class ZienkiewiczZhuEstimator(AnisotropicErrorEstimator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr + def SetWithCoeff(self, w_coeff=True): + r"""SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)""" + return _estimators.ZienkiewiczZhuEstimator_SetWithCoeff(self, w_coeff) + SetWithCoeff = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_SetWithCoeff) + def SetAnisotropic(self, aniso=True): r"""SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)""" return _estimators.ZienkiewiczZhuEstimator_SetAnisotropic(self, aniso) + SetAnisotropic = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_SetAnisotropic) def SetFluxAveraging(self, fa): r"""SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)""" return _estimators.ZienkiewiczZhuEstimator_SetFluxAveraging(self, fa) + SetFluxAveraging = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_SetFluxAveraging) def GetTotalError(self): r"""GetTotalError(ZienkiewiczZhuEstimator self) -> double""" return _estimators.ZienkiewiczZhuEstimator_GetTotalError(self) + GetTotalError = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_GetTotalError) def GetLocalErrors(self): r"""GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector""" return _estimators.ZienkiewiczZhuEstimator_GetLocalErrors(self) + GetLocalErrors = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_GetLocalErrors) def GetAnisotropicFlags(self): r"""GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray""" return _estimators.ZienkiewiczZhuEstimator_GetAnisotropicFlags(self) + GetAnisotropicFlags = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_GetAnisotropicFlags) def Reset(self): r"""Reset(ZienkiewiczZhuEstimator self)""" return _estimators.ZienkiewiczZhuEstimator_Reset(self) + Reset = _swig_new_instance_method(_estimators.ZienkiewiczZhuEstimator_Reset) __swig_destroy__ = _estimators.delete_ZienkiewiczZhuEstimator def __init__(self, integ, sol, flux_fes, own_flux_fes=False): diff --git a/mfem/_ser/estimators_wrap.cxx b/mfem/_ser/estimators_wrap.cxx index 6f911840..97ef9513 100644 --- a/mfem/_ser/estimators_wrap.cxx +++ b/mfem/_ser/estimators_wrap.cxx @@ -3066,107 +3066,109 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__AbstractErrorEstimator swig_types[5] -#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[8] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[10] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[11] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[12] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[17] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[18] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[20] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[21] -#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[22] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[23] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[24] -#define SWIGTYPE_p_mfem__GridFunction swig_types[25] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[26] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[27] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[28] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[29] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[30] -#define SWIGTYPE_p_mfem__LinearForm swig_types[31] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[32] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[33] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[35] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[36] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[38] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[39] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[40] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[41] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[42] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[43] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[44] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[45] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[46] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[47] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[48] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[49] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[50] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[51] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[53] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[57] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[58] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[59] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[60] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[61] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[62] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[63] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[66] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[67] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[73] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[74] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[75] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[76] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[77] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[78] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[79] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[80] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__Vector swig_types[82] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[83] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[86] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[90] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[91] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[93] -#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[94] -#define SWIGTYPE_p_pri_t swig_types[95] -#define SWIGTYPE_p_quad_t swig_types[96] -#define SWIGTYPE_p_seg_t swig_types[97] -#define SWIGTYPE_p_tet_t swig_types[98] -#define SWIGTYPE_p_tri_t swig_types[99] -static swig_type_info *swig_types[101]; -static swig_module_info swig_module = {swig_types, 100, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__AbstractErrorEstimator swig_types[6] +#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[9] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[10] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[11] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[12] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[13] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[18] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[19] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[21] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[22] +#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[23] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[24] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[25] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[26] +#define SWIGTYPE_p_mfem__GridFunction swig_types[27] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[28] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[29] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[30] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[32] +#define SWIGTYPE_p_mfem__LinearForm swig_types[33] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[34] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[36] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[37] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[39] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[40] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[41] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[42] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[43] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[44] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[45] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[46] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[47] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[48] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[49] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[50] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[51] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[52] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[53] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[56] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[57] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[60] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[61] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[62] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[63] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[64] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[65] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[66] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[69] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[70] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[75] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[76] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[77] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[78] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[79] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[80] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[81] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__Vector swig_types[84] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[85] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[91] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[93] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[95] +#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[96] +#define SWIGTYPE_p_pri_t swig_types[97] +#define SWIGTYPE_p_quad_t swig_types[98] +#define SWIGTYPE_p_seg_t swig_types[99] +#define SWIGTYPE_p_tet_t swig_types[100] +#define SWIGTYPE_p_tri_t swig_types[101] +static swig_type_info *swig_types[103]; +static swig_module_info swig_module = {swig_types, 102, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3731,6 +3733,132 @@ SWIGINTERN PyObject *AnisotropicErrorEstimator_swigregister(PyObject *SWIGUNUSED return SWIG_Py_Void(); } +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); + } + arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + (arg1)->SetWithCoeff(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); + } + arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); + { + try { + (arg1)->SetWithCoeff(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetWithCoeff", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZienkiewiczZhuEstimator_SetWithCoeff'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ZienkiewiczZhuEstimator::SetWithCoeff(bool)\n" + " mfem::ZienkiewiczZhuEstimator::SetWithCoeff()\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; @@ -4311,6 +4439,7 @@ SWIGINTERN PyObject *ZienkiewiczZhuEstimator_swiginit(PyObject *SWIGUNUSEDPARM(s static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "delete_AbstractErrorEstimator", _wrap_delete_AbstractErrorEstimator, METH_O, "delete_AbstractErrorEstimator(AbstractErrorEstimator self)"}, { "new_AbstractErrorEstimator", _wrap_new_AbstractErrorEstimator, METH_NOARGS, "new_AbstractErrorEstimator() -> AbstractErrorEstimator"}, { "AbstractErrorEstimator_swigregister", AbstractErrorEstimator_swigregister, METH_O, NULL}, @@ -4322,6 +4451,7 @@ static PyMethodDef SwigMethods[] = { { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "AnisotropicErrorEstimator_GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "ZienkiewiczZhuEstimator_SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "ZienkiewiczZhuEstimator_SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "ZienkiewiczZhuEstimator_SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "ZienkiewiczZhuEstimator_GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, @@ -4336,6 +4466,30 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "delete_AbstractErrorEstimator", _wrap_delete_AbstractErrorEstimator, METH_O, "delete_AbstractErrorEstimator(AbstractErrorEstimator self)"}, + { "new_AbstractErrorEstimator", _wrap_new_AbstractErrorEstimator, METH_NOARGS, "new_AbstractErrorEstimator() -> AbstractErrorEstimator"}, + { "AbstractErrorEstimator_swigregister", AbstractErrorEstimator_swigregister, METH_O, NULL}, + { "AbstractErrorEstimator_swiginit", AbstractErrorEstimator_swiginit, METH_VARARGS, NULL}, + { "ErrorEstimator_GetLocalErrors", _wrap_ErrorEstimator_GetLocalErrors, METH_O, "GetLocalErrors(ErrorEstimator self) -> Vector"}, + { "ErrorEstimator_Reset", _wrap_ErrorEstimator_Reset, METH_O, "Reset(ErrorEstimator self)"}, + { "delete_ErrorEstimator", _wrap_delete_ErrorEstimator, METH_O, "delete_ErrorEstimator(ErrorEstimator self)"}, + { "ErrorEstimator_swigregister", ErrorEstimator_swigregister, METH_O, NULL}, + { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, + { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, + { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, + { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, + { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, + { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, + { "ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector"}, + { "ZienkiewiczZhuEstimator_GetAnisotropicFlags", _wrap_ZienkiewiczZhuEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray"}, + { "ZienkiewiczZhuEstimator_Reset", _wrap_ZienkiewiczZhuEstimator_Reset, METH_O, "Reset(ZienkiewiczZhuEstimator self)"}, + { "delete_ZienkiewiczZhuEstimator", _wrap_delete_ZienkiewiczZhuEstimator, METH_O, "delete_ZienkiewiczZhuEstimator(ZienkiewiczZhuEstimator self)"}, + { "new_ZienkiewiczZhuEstimator", _wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS, "ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False)"}, + { "ZienkiewiczZhuEstimator_swigregister", ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, + { "ZienkiewiczZhuEstimator_swiginit", ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4417,6 +4571,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -4546,9 +4703,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -4573,6 +4727,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -4598,6 +4755,7 @@ static void *_p_mfem__ZienkiewiczZhuEstimatorTo_p_mfem__AbstractErrorEstimator(v return (void *)((mfem::AbstractErrorEstimator *) (mfem::ErrorEstimator *)(mfem::AnisotropicErrorEstimator *) ((mfem::ZienkiewiczZhuEstimator *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -4606,7 +4764,6 @@ static swig_type_info _swigt__p_mfem__AbstractErrorEstimator = {"_p_mfem__Abstra static swig_type_info _swigt__p_mfem__AnisotropicErrorEstimator = {"_p_mfem__AnisotropicErrorEstimator", "mfem::AnisotropicErrorEstimator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -4617,6 +4774,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -4638,6 +4796,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -4670,8 +4829,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -4680,6 +4838,7 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ErrorEstimator = {"_p_mfem__ErrorEstimator", "mfem::ErrorEstimator *", 0, 0, (void*)0, 0}; @@ -4700,6 +4859,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, @@ -4723,6 +4883,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__ErrorEstimator, &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GroupConvectionIntegrator, @@ -4802,6 +4963,7 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -4809,7 +4971,6 @@ static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, static swig_cast_info _swigc__p_mfem__AbstractErrorEstimator[] = { {&_swigt__p_mfem__AbstractErrorEstimator, 0, 0, 0}, {&_swigt__p_mfem__ErrorEstimator, _p_mfem__ErrorEstimatorTo_p_mfem__AbstractErrorEstimator, 0, 0}, {&_swigt__p_mfem__AnisotropicErrorEstimator, _p_mfem__AnisotropicErrorEstimatorTo_p_mfem__AbstractErrorEstimator, 0, 0}, {&_swigt__p_mfem__ZienkiewiczZhuEstimator, _p_mfem__ZienkiewiczZhuEstimatorTo_p_mfem__AbstractErrorEstimator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AnisotropicErrorEstimator[] = { {&_swigt__p_mfem__AnisotropicErrorEstimator, 0, 0, 0}, {&_swigt__p_mfem__ZienkiewiczZhuEstimator, _p_mfem__ZienkiewiczZhuEstimatorTo_p_mfem__AnisotropicErrorEstimator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4820,6 +4981,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4841,6 +5003,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4873,8 +5036,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4883,9 +5045,10 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ErrorEstimator[] = { {&_swigt__p_mfem__ErrorEstimator, 0, 0, 0}, {&_swigt__p_mfem__AnisotropicErrorEstimator, _p_mfem__AnisotropicErrorEstimatorTo_p_mfem__ErrorEstimator, 0, 0}, {&_swigt__p_mfem__ZienkiewiczZhuEstimator, _p_mfem__ZienkiewiczZhuEstimatorTo_p_mfem__ErrorEstimator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -4904,6 +5067,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, @@ -4927,6 +5091,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__ErrorEstimator, _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GroupConvectionIntegrator, diff --git a/mfem/_ser/fe.py b/mfem/_ser/fe.py index 6eb0ca90..01df573a 100644 --- a/mfem/_ser/fe.py +++ b/mfem/_ser/fe.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _fe.SWIG_PyInstanceMethod_New +_swig_new_static_method = _fe.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -91,6 +94,8 @@ class BasisType(object): OpenHalfUniform = _fe.BasisType_OpenHalfUniform + Serendipity = _fe.BasisType_Serendipity + NumBasisTypes = _fe.BasisType_NumBasisTypes @@ -98,36 +103,43 @@ class BasisType(object): def Check(b_type): r"""Check(int b_type) -> int""" return _fe.BasisType_Check(b_type) + Check = _swig_new_static_method(_fe.BasisType_Check) @staticmethod def CheckNodal(b_type): r"""CheckNodal(int b_type) -> int""" return _fe.BasisType_CheckNodal(b_type) + CheckNodal = _swig_new_static_method(_fe.BasisType_CheckNodal) @staticmethod def GetQuadrature1D(b_type): r"""GetQuadrature1D(int b_type) -> int""" return _fe.BasisType_GetQuadrature1D(b_type) + GetQuadrature1D = _swig_new_static_method(_fe.BasisType_GetQuadrature1D) @staticmethod def GetNodalBasis(qpt_type): r"""GetNodalBasis(int qpt_type) -> int""" return _fe.BasisType_GetNodalBasis(qpt_type) + GetNodalBasis = _swig_new_static_method(_fe.BasisType_GetNodalBasis) @staticmethod def Name(b_type): r"""Name(int b_type) -> char const *""" return _fe.BasisType_Name(b_type) + Name = _swig_new_static_method(_fe.BasisType_Name) @staticmethod def GetChar(b_type): r"""GetChar(int b_type) -> char""" return _fe.BasisType_GetChar(b_type) + GetChar = _swig_new_static_method(_fe.BasisType_GetChar) @staticmethod def GetType(b_ident): r"""GetType(char b_ident) -> int""" return _fe.BasisType_GetType(b_ident) + GetType = _swig_new_static_method(_fe.BasisType_GetType) def __init__(self): r"""__init__(BasisType self) -> BasisType""" @@ -140,30 +152,37 @@ def __init__(self): def BasisType_Check(b_type): r"""BasisType_Check(int b_type) -> int""" return _fe.BasisType_Check(b_type) +BasisType_Check = _fe.BasisType_Check def BasisType_CheckNodal(b_type): r"""BasisType_CheckNodal(int b_type) -> int""" return _fe.BasisType_CheckNodal(b_type) +BasisType_CheckNodal = _fe.BasisType_CheckNodal def BasisType_GetQuadrature1D(b_type): r"""BasisType_GetQuadrature1D(int b_type) -> int""" return _fe.BasisType_GetQuadrature1D(b_type) +BasisType_GetQuadrature1D = _fe.BasisType_GetQuadrature1D def BasisType_GetNodalBasis(qpt_type): r"""BasisType_GetNodalBasis(int qpt_type) -> int""" return _fe.BasisType_GetNodalBasis(qpt_type) +BasisType_GetNodalBasis = _fe.BasisType_GetNodalBasis def BasisType_Name(b_type): r"""BasisType_Name(int b_type) -> char const *""" return _fe.BasisType_Name(b_type) +BasisType_Name = _fe.BasisType_Name def BasisType_GetChar(b_type): r"""BasisType_GetChar(int b_type) -> char""" return _fe.BasisType_GetChar(b_type) +BasisType_GetChar = _fe.BasisType_GetChar def BasisType_GetType(b_ident): r"""BasisType_GetType(char b_ident) -> int""" return _fe.BasisType_GetType(b_ident) +BasisType_GetType = _fe.BasisType_GetType class DofToQuad(object): r"""Proxy of C++ mfem::DofToQuad class.""" @@ -243,70 +262,87 @@ def __init__(self, *args, **kwargs): def GetDim(self): r"""GetDim(FiniteElement self) -> int""" return _fe.FiniteElement_GetDim(self) + GetDim = _swig_new_instance_method(_fe.FiniteElement_GetDim) def GetGeomType(self): r"""GetGeomType(FiniteElement self) -> mfem::Geometry::Type""" return _fe.FiniteElement_GetGeomType(self) + GetGeomType = _swig_new_instance_method(_fe.FiniteElement_GetGeomType) def GetDof(self): r"""GetDof(FiniteElement self) -> int""" return _fe.FiniteElement_GetDof(self) + GetDof = _swig_new_instance_method(_fe.FiniteElement_GetDof) def GetOrder(self): r"""GetOrder(FiniteElement self) -> int""" return _fe.FiniteElement_GetOrder(self) + GetOrder = _swig_new_instance_method(_fe.FiniteElement_GetOrder) def HasAnisotropicOrders(self): r"""HasAnisotropicOrders(FiniteElement self) -> bool""" return _fe.FiniteElement_HasAnisotropicOrders(self) + HasAnisotropicOrders = _swig_new_instance_method(_fe.FiniteElement_HasAnisotropicOrders) def GetAnisotropicOrders(self): r"""GetAnisotropicOrders(FiniteElement self) -> int const *""" return _fe.FiniteElement_GetAnisotropicOrders(self) + GetAnisotropicOrders = _swig_new_instance_method(_fe.FiniteElement_GetAnisotropicOrders) def Space(self): r"""Space(FiniteElement self) -> int""" return _fe.FiniteElement_Space(self) + Space = _swig_new_instance_method(_fe.FiniteElement_Space) def GetRangeType(self): r"""GetRangeType(FiniteElement self) -> int""" return _fe.FiniteElement_GetRangeType(self) + GetRangeType = _swig_new_instance_method(_fe.FiniteElement_GetRangeType) def GetDerivRangeType(self): r"""GetDerivRangeType(FiniteElement self) -> int""" return _fe.FiniteElement_GetDerivRangeType(self) + GetDerivRangeType = _swig_new_instance_method(_fe.FiniteElement_GetDerivRangeType) def GetMapType(self): r"""GetMapType(FiniteElement self) -> int""" return _fe.FiniteElement_GetMapType(self) + GetMapType = _swig_new_instance_method(_fe.FiniteElement_GetMapType) def GetDerivType(self): r"""GetDerivType(FiniteElement self) -> int""" return _fe.FiniteElement_GetDerivType(self) + GetDerivType = _swig_new_instance_method(_fe.FiniteElement_GetDerivType) def GetDerivMapType(self): r"""GetDerivMapType(FiniteElement self) -> int""" return _fe.FiniteElement_GetDerivMapType(self) + GetDerivMapType = _swig_new_instance_method(_fe.FiniteElement_GetDerivMapType) def CalcShape(self, ip, shape): r"""CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.FiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.FiniteElement_CalcShape) def CalcPhysShape(self, Trans, shape): r"""CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)""" return _fe.FiniteElement_CalcPhysShape(self, Trans, shape) + CalcPhysShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.FiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.FiniteElement_CalcDShape) def CalcPhysDShape(self, Trans, dshape): r"""CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)""" return _fe.FiniteElement_CalcPhysDShape(self, Trans, dshape) + CalcPhysDShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysDShape) def GetNodes(self): r"""GetNodes(FiniteElement self) -> IntegrationRule""" return _fe.FiniteElement_GetNodes(self) + GetNodes = _swig_new_instance_method(_fe.FiniteElement_GetNodes) def CalcVShape(self, *args): r""" @@ -314,54 +350,82 @@ def CalcVShape(self, *args): CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.FiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.FiniteElement_CalcVShape) def CalcPhysVShape(self, Trans, shape): r"""CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)""" return _fe.FiniteElement_CalcPhysVShape(self, Trans, shape) + CalcPhysVShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.FiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.FiniteElement_CalcDivShape) def CalcPhysDivShape(self, Trans, divshape): r"""CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)""" return _fe.FiniteElement_CalcPhysDivShape(self, Trans, divshape) + CalcPhysDivShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysDivShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.FiniteElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.FiniteElement_CalcCurlShape) def CalcPhysCurlShape(self, Trans, curl_shape): r"""CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)""" return _fe.FiniteElement_CalcPhysCurlShape(self, Trans, curl_shape) + CalcPhysCurlShape = _swig_new_instance_method(_fe.FiniteElement_CalcPhysCurlShape) def GetFaceDofs(self, face, dofs, ndofs): r"""GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)""" return _fe.FiniteElement_GetFaceDofs(self, face, dofs, ndofs) + GetFaceDofs = _swig_new_instance_method(_fe.FiniteElement_GetFaceDofs) - def CalcHessian(self, ip, h): - r"""CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix h)""" - return _fe.FiniteElement_CalcHessian(self, ip, h) + def CalcHessian(self, ip, Hessian): + r"""CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)""" + return _fe.FiniteElement_CalcHessian(self, ip, Hessian) + CalcHessian = _swig_new_instance_method(_fe.FiniteElement_CalcHessian) + + def CalcPhysHessian(self, Trans, Hessian): + r"""CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)""" + return _fe.FiniteElement_CalcPhysHessian(self, Trans, Hessian) + CalcPhysHessian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysHessian) + + def CalcPhysLaplacian(self, Trans, Laplacian): + r"""CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)""" + return _fe.FiniteElement_CalcPhysLaplacian(self, Trans, Laplacian) + CalcPhysLaplacian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysLaplacian) + + def CalcPhysLinLaplacian(self, Trans, Laplacian): + r"""CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)""" + return _fe.FiniteElement_CalcPhysLinLaplacian(self, Trans, Laplacian) + CalcPhysLinLaplacian = _swig_new_instance_method(_fe.FiniteElement_CalcPhysLinLaplacian) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.FiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.FiniteElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.FiniteElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.FiniteElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.FiniteElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.FiniteElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.FiniteElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.FiniteElement_ProjectMatrixCoefficient) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(FiniteElement self, int vertex, Vector dofs)""" return _fe.FiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.FiniteElement_ProjectDelta) def Project(self, *args): r""" @@ -370,48 +434,58 @@ def Project(self, *args): Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.FiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.FiniteElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.FiniteElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.FiniteElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.FiniteElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.FiniteElement_ProjectCurl) def ProjectDiv(self, fe, Trans, div): r"""ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)""" return _fe.FiniteElement_ProjectDiv(self, fe, Trans, div) + ProjectDiv = _swig_new_instance_method(_fe.FiniteElement_ProjectDiv) def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.FiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.FiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_FiniteElement @staticmethod def IsClosedType(b_type): r"""IsClosedType(int b_type) -> bool""" return _fe.FiniteElement_IsClosedType(b_type) + IsClosedType = _swig_new_static_method(_fe.FiniteElement_IsClosedType) @staticmethod def IsOpenType(b_type): r"""IsOpenType(int b_type) -> bool""" return _fe.FiniteElement_IsOpenType(b_type) + IsOpenType = _swig_new_static_method(_fe.FiniteElement_IsOpenType) @staticmethod def VerifyClosed(b_type): r"""VerifyClosed(int b_type) -> int""" return _fe.FiniteElement_VerifyClosed(b_type) + VerifyClosed = _swig_new_static_method(_fe.FiniteElement_VerifyClosed) @staticmethod def VerifyOpen(b_type): r"""VerifyOpen(int b_type) -> int""" return _fe.FiniteElement_VerifyOpen(b_type) + VerifyOpen = _swig_new_static_method(_fe.FiniteElement_VerifyOpen) @staticmethod def VerifyNodal(b_type): r"""VerifyNodal(int b_type) -> int""" return _fe.FiniteElement_VerifyNodal(b_type) + VerifyNodal = _swig_new_static_method(_fe.FiniteElement_VerifyNodal) # Register FiniteElement in _fe: _fe.FiniteElement_swigregister(FiniteElement) @@ -419,22 +493,27 @@ def VerifyNodal(b_type): def FiniteElement_IsClosedType(b_type): r"""FiniteElement_IsClosedType(int b_type) -> bool""" return _fe.FiniteElement_IsClosedType(b_type) +FiniteElement_IsClosedType = _fe.FiniteElement_IsClosedType def FiniteElement_IsOpenType(b_type): r"""FiniteElement_IsOpenType(int b_type) -> bool""" return _fe.FiniteElement_IsOpenType(b_type) +FiniteElement_IsOpenType = _fe.FiniteElement_IsOpenType def FiniteElement_VerifyClosed(b_type): r"""FiniteElement_VerifyClosed(int b_type) -> int""" return _fe.FiniteElement_VerifyClosed(b_type) +FiniteElement_VerifyClosed = _fe.FiniteElement_VerifyClosed def FiniteElement_VerifyOpen(b_type): r"""FiniteElement_VerifyOpen(int b_type) -> int""" return _fe.FiniteElement_VerifyOpen(b_type) +FiniteElement_VerifyOpen = _fe.FiniteElement_VerifyOpen def FiniteElement_VerifyNodal(b_type): r"""FiniteElement_VerifyNodal(int b_type) -> int""" return _fe.FiniteElement_VerifyNodal(b_type) +FiniteElement_VerifyNodal = _fe.FiniteElement_VerifyNodal class ScalarFiniteElement(FiniteElement): r"""Proxy of C++ mfem::ScalarFiniteElement class.""" @@ -448,18 +527,22 @@ def __init__(self, *args, **kwargs): def SetMapType(self, M): r"""SetMapType(ScalarFiniteElement self, int M)""" return _fe.ScalarFiniteElement_SetMapType(self, M) + SetMapType = _swig_new_instance_method(_fe.ScalarFiniteElement_SetMapType) def NodalLocalInterpolation(self, Trans, I, fine_fe): r"""NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)""" return _fe.ScalarFiniteElement_NodalLocalInterpolation(self, Trans, I, fine_fe) + NodalLocalInterpolation = _swig_new_instance_method(_fe.ScalarFiniteElement_NodalLocalInterpolation) def ScalarLocalInterpolation(self, Trans, I, fine_fe): r"""ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)""" return _fe.ScalarFiniteElement_ScalarLocalInterpolation(self, Trans, I, fine_fe) + ScalarLocalInterpolation = _swig_new_instance_method(_fe.ScalarFiniteElement_ScalarLocalInterpolation) def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.ScalarFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.ScalarFiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_ScalarFiniteElement # Register ScalarFiniteElement in _fe: @@ -477,18 +560,22 @@ def __init__(self, *args, **kwargs): def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.NodalFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.NodalFiniteElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.NodalFiniteElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.NodalFiniteElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.NodalFiniteElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.NodalFiniteElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.NodalFiniteElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -497,14 +584,17 @@ def Project(self, *args): Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.NodalFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.NodalFiniteElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.NodalFiniteElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectGrad) def ProjectDiv(self, fe, Trans, div): r"""ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)""" return _fe.NodalFiniteElement_ProjectDiv(self, fe, Trans, div) + ProjectDiv = _swig_new_instance_method(_fe.NodalFiniteElement_ProjectDiv) __swig_destroy__ = _fe.delete_NodalFiniteElement # Register NodalFiniteElement in _fe: @@ -522,10 +612,12 @@ def __init__(self, *args, **kwargs): def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.PositiveFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.PositiveFiniteElement_GetLocalInterpolation) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.PositiveFiniteElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.PositiveFiniteElement_GetTransferMatrix) def Project(self, *args): r""" @@ -537,6 +629,7 @@ def Project(self, *args): Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.PositiveFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.PositiveFiniteElement_Project) __swig_destroy__ = _fe.delete_PositiveFiniteElement # Register PositiveFiniteElement in _fe: @@ -569,10 +662,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.PointFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.PointFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.PointFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.PointFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_PointFiniteElement # Register PointFiniteElement in _fe: @@ -591,10 +686,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Linear1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Linear1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Linear1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Linear1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Linear1DFiniteElement # Register Linear1DFiniteElement in _fe: @@ -613,14 +710,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Linear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Linear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Linear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Linear2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.Linear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.Linear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_Linear2DFiniteElement # Register Linear2DFiniteElement in _fe: @@ -639,18 +739,22 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.BiLinear2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_CalcHessian) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.BiLinear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.BiLinear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_BiLinear2DFiniteElement # Register BiLinear2DFiniteElement in _fe: @@ -669,14 +773,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.GaussLinear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.GaussLinear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_GaussLinear2DFiniteElement # Register GaussLinear2DFiniteElement in _fe: @@ -695,14 +802,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussBiLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussBiLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)""" return _fe.GaussBiLinear2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.GaussBiLinear2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_GaussBiLinear2DFiniteElement # Register GaussBiLinear2DFiniteElement in _fe: @@ -721,14 +831,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P1OnQuadFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P1OnQuadFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)""" return _fe.P1OnQuadFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P1OnQuadFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P1OnQuadFiniteElement # Register P1OnQuadFiniteElement in _fe: @@ -747,10 +860,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Quad1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Quad1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Quad1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Quad1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Quad1DFiniteElement # Register Quad1DFiniteElement in _fe: @@ -769,10 +884,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.QuadPos1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.QuadPos1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.QuadPos1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.QuadPos1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_QuadPos1DFiniteElement # Register QuadPos1DFiniteElement in _fe: @@ -791,18 +908,22 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Quad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Quad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.Quad2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.Quad2DFiniteElement_CalcHessian) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)""" return _fe.Quad2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.Quad2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_Quad2DFiniteElement # Register Quad2DFiniteElement in _fe: @@ -821,10 +942,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussQuad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussQuad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussQuad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussQuad2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_GaussQuad2DFiniteElement # Register GaussQuad2DFiniteElement in _fe: @@ -843,14 +966,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiQuad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiQuad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)""" return _fe.BiQuad2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.BiQuad2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_BiQuad2DFiniteElement # Register BiQuad2DFiniteElement in _fe: @@ -869,14 +995,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiQuadPos2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiQuadPos2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_CalcDShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.BiQuadPos2DFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -887,10 +1016,12 @@ def Project(self, *args): Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.BiQuadPos2DFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_Project) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)""" return _fe.BiQuadPos2DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.BiQuadPos2DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_BiQuadPos2DFiniteElement # Register BiQuadPos2DFiniteElement in _fe: @@ -909,10 +1040,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.GaussBiQuad2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.GaussBiQuad2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.GaussBiQuad2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.GaussBiQuad2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_GaussBiQuad2DFiniteElement # Register GaussBiQuad2DFiniteElement in _fe: @@ -931,14 +1064,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.BiCubic2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.BiCubic2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.BiCubic2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.BiCubic2DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_BiCubic2DFiniteElement # Register BiCubic2DFiniteElement in _fe: @@ -957,10 +1093,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Cubic1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Cubic1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Cubic1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Cubic1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Cubic1DFiniteElement # Register Cubic1DFiniteElement in _fe: @@ -979,14 +1117,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Cubic2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Cubic2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcDShape) def CalcHessian(self, ip, h): r"""CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)""" return _fe.Cubic2DFiniteElement_CalcHessian(self, ip, h) + CalcHessian = _swig_new_instance_method(_fe.Cubic2DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_Cubic2DFiniteElement # Register Cubic2DFiniteElement in _fe: @@ -1005,10 +1146,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Cubic3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Cubic3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Cubic3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Cubic3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Cubic3DFiniteElement # Register Cubic3DFiniteElement in _fe: @@ -1027,14 +1170,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0TriangleFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0TriangleFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0TriangleFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0TriangleFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)""" return _fe.P0TriangleFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0TriangleFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0TriangleFiniteElement # Register P0TriangleFiniteElement in _fe: @@ -1053,14 +1199,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0QuadFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0QuadFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0QuadFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0QuadFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)""" return _fe.P0QuadFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0QuadFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0QuadFiniteElement # Register P0QuadFiniteElement in _fe: @@ -1079,18 +1228,22 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Linear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Linear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Linear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Linear3DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)""" return _fe.Linear3DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.Linear3DFiniteElement_ProjectDelta) def GetFaceDofs(self, face, dofs, ndofs): r"""GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)""" return _fe.Linear3DFiniteElement_GetFaceDofs(self, face, dofs, ndofs) + GetFaceDofs = _swig_new_instance_method(_fe.Linear3DFiniteElement_GetFaceDofs) __swig_destroy__ = _fe.delete_Linear3DFiniteElement # Register Linear3DFiniteElement in _fe: @@ -1109,10 +1262,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Quadratic3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Quadratic3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Quadratic3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Quadratic3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Quadratic3DFiniteElement # Register Quadratic3DFiniteElement in _fe: @@ -1131,14 +1286,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.TriLinear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.TriLinear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)""" return _fe.TriLinear3DFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.TriLinear3DFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_TriLinear3DFiniteElement # Register TriLinear3DFiniteElement in _fe: @@ -1157,14 +1315,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.CrouzeixRaviartFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.CrouzeixRaviartFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)""" return _fe.CrouzeixRaviartFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.CrouzeixRaviartFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_CrouzeixRaviartFiniteElement # Register CrouzeixRaviartFiniteElement in _fe: @@ -1183,10 +1344,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.CrouzeixRaviartQuadFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.CrouzeixRaviartQuadFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.CrouzeixRaviartQuadFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.CrouzeixRaviartQuadFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_CrouzeixRaviartQuadFiniteElement # Register CrouzeixRaviartQuadFiniteElement in _fe: @@ -1205,10 +1368,12 @@ def __init__(self, Ord=0): def CalcShape(self, ip, shape): r"""CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0SegmentFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0SegmentFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0SegmentFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0SegmentFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P0SegmentFiniteElement # Register P0SegmentFiniteElement in _fe: @@ -1230,14 +1395,17 @@ def CalcVShape(self, *args): CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0TriangleFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0TriangleFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0TriangleFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1247,6 +1415,7 @@ def Project(self, *args): Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0TriangleFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0TriangleFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0TriangleFiniteElement # Register RT0TriangleFiniteElement in _fe: @@ -1268,14 +1437,17 @@ def CalcVShape(self, *args): CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0QuadFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0QuadFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0QuadFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0QuadFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0QuadFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0QuadFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1285,6 +1457,7 @@ def Project(self, *args): Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0QuadFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0QuadFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0QuadFiniteElement # Register RT0QuadFiniteElement in _fe: @@ -1306,14 +1479,17 @@ def CalcVShape(self, *args): CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT1TriangleFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT1TriangleFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT1TriangleFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1323,6 +1499,7 @@ def Project(self, *args): Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT1TriangleFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT1TriangleFiniteElement_Project) __swig_destroy__ = _fe.delete_RT1TriangleFiniteElement # Register RT1TriangleFiniteElement in _fe: @@ -1344,14 +1521,17 @@ def CalcVShape(self, *args): CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT1QuadFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT1QuadFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT1QuadFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT1QuadFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT1QuadFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT1QuadFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1361,6 +1541,7 @@ def Project(self, *args): Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT1QuadFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT1QuadFiniteElement_Project) __swig_destroy__ = _fe.delete_RT1QuadFiniteElement # Register RT1QuadFiniteElement in _fe: @@ -1382,10 +1563,12 @@ def CalcVShape(self, *args): CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT2TriangleFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT2TriangleFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT2TriangleFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT2TriangleFiniteElement_CalcDivShape) __swig_destroy__ = _fe.delete_RT2TriangleFiniteElement # Register RT2TriangleFiniteElement in _fe: @@ -1407,14 +1590,17 @@ def CalcVShape(self, *args): CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT2QuadFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT2QuadFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT2QuadFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT2QuadFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT2QuadFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT2QuadFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1424,6 +1610,7 @@ def Project(self, *args): Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT2QuadFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT2QuadFiniteElement_Project) __swig_destroy__ = _fe.delete_RT2QuadFiniteElement # Register RT2QuadFiniteElement in _fe: @@ -1442,10 +1629,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P1SegmentFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P1SegmentFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P1SegmentFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P1SegmentFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P1SegmentFiniteElement # Register P1SegmentFiniteElement in _fe: @@ -1464,10 +1653,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P2SegmentFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P2SegmentFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P2SegmentFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P2SegmentFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P2SegmentFiniteElement # Register P2SegmentFiniteElement in _fe: @@ -1486,10 +1677,12 @@ def __init__(self, degree): def CalcShape(self, ip, shape): r"""CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.Lagrange1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.Lagrange1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.Lagrange1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.Lagrange1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_Lagrange1DFiniteElement # Register Lagrange1DFiniteElement in _fe: @@ -1508,10 +1701,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P1TetNonConfFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P1TetNonConfFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P1TetNonConfFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P1TetNonConfFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_P1TetNonConfFiniteElement # Register P1TetNonConfFiniteElement in _fe: @@ -1530,14 +1725,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0TetFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0TetFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0TetFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0TetFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)""" return _fe.P0TetFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0TetFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0TetFiniteElement # Register P0TetFiniteElement in _fe: @@ -1556,14 +1754,17 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.P0HexFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.P0HexFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.P0HexFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.P0HexFiniteElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)""" return _fe.P0HexFiniteElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.P0HexFiniteElement_ProjectDelta) __swig_destroy__ = _fe.delete_P0HexFiniteElement # Register P0HexFiniteElement in _fe: @@ -1582,10 +1783,12 @@ def __init__(self, degree): def CalcShape(self, ip, shape): r"""CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.LagrangeHexFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.LagrangeHexFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.LagrangeHexFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.LagrangeHexFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_LagrangeHexFiniteElement # Register LagrangeHexFiniteElement in _fe: @@ -1604,10 +1807,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedLinear1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedLinear1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedLinear1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedLinear1DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedLinear1DFiniteElement # Register RefinedLinear1DFiniteElement in _fe: @@ -1626,10 +1831,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedLinear2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedLinear2DFiniteElement # Register RefinedLinear2DFiniteElement in _fe: @@ -1648,10 +1855,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedLinear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedLinear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedLinear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedLinear3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedLinear3DFiniteElement # Register RefinedLinear3DFiniteElement in _fe: @@ -1670,10 +1879,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedBiLinear2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedBiLinear2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedBiLinear2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedBiLinear2DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedBiLinear2DFiniteElement # Register RefinedBiLinear2DFiniteElement in _fe: @@ -1692,10 +1903,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RefinedTriLinear3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RefinedTriLinear3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RefinedTriLinear3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RefinedTriLinear3DFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RefinedTriLinear3DFiniteElement # Register RefinedTriLinear3DFiniteElement in _fe: @@ -1717,14 +1930,17 @@ def CalcVShape(self, *args): CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.Nedelec1HexFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.Nedelec1HexFiniteElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.Nedelec1HexFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1734,6 +1950,7 @@ def Project(self, *args): Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.Nedelec1HexFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.Nedelec1HexFiniteElement_Project) __swig_destroy__ = _fe.delete_Nedelec1HexFiniteElement # Register Nedelec1HexFiniteElement in _fe: @@ -1755,14 +1972,17 @@ def CalcVShape(self, *args): CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.Nedelec1TetFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.Nedelec1TetFiniteElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.Nedelec1TetFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1772,6 +1992,7 @@ def Project(self, *args): Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.Nedelec1TetFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.Nedelec1TetFiniteElement_Project) __swig_destroy__ = _fe.delete_Nedelec1TetFiniteElement # Register Nedelec1TetFiniteElement in _fe: @@ -1793,14 +2014,17 @@ def CalcVShape(self, *args): CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0HexFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0HexFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0HexFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0HexFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0HexFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0HexFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1810,6 +2034,7 @@ def Project(self, *args): Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0HexFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0HexFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0HexFiniteElement # Register RT0HexFiniteElement in _fe: @@ -1831,14 +2056,17 @@ def CalcVShape(self, *args): CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT1HexFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT1HexFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT1HexFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT1HexFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT1HexFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT1HexFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1848,6 +2076,7 @@ def Project(self, *args): Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT1HexFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT1HexFiniteElement_Project) __swig_destroy__ = _fe.delete_RT1HexFiniteElement # Register RT1HexFiniteElement in _fe: @@ -1869,14 +2098,17 @@ def CalcVShape(self, *args): CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT0TetFiniteElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT0TetFiniteElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT0TetFiniteElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT0TetFiniteElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT0TetFiniteElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT0TetFiniteElement_GetLocalInterpolation) def Project(self, *args): r""" @@ -1886,6 +2118,7 @@ def Project(self, *args): Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) """ return _fe.RT0TetFiniteElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT0TetFiniteElement_Project) __swig_destroy__ = _fe.delete_RT0TetFiniteElement # Register RT0TetFiniteElement in _fe: @@ -1904,10 +2137,12 @@ def __init__(self): def CalcShape(self, ip, shape): r"""CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.RotTriLinearHexFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.RotTriLinearHexFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.RotTriLinearHexFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.RotTriLinearHexFiniteElement_CalcDShape) __swig_destroy__ = _fe.delete_RotTriLinearHexFiniteElement # Register RotTriLinearHexFiniteElement in _fe: @@ -1935,22 +2170,27 @@ def __init__(self): def Binom(p): r"""Binom(int const p) -> int const *""" return _fe.Poly_1D_Binom(p) + Binom = _swig_new_static_method(_fe.Poly_1D_Binom) def GetPoints(self, p, btype): r"""GetPoints(Poly_1D self, int const p, int const btype) -> double const *""" return _fe.Poly_1D_GetPoints(self, p, btype) + GetPoints = _swig_new_instance_method(_fe.Poly_1D_GetPoints) def OpenPoints(self, *args): r"""OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const""" return _fe.Poly_1D_OpenPoints(self, *args) + OpenPoints = _swig_new_instance_method(_fe.Poly_1D_OpenPoints) def ClosedPoints(self, *args): r"""ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const""" return _fe.Poly_1D_ClosedPoints(self, *args) + ClosedPoints = _swig_new_instance_method(_fe.Poly_1D_ClosedPoints) def GetBasis(self, p, btype): r"""GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &""" return _fe.Poly_1D_GetBasis(self, p, btype) + GetBasis = _swig_new_instance_method(_fe.Poly_1D_GetBasis) @staticmethod def CalcBasis(*args): @@ -1960,16 +2200,19 @@ def CalcBasis(*args): CalcBasis(int const p, double const x, double * u, double * d, double * dd) """ return _fe.Poly_1D_CalcBasis(*args) + CalcBasis = _swig_new_static_method(_fe.Poly_1D_CalcBasis) @staticmethod def CalcDelta(p, x): r"""CalcDelta(int const p, double const x) -> double""" return _fe.Poly_1D_CalcDelta(p, x) + CalcDelta = _swig_new_static_method(_fe.Poly_1D_CalcDelta) @staticmethod def ChebyshevPoints(p, x): r"""ChebyshevPoints(int const p, double * x)""" return _fe.Poly_1D_ChebyshevPoints(p, x) + ChebyshevPoints = _swig_new_static_method(_fe.Poly_1D_ChebyshevPoints) @staticmethod def CalcBinomTerms(*args): @@ -1978,11 +2221,13 @@ def CalcBinomTerms(*args): CalcBinomTerms(int const p, double const x, double const y, double * u, double * d) """ return _fe.Poly_1D_CalcBinomTerms(*args) + CalcBinomTerms = _swig_new_static_method(_fe.Poly_1D_CalcBinomTerms) @staticmethod def CalcDBinomTerms(p, x, y, d): r"""CalcDBinomTerms(int const p, double const x, double const y, double * d)""" return _fe.Poly_1D_CalcDBinomTerms(p, x, y, d) + CalcDBinomTerms = _swig_new_static_method(_fe.Poly_1D_CalcDBinomTerms) @staticmethod def CalcBernstein(*args): @@ -1991,6 +2236,16 @@ def CalcBernstein(*args): CalcBernstein(int const p, double const x, double * u, double * d) """ return _fe.Poly_1D_CalcBernstein(*args) + CalcBernstein = _swig_new_static_method(_fe.Poly_1D_CalcBernstein) + + @staticmethod + def CalcLegendre(*args): + r""" + CalcLegendre(int const p, double const x, double * u) + CalcLegendre(int const p, double const x, double * u, double * d) + """ + return _fe.Poly_1D_CalcLegendre(*args) + CalcLegendre = _swig_new_static_method(_fe.Poly_1D_CalcLegendre) __swig_destroy__ = _fe.delete_Poly_1D # Register Poly_1D in _fe: @@ -1999,6 +2254,7 @@ def CalcBernstein(*args): def Poly_1D_Binom(p): r"""Poly_1D_Binom(int const p) -> int const *""" return _fe.Poly_1D_Binom(p) +Poly_1D_Binom = _fe.Poly_1D_Binom def Poly_1D_CalcBasis(*args): r""" @@ -2007,14 +2263,17 @@ def Poly_1D_CalcBasis(*args): Poly_1D_CalcBasis(int const p, double const x, double * u, double * d, double * dd) """ return _fe.Poly_1D_CalcBasis(*args) +Poly_1D_CalcBasis = _fe.Poly_1D_CalcBasis def Poly_1D_CalcDelta(p, x): r"""Poly_1D_CalcDelta(int const p, double const x) -> double""" return _fe.Poly_1D_CalcDelta(p, x) +Poly_1D_CalcDelta = _fe.Poly_1D_CalcDelta def Poly_1D_ChebyshevPoints(p, x): r"""Poly_1D_ChebyshevPoints(int const p, double * x)""" return _fe.Poly_1D_ChebyshevPoints(p, x) +Poly_1D_ChebyshevPoints = _fe.Poly_1D_ChebyshevPoints def Poly_1D_CalcBinomTerms(*args): r""" @@ -2022,10 +2281,12 @@ def Poly_1D_CalcBinomTerms(*args): Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u, double * d) """ return _fe.Poly_1D_CalcBinomTerms(*args) +Poly_1D_CalcBinomTerms = _fe.Poly_1D_CalcBinomTerms def Poly_1D_CalcDBinomTerms(p, x, y, d): r"""Poly_1D_CalcDBinomTerms(int const p, double const x, double const y, double * d)""" return _fe.Poly_1D_CalcDBinomTerms(p, x, y, d) +Poly_1D_CalcDBinomTerms = _fe.Poly_1D_CalcDBinomTerms def Poly_1D_CalcBernstein(*args): r""" @@ -2033,6 +2294,15 @@ def Poly_1D_CalcBernstein(*args): Poly_1D_CalcBernstein(int const p, double const x, double * u, double * d) """ return _fe.Poly_1D_CalcBernstein(*args) +Poly_1D_CalcBernstein = _fe.Poly_1D_CalcBernstein + +def Poly_1D_CalcLegendre(*args): + r""" + Poly_1D_CalcLegendre(int const p, double const x, double * u) + Poly_1D_CalcLegendre(int const p, double const x, double * u, double * d) + """ + return _fe.Poly_1D_CalcLegendre(*args) +Poly_1D_CalcLegendre = _fe.Poly_1D_CalcLegendre class TensorBasisElement(object): r"""Proxy of C++ mfem::TensorBasisElement class.""" @@ -2043,6 +2313,8 @@ class TensorBasisElement(object): H1_DOF_MAP = _fe.TensorBasisElement_H1_DOF_MAP + Sr_DOF_MAP = _fe.TensorBasisElement_Sr_DOF_MAP + def __init__(self, dims, p, btype, dmtype): r"""__init__(TensorBasisElement self, int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement""" @@ -2051,24 +2323,29 @@ def __init__(self, dims, p, btype, dmtype): def GetBasisType(self): r"""GetBasisType(TensorBasisElement self) -> int""" return _fe.TensorBasisElement_GetBasisType(self) + GetBasisType = _swig_new_instance_method(_fe.TensorBasisElement_GetBasisType) def GetBasis1D(self): r"""GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &""" return _fe.TensorBasisElement_GetBasis1D(self) + GetBasis1D = _swig_new_instance_method(_fe.TensorBasisElement_GetBasis1D) def GetDofMap(self): r"""GetDofMap(TensorBasisElement self) -> intArray""" return _fe.TensorBasisElement_GetDofMap(self) + GetDofMap = _swig_new_instance_method(_fe.TensorBasisElement_GetDofMap) @staticmethod def GetTensorProductGeometry(dim): r"""GetTensorProductGeometry(int dim) -> mfem::Geometry::Type""" return _fe.TensorBasisElement_GetTensorProductGeometry(dim) + GetTensorProductGeometry = _swig_new_static_method(_fe.TensorBasisElement_GetTensorProductGeometry) @staticmethod def Pow(base, dim): r"""Pow(int base, int dim) -> int""" return _fe.TensorBasisElement_Pow(base, dim) + Pow = _swig_new_static_method(_fe.TensorBasisElement_Pow) __swig_destroy__ = _fe.delete_TensorBasisElement # Register TensorBasisElement in _fe: @@ -2077,10 +2354,12 @@ def Pow(base, dim): def TensorBasisElement_GetTensorProductGeometry(dim): r"""TensorBasisElement_GetTensorProductGeometry(int dim) -> mfem::Geometry::Type""" return _fe.TensorBasisElement_GetTensorProductGeometry(dim) +TensorBasisElement_GetTensorProductGeometry = _fe.TensorBasisElement_GetTensorProductGeometry def TensorBasisElement_Pow(base, dim): r"""TensorBasisElement_Pow(int base, int dim) -> int""" return _fe.TensorBasisElement_Pow(base, dim) +TensorBasisElement_Pow = _fe.TensorBasisElement_Pow class NodalTensorFiniteElement(NodalFiniteElement, TensorBasisElement): r"""Proxy of C++ mfem::NodalTensorFiniteElement class.""" @@ -2094,6 +2373,7 @@ def __init__(self, *args, **kwargs): def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.NodalTensorFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.NodalTensorFiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_NodalTensorFiniteElement # Register NodalTensorFiniteElement in _fe: @@ -2111,11 +2391,41 @@ def __init__(self, *args, **kwargs): def GetDofToQuad(self, ir, mode): r"""GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" return _fe.PositiveTensorFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.PositiveTensorFiniteElement_GetDofToQuad) __swig_destroy__ = _fe.delete_PositiveTensorFiniteElement # Register PositiveTensorFiniteElement in _fe: _fe.PositiveTensorFiniteElement_swigregister(PositiveTensorFiniteElement) +class VectorTensorFiniteElement(VectorFiniteElement, TensorBasisElement): + r"""Proxy of C++ mfem::VectorTensorFiniteElement class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, dims, d, p, cbtype, obtype, M, dmtype): + r"""__init__(VectorTensorFiniteElement self, int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement""" + _fe.VectorTensorFiniteElement_swiginit(self, _fe.new_VectorTensorFiniteElement(dims, d, p, cbtype, obtype, M, dmtype)) + + def GetDofToQuad(self, ir, mode): + r"""GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" + return _fe.VectorTensorFiniteElement_GetDofToQuad(self, ir, mode) + GetDofToQuad = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetDofToQuad) + + def GetDofToQuadOpen(self, ir, mode): + r"""GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad""" + return _fe.VectorTensorFiniteElement_GetDofToQuadOpen(self, ir, mode) + GetDofToQuadOpen = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetDofToQuadOpen) + + def GetTensorDofToQuad(self, ir, mode, closed): + r"""GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad""" + return _fe.VectorTensorFiniteElement_GetTensorDofToQuad(self, ir, mode, closed) + GetTensorDofToQuad = _swig_new_instance_method(_fe.VectorTensorFiniteElement_GetTensorDofToQuad) + __swig_destroy__ = _fe.delete_VectorTensorFiniteElement + +# Register VectorTensorFiniteElement in _fe: +_fe.VectorTensorFiniteElement_swigregister(VectorTensorFiniteElement) + class H1_SegmentElement(NodalTensorFiniteElement): r"""Proxy of C++ mfem::H1_SegmentElement class.""" @@ -2129,14 +2439,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)""" return _fe.H1_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1_SegmentElement # Register H1_SegmentElement in _fe: @@ -2155,14 +2468,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.H1_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1_QuadrilateralElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1_QuadrilateralElement # Register H1_QuadrilateralElement in _fe: @@ -2181,14 +2497,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)""" return _fe.H1_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1_HexahedronElement # Register H1_HexahedronElement in _fe: @@ -2207,14 +2526,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)""" return _fe.H1Pos_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1Pos_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1Pos_SegmentElement # Register H1Pos_SegmentElement in _fe: @@ -2233,19 +2555,60 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.H1Pos_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1Pos_QuadrilateralElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1Pos_QuadrilateralElement # Register H1Pos_QuadrilateralElement in _fe: _fe.H1Pos_QuadrilateralElement_swigregister(H1Pos_QuadrilateralElement) +class H1Ser_QuadrilateralElement(ScalarFiniteElement): + r"""Proxy of C++ mfem::H1Ser_QuadrilateralElement class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, p): + r"""__init__(H1Ser_QuadrilateralElement self, int const p) -> H1Ser_QuadrilateralElement""" + _fe.H1Ser_QuadrilateralElement_swiginit(self, _fe.new_H1Ser_QuadrilateralElement(p)) + + def CalcShape(self, ip, shape): + r"""CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" + return _fe.H1Ser_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_CalcShape) + + def CalcDShape(self, ip, dshape): + r"""CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" + return _fe.H1Ser_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_CalcDShape) + + def GetLocalInterpolation(self, Trans, I): + r"""GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" + return _fe.H1Ser_QuadrilateralElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_GetLocalInterpolation) + + def Project(self, *args): + r""" + Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs) + Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs) + Project(H1Ser_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) + """ + return _fe.H1Ser_QuadrilateralElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.H1Ser_QuadrilateralElement_Project) + __swig_destroy__ = _fe.delete_H1Ser_QuadrilateralElement + +# Register H1Ser_QuadrilateralElement in _fe: +_fe.H1Ser_QuadrilateralElement_swigregister(H1Ser_QuadrilateralElement) + class H1Pos_HexahedronElement(PositiveTensorFiniteElement): r"""Proxy of C++ mfem::H1Pos_HexahedronElement class.""" @@ -2259,14 +2622,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)""" return _fe.H1Pos_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.H1Pos_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_H1Pos_HexahedronElement # Register H1Pos_HexahedronElement in _fe: @@ -2285,14 +2651,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_TriangleElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_TriangleElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_TriangleElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_TriangleElement_CalcDShape) def CalcHessian(self, ip, ddshape): r"""CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)""" return _fe.H1_TriangleElement_CalcHessian(self, ip, ddshape) + CalcHessian = _swig_new_instance_method(_fe.H1_TriangleElement_CalcHessian) __swig_destroy__ = _fe.delete_H1_TriangleElement # Register H1_TriangleElement in _fe: @@ -2311,14 +2680,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_TetrahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_TetrahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcDShape) def CalcHessian(self, ip, ddshape): r"""CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)""" return _fe.H1_TetrahedronElement_CalcHessian(self, ip, ddshape) + CalcHessian = _swig_new_instance_method(_fe.H1_TetrahedronElement_CalcHessian) __swig_destroy__ = _fe.delete_H1_TetrahedronElement # Register H1_TetrahedronElement in _fe: @@ -2340,6 +2712,7 @@ def CalcShape(self, *args): CalcShape(H1Pos_TriangleElement self, IntegrationPoint ip, Vector shape) """ return _fe.H1Pos_TriangleElement_CalcShape(self, *args) + CalcShape = _swig_new_instance_method(_fe.H1Pos_TriangleElement_CalcShape) def CalcDShape(self, *args): r""" @@ -2347,6 +2720,7 @@ def CalcDShape(self, *args): CalcDShape(H1Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape) """ return _fe.H1Pos_TriangleElement_CalcDShape(self, *args) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_TriangleElement_CalcDShape) __swig_destroy__ = _fe.delete_H1Pos_TriangleElement # Register H1Pos_TriangleElement in _fe: @@ -2368,6 +2742,7 @@ def CalcShape(self, *args): CalcShape(H1Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape) """ return _fe.H1Pos_TetrahedronElement_CalcShape(self, *args) + CalcShape = _swig_new_instance_method(_fe.H1Pos_TetrahedronElement_CalcShape) def CalcDShape(self, *args): r""" @@ -2375,6 +2750,7 @@ def CalcDShape(self, *args): CalcDShape(H1Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape) """ return _fe.H1Pos_TetrahedronElement_CalcDShape(self, *args) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_TetrahedronElement_CalcDShape) __swig_destroy__ = _fe.delete_H1Pos_TetrahedronElement # Register H1Pos_TetrahedronElement in _fe: @@ -2393,10 +2769,12 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_H1_WedgeElement # Register H1_WedgeElement in _fe: @@ -2457,10 +2835,12 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.H1Pos_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.H1Pos_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.H1Pos_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.H1Pos_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_H1Pos_WedgeElement # Register H1Pos_WedgeElement in _fe: @@ -2479,14 +2859,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)""" return _fe.L2_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2_SegmentElement # Register L2_SegmentElement in _fe: @@ -2505,14 +2888,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_SegmentElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_SegmentElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_SegmentElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)""" return _fe.L2Pos_SegmentElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_SegmentElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_SegmentElement # Register L2Pos_SegmentElement in _fe: @@ -2531,18 +2917,22 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.L2_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_QuadrilateralElement_ProjectDelta) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.L2_QuadrilateralElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.L2_QuadrilateralElement_ProjectCurl) __swig_destroy__ = _fe.delete_L2_QuadrilateralElement # Register L2_QuadrilateralElement in _fe: @@ -2561,14 +2951,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_QuadrilateralElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_QuadrilateralElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)""" return _fe.L2Pos_QuadrilateralElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_QuadrilateralElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_QuadrilateralElement # Register L2Pos_QuadrilateralElement in _fe: @@ -2587,14 +2980,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)""" return _fe.L2_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2_HexahedronElement # Register L2_HexahedronElement in _fe: @@ -2613,14 +3009,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_HexahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_HexahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)""" return _fe.L2Pos_HexahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_HexahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_HexahedronElement # Register L2Pos_HexahedronElement in _fe: @@ -2639,18 +3038,22 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_TriangleElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_TriangleElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_TriangleElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_TriangleElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)""" return _fe.L2_TriangleElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_TriangleElement_ProjectDelta) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.L2_TriangleElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.L2_TriangleElement_ProjectCurl) __swig_destroy__ = _fe.delete_L2_TriangleElement # Register L2_TriangleElement in _fe: @@ -2669,14 +3072,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_TriangleElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_TriangleElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_TriangleElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_TriangleElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)""" return _fe.L2Pos_TriangleElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_TriangleElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_TriangleElement # Register L2Pos_TriangleElement in _fe: @@ -2695,14 +3101,17 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_TetrahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_TetrahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_TetrahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_TetrahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)""" return _fe.L2_TetrahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2_TetrahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2_TetrahedronElement # Register L2_TetrahedronElement in _fe: @@ -2721,14 +3130,17 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_TetrahedronElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_TetrahedronElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_CalcDShape) def ProjectDelta(self, vertex, dofs): r"""ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)""" return _fe.L2Pos_TetrahedronElement_ProjectDelta(self, vertex, dofs) + ProjectDelta = _swig_new_instance_method(_fe.L2Pos_TetrahedronElement_ProjectDelta) __swig_destroy__ = _fe.delete_L2Pos_TetrahedronElement # Register L2Pos_TetrahedronElement in _fe: @@ -2747,10 +3159,12 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_L2_WedgeElement # Register L2_WedgeElement in _fe: @@ -2783,10 +3197,12 @@ def __init__(self, p): def CalcShape(self, ip, shape): r"""CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)""" return _fe.L2Pos_WedgeElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.L2Pos_WedgeElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.L2Pos_WedgeElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.L2Pos_WedgeElement_CalcDShape) __swig_destroy__ = _fe.delete_L2Pos_WedgeElement # Register L2Pos_WedgeElement in _fe: @@ -2808,26 +3224,32 @@ def CalcVShape(self, *args): CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_QuadrilateralElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_QuadrilateralElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_QuadrilateralElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_QuadrilateralElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_QuadrilateralElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_QuadrilateralElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_QuadrilateralElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_QuadrilateralElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_QuadrilateralElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -2838,14 +3260,17 @@ def Project(self, *args): Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_QuadrilateralElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_QuadrilateralElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.RT_QuadrilateralElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_QuadrilateralElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_QuadrilateralElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_QuadrilateralElement # Register RT_QuadrilateralElement in _fe: @@ -2867,26 +3292,32 @@ def CalcVShape(self, *args): CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_HexahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_HexahedronElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_HexahedronElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_HexahedronElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_HexahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_HexahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_HexahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_HexahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_HexahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_HexahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_HexahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_HexahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -2897,10 +3328,12 @@ def Project(self, *args): Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_HexahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_HexahedronElement_Project) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_HexahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_HexahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_HexahedronElement # Register RT_HexahedronElement in _fe: @@ -2922,26 +3355,32 @@ def CalcVShape(self, *args): CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_TriangleElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_TriangleElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_TriangleElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_TriangleElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TriangleElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_TriangleElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_TriangleElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_TriangleElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TriangleElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_TriangleElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_TriangleElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -2952,14 +3391,17 @@ def Project(self, *args): Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_TriangleElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_TriangleElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.RT_TriangleElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_TriangleElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_TriangleElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_TriangleElement # Register RT_TriangleElement in _fe: @@ -2981,26 +3423,32 @@ def CalcVShape(self, *args): CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.RT_TetrahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.RT_TetrahedronElement_CalcVShape) def CalcDivShape(self, ip, divshape): r"""CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)""" return _fe.RT_TetrahedronElement_CalcDivShape(self, ip, divshape) + CalcDivShape = _swig_new_instance_method(_fe.RT_TetrahedronElement_CalcDivShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TetrahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.RT_TetrahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.RT_TetrahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.RT_TetrahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.RT_TetrahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.RT_TetrahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3011,16 +3459,18 @@ def Project(self, *args): Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.RT_TetrahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.RT_TetrahedronElement_Project) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.RT_TetrahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.RT_TetrahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_RT_TetrahedronElement # Register RT_TetrahedronElement in _fe: _fe.RT_TetrahedronElement_swigregister(RT_TetrahedronElement) -class ND_HexahedronElement(VectorFiniteElement): +class ND_HexahedronElement(VectorTensorFiniteElement): r"""Proxy of C++ mfem::ND_HexahedronElement class.""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -3036,26 +3486,32 @@ def CalcVShape(self, *args): CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_HexahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_HexahedronElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_HexahedronElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_HexahedronElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_HexahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_HexahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_HexahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_HexahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_HexahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_HexahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_HexahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3066,20 +3522,23 @@ def Project(self, *args): Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_HexahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_HexahedronElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_HexahedronElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.ND_HexahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.ND_HexahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_ND_HexahedronElement # Register ND_HexahedronElement in _fe: _fe.ND_HexahedronElement_swigregister(ND_HexahedronElement) -class ND_QuadrilateralElement(VectorFiniteElement): +class ND_QuadrilateralElement(VectorTensorFiniteElement): r"""Proxy of C++ mfem::ND_QuadrilateralElement class.""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -3095,26 +3554,32 @@ def CalcVShape(self, *args): CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_QuadrilateralElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_QuadrilateralElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_QuadrilateralElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_QuadrilateralElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_QuadrilateralElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_QuadrilateralElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_QuadrilateralElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_QuadrilateralElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_QuadrilateralElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_QuadrilateralElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3125,10 +3590,12 @@ def Project(self, *args): Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_QuadrilateralElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_QuadrilateralElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_QuadrilateralElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_QuadrilateralElement_ProjectGrad) __swig_destroy__ = _fe.delete_ND_QuadrilateralElement # Register ND_QuadrilateralElement in _fe: @@ -3150,26 +3617,32 @@ def CalcVShape(self, *args): CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_TetrahedronElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_TetrahedronElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_TetrahedronElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_TetrahedronElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TetrahedronElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_TetrahedronElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TetrahedronElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_TetrahedronElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_TetrahedronElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3180,14 +3653,17 @@ def Project(self, *args): Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_TetrahedronElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_TetrahedronElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_TetrahedronElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectGrad) def ProjectCurl(self, fe, Trans, curl): r"""ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)""" return _fe.ND_TetrahedronElement_ProjectCurl(self, fe, Trans, curl) + ProjectCurl = _swig_new_instance_method(_fe.ND_TetrahedronElement_ProjectCurl) __swig_destroy__ = _fe.delete_ND_TetrahedronElement # Register ND_TetrahedronElement in _fe: @@ -3209,26 +3685,32 @@ def CalcVShape(self, *args): CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_TriangleElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_TriangleElement_CalcVShape) def CalcCurlShape(self, ip, curl_shape): r"""CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)""" return _fe.ND_TriangleElement_CalcCurlShape(self, ip, curl_shape) + CalcCurlShape = _swig_new_instance_method(_fe.ND_TriangleElement_CalcCurlShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TriangleElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_TriangleElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_TriangleElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_TriangleElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_TriangleElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_TriangleElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_TriangleElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_TriangleElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3239,10 +3721,12 @@ def Project(self, *args): Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_TriangleElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_TriangleElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_TriangleElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_TriangleElement_ProjectGrad) __swig_destroy__ = _fe.delete_ND_TriangleElement # Register ND_TriangleElement in _fe: @@ -3261,6 +3745,7 @@ def __init__(self, *args): def CalcShape(self, ip, shape): r"""CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)""" return _fe.ND_SegmentElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.ND_SegmentElement_CalcShape) def CalcVShape(self, *args): r""" @@ -3268,22 +3753,27 @@ def CalcVShape(self, *args): CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape) """ return _fe.ND_SegmentElement_CalcVShape(self, *args) + CalcVShape = _swig_new_instance_method(_fe.ND_SegmentElement_CalcVShape) def GetLocalInterpolation(self, Trans, I): r"""GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_SegmentElement_GetLocalInterpolation(self, Trans, I) + GetLocalInterpolation = _swig_new_instance_method(_fe.ND_SegmentElement_GetLocalInterpolation) def GetLocalRestriction(self, Trans, R): r"""GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)""" return _fe.ND_SegmentElement_GetLocalRestriction(self, Trans, R) + GetLocalRestriction = _swig_new_instance_method(_fe.ND_SegmentElement_GetLocalRestriction) def GetTransferMatrix(self, fe, Trans, I): r"""GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)""" return _fe.ND_SegmentElement_GetTransferMatrix(self, fe, Trans, I) + GetTransferMatrix = _swig_new_instance_method(_fe.ND_SegmentElement_GetTransferMatrix) def ProjectMatrixCoefficient(self, mc, T, dofs): r"""ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)""" return _fe.ND_SegmentElement_ProjectMatrixCoefficient(self, mc, T, dofs) + ProjectMatrixCoefficient = _swig_new_instance_method(_fe.ND_SegmentElement_ProjectMatrixCoefficient) def Project(self, *args): r""" @@ -3294,10 +3784,12 @@ def Project(self, *args): Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I) """ return _fe.ND_SegmentElement_Project(self, *args) + Project = _swig_new_instance_method(_fe.ND_SegmentElement_Project) def ProjectGrad(self, fe, Trans, grad): r"""ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)""" return _fe.ND_SegmentElement_ProjectGrad(self, fe, Trans, grad) + ProjectGrad = _swig_new_instance_method(_fe.ND_SegmentElement_ProjectGrad) __swig_destroy__ = _fe.delete_ND_SegmentElement # Register ND_SegmentElement in _fe: @@ -3315,38 +3807,47 @@ def __init__(self, *args, **kwargs): def Reset(self): r"""Reset(NURBSFiniteElement self)""" return _fe.NURBSFiniteElement_Reset(self) + Reset = _swig_new_instance_method(_fe.NURBSFiniteElement_Reset) def SetIJK(self, IJK): r"""SetIJK(NURBSFiniteElement self, int const * IJK)""" return _fe.NURBSFiniteElement_SetIJK(self, IJK) + SetIJK = _swig_new_instance_method(_fe.NURBSFiniteElement_SetIJK) def GetPatch(self): r"""GetPatch(NURBSFiniteElement self) -> int""" return _fe.NURBSFiniteElement_GetPatch(self) + GetPatch = _swig_new_instance_method(_fe.NURBSFiniteElement_GetPatch) def SetPatch(self, p): r"""SetPatch(NURBSFiniteElement self, int p)""" return _fe.NURBSFiniteElement_SetPatch(self, p) + SetPatch = _swig_new_instance_method(_fe.NURBSFiniteElement_SetPatch) def GetElement(self): r"""GetElement(NURBSFiniteElement self) -> int""" return _fe.NURBSFiniteElement_GetElement(self) + GetElement = _swig_new_instance_method(_fe.NURBSFiniteElement_GetElement) def SetElement(self, e): r"""SetElement(NURBSFiniteElement self, int e)""" return _fe.NURBSFiniteElement_SetElement(self, e) + SetElement = _swig_new_instance_method(_fe.NURBSFiniteElement_SetElement) def KnotVectors(self): r"""KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &""" return _fe.NURBSFiniteElement_KnotVectors(self) + KnotVectors = _swig_new_instance_method(_fe.NURBSFiniteElement_KnotVectors) def Weights(self): r"""Weights(NURBSFiniteElement self) -> Vector""" return _fe.NURBSFiniteElement_Weights(self) + Weights = _swig_new_instance_method(_fe.NURBSFiniteElement_Weights) def SetOrder(self): r"""SetOrder(NURBSFiniteElement self)""" return _fe.NURBSFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBSFiniteElement_SetOrder) __swig_destroy__ = _fe.delete_NURBSFiniteElement # Register NURBSFiniteElement in _fe: @@ -3365,14 +3866,22 @@ def __init__(self, p): def SetOrder(self): r"""SetOrder(NURBS1DFiniteElement self)""" return _fe.NURBS1DFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBS1DFiniteElement_SetOrder) def CalcShape(self, ip, shape): r"""CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.NURBS1DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.NURBS1DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcDShape) + + def CalcHessian(self, ip, hessian): + r"""CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)""" + return _fe.NURBS1DFiniteElement_CalcHessian(self, ip, hessian) + CalcHessian = _swig_new_instance_method(_fe.NURBS1DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_NURBS1DFiniteElement # Register NURBS1DFiniteElement in _fe: @@ -3394,14 +3903,22 @@ def __init__(self, *args): def SetOrder(self): r"""SetOrder(NURBS2DFiniteElement self)""" return _fe.NURBS2DFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBS2DFiniteElement_SetOrder) def CalcShape(self, ip, shape): r"""CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.NURBS2DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.NURBS2DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcDShape) + + def CalcHessian(self, ip, hessian): + r"""CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)""" + return _fe.NURBS2DFiniteElement_CalcHessian(self, ip, hessian) + CalcHessian = _swig_new_instance_method(_fe.NURBS2DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_NURBS2DFiniteElement # Register NURBS2DFiniteElement in _fe: @@ -3423,14 +3940,22 @@ def __init__(self, *args): def SetOrder(self): r"""SetOrder(NURBS3DFiniteElement self)""" return _fe.NURBS3DFiniteElement_SetOrder(self) + SetOrder = _swig_new_instance_method(_fe.NURBS3DFiniteElement_SetOrder) def CalcShape(self, ip, shape): r"""CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)""" return _fe.NURBS3DFiniteElement_CalcShape(self, ip, shape) + CalcShape = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcShape) def CalcDShape(self, ip, dshape): r"""CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)""" return _fe.NURBS3DFiniteElement_CalcDShape(self, ip, dshape) + CalcDShape = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcDShape) + + def CalcHessian(self, ip, hessian): + r"""CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)""" + return _fe.NURBS3DFiniteElement_CalcHessian(self, ip, hessian) + CalcHessian = _swig_new_instance_method(_fe.NURBS3DFiniteElement_CalcHessian) __swig_destroy__ = _fe.delete_NURBS3DFiniteElement # Register NURBS3DFiniteElement in _fe: diff --git a/mfem/_ser/fe_coll.py b/mfem/_ser/fe_coll.py index eab03f23..b30d5c84 100644 --- a/mfem/_ser/fe_coll.py +++ b/mfem/_ser/fe_coll.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _fe_coll.SWIG_PyInstanceMethod_New +_swig_new_static_method = _fe_coll.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -73,22 +76,27 @@ def __init__(self): def assign(self, value): return _fe_coll.intp_assign(self, value) + assign = _swig_new_instance_method(_fe_coll.intp_assign) def value(self): return _fe_coll.intp_value(self) + value = _swig_new_instance_method(_fe_coll.intp_value) def cast(self): return _fe_coll.intp_cast(self) + cast = _swig_new_instance_method(_fe_coll.intp_cast) @staticmethod def frompointer(t): return _fe_coll.intp_frompointer(t) + frompointer = _swig_new_static_method(_fe_coll.intp_frompointer) # Register intp in _fe_coll: _fe_coll.intp_swigregister(intp) def intp_frompointer(t): return _fe_coll.intp_frompointer(t) +intp_frompointer = _fe_coll.intp_frompointer class doublep(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -100,22 +108,27 @@ def __init__(self): def assign(self, value): return _fe_coll.doublep_assign(self, value) + assign = _swig_new_instance_method(_fe_coll.doublep_assign) def value(self): return _fe_coll.doublep_value(self) + value = _swig_new_instance_method(_fe_coll.doublep_value) def cast(self): return _fe_coll.doublep_cast(self) + cast = _swig_new_instance_method(_fe_coll.doublep_cast) @staticmethod def frompointer(t): return _fe_coll.doublep_frompointer(t) + frompointer = _swig_new_static_method(_fe_coll.doublep_frompointer) # Register doublep in _fe_coll: _fe_coll.doublep_swigregister(doublep) def doublep_frompointer(t): return _fe_coll.doublep_frompointer(t) +doublep_frompointer = _fe_coll.doublep_frompointer import mfem._ser.mesh import mfem._ser.matrix @@ -135,12 +148,14 @@ def doublep_frompointer(t): import mfem._ser.fespace import mfem._ser.lininteg import mfem._ser.handle -import mfem._ser.bilininteg -import mfem._ser.linearform +import mfem._ser.restriction import mfem._ser.element import mfem._ser.table import mfem._ser.hash +import mfem._ser.bilininteg +import mfem._ser.linearform import mfem._ser.vertex +import mfem._ser.vtk class FiniteElementCollection(object): r"""Proxy of C++ mfem::FiniteElementCollection class.""" @@ -153,40 +168,49 @@ def __init__(self, *args, **kwargs): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.FiniteElementCollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.FiniteElementCollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.FiniteElementCollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.FiniteElementCollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.FiniteElementCollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.FiniteElementCollection_DofOrderForOrientation) def Name(self): r"""Name(FiniteElementCollection self) -> char const *""" return _fe_coll.FiniteElementCollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.FiniteElementCollection_Name) def HasFaceDofs(self, GeomType): r"""HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.FiniteElementCollection_HasFaceDofs(self, GeomType) + HasFaceDofs = _swig_new_instance_method(_fe_coll.FiniteElementCollection_HasFaceDofs) def TraceFiniteElementForGeometry(self, GeomType): r"""TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.FiniteElementCollection_TraceFiniteElementForGeometry(self, GeomType) + TraceFiniteElementForGeometry = _swig_new_instance_method(_fe_coll.FiniteElementCollection_TraceFiniteElementForGeometry) def GetTraceCollection(self): r"""GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection""" return _fe_coll.FiniteElementCollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.FiniteElementCollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_FiniteElementCollection @staticmethod def New(name): r"""New(char const * name) -> FiniteElementCollection""" return _fe_coll.FiniteElementCollection_New(name) + New = _swig_new_static_method(_fe_coll.FiniteElementCollection_New) def SubDofOrder(self, Geom, SDim, Info, dofs): r"""SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)""" return _fe_coll.FiniteElementCollection_SubDofOrder(self, Geom, SDim, Info, dofs) + SubDofOrder = _swig_new_instance_method(_fe_coll.FiniteElementCollection_SubDofOrder) # Register FiniteElementCollection in _fe_coll: _fe_coll.FiniteElementCollection_swigregister(FiniteElementCollection) @@ -194,6 +218,7 @@ def SubDofOrder(self, Geom, SDim, Info, dofs): def FiniteElementCollection_New(name): r"""FiniteElementCollection_New(char const * name) -> FiniteElementCollection""" return _fe_coll.FiniteElementCollection_New(name) +FiniteElementCollection_New = _fe_coll.FiniteElementCollection_New class H1_FECollection(FiniteElementCollection): r"""Proxy of C++ mfem::H1_FECollection class.""" @@ -208,30 +233,37 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.H1_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.H1_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.H1_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.H1_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.H1_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.H1_FECollection_DofOrderForOrientation) def Name(self): r"""Name(H1_FECollection self) -> char const *""" return _fe_coll.H1_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.H1_FECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(H1_FECollection self) -> FiniteElementCollection""" return _fe_coll.H1_FECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.H1_FECollection_GetTraceCollection) def GetBasisType(self): r"""GetBasisType(H1_FECollection self) -> int""" return _fe_coll.H1_FECollection_GetBasisType(self) + GetBasisType = _swig_new_instance_method(_fe_coll.H1_FECollection_GetBasisType) def GetDofMap(self, GeomType): r"""GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *""" return _fe_coll.H1_FECollection_GetDofMap(self, GeomType) + GetDofMap = _swig_new_instance_method(_fe_coll.H1_FECollection_GetDofMap) __swig_destroy__ = _fe_coll.delete_H1_FECollection # Register H1_FECollection in _fe_coll: @@ -251,6 +283,20 @@ def __init__(self, p, dim=3): # Register H1Pos_FECollection in _fe_coll: _fe_coll.H1Pos_FECollection_swigregister(H1Pos_FECollection) +class H1Ser_FECollection(H1_FECollection): + r"""Proxy of C++ mfem::H1Ser_FECollection class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, p, dim=2): + r"""__init__(H1Ser_FECollection self, int const p, int const dim=2) -> H1Ser_FECollection""" + _fe_coll.H1Ser_FECollection_swiginit(self, _fe_coll.new_H1Ser_FECollection(p, dim)) + __swig_destroy__ = _fe_coll.delete_H1Ser_FECollection + +# Register H1Ser_FECollection in _fe_coll: +_fe_coll.H1Ser_FECollection_swigregister(H1Ser_FECollection) + class H1_Trace_FECollection(H1_FECollection): r"""Proxy of C++ mfem::H1_Trace_FECollection class.""" @@ -278,26 +324,32 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.L2_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.L2_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.L2_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.L2_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.L2_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.L2_FECollection_DofOrderForOrientation) def Name(self): r"""Name(L2_FECollection self) -> char const *""" return _fe_coll.L2_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.L2_FECollection_Name) def TraceFiniteElementForGeometry(self, GeomType): r"""TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.L2_FECollection_TraceFiniteElementForGeometry(self, GeomType) + TraceFiniteElementForGeometry = _swig_new_instance_method(_fe_coll.L2_FECollection_TraceFiniteElementForGeometry) def GetBasisType(self): r"""GetBasisType(L2_FECollection self) -> int""" return _fe_coll.L2_FECollection_GetBasisType(self) + GetBasisType = _swig_new_instance_method(_fe_coll.L2_FECollection_GetBasisType) __swig_destroy__ = _fe_coll.delete_L2_FECollection # Register L2_FECollection in _fe_coll: @@ -316,22 +368,27 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT_FECollection_DofOrderForOrientation) def Name(self): r"""Name(RT_FECollection self) -> char const *""" return _fe_coll.RT_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT_FECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(RT_FECollection self) -> FiniteElementCollection""" return _fe_coll.RT_FECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.RT_FECollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_RT_FECollection # Register RT_FECollection in _fe_coll: @@ -378,22 +435,27 @@ def __init__(self, *args): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.ND_FECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.ND_FECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.ND_FECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.ND_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.ND_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.ND_FECollection_DofOrderForOrientation) def Name(self): r"""Name(ND_FECollection self) -> char const *""" return _fe_coll.ND_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.ND_FECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(ND_FECollection self) -> FiniteElementCollection""" return _fe_coll.ND_FECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.ND_FECollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_ND_FECollection # Register ND_FECollection in _fe_coll: @@ -428,34 +490,42 @@ def __init__(self, *args): def Reset(self): r"""Reset(NURBSFECollection self)""" return _fe_coll.NURBSFECollection_Reset(self) + Reset = _swig_new_instance_method(_fe_coll.NURBSFECollection_Reset) def GetOrder(self): r"""GetOrder(NURBSFECollection self) -> int""" return _fe_coll.NURBSFECollection_GetOrder(self) + GetOrder = _swig_new_instance_method(_fe_coll.NURBSFECollection_GetOrder) def SetOrder(self, Order): r"""SetOrder(NURBSFECollection self, int Order)""" return _fe_coll.NURBSFECollection_SetOrder(self, Order) + SetOrder = _swig_new_instance_method(_fe_coll.NURBSFECollection_SetOrder) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.NURBSFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.NURBSFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.NURBSFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.NURBSFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.NURBSFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.NURBSFECollection_DofOrderForOrientation) def Name(self): r"""Name(NURBSFECollection self) -> char const *""" return _fe_coll.NURBSFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.NURBSFECollection_Name) def GetTraceCollection(self): r"""GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection""" return _fe_coll.NURBSFECollection_GetTraceCollection(self) + GetTraceCollection = _swig_new_instance_method(_fe_coll.NURBSFECollection_GetTraceCollection) __swig_destroy__ = _fe_coll.delete_NURBSFECollection # Register NURBSFECollection in _fe_coll: @@ -474,18 +544,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearFECollection self) -> char const *""" return _fe_coll.LinearFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearFECollection # Register LinearFECollection in _fe_coll: @@ -504,18 +578,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticFECollection self) -> char const *""" return _fe_coll.QuadraticFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticFECollection # Register QuadraticFECollection in _fe_coll: @@ -534,18 +612,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticPosFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticPosFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticPosFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticPosFECollection self) -> char const *""" return _fe_coll.QuadraticPosFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticPosFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticPosFECollection # Register QuadraticPosFECollection in _fe_coll: @@ -564,18 +646,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.CubicFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.CubicFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.CubicFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.CubicFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.CubicFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.CubicFECollection_DofOrderForOrientation) def Name(self): r"""Name(CubicFECollection self) -> char const *""" return _fe_coll.CubicFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.CubicFECollection_Name) __swig_destroy__ = _fe_coll.delete_CubicFECollection # Register CubicFECollection in _fe_coll: @@ -594,18 +680,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.CrouzeixRaviartFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.CrouzeixRaviartFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.CrouzeixRaviartFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_DofOrderForOrientation) def Name(self): r"""Name(CrouzeixRaviartFECollection self) -> char const *""" return _fe_coll.CrouzeixRaviartFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.CrouzeixRaviartFECollection_Name) __swig_destroy__ = _fe_coll.delete_CrouzeixRaviartFECollection # Register CrouzeixRaviartFECollection in _fe_coll: @@ -624,18 +714,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearNonConf3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearNonConf3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearNonConf3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearNonConf3DFECollection self) -> char const *""" return _fe_coll.LinearNonConf3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearNonConf3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearNonConf3DFECollection # Register LinearNonConf3DFECollection in _fe_coll: @@ -654,18 +748,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT0_2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT0_2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT0_2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT0_2DFECollection self) -> char const *""" return _fe_coll.RT0_2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT0_2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT0_2DFECollection # Register RT0_2DFECollection in _fe_coll: @@ -684,18 +782,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT1_2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT1_2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT1_2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT1_2DFECollection self) -> char const *""" return _fe_coll.RT1_2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT1_2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT1_2DFECollection # Register RT1_2DFECollection in _fe_coll: @@ -714,18 +816,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT2_2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT2_2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT2_2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT2_2DFECollection self) -> char const *""" return _fe_coll.RT2_2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT2_2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT2_2DFECollection # Register RT2_2DFECollection in _fe_coll: @@ -744,18 +850,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.Const2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.Const2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.Const2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.Const2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.Const2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.Const2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(Const2DFECollection self) -> char const *""" return _fe_coll.Const2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.Const2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_Const2DFECollection # Register Const2DFECollection in _fe_coll: @@ -774,18 +884,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearDiscont2DFECollection self) -> char const *""" return _fe_coll.LinearDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearDiscont2DFECollection # Register LinearDiscont2DFECollection in _fe_coll: @@ -804,18 +918,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.GaussLinearDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.GaussLinearDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.GaussLinearDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(GaussLinearDiscont2DFECollection self) -> char const *""" return _fe_coll.GaussLinearDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.GaussLinearDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_GaussLinearDiscont2DFECollection # Register GaussLinearDiscont2DFECollection in _fe_coll: @@ -834,18 +952,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.P1OnQuadFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.P1OnQuadFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.P1OnQuadFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_DofOrderForOrientation) def Name(self): r"""Name(P1OnQuadFECollection self) -> char const *""" return _fe_coll.P1OnQuadFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.P1OnQuadFECollection_Name) __swig_destroy__ = _fe_coll.delete_P1OnQuadFECollection # Register P1OnQuadFECollection in _fe_coll: @@ -864,18 +986,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticDiscont2DFECollection self) -> char const *""" return _fe_coll.QuadraticDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticDiscont2DFECollection # Register QuadraticDiscont2DFECollection in _fe_coll: @@ -894,18 +1020,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticPosDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticPosDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticPosDiscont2DFECollection self) -> char const *""" return _fe_coll.QuadraticPosDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticPosDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticPosDiscont2DFECollection # Register QuadraticPosDiscont2DFECollection in _fe_coll: @@ -924,18 +1054,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.GaussQuadraticDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(GaussQuadraticDiscont2DFECollection self) -> char const *""" return _fe_coll.GaussQuadraticDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.GaussQuadraticDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_GaussQuadraticDiscont2DFECollection # Register GaussQuadraticDiscont2DFECollection in _fe_coll: @@ -954,18 +1088,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.CubicDiscont2DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.CubicDiscont2DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.CubicDiscont2DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_DofOrderForOrientation) def Name(self): r"""Name(CubicDiscont2DFECollection self) -> char const *""" return _fe_coll.CubicDiscont2DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.CubicDiscont2DFECollection_Name) __swig_destroy__ = _fe_coll.delete_CubicDiscont2DFECollection # Register CubicDiscont2DFECollection in _fe_coll: @@ -984,18 +1122,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.Const3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.Const3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.Const3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.Const3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.Const3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.Const3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(Const3DFECollection self) -> char const *""" return _fe_coll.Const3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.Const3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_Const3DFECollection # Register Const3DFECollection in _fe_coll: @@ -1014,18 +1156,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.LinearDiscont3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.LinearDiscont3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.LinearDiscont3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(LinearDiscont3DFECollection self) -> char const *""" return _fe_coll.LinearDiscont3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.LinearDiscont3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_LinearDiscont3DFECollection # Register LinearDiscont3DFECollection in _fe_coll: @@ -1044,18 +1190,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.QuadraticDiscont3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.QuadraticDiscont3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.QuadraticDiscont3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(QuadraticDiscont3DFECollection self) -> char const *""" return _fe_coll.QuadraticDiscont3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.QuadraticDiscont3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_QuadraticDiscont3DFECollection # Register QuadraticDiscont3DFECollection in _fe_coll: @@ -1074,18 +1224,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RefinedLinearFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RefinedLinearFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RefinedLinearFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_DofOrderForOrientation) def Name(self): r"""Name(RefinedLinearFECollection self) -> char const *""" return _fe_coll.RefinedLinearFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RefinedLinearFECollection_Name) __swig_destroy__ = _fe_coll.delete_RefinedLinearFECollection # Register RefinedLinearFECollection in _fe_coll: @@ -1104,18 +1258,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.ND1_3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.ND1_3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.ND1_3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(ND1_3DFECollection self) -> char const *""" return _fe_coll.ND1_3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.ND1_3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_ND1_3DFECollection # Register ND1_3DFECollection in _fe_coll: @@ -1134,18 +1292,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT0_3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT0_3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT0_3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT0_3DFECollection self) -> char const *""" return _fe_coll.RT0_3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT0_3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT0_3DFECollection # Register RT0_3DFECollection in _fe_coll: @@ -1164,18 +1326,22 @@ def __init__(self): def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" return _fe_coll.RT1_3DFECollection_FiniteElementForGeometry(self, GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_FiniteElementForGeometry) def DofForGeometry(self, GeomType): r"""DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int""" return _fe_coll.RT1_3DFECollection_DofForGeometry(self, GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.RT1_3DFECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_DofOrderForOrientation) def Name(self): r"""Name(RT1_3DFECollection self) -> char const *""" return _fe_coll.RT1_3DFECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.RT1_3DFECollection_Name) __swig_destroy__ = _fe_coll.delete_RT1_3DFECollection # Register RT1_3DFECollection in _fe_coll: @@ -1194,18 +1360,22 @@ def __init__(self, fe_name): def FiniteElementForGeometry(self, _GeomType): r"""FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement""" return _fe_coll.Local_FECollection_FiniteElementForGeometry(self, _GeomType) + FiniteElementForGeometry = _swig_new_instance_method(_fe_coll.Local_FECollection_FiniteElementForGeometry) def DofForGeometry(self, _GeomType): r"""DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int""" return _fe_coll.Local_FECollection_DofForGeometry(self, _GeomType) + DofForGeometry = _swig_new_instance_method(_fe_coll.Local_FECollection_DofForGeometry) def DofOrderForOrientation(self, GeomType, Or): r"""DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *""" return _fe_coll.Local_FECollection_DofOrderForOrientation(self, GeomType, Or) + DofOrderForOrientation = _swig_new_instance_method(_fe_coll.Local_FECollection_DofOrderForOrientation) def Name(self): r"""Name(Local_FECollection self) -> char const *""" return _fe_coll.Local_FECollection_Name(self) + Name = _swig_new_instance_method(_fe_coll.Local_FECollection_Name) __swig_destroy__ = _fe_coll.delete_Local_FECollection # Register Local_FECollection in _fe_coll: diff --git a/mfem/_ser/fe_coll_wrap.cxx b/mfem/_ser/fe_coll_wrap.cxx index 6fb16d9a..0d4a24db 100644 --- a/mfem/_ser/fe_coll_wrap.cxx +++ b/mfem/_ser/fe_coll_wrap.cxx @@ -3066,157 +3066,161 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_double swig_types[2] -#define SWIGTYPE_p_doublep swig_types[3] -#define SWIGTYPE_p_hex_t swig_types[4] -#define SWIGTYPE_p_int swig_types[5] -#define SWIGTYPE_p_intp swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[8] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[12] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[13] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[14] -#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[15] -#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[16] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[17] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[18] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[22] -#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[23] -#define SWIGTYPE_p_mfem__CubicFECollection swig_types[24] -#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[25] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[26] -#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[27] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[28] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[29] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[30] -#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[31] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[32] -#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[33] -#define SWIGTYPE_p_mfem__GridFunction swig_types[34] -#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[35] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[36] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[37] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[38] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[39] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[40] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[41] -#define SWIGTYPE_p_mfem__H1_FECollection swig_types[42] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[43] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[44] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[45] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[46] -#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[47] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[48] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[49] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[50] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[51] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[52] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[53] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[54] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[55] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[56] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[57] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[59] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[60] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[62] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[63] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[64] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[65] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[66] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[67] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[68] -#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[69] -#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[70] -#define SWIGTYPE_p_mfem__LinearFECollection swig_types[71] -#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[72] -#define SWIGTYPE_p_mfem__Local_FECollection swig_types[73] -#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[74] -#define SWIGTYPE_p_mfem__ND_FECollection swig_types[75] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[76] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[77] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[78] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[79] -#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[80] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[81] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[82] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[83] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[85] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[91] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[98] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[109] -#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[110] -#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[111] -#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[112] -#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[113] -#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[114] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[118] -#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[119] -#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[120] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[123] -#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[124] -#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[125] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[126] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[127] -#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[128] -#define SWIGTYPE_p_mfem__RT_FECollection swig_types[129] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[130] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[131] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[132] -#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[133] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[134] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[135] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[136] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[137] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[138] -#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[139] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[140] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[141] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[142] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[143] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[144] -#define SWIGTYPE_p_pri_t swig_types[145] -#define SWIGTYPE_p_quad_t swig_types[146] -#define SWIGTYPE_p_seg_t swig_types[147] -#define SWIGTYPE_p_tet_t swig_types[148] -#define SWIGTYPE_p_tri_t swig_types[149] -static swig_type_info *swig_types[151]; -static swig_module_info swig_module = {swig_types, 150, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_double swig_types[3] +#define SWIGTYPE_p_doublep swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_intp swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[9] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[13] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[14] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[15] +#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[16] +#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[17] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[18] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[19] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[24] +#define SWIGTYPE_p_mfem__CubicFECollection swig_types[25] +#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[26] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[27] +#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[28] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[29] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[30] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[31] +#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[32] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[33] +#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[34] +#define SWIGTYPE_p_mfem__GridFunction swig_types[35] +#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[36] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[37] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[38] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[39] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[40] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[41] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[42] +#define SWIGTYPE_p_mfem__H1Ser_FECollection swig_types[43] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[44] +#define SWIGTYPE_p_mfem__H1_FECollection swig_types[45] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[46] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[47] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[48] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[49] +#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[50] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[51] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[52] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[53] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[54] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[55] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[56] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[57] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[58] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[59] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[60] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[61] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[62] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[63] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[64] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[65] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[66] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[67] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[70] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[71] +#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[72] +#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[73] +#define SWIGTYPE_p_mfem__LinearFECollection swig_types[74] +#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[75] +#define SWIGTYPE_p_mfem__Local_FECollection swig_types[76] +#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[77] +#define SWIGTYPE_p_mfem__ND_FECollection swig_types[78] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[79] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[80] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[81] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[82] +#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[83] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[84] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[85] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[86] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[88] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[94] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[99] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[101] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[106] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[110] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[111] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[112] +#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[113] +#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[114] +#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[115] +#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[116] +#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[117] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[118] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[122] +#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[123] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[125] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[126] +#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[127] +#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[128] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[129] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[130] +#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[131] +#define SWIGTYPE_p_mfem__RT_FECollection swig_types[132] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[133] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[134] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[135] +#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[136] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[137] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[138] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[139] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[140] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[141] +#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[142] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[143] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[144] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[145] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[146] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[147] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[148] +#define SWIGTYPE_p_pri_t swig_types[149] +#define SWIGTYPE_p_quad_t swig_types[150] +#define SWIGTYPE_p_seg_t swig_types[151] +#define SWIGTYPE_p_tet_t swig_types[152] +#define SWIGTYPE_p_tri_t swig_types[153] +static swig_type_info *swig_types[155]; +static swig_module_info swig_module = {swig_types, 154, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5273,6 +5277,196 @@ SWIGINTERN PyObject *H1Pos_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + mfem::H1Ser_FECollection *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::H1Ser_FECollection *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1Ser_FECollection", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_H1Ser_FECollection__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_H1Ser_FECollection__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1Ser_FECollection'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::H1Ser_FECollection::H1Ser_FECollection(int const,int const)\n" + " mfem::H1Ser_FECollection::H1Ser_FECollection(int const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Ser_FECollection *arg1 = (mfem::H1Ser_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Ser_FECollection" "', argument " "1"" of type '" "mfem::H1Ser_FECollection *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_FECollection * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *H1Ser_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1Ser_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; @@ -15592,6 +15786,7 @@ SWIGINTERN PyObject *Local_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, @@ -15634,6 +15829,10 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, + { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, + { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, @@ -15894,15 +16093,316 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, + { "delete_intp", _wrap_delete_intp, METH_O, NULL}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_value", _wrap_intp_value, METH_O, NULL}, + { "intp_cast", _wrap_intp_cast, METH_O, NULL}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, + { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_value", _wrap_doublep_value, METH_O, NULL}, + { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "FiniteElementCollection_FiniteElementForGeometry", _wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_DofForGeometry", _wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS, "DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_DofOrderForOrientation", _wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "FiniteElementCollection_Name", _wrap_FiniteElementCollection_Name, METH_O, "Name(FiniteElementCollection self) -> char const *"}, + { "FiniteElementCollection_HasFaceDofs", _wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS, "HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_TraceFiniteElementForGeometry", _wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_GetTraceCollection", _wrap_FiniteElementCollection_GetTraceCollection, METH_O, "GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection"}, + { "delete_FiniteElementCollection", _wrap_delete_FiniteElementCollection, METH_O, "delete_FiniteElementCollection(FiniteElementCollection self)"}, + { "FiniteElementCollection_New", _wrap_FiniteElementCollection_New, METH_O, "New(char const * name) -> FiniteElementCollection"}, + { "FiniteElementCollection_SubDofOrder", _wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS, "SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, + { "FiniteElementCollection_swigregister", FiniteElementCollection_swigregister, METH_O, NULL}, + { "new_H1_FECollection", _wrap_new_H1_FECollection, METH_VARARGS, "H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto)"}, + { "H1_FECollection_FiniteElementForGeometry", _wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "H1_FECollection_DofForGeometry", _wrap_H1_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "H1_FECollection_DofOrderForOrientation", _wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "H1_FECollection_Name", _wrap_H1_FECollection_Name, METH_O, "Name(H1_FECollection self) -> char const *"}, + { "H1_FECollection_GetTraceCollection", _wrap_H1_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(H1_FECollection self) -> FiniteElementCollection"}, + { "H1_FECollection_GetBasisType", _wrap_H1_FECollection_GetBasisType, METH_O, "GetBasisType(H1_FECollection self) -> int"}, + { "H1_FECollection_GetDofMap", _wrap_H1_FECollection_GetDofMap, METH_VARARGS, "GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, + { "delete_H1_FECollection", _wrap_delete_H1_FECollection, METH_O, "delete_H1_FECollection(H1_FECollection self)"}, + { "H1_FECollection_swigregister", H1_FECollection_swigregister, METH_O, NULL}, + { "H1_FECollection_swiginit", H1_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_FECollection", _wrap_new_H1Pos_FECollection, METH_VARARGS, "H1Pos_FECollection(int const p, int const dim=3)"}, + { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, + { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, + { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, + { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, + { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, + { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, + { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, + { "H1_Trace_FECollection_swiginit", H1_Trace_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_L2_FECollection", _wrap_new_L2_FECollection, METH_VARARGS, "L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE)"}, + { "L2_FECollection_FiniteElementForGeometry", _wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_DofForGeometry", _wrap_L2_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "L2_FECollection_DofOrderForOrientation", _wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "L2_FECollection_Name", _wrap_L2_FECollection_Name, METH_O, "Name(L2_FECollection self) -> char const *"}, + { "L2_FECollection_TraceFiniteElementForGeometry", _wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_GetBasisType", _wrap_L2_FECollection_GetBasisType, METH_O, "GetBasisType(L2_FECollection self) -> int"}, + { "delete_L2_FECollection", _wrap_delete_L2_FECollection, METH_O, "delete_L2_FECollection(L2_FECollection self)"}, + { "L2_FECollection_swigregister", L2_FECollection_swigregister, METH_O, NULL}, + { "L2_FECollection_swiginit", L2_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, "RT_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "RT_FECollection_FiniteElementForGeometry", _wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT_FECollection_DofForGeometry", _wrap_RT_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT_FECollection_DofOrderForOrientation", _wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT_FECollection_Name", _wrap_RT_FECollection_Name, METH_O, "Name(RT_FECollection self) -> char const *"}, + { "RT_FECollection_GetTraceCollection", _wrap_RT_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(RT_FECollection self) -> FiniteElementCollection"}, + { "delete_RT_FECollection", _wrap_delete_RT_FECollection, METH_O, "delete_RT_FECollection(RT_FECollection self)"}, + { "RT_FECollection_swigregister", RT_FECollection_swigregister, METH_O, NULL}, + { "RT_FECollection_swiginit", RT_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT_Trace_FECollection", _wrap_new_RT_Trace_FECollection, METH_VARARGS, "RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre)"}, + { "delete_RT_Trace_FECollection", _wrap_delete_RT_Trace_FECollection, METH_O, "delete_RT_Trace_FECollection(RT_Trace_FECollection self)"}, + { "RT_Trace_FECollection_swigregister", RT_Trace_FECollection_swigregister, METH_O, NULL}, + { "RT_Trace_FECollection_swiginit", RT_Trace_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_DG_Interface_FECollection", _wrap_new_DG_Interface_FECollection, METH_VARARGS, "DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre)"}, + { "delete_DG_Interface_FECollection", _wrap_delete_DG_Interface_FECollection, METH_O, "delete_DG_Interface_FECollection(DG_Interface_FECollection self)"}, + { "DG_Interface_FECollection_swigregister", DG_Interface_FECollection_swigregister, METH_O, NULL}, + { "DG_Interface_FECollection_swiginit", DG_Interface_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_ND_FECollection", _wrap_new_ND_FECollection, METH_VARARGS, "ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "ND_FECollection_FiniteElementForGeometry", _wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND_FECollection_DofForGeometry", _wrap_ND_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND_FECollection_DofOrderForOrientation", _wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND_FECollection_Name", _wrap_ND_FECollection_Name, METH_O, "Name(ND_FECollection self) -> char const *"}, + { "ND_FECollection_GetTraceCollection", _wrap_ND_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(ND_FECollection self) -> FiniteElementCollection"}, + { "delete_ND_FECollection", _wrap_delete_ND_FECollection, METH_O, "delete_ND_FECollection(ND_FECollection self)"}, + { "ND_FECollection_swigregister", ND_FECollection_swigregister, METH_O, NULL}, + { "ND_FECollection_swiginit", ND_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_ND_Trace_FECollection", _wrap_new_ND_Trace_FECollection, METH_VARARGS, "ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "delete_ND_Trace_FECollection", _wrap_delete_ND_Trace_FECollection, METH_O, "delete_ND_Trace_FECollection(ND_Trace_FECollection self)"}, + { "ND_Trace_FECollection_swigregister", ND_Trace_FECollection_swigregister, METH_O, NULL}, + { "ND_Trace_FECollection_swiginit", ND_Trace_FECollection_swiginit, METH_VARARGS, NULL}, + { "new_NURBSFECollection", _wrap_new_NURBSFECollection, METH_VARARGS, "NURBSFECollection(int Order=VariableOrder)"}, + { "NURBSFECollection_Reset", _wrap_NURBSFECollection_Reset, METH_O, "Reset(NURBSFECollection self)"}, + { "NURBSFECollection_GetOrder", _wrap_NURBSFECollection_GetOrder, METH_O, "GetOrder(NURBSFECollection self) -> int"}, + { "NURBSFECollection_SetOrder", _wrap_NURBSFECollection_SetOrder, METH_VARARGS, "SetOrder(NURBSFECollection self, int Order)"}, + { "NURBSFECollection_FiniteElementForGeometry", _wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "NURBSFECollection_DofForGeometry", _wrap_NURBSFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "NURBSFECollection_DofOrderForOrientation", _wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "NURBSFECollection_Name", _wrap_NURBSFECollection_Name, METH_O, "Name(NURBSFECollection self) -> char const *"}, + { "NURBSFECollection_GetTraceCollection", _wrap_NURBSFECollection_GetTraceCollection, METH_O, "GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection"}, + { "delete_NURBSFECollection", _wrap_delete_NURBSFECollection, METH_O, "delete_NURBSFECollection(NURBSFECollection self)"}, + { "NURBSFECollection_swigregister", NURBSFECollection_swigregister, METH_O, NULL}, + { "NURBSFECollection_swiginit", NURBSFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearFECollection", _wrap_new_LinearFECollection, METH_NOARGS, "new_LinearFECollection() -> LinearFECollection"}, + { "LinearFECollection_FiniteElementForGeometry", _wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearFECollection_DofForGeometry", _wrap_LinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearFECollection_DofOrderForOrientation", _wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearFECollection_Name", _wrap_LinearFECollection_Name, METH_O, "Name(LinearFECollection self) -> char const *"}, + { "delete_LinearFECollection", _wrap_delete_LinearFECollection, METH_O, "delete_LinearFECollection(LinearFECollection self)"}, + { "LinearFECollection_swigregister", LinearFECollection_swigregister, METH_O, NULL}, + { "LinearFECollection_swiginit", LinearFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticFECollection", _wrap_new_QuadraticFECollection, METH_NOARGS, "new_QuadraticFECollection() -> QuadraticFECollection"}, + { "QuadraticFECollection_FiniteElementForGeometry", _wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticFECollection_DofForGeometry", _wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticFECollection_DofOrderForOrientation", _wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticFECollection_Name", _wrap_QuadraticFECollection_Name, METH_O, "Name(QuadraticFECollection self) -> char const *"}, + { "delete_QuadraticFECollection", _wrap_delete_QuadraticFECollection, METH_O, "delete_QuadraticFECollection(QuadraticFECollection self)"}, + { "QuadraticFECollection_swigregister", QuadraticFECollection_swigregister, METH_O, NULL}, + { "QuadraticFECollection_swiginit", QuadraticFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticPosFECollection", _wrap_new_QuadraticPosFECollection, METH_NOARGS, "new_QuadraticPosFECollection() -> QuadraticPosFECollection"}, + { "QuadraticPosFECollection_FiniteElementForGeometry", _wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosFECollection_DofForGeometry", _wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosFECollection_DofOrderForOrientation", _wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosFECollection_Name", _wrap_QuadraticPosFECollection_Name, METH_O, "Name(QuadraticPosFECollection self) -> char const *"}, + { "delete_QuadraticPosFECollection", _wrap_delete_QuadraticPosFECollection, METH_O, "delete_QuadraticPosFECollection(QuadraticPosFECollection self)"}, + { "QuadraticPosFECollection_swigregister", QuadraticPosFECollection_swigregister, METH_O, NULL}, + { "QuadraticPosFECollection_swiginit", QuadraticPosFECollection_swiginit, METH_VARARGS, NULL}, + { "new_CubicFECollection", _wrap_new_CubicFECollection, METH_NOARGS, "new_CubicFECollection() -> CubicFECollection"}, + { "CubicFECollection_FiniteElementForGeometry", _wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicFECollection_DofForGeometry", _wrap_CubicFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicFECollection_DofOrderForOrientation", _wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicFECollection_Name", _wrap_CubicFECollection_Name, METH_O, "Name(CubicFECollection self) -> char const *"}, + { "delete_CubicFECollection", _wrap_delete_CubicFECollection, METH_O, "delete_CubicFECollection(CubicFECollection self)"}, + { "CubicFECollection_swigregister", CubicFECollection_swigregister, METH_O, NULL}, + { "CubicFECollection_swiginit", CubicFECollection_swiginit, METH_VARARGS, NULL}, + { "new_CrouzeixRaviartFECollection", _wrap_new_CrouzeixRaviartFECollection, METH_NOARGS, "new_CrouzeixRaviartFECollection() -> CrouzeixRaviartFECollection"}, + { "CrouzeixRaviartFECollection_FiniteElementForGeometry", _wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CrouzeixRaviartFECollection_DofForGeometry", _wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CrouzeixRaviartFECollection_DofOrderForOrientation", _wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CrouzeixRaviartFECollection_Name", _wrap_CrouzeixRaviartFECollection_Name, METH_O, "Name(CrouzeixRaviartFECollection self) -> char const *"}, + { "delete_CrouzeixRaviartFECollection", _wrap_delete_CrouzeixRaviartFECollection, METH_O, "delete_CrouzeixRaviartFECollection(CrouzeixRaviartFECollection self)"}, + { "CrouzeixRaviartFECollection_swigregister", CrouzeixRaviartFECollection_swigregister, METH_O, NULL}, + { "CrouzeixRaviartFECollection_swiginit", CrouzeixRaviartFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearNonConf3DFECollection", _wrap_new_LinearNonConf3DFECollection, METH_NOARGS, "new_LinearNonConf3DFECollection() -> LinearNonConf3DFECollection"}, + { "LinearNonConf3DFECollection_FiniteElementForGeometry", _wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearNonConf3DFECollection_DofForGeometry", _wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearNonConf3DFECollection_DofOrderForOrientation", _wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearNonConf3DFECollection_Name", _wrap_LinearNonConf3DFECollection_Name, METH_O, "Name(LinearNonConf3DFECollection self) -> char const *"}, + { "delete_LinearNonConf3DFECollection", _wrap_delete_LinearNonConf3DFECollection, METH_O, "delete_LinearNonConf3DFECollection(LinearNonConf3DFECollection self)"}, + { "LinearNonConf3DFECollection_swigregister", LinearNonConf3DFECollection_swigregister, METH_O, NULL}, + { "LinearNonConf3DFECollection_swiginit", LinearNonConf3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT0_2DFECollection", _wrap_new_RT0_2DFECollection, METH_NOARGS, "new_RT0_2DFECollection() -> RT0_2DFECollection"}, + { "RT0_2DFECollection_FiniteElementForGeometry", _wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_2DFECollection_DofForGeometry", _wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_2DFECollection_DofOrderForOrientation", _wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_2DFECollection_Name", _wrap_RT0_2DFECollection_Name, METH_O, "Name(RT0_2DFECollection self) -> char const *"}, + { "delete_RT0_2DFECollection", _wrap_delete_RT0_2DFECollection, METH_O, "delete_RT0_2DFECollection(RT0_2DFECollection self)"}, + { "RT0_2DFECollection_swigregister", RT0_2DFECollection_swigregister, METH_O, NULL}, + { "RT0_2DFECollection_swiginit", RT0_2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT1_2DFECollection", _wrap_new_RT1_2DFECollection, METH_NOARGS, "new_RT1_2DFECollection() -> RT1_2DFECollection"}, + { "RT1_2DFECollection_FiniteElementForGeometry", _wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_2DFECollection_DofForGeometry", _wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_2DFECollection_DofOrderForOrientation", _wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_2DFECollection_Name", _wrap_RT1_2DFECollection_Name, METH_O, "Name(RT1_2DFECollection self) -> char const *"}, + { "delete_RT1_2DFECollection", _wrap_delete_RT1_2DFECollection, METH_O, "delete_RT1_2DFECollection(RT1_2DFECollection self)"}, + { "RT1_2DFECollection_swigregister", RT1_2DFECollection_swigregister, METH_O, NULL}, + { "RT1_2DFECollection_swiginit", RT1_2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT2_2DFECollection", _wrap_new_RT2_2DFECollection, METH_NOARGS, "new_RT2_2DFECollection() -> RT2_2DFECollection"}, + { "RT2_2DFECollection_FiniteElementForGeometry", _wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT2_2DFECollection_DofForGeometry", _wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT2_2DFECollection_DofOrderForOrientation", _wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT2_2DFECollection_Name", _wrap_RT2_2DFECollection_Name, METH_O, "Name(RT2_2DFECollection self) -> char const *"}, + { "delete_RT2_2DFECollection", _wrap_delete_RT2_2DFECollection, METH_O, "delete_RT2_2DFECollection(RT2_2DFECollection self)"}, + { "RT2_2DFECollection_swigregister", RT2_2DFECollection_swigregister, METH_O, NULL}, + { "RT2_2DFECollection_swiginit", RT2_2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_Const2DFECollection", _wrap_new_Const2DFECollection, METH_NOARGS, "new_Const2DFECollection() -> Const2DFECollection"}, + { "Const2DFECollection_FiniteElementForGeometry", _wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const2DFECollection_DofForGeometry", _wrap_Const2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const2DFECollection_DofOrderForOrientation", _wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const2DFECollection_Name", _wrap_Const2DFECollection_Name, METH_O, "Name(Const2DFECollection self) -> char const *"}, + { "delete_Const2DFECollection", _wrap_delete_Const2DFECollection, METH_O, "delete_Const2DFECollection(Const2DFECollection self)"}, + { "Const2DFECollection_swigregister", Const2DFECollection_swigregister, METH_O, NULL}, + { "Const2DFECollection_swiginit", Const2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearDiscont2DFECollection", _wrap_new_LinearDiscont2DFECollection, METH_NOARGS, "new_LinearDiscont2DFECollection() -> LinearDiscont2DFECollection"}, + { "LinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont2DFECollection_DofForGeometry", _wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont2DFECollection_DofOrderForOrientation", _wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont2DFECollection_Name", _wrap_LinearDiscont2DFECollection_Name, METH_O, "Name(LinearDiscont2DFECollection self) -> char const *"}, + { "delete_LinearDiscont2DFECollection", _wrap_delete_LinearDiscont2DFECollection, METH_O, "delete_LinearDiscont2DFECollection(LinearDiscont2DFECollection self)"}, + { "LinearDiscont2DFECollection_swigregister", LinearDiscont2DFECollection_swigregister, METH_O, NULL}, + { "LinearDiscont2DFECollection_swiginit", LinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_GaussLinearDiscont2DFECollection", _wrap_new_GaussLinearDiscont2DFECollection, METH_NOARGS, "new_GaussLinearDiscont2DFECollection() -> GaussLinearDiscont2DFECollection"}, + { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussLinearDiscont2DFECollection_DofForGeometry", _wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussLinearDiscont2DFECollection_Name", _wrap_GaussLinearDiscont2DFECollection_Name, METH_O, "Name(GaussLinearDiscont2DFECollection self) -> char const *"}, + { "delete_GaussLinearDiscont2DFECollection", _wrap_delete_GaussLinearDiscont2DFECollection, METH_O, "delete_GaussLinearDiscont2DFECollection(GaussLinearDiscont2DFECollection self)"}, + { "GaussLinearDiscont2DFECollection_swigregister", GaussLinearDiscont2DFECollection_swigregister, METH_O, NULL}, + { "GaussLinearDiscont2DFECollection_swiginit", GaussLinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_P1OnQuadFECollection", _wrap_new_P1OnQuadFECollection, METH_NOARGS, "new_P1OnQuadFECollection() -> P1OnQuadFECollection"}, + { "P1OnQuadFECollection_FiniteElementForGeometry", _wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "P1OnQuadFECollection_DofForGeometry", _wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "P1OnQuadFECollection_DofOrderForOrientation", _wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "P1OnQuadFECollection_Name", _wrap_P1OnQuadFECollection_Name, METH_O, "Name(P1OnQuadFECollection self) -> char const *"}, + { "delete_P1OnQuadFECollection", _wrap_delete_P1OnQuadFECollection, METH_O, "delete_P1OnQuadFECollection(P1OnQuadFECollection self)"}, + { "P1OnQuadFECollection_swigregister", P1OnQuadFECollection_swigregister, METH_O, NULL}, + { "P1OnQuadFECollection_swiginit", P1OnQuadFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticDiscont2DFECollection", _wrap_new_QuadraticDiscont2DFECollection, METH_NOARGS, "new_QuadraticDiscont2DFECollection() -> QuadraticDiscont2DFECollection"}, + { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont2DFECollection_DofForGeometry", _wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont2DFECollection_Name", _wrap_QuadraticDiscont2DFECollection_Name, METH_O, "Name(QuadraticDiscont2DFECollection self) -> char const *"}, + { "delete_QuadraticDiscont2DFECollection", _wrap_delete_QuadraticDiscont2DFECollection, METH_O, "delete_QuadraticDiscont2DFECollection(QuadraticDiscont2DFECollection self)"}, + { "QuadraticDiscont2DFECollection_swigregister", QuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, + { "QuadraticDiscont2DFECollection_swiginit", QuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticPosDiscont2DFECollection", _wrap_new_QuadraticPosDiscont2DFECollection, METH_NOARGS, "new_QuadraticPosDiscont2DFECollection() -> QuadraticPosDiscont2DFECollection"}, + { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosDiscont2DFECollection_DofForGeometry", _wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosDiscont2DFECollection_Name", _wrap_QuadraticPosDiscont2DFECollection_Name, METH_O, "Name(QuadraticPosDiscont2DFECollection self) -> char const *"}, + { "delete_QuadraticPosDiscont2DFECollection", _wrap_delete_QuadraticPosDiscont2DFECollection, METH_O, "delete_QuadraticPosDiscont2DFECollection(QuadraticPosDiscont2DFECollection self)"}, + { "QuadraticPosDiscont2DFECollection_swigregister", QuadraticPosDiscont2DFECollection_swigregister, METH_O, NULL}, + { "QuadraticPosDiscont2DFECollection_swiginit", QuadraticPosDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_GaussQuadraticDiscont2DFECollection", _wrap_new_GaussQuadraticDiscont2DFECollection, METH_NOARGS, "new_GaussQuadraticDiscont2DFECollection() -> GaussQuadraticDiscont2DFECollection"}, + { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussQuadraticDiscont2DFECollection_DofForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussQuadraticDiscont2DFECollection_Name", _wrap_GaussQuadraticDiscont2DFECollection_Name, METH_O, "Name(GaussQuadraticDiscont2DFECollection self) -> char const *"}, + { "delete_GaussQuadraticDiscont2DFECollection", _wrap_delete_GaussQuadraticDiscont2DFECollection, METH_O, "delete_GaussQuadraticDiscont2DFECollection(GaussQuadraticDiscont2DFECollection self)"}, + { "GaussQuadraticDiscont2DFECollection_swigregister", GaussQuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, + { "GaussQuadraticDiscont2DFECollection_swiginit", GaussQuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_CubicDiscont2DFECollection", _wrap_new_CubicDiscont2DFECollection, METH_NOARGS, "new_CubicDiscont2DFECollection() -> CubicDiscont2DFECollection"}, + { "CubicDiscont2DFECollection_FiniteElementForGeometry", _wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicDiscont2DFECollection_DofForGeometry", _wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicDiscont2DFECollection_DofOrderForOrientation", _wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicDiscont2DFECollection_Name", _wrap_CubicDiscont2DFECollection_Name, METH_O, "Name(CubicDiscont2DFECollection self) -> char const *"}, + { "delete_CubicDiscont2DFECollection", _wrap_delete_CubicDiscont2DFECollection, METH_O, "delete_CubicDiscont2DFECollection(CubicDiscont2DFECollection self)"}, + { "CubicDiscont2DFECollection_swigregister", CubicDiscont2DFECollection_swigregister, METH_O, NULL}, + { "CubicDiscont2DFECollection_swiginit", CubicDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_Const3DFECollection", _wrap_new_Const3DFECollection, METH_NOARGS, "new_Const3DFECollection() -> Const3DFECollection"}, + { "Const3DFECollection_FiniteElementForGeometry", _wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const3DFECollection_DofForGeometry", _wrap_Const3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const3DFECollection_DofOrderForOrientation", _wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const3DFECollection_Name", _wrap_Const3DFECollection_Name, METH_O, "Name(Const3DFECollection self) -> char const *"}, + { "delete_Const3DFECollection", _wrap_delete_Const3DFECollection, METH_O, "delete_Const3DFECollection(Const3DFECollection self)"}, + { "Const3DFECollection_swigregister", Const3DFECollection_swigregister, METH_O, NULL}, + { "Const3DFECollection_swiginit", Const3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_LinearDiscont3DFECollection", _wrap_new_LinearDiscont3DFECollection, METH_NOARGS, "new_LinearDiscont3DFECollection() -> LinearDiscont3DFECollection"}, + { "LinearDiscont3DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont3DFECollection_DofForGeometry", _wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont3DFECollection_DofOrderForOrientation", _wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont3DFECollection_Name", _wrap_LinearDiscont3DFECollection_Name, METH_O, "Name(LinearDiscont3DFECollection self) -> char const *"}, + { "delete_LinearDiscont3DFECollection", _wrap_delete_LinearDiscont3DFECollection, METH_O, "delete_LinearDiscont3DFECollection(LinearDiscont3DFECollection self)"}, + { "LinearDiscont3DFECollection_swigregister", LinearDiscont3DFECollection_swigregister, METH_O, NULL}, + { "LinearDiscont3DFECollection_swiginit", LinearDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_QuadraticDiscont3DFECollection", _wrap_new_QuadraticDiscont3DFECollection, METH_NOARGS, "new_QuadraticDiscont3DFECollection() -> QuadraticDiscont3DFECollection"}, + { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont3DFECollection_DofForGeometry", _wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont3DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont3DFECollection_Name", _wrap_QuadraticDiscont3DFECollection_Name, METH_O, "Name(QuadraticDiscont3DFECollection self) -> char const *"}, + { "delete_QuadraticDiscont3DFECollection", _wrap_delete_QuadraticDiscont3DFECollection, METH_O, "delete_QuadraticDiscont3DFECollection(QuadraticDiscont3DFECollection self)"}, + { "QuadraticDiscont3DFECollection_swigregister", QuadraticDiscont3DFECollection_swigregister, METH_O, NULL}, + { "QuadraticDiscont3DFECollection_swiginit", QuadraticDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinearFECollection", _wrap_new_RefinedLinearFECollection, METH_NOARGS, "new_RefinedLinearFECollection() -> RefinedLinearFECollection"}, + { "RefinedLinearFECollection_FiniteElementForGeometry", _wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RefinedLinearFECollection_DofForGeometry", _wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RefinedLinearFECollection_DofOrderForOrientation", _wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RefinedLinearFECollection_Name", _wrap_RefinedLinearFECollection_Name, METH_O, "Name(RefinedLinearFECollection self) -> char const *"}, + { "delete_RefinedLinearFECollection", _wrap_delete_RefinedLinearFECollection, METH_O, "delete_RefinedLinearFECollection(RefinedLinearFECollection self)"}, + { "RefinedLinearFECollection_swigregister", RefinedLinearFECollection_swigregister, METH_O, NULL}, + { "RefinedLinearFECollection_swiginit", RefinedLinearFECollection_swiginit, METH_VARARGS, NULL}, + { "new_ND1_3DFECollection", _wrap_new_ND1_3DFECollection, METH_NOARGS, "new_ND1_3DFECollection() -> ND1_3DFECollection"}, + { "ND1_3DFECollection_FiniteElementForGeometry", _wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND1_3DFECollection_DofForGeometry", _wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND1_3DFECollection_DofOrderForOrientation", _wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND1_3DFECollection_Name", _wrap_ND1_3DFECollection_Name, METH_O, "Name(ND1_3DFECollection self) -> char const *"}, + { "delete_ND1_3DFECollection", _wrap_delete_ND1_3DFECollection, METH_O, "delete_ND1_3DFECollection(ND1_3DFECollection self)"}, + { "ND1_3DFECollection_swigregister", ND1_3DFECollection_swigregister, METH_O, NULL}, + { "ND1_3DFECollection_swiginit", ND1_3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT0_3DFECollection", _wrap_new_RT0_3DFECollection, METH_NOARGS, "new_RT0_3DFECollection() -> RT0_3DFECollection"}, + { "RT0_3DFECollection_FiniteElementForGeometry", _wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_3DFECollection_DofForGeometry", _wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_3DFECollection_DofOrderForOrientation", _wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_3DFECollection_Name", _wrap_RT0_3DFECollection_Name, METH_O, "Name(RT0_3DFECollection self) -> char const *"}, + { "delete_RT0_3DFECollection", _wrap_delete_RT0_3DFECollection, METH_O, "delete_RT0_3DFECollection(RT0_3DFECollection self)"}, + { "RT0_3DFECollection_swigregister", RT0_3DFECollection_swigregister, METH_O, NULL}, + { "RT0_3DFECollection_swiginit", RT0_3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_RT1_3DFECollection", _wrap_new_RT1_3DFECollection, METH_NOARGS, "new_RT1_3DFECollection() -> RT1_3DFECollection"}, + { "RT1_3DFECollection_FiniteElementForGeometry", _wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_3DFECollection_DofForGeometry", _wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_3DFECollection_DofOrderForOrientation", _wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_3DFECollection_Name", _wrap_RT1_3DFECollection_Name, METH_O, "Name(RT1_3DFECollection self) -> char const *"}, + { "delete_RT1_3DFECollection", _wrap_delete_RT1_3DFECollection, METH_O, "delete_RT1_3DFECollection(RT1_3DFECollection self)"}, + { "RT1_3DFECollection_swigregister", RT1_3DFECollection_swigregister, METH_O, NULL}, + { "RT1_3DFECollection_swiginit", RT1_3DFECollection_swiginit, METH_VARARGS, NULL}, + { "new_Local_FECollection", _wrap_new_Local_FECollection, METH_O, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, + { "Local_FECollection_FiniteElementForGeometry", _wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, + { "Local_FECollection_DofForGeometry", _wrap_Local_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, + { "Local_FECollection_DofOrderForOrientation", _wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Local_FECollection_Name", _wrap_Local_FECollection_Name, METH_O, "Name(Local_FECollection self) -> char const *"}, + { "delete_Local_FECollection", _wrap_delete_Local_FECollection, METH_O, "delete_Local_FECollection(Local_FECollection self)"}, + { "Local_FECollection_swigregister", Local_FECollection_swigregister, METH_O, NULL}, + { "Local_FECollection_swiginit", Local_FECollection_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); -} static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); } @@ -15960,12 +16460,18 @@ static void *_p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollect static void *_p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::CrouzeixRaviartFECollection *) x)); } +static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +} static void *_p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::H1_FECollection *) x)); } static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -15999,8 +16505,8 @@ static void *_p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection(vo static void *_p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::QuadraticPosFECollection *) x)); } -static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); } static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::Local_FECollection *) x)); @@ -16008,6 +16514,9 @@ static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__H1_FECollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__H1_FECollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__H1_FECollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -16026,12 +16535,6 @@ static void *_p_doublepTo_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) { static void *_p_intpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((int *) ((intp *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -16065,6 +16568,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -16080,6 +16586,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -16248,6 +16757,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -16291,10 +16806,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -16318,6 +16833,7 @@ static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NURBSFiniteElement *) ((mfem::NURBS3DFiniteElement *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; @@ -16347,13 +16863,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -16365,6 +16879,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -16406,6 +16922,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -16434,6 +16952,7 @@ static swig_type_info _swigt__p_mfem__GaussLinearDiscont2DFECollection = {"_p_mf static swig_type_info _swigt__p_mfem__GaussQuadraticDiscont2DFECollection = {"_p_mfem__GaussQuadraticDiscont2DFECollection", "mfem::GaussQuadraticDiscont2DFECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_FECollection = {"_p_mfem__H1Pos_FECollection", "mfem::H1Pos_FECollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_FECollection = {"_p_mfem__H1Ser_FECollection", "mfem::H1Ser_FECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_FECollection = {"_p_mfem__H1_FECollection", "mfem::H1_FECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_Trace_FECollection = {"_p_mfem__H1_Trace_FECollection", "mfem::H1_Trace_FECollection *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__IntegrationRule = {"_p_mfem__IntegrationRule", "mfem::IntegrationRule *", 0, 0, (void*)0, 0}; @@ -16470,6 +16989,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_doublep, @@ -16511,6 +17031,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_FECollection, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_FECollection, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, @@ -16614,6 +17136,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ScalarFiniteElement, &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__VectorFiniteElement, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -16622,6 +17145,7 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0}, {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; @@ -16650,13 +17174,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -16668,6 +17190,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -16709,6 +17233,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -16732,13 +17258,14 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussLinearDiscont2DFECollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussQuadraticDiscont2DFECollection[] = { {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_FECollection[] = { {&_swigt__p_mfem__H1Pos_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1_FECollection[] = { {&_swigt__p_mfem__H1_FECollection, 0, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__H1_FECollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__H1_FECollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_FECollection[] = { {&_swigt__p_mfem__H1Ser_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1_FECollection[] = { {&_swigt__p_mfem__H1_FECollection, 0, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__H1_FECollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__H1_FECollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__H1_FECollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_Trace_FECollection[] = { {&_swigt__p_mfem__H1_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -16774,6 +17301,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_doublep, @@ -16815,6 +17343,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_FECollection, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_FECollection, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, @@ -16918,6 +17448,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ScalarFiniteElement, _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__VectorFiniteElement, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_ser/fe_wrap.cxx b/mfem/_ser/fe_wrap.cxx index 674b3ef7..9c97692a 100644 --- a/mfem/_ser/fe_wrap.cxx +++ b/mfem/_ser/fe_wrap.cxx @@ -3101,92 +3101,94 @@ namespace Swig { #define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[33] #define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[34] #define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[35] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[36] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[37] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[38] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[39] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[40] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[41] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[42] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[43] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[44] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[45] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[46] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[47] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[48] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[49] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[50] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[51] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[52] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[53] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[54] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[55] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[56] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[57] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[58] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[59] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[60] -#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[61] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[62] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[63] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[64] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[65] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[66] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[67] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[68] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[69] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[70] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[76] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[77] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[78] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[79] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[80] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[81] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[82] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[83] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__Poly_1D swig_types[86] -#define SWIGTYPE_p_mfem__Poly_1D__Basis swig_types[87] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[103] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[104] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[105] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[106] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[109] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[110] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[111] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__TensorBasisElement swig_types[114] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__Vector swig_types[116] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[117] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[118] -#define SWIGTYPE_p_p_int swig_types[119] -static swig_type_info *swig_types[121]; -static swig_module_info swig_module = {swig_types, 120, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[36] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[37] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[38] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[39] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[40] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[41] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[42] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[43] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[44] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[45] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[46] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[47] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[49] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[50] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[51] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[52] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[53] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[54] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[55] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[56] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[57] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[58] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[59] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[60] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[61] +#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[62] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[63] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[64] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[65] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[66] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[67] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[70] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[71] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[72] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[73] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[74] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[75] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[79] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[80] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[81] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[82] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[83] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[84] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[85] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[86] +#define SWIGTYPE_p_mfem__Poly_1D swig_types[87] +#define SWIGTYPE_p_mfem__Poly_1D__Basis swig_types[88] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[99] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[104] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[105] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[106] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[107] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[110] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[111] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[112] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__TensorBasisElement swig_types[115] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__Vector swig_types[117] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[118] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[120] +#define SWIGTYPE_p_p_int swig_types[121] +static swig_type_info *swig_types[123]; +static swig_module_info swig_module = {swig_types, 122, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3668,6 +3670,20 @@ SWIGINTERNINLINE PyObject* #define SWIG_From_double PyFloat_FromDouble +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + /* --------------------------------------------------- * C++ director class methods @@ -5999,7 +6015,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6012,31 +6028,31 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysHessian", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::FiniteElement const *)arg1)->GetLocalInterpolation(*arg2,*arg3); + ((mfem::FiniteElement const *)arg1)->CalcPhysHessian(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6060,11 +6076,11 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; - mfem::DenseMatrix *arg3 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6073,31 +6089,31 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLaplacian", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::FiniteElement const *)arg1)->GetLocalRestriction(*arg2,*arg3); + ((mfem::FiniteElement const *)arg1)->CalcPhysLaplacian(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6121,55 +6137,44 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLinLaplacian", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::FiniteElement const *)arg1)->GetTransferMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + ((mfem::FiniteElement const *)arg1)->CalcPhysLinLaplacian(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6193,54 +6198,105 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_Project" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::FiniteElement const *)arg1)->GetLocalInterpolation(*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::FiniteElement const *)arg1)->Project(*arg2,*arg3,*arg4); + ((mfem::FiniteElement const *)arg1)->GetLocalRestriction(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6264,12 +6320,12 @@ SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; + mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6278,40 +6334,41 @@ SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_1(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject *swig_obj[4] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_Project" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - ((mfem::FiniteElement const *)arg1)->Project(*arg2,*arg3,*arg4); + ((mfem::FiniteElement const *)arg1)->GetTransferMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6335,10 +6392,10 @@ SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; - mfem::MatrixCoefficient *arg2 = 0 ; + mfem::Coefficient *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; @@ -6349,41 +6406,40 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_Project" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - ((mfem::FiniteElement const *)arg1)->ProjectMatrixCoefficient(*arg2,*arg3,*arg4); + ((mfem::FiniteElement const *)arg1)->Project(*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6407,40 +6463,183 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_Project" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - ((mfem::FiniteElement const *)arg1)->ProjectDelta(arg2,*arg3); + ((mfem::FiniteElement const *)arg1)->Project(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; + mfem::MatrixCoefficient *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::FiniteElement const *)arg1)->ProjectMatrixCoefficient(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::FiniteElement const *)arg1)->ProjectDelta(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28513,6 +28712,193 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcBernstein(PyObject *self, PyObject *args) } +SWIGINTERN PyObject *_wrap_Poly_1D_CalcLegendre__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + double *arg3 = (double *) 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcLegendre" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Poly_1D_CalcLegendre" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + { + try { + mfem::Poly_1D::CalcLegendre(arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Poly_1D_CalcLegendre__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + double *arg3 = (double *) 0 ; + double *arg4 = (double *) 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcLegendre" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Poly_1D_CalcLegendre" "', argument " "3"" of type '" "double *""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Poly_1D_CalcLegendre" "', argument " "4"" of type '" "double *""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + { + try { + mfem::Poly_1D::CalcLegendre(arg1,arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Poly_1D_CalcLegendre(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Poly_1D_CalcLegendre", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Poly_1D_CalcLegendre__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Poly_1D_CalcLegendre__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Poly_1D_CalcLegendre'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Poly_1D::CalcLegendre(int const,double const,double *)\n" + " mfem::Poly_1D::CalcLegendre(int const,double const,double *,double *)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_delete_Poly_1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; @@ -29097,6 +29483,324 @@ SWIGINTERN PyObject *PositiveTensorFiniteElement_swigregister(PyObject *SWIGUNUS return SWIG_Py_Void(); } +SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + mfem::TensorBasisElement::DofMapType arg7 ; + int val7 ; + int ecode7 = 0 ; + PyObject *swig_obj[7] ; + mfem::VectorTensorFiniteElement *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_VectorTensorFiniteElement", 7, 7, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VectorTensorFiniteElement" "', argument " "7"" of type '" "mfem::TensorBasisElement::DofMapType""'"); + } + arg7 = static_cast< mfem::TensorBasisElement::DofMapType >(val7); + { + try { + result = (mfem::VectorTensorFiniteElement *)new mfem::VectorTensorFiniteElement(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorTensorFiniteElement, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::DofToQuad::Mode arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::DofToQuad *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); + } + arg3 = static_cast< mfem::DofToQuad::Mode >(val3); + { + try { + result = (mfem::DofToQuad *) &((mfem::VectorTensorFiniteElement const *)arg1)->GetDofToQuad((mfem::IntegrationRule const &)*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DofToQuad, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::DofToQuad::Mode arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::DofToQuad *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuadOpen", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); + } + arg3 = static_cast< mfem::DofToQuad::Mode >(val3); + { + try { + result = (mfem::DofToQuad *) &((mfem::VectorTensorFiniteElement const *)arg1)->GetDofToQuadOpen((mfem::IntegrationRule const &)*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DofToQuad, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::DofToQuad::Mode arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + mfem::DofToQuad *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetTensorDofToQuad", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); + } + arg3 = static_cast< mfem::DofToQuad::Mode >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + { + try { + result = (mfem::DofToQuad *) &((mfem::VectorTensorFiniteElement const *)arg1)->GetTensorDofToQuad((mfem::IntegrationRule const &)*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DofToQuad, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorTensorFiniteElement" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement *""'"); + } + arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *VectorTensorFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorTensorFiniteElement, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *VectorTensorFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; @@ -30744,6 +31448,583 @@ SWIGINTERN PyObject *H1Pos_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } +SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + PyObject *swig_obj[1] ; + mfem::H1Ser_QuadrilateralElement *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::H1Ser_QuadrilateralElement *)new mfem::H1Ser_QuadrilateralElement(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->CalcShape((mfem::IntegrationPoint const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->CalcDShape((mfem::IntegrationPoint const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->GetLocalInterpolation(*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->Project(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->Project(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_Project" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + ((mfem::H1Ser_QuadrilateralElement const *)arg1)->Project((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_Project(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_Project", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_0(self, argc, argv); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_1(self, argc, argv); + } + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_H1Ser_QuadrilateralElement_Project_SWIG_0_2(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'H1Ser_QuadrilateralElement_Project'.\n" + " Possible C/C++ prototypes are:\n" + " Project(mfem::Coefficient &,mfem::ElementTransformation &,mfem::Vector &) const\n" + " Project(mfem::VectorCoefficient &,mfem::ElementTransformation &,mfem::Vector &) const\n" + " Project(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::DenseMatrix &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Ser_QuadrilateralElement" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement *""'"); + } + arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *H1Ser_QuadrilateralElement_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1Ser_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; int arg1 ; @@ -49659,6 +50940,67 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::NURBS1DFiniteElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_NURBS1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; @@ -50011,6 +51353,67 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::NURBS2DFiniteElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_NURBS2DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; @@ -50380,6 +51783,67 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); + } + arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::NURBS3DFiniteElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_delete_NURBS3DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; @@ -50433,6 +51897,7 @@ SWIGINTERN PyObject *NURBS3DFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "BasisType_Check", _wrap_BasisType_Check, METH_O, "BasisType_Check(int b_type) -> int"}, { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "BasisType_CheckNodal(int b_type) -> int"}, { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "BasisType_GetQuadrature1D(int b_type) -> int"}, @@ -50495,7 +51960,10 @@ static PyMethodDef SwigMethods[] = { { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "FiniteElement_CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "FiniteElement_CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "FiniteElement_GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, - { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "FiniteElement_CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "FiniteElement_GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "FiniteElement_GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "FiniteElement_GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, @@ -51005,6 +52473,10 @@ static PyMethodDef SwigMethods[] = { "Poly_1D_CalcBernstein(int const p, double const x, double * u)\n" "Poly_1D_CalcBernstein(int const p, double const x, double * u, double * d)\n" ""}, + { "Poly_1D_CalcLegendre", _wrap_Poly_1D_CalcLegendre, METH_VARARGS, "\n" + "Poly_1D_CalcLegendre(int const p, double const x, double * u)\n" + "Poly_1D_CalcLegendre(int const p, double const x, double * u, double * d)\n" + ""}, { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, @@ -51023,6 +52495,13 @@ static PyMethodDef SwigMethods[] = { { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "PositiveTensorFiniteElement_GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, + { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, + { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, + { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "H1_SegmentElement_CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "H1_SegmentElement_CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, @@ -51058,6 +52537,18 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "H1Ser_QuadrilateralElement_GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" + "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, + { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, @@ -51423,6 +52914,7 @@ static PyMethodDef SwigMethods[] = { { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "NURBS1DFiniteElement_SetOrder(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "NURBS1DFiniteElement_CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "NURBS1DFiniteElement_CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "NURBS1DFiniteElement_CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -51433,6 +52925,7 @@ static PyMethodDef SwigMethods[] = { { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "NURBS2DFiniteElement_SetOrder(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "NURBS2DFiniteElement_CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "NURBS2DFiniteElement_CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "NURBS2DFiniteElement_CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -51443,6 +52936,7 @@ static PyMethodDef SwigMethods[] = { { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "NURBS3DFiniteElement_SetOrder(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "NURBS3DFiniteElement_CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "NURBS3DFiniteElement_CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "NURBS3DFiniteElement_CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -51450,15 +52944,1056 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "BasisType_Check", _wrap_BasisType_Check, METH_O, "Check(int b_type) -> int"}, + { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "CheckNodal(int b_type) -> int"}, + { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "GetQuadrature1D(int b_type) -> int"}, + { "BasisType_GetNodalBasis", _wrap_BasisType_GetNodalBasis, METH_O, "GetNodalBasis(int qpt_type) -> int"}, + { "BasisType_Name", _wrap_BasisType_Name, METH_O, "Name(int b_type) -> char const *"}, + { "BasisType_GetChar", _wrap_BasisType_GetChar, METH_O, "GetChar(int b_type) -> char"}, + { "BasisType_GetType", _wrap_BasisType_GetType, METH_O, "GetType(char b_ident) -> int"}, + { "new_BasisType", _wrap_new_BasisType, METH_NOARGS, "new_BasisType() -> BasisType"}, + { "delete_BasisType", _wrap_delete_BasisType, METH_O, "delete_BasisType(BasisType self)"}, + { "BasisType_swigregister", BasisType_swigregister, METH_O, NULL}, + { "BasisType_swiginit", BasisType_swiginit, METH_VARARGS, NULL}, + { "DofToQuad_IntRule_set", _wrap_DofToQuad_IntRule_set, METH_VARARGS, "DofToQuad_IntRule_set(DofToQuad self, IntegrationRule IntRule)"}, + { "DofToQuad_IntRule_get", _wrap_DofToQuad_IntRule_get, METH_O, "DofToQuad_IntRule_get(DofToQuad self) -> IntegrationRule"}, + { "DofToQuad_mode_set", _wrap_DofToQuad_mode_set, METH_VARARGS, "DofToQuad_mode_set(DofToQuad self, mfem::DofToQuad::Mode mode)"}, + { "DofToQuad_mode_get", _wrap_DofToQuad_mode_get, METH_O, "DofToQuad_mode_get(DofToQuad self) -> mfem::DofToQuad::Mode"}, + { "DofToQuad_ndof_set", _wrap_DofToQuad_ndof_set, METH_VARARGS, "DofToQuad_ndof_set(DofToQuad self, int ndof)"}, + { "DofToQuad_ndof_get", _wrap_DofToQuad_ndof_get, METH_O, "DofToQuad_ndof_get(DofToQuad self) -> int"}, + { "DofToQuad_nqpt_set", _wrap_DofToQuad_nqpt_set, METH_VARARGS, "DofToQuad_nqpt_set(DofToQuad self, int nqpt)"}, + { "DofToQuad_nqpt_get", _wrap_DofToQuad_nqpt_get, METH_O, "DofToQuad_nqpt_get(DofToQuad self) -> int"}, + { "DofToQuad_B_set", _wrap_DofToQuad_B_set, METH_VARARGS, "DofToQuad_B_set(DofToQuad self, doubleArray B)"}, + { "DofToQuad_B_get", _wrap_DofToQuad_B_get, METH_O, "DofToQuad_B_get(DofToQuad self) -> doubleArray"}, + { "DofToQuad_Bt_set", _wrap_DofToQuad_Bt_set, METH_VARARGS, "DofToQuad_Bt_set(DofToQuad self, doubleArray Bt)"}, + { "DofToQuad_Bt_get", _wrap_DofToQuad_Bt_get, METH_O, "DofToQuad_Bt_get(DofToQuad self) -> doubleArray"}, + { "DofToQuad_G_set", _wrap_DofToQuad_G_set, METH_VARARGS, "DofToQuad_G_set(DofToQuad self, doubleArray G)"}, + { "DofToQuad_G_get", _wrap_DofToQuad_G_get, METH_O, "DofToQuad_G_get(DofToQuad self) -> doubleArray"}, + { "DofToQuad_Gt_set", _wrap_DofToQuad_Gt_set, METH_VARARGS, "DofToQuad_Gt_set(DofToQuad self, doubleArray Gt)"}, + { "DofToQuad_Gt_get", _wrap_DofToQuad_Gt_get, METH_O, "DofToQuad_Gt_get(DofToQuad self) -> doubleArray"}, + { "new_DofToQuad", _wrap_new_DofToQuad, METH_NOARGS, "new_DofToQuad() -> DofToQuad"}, + { "delete_DofToQuad", _wrap_delete_DofToQuad, METH_O, "delete_DofToQuad(DofToQuad self)"}, + { "DofToQuad_swigregister", DofToQuad_swigregister, METH_O, NULL}, + { "DofToQuad_swiginit", DofToQuad_swiginit, METH_VARARGS, NULL}, + { "new_FunctionSpace", _wrap_new_FunctionSpace, METH_NOARGS, "new_FunctionSpace() -> FunctionSpace"}, + { "delete_FunctionSpace", _wrap_delete_FunctionSpace, METH_O, "delete_FunctionSpace(FunctionSpace self)"}, + { "FunctionSpace_swigregister", FunctionSpace_swigregister, METH_O, NULL}, + { "FunctionSpace_swiginit", FunctionSpace_swiginit, METH_VARARGS, NULL}, + { "FiniteElement_GetDim", _wrap_FiniteElement_GetDim, METH_O, "GetDim(FiniteElement self) -> int"}, + { "FiniteElement_GetGeomType", _wrap_FiniteElement_GetGeomType, METH_O, "GetGeomType(FiniteElement self) -> mfem::Geometry::Type"}, + { "FiniteElement_GetDof", _wrap_FiniteElement_GetDof, METH_O, "GetDof(FiniteElement self) -> int"}, + { "FiniteElement_GetOrder", _wrap_FiniteElement_GetOrder, METH_O, "GetOrder(FiniteElement self) -> int"}, + { "FiniteElement_HasAnisotropicOrders", _wrap_FiniteElement_HasAnisotropicOrders, METH_O, "HasAnisotropicOrders(FiniteElement self) -> bool"}, + { "FiniteElement_GetAnisotropicOrders", _wrap_FiniteElement_GetAnisotropicOrders, METH_O, "GetAnisotropicOrders(FiniteElement self) -> int const *"}, + { "FiniteElement_Space", _wrap_FiniteElement_Space, METH_O, "Space(FiniteElement self) -> int"}, + { "FiniteElement_GetRangeType", _wrap_FiniteElement_GetRangeType, METH_O, "GetRangeType(FiniteElement self) -> int"}, + { "FiniteElement_GetDerivRangeType", _wrap_FiniteElement_GetDerivRangeType, METH_O, "GetDerivRangeType(FiniteElement self) -> int"}, + { "FiniteElement_GetMapType", _wrap_FiniteElement_GetMapType, METH_O, "GetMapType(FiniteElement self) -> int"}, + { "FiniteElement_GetDerivType", _wrap_FiniteElement_GetDerivType, METH_O, "GetDerivType(FiniteElement self) -> int"}, + { "FiniteElement_GetDerivMapType", _wrap_FiniteElement_GetDerivMapType, METH_O, "GetDerivMapType(FiniteElement self) -> int"}, + { "FiniteElement_CalcShape", _wrap_FiniteElement_CalcShape, METH_VARARGS, "CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "FiniteElement_CalcPhysShape", _wrap_FiniteElement_CalcPhysShape, METH_VARARGS, "CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, + { "FiniteElement_CalcDShape", _wrap_FiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "FiniteElement_CalcPhysDShape", _wrap_FiniteElement_CalcPhysDShape, METH_VARARGS, "CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, + { "FiniteElement_GetNodes", _wrap_FiniteElement_GetNodes, METH_O, "GetNodes(FiniteElement self) -> IntegrationRule"}, + { "FiniteElement_CalcVShape", _wrap_FiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(FiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "FiniteElement_CalcPhysVShape", _wrap_FiniteElement_CalcPhysVShape, METH_VARARGS, "CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, + { "FiniteElement_CalcDivShape", _wrap_FiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "FiniteElement_CalcPhysDivShape", _wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS, "CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, + { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, + { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_ProjectMatrixCoefficient", _wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "FiniteElement_ProjectDelta", _wrap_FiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, + { "FiniteElement_Project", _wrap_FiniteElement_Project, METH_VARARGS, "\n" + "Project(FiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(FiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "FiniteElement_ProjectGrad", _wrap_FiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "FiniteElement_ProjectCurl", _wrap_FiniteElement_ProjectCurl, METH_VARARGS, "ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "FiniteElement_ProjectDiv", _wrap_FiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "FiniteElement_GetDofToQuad", _wrap_FiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_FiniteElement", _wrap_delete_FiniteElement, METH_O, "delete_FiniteElement(FiniteElement self)"}, + { "FiniteElement_IsClosedType", _wrap_FiniteElement_IsClosedType, METH_O, "IsClosedType(int b_type) -> bool"}, + { "FiniteElement_IsOpenType", _wrap_FiniteElement_IsOpenType, METH_O, "IsOpenType(int b_type) -> bool"}, + { "FiniteElement_VerifyClosed", _wrap_FiniteElement_VerifyClosed, METH_O, "VerifyClosed(int b_type) -> int"}, + { "FiniteElement_VerifyOpen", _wrap_FiniteElement_VerifyOpen, METH_O, "VerifyOpen(int b_type) -> int"}, + { "FiniteElement_VerifyNodal", _wrap_FiniteElement_VerifyNodal, METH_O, "VerifyNodal(int b_type) -> int"}, + { "FiniteElement_swigregister", FiniteElement_swigregister, METH_O, NULL}, + { "ScalarFiniteElement_SetMapType", _wrap_ScalarFiniteElement_SetMapType, METH_VARARGS, "SetMapType(ScalarFiniteElement self, int M)"}, + { "ScalarFiniteElement_NodalLocalInterpolation", _wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS, "NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_ScalarLocalInterpolation", _wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS, "ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_GetDofToQuad", _wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_ScalarFiniteElement", _wrap_delete_ScalarFiniteElement, METH_O, "delete_ScalarFiniteElement(ScalarFiniteElement self)"}, + { "ScalarFiniteElement_swigregister", ScalarFiniteElement_swigregister, METH_O, NULL}, + { "NodalFiniteElement_GetLocalInterpolation", _wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_GetLocalRestriction", _wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "NodalFiniteElement_GetTransferMatrix", _wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_ProjectMatrixCoefficient", _wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "NodalFiniteElement_Project", _wrap_NodalFiniteElement_Project, METH_VARARGS, "\n" + "Project(NodalFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(NodalFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "NodalFiniteElement_ProjectGrad", _wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "NodalFiniteElement_ProjectDiv", _wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "delete_NodalFiniteElement", _wrap_delete_NodalFiniteElement, METH_O, "delete_NodalFiniteElement(NodalFiniteElement self)"}, + { "NodalFiniteElement_swigregister", NodalFiniteElement_swigregister, METH_O, NULL}, + { "PositiveFiniteElement_GetLocalInterpolation", _wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetTransferMatrix", _wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_Project", _wrap_PositiveFiniteElement_Project, METH_VARARGS, "\n" + "Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "delete_PositiveFiniteElement", _wrap_delete_PositiveFiniteElement, METH_O, "delete_PositiveFiniteElement(PositiveFiniteElement self)"}, + { "PositiveFiniteElement_swigregister", PositiveFiniteElement_swigregister, METH_O, NULL}, + { "new_VectorFiniteElement", _wrap_new_VectorFiniteElement, METH_VARARGS, "VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk)"}, + { "delete_VectorFiniteElement", _wrap_delete_VectorFiniteElement, METH_O, "delete_VectorFiniteElement(VectorFiniteElement self)"}, + { "VectorFiniteElement_swigregister", VectorFiniteElement_swigregister, METH_O, NULL}, + { "VectorFiniteElement_swiginit", VectorFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_PointFiniteElement", _wrap_new_PointFiniteElement, METH_NOARGS, "new_PointFiniteElement() -> PointFiniteElement"}, + { "PointFiniteElement_CalcShape", _wrap_PointFiniteElement_CalcShape, METH_VARARGS, "CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "PointFiniteElement_CalcDShape", _wrap_PointFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_PointFiniteElement", _wrap_delete_PointFiniteElement, METH_O, "delete_PointFiniteElement(PointFiniteElement self)"}, + { "PointFiniteElement_swigregister", PointFiniteElement_swigregister, METH_O, NULL}, + { "PointFiniteElement_swiginit", PointFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Linear1DFiniteElement", _wrap_new_Linear1DFiniteElement, METH_NOARGS, "new_Linear1DFiniteElement() -> Linear1DFiniteElement"}, + { "Linear1DFiniteElement_CalcShape", _wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear1DFiniteElement_CalcDShape", _wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Linear1DFiniteElement", _wrap_delete_Linear1DFiniteElement, METH_O, "delete_Linear1DFiniteElement(Linear1DFiniteElement self)"}, + { "Linear1DFiniteElement_swigregister", Linear1DFiniteElement_swigregister, METH_O, NULL}, + { "Linear1DFiniteElement_swiginit", Linear1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Linear2DFiniteElement", _wrap_new_Linear2DFiniteElement, METH_NOARGS, "new_Linear2DFiniteElement() -> Linear2DFiniteElement"}, + { "Linear2DFiniteElement_CalcShape", _wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear2DFiniteElement_CalcDShape", _wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear2DFiniteElement_ProjectDelta", _wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_Linear2DFiniteElement", _wrap_delete_Linear2DFiniteElement, METH_O, "delete_Linear2DFiniteElement(Linear2DFiniteElement self)"}, + { "Linear2DFiniteElement_swigregister", Linear2DFiniteElement_swigregister, METH_O, NULL}, + { "Linear2DFiniteElement_swiginit", Linear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiLinear2DFiniteElement", _wrap_new_BiLinear2DFiniteElement, METH_NOARGS, "new_BiLinear2DFiniteElement() -> BiLinear2DFiniteElement"}, + { "BiLinear2DFiniteElement_CalcShape", _wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiLinear2DFiniteElement_CalcDShape", _wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiLinear2DFiniteElement_CalcHessian", _wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiLinear2DFiniteElement_ProjectDelta", _wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_BiLinear2DFiniteElement", _wrap_delete_BiLinear2DFiniteElement, METH_O, "delete_BiLinear2DFiniteElement(BiLinear2DFiniteElement self)"}, + { "BiLinear2DFiniteElement_swigregister", BiLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "BiLinear2DFiniteElement_swiginit", BiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussLinear2DFiniteElement", _wrap_new_GaussLinear2DFiniteElement, METH_NOARGS, "new_GaussLinear2DFiniteElement() -> GaussLinear2DFiniteElement"}, + { "GaussLinear2DFiniteElement_CalcShape", _wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussLinear2DFiniteElement_CalcDShape", _wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussLinear2DFiniteElement_ProjectDelta", _wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_GaussLinear2DFiniteElement", _wrap_delete_GaussLinear2DFiniteElement, METH_O, "delete_GaussLinear2DFiniteElement(GaussLinear2DFiniteElement self)"}, + { "GaussLinear2DFiniteElement_swigregister", GaussLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussLinear2DFiniteElement_swiginit", GaussLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussBiLinear2DFiniteElement", _wrap_new_GaussBiLinear2DFiniteElement, METH_NOARGS, "new_GaussBiLinear2DFiniteElement() -> GaussBiLinear2DFiniteElement"}, + { "GaussBiLinear2DFiniteElement_CalcShape", _wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiLinear2DFiniteElement_CalcDShape", _wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiLinear2DFiniteElement_ProjectDelta", _wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_GaussBiLinear2DFiniteElement", _wrap_delete_GaussBiLinear2DFiniteElement, METH_O, "delete_GaussBiLinear2DFiniteElement(GaussBiLinear2DFiniteElement self)"}, + { "GaussBiLinear2DFiniteElement_swigregister", GaussBiLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussBiLinear2DFiniteElement_swiginit", GaussBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P1OnQuadFiniteElement", _wrap_new_P1OnQuadFiniteElement, METH_NOARGS, "new_P1OnQuadFiniteElement() -> P1OnQuadFiniteElement"}, + { "P1OnQuadFiniteElement_CalcShape", _wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1OnQuadFiniteElement_CalcDShape", _wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1OnQuadFiniteElement_ProjectDelta", _wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P1OnQuadFiniteElement", _wrap_delete_P1OnQuadFiniteElement, METH_O, "delete_P1OnQuadFiniteElement(P1OnQuadFiniteElement self)"}, + { "P1OnQuadFiniteElement_swigregister", P1OnQuadFiniteElement_swigregister, METH_O, NULL}, + { "P1OnQuadFiniteElement_swiginit", P1OnQuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Quad1DFiniteElement", _wrap_new_Quad1DFiniteElement, METH_NOARGS, "new_Quad1DFiniteElement() -> Quad1DFiniteElement"}, + { "Quad1DFiniteElement_CalcShape", _wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad1DFiniteElement_CalcDShape", _wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Quad1DFiniteElement", _wrap_delete_Quad1DFiniteElement, METH_O, "delete_Quad1DFiniteElement(Quad1DFiniteElement self)"}, + { "Quad1DFiniteElement_swigregister", Quad1DFiniteElement_swigregister, METH_O, NULL}, + { "Quad1DFiniteElement_swiginit", Quad1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_QuadPos1DFiniteElement", _wrap_new_QuadPos1DFiniteElement, METH_NOARGS, "new_QuadPos1DFiniteElement() -> QuadPos1DFiniteElement"}, + { "QuadPos1DFiniteElement_CalcShape", _wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "QuadPos1DFiniteElement_CalcDShape", _wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_QuadPos1DFiniteElement", _wrap_delete_QuadPos1DFiniteElement, METH_O, "delete_QuadPos1DFiniteElement(QuadPos1DFiniteElement self)"}, + { "QuadPos1DFiniteElement_swigregister", QuadPos1DFiniteElement_swigregister, METH_O, NULL}, + { "QuadPos1DFiniteElement_swiginit", QuadPos1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Quad2DFiniteElement", _wrap_new_Quad2DFiniteElement, METH_NOARGS, "new_Quad2DFiniteElement() -> Quad2DFiniteElement"}, + { "Quad2DFiniteElement_CalcShape", _wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad2DFiniteElement_CalcDShape", _wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad2DFiniteElement_CalcHessian", _wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Quad2DFiniteElement_ProjectDelta", _wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_Quad2DFiniteElement", _wrap_delete_Quad2DFiniteElement, METH_O, "delete_Quad2DFiniteElement(Quad2DFiniteElement self)"}, + { "Quad2DFiniteElement_swigregister", Quad2DFiniteElement_swigregister, METH_O, NULL}, + { "Quad2DFiniteElement_swiginit", Quad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussQuad2DFiniteElement", _wrap_new_GaussQuad2DFiniteElement, METH_NOARGS, "new_GaussQuad2DFiniteElement() -> GaussQuad2DFiniteElement"}, + { "GaussQuad2DFiniteElement_CalcShape", _wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussQuad2DFiniteElement_CalcDShape", _wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_GaussQuad2DFiniteElement", _wrap_delete_GaussQuad2DFiniteElement, METH_O, "delete_GaussQuad2DFiniteElement(GaussQuad2DFiniteElement self)"}, + { "GaussQuad2DFiniteElement_swigregister", GaussQuad2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussQuad2DFiniteElement_swiginit", GaussQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiQuad2DFiniteElement", _wrap_new_BiQuad2DFiniteElement, METH_NOARGS, "new_BiQuad2DFiniteElement() -> BiQuad2DFiniteElement"}, + { "BiQuad2DFiniteElement_CalcShape", _wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuad2DFiniteElement_CalcDShape", _wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuad2DFiniteElement_ProjectDelta", _wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_BiQuad2DFiniteElement", _wrap_delete_BiQuad2DFiniteElement, METH_O, "delete_BiQuad2DFiniteElement(BiQuad2DFiniteElement self)"}, + { "BiQuad2DFiniteElement_swigregister", BiQuad2DFiniteElement_swigregister, METH_O, NULL}, + { "BiQuad2DFiniteElement_swiginit", BiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiQuadPos2DFiniteElement", _wrap_new_BiQuadPos2DFiniteElement, METH_NOARGS, "new_BiQuadPos2DFiniteElement() -> BiQuadPos2DFiniteElement"}, + { "BiQuadPos2DFiniteElement_CalcShape", _wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuadPos2DFiniteElement_CalcDShape", _wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuadPos2DFiniteElement_GetLocalInterpolation", _wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "BiQuadPos2DFiniteElement_Project", _wrap_BiQuadPos2DFiniteElement_Project, METH_VARARGS, "\n" + "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(BiQuadPos2DFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "BiQuadPos2DFiniteElement_ProjectDelta", _wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_BiQuadPos2DFiniteElement", _wrap_delete_BiQuadPos2DFiniteElement, METH_O, "delete_BiQuadPos2DFiniteElement(BiQuadPos2DFiniteElement self)"}, + { "BiQuadPos2DFiniteElement_swigregister", BiQuadPos2DFiniteElement_swigregister, METH_O, NULL}, + { "BiQuadPos2DFiniteElement_swiginit", BiQuadPos2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_GaussBiQuad2DFiniteElement", _wrap_new_GaussBiQuad2DFiniteElement, METH_NOARGS, "new_GaussBiQuad2DFiniteElement() -> GaussBiQuad2DFiniteElement"}, + { "GaussBiQuad2DFiniteElement_CalcShape", _wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiQuad2DFiniteElement_CalcDShape", _wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_GaussBiQuad2DFiniteElement", _wrap_delete_GaussBiQuad2DFiniteElement, METH_O, "delete_GaussBiQuad2DFiniteElement(GaussBiQuad2DFiniteElement self)"}, + { "GaussBiQuad2DFiniteElement_swigregister", GaussBiQuad2DFiniteElement_swigregister, METH_O, NULL}, + { "GaussBiQuad2DFiniteElement_swiginit", GaussBiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiCubic2DFiniteElement", _wrap_new_BiCubic2DFiniteElement, METH_NOARGS, "new_BiCubic2DFiniteElement() -> BiCubic2DFiniteElement"}, + { "BiCubic2DFiniteElement_CalcShape", _wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiCubic2DFiniteElement_CalcDShape", _wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiCubic2DFiniteElement_CalcHessian", _wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "delete_BiCubic2DFiniteElement", _wrap_delete_BiCubic2DFiniteElement, METH_O, "delete_BiCubic2DFiniteElement(BiCubic2DFiniteElement self)"}, + { "BiCubic2DFiniteElement_swigregister", BiCubic2DFiniteElement_swigregister, METH_O, NULL}, + { "BiCubic2DFiniteElement_swiginit", BiCubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Cubic1DFiniteElement", _wrap_new_Cubic1DFiniteElement, METH_NOARGS, "new_Cubic1DFiniteElement() -> Cubic1DFiniteElement"}, + { "Cubic1DFiniteElement_CalcShape", _wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic1DFiniteElement_CalcDShape", _wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Cubic1DFiniteElement", _wrap_delete_Cubic1DFiniteElement, METH_O, "delete_Cubic1DFiniteElement(Cubic1DFiniteElement self)"}, + { "Cubic1DFiniteElement_swigregister", Cubic1DFiniteElement_swigregister, METH_O, NULL}, + { "Cubic1DFiniteElement_swiginit", Cubic1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Cubic2DFiniteElement", _wrap_new_Cubic2DFiniteElement, METH_NOARGS, "new_Cubic2DFiniteElement() -> Cubic2DFiniteElement"}, + { "Cubic2DFiniteElement_CalcShape", _wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic2DFiniteElement_CalcDShape", _wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic2DFiniteElement_CalcHessian", _wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "delete_Cubic2DFiniteElement", _wrap_delete_Cubic2DFiniteElement, METH_O, "delete_Cubic2DFiniteElement(Cubic2DFiniteElement self)"}, + { "Cubic2DFiniteElement_swigregister", Cubic2DFiniteElement_swigregister, METH_O, NULL}, + { "Cubic2DFiniteElement_swiginit", Cubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Cubic3DFiniteElement", _wrap_new_Cubic3DFiniteElement, METH_NOARGS, "new_Cubic3DFiniteElement() -> Cubic3DFiniteElement"}, + { "Cubic3DFiniteElement_CalcShape", _wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic3DFiniteElement_CalcDShape", _wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Cubic3DFiniteElement", _wrap_delete_Cubic3DFiniteElement, METH_O, "delete_Cubic3DFiniteElement(Cubic3DFiniteElement self)"}, + { "Cubic3DFiniteElement_swigregister", Cubic3DFiniteElement_swigregister, METH_O, NULL}, + { "Cubic3DFiniteElement_swiginit", Cubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0TriangleFiniteElement", _wrap_new_P0TriangleFiniteElement, METH_NOARGS, "new_P0TriangleFiniteElement() -> P0TriangleFiniteElement"}, + { "P0TriangleFiniteElement_CalcShape", _wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TriangleFiniteElement_CalcDShape", _wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TriangleFiniteElement_ProjectDelta", _wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0TriangleFiniteElement", _wrap_delete_P0TriangleFiniteElement, METH_O, "delete_P0TriangleFiniteElement(P0TriangleFiniteElement self)"}, + { "P0TriangleFiniteElement_swigregister", P0TriangleFiniteElement_swigregister, METH_O, NULL}, + { "P0TriangleFiniteElement_swiginit", P0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0QuadFiniteElement", _wrap_new_P0QuadFiniteElement, METH_NOARGS, "new_P0QuadFiniteElement() -> P0QuadFiniteElement"}, + { "P0QuadFiniteElement_CalcShape", _wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0QuadFiniteElement_CalcDShape", _wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0QuadFiniteElement_ProjectDelta", _wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0QuadFiniteElement", _wrap_delete_P0QuadFiniteElement, METH_O, "delete_P0QuadFiniteElement(P0QuadFiniteElement self)"}, + { "P0QuadFiniteElement_swigregister", P0QuadFiniteElement_swigregister, METH_O, NULL}, + { "P0QuadFiniteElement_swiginit", P0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Linear3DFiniteElement", _wrap_new_Linear3DFiniteElement, METH_NOARGS, "new_Linear3DFiniteElement() -> Linear3DFiniteElement"}, + { "Linear3DFiniteElement_CalcShape", _wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear3DFiniteElement_CalcDShape", _wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear3DFiniteElement_ProjectDelta", _wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear3DFiniteElement_GetFaceDofs", _wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "delete_Linear3DFiniteElement", _wrap_delete_Linear3DFiniteElement, METH_O, "delete_Linear3DFiniteElement(Linear3DFiniteElement self)"}, + { "Linear3DFiniteElement_swigregister", Linear3DFiniteElement_swigregister, METH_O, NULL}, + { "Linear3DFiniteElement_swiginit", Linear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Quadratic3DFiniteElement", _wrap_new_Quadratic3DFiniteElement, METH_NOARGS, "new_Quadratic3DFiniteElement() -> Quadratic3DFiniteElement"}, + { "Quadratic3DFiniteElement_CalcShape", _wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quadratic3DFiniteElement_CalcDShape", _wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Quadratic3DFiniteElement", _wrap_delete_Quadratic3DFiniteElement, METH_O, "delete_Quadratic3DFiniteElement(Quadratic3DFiniteElement self)"}, + { "Quadratic3DFiniteElement_swigregister", Quadratic3DFiniteElement_swigregister, METH_O, NULL}, + { "Quadratic3DFiniteElement_swiginit", Quadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_TriLinear3DFiniteElement", _wrap_new_TriLinear3DFiniteElement, METH_NOARGS, "new_TriLinear3DFiniteElement() -> TriLinear3DFiniteElement"}, + { "TriLinear3DFiniteElement_CalcShape", _wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "TriLinear3DFiniteElement_CalcDShape", _wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "TriLinear3DFiniteElement_ProjectDelta", _wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, + { "delete_TriLinear3DFiniteElement", _wrap_delete_TriLinear3DFiniteElement, METH_O, "delete_TriLinear3DFiniteElement(TriLinear3DFiniteElement self)"}, + { "TriLinear3DFiniteElement_swigregister", TriLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "TriLinear3DFiniteElement_swiginit", TriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_CrouzeixRaviartFiniteElement", _wrap_new_CrouzeixRaviartFiniteElement, METH_NOARGS, "new_CrouzeixRaviartFiniteElement() -> CrouzeixRaviartFiniteElement"}, + { "CrouzeixRaviartFiniteElement_CalcShape", _wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartFiniteElement_CalcDShape", _wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartFiniteElement_ProjectDelta", _wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, + { "delete_CrouzeixRaviartFiniteElement", _wrap_delete_CrouzeixRaviartFiniteElement, METH_O, "delete_CrouzeixRaviartFiniteElement(CrouzeixRaviartFiniteElement self)"}, + { "CrouzeixRaviartFiniteElement_swigregister", CrouzeixRaviartFiniteElement_swigregister, METH_O, NULL}, + { "CrouzeixRaviartFiniteElement_swiginit", CrouzeixRaviartFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_CrouzeixRaviartQuadFiniteElement", _wrap_new_CrouzeixRaviartQuadFiniteElement, METH_NOARGS, "new_CrouzeixRaviartQuadFiniteElement() -> CrouzeixRaviartQuadFiniteElement"}, + { "CrouzeixRaviartQuadFiniteElement_CalcShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcDShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_CrouzeixRaviartQuadFiniteElement", _wrap_delete_CrouzeixRaviartQuadFiniteElement, METH_O, "delete_CrouzeixRaviartQuadFiniteElement(CrouzeixRaviartQuadFiniteElement self)"}, + { "CrouzeixRaviartQuadFiniteElement_swigregister", CrouzeixRaviartQuadFiniteElement_swigregister, METH_O, NULL}, + { "CrouzeixRaviartQuadFiniteElement_swiginit", CrouzeixRaviartQuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0SegmentFiniteElement", _wrap_new_P0SegmentFiniteElement, METH_VARARGS, "P0SegmentFiniteElement(int Ord=0)"}, + { "P0SegmentFiniteElement_CalcShape", _wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0SegmentFiniteElement_CalcDShape", _wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P0SegmentFiniteElement", _wrap_delete_P0SegmentFiniteElement, METH_O, "delete_P0SegmentFiniteElement(P0SegmentFiniteElement self)"}, + { "P0SegmentFiniteElement_swigregister", P0SegmentFiniteElement_swigregister, METH_O, NULL}, + { "P0SegmentFiniteElement_swiginit", P0SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0TriangleFiniteElement", _wrap_new_RT0TriangleFiniteElement, METH_NOARGS, "new_RT0TriangleFiniteElement() -> RT0TriangleFiniteElement"}, + { "RT0TriangleFiniteElement_CalcVShape", _wrap_RT0TriangleFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0TriangleFiniteElement_CalcDivShape", _wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TriangleFiniteElement_GetLocalInterpolation", _wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TriangleFiniteElement_Project", _wrap_RT0TriangleFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TriangleFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0TriangleFiniteElement", _wrap_delete_RT0TriangleFiniteElement, METH_O, "delete_RT0TriangleFiniteElement(RT0TriangleFiniteElement self)"}, + { "RT0TriangleFiniteElement_swigregister", RT0TriangleFiniteElement_swigregister, METH_O, NULL}, + { "RT0TriangleFiniteElement_swiginit", RT0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0QuadFiniteElement", _wrap_new_RT0QuadFiniteElement, METH_NOARGS, "new_RT0QuadFiniteElement() -> RT0QuadFiniteElement"}, + { "RT0QuadFiniteElement_CalcVShape", _wrap_RT0QuadFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0QuadFiniteElement_CalcDivShape", _wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0QuadFiniteElement_GetLocalInterpolation", _wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0QuadFiniteElement_Project", _wrap_RT0QuadFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0QuadFiniteElement", _wrap_delete_RT0QuadFiniteElement, METH_O, "delete_RT0QuadFiniteElement(RT0QuadFiniteElement self)"}, + { "RT0QuadFiniteElement_swigregister", RT0QuadFiniteElement_swigregister, METH_O, NULL}, + { "RT0QuadFiniteElement_swiginit", RT0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT1TriangleFiniteElement", _wrap_new_RT1TriangleFiniteElement, METH_NOARGS, "new_RT1TriangleFiniteElement() -> RT1TriangleFiniteElement"}, + { "RT1TriangleFiniteElement_CalcVShape", _wrap_RT1TriangleFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT1TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT1TriangleFiniteElement_CalcDivShape", _wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1TriangleFiniteElement_GetLocalInterpolation", _wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1TriangleFiniteElement_Project", _wrap_RT1TriangleFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT1TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1TriangleFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT1TriangleFiniteElement", _wrap_delete_RT1TriangleFiniteElement, METH_O, "delete_RT1TriangleFiniteElement(RT1TriangleFiniteElement self)"}, + { "RT1TriangleFiniteElement_swigregister", RT1TriangleFiniteElement_swigregister, METH_O, NULL}, + { "RT1TriangleFiniteElement_swiginit", RT1TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT1QuadFiniteElement", _wrap_new_RT1QuadFiniteElement, METH_NOARGS, "new_RT1QuadFiniteElement() -> RT1QuadFiniteElement"}, + { "RT1QuadFiniteElement_CalcVShape", _wrap_RT1QuadFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT1QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT1QuadFiniteElement_CalcDivShape", _wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1QuadFiniteElement_GetLocalInterpolation", _wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1QuadFiniteElement_Project", _wrap_RT1QuadFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT1QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT1QuadFiniteElement", _wrap_delete_RT1QuadFiniteElement, METH_O, "delete_RT1QuadFiniteElement(RT1QuadFiniteElement self)"}, + { "RT1QuadFiniteElement_swigregister", RT1QuadFiniteElement_swigregister, METH_O, NULL}, + { "RT1QuadFiniteElement_swiginit", RT1QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT2TriangleFiniteElement", _wrap_new_RT2TriangleFiniteElement, METH_NOARGS, "new_RT2TriangleFiniteElement() -> RT2TriangleFiniteElement"}, + { "RT2TriangleFiniteElement_CalcVShape", _wrap_RT2TriangleFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT2TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT2TriangleFiniteElement_CalcDivShape", _wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "delete_RT2TriangleFiniteElement", _wrap_delete_RT2TriangleFiniteElement, METH_O, "delete_RT2TriangleFiniteElement(RT2TriangleFiniteElement self)"}, + { "RT2TriangleFiniteElement_swigregister", RT2TriangleFiniteElement_swigregister, METH_O, NULL}, + { "RT2TriangleFiniteElement_swiginit", RT2TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT2QuadFiniteElement", _wrap_new_RT2QuadFiniteElement, METH_NOARGS, "new_RT2QuadFiniteElement() -> RT2QuadFiniteElement"}, + { "RT2QuadFiniteElement_CalcVShape", _wrap_RT2QuadFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT2QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT2QuadFiniteElement_CalcDivShape", _wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2QuadFiniteElement_GetLocalInterpolation", _wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT2QuadFiniteElement_Project", _wrap_RT2QuadFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT2QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT2QuadFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT2QuadFiniteElement", _wrap_delete_RT2QuadFiniteElement, METH_O, "delete_RT2QuadFiniteElement(RT2QuadFiniteElement self)"}, + { "RT2QuadFiniteElement_swigregister", RT2QuadFiniteElement_swigregister, METH_O, NULL}, + { "RT2QuadFiniteElement_swiginit", RT2QuadFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P1SegmentFiniteElement", _wrap_new_P1SegmentFiniteElement, METH_NOARGS, "new_P1SegmentFiniteElement() -> P1SegmentFiniteElement"}, + { "P1SegmentFiniteElement_CalcShape", _wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1SegmentFiniteElement_CalcDShape", _wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P1SegmentFiniteElement", _wrap_delete_P1SegmentFiniteElement, METH_O, "delete_P1SegmentFiniteElement(P1SegmentFiniteElement self)"}, + { "P1SegmentFiniteElement_swigregister", P1SegmentFiniteElement_swigregister, METH_O, NULL}, + { "P1SegmentFiniteElement_swiginit", P1SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P2SegmentFiniteElement", _wrap_new_P2SegmentFiniteElement, METH_NOARGS, "new_P2SegmentFiniteElement() -> P2SegmentFiniteElement"}, + { "P2SegmentFiniteElement_CalcShape", _wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P2SegmentFiniteElement_CalcDShape", _wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P2SegmentFiniteElement", _wrap_delete_P2SegmentFiniteElement, METH_O, "delete_P2SegmentFiniteElement(P2SegmentFiniteElement self)"}, + { "P2SegmentFiniteElement_swigregister", P2SegmentFiniteElement_swigregister, METH_O, NULL}, + { "P2SegmentFiniteElement_swiginit", P2SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Lagrange1DFiniteElement", _wrap_new_Lagrange1DFiniteElement, METH_O, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, + { "Lagrange1DFiniteElement_CalcShape", _wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Lagrange1DFiniteElement_CalcDShape", _wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_Lagrange1DFiniteElement", _wrap_delete_Lagrange1DFiniteElement, METH_O, "delete_Lagrange1DFiniteElement(Lagrange1DFiniteElement self)"}, + { "Lagrange1DFiniteElement_swigregister", Lagrange1DFiniteElement_swigregister, METH_O, NULL}, + { "Lagrange1DFiniteElement_swiginit", Lagrange1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P1TetNonConfFiniteElement", _wrap_new_P1TetNonConfFiniteElement, METH_NOARGS, "new_P1TetNonConfFiniteElement() -> P1TetNonConfFiniteElement"}, + { "P1TetNonConfFiniteElement_CalcShape", _wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1TetNonConfFiniteElement_CalcDShape", _wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_P1TetNonConfFiniteElement", _wrap_delete_P1TetNonConfFiniteElement, METH_O, "delete_P1TetNonConfFiniteElement(P1TetNonConfFiniteElement self)"}, + { "P1TetNonConfFiniteElement_swigregister", P1TetNonConfFiniteElement_swigregister, METH_O, NULL}, + { "P1TetNonConfFiniteElement_swiginit", P1TetNonConfFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0TetFiniteElement", _wrap_new_P0TetFiniteElement, METH_NOARGS, "new_P0TetFiniteElement() -> P0TetFiniteElement"}, + { "P0TetFiniteElement_CalcShape", _wrap_P0TetFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TetFiniteElement_CalcDShape", _wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TetFiniteElement_ProjectDelta", _wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0TetFiniteElement", _wrap_delete_P0TetFiniteElement, METH_O, "delete_P0TetFiniteElement(P0TetFiniteElement self)"}, + { "P0TetFiniteElement_swigregister", P0TetFiniteElement_swigregister, METH_O, NULL}, + { "P0TetFiniteElement_swiginit", P0TetFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_P0HexFiniteElement", _wrap_new_P0HexFiniteElement, METH_NOARGS, "new_P0HexFiniteElement() -> P0HexFiniteElement"}, + { "P0HexFiniteElement_CalcShape", _wrap_P0HexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0HexFiniteElement_CalcDShape", _wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0HexFiniteElement_ProjectDelta", _wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, + { "delete_P0HexFiniteElement", _wrap_delete_P0HexFiniteElement, METH_O, "delete_P0HexFiniteElement(P0HexFiniteElement self)"}, + { "P0HexFiniteElement_swigregister", P0HexFiniteElement_swigregister, METH_O, NULL}, + { "P0HexFiniteElement_swiginit", P0HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_LagrangeHexFiniteElement", _wrap_new_LagrangeHexFiniteElement, METH_O, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, + { "LagrangeHexFiniteElement_CalcShape", _wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "LagrangeHexFiniteElement_CalcDShape", _wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_LagrangeHexFiniteElement", _wrap_delete_LagrangeHexFiniteElement, METH_O, "delete_LagrangeHexFiniteElement(LagrangeHexFiniteElement self)"}, + { "LagrangeHexFiniteElement_swigregister", LagrangeHexFiniteElement_swigregister, METH_O, NULL}, + { "LagrangeHexFiniteElement_swiginit", LagrangeHexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinear1DFiniteElement", _wrap_new_RefinedLinear1DFiniteElement, METH_NOARGS, "new_RefinedLinear1DFiniteElement() -> RefinedLinear1DFiniteElement"}, + { "RefinedLinear1DFiniteElement_CalcShape", _wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear1DFiniteElement_CalcDShape", _wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedLinear1DFiniteElement", _wrap_delete_RefinedLinear1DFiniteElement, METH_O, "delete_RefinedLinear1DFiniteElement(RefinedLinear1DFiniteElement self)"}, + { "RefinedLinear1DFiniteElement_swigregister", RefinedLinear1DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedLinear1DFiniteElement_swiginit", RefinedLinear1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinear2DFiniteElement", _wrap_new_RefinedLinear2DFiniteElement, METH_NOARGS, "new_RefinedLinear2DFiniteElement() -> RefinedLinear2DFiniteElement"}, + { "RefinedLinear2DFiniteElement_CalcShape", _wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear2DFiniteElement_CalcDShape", _wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedLinear2DFiniteElement", _wrap_delete_RefinedLinear2DFiniteElement, METH_O, "delete_RefinedLinear2DFiniteElement(RefinedLinear2DFiniteElement self)"}, + { "RefinedLinear2DFiniteElement_swigregister", RefinedLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedLinear2DFiniteElement_swiginit", RefinedLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedLinear3DFiniteElement", _wrap_new_RefinedLinear3DFiniteElement, METH_NOARGS, "new_RefinedLinear3DFiniteElement() -> RefinedLinear3DFiniteElement"}, + { "RefinedLinear3DFiniteElement_CalcShape", _wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear3DFiniteElement_CalcDShape", _wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedLinear3DFiniteElement", _wrap_delete_RefinedLinear3DFiniteElement, METH_O, "delete_RefinedLinear3DFiniteElement(RefinedLinear3DFiniteElement self)"}, + { "RefinedLinear3DFiniteElement_swigregister", RefinedLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedLinear3DFiniteElement_swiginit", RefinedLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedBiLinear2DFiniteElement", _wrap_new_RefinedBiLinear2DFiniteElement, METH_NOARGS, "new_RefinedBiLinear2DFiniteElement() -> RefinedBiLinear2DFiniteElement"}, + { "RefinedBiLinear2DFiniteElement_CalcShape", _wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedBiLinear2DFiniteElement_CalcDShape", _wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedBiLinear2DFiniteElement", _wrap_delete_RefinedBiLinear2DFiniteElement, METH_O, "delete_RefinedBiLinear2DFiniteElement(RefinedBiLinear2DFiniteElement self)"}, + { "RefinedBiLinear2DFiniteElement_swigregister", RefinedBiLinear2DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedBiLinear2DFiniteElement_swiginit", RefinedBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RefinedTriLinear3DFiniteElement", _wrap_new_RefinedTriLinear3DFiniteElement, METH_NOARGS, "new_RefinedTriLinear3DFiniteElement() -> RefinedTriLinear3DFiniteElement"}, + { "RefinedTriLinear3DFiniteElement_CalcShape", _wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedTriLinear3DFiniteElement_CalcDShape", _wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RefinedTriLinear3DFiniteElement", _wrap_delete_RefinedTriLinear3DFiniteElement, METH_O, "delete_RefinedTriLinear3DFiniteElement(RefinedTriLinear3DFiniteElement self)"}, + { "RefinedTriLinear3DFiniteElement_swigregister", RefinedTriLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "RefinedTriLinear3DFiniteElement_swiginit", RefinedTriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Nedelec1HexFiniteElement", _wrap_new_Nedelec1HexFiniteElement, METH_NOARGS, "new_Nedelec1HexFiniteElement() -> Nedelec1HexFiniteElement"}, + { "Nedelec1HexFiniteElement_CalcVShape", _wrap_Nedelec1HexFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "Nedelec1HexFiniteElement_CalcCurlShape", _wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1HexFiniteElement_GetLocalInterpolation", _wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1HexFiniteElement_Project", _wrap_Nedelec1HexFiniteElement_Project, METH_VARARGS, "\n" + "Project(Nedelec1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_Nedelec1HexFiniteElement", _wrap_delete_Nedelec1HexFiniteElement, METH_O, "delete_Nedelec1HexFiniteElement(Nedelec1HexFiniteElement self)"}, + { "Nedelec1HexFiniteElement_swigregister", Nedelec1HexFiniteElement_swigregister, METH_O, NULL}, + { "Nedelec1HexFiniteElement_swiginit", Nedelec1HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Nedelec1TetFiniteElement", _wrap_new_Nedelec1TetFiniteElement, METH_NOARGS, "new_Nedelec1TetFiniteElement() -> Nedelec1TetFiniteElement"}, + { "Nedelec1TetFiniteElement_CalcVShape", _wrap_Nedelec1TetFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "Nedelec1TetFiniteElement_CalcCurlShape", _wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1TetFiniteElement_GetLocalInterpolation", _wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1TetFiniteElement_Project", _wrap_Nedelec1TetFiniteElement_Project, METH_VARARGS, "\n" + "Project(Nedelec1TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(Nedelec1TetFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_Nedelec1TetFiniteElement", _wrap_delete_Nedelec1TetFiniteElement, METH_O, "delete_Nedelec1TetFiniteElement(Nedelec1TetFiniteElement self)"}, + { "Nedelec1TetFiniteElement_swigregister", Nedelec1TetFiniteElement_swigregister, METH_O, NULL}, + { "Nedelec1TetFiniteElement_swiginit", Nedelec1TetFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0HexFiniteElement", _wrap_new_RT0HexFiniteElement, METH_NOARGS, "new_RT0HexFiniteElement() -> RT0HexFiniteElement"}, + { "RT0HexFiniteElement_CalcVShape", _wrap_RT0HexFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0HexFiniteElement_CalcDivShape", _wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0HexFiniteElement_GetLocalInterpolation", _wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0HexFiniteElement_Project", _wrap_RT0HexFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0HexFiniteElement", _wrap_delete_RT0HexFiniteElement, METH_O, "delete_RT0HexFiniteElement(RT0HexFiniteElement self)"}, + { "RT0HexFiniteElement_swigregister", RT0HexFiniteElement_swigregister, METH_O, NULL}, + { "RT0HexFiniteElement_swiginit", RT0HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT1HexFiniteElement", _wrap_new_RT1HexFiniteElement, METH_NOARGS, "new_RT1HexFiniteElement() -> RT1HexFiniteElement"}, + { "RT1HexFiniteElement_CalcVShape", _wrap_RT1HexFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT1HexFiniteElement_CalcDivShape", _wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1HexFiniteElement_GetLocalInterpolation", _wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1HexFiniteElement_Project", _wrap_RT1HexFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT1HexFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT1HexFiniteElement", _wrap_delete_RT1HexFiniteElement, METH_O, "delete_RT1HexFiniteElement(RT1HexFiniteElement self)"}, + { "RT1HexFiniteElement_swigregister", RT1HexFiniteElement_swigregister, METH_O, NULL}, + { "RT1HexFiniteElement_swiginit", RT1HexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RT0TetFiniteElement", _wrap_new_RT0TetFiniteElement, METH_NOARGS, "new_RT0TetFiniteElement() -> RT0TetFiniteElement"}, + { "RT0TetFiniteElement_CalcVShape", _wrap_RT0TetFiniteElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT0TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT0TetFiniteElement_CalcDivShape", _wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TetFiniteElement_GetLocalInterpolation", _wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TetFiniteElement_Project", _wrap_RT0TetFiniteElement_Project, METH_VARARGS, "\n" + "Project(RT0TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT0TetFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + ""}, + { "delete_RT0TetFiniteElement", _wrap_delete_RT0TetFiniteElement, METH_O, "delete_RT0TetFiniteElement(RT0TetFiniteElement self)"}, + { "RT0TetFiniteElement_swigregister", RT0TetFiniteElement_swigregister, METH_O, NULL}, + { "RT0TetFiniteElement_swiginit", RT0TetFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_RotTriLinearHexFiniteElement", _wrap_new_RotTriLinearHexFiniteElement, METH_NOARGS, "new_RotTriLinearHexFiniteElement() -> RotTriLinearHexFiniteElement"}, + { "RotTriLinearHexFiniteElement_CalcShape", _wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RotTriLinearHexFiniteElement_CalcDShape", _wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_RotTriLinearHexFiniteElement", _wrap_delete_RotTriLinearHexFiniteElement, METH_O, "delete_RotTriLinearHexFiniteElement(RotTriLinearHexFiniteElement self)"}, + { "RotTriLinearHexFiniteElement_swigregister", RotTriLinearHexFiniteElement_swigregister, METH_O, NULL}, + { "RotTriLinearHexFiniteElement_swiginit", RotTriLinearHexFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_Poly_1D", _wrap_new_Poly_1D, METH_NOARGS, "new_Poly_1D() -> Poly_1D"}, + { "Poly_1D_Binom", _wrap_Poly_1D_Binom, METH_O, "Binom(int const p) -> int const *"}, + { "Poly_1D_GetPoints", _wrap_Poly_1D_GetPoints, METH_VARARGS, "GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, + { "Poly_1D_OpenPoints", _wrap_Poly_1D_OpenPoints, METH_VARARGS, "OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const"}, + { "Poly_1D_ClosedPoints", _wrap_Poly_1D_ClosedPoints, METH_VARARGS, "ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const"}, + { "Poly_1D_GetBasis", _wrap_Poly_1D_GetBasis, METH_VARARGS, "GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, + { "Poly_1D_CalcBasis", _wrap_Poly_1D_CalcBasis, METH_VARARGS, "\n" + "CalcBasis(int const p, double const x, double * u)\n" + "CalcBasis(int const p, double const x, double * u, double * d)\n" + "CalcBasis(int const p, double const x, double * u, double * d, double * dd)\n" + ""}, + { "Poly_1D_CalcDelta", _wrap_Poly_1D_CalcDelta, METH_VARARGS, "CalcDelta(int const p, double const x) -> double"}, + { "Poly_1D_ChebyshevPoints", _wrap_Poly_1D_ChebyshevPoints, METH_VARARGS, "ChebyshevPoints(int const p, double * x)"}, + { "Poly_1D_CalcBinomTerms", _wrap_Poly_1D_CalcBinomTerms, METH_VARARGS, "\n" + "CalcBinomTerms(int const p, double const x, double const y, double * u)\n" + "CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)\n" + ""}, + { "Poly_1D_CalcDBinomTerms", _wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS, "CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, + { "Poly_1D_CalcBernstein", _wrap_Poly_1D_CalcBernstein, METH_VARARGS, "\n" + "CalcBernstein(int const p, double const x, double * u)\n" + "CalcBernstein(int const p, double const x, double * u, double * d)\n" + ""}, + { "Poly_1D_CalcLegendre", _wrap_Poly_1D_CalcLegendre, METH_VARARGS, "\n" + "CalcLegendre(int const p, double const x, double * u)\n" + "CalcLegendre(int const p, double const x, double * u, double * d)\n" + ""}, + { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, + { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, + { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, + { "new_TensorBasisElement", _wrap_new_TensorBasisElement, METH_VARARGS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, + { "TensorBasisElement_GetBasisType", _wrap_TensorBasisElement_GetBasisType, METH_O, "GetBasisType(TensorBasisElement self) -> int"}, + { "TensorBasisElement_GetBasis1D", _wrap_TensorBasisElement_GetBasis1D, METH_O, "GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &"}, + { "TensorBasisElement_GetDofMap", _wrap_TensorBasisElement_GetDofMap, METH_O, "GetDofMap(TensorBasisElement self) -> intArray"}, + { "TensorBasisElement_GetTensorProductGeometry", _wrap_TensorBasisElement_GetTensorProductGeometry, METH_O, "GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, + { "TensorBasisElement_Pow", _wrap_TensorBasisElement_Pow, METH_VARARGS, "Pow(int base, int dim) -> int"}, + { "delete_TensorBasisElement", _wrap_delete_TensorBasisElement, METH_O, "delete_TensorBasisElement(TensorBasisElement self)"}, + { "TensorBasisElement_swigregister", TensorBasisElement_swigregister, METH_O, NULL}, + { "TensorBasisElement_swiginit", TensorBasisElement_swiginit, METH_VARARGS, NULL}, + { "NodalTensorFiniteElement_GetDofToQuad", _wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_NodalTensorFiniteElement", _wrap_delete_NodalTensorFiniteElement, METH_O, "delete_NodalTensorFiniteElement(NodalTensorFiniteElement self)"}, + { "NodalTensorFiniteElement_swigregister", NodalTensorFiniteElement_swigregister, METH_O, NULL}, + { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, + { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, + { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, + { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, + { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, + { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_SegmentElement_ProjectDelta", _wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_H1_SegmentElement", _wrap_delete_H1_SegmentElement, METH_O, "delete_H1_SegmentElement(H1_SegmentElement self)"}, + { "H1_SegmentElement_swigregister", H1_SegmentElement_swigregister, METH_O, NULL}, + { "H1_SegmentElement_swiginit", H1_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_QuadrilateralElement", _wrap_new_H1_QuadrilateralElement, METH_VARARGS, "H1_QuadrilateralElement(int const p, int const btype=GaussLobatto)"}, + { "H1_QuadrilateralElement_CalcShape", _wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_QuadrilateralElement_CalcDShape", _wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_QuadrilateralElement_ProjectDelta", _wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "delete_H1_QuadrilateralElement", _wrap_delete_H1_QuadrilateralElement, METH_O, "delete_H1_QuadrilateralElement(H1_QuadrilateralElement self)"}, + { "H1_QuadrilateralElement_swigregister", H1_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1_QuadrilateralElement_swiginit", H1_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_HexahedronElement", _wrap_new_H1_HexahedronElement, METH_VARARGS, "H1_HexahedronElement(int const p, int const btype=GaussLobatto)"}, + { "H1_HexahedronElement_CalcShape", _wrap_H1_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_HexahedronElement_CalcDShape", _wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_HexahedronElement_ProjectDelta", _wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_H1_HexahedronElement", _wrap_delete_H1_HexahedronElement, METH_O, "delete_H1_HexahedronElement(H1_HexahedronElement self)"}, + { "H1_HexahedronElement_swigregister", H1_HexahedronElement_swigregister, METH_O, NULL}, + { "H1_HexahedronElement_swiginit", H1_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_SegmentElement", _wrap_new_H1Pos_SegmentElement, METH_O, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, + { "H1Pos_SegmentElement_CalcShape", _wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_SegmentElement_CalcDShape", _wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_SegmentElement_ProjectDelta", _wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_H1Pos_SegmentElement", _wrap_delete_H1Pos_SegmentElement, METH_O, "delete_H1Pos_SegmentElement(H1Pos_SegmentElement self)"}, + { "H1Pos_SegmentElement_swigregister", H1Pos_SegmentElement_swigregister, METH_O, NULL}, + { "H1Pos_SegmentElement_swiginit", H1Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_QuadrilateralElement", _wrap_new_H1Pos_QuadrilateralElement, METH_O, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, + { "H1Pos_QuadrilateralElement_CalcShape", _wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_QuadrilateralElement_CalcDShape", _wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_QuadrilateralElement_ProjectDelta", _wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, + { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" + "Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(H1Ser_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, + { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, + { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, + { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_HexahedronElement_ProjectDelta", _wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_H1Pos_HexahedronElement", _wrap_delete_H1Pos_HexahedronElement, METH_O, "delete_H1Pos_HexahedronElement(H1Pos_HexahedronElement self)"}, + { "H1Pos_HexahedronElement_swigregister", H1Pos_HexahedronElement_swigregister, METH_O, NULL}, + { "H1Pos_HexahedronElement_swiginit", H1Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_TriangleElement", _wrap_new_H1_TriangleElement, METH_VARARGS, "H1_TriangleElement(int const p, int const btype=GaussLobatto)"}, + { "H1_TriangleElement_CalcShape", _wrap_H1_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TriangleElement_CalcDShape", _wrap_H1_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TriangleElement_CalcHessian", _wrap_H1_TriangleElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "delete_H1_TriangleElement", _wrap_delete_H1_TriangleElement, METH_O, "delete_H1_TriangleElement(H1_TriangleElement self)"}, + { "H1_TriangleElement_swigregister", H1_TriangleElement_swigregister, METH_O, NULL}, + { "H1_TriangleElement_swiginit", H1_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_TetrahedronElement", _wrap_new_H1_TetrahedronElement, METH_VARARGS, "H1_TetrahedronElement(int const p, int const btype=GaussLobatto)"}, + { "H1_TetrahedronElement_CalcShape", _wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TetrahedronElement_CalcDShape", _wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TetrahedronElement_CalcHessian", _wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "delete_H1_TetrahedronElement", _wrap_delete_H1_TetrahedronElement, METH_O, "delete_H1_TetrahedronElement(H1_TetrahedronElement self)"}, + { "H1_TetrahedronElement_swigregister", H1_TetrahedronElement_swigregister, METH_O, NULL}, + { "H1_TetrahedronElement_swiginit", H1_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_TriangleElement", _wrap_new_H1Pos_TriangleElement, METH_O, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, + { "H1Pos_TriangleElement_CalcShape", _wrap_H1Pos_TriangleElement_CalcShape, METH_VARARGS, "\n" + "CalcShape(int const p, double const x, double const y, double * shape)\n" + "CalcShape(IntegrationPoint ip, Vector shape)\n" + ""}, + { "H1Pos_TriangleElement_CalcDShape", _wrap_H1Pos_TriangleElement_CalcDShape, METH_VARARGS, "\n" + "CalcDShape(int const p, double const x, double const y, double * dshape_1d, double * dshape)\n" + "CalcDShape(IntegrationPoint ip, DenseMatrix dshape)\n" + ""}, + { "delete_H1Pos_TriangleElement", _wrap_delete_H1Pos_TriangleElement, METH_O, "delete_H1Pos_TriangleElement(H1Pos_TriangleElement self)"}, + { "H1Pos_TriangleElement_swigregister", H1Pos_TriangleElement_swigregister, METH_O, NULL}, + { "H1Pos_TriangleElement_swiginit", H1Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_TetrahedronElement", _wrap_new_H1Pos_TetrahedronElement, METH_O, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, + { "H1Pos_TetrahedronElement_CalcShape", _wrap_H1Pos_TetrahedronElement_CalcShape, METH_VARARGS, "\n" + "CalcShape(int const p, double const x, double const y, double const z, double * shape)\n" + "CalcShape(IntegrationPoint ip, Vector shape)\n" + ""}, + { "H1Pos_TetrahedronElement_CalcDShape", _wrap_H1Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "\n" + "CalcDShape(int const p, double const x, double const y, double const z, double * dshape_1d, double * dshape)\n" + "CalcDShape(IntegrationPoint ip, DenseMatrix dshape)\n" + ""}, + { "delete_H1Pos_TetrahedronElement", _wrap_delete_H1Pos_TetrahedronElement, METH_O, "delete_H1Pos_TetrahedronElement(H1Pos_TetrahedronElement self)"}, + { "H1Pos_TetrahedronElement_swigregister", H1Pos_TetrahedronElement_swigregister, METH_O, NULL}, + { "H1Pos_TetrahedronElement_swiginit", H1Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_H1_WedgeElement", _wrap_new_H1_WedgeElement, METH_VARARGS, "H1_WedgeElement(int const p, int const btype=GaussLobatto)"}, + { "H1_WedgeElement_CalcShape", _wrap_H1_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_WedgeElement_CalcDShape", _wrap_H1_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_H1_WedgeElement", _wrap_delete_H1_WedgeElement, METH_O, "delete_H1_WedgeElement(H1_WedgeElement self)"}, + { "H1_WedgeElement_swigregister", H1_WedgeElement_swigregister, METH_O, NULL}, + { "H1_WedgeElement_swiginit", H1_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_BiLinear3DFiniteElement", _wrap_new_BiLinear3DFiniteElement, METH_NOARGS, "new_BiLinear3DFiniteElement() -> BiLinear3DFiniteElement"}, + { "delete_BiLinear3DFiniteElement", _wrap_delete_BiLinear3DFiniteElement, METH_O, "delete_BiLinear3DFiniteElement(BiLinear3DFiniteElement self)"}, + { "BiLinear3DFiniteElement_swigregister", BiLinear3DFiniteElement_swigregister, METH_O, NULL}, + { "BiLinear3DFiniteElement_swiginit", BiLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiQuadratic3DFiniteElement", _wrap_new_BiQuadratic3DFiniteElement, METH_NOARGS, "new_BiQuadratic3DFiniteElement() -> BiQuadratic3DFiniteElement"}, + { "delete_BiQuadratic3DFiniteElement", _wrap_delete_BiQuadratic3DFiniteElement, METH_O, "delete_BiQuadratic3DFiniteElement(BiQuadratic3DFiniteElement self)"}, + { "BiQuadratic3DFiniteElement_swigregister", BiQuadratic3DFiniteElement_swigregister, METH_O, NULL}, + { "BiQuadratic3DFiniteElement_swiginit", BiQuadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_BiCubic3DFiniteElement", _wrap_new_BiCubic3DFiniteElement, METH_NOARGS, "new_BiCubic3DFiniteElement() -> BiCubic3DFiniteElement"}, + { "delete_BiCubic3DFiniteElement", _wrap_delete_BiCubic3DFiniteElement, METH_O, "delete_BiCubic3DFiniteElement(BiCubic3DFiniteElement self)"}, + { "BiCubic3DFiniteElement_swigregister", BiCubic3DFiniteElement_swigregister, METH_O, NULL}, + { "BiCubic3DFiniteElement_swiginit", BiCubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_H1Pos_WedgeElement", _wrap_new_H1Pos_WedgeElement, METH_O, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, + { "H1Pos_WedgeElement_CalcShape", _wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_WedgeElement_CalcDShape", _wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_H1Pos_WedgeElement", _wrap_delete_H1Pos_WedgeElement, METH_O, "delete_H1Pos_WedgeElement(H1Pos_WedgeElement self)"}, + { "H1Pos_WedgeElement_swigregister", H1Pos_WedgeElement_swigregister, METH_O, NULL}, + { "H1Pos_WedgeElement_swiginit", H1Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_SegmentElement", _wrap_new_L2_SegmentElement, METH_VARARGS, "L2_SegmentElement(int const p, int const btype=GaussLegendre)"}, + { "L2_SegmentElement_CalcShape", _wrap_L2_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_SegmentElement_CalcDShape", _wrap_L2_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_SegmentElement_ProjectDelta", _wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_L2_SegmentElement", _wrap_delete_L2_SegmentElement, METH_O, "delete_L2_SegmentElement(L2_SegmentElement self)"}, + { "L2_SegmentElement_swigregister", L2_SegmentElement_swigregister, METH_O, NULL}, + { "L2_SegmentElement_swiginit", L2_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_SegmentElement", _wrap_new_L2Pos_SegmentElement, METH_O, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, + { "L2Pos_SegmentElement_CalcShape", _wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_SegmentElement_CalcDShape", _wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_SegmentElement_ProjectDelta", _wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_SegmentElement", _wrap_delete_L2Pos_SegmentElement, METH_O, "delete_L2Pos_SegmentElement(L2Pos_SegmentElement self)"}, + { "L2Pos_SegmentElement_swigregister", L2Pos_SegmentElement_swigregister, METH_O, NULL}, + { "L2Pos_SegmentElement_swiginit", L2Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_QuadrilateralElement", _wrap_new_L2_QuadrilateralElement, METH_VARARGS, "L2_QuadrilateralElement(int const p, int const btype=GaussLegendre)"}, + { "L2_QuadrilateralElement_CalcShape", _wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_QuadrilateralElement_CalcDShape", _wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_QuadrilateralElement_ProjectDelta", _wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "L2_QuadrilateralElement_ProjectCurl", _wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_L2_QuadrilateralElement", _wrap_delete_L2_QuadrilateralElement, METH_O, "delete_L2_QuadrilateralElement(L2_QuadrilateralElement self)"}, + { "L2_QuadrilateralElement_swigregister", L2_QuadrilateralElement_swigregister, METH_O, NULL}, + { "L2_QuadrilateralElement_swiginit", L2_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_QuadrilateralElement", _wrap_new_L2Pos_QuadrilateralElement, METH_O, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, + { "L2Pos_QuadrilateralElement_CalcShape", _wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_QuadrilateralElement_CalcDShape", _wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_QuadrilateralElement_ProjectDelta", _wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_QuadrilateralElement", _wrap_delete_L2Pos_QuadrilateralElement, METH_O, "delete_L2Pos_QuadrilateralElement(L2Pos_QuadrilateralElement self)"}, + { "L2Pos_QuadrilateralElement_swigregister", L2Pos_QuadrilateralElement_swigregister, METH_O, NULL}, + { "L2Pos_QuadrilateralElement_swiginit", L2Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_HexahedronElement", _wrap_new_L2_HexahedronElement, METH_VARARGS, "L2_HexahedronElement(int const p, int const btype=GaussLegendre)"}, + { "L2_HexahedronElement_CalcShape", _wrap_L2_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_HexahedronElement_CalcDShape", _wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_HexahedronElement_ProjectDelta", _wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2_HexahedronElement", _wrap_delete_L2_HexahedronElement, METH_O, "delete_L2_HexahedronElement(L2_HexahedronElement self)"}, + { "L2_HexahedronElement_swigregister", L2_HexahedronElement_swigregister, METH_O, NULL}, + { "L2_HexahedronElement_swiginit", L2_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_HexahedronElement", _wrap_new_L2Pos_HexahedronElement, METH_O, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, + { "L2Pos_HexahedronElement_CalcShape", _wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_HexahedronElement_CalcDShape", _wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_HexahedronElement_ProjectDelta", _wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_HexahedronElement", _wrap_delete_L2Pos_HexahedronElement, METH_O, "delete_L2Pos_HexahedronElement(L2Pos_HexahedronElement self)"}, + { "L2Pos_HexahedronElement_swigregister", L2Pos_HexahedronElement_swigregister, METH_O, NULL}, + { "L2Pos_HexahedronElement_swiginit", L2Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_TriangleElement", _wrap_new_L2_TriangleElement, METH_VARARGS, "L2_TriangleElement(int const p, int const btype=GaussLegendre)"}, + { "L2_TriangleElement_CalcShape", _wrap_L2_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TriangleElement_CalcDShape", _wrap_L2_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TriangleElement_ProjectDelta", _wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, + { "L2_TriangleElement_ProjectCurl", _wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_L2_TriangleElement", _wrap_delete_L2_TriangleElement, METH_O, "delete_L2_TriangleElement(L2_TriangleElement self)"}, + { "L2_TriangleElement_swigregister", L2_TriangleElement_swigregister, METH_O, NULL}, + { "L2_TriangleElement_swiginit", L2_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_TriangleElement", _wrap_new_L2Pos_TriangleElement, METH_O, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, + { "L2Pos_TriangleElement_CalcShape", _wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TriangleElement_CalcDShape", _wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TriangleElement_ProjectDelta", _wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_TriangleElement", _wrap_delete_L2Pos_TriangleElement, METH_O, "delete_L2Pos_TriangleElement(L2Pos_TriangleElement self)"}, + { "L2Pos_TriangleElement_swigregister", L2Pos_TriangleElement_swigregister, METH_O, NULL}, + { "L2Pos_TriangleElement_swiginit", L2Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_TetrahedronElement", _wrap_new_L2_TetrahedronElement, METH_VARARGS, "L2_TetrahedronElement(int const p, int const btype=GaussLegendre)"}, + { "L2_TetrahedronElement_CalcShape", _wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TetrahedronElement_CalcDShape", _wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TetrahedronElement_ProjectDelta", _wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2_TetrahedronElement", _wrap_delete_L2_TetrahedronElement, METH_O, "delete_L2_TetrahedronElement(L2_TetrahedronElement self)"}, + { "L2_TetrahedronElement_swigregister", L2_TetrahedronElement_swigregister, METH_O, NULL}, + { "L2_TetrahedronElement_swiginit", L2_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_TetrahedronElement", _wrap_new_L2Pos_TetrahedronElement, METH_O, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, + { "L2Pos_TetrahedronElement_CalcShape", _wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TetrahedronElement_CalcDShape", _wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TetrahedronElement_ProjectDelta", _wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, + { "delete_L2Pos_TetrahedronElement", _wrap_delete_L2Pos_TetrahedronElement, METH_O, "delete_L2Pos_TetrahedronElement(L2Pos_TetrahedronElement self)"}, + { "L2Pos_TetrahedronElement_swigregister", L2Pos_TetrahedronElement_swigregister, METH_O, NULL}, + { "L2Pos_TetrahedronElement_swiginit", L2Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_L2_WedgeElement", _wrap_new_L2_WedgeElement, METH_VARARGS, "L2_WedgeElement(int const p, int const btype=GaussLegendre)"}, + { "L2_WedgeElement_CalcShape", _wrap_L2_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_WedgeElement_CalcDShape", _wrap_L2_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_L2_WedgeElement", _wrap_delete_L2_WedgeElement, METH_O, "delete_L2_WedgeElement(L2_WedgeElement self)"}, + { "L2_WedgeElement_swigregister", L2_WedgeElement_swigregister, METH_O, NULL}, + { "L2_WedgeElement_swiginit", L2_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_P0WedgeFiniteElement", _wrap_new_P0WedgeFiniteElement, METH_NOARGS, "new_P0WedgeFiniteElement() -> P0WedgeFiniteElement"}, + { "delete_P0WedgeFiniteElement", _wrap_delete_P0WedgeFiniteElement, METH_O, "delete_P0WedgeFiniteElement(P0WedgeFiniteElement self)"}, + { "P0WedgeFiniteElement_swigregister", P0WedgeFiniteElement_swigregister, METH_O, NULL}, + { "P0WedgeFiniteElement_swiginit", P0WedgeFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_L2Pos_WedgeElement", _wrap_new_L2Pos_WedgeElement, METH_O, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, + { "L2Pos_WedgeElement_CalcShape", _wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_WedgeElement_CalcDShape", _wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "delete_L2Pos_WedgeElement", _wrap_delete_L2Pos_WedgeElement, METH_O, "delete_L2Pos_WedgeElement(L2Pos_WedgeElement self)"}, + { "L2Pos_WedgeElement_swigregister", L2Pos_WedgeElement_swigregister, METH_O, NULL}, + { "L2Pos_WedgeElement_swiginit", L2Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_QuadrilateralElement", _wrap_new_RT_QuadrilateralElement, METH_VARARGS, "RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "RT_QuadrilateralElement_CalcVShape", _wrap_RT_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_QuadrilateralElement_CalcDivShape", _wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_QuadrilateralElement_GetLocalInterpolation", _wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_GetLocalRestriction", _wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_QuadrilateralElement_GetTransferMatrix", _wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_QuadrilateralElement_Project", _wrap_RT_QuadrilateralElement_Project, METH_VARARGS, "\n" + "Project(RT_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_QuadrilateralElement_ProjectGrad", _wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_QuadrilateralElement_ProjectCurl", _wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_QuadrilateralElement", _wrap_delete_RT_QuadrilateralElement, METH_O, "delete_RT_QuadrilateralElement(RT_QuadrilateralElement self)"}, + { "RT_QuadrilateralElement_swigregister", RT_QuadrilateralElement_swigregister, METH_O, NULL}, + { "RT_QuadrilateralElement_swiginit", RT_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_HexahedronElement", _wrap_new_RT_HexahedronElement, METH_VARARGS, "RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "RT_HexahedronElement_CalcVShape", _wrap_RT_HexahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_HexahedronElement_CalcDivShape", _wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_HexahedronElement_GetLocalInterpolation", _wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_GetLocalRestriction", _wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_HexahedronElement_GetTransferMatrix", _wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_ProjectMatrixCoefficient", _wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_HexahedronElement_Project", _wrap_RT_HexahedronElement_Project, METH_VARARGS, "\n" + "Project(RT_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_HexahedronElement_ProjectCurl", _wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_HexahedronElement", _wrap_delete_RT_HexahedronElement, METH_O, "delete_RT_HexahedronElement(RT_HexahedronElement self)"}, + { "RT_HexahedronElement_swigregister", RT_HexahedronElement_swigregister, METH_O, NULL}, + { "RT_HexahedronElement_swiginit", RT_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_TriangleElement", _wrap_new_RT_TriangleElement, METH_O, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, + { "RT_TriangleElement_CalcVShape", _wrap_RT_TriangleElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_TriangleElement_CalcDivShape", _wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TriangleElement_GetLocalInterpolation", _wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_GetLocalRestriction", _wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TriangleElement_GetTransferMatrix", _wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_ProjectMatrixCoefficient", _wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TriangleElement_Project", _wrap_RT_TriangleElement_Project, METH_VARARGS, "\n" + "Project(RT_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_TriangleElement_ProjectGrad", _wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_TriangleElement_ProjectCurl", _wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_TriangleElement", _wrap_delete_RT_TriangleElement, METH_O, "delete_RT_TriangleElement(RT_TriangleElement self)"}, + { "RT_TriangleElement_swigregister", RT_TriangleElement_swigregister, METH_O, NULL}, + { "RT_TriangleElement_swiginit", RT_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_RT_TetrahedronElement", _wrap_new_RT_TetrahedronElement, METH_O, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, + { "RT_TetrahedronElement_CalcVShape", _wrap_RT_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(RT_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "RT_TetrahedronElement_CalcDivShape", _wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TetrahedronElement_GetLocalInterpolation", _wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_GetLocalRestriction", _wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TetrahedronElement_GetTransferMatrix", _wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_ProjectMatrixCoefficient", _wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TetrahedronElement_Project", _wrap_RT_TetrahedronElement_Project, METH_VARARGS, "\n" + "Project(RT_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "RT_TetrahedronElement_ProjectCurl", _wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_RT_TetrahedronElement", _wrap_delete_RT_TetrahedronElement, METH_O, "delete_RT_TetrahedronElement(RT_TetrahedronElement self)"}, + { "RT_TetrahedronElement_swigregister", RT_TetrahedronElement_swigregister, METH_O, NULL}, + { "RT_TetrahedronElement_swiginit", RT_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_HexahedronElement", _wrap_new_ND_HexahedronElement, METH_VARARGS, "ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "ND_HexahedronElement_CalcVShape", _wrap_ND_HexahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_HexahedronElement_CalcCurlShape", _wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_HexahedronElement_GetLocalInterpolation", _wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_GetLocalRestriction", _wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_HexahedronElement_GetTransferMatrix", _wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_ProjectMatrixCoefficient", _wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_HexahedronElement_Project", _wrap_ND_HexahedronElement_Project, METH_VARARGS, "\n" + "Project(ND_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_HexahedronElement_ProjectGrad", _wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_HexahedronElement_ProjectCurl", _wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_ND_HexahedronElement", _wrap_delete_ND_HexahedronElement, METH_O, "delete_ND_HexahedronElement(ND_HexahedronElement self)"}, + { "ND_HexahedronElement_swigregister", ND_HexahedronElement_swigregister, METH_O, NULL}, + { "ND_HexahedronElement_swiginit", ND_HexahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_QuadrilateralElement", _wrap_new_ND_QuadrilateralElement, METH_VARARGS, "ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "ND_QuadrilateralElement_CalcVShape", _wrap_ND_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_QuadrilateralElement_CalcCurlShape", _wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_QuadrilateralElement_GetLocalInterpolation", _wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_GetLocalRestriction", _wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_QuadrilateralElement_GetTransferMatrix", _wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_QuadrilateralElement_Project", _wrap_ND_QuadrilateralElement_Project, METH_VARARGS, "\n" + "Project(ND_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_QuadrilateralElement_ProjectGrad", _wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "delete_ND_QuadrilateralElement", _wrap_delete_ND_QuadrilateralElement, METH_O, "delete_ND_QuadrilateralElement(ND_QuadrilateralElement self)"}, + { "ND_QuadrilateralElement_swigregister", ND_QuadrilateralElement_swigregister, METH_O, NULL}, + { "ND_QuadrilateralElement_swiginit", ND_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_TetrahedronElement", _wrap_new_ND_TetrahedronElement, METH_O, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, + { "ND_TetrahedronElement_CalcVShape", _wrap_ND_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_TetrahedronElement_CalcCurlShape", _wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TetrahedronElement_GetLocalInterpolation", _wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_GetLocalRestriction", _wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TetrahedronElement_GetTransferMatrix", _wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_ProjectMatrixCoefficient", _wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TetrahedronElement_Project", _wrap_ND_TetrahedronElement_Project, METH_VARARGS, "\n" + "Project(ND_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_TetrahedronElement_ProjectGrad", _wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TetrahedronElement_ProjectCurl", _wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "delete_ND_TetrahedronElement", _wrap_delete_ND_TetrahedronElement, METH_O, "delete_ND_TetrahedronElement(ND_TetrahedronElement self)"}, + { "ND_TetrahedronElement_swigregister", ND_TetrahedronElement_swigregister, METH_O, NULL}, + { "ND_TetrahedronElement_swiginit", ND_TetrahedronElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_TriangleElement", _wrap_new_ND_TriangleElement, METH_O, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, + { "ND_TriangleElement_CalcVShape", _wrap_ND_TriangleElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_TriangleElement_CalcCurlShape", _wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TriangleElement_GetLocalInterpolation", _wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_GetLocalRestriction", _wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TriangleElement_GetTransferMatrix", _wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_ProjectMatrixCoefficient", _wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TriangleElement_Project", _wrap_ND_TriangleElement_Project, METH_VARARGS, "\n" + "Project(ND_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_TriangleElement_ProjectGrad", _wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "delete_ND_TriangleElement", _wrap_delete_ND_TriangleElement, METH_O, "delete_ND_TriangleElement(ND_TriangleElement self)"}, + { "ND_TriangleElement_swigregister", ND_TriangleElement_swigregister, METH_O, NULL}, + { "ND_TriangleElement_swiginit", ND_TriangleElement_swiginit, METH_VARARGS, NULL}, + { "new_ND_SegmentElement", _wrap_new_ND_SegmentElement, METH_VARARGS, "ND_SegmentElement(int const p, int const ob_type=GaussLegendre)"}, + { "ND_SegmentElement_CalcShape", _wrap_ND_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "ND_SegmentElement_CalcVShape", _wrap_ND_SegmentElement_CalcVShape, METH_VARARGS, "\n" + "CalcVShape(ND_SegmentElement self, IntegrationPoint ip, DenseMatrix shape)\n" + "CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" + ""}, + { "ND_SegmentElement_GetLocalInterpolation", _wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_GetLocalRestriction", _wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_SegmentElement_GetTransferMatrix", _wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_ProjectMatrixCoefficient", _wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_SegmentElement_Project", _wrap_ND_SegmentElement_Project, METH_VARARGS, "\n" + "Project(ND_SegmentElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" + "Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" + ""}, + { "ND_SegmentElement_ProjectGrad", _wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "delete_ND_SegmentElement", _wrap_delete_ND_SegmentElement, METH_O, "delete_ND_SegmentElement(ND_SegmentElement self)"}, + { "ND_SegmentElement_swigregister", ND_SegmentElement_swigregister, METH_O, NULL}, + { "ND_SegmentElement_swiginit", ND_SegmentElement_swiginit, METH_VARARGS, NULL}, + { "NURBSFiniteElement_Reset", _wrap_NURBSFiniteElement_Reset, METH_O, "Reset(NURBSFiniteElement self)"}, + { "NURBSFiniteElement_SetIJK", _wrap_NURBSFiniteElement_SetIJK, METH_VARARGS, "SetIJK(NURBSFiniteElement self, int const * IJK)"}, + { "NURBSFiniteElement_GetPatch", _wrap_NURBSFiniteElement_GetPatch, METH_O, "GetPatch(NURBSFiniteElement self) -> int"}, + { "NURBSFiniteElement_SetPatch", _wrap_NURBSFiniteElement_SetPatch, METH_VARARGS, "SetPatch(NURBSFiniteElement self, int p)"}, + { "NURBSFiniteElement_GetElement", _wrap_NURBSFiniteElement_GetElement, METH_O, "GetElement(NURBSFiniteElement self) -> int"}, + { "NURBSFiniteElement_SetElement", _wrap_NURBSFiniteElement_SetElement, METH_VARARGS, "SetElement(NURBSFiniteElement self, int e)"}, + { "NURBSFiniteElement_KnotVectors", _wrap_NURBSFiniteElement_KnotVectors, METH_O, "KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &"}, + { "NURBSFiniteElement_Weights", _wrap_NURBSFiniteElement_Weights, METH_O, "Weights(NURBSFiniteElement self) -> Vector"}, + { "NURBSFiniteElement_SetOrder", _wrap_NURBSFiniteElement_SetOrder, METH_O, "SetOrder(NURBSFiniteElement self)"}, + { "delete_NURBSFiniteElement", _wrap_delete_NURBSFiniteElement, METH_O, "delete_NURBSFiniteElement(NURBSFiniteElement self)"}, + { "NURBSFiniteElement_swigregister", NURBSFiniteElement_swigregister, METH_O, NULL}, + { "new_NURBS1DFiniteElement", _wrap_new_NURBS1DFiniteElement, METH_O, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, + { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS1DFiniteElement self)"}, + { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, + { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, + { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_NURBS2DFiniteElement", _wrap_new_NURBS2DFiniteElement, METH_VARARGS, "\n" + "NURBS2DFiniteElement(int p)\n" + "new_NURBS2DFiniteElement(int px, int py) -> NURBS2DFiniteElement\n" + ""}, + { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS2DFiniteElement self)"}, + { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, + { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, + { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, + { "new_NURBS3DFiniteElement", _wrap_new_NURBS3DFiniteElement, METH_VARARGS, "\n" + "NURBS3DFiniteElement(int p)\n" + "new_NURBS3DFiniteElement(int px, int py, int pz) -> NURBS3DFiniteElement\n" + ""}, + { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS3DFiniteElement self)"}, + { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, + { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, + { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS2DFiniteElement *) x)); -} static void *_p_mfem__NURBS1DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS1DFiniteElement *) x)); } @@ -51534,6 +54069,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__ScalarFiniteElement(void *x, static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -51678,6 +54216,9 @@ static void *_p_mfem__P0TetFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, static void *_p_mfem__P0HexFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::NodalFiniteElement *) ((mfem::P0HexFiniteElement *) x)); } +static void *_p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS2DFiniteElement *) x)); +} static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__ScalarFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ScalarFiniteElement *) (mfem::NURBSFiniteElement *) ((mfem::NURBS3DFiniteElement *) x)); } @@ -51690,6 +54231,12 @@ static void *_p_mfem__NURBS2DFiniteElementTo_p_mfem__NURBSFiniteElement(void *x, static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__NURBSFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NURBSFiniteElement *) ((mfem::NURBS3DFiniteElement *) x)); } +static void *_p_mfem__ND_HexahedronElementTo_p_mfem__VectorTensorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); +} +static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorTensorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); +} static void *_p_mfem__P0WedgeFiniteElementTo_p_mfem__L2_WedgeElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::L2_WedgeElement *) ((mfem::P0WedgeFiniteElement *) x)); } @@ -51738,9 +54285,6 @@ static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__NodalTensorFiniteElement static void *_p_mfem__L2_HexahedronElementTo_p_mfem__NodalTensorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NodalTensorFiniteElement *) ((mfem::L2_HexahedronElement *) x)); } -static void *_p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::TensorBasisElement *) (mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_HexahedronElement *) x)); -} static void *_p_mfem__L2_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) (mfem::NodalTensorFiniteElement *) ((mfem::L2_HexahedronElement *) x)); } @@ -51774,14 +54318,23 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__TensorBasisElement(void static void *_p_mfem__H1_SegmentElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) (mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) ((mfem::PositiveTensorFiniteElement *) x)); } static void *_p_mfem__NodalTensorFiniteElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TensorBasisElement *) ((mfem::NodalTensorFiniteElement *) x)); } -static void *_p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_TriangleElement *) x)); +static void *_p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) (mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_HexahedronElement *) x)); +} +static void *_p_mfem__ND_HexahedronElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); +} +static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__TensorBasisElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TensorBasisElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_HexahedronElement *) x)); @@ -51789,6 +54342,9 @@ static void *_p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement(void *x static void *_p_mfem__RT_QuadrilateralElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_QuadrilateralElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__RT0TetFiniteElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT0TetFiniteElement *) x)); } @@ -51822,14 +54378,17 @@ static void *_p_mfem__RT0QuadFiniteElementTo_p_mfem__VectorFiniteElement(void *x static void *_p_mfem__RT0TriangleFiniteElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT0TriangleFiniteElement *) x)); } +static void *_p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_TriangleElement *) x)); +} static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::VectorFiniteElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::VectorFiniteElement *) (mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__VectorFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -52047,12 +54606,6 @@ static void *_p_mfem__L2_WedgeElementTo_p_mfem__NodalFiniteElement(void *x, int static void *_p_mfem__P0WedgeFiniteElementTo_p_mfem__NodalFiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NodalFiniteElement *) (mfem::L2_WedgeElement *) ((mfem::P0WedgeFiniteElement *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -52086,6 +54639,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -52101,6 +54657,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -52269,6 +54828,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -52312,10 +54877,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -52374,6 +54939,7 @@ static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_Se static swig_type_info _swigt__p_mfem__H1Pos_TetrahedronElement = {"_p_mfem__H1Pos_TetrahedronElement", "mfem::H1Pos_TetrahedronElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_TriangleElement", "mfem::H1Pos_TriangleElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", "mfem::H1Pos_WedgeElement *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", "mfem::H1Ser_QuadrilateralElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", "mfem::H1_HexahedronElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", "mfem::H1_QuadrilateralElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", "mfem::H1_SegmentElement *", 0, 0, (void*)0, 0}; @@ -52457,6 +55023,7 @@ static swig_type_info _swigt__p_mfem__TriLinear3DFiniteElement = {"_p_mfem__TriL static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__VectorCoefficient = {"_p_mfem__VectorCoefficient", "mfem::VectorCoefficient *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__VectorFiniteElement = {"_p_mfem__VectorFiniteElement", "mfem::VectorFiniteElement *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", "mfem::VectorTensorFiniteElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { @@ -52496,6 +55063,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -52579,6 +55147,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__Vector, &_swigt__p_mfem__VectorCoefficient, &_swigt__p_mfem__VectorFiniteElement, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_p_int, }; @@ -52606,7 +55175,7 @@ static swig_cast_info _swigc__p_mfem__Cubic3DFiniteElement[] = { {&_swigt__p_mf static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DofToQuad[] = { {&_swigt__p_mfem__DofToQuad, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FunctionSpace[] = { {&_swigt__p_mfem__FunctionSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussBiLinear2DFiniteElement[] = { {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussBiQuad2DFiniteElement[] = { {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -52618,6 +55187,7 @@ static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = { {&_swigt__p_mf static swig_cast_info _swigc__p_mfem__H1Pos_TetrahedronElement[] = { {&_swigt__p_mfem__H1Pos_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = { {&_swigt__p_mfem__H1Pos_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = { {&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = { {&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = { {&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = { {&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = { {&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -52695,12 +55265,13 @@ static swig_cast_info _swigc__p_mfem__RefinedLinear2DFiniteElement[] = { {&_swi static swig_cast_info _swigc__p_mfem__RefinedLinear3DFiniteElement[] = { {&_swigt__p_mfem__RefinedLinear3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RefinedTriLinear3DFiniteElement[] = { {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = { {&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ScalarFiniteElement[] = { {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TensorBasisElement[] = { {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__TensorBasisElement, 0, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScalarFiniteElement[] = { {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__ScalarFiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__ScalarFiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TensorBasisElement[] = { {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__TensorBasisElement, 0, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__TensorBasisElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__TensorBasisElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TriLinear3DFiniteElement[] = { {&_swigt__p_mfem__TriLinear3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCoefficient[] = { {&_swigt__p_mfem__VectorCoefficient, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorFiniteElement[] = { {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__VectorFiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorFiniteElement[] = { {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__VectorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__VectorFiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = { {&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__VectorTensorFiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__VectorTensorFiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_int[] = { {&_swigt__p_p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { @@ -52740,6 +55311,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -52823,6 +55395,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__Vector, _swigc__p_mfem__VectorCoefficient, _swigc__p_mfem__VectorFiniteElement, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_p_int, }; @@ -53563,6 +56136,7 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "BasisType_OpenUniform",SWIG_From_int(static_cast< int >(mfem::BasisType::OpenUniform))); SWIG_Python_SetConstant(d, "BasisType_ClosedUniform",SWIG_From_int(static_cast< int >(mfem::BasisType::ClosedUniform))); SWIG_Python_SetConstant(d, "BasisType_OpenHalfUniform",SWIG_From_int(static_cast< int >(mfem::BasisType::OpenHalfUniform))); + SWIG_Python_SetConstant(d, "BasisType_Serendipity",SWIG_From_int(static_cast< int >(mfem::BasisType::Serendipity))); SWIG_Python_SetConstant(d, "BasisType_NumBasisTypes",SWIG_From_int(static_cast< int >(mfem::BasisType::NumBasisTypes))); SWIG_Python_SetConstant(d, "DofToQuad_FULL",SWIG_From_int(static_cast< int >(mfem::DofToQuad::FULL))); SWIG_Python_SetConstant(d, "DofToQuad_TENSOR",SWIG_From_int(static_cast< int >(mfem::DofToQuad::TENSOR))); @@ -53585,6 +56159,7 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Poly_1D_NumEvalTypes",SWIG_From_int(static_cast< int >(mfem::Poly_1D::NumEvalTypes))); SWIG_Python_SetConstant(d, "TensorBasisElement_L2_DOF_MAP",SWIG_From_int(static_cast< int >(mfem::TensorBasisElement::L2_DOF_MAP))); SWIG_Python_SetConstant(d, "TensorBasisElement_H1_DOF_MAP",SWIG_From_int(static_cast< int >(mfem::TensorBasisElement::H1_DOF_MAP))); + SWIG_Python_SetConstant(d, "TensorBasisElement_Sr_DOF_MAP",SWIG_From_int(static_cast< int >(mfem::TensorBasisElement::Sr_DOF_MAP))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_ser/fespace.i b/mfem/_ser/fespace.i index a72c189d..79cca15e 100644 --- a/mfem/_ser/fespace.i +++ b/mfem/_ser/fespace.i @@ -17,6 +17,7 @@ #include "fem/eltrans.hpp" #include "fem/coefficient.hpp" #include "fem/intrules.hpp" +#include "fem/restriction.hpp" #include "pyoperator.hpp" %} @@ -38,6 +39,7 @@ import_array(); %import "eltrans.i" %import "lininteg.i" %import "handle.i" +%import "restriction.i" %import "../common/exception.i" %import "../common/io_stream_typemap.i" diff --git a/mfem/_ser/fespace.py b/mfem/_ser/fespace.py index 1d73d61e..d42bb59b 100644 --- a/mfem/_ser/fespace.py +++ b/mfem/_ser/fespace.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _fespace.SWIG_PyInstanceMethod_New +_swig_new_static_method = _fespace.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -86,7 +89,9 @@ class _SwigNonDynamicMeta(type): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.handle +import mfem._ser.restriction class Ordering(object): r"""Proxy of C++ mfem::Ordering class.""" @@ -142,6 +147,7 @@ def __init__(self, *args): def GetMesh(self): r"""GetMesh(FiniteElementSpace self) -> Mesh""" return _fespace.FiniteElementSpace_GetMesh(self) + GetMesh = _swig_new_instance_method(_fespace.FiniteElementSpace_GetMesh) def GetNURBSext(self, *args): r""" @@ -149,125 +155,170 @@ def GetNURBSext(self, *args): GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension * """ return _fespace.FiniteElementSpace_GetNURBSext(self, *args) + GetNURBSext = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNURBSext) def StealNURBSext(self): r"""StealNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *""" return _fespace.FiniteElementSpace_StealNURBSext(self) + StealNURBSext = _swig_new_instance_method(_fespace.FiniteElementSpace_StealNURBSext) def Conforming(self): r"""Conforming(FiniteElementSpace self) -> bool""" return _fespace.FiniteElementSpace_Conforming(self) + Conforming = _swig_new_instance_method(_fespace.FiniteElementSpace_Conforming) def Nonconforming(self): r"""Nonconforming(FiniteElementSpace self) -> bool""" return _fespace.FiniteElementSpace_Nonconforming(self) + Nonconforming = _swig_new_instance_method(_fespace.FiniteElementSpace_Nonconforming) def GetConformingProlongation(self): r"""GetConformingProlongation(FiniteElementSpace self) -> SparseMatrix""" return _fespace.FiniteElementSpace_GetConformingProlongation(self) + GetConformingProlongation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingProlongation) def GetConformingRestriction(self): r"""GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix""" return _fespace.FiniteElementSpace_GetConformingRestriction(self) + GetConformingRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingRestriction) def GetProlongationMatrix(self): r"""GetProlongationMatrix(FiniteElementSpace self) -> Operator""" return _fespace.FiniteElementSpace_GetProlongationMatrix(self) + GetProlongationMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_GetProlongationMatrix) def GetRestrictionMatrix(self): r"""GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix""" return _fespace.FiniteElementSpace_GetRestrictionMatrix(self) + GetRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_GetRestrictionMatrix) def GetElementRestriction(self, e_ordering): r"""GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator""" return _fespace.FiniteElementSpace_GetElementRestriction(self, e_ordering) + GetElementRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementRestriction) + + def GetFaceRestriction(self, *args): + r"""GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator""" + return _fespace.FiniteElementSpace_GetFaceRestriction(self, *args) + GetFaceRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceRestriction) def GetQuadratureInterpolator(self, *args): r""" - GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> QuadratureInterpolator - GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> QuadratureInterpolator + GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const + GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const * """ return _fespace.FiniteElementSpace_GetQuadratureInterpolator(self, *args) + GetQuadratureInterpolator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetQuadratureInterpolator) + + def GetFaceQuadratureInterpolator(self, ir, type): + r"""GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *""" + return _fespace.FiniteElementSpace_GetFaceQuadratureInterpolator(self, ir, type) + GetFaceQuadratureInterpolator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceQuadratureInterpolator) def GetVDim(self): r"""GetVDim(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetVDim(self) + GetVDim = _swig_new_instance_method(_fespace.FiniteElementSpace_GetVDim) def GetOrder(self, i): r"""GetOrder(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetOrder(self, i) + GetOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetOrder) def GetFaceOrder(self, i): r"""GetFaceOrder(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetFaceOrder(self, i) + GetFaceOrder = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceOrder) def GetNDofs(self): r"""GetNDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNDofs(self) + GetNDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNDofs) def GetVSize(self): r"""GetVSize(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetVSize(self) + GetVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetVSize) def GetTrueVSize(self): r"""GetTrueVSize(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetTrueVSize(self) + GetTrueVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTrueVSize) def GetNConformingDofs(self): r"""GetNConformingDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNConformingDofs(self) + GetNConformingDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNConformingDofs) def GetConformingVSize(self): r"""GetConformingVSize(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetConformingVSize(self) + GetConformingVSize = _swig_new_instance_method(_fespace.FiniteElementSpace_GetConformingVSize) def GetOrdering(self): r"""GetOrdering(FiniteElementSpace self) -> mfem::Ordering::Type""" return _fespace.FiniteElementSpace_GetOrdering(self) + GetOrdering = _swig_new_instance_method(_fespace.FiniteElementSpace_GetOrdering) def FEColl(self): r"""FEColl(FiniteElementSpace self) -> FiniteElementCollection""" return _fespace.FiniteElementSpace_FEColl(self) + FEColl = _swig_new_instance_method(_fespace.FiniteElementSpace_FEColl) def GetNVDofs(self): r"""GetNVDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNVDofs(self) + GetNVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNVDofs) def GetNEDofs(self): r"""GetNEDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNEDofs(self) + GetNEDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNEDofs) def GetNFDofs(self): r"""GetNFDofs(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNFDofs(self) + GetNFDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNFDofs) def GetNV(self): r"""GetNV(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNV(self) + GetNV = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNV) def GetNE(self): r"""GetNE(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNE(self) + GetNE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNE) def GetNF(self): r"""GetNF(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNF(self) + GetNF = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNF) def GetNBE(self): r"""GetNBE(FiniteElementSpace self) -> int""" return _fespace.FiniteElementSpace_GetNBE(self) + GetNBE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNBE) + + def GetNFbyType(self, type): + r"""GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int""" + return _fespace.FiniteElementSpace_GetNFbyType(self, type) + GetNFbyType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNFbyType) def GetElementType(self, i): r"""GetElementType(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetElementType(self, i) + GetElementType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementType) def GetElementVertices(self, i, vertices): r"""GetElementVertices(FiniteElementSpace self, int i, intArray vertices)""" return _fespace.FiniteElementSpace_GetElementVertices(self, i, vertices) + GetElementVertices = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementVertices) def GetBdrElementType(self, i): r"""GetBdrElementType(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetBdrElementType(self, i) + GetBdrElementType = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementType) def GetElementTransformation(self, *args): r""" @@ -275,18 +326,22 @@ def GetElementTransformation(self, *args): GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr) """ return _fespace.FiniteElementSpace_GetElementTransformation(self, *args) + GetElementTransformation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementTransformation) def GetBdrElementTransformation(self, i): r"""GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation""" return _fespace.FiniteElementSpace_GetBdrElementTransformation(self, i) + GetBdrElementTransformation = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementTransformation) def GetAttribute(self, i): r"""GetAttribute(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetAttribute(self, i) + GetAttribute = _swig_new_instance_method(_fespace.FiniteElementSpace_GetAttribute) def GetBdrAttribute(self, i): r"""GetBdrAttribute(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetBdrAttribute(self, i) + GetBdrAttribute = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrAttribute) def GetElementDofs(self, i): from .array import intArray @@ -339,10 +394,12 @@ def GetElementInteriorDofs(self, i): def GetFaceInteriorDofs(self, i, dofs): r"""GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)""" return _fespace.FiniteElementSpace_GetFaceInteriorDofs(self, i, dofs) + GetFaceInteriorDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceInteriorDofs) def GetNumElementInteriorDofs(self, i): r"""GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetNumElementInteriorDofs(self, i) + GetNumElementInteriorDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetNumElementInteriorDofs) def GetEdgeInteriorDofs(self, i): from .array import intArray @@ -358,19 +415,23 @@ def DofsToVDofs(self, *args): DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1) """ return _fespace.FiniteElementSpace_DofsToVDofs(self, *args) + DofsToVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_DofsToVDofs) def DofToVDof(self, dof, vd, ndofs=-1): r"""DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int""" return _fespace.FiniteElementSpace_DofToVDof(self, dof, vd, ndofs) + DofToVDof = _swig_new_instance_method(_fespace.FiniteElementSpace_DofToVDof) def VDofToDof(self, vdof): r"""VDofToDof(FiniteElementSpace self, int vdof) -> int""" return _fespace.FiniteElementSpace_VDofToDof(self, vdof) + VDofToDof = _swig_new_instance_method(_fespace.FiniteElementSpace_VDofToDof) @staticmethod def AdjustVDofs(vdofs): r"""AdjustVDofs(intArray vdofs)""" return _fespace.FiniteElementSpace_AdjustVDofs(vdofs) + AdjustVDofs = _swig_new_static_method(_fespace.FiniteElementSpace_AdjustVDofs) def GetElementVDofs(self, i): from .array import intArray @@ -431,100 +492,124 @@ def GetEdgeInteriorVDofs(self, i): def RebuildElementToDofTable(self): r"""RebuildElementToDofTable(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_RebuildElementToDofTable(self) + RebuildElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_RebuildElementToDofTable) def ReorderElementToDofTable(self): r"""ReorderElementToDofTable(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_ReorderElementToDofTable(self) + ReorderElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_ReorderElementToDofTable) def BuildDofToArrays(self): r"""BuildDofToArrays(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_BuildDofToArrays(self) + BuildDofToArrays = _swig_new_instance_method(_fespace.FiniteElementSpace_BuildDofToArrays) def GetElementToDofTable(self): r"""GetElementToDofTable(FiniteElementSpace self) -> Table""" return _fespace.FiniteElementSpace_GetElementToDofTable(self) + GetElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementToDofTable) def GetBdrElementToDofTable(self): r"""GetBdrElementToDofTable(FiniteElementSpace self) -> Table""" return _fespace.FiniteElementSpace_GetBdrElementToDofTable(self) + GetBdrElementToDofTable = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBdrElementToDofTable) def GetElementForDof(self, i): r"""GetElementForDof(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetElementForDof(self, i) + GetElementForDof = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementForDof) def GetLocalDofForDof(self, i): r"""GetLocalDofForDof(FiniteElementSpace self, int i) -> int""" return _fespace.FiniteElementSpace_GetLocalDofForDof(self, i) + GetLocalDofForDof = _swig_new_instance_method(_fespace.FiniteElementSpace_GetLocalDofForDof) def GetFE(self, i): r"""GetFE(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetFE(self, i) + GetFE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFE) def GetBE(self, i): r"""GetBE(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetBE(self, i) + GetBE = _swig_new_instance_method(_fespace.FiniteElementSpace_GetBE) def GetFaceElement(self, i): r"""GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetFaceElement(self, i) + GetFaceElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceElement) def GetEdgeElement(self, i): r"""GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement""" return _fespace.FiniteElementSpace_GetEdgeElement(self, i) + GetEdgeElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEdgeElement) def GetTraceElement(self, i, geom_type): r"""GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement""" return _fespace.FiniteElementSpace_GetTraceElement(self, i, geom_type) + GetTraceElement = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTraceElement) def GetEssentialVDofs(self, bdr_attr_is_ess, ess_vdofs, component=-1): r"""GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)""" return _fespace.FiniteElementSpace_GetEssentialVDofs(self, bdr_attr_is_ess, ess_vdofs, component) + GetEssentialVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEssentialVDofs) def GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component=-1): r"""GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)""" return _fespace.FiniteElementSpace_GetEssentialTrueDofs(self, bdr_attr_is_ess, ess_tdof_list, component) + GetEssentialTrueDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_GetEssentialTrueDofs) @staticmethod def MarkerToList(marker, list): r"""MarkerToList(intArray marker, intArray list)""" return _fespace.FiniteElementSpace_MarkerToList(marker, list) + MarkerToList = _swig_new_static_method(_fespace.FiniteElementSpace_MarkerToList) @staticmethod def ListToMarker(list, marker_size, marker, mark_val=-1): r"""ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)""" return _fespace.FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val) + ListToMarker = _swig_new_static_method(_fespace.FiniteElementSpace_ListToMarker) def ConvertToConformingVDofs(self, dofs, cdofs): r"""ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)""" return _fespace.FiniteElementSpace_ConvertToConformingVDofs(self, dofs, cdofs) + ConvertToConformingVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_ConvertToConformingVDofs) def ConvertFromConformingVDofs(self, cdofs, dofs): r"""ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)""" return _fespace.FiniteElementSpace_ConvertFromConformingVDofs(self, cdofs, dofs) + ConvertFromConformingVDofs = _swig_new_instance_method(_fespace.FiniteElementSpace_ConvertFromConformingVDofs) def D2C_GlobalRestrictionMatrix(self, cfes): r"""D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix""" return _fespace.FiniteElementSpace_D2C_GlobalRestrictionMatrix(self, cfes) + D2C_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_D2C_GlobalRestrictionMatrix) def D2Const_GlobalRestrictionMatrix(self, cfes): r"""D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix""" return _fespace.FiniteElementSpace_D2Const_GlobalRestrictionMatrix(self, cfes) + D2Const_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_D2Const_GlobalRestrictionMatrix) def H2L_GlobalRestrictionMatrix(self, lfes): r"""H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix""" return _fespace.FiniteElementSpace_H2L_GlobalRestrictionMatrix(self, lfes) + H2L_GlobalRestrictionMatrix = _swig_new_instance_method(_fespace.FiniteElementSpace_H2L_GlobalRestrictionMatrix) def GetTransferOperator(self, coarse_fes, T): r"""GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)""" return _fespace.FiniteElementSpace_GetTransferOperator(self, coarse_fes, T) + GetTransferOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTransferOperator) def GetTrueTransferOperator(self, coarse_fes, T): r"""GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)""" return _fespace.FiniteElementSpace_GetTrueTransferOperator(self, coarse_fes, T) + GetTrueTransferOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetTrueTransferOperator) def Update(self, want_transform=True): r"""Update(FiniteElementSpace self, bool want_transform=True)""" return _fespace.FiniteElementSpace_Update(self, want_transform) + Update = _swig_new_instance_method(_fespace.FiniteElementSpace_Update) def GetUpdateOperator(self, *args): r""" @@ -532,26 +617,32 @@ def GetUpdateOperator(self, *args): GetUpdateOperator(FiniteElementSpace self, OperatorHandle T) """ return _fespace.FiniteElementSpace_GetUpdateOperator(self, *args) + GetUpdateOperator = _swig_new_instance_method(_fespace.FiniteElementSpace_GetUpdateOperator) def SetUpdateOperatorOwner(self, own): r"""SetUpdateOperatorOwner(FiniteElementSpace self, bool own)""" return _fespace.FiniteElementSpace_SetUpdateOperatorOwner(self, own) + SetUpdateOperatorOwner = _swig_new_instance_method(_fespace.FiniteElementSpace_SetUpdateOperatorOwner) def SetUpdateOperatorType(self, tid): r"""SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)""" return _fespace.FiniteElementSpace_SetUpdateOperatorType(self, tid) + SetUpdateOperatorType = _swig_new_instance_method(_fespace.FiniteElementSpace_SetUpdateOperatorType) def UpdatesFinished(self): r"""UpdatesFinished(FiniteElementSpace self)""" return _fespace.FiniteElementSpace_UpdatesFinished(self) + UpdatesFinished = _swig_new_instance_method(_fespace.FiniteElementSpace_UpdatesFinished) def GetSequence(self): r"""GetSequence(FiniteElementSpace self) -> long""" return _fespace.FiniteElementSpace_GetSequence(self) + GetSequence = _swig_new_instance_method(_fespace.FiniteElementSpace_GetSequence) def Load(self, m, input): r"""Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection""" return _fespace.FiniteElementSpace_Load(self, m, input) + Load = _swig_new_instance_method(_fespace.FiniteElementSpace_Load) __swig_destroy__ = _fespace.delete_FiniteElementSpace def Save(self, *args): @@ -561,6 +652,7 @@ def Save(self, *args): Save(FiniteElementSpace self) """ return _fespace.FiniteElementSpace_Save(self, *args) + Save = _swig_new_instance_method(_fespace.FiniteElementSpace_Save) # Register FiniteElementSpace in _fespace: _fespace.FiniteElementSpace_swigregister(FiniteElementSpace) @@ -568,14 +660,17 @@ def Save(self, *args): def FiniteElementSpace_AdjustVDofs(vdofs): r"""FiniteElementSpace_AdjustVDofs(intArray vdofs)""" return _fespace.FiniteElementSpace_AdjustVDofs(vdofs) +FiniteElementSpace_AdjustVDofs = _fespace.FiniteElementSpace_AdjustVDofs def FiniteElementSpace_MarkerToList(marker, list): r"""FiniteElementSpace_MarkerToList(intArray marker, intArray list)""" return _fespace.FiniteElementSpace_MarkerToList(marker, list) +FiniteElementSpace_MarkerToList = _fespace.FiniteElementSpace_MarkerToList def FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val=-1): r"""FiniteElementSpace_ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)""" return _fespace.FiniteElementSpace_ListToMarker(list, marker_size, marker, mark_val) +FiniteElementSpace_ListToMarker = _fespace.FiniteElementSpace_ListToMarker class QuadratureSpace(object): r"""Proxy of C++ mfem::QuadratureSpace class.""" @@ -594,10 +689,12 @@ def __init__(self, *args): def GetSize(self): r"""GetSize(QuadratureSpace self) -> int""" return _fespace.QuadratureSpace_GetSize(self) + GetSize = _swig_new_instance_method(_fespace.QuadratureSpace_GetSize) def GetElementIntRule(self, idx): r"""GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule""" return _fespace.QuadratureSpace_GetElementIntRule(self, idx) + GetElementIntRule = _swig_new_instance_method(_fespace.QuadratureSpace_GetElementIntRule) def Save(self, *args): r""" @@ -606,6 +703,7 @@ def Save(self, *args): Save(QuadratureSpace self) """ return _fespace.QuadratureSpace_Save(self, *args) + Save = _swig_new_instance_method(_fespace.QuadratureSpace_Save) # Register QuadratureSpace in _fespace: _fespace.QuadratureSpace_swigregister(QuadratureSpace) @@ -623,22 +721,27 @@ def __init__(self, *args, **kwargs): def SetOperatorType(self, type): r"""SetOperatorType(GridTransfer self, mfem::Operator::Type type)""" return _fespace.GridTransfer_SetOperatorType(self, type) + SetOperatorType = _swig_new_instance_method(_fespace.GridTransfer_SetOperatorType) def ForwardOperator(self): r"""ForwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_ForwardOperator(self) + ForwardOperator = _swig_new_instance_method(_fespace.GridTransfer_ForwardOperator) def BackwardOperator(self): r"""BackwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_BackwardOperator(self) + BackwardOperator = _swig_new_instance_method(_fespace.GridTransfer_BackwardOperator) def TrueForwardOperator(self): r"""TrueForwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_TrueForwardOperator(self) + TrueForwardOperator = _swig_new_instance_method(_fespace.GridTransfer_TrueForwardOperator) def TrueBackwardOperator(self): r"""TrueBackwardOperator(GridTransfer self) -> Operator""" return _fespace.GridTransfer_TrueBackwardOperator(self) + TrueBackwardOperator = _swig_new_instance_method(_fespace.GridTransfer_TrueBackwardOperator) # Register GridTransfer in _fespace: _fespace.GridTransfer_swigregister(GridTransfer) @@ -657,14 +760,17 @@ def __init__(self, coarse_fes, fine_fes): def SetMassIntegrator(self, mass_integ_, own_mass_integ_=True): r"""SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)""" return _fespace.InterpolationGridTransfer_SetMassIntegrator(self, mass_integ_, own_mass_integ_) + SetMassIntegrator = _swig_new_instance_method(_fespace.InterpolationGridTransfer_SetMassIntegrator) def ForwardOperator(self): r"""ForwardOperator(InterpolationGridTransfer self) -> Operator""" return _fespace.InterpolationGridTransfer_ForwardOperator(self) + ForwardOperator = _swig_new_instance_method(_fespace.InterpolationGridTransfer_ForwardOperator) def BackwardOperator(self): r"""BackwardOperator(InterpolationGridTransfer self) -> Operator""" return _fespace.InterpolationGridTransfer_BackwardOperator(self) + BackwardOperator = _swig_new_instance_method(_fespace.InterpolationGridTransfer_BackwardOperator) # Register InterpolationGridTransfer in _fespace: _fespace.InterpolationGridTransfer_swigregister(InterpolationGridTransfer) @@ -682,71 +788,21 @@ def __init__(self, coarse_fes, fine_fes): def ForwardOperator(self): r"""ForwardOperator(L2ProjectionGridTransfer self) -> Operator""" return _fespace.L2ProjectionGridTransfer_ForwardOperator(self) + ForwardOperator = _swig_new_instance_method(_fespace.L2ProjectionGridTransfer_ForwardOperator) def BackwardOperator(self): r"""BackwardOperator(L2ProjectionGridTransfer self) -> Operator""" return _fespace.L2ProjectionGridTransfer_BackwardOperator(self) + BackwardOperator = _swig_new_instance_method(_fespace.L2ProjectionGridTransfer_BackwardOperator) __swig_destroy__ = _fespace.delete_L2ProjectionGridTransfer # Register L2ProjectionGridTransfer in _fespace: _fespace.L2ProjectionGridTransfer_swigregister(L2ProjectionGridTransfer) -class ElementRestriction(mfem._ser.operators.Operator): - r"""Proxy of C++ mfem::ElementRestriction class.""" - - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") - __repr__ = _swig_repr - - def __init__(self, arg2, arg3): - r"""__init__(ElementRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering arg3) -> ElementRestriction""" - _fespace.ElementRestriction_swiginit(self, _fespace.new_ElementRestriction(arg2, arg3)) - - def Mult(self, x, y): - r"""Mult(ElementRestriction self, Vector x, Vector y)""" - return _fespace.ElementRestriction_Mult(self, x, y) - - def MultTranspose(self, x, y): - r"""MultTranspose(ElementRestriction self, Vector x, Vector y)""" - return _fespace.ElementRestriction_MultTranspose(self, x, y) - __swig_destroy__ = _fespace.delete_ElementRestriction - -# Register ElementRestriction in _fespace: -_fespace.ElementRestriction_swigregister(ElementRestriction) - -class QuadratureInterpolator(object): - r"""Proxy of C++ mfem::QuadratureInterpolator class.""" - - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") - __repr__ = _swig_repr - VALUES = _fespace.QuadratureInterpolator_VALUES - - DERIVATIVES = _fespace.QuadratureInterpolator_DERIVATIVES - - DETERMINANTS = _fespace.QuadratureInterpolator_DETERMINANTS - - - def __init__(self, *args): - r""" - __init__(QuadratureInterpolator self, FiniteElementSpace fes, IntegrationRule ir) -> QuadratureInterpolator - __init__(QuadratureInterpolator self, FiniteElementSpace fes, QuadratureSpace qs) -> QuadratureInterpolator - """ - _fespace.QuadratureInterpolator_swiginit(self, _fespace.new_QuadratureInterpolator(*args)) - - def DisableTensorProducts(self, disable=True): - r"""DisableTensorProducts(QuadratureInterpolator self, bool disable=True)""" - return _fespace.QuadratureInterpolator_DisableTensorProducts(self, disable) - - def Mult(self, e_vec, eval_flags, q_val, q_der, q_det): - r"""Mult(QuadratureInterpolator self, Vector e_vec, unsigned int eval_flags, Vector q_val, Vector q_der, Vector q_det)""" - return _fespace.QuadratureInterpolator_Mult(self, e_vec, eval_flags, q_val, q_der, q_det) - - def MultTranspose(self, eval_flags, q_val, q_der, e_vec): - r"""MultTranspose(QuadratureInterpolator self, unsigned int eval_flags, Vector q_val, Vector q_der, Vector e_vec)""" - return _fespace.QuadratureInterpolator_MultTranspose(self, eval_flags, q_val, q_der, e_vec) - __swig_destroy__ = _fespace.delete_QuadratureInterpolator - -# Register QuadratureInterpolator in _fespace: -_fespace.QuadratureInterpolator_swigregister(QuadratureInterpolator) +def UsesTensorBasis(fes): + r"""UsesTensorBasis(FiniteElementSpace fes) -> bool""" + return _fespace.UsesTensorBasis(fes) +UsesTensorBasis = _fespace.UsesTensorBasis diff --git a/mfem/_ser/fespace_wrap.cxx b/mfem/_ser/fespace_wrap.cxx index 4a583b9c..aeeb4d10 100644 --- a/mfem/_ser/fespace_wrap.cxx +++ b/mfem/_ser/fespace_wrap.cxx @@ -3066,268 +3066,277 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[7] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[8] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[12] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[13] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[16] -#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[17] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[18] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[20] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[22] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[23] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[24] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[25] -#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[26] -#define SWIGTYPE_p_mfem__CubicFECollection swig_types[27] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[29] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[31] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[32] -#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[33] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[34] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[35] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[36] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[38] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[39] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[40] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[41] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[42] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[43] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[44] -#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[45] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[46] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[47] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[48] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[49] -#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[50] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[51] -#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[52] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[53] -#define SWIGTYPE_p_mfem__GridFunction swig_types[54] -#define SWIGTYPE_p_mfem__GridTransfer swig_types[55] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[57] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[59] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[60] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[62] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[63] -#define SWIGTYPE_p_mfem__H1_FECollection swig_types[64] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[65] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[66] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[67] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[68] -#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[69] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[70] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[71] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[72] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[73] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[74] -#define SWIGTYPE_p_mfem__InterpolationGridTransfer swig_types[75] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[76] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[77] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[78] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[79] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[80] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[81] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[82] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[83] -#define SWIGTYPE_p_mfem__L2ProjectionGridTransfer swig_types[84] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[85] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[86] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[87] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[88] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[89] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[90] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[91] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[97] -#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[98] -#define SWIGTYPE_p_mfem__LinearFECollection swig_types[99] -#define SWIGTYPE_p_mfem__LinearForm swig_types[100] -#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[101] -#define SWIGTYPE_p_mfem__Local_FECollection swig_types[102] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[103] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[104] -#define SWIGTYPE_p_mfem__Matrix swig_types[105] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[106] -#define SWIGTYPE_p_mfem__Mesh swig_types[107] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[108] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[109] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[110] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[111] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[112] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[113] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[114] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[115] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[116] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[117] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[118] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[119] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[120] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[121] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[122] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[123] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[124] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[125] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[126] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[127] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[128] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[129] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[130] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[131] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[132] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[133] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[134] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[135] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[136] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[137] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[138] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[139] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[140] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[141] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[142] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[143] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[144] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[145] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[146] -#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[147] -#define SWIGTYPE_p_mfem__ND_FECollection swig_types[148] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[149] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[150] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[151] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[152] -#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[153] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[154] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[155] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[156] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[157] -#define SWIGTYPE_p_mfem__NURBSExtension swig_types[158] -#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[159] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[160] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[161] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[162] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[163] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[164] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[165] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[166] -#define SWIGTYPE_p_mfem__Operator swig_types[167] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[168] -#define SWIGTYPE_p_mfem__Ordering swig_types[169] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[170] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[171] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[172] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[173] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[174] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[175] -#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[176] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[177] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[178] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[179] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[180] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[181] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[182] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[183] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[184] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[185] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[186] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[187] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[188] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[189] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[190] -#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[191] -#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[192] -#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[193] -#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[194] -#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[195] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[196] -#define SWIGTYPE_p_mfem__QuadratureInterpolator swig_types[197] -#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[198] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[199] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[200] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[201] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[202] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[203] -#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[204] -#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[205] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[206] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[207] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[208] -#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[209] -#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[210] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[211] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[212] -#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[213] -#define SWIGTYPE_p_mfem__RT_FECollection swig_types[214] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[215] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[216] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[217] -#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[218] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[219] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[220] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[221] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[222] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[223] -#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[224] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[225] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[226] -#define SWIGTYPE_p_mfem__STable swig_types[227] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[228] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[229] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[230] -#define SWIGTYPE_p_mfem__Solver swig_types[231] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[232] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[233] -#define SWIGTYPE_p_mfem__Table swig_types[234] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[235] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[236] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[237] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[238] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[239] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[240] -#define SWIGTYPE_p_mfem__Vector swig_types[241] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[242] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[243] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[244] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[245] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[246] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[247] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[248] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[249] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[250] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[251] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[252] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[253] -#define SWIGTYPE_p_pri_t swig_types[254] -#define SWIGTYPE_p_quad_t swig_types[255] -#define SWIGTYPE_p_seg_t swig_types[256] -#define SWIGTYPE_p_std__istream swig_types[257] -#define SWIGTYPE_p_tet_t swig_types[258] -#define SWIGTYPE_p_tri_t swig_types[259] -#define SWIGTYPE_p_void swig_types[260] -static swig_type_info *swig_types[262]; -static swig_module_info swig_module = {swig_types, 261, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[8] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[9] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[13] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[14] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[17] +#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[18] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[19] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[21] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[24] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[25] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[26] +#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[27] +#define SWIGTYPE_p_mfem__CubicFECollection swig_types[28] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[29] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[30] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[34] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[35] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[36] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[37] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[39] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[40] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[41] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[42] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[43] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[44] +#define SWIGTYPE_p_mfem__FaceQuadratureInterpolator swig_types[45] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[46] +#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[47] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[48] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[49] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[50] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[51] +#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[52] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[53] +#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[54] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[56] +#define SWIGTYPE_p_mfem__GridFunction swig_types[57] +#define SWIGTYPE_p_mfem__GridTransfer swig_types[58] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[60] +#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[61] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[63] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[64] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[65] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[66] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[67] +#define SWIGTYPE_p_mfem__H1Ser_FECollection swig_types[68] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[69] +#define SWIGTYPE_p_mfem__H1_FECollection swig_types[70] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[71] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[72] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[73] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[74] +#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[75] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[76] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[77] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[78] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[79] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[80] +#define SWIGTYPE_p_mfem__InterpolationGridTransfer swig_types[81] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[83] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[84] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[85] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[86] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[87] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[88] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[89] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[90] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[91] +#define SWIGTYPE_p_mfem__L2ProjectionGridTransfer swig_types[92] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[93] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[94] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[95] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[96] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[97] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[98] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[99] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[105] +#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[106] +#define SWIGTYPE_p_mfem__LinearFECollection swig_types[107] +#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[108] +#define SWIGTYPE_p_mfem__Local_FECollection swig_types[109] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[110] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[111] +#define SWIGTYPE_p_mfem__Matrix swig_types[112] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[113] +#define SWIGTYPE_p_mfem__Mesh swig_types[114] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[115] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[116] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[117] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[118] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[119] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[120] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[121] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[122] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[123] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[124] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[125] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[126] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[127] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[128] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[129] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[130] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[131] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[132] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[133] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[134] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[135] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[136] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[137] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[138] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[139] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[140] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[141] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[142] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[143] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[144] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[145] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[146] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[147] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[148] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[149] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[150] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[151] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[152] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[153] +#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[154] +#define SWIGTYPE_p_mfem__ND_FECollection swig_types[155] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[156] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[157] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[158] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[159] +#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[160] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[161] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[162] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[163] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[164] +#define SWIGTYPE_p_mfem__NURBSExtension swig_types[165] +#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[166] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[167] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[168] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[169] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[170] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[171] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[172] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[173] +#define SWIGTYPE_p_mfem__Operator swig_types[174] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[175] +#define SWIGTYPE_p_mfem__Ordering swig_types[176] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[177] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[178] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[179] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[180] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[181] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[182] +#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[183] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[184] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[185] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[186] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[187] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[188] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[189] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[190] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[191] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[192] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[193] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[194] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[195] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[196] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[197] +#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[198] +#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[199] +#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[200] +#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[201] +#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[202] +#define SWIGTYPE_p_mfem__QuadratureInterpolator swig_types[203] +#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[204] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[205] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[206] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[207] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[208] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[209] +#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[210] +#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[211] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[212] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[213] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[214] +#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[215] +#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[216] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[217] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[218] +#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[219] +#define SWIGTYPE_p_mfem__RT_FECollection swig_types[220] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[221] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[222] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[223] +#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[224] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[225] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[226] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[227] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[228] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[229] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[230] +#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[231] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[232] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[233] +#define SWIGTYPE_p_mfem__STable swig_types[234] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[235] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[236] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[237] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[238] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[239] +#define SWIGTYPE_p_mfem__Solver swig_types[240] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[241] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[242] +#define SWIGTYPE_p_mfem__Table swig_types[243] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[244] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[245] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[246] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[247] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[248] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[249] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[250] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[251] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[252] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[253] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[254] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[255] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[256] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[257] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[258] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[259] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[260] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[261] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[262] +#define SWIGTYPE_p_pri_t swig_types[263] +#define SWIGTYPE_p_quad_t swig_types[264] +#define SWIGTYPE_p_seg_t swig_types[265] +#define SWIGTYPE_p_std__istream swig_types[266] +#define SWIGTYPE_p_tet_t swig_types[267] +#define SWIGTYPE_p_tri_t swig_types[268] +#define SWIGTYPE_p_void swig_types[269] +static swig_type_info *swig_types[271]; +static swig_module_info swig_module = {swig_types, 270, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3447,6 +3456,7 @@ namespace swig { #include "fem/eltrans.hpp" #include "fem/coefficient.hpp" #include "fem/intrules.hpp" +#include "fem/restriction.hpp" #include "pyoperator.hpp" @@ -3783,70 +3793,6 @@ SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_3(mfem::QuadratureSpace *self){ self -> Save(std::cout); } -SWIGINTERN int -SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) -{ -#if PY_VERSION_HEX < 0x03000000 - if (PyInt_Check(obj)) { - long v = PyInt_AsLong(obj); - if (v >= 0) { - if (val) *val = v; - return SWIG_OK; - } else { - return SWIG_OverflowError; - } - } else -#endif - if (PyLong_Check(obj)) { - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_OK; - } else { - PyErr_Clear(); - return SWIG_OverflowError; - } - } -#ifdef SWIG_PYTHON_CAST_MODE - { - int dispatch = 0; - unsigned long v = PyLong_AsUnsignedLong(obj); - if (!PyErr_Occurred()) { - if (val) *val = v; - return SWIG_AddCast(SWIG_OK); - } else { - PyErr_Clear(); - } - if (!dispatch) { - double d; - int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); - if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) { - if (val) *val = (unsigned long)(d); - return res; - } - } - } -#endif - return SWIG_TypeError; -} - - -SWIGINTERN int -SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) -{ - unsigned long v; - int res = SWIG_AsVal_unsigned_SS_long (obj, &v); - if (SWIG_IsOK(res)) { - if ((v > UINT_MAX)) { - return SWIG_OverflowError; - } else { - if (val) *val = static_cast< unsigned int >(v); - } - } - return res; -} - - /* --------------------------------------------------- * C++ director class methods @@ -5185,6 +5131,190 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SW } +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + mfem::L2FaceValues arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); + { + try { + result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceRestriction", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetFaceRestriction'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues) const\n" + " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType) const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -5329,6 +5459,65 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator(PyObject } +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::FaceQuadratureInterpolator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceQuadratureInterpolator", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::FaceQuadratureInterpolator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceQuadratureInterpolator((mfem::IntegrationRule const &)*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceQuadratureInterpolator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -6038,16 +6227,64 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNBE(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; + mfem::FaceType arg2 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; PyObject *swig_obj[2] ; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementType", 2, 2, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); + { + try { + result = (int)((mfem::FiniteElementSpace const *)arg1)->GetNFbyType(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementType", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); @@ -11755,260 +11992,27 @@ SWIGINTERN PyObject *L2ProjectionGridTransfer_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_UsesTensorBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; - mfem::ElementDofOrdering arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::ElementRestriction *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_ElementRestriction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - { - try { - result = (mfem::ElementRestriction *)new mfem::ElementRestriction((mfem::FiniteElementSpace const &)*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); - } - arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::ElementRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); - } - arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::ElementRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + bool result; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElementRestriction" "', argument " "1"" of type '" "mfem::ElementRestriction *""'"); - } - arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ElementRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElementRestriction, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_QuadratureInterpolator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::IntegrationRule *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::QuadratureInterpolator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsesTensorBasis" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "UsesTensorBasis" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { try { - result = (mfem::QuadratureInterpolator *)new mfem::QuadratureInterpolator((mfem::FiniteElementSpace const &)*arg1,(mfem::IntegrationRule const &)*arg2); + result = (bool)mfem::UsesTensorBasis((mfem::FiniteElementSpace const &)*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12025,458 +12029,16 @@ SWIGINTERN PyObject *_wrap_new_QuadratureInterpolator__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_QuadratureInterpolator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::QuadratureSpace *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::QuadratureInterpolator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::QuadratureSpace const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_QuadratureInterpolator" "', argument " "2"" of type '" "mfem::QuadratureSpace const &""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); - { - try { - result = (mfem::QuadratureInterpolator *)new mfem::QuadratureInterpolator((mfem::FiniteElementSpace const &)*arg1,(mfem::QuadratureSpace const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_QuadratureInterpolator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuadratureInterpolator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureInterpolator__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureInterpolator__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuadratureInterpolator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureInterpolator::QuadratureInterpolator(mfem::FiniteElementSpace const &,mfem::IntegrationRule const &)\n" - " mfem::QuadratureInterpolator::QuadratureInterpolator(mfem::FiniteElementSpace const &,mfem::QuadratureSpace const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_DisableTensorProducts" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureInterpolator_DisableTensorProducts" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - ((mfem::QuadratureInterpolator const *)arg1)->DisableTensorProducts(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_DisableTensorProducts" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - { - try { - ((mfem::QuadratureInterpolator const *)arg1)->DisableTensorProducts(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_DisableTensorProducts(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureInterpolator_DisableTensorProducts", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureInterpolator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureInterpolator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_QuadratureInterpolator_DisableTensorProducts__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureInterpolator_DisableTensorProducts'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureInterpolator::DisableTensorProducts(bool) const\n" - " mfem::QuadratureInterpolator::DisableTensorProducts() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - mfem::Vector *arg2 = 0 ; - unsigned int arg3 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - unsigned int val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject *swig_obj[6] ; - - if (!SWIG_Python_UnpackTuple(args, "QuadratureInterpolator_Mult", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_Mult" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureInterpolator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "QuadratureInterpolator_Mult" "', argument " "3"" of type '" "unsigned int""'"); - } - arg3 = static_cast< unsigned int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuadratureInterpolator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "QuadratureInterpolator_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "QuadratureInterpolator_Mult" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_Mult" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - try { - ((mfem::QuadratureInterpolator const *)arg1)->Mult((mfem::Vector const &)*arg2,arg3,*arg4,*arg5,*arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureInterpolator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - unsigned int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - unsigned int val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "QuadratureInterpolator_MultTranspose", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "1"" of type '" "mfem::QuadratureInterpolator const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "2"" of type '" "unsigned int""'"); - } - arg2 = static_cast< unsigned int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureInterpolator_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - ((mfem::QuadratureInterpolator const *)arg1)->MultTranspose(arg2,(mfem::Vector const &)*arg3,(mfem::Vector const &)*arg4,*arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_QuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureInterpolator *arg1 = (mfem::QuadratureInterpolator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuadratureInterpolator" "', argument " "1"" of type '" "mfem::QuadratureInterpolator *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureInterpolator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *QuadratureInterpolator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__QuadratureInterpolator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *QuadratureInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Ordering", _wrap_new_Ordering, METH_NOARGS, "new_Ordering() -> Ordering"}, { "delete_Ordering", _wrap_delete_Ordering, METH_O, "delete_Ordering(Ordering self)"}, { "Ordering_swigregister", Ordering_swigregister, METH_O, NULL}, @@ -12500,10 +12062,12 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "FiniteElementSpace_GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "FiniteElementSpace_GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "FiniteElementSpace_GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "FiniteElementSpace_GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" - "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> QuadratureInterpolator\n" - "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> QuadratureInterpolator\n" + "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" + "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" ""}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "FiniteElementSpace_GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "FiniteElementSpace_GetVDim(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "FiniteElementSpace_GetOrder(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "FiniteElementSpace_GetFaceOrder(FiniteElementSpace self, int i) -> int"}, @@ -12521,6 +12085,7 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "FiniteElementSpace_GetNE(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "FiniteElementSpace_GetNF(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "FiniteElementSpace_GetNBE(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "FiniteElementSpace_GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "FiniteElementSpace_GetElementType(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "FiniteElementSpace_GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "FiniteElementSpace_GetBdrElementType(FiniteElementSpace self, int i) -> int"}, @@ -12629,26 +12194,169 @@ static PyMethodDef SwigMethods[] = { { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, - { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, - { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, - { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, - { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, - { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_QuadratureInterpolator", _wrap_new_QuadratureInterpolator, METH_VARARGS, "\n" - "QuadratureInterpolator(FiniteElementSpace fes, IntegrationRule ir)\n" - "new_QuadratureInterpolator(FiniteElementSpace fes, QuadratureSpace qs) -> QuadratureInterpolator\n" - ""}, - { "QuadratureInterpolator_DisableTensorProducts", _wrap_QuadratureInterpolator_DisableTensorProducts, METH_VARARGS, "QuadratureInterpolator_DisableTensorProducts(QuadratureInterpolator self, bool disable=True)"}, - { "QuadratureInterpolator_Mult", _wrap_QuadratureInterpolator_Mult, METH_VARARGS, "QuadratureInterpolator_Mult(QuadratureInterpolator self, Vector e_vec, unsigned int eval_flags, Vector q_val, Vector q_der, Vector q_det)"}, - { "QuadratureInterpolator_MultTranspose", _wrap_QuadratureInterpolator_MultTranspose, METH_VARARGS, "QuadratureInterpolator_MultTranspose(QuadratureInterpolator self, unsigned int eval_flags, Vector q_val, Vector q_der, Vector e_vec)"}, - { "delete_QuadratureInterpolator", _wrap_delete_QuadratureInterpolator, METH_O, "delete_QuadratureInterpolator(QuadratureInterpolator self)"}, - { "QuadratureInterpolator_swigregister", QuadratureInterpolator_swigregister, METH_O, NULL}, - { "QuadratureInterpolator_swiginit", QuadratureInterpolator_swiginit, METH_VARARGS, NULL}, + { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Ordering", _wrap_new_Ordering, METH_NOARGS, "new_Ordering() -> Ordering"}, + { "delete_Ordering", _wrap_delete_Ordering, METH_O, "delete_Ordering(Ordering self)"}, + { "Ordering_swigregister", Ordering_swigregister, METH_O, NULL}, + { "Ordering_swiginit", Ordering_swiginit, METH_VARARGS, NULL}, + { "new_FiniteElementSpace", _wrap_new_FiniteElementSpace, METH_VARARGS, "\n" + "FiniteElementSpace()\n" + "FiniteElementSpace(FiniteElementSpace orig, Mesh mesh=None, FiniteElementCollection fec=None)\n" + "FiniteElementSpace(Mesh mesh, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + "FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + ""}, + { "FiniteElementSpace_GetMesh", _wrap_FiniteElementSpace_GetMesh, METH_O, "GetMesh(FiniteElementSpace self) -> Mesh"}, + { "FiniteElementSpace_GetNURBSext", _wrap_FiniteElementSpace_GetNURBSext, METH_VARARGS, "\n" + "GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension const\n" + "GetNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *\n" + ""}, + { "FiniteElementSpace_StealNURBSext", _wrap_FiniteElementSpace_StealNURBSext, METH_O, "StealNURBSext(FiniteElementSpace self) -> mfem::NURBSExtension *"}, + { "FiniteElementSpace_Conforming", _wrap_FiniteElementSpace_Conforming, METH_O, "Conforming(FiniteElementSpace self) -> bool"}, + { "FiniteElementSpace_Nonconforming", _wrap_FiniteElementSpace_Nonconforming, METH_O, "Nonconforming(FiniteElementSpace self) -> bool"}, + { "FiniteElementSpace_GetConformingProlongation", _wrap_FiniteElementSpace_GetConformingProlongation, METH_O, "GetConformingProlongation(FiniteElementSpace self) -> SparseMatrix"}, + { "FiniteElementSpace_GetConformingRestriction", _wrap_FiniteElementSpace_GetConformingRestriction, METH_O, "GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix"}, + { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, + { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, + { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" + "GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" + "GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" + ""}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, + { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "GetVDim(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "GetOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "GetFaceOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetNDofs", _wrap_FiniteElementSpace_GetNDofs, METH_O, "GetNDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetVSize", _wrap_FiniteElementSpace_GetVSize, METH_O, "GetVSize(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetTrueVSize", _wrap_FiniteElementSpace_GetTrueVSize, METH_O, "GetTrueVSize(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNConformingDofs", _wrap_FiniteElementSpace_GetNConformingDofs, METH_O, "GetNConformingDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetConformingVSize", _wrap_FiniteElementSpace_GetConformingVSize, METH_O, "GetConformingVSize(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetOrdering", _wrap_FiniteElementSpace_GetOrdering, METH_O, "GetOrdering(FiniteElementSpace self) -> mfem::Ordering::Type"}, + { "FiniteElementSpace_FEColl", _wrap_FiniteElementSpace_FEColl, METH_O, "FEColl(FiniteElementSpace self) -> FiniteElementCollection"}, + { "FiniteElementSpace_GetNVDofs", _wrap_FiniteElementSpace_GetNVDofs, METH_O, "GetNVDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNEDofs", _wrap_FiniteElementSpace_GetNEDofs, METH_O, "GetNEDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNFDofs", _wrap_FiniteElementSpace_GetNFDofs, METH_O, "GetNFDofs(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNV", _wrap_FiniteElementSpace_GetNV, METH_O, "GetNV(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "GetNE(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "GetNF(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "GetNBE(FiniteElementSpace self) -> int"}, + { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, + { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "GetElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, + { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "GetBdrElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementTransformation", _wrap_FiniteElementSpace_GetElementTransformation, METH_VARARGS, "\n" + "GetElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation\n" + "GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr)\n" + ""}, + { "FiniteElementSpace_GetBdrElementTransformation", _wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS, "GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, + { "FiniteElementSpace_GetAttribute", _wrap_FiniteElementSpace_GetAttribute, METH_VARARGS, "GetAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetBdrAttribute", _wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementDofs", _wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS, "GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementDofs", _wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceDofs", _wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetEdgeDofs", _wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS, "GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetVertexDofs", _wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS, "GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetElementInteriorDofs", _wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS, "GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceInteriorDofs", _wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS, "GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetNumElementInteriorDofs", _wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS, "GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetEdgeInteriorDofs", _wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS, "GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_DofsToVDofs", _wrap_FiniteElementSpace_DofsToVDofs, METH_VARARGS, "\n" + "DofsToVDofs(FiniteElementSpace self, intArray dofs, int ndofs=-1)\n" + "DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)\n" + ""}, + { "FiniteElementSpace_DofToVDof", _wrap_FiniteElementSpace_DofToVDof, METH_VARARGS, "DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, + { "FiniteElementSpace_VDofToDof", _wrap_FiniteElementSpace_VDofToDof, METH_VARARGS, "VDofToDof(FiniteElementSpace self, int vdof) -> int"}, + { "FiniteElementSpace_AdjustVDofs", _wrap_FiniteElementSpace_AdjustVDofs, METH_O, "AdjustVDofs(intArray vdofs)"}, + { "FiniteElementSpace_GetElementVDofs", _wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS, "GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetBdrElementVDofs", _wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS, "GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetFaceVDofs", _wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS, "GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeVDofs", _wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS, "GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetVertexVDofs", _wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS, "GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetElementInteriorVDofs", _wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS, "GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeInteriorVDofs", _wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS, "GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_RebuildElementToDofTable", _wrap_FiniteElementSpace_RebuildElementToDofTable, METH_O, "RebuildElementToDofTable(FiniteElementSpace self)"}, + { "FiniteElementSpace_ReorderElementToDofTable", _wrap_FiniteElementSpace_ReorderElementToDofTable, METH_O, "ReorderElementToDofTable(FiniteElementSpace self)"}, + { "FiniteElementSpace_BuildDofToArrays", _wrap_FiniteElementSpace_BuildDofToArrays, METH_O, "BuildDofToArrays(FiniteElementSpace self)"}, + { "FiniteElementSpace_GetElementToDofTable", _wrap_FiniteElementSpace_GetElementToDofTable, METH_O, "GetElementToDofTable(FiniteElementSpace self) -> Table"}, + { "FiniteElementSpace_GetBdrElementToDofTable", _wrap_FiniteElementSpace_GetBdrElementToDofTable, METH_O, "GetBdrElementToDofTable(FiniteElementSpace self) -> Table"}, + { "FiniteElementSpace_GetElementForDof", _wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS, "GetElementForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetLocalDofForDof", _wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS, "GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFE", _wrap_FiniteElementSpace_GetFE, METH_VARARGS, "GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetBE", _wrap_FiniteElementSpace_GetBE, METH_VARARGS, "GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetFaceElement", _wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS, "GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetEdgeElement", _wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS, "GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetTraceElement", _wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS, "GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, + { "FiniteElementSpace_GetEssentialVDofs", _wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, + { "FiniteElementSpace_GetEssentialTrueDofs", _wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "FiniteElementSpace_MarkerToList", _wrap_FiniteElementSpace_MarkerToList, METH_VARARGS, "MarkerToList(intArray marker, intArray list)"}, + { "FiniteElementSpace_ListToMarker", _wrap_FiniteElementSpace_ListToMarker, METH_VARARGS, "ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, + { "FiniteElementSpace_ConvertToConformingVDofs", _wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS, "ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, + { "FiniteElementSpace_ConvertFromConformingVDofs", _wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS, "ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, + { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS, "D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS, "D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS, "H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, + { "FiniteElementSpace_GetTransferOperator", _wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS, "GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_GetTrueTransferOperator", _wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_Update", _wrap_FiniteElementSpace_Update, METH_VARARGS, "Update(FiniteElementSpace self, bool want_transform=True)"}, + { "FiniteElementSpace_GetUpdateOperator", _wrap_FiniteElementSpace_GetUpdateOperator, METH_VARARGS, "\n" + "GetUpdateOperator(FiniteElementSpace self) -> Operator\n" + "GetUpdateOperator(FiniteElementSpace self, OperatorHandle T)\n" + ""}, + { "FiniteElementSpace_SetUpdateOperatorOwner", _wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS, "SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, + { "FiniteElementSpace_SetUpdateOperatorType", _wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS, "SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, + { "FiniteElementSpace_UpdatesFinished", _wrap_FiniteElementSpace_UpdatesFinished, METH_O, "UpdatesFinished(FiniteElementSpace self)"}, + { "FiniteElementSpace_GetSequence", _wrap_FiniteElementSpace_GetSequence, METH_O, "GetSequence(FiniteElementSpace self) -> long"}, + { "FiniteElementSpace_Load", _wrap_FiniteElementSpace_Load, METH_VARARGS, "Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, + { "delete_FiniteElementSpace", _wrap_delete_FiniteElementSpace, METH_O, "delete_FiniteElementSpace(FiniteElementSpace self)"}, + { "FiniteElementSpace_Save", _wrap_FiniteElementSpace_Save, METH_VARARGS, "\n" + "Save(FiniteElementSpace self, std::ostream & out)\n" + "Save(FiniteElementSpace self, char const * file, int precision=8)\n" + "Save(FiniteElementSpace self)\n" + ""}, + { "FiniteElementSpace_swigregister", FiniteElementSpace_swigregister, METH_O, NULL}, + { "FiniteElementSpace_swiginit", FiniteElementSpace_swiginit, METH_VARARGS, NULL}, + { "new_QuadratureSpace", _wrap_new_QuadratureSpace, METH_VARARGS, "\n" + "QuadratureSpace(Mesh mesh_, int order_)\n" + "new_QuadratureSpace(Mesh mesh_, std::istream & _in) -> QuadratureSpace\n" + ""}, + { "delete_QuadratureSpace", _wrap_delete_QuadratureSpace, METH_O, "delete_QuadratureSpace(QuadratureSpace self)"}, + { "QuadratureSpace_GetSize", _wrap_QuadratureSpace_GetSize, METH_O, "GetSize(QuadratureSpace self) -> int"}, + { "QuadratureSpace_GetElementIntRule", _wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, + { "QuadratureSpace_Save", _wrap_QuadratureSpace_Save, METH_VARARGS, "\n" + "Save(QuadratureSpace self, std::ostream & out)\n" + "Save(QuadratureSpace self, char const * file, int precision=8)\n" + "Save(QuadratureSpace self)\n" + ""}, + { "QuadratureSpace_swigregister", QuadratureSpace_swigregister, METH_O, NULL}, + { "QuadratureSpace_swiginit", QuadratureSpace_swiginit, METH_VARARGS, NULL}, + { "delete_GridTransfer", _wrap_delete_GridTransfer, METH_O, "delete_GridTransfer(GridTransfer self)"}, + { "GridTransfer_SetOperatorType", _wrap_GridTransfer_SetOperatorType, METH_VARARGS, "SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, + { "GridTransfer_ForwardOperator", _wrap_GridTransfer_ForwardOperator, METH_O, "ForwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_BackwardOperator", _wrap_GridTransfer_BackwardOperator, METH_O, "BackwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_TrueForwardOperator", _wrap_GridTransfer_TrueForwardOperator, METH_O, "TrueForwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_TrueBackwardOperator", _wrap_GridTransfer_TrueBackwardOperator, METH_O, "TrueBackwardOperator(GridTransfer self) -> Operator"}, + { "GridTransfer_swigregister", GridTransfer_swigregister, METH_O, NULL}, + { "new_InterpolationGridTransfer", _wrap_new_InterpolationGridTransfer, METH_VARARGS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, + { "delete_InterpolationGridTransfer", _wrap_delete_InterpolationGridTransfer, METH_O, "delete_InterpolationGridTransfer(InterpolationGridTransfer self)"}, + { "InterpolationGridTransfer_SetMassIntegrator", _wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS, "SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, + { "InterpolationGridTransfer_ForwardOperator", _wrap_InterpolationGridTransfer_ForwardOperator, METH_O, "ForwardOperator(InterpolationGridTransfer self) -> Operator"}, + { "InterpolationGridTransfer_BackwardOperator", _wrap_InterpolationGridTransfer_BackwardOperator, METH_O, "BackwardOperator(InterpolationGridTransfer self) -> Operator"}, + { "InterpolationGridTransfer_swigregister", InterpolationGridTransfer_swigregister, METH_O, NULL}, + { "InterpolationGridTransfer_swiginit", InterpolationGridTransfer_swiginit, METH_VARARGS, NULL}, + { "new_L2ProjectionGridTransfer", _wrap_new_L2ProjectionGridTransfer, METH_VARARGS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, + { "L2ProjectionGridTransfer_ForwardOperator", _wrap_L2ProjectionGridTransfer_ForwardOperator, METH_O, "ForwardOperator(L2ProjectionGridTransfer self) -> Operator"}, + { "L2ProjectionGridTransfer_BackwardOperator", _wrap_L2ProjectionGridTransfer_BackwardOperator, METH_O, "BackwardOperator(L2ProjectionGridTransfer self) -> Operator"}, + { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, + { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, + { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, + { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; @@ -12721,6 +12429,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -12850,9 +12561,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -12877,15 +12585,15 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } static void *_p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorInnerProductInterpolator *) x)); } -static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); -} static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); } @@ -12943,12 +12651,18 @@ static void *_p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollect static void *_p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::CrouzeixRaviartFECollection *) x)); } +static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +} static void *_p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::H1_FECollection *) x)); } static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -12982,8 +12696,8 @@ static void *_p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection(vo static void *_p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::QuadraticPosFECollection *) x)); } -static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); } static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::Local_FECollection *) x)); @@ -13003,21 +12717,33 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -13033,9 +12759,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -13045,12 +12777,6 @@ static void *_p_mfem__InterpolationGridTransferTo_p_mfem__GridTransfer(void *x, static void *_p_mfem__L2ProjectionGridTransferTo_p_mfem__GridTransfer(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::GridTransfer *) ((mfem::L2ProjectionGridTransfer *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -13084,6 +12810,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -13099,6 +12828,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -13267,6 +12999,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -13310,10 +13048,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -13342,23 +13080,14 @@ static void *_p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformatio static void *_p_mfem__STableTo_p_mfem__Table(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Table *) ((mfem::STable *) x)); } -static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); -} -static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); -} -static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); -} static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -13369,6 +13098,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -13390,6 +13120,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -13422,8 +13153,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -13432,10 +13162,11 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", "mfem::ElementRestriction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ElementTransformation = {"_p_mfem__ElementTransformation", "mfem::ElementTransformation *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FaceQuadratureInterpolator = {"_p_mfem__FaceQuadratureInterpolator", "mfem::FaceQuadratureInterpolator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FiniteElement = {"_p_mfem__FiniteElement", "mfem::FiniteElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__P0HexFiniteElement = {"_p_mfem__P0HexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LagrangeHexFiniteElement = {"_p_mfem__LagrangeHexFiniteElement", 0, 0, 0, 0, 0}; @@ -13452,13 +13183,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -13470,6 +13199,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -13511,6 +13242,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -13535,6 +13268,7 @@ static swig_type_info _swigt__p_mfem__NURBS1DFiniteElement = {"_p_mfem__NURBS1DF static swig_type_info _swigt__p_mfem__NURBS2DFiniteElement = {"_p_mfem__NURBS2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS3DFiniteElement = {"_p_mfem__NURBS3DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementCollection = {"_p_mfem__FiniteElementCollection", "mfem::FiniteElementCollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GaussLinearDiscont2DFECollection = {"_p_mfem__GaussLinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1OnQuadFECollection = {"_p_mfem__P1OnQuadFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticDiscont2DFECollection = {"_p_mfem__QuadraticDiscont2DFECollection", 0, 0, 0, 0, 0}; @@ -13547,15 +13281,13 @@ static swig_type_info _swigt__p_mfem__QuadraticDiscont3DFECollection = {"_p_mfem static swig_type_info _swigt__p_mfem__RefinedLinearFECollection = {"_p_mfem__RefinedLinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ND1_3DFECollection = {"_p_mfem__ND1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_3DFECollection = {"_p_mfem__RT0_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Const2DFECollection = {"_p_mfem__Const2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT2_2DFECollection = {"_p_mfem__RT2_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1_2DFECollection = {"_p_mfem__RT1_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_2DFECollection = {"_p_mfem__RT0_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearNonConf3DFECollection = {"_p_mfem__LinearNonConf3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CrouzeixRaviartFECollection = {"_p_mfem__CrouzeixRaviartFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticFECollection = {"_p_mfem__QuadraticFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearFECollection = {"_p_mfem__LinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBSFECollection = {"_p_mfem__NURBSFECollection", 0, 0, 0, 0, 0}; @@ -13565,9 +13297,11 @@ static swig_type_info _swigt__p_mfem__DG_Interface_FECollection = {"_p_mfem__DG_ static swig_type_info _swigt__p_mfem__RT_Trace_FECollection = {"_p_mfem__RT_Trace_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT_FECollection = {"_p_mfem__RT_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_Trace_FECollection = {"_p_mfem__H1_Trace_FECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_FECollection = {"_p_mfem__H1Ser_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_FECollection = {"_p_mfem__H1Pos_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_FECollection = {"_p_mfem__H1_FECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Local_FECollection = {"_p_mfem__Local_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; @@ -13585,15 +13319,22 @@ static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Ordering = {"_p_mfem__Ordering", "mfem::Ordering *", 0, 0, (void*)0, 0}; @@ -13602,9 +13343,6 @@ static swig_type_info _swigt__p_mfem__QuadratureSpace = {"_p_mfem__QuadratureSpa static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Table = {"_p_mfem__Table", "mfem::Table *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__STable = {"_p_mfem__STable", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; @@ -13615,6 +13353,7 @@ static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, @@ -13658,6 +13397,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__ElementTransformation, + &_swigt__p_mfem__FaceQuadratureInterpolator, &_swigt__p_mfem__FiniteElement, &_swigt__p_mfem__FiniteElementCollection, &_swigt__p_mfem__FiniteElementSpace, @@ -13667,10 +13407,12 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__GaussLinearDiscont2DFECollection, &_swigt__p_mfem__GaussQuad2DFiniteElement, &_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GridTransfer, &_swigt__p_mfem__GroupConvectionIntegrator, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__H1Pos_FECollection, &_swigt__p_mfem__H1Pos_HexahedronElement, &_swigt__p_mfem__H1Pos_QuadrilateralElement, @@ -13678,6 +13420,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_FECollection, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_FECollection, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, @@ -13692,6 +13436,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__InterpolationGridTransfer, &_swigt__p_mfem__InverseIntegrator, &_swigt__p_mfem__IsoparametricTransformation, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2Pos_HexahedronElement, &_swigt__p_mfem__L2Pos_QuadrilateralElement, &_swigt__p_mfem__L2Pos_SegmentElement, @@ -13714,7 +13460,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__LinearDiscont2DFECollection, &_swigt__p_mfem__LinearDiscont3DFECollection, &_swigt__p_mfem__LinearFECollection, - &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__LinearNonConf3DFECollection, &_swigt__p_mfem__Local_FECollection, &_swigt__p_mfem__LumpedIntegrator, @@ -13810,7 +13555,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__QuadraticFECollection, &_swigt__p_mfem__QuadraticPosDiscont2DFECollection, &_swigt__p_mfem__QuadraticPosFECollection, - &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__QuadratureInterpolator, &_swigt__p_mfem__QuadratureSpace, &_swigt__p_mfem__RAPOperator, @@ -13834,6 +13578,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__RT_TetrahedronElement, &_swigt__p_mfem__RT_Trace_FECollection, &_swigt__p_mfem__RT_TriangleElement, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__RefinedBiLinear2DFiniteElement, &_swigt__p_mfem__RefinedLinear1DFiniteElement, &_swigt__p_mfem__RefinedLinear2DFiniteElement, @@ -13845,6 +13590,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ScalarFiniteElement, &_swigt__p_mfem__ScalarProductInterpolator, &_swigt__p_mfem__ScalarVectorProductInterpolator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__SumIntegrator, @@ -13855,7 +13602,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__TransposeOperator, &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__TripleProductOperator, - &_swigt__p_mfem__Vector, &_swigt__p_mfem__VectorCrossProductInterpolator, &_swigt__p_mfem__VectorCurlCurlIntegrator, &_swigt__p_mfem__VectorDiffusionIntegrator, @@ -13868,6 +13614,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorInnerProductInterpolator, &_swigt__p_mfem__VectorMassIntegrator, &_swigt__p_mfem__VectorScalarProductInterpolator, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -13878,12 +13625,12 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -13894,6 +13641,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -13915,6 +13663,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -13947,8 +13696,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -13957,11 +13705,12 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ElementRestriction[] = { {&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0}, {&_swigt__p_mfem__IsoparametricTransformation, _p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FaceQuadratureInterpolator[] = { {&_swigt__p_mfem__FaceQuadratureInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0HexFiniteElement[] = {{&_swigt__p_mfem__P0HexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LagrangeHexFiniteElement[] = {{&_swigt__p_mfem__LagrangeHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RefinedLinear1DFiniteElement[] = {{&_swigt__p_mfem__RefinedLinear1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -13977,13 +13726,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -13995,6 +13742,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -14036,6 +13785,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -14059,7 +13810,8 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussLinearDiscont2DFECollection[] = {{&_swigt__p_mfem__GaussLinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1OnQuadFECollection[] = {{&_swigt__p_mfem__P1OnQuadFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticDiscont2DFECollection[] = {{&_swigt__p_mfem__QuadraticDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -14072,15 +13824,13 @@ static swig_cast_info _swigc__p_mfem__QuadraticDiscont3DFECollection[] = {{&_swi static swig_cast_info _swigc__p_mfem__RefinedLinearFECollection[] = {{&_swigt__p_mfem__RefinedLinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ND1_3DFECollection[] = {{&_swigt__p_mfem__ND1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_3DFECollection[] = {{&_swigt__p_mfem__RT0_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Const2DFECollection[] = {{&_swigt__p_mfem__Const2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT2_2DFECollection[] = {{&_swigt__p_mfem__RT2_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1_2DFECollection[] = {{&_swigt__p_mfem__RT1_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_2DFECollection[] = {{&_swigt__p_mfem__RT0_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearNonConf3DFECollection[] = {{&_swigt__p_mfem__LinearNonConf3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CrouzeixRaviartFECollection[] = {{&_swigt__p_mfem__CrouzeixRaviartFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticFECollection[] = {{&_swigt__p_mfem__QuadraticFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearFECollection[] = {{&_swigt__p_mfem__LinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBSFECollection[] = {{&_swigt__p_mfem__NURBSFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -14090,11 +13840,13 @@ static swig_cast_info _swigc__p_mfem__DG_Interface_FECollection[] = {{&_swigt__p static swig_cast_info _swigc__p_mfem__RT_Trace_FECollection[] = {{&_swigt__p_mfem__RT_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT_FECollection[] = {{&_swigt__p_mfem__RT_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_Trace_FECollection[] = {{&_swigt__p_mfem__H1_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_FECollection[] = {{&_swigt__p_mfem__H1Ser_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_FECollection[] = {{&_swigt__p_mfem__H1Pos_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_FECollection[] = {{&_swigt__p_mfem__H1_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Local_FECollection[] = {{&_swigt__p_mfem__Local_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridTransfer[] = { {&_swigt__p_mfem__GridTransfer, 0, 0, 0}, {&_swigt__p_mfem__InterpolationGridTransfer, _p_mfem__InterpolationGridTransferTo_p_mfem__GridTransfer, 0, 0}, {&_swigt__p_mfem__L2ProjectionGridTransfer, _p_mfem__L2ProjectionGridTransferTo_p_mfem__GridTransfer, 0, 0},{0, 0, 0, 0}}; @@ -14110,17 +13862,24 @@ static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOp static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Ordering[] = { {&_swigt__p_mfem__Ordering, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadratureInterpolator[] = { {&_swigt__p_mfem__QuadratureInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -14128,9 +13887,6 @@ static swig_cast_info _swigc__p_mfem__QuadratureSpace[] = { {&_swigt__p_mfem__Q static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__STable[] = {{&_swigt__p_mfem__STable, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Table[] = { {&_swigt__p_mfem__STable, _p_mfem__STableTo_p_mfem__Table, 0, 0}, {&_swigt__p_mfem__Table, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -14141,6 +13897,7 @@ static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, @@ -14184,6 +13941,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__ElementTransformation, + _swigc__p_mfem__FaceQuadratureInterpolator, _swigc__p_mfem__FiniteElement, _swigc__p_mfem__FiniteElementCollection, _swigc__p_mfem__FiniteElementSpace, @@ -14193,10 +13951,12 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__GaussLinearDiscont2DFECollection, _swigc__p_mfem__GaussQuad2DFiniteElement, _swigc__p_mfem__GaussQuadraticDiscont2DFECollection, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GridTransfer, _swigc__p_mfem__GroupConvectionIntegrator, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__H1Pos_FECollection, _swigc__p_mfem__H1Pos_HexahedronElement, _swigc__p_mfem__H1Pos_QuadrilateralElement, @@ -14204,6 +13964,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_FECollection, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_FECollection, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, @@ -14218,6 +13980,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__InterpolationGridTransfer, _swigc__p_mfem__InverseIntegrator, _swigc__p_mfem__IsoparametricTransformation, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2Pos_HexahedronElement, _swigc__p_mfem__L2Pos_QuadrilateralElement, _swigc__p_mfem__L2Pos_SegmentElement, @@ -14240,7 +14004,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__LinearDiscont2DFECollection, _swigc__p_mfem__LinearDiscont3DFECollection, _swigc__p_mfem__LinearFECollection, - _swigc__p_mfem__LinearForm, _swigc__p_mfem__LinearNonConf3DFECollection, _swigc__p_mfem__Local_FECollection, _swigc__p_mfem__LumpedIntegrator, @@ -14336,7 +14099,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__QuadraticFECollection, _swigc__p_mfem__QuadraticPosDiscont2DFECollection, _swigc__p_mfem__QuadraticPosFECollection, - _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__QuadratureInterpolator, _swigc__p_mfem__QuadratureSpace, _swigc__p_mfem__RAPOperator, @@ -14360,6 +14122,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__RT_TetrahedronElement, _swigc__p_mfem__RT_Trace_FECollection, _swigc__p_mfem__RT_TriangleElement, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__RefinedBiLinear2DFiniteElement, _swigc__p_mfem__RefinedLinear1DFiniteElement, _swigc__p_mfem__RefinedLinear2DFiniteElement, @@ -14371,6 +14134,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ScalarFiniteElement, _swigc__p_mfem__ScalarProductInterpolator, _swigc__p_mfem__ScalarVectorProductInterpolator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__SumIntegrator, @@ -14381,7 +14146,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__TransposeOperator, _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__TripleProductOperator, - _swigc__p_mfem__Vector, _swigc__p_mfem__VectorCrossProductInterpolator, _swigc__p_mfem__VectorCurlCurlIntegrator, _swigc__p_mfem__VectorDiffusionIntegrator, @@ -14394,6 +14158,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorInnerProductInterpolator, _swigc__p_mfem__VectorMassIntegrator, _swigc__p_mfem__VectorScalarProductInterpolator, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, @@ -15137,9 +14902,6 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Ordering_byVDIM",SWIG_From_int(static_cast< int >(mfem::Ordering::byVDIM))); SWIG_Python_SetConstant(d, "ElementDofOrdering_NATIVE",SWIG_From_int(static_cast< int >(mfem::ElementDofOrdering::NATIVE))); SWIG_Python_SetConstant(d, "ElementDofOrdering_LEXICOGRAPHIC",SWIG_From_int(static_cast< int >(mfem::ElementDofOrdering::LEXICOGRAPHIC))); - SWIG_Python_SetConstant(d, "QuadratureInterpolator_VALUES",SWIG_From_int(static_cast< int >(mfem::QuadratureInterpolator::VALUES))); - SWIG_Python_SetConstant(d, "QuadratureInterpolator_DERIVATIVES",SWIG_From_int(static_cast< int >(mfem::QuadratureInterpolator::DERIVATIVES))); - SWIG_Python_SetConstant(d, "QuadratureInterpolator_DETERMINANTS",SWIG_From_int(static_cast< int >(mfem::QuadratureInterpolator::DETERMINANTS))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_ser/geom.py b/mfem/_ser/geom.py index cea8b5f5..dcb0977a 100644 --- a/mfem/_ser/geom.py +++ b/mfem/_ser/geom.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _geom.SWIG_PyInstanceMethod_New +_swig_new_static_method = _geom.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -107,15 +110,18 @@ def __init__(self): def GetVertices(self, GeomType): r"""GetVertices(Geometry self, int GeomType) -> IntegrationRule""" return _geom.Geometry_GetVertices(self, GeomType) + GetVertices = _swig_new_instance_method(_geom.Geometry_GetVertices) def GetCenter(self, GeomType): r"""GetCenter(Geometry self, int GeomType) -> IntegrationPoint""" return _geom.Geometry_GetCenter(self, GeomType) + GetCenter = _swig_new_instance_method(_geom.Geometry_GetCenter) @staticmethod def GetRandomPoint(GeomType, ip): r"""GetRandomPoint(int GeomType, IntegrationPoint ip)""" return _geom.Geometry_GetRandomPoint(GeomType, ip) + GetRandomPoint = _swig_new_static_method(_geom.Geometry_GetRandomPoint) @staticmethod def CheckPoint(*args): @@ -124,6 +130,7 @@ def CheckPoint(*args): CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool """ return _geom.Geometry_CheckPoint(*args) + CheckPoint = _swig_new_static_method(_geom.Geometry_CheckPoint) @staticmethod def ProjectPoint(*args): @@ -132,26 +139,32 @@ def ProjectPoint(*args): ProjectPoint(int GeomType, IntegrationPoint ip) -> bool """ return _geom.Geometry_ProjectPoint(*args) + ProjectPoint = _swig_new_static_method(_geom.Geometry_ProjectPoint) def GetGeomToPerfGeomJac(self, GeomType): r"""GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix""" return _geom.Geometry_GetGeomToPerfGeomJac(self, GeomType) + GetGeomToPerfGeomJac = _swig_new_instance_method(_geom.Geometry_GetGeomToPerfGeomJac) def GetPerfGeomToGeomJac(self, GeomType): r"""GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix""" return _geom.Geometry_GetPerfGeomToGeomJac(self, GeomType) + GetPerfGeomToGeomJac = _swig_new_instance_method(_geom.Geometry_GetPerfGeomToGeomJac) def GetPerfPointMat(self, GeomType, pm): r"""GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)""" return _geom.Geometry_GetPerfPointMat(self, GeomType, pm) + GetPerfPointMat = _swig_new_instance_method(_geom.Geometry_GetPerfPointMat) def JacToPerfJac(self, GeomType, J, PJ): r"""JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)""" return _geom.Geometry_JacToPerfJac(self, GeomType, J, PJ) + JacToPerfJac = _swig_new_instance_method(_geom.Geometry_JacToPerfJac) def NumBdr(self, GeomType): r"""NumBdr(Geometry self, int GeomType) -> int""" return _geom.Geometry_NumBdr(self, GeomType) + NumBdr = _swig_new_instance_method(_geom.Geometry_NumBdr) # Register Geometry in _geom: _geom.Geometry_swigregister(Geometry) @@ -167,6 +180,7 @@ def NumBdr(self, GeomType): def Geometry_GetRandomPoint(GeomType, ip): r"""Geometry_GetRandomPoint(int GeomType, IntegrationPoint ip)""" return _geom.Geometry_GetRandomPoint(GeomType, ip) +Geometry_GetRandomPoint = _geom.Geometry_GetRandomPoint def Geometry_CheckPoint(*args): r""" @@ -174,6 +188,7 @@ def Geometry_CheckPoint(*args): Geometry_CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool """ return _geom.Geometry_CheckPoint(*args) +Geometry_CheckPoint = _geom.Geometry_CheckPoint def Geometry_ProjectPoint(*args): r""" @@ -181,6 +196,7 @@ def Geometry_ProjectPoint(*args): Geometry_ProjectPoint(int GeomType, IntegrationPoint ip) -> bool """ return _geom.Geometry_ProjectPoint(*args) +Geometry_ProjectPoint = _geom.Geometry_ProjectPoint class RefinedGeometry(object): r"""Proxy of C++ mfem::RefinedGeometry class.""" @@ -216,18 +232,22 @@ def __init__(self): def SetType(self, t): r"""SetType(GeometryRefiner self, int const t)""" return _geom.GeometryRefiner_SetType(self, t) + SetType = _swig_new_instance_method(_geom.GeometryRefiner_SetType) def GetType(self): r"""GetType(GeometryRefiner self) -> int""" return _geom.GeometryRefiner_GetType(self) + GetType = _swig_new_instance_method(_geom.GeometryRefiner_GetType) def Refine(self, Geom, Times, ETimes=1): r"""Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry""" return _geom.GeometryRefiner_Refine(self, Geom, Times, ETimes) + Refine = _swig_new_instance_method(_geom.GeometryRefiner_Refine) def RefineInterior(self, Geom, Times): r"""RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule""" return _geom.GeometryRefiner_RefineInterior(self, Geom, Times) + RefineInterior = _swig_new_instance_method(_geom.GeometryRefiner_RefineInterior) __swig_destroy__ = _geom.delete_GeometryRefiner # Register GeometryRefiner in _geom: diff --git a/mfem/_ser/geom_wrap.cxx b/mfem/_ser/geom_wrap.cxx index 2c2c2649..002aa9d4 100644 --- a/mfem/_ser/geom_wrap.cxx +++ b/mfem/_ser/geom_wrap.cxx @@ -5377,6 +5377,7 @@ SWIGINTERN PyObject *Swig_var_GlobGeometryRefiner_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Geometry_Name_get", _wrap_Geometry_Name_get, METH_VARARGS, NULL}, { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, @@ -5428,6 +5429,55 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Geometry_Name_get", _wrap_Geometry_Name_get, METH_VARARGS, NULL}, + { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, + { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, + { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"}, + { "Geometry_GetVertices", _wrap_Geometry_GetVertices, METH_VARARGS, "GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, + { "Geometry_GetCenter", _wrap_Geometry_GetCenter, METH_VARARGS, "GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, + { "Geometry_GetRandomPoint", _wrap_Geometry_GetRandomPoint, METH_VARARGS, "GetRandomPoint(int GeomType, IntegrationPoint ip)"}, + { "Geometry_CheckPoint", _wrap_Geometry_CheckPoint, METH_VARARGS, "\n" + "CheckPoint(int GeomType, IntegrationPoint ip) -> bool\n" + "CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool\n" + ""}, + { "Geometry_ProjectPoint", _wrap_Geometry_ProjectPoint, METH_VARARGS, "\n" + "ProjectPoint(int GeomType, IntegrationPoint beg, IntegrationPoint end) -> bool\n" + "ProjectPoint(int GeomType, IntegrationPoint ip) -> bool\n" + ""}, + { "Geometry_GetGeomToPerfGeomJac", _wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS, "GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfGeomToGeomJac", _wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS, "GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfPointMat", _wrap_Geometry_GetPerfPointMat, METH_VARARGS, "GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, + { "Geometry_JacToPerfJac", _wrap_Geometry_JacToPerfJac, METH_VARARGS, "JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, + { "Geometry_NumBdr", _wrap_Geometry_NumBdr, METH_VARARGS, "NumBdr(Geometry self, int GeomType) -> int"}, + { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL}, + { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL}, + { "RefinedGeometry_Times_set", _wrap_RefinedGeometry_Times_set, METH_VARARGS, "RefinedGeometry_Times_set(RefinedGeometry self, int Times)"}, + { "RefinedGeometry_Times_get", _wrap_RefinedGeometry_Times_get, METH_O, "RefinedGeometry_Times_get(RefinedGeometry self) -> int"}, + { "RefinedGeometry_ETimes_set", _wrap_RefinedGeometry_ETimes_set, METH_VARARGS, "RefinedGeometry_ETimes_set(RefinedGeometry self, int ETimes)"}, + { "RefinedGeometry_ETimes_get", _wrap_RefinedGeometry_ETimes_get, METH_O, "RefinedGeometry_ETimes_get(RefinedGeometry self) -> int"}, + { "RefinedGeometry_RefPts_get", _wrap_RefinedGeometry_RefPts_get, METH_O, "RefinedGeometry_RefPts_get(RefinedGeometry self) -> IntegrationRule"}, + { "RefinedGeometry_RefGeoms_set", _wrap_RefinedGeometry_RefGeoms_set, METH_VARARGS, "RefinedGeometry_RefGeoms_set(RefinedGeometry self, intArray RefGeoms)"}, + { "RefinedGeometry_RefGeoms_get", _wrap_RefinedGeometry_RefGeoms_get, METH_O, "RefinedGeometry_RefGeoms_get(RefinedGeometry self) -> intArray"}, + { "RefinedGeometry_RefEdges_set", _wrap_RefinedGeometry_RefEdges_set, METH_VARARGS, "RefinedGeometry_RefEdges_set(RefinedGeometry self, intArray RefEdges)"}, + { "RefinedGeometry_RefEdges_get", _wrap_RefinedGeometry_RefEdges_get, METH_O, "RefinedGeometry_RefEdges_get(RefinedGeometry self) -> intArray"}, + { "RefinedGeometry_NumBdrEdges_set", _wrap_RefinedGeometry_NumBdrEdges_set, METH_VARARGS, "RefinedGeometry_NumBdrEdges_set(RefinedGeometry self, int NumBdrEdges)"}, + { "RefinedGeometry_NumBdrEdges_get", _wrap_RefinedGeometry_NumBdrEdges_get, METH_O, "RefinedGeometry_NumBdrEdges_get(RefinedGeometry self) -> int"}, + { "RefinedGeometry_Type_set", _wrap_RefinedGeometry_Type_set, METH_VARARGS, "RefinedGeometry_Type_set(RefinedGeometry self, int Type)"}, + { "RefinedGeometry_Type_get", _wrap_RefinedGeometry_Type_get, METH_O, "RefinedGeometry_Type_get(RefinedGeometry self) -> int"}, + { "new_RefinedGeometry", _wrap_new_RefinedGeometry, METH_VARARGS, "RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0)"}, + { "delete_RefinedGeometry", _wrap_delete_RefinedGeometry, METH_O, "delete_RefinedGeometry(RefinedGeometry self)"}, + { "RefinedGeometry_swigregister", RefinedGeometry_swigregister, METH_O, NULL}, + { "RefinedGeometry_swiginit", RefinedGeometry_swiginit, METH_VARARGS, NULL}, + { "new_GeometryRefiner", _wrap_new_GeometryRefiner, METH_NOARGS, "new_GeometryRefiner() -> GeometryRefiner"}, + { "GeometryRefiner_SetType", _wrap_GeometryRefiner_SetType, METH_VARARGS, "SetType(GeometryRefiner self, int const t)"}, + { "GeometryRefiner_GetType", _wrap_GeometryRefiner_GetType, METH_O, "GetType(GeometryRefiner self) -> int"}, + { "GeometryRefiner_Refine", _wrap_GeometryRefiner_Refine, METH_VARARGS, "Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, + { "GeometryRefiner_RefineInterior", _wrap_GeometryRefiner_RefineInterior, METH_VARARGS, "RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, + { "delete_GeometryRefiner", _wrap_delete_GeometryRefiner, METH_O, "delete_GeometryRefiner(GeometryRefiner self)"}, + { "GeometryRefiner_swigregister", GeometryRefiner_swigregister, METH_O, NULL}, + { "GeometryRefiner_swiginit", GeometryRefiner_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/globals.py b/mfem/_ser/globals.py index aabb73e9..78ab457e 100644 --- a/mfem/_ser/globals.py +++ b/mfem/_ser/globals.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _globals.SWIG_PyInstanceMethod_New +_swig_new_static_method = _globals.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -70,15 +73,19 @@ def __init__(self, out): def SetStream(self, out): return _globals.OutStream_SetStream(self, out) + SetStream = _swig_new_instance_method(_globals.OutStream_SetStream) def Enable(self): return _globals.OutStream_Enable(self) + Enable = _swig_new_instance_method(_globals.OutStream_Enable) def Disable(self): return _globals.OutStream_Disable(self) + Disable = _swig_new_instance_method(_globals.OutStream_Disable) def IsEnabled(self): return _globals.OutStream_IsEnabled(self) + IsEnabled = _swig_new_instance_method(_globals.OutStream_IsEnabled) __swig_destroy__ = _globals.delete_OutStream # Register OutStream in _globals: @@ -87,6 +94,7 @@ def IsEnabled(self): def MakeParFilename(*args): return _globals.MakeParFilename(*args) +MakeParFilename = _globals.MakeParFilename cvar = _globals.cvar out = cvar.out diff --git a/mfem/_ser/globals_wrap.cxx b/mfem/_ser/globals_wrap.cxx index 8082d656..addcf9e1 100644 --- a/mfem/_ser/globals_wrap.cxx +++ b/mfem/_ser/globals_wrap.cxx @@ -3468,6 +3468,7 @@ SWIGINTERN PyObject *_wrap_MakeParFilename(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, @@ -3481,6 +3482,17 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, + { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, + { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, + { "OutStream_Disable", _wrap_OutStream_Disable, METH_O, NULL}, + { "OutStream_IsEnabled", _wrap_OutStream_IsEnabled, METH_O, NULL}, + { "delete_OutStream", _wrap_delete_OutStream, METH_O, NULL}, + { "OutStream_swigregister", OutStream_swigregister, METH_O, NULL}, + { "OutStream_swiginit", OutStream_swiginit, METH_VARARGS, NULL}, + { "MakeParFilename", _wrap_MakeParFilename, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/gridfunc.py b/mfem/_ser/gridfunc.py index ad1df534..6dacfb34 100644 --- a/mfem/_ser/gridfunc.py +++ b/mfem/_ser/gridfunc.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _gridfunc.SWIG_PyInstanceMethod_New +_swig_new_static_method = _gridfunc.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -73,22 +76,27 @@ def __init__(self): def assign(self, value): return _gridfunc.intp_assign(self, value) + assign = _swig_new_instance_method(_gridfunc.intp_assign) def value(self): return _gridfunc.intp_value(self) + value = _swig_new_instance_method(_gridfunc.intp_value) def cast(self): return _gridfunc.intp_cast(self) + cast = _swig_new_instance_method(_gridfunc.intp_cast) @staticmethod def frompointer(t): return _gridfunc.intp_frompointer(t) + frompointer = _swig_new_static_method(_gridfunc.intp_frompointer) # Register intp in _gridfunc: _gridfunc.intp_swigregister(intp) def intp_frompointer(t): return _gridfunc.intp_frompointer(t) +intp_frompointer = _gridfunc.intp_frompointer class doublep(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -100,22 +108,27 @@ def __init__(self): def assign(self, value): return _gridfunc.doublep_assign(self, value) + assign = _swig_new_instance_method(_gridfunc.doublep_assign) def value(self): return _gridfunc.doublep_value(self) + value = _swig_new_instance_method(_gridfunc.doublep_value) def cast(self): return _gridfunc.doublep_cast(self) + cast = _swig_new_instance_method(_gridfunc.doublep_cast) @staticmethod def frompointer(t): return _gridfunc.doublep_frompointer(t) + frompointer = _swig_new_static_method(_gridfunc.doublep_frompointer) # Register doublep in _gridfunc: _gridfunc.doublep_swigregister(doublep) def doublep_frompointer(t): return _gridfunc.doublep_frompointer(t) +doublep_frompointer = _gridfunc.doublep_frompointer import mfem._ser.array import mfem._ser.mem_manager @@ -135,10 +148,12 @@ def doublep_frompointer(t): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.fespace import mfem._ser.fe_coll import mfem._ser.lininteg import mfem._ser.handle +import mfem._ser.restriction import mfem._ser.bilininteg import mfem._ser.linearform class GridFunction(mfem._ser.vector.Vector): @@ -150,14 +165,17 @@ class GridFunction(mfem._ser.vector.Vector): def MakeOwner(self, _fec): r"""MakeOwner(GridFunction self, FiniteElementCollection _fec)""" return _gridfunc.GridFunction_MakeOwner(self, _fec) + MakeOwner = _swig_new_instance_method(_gridfunc.GridFunction_MakeOwner) def OwnFEC(self): r"""OwnFEC(GridFunction self) -> FiniteElementCollection""" return _gridfunc.GridFunction_OwnFEC(self) + OwnFEC = _swig_new_instance_method(_gridfunc.GridFunction_OwnFEC) def VectorDim(self): r"""VectorDim(GridFunction self) -> int""" return _gridfunc.GridFunction_VectorDim(self) + VectorDim = _swig_new_instance_method(_gridfunc.GridFunction_VectorDim) def GetTrueVector(self, *args): r""" @@ -165,30 +183,37 @@ def GetTrueVector(self, *args): GetTrueVector(GridFunction self) -> Vector """ return _gridfunc.GridFunction_GetTrueVector(self, *args) + GetTrueVector = _swig_new_instance_method(_gridfunc.GridFunction_GetTrueVector) def GetTrueDofs(self, tv): r"""GetTrueDofs(GridFunction self, Vector tv)""" return _gridfunc.GridFunction_GetTrueDofs(self, tv) + GetTrueDofs = _swig_new_instance_method(_gridfunc.GridFunction_GetTrueDofs) def SetTrueVector(self): r"""SetTrueVector(GridFunction self)""" return _gridfunc.GridFunction_SetTrueVector(self) + SetTrueVector = _swig_new_instance_method(_gridfunc.GridFunction_SetTrueVector) def SetFromTrueDofs(self, tv): r"""SetFromTrueDofs(GridFunction self, Vector tv)""" return _gridfunc.GridFunction_SetFromTrueDofs(self, tv) + SetFromTrueDofs = _swig_new_instance_method(_gridfunc.GridFunction_SetFromTrueDofs) def SetFromTrueVector(self): r"""SetFromTrueVector(GridFunction self)""" return _gridfunc.GridFunction_SetFromTrueVector(self) + SetFromTrueVector = _swig_new_instance_method(_gridfunc.GridFunction_SetFromTrueVector) def GetValue(self, i, ip, vdim=1): r"""GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double""" return _gridfunc.GridFunction_GetValue(self, i, ip, vdim) + GetValue = _swig_new_instance_method(_gridfunc.GridFunction_GetValue) def GetVectorValue(self, i, ip, val): r"""GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)""" return _gridfunc.GridFunction_GetVectorValue(self, i, ip, val) + GetVectorValue = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorValue) def GetValues(self, *args): r""" @@ -196,10 +221,28 @@ def GetValues(self, *args): GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) """ return _gridfunc.GridFunction_GetValues(self, *args) + GetValues = _swig_new_instance_method(_gridfunc.GridFunction_GetValues) + + def GetLaplacians(self, *args): + r""" + GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, int vdim=1) + GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, DenseMatrix tr, int vdim=1) + """ + return _gridfunc.GridFunction_GetLaplacians(self, *args) + GetLaplacians = _swig_new_instance_method(_gridfunc.GridFunction_GetLaplacians) + + def GetHessians(self, *args): + r""" + GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1) + GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1) + """ + return _gridfunc.GridFunction_GetHessians(self, *args) + GetHessians = _swig_new_instance_method(_gridfunc.GridFunction_GetHessians) def GetFaceValues(self, i, side, ir, vals, tr, vdim=1): r"""GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int""" return _gridfunc.GridFunction_GetFaceValues(self, i, side, ir, vals, tr, vdim) + GetFaceValues = _swig_new_instance_method(_gridfunc.GridFunction_GetFaceValues) def GetVectorValues(self, *args): r""" @@ -207,26 +250,32 @@ def GetVectorValues(self, *args): GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) """ return _gridfunc.GridFunction_GetVectorValues(self, *args) + GetVectorValues = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorValues) def GetFaceVectorValues(self, i, side, ir, vals, tr): r"""GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int""" return _gridfunc.GridFunction_GetFaceVectorValues(self, i, side, ir, vals, tr) + GetFaceVectorValues = _swig_new_instance_method(_gridfunc.GridFunction_GetFaceVectorValues) def GetValuesFrom(self, orig_func): r"""GetValuesFrom(GridFunction self, GridFunction orig_func)""" return _gridfunc.GridFunction_GetValuesFrom(self, orig_func) + GetValuesFrom = _swig_new_instance_method(_gridfunc.GridFunction_GetValuesFrom) def GetBdrValuesFrom(self, orig_func): r"""GetBdrValuesFrom(GridFunction self, GridFunction orig_func)""" return _gridfunc.GridFunction_GetBdrValuesFrom(self, orig_func) + GetBdrValuesFrom = _swig_new_instance_method(_gridfunc.GridFunction_GetBdrValuesFrom) def GetVectorFieldValues(self, i, ir, vals, tr, comp=0): r"""GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)""" return _gridfunc.GridFunction_GetVectorFieldValues(self, i, ir, vals, tr, comp) + GetVectorFieldValues = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorFieldValues) def ReorderByNodes(self): r"""ReorderByNodes(GridFunction self)""" return _gridfunc.GridFunction_ReorderByNodes(self) + ReorderByNodes = _swig_new_instance_method(_gridfunc.GridFunction_ReorderByNodes) def GetNodalValues(self, *args): ''' @@ -247,26 +296,32 @@ def GetNodalValues(self, *args): def GetVectorFieldNodalValues(self, val, comp): r"""GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)""" return _gridfunc.GridFunction_GetVectorFieldNodalValues(self, val, comp) + GetVectorFieldNodalValues = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorFieldNodalValues) def ProjectVectorFieldOn(self, vec_field, comp=0): r"""ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)""" return _gridfunc.GridFunction_ProjectVectorFieldOn(self, vec_field, comp) + ProjectVectorFieldOn = _swig_new_instance_method(_gridfunc.GridFunction_ProjectVectorFieldOn) def GetDerivative(self, comp, der_comp, der): r"""GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)""" return _gridfunc.GridFunction_GetDerivative(self, comp, der_comp, der) + GetDerivative = _swig_new_instance_method(_gridfunc.GridFunction_GetDerivative) def GetDivergence(self, tr): r"""GetDivergence(GridFunction self, ElementTransformation tr) -> double""" return _gridfunc.GridFunction_GetDivergence(self, tr) + GetDivergence = _swig_new_instance_method(_gridfunc.GridFunction_GetDivergence) def GetCurl(self, tr, curl): r"""GetCurl(GridFunction self, ElementTransformation tr, Vector curl)""" return _gridfunc.GridFunction_GetCurl(self, tr, curl) + GetCurl = _swig_new_instance_method(_gridfunc.GridFunction_GetCurl) def GetGradient(self, tr, grad): r"""GetGradient(GridFunction self, ElementTransformation tr, Vector grad)""" return _gridfunc.GridFunction_GetGradient(self, tr, grad) + GetGradient = _swig_new_instance_method(_gridfunc.GridFunction_GetGradient) def GetGradients(self, *args): r""" @@ -274,14 +329,17 @@ def GetGradients(self, *args): GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad) """ return _gridfunc.GridFunction_GetGradients(self, *args) + GetGradients = _swig_new_instance_method(_gridfunc.GridFunction_GetGradients) def GetVectorGradient(self, tr, grad): r"""GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)""" return _gridfunc.GridFunction_GetVectorGradient(self, tr, grad) + GetVectorGradient = _swig_new_instance_method(_gridfunc.GridFunction_GetVectorGradient) def GetElementAverages(self, avgs): r"""GetElementAverages(GridFunction self, GridFunction avgs)""" return _gridfunc.GridFunction_GetElementAverages(self, avgs) + GetElementAverages = _swig_new_instance_method(_gridfunc.GridFunction_GetElementAverages) def ImposeBounds(self, *args): r""" @@ -289,10 +347,12 @@ def ImposeBounds(self, *args): ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity()) """ return _gridfunc.GridFunction_ImposeBounds(self, *args) + ImposeBounds = _swig_new_instance_method(_gridfunc.GridFunction_ImposeBounds) def ProjectGridFunction(self, src): r"""ProjectGridFunction(GridFunction self, GridFunction src)""" return _gridfunc.GridFunction_ProjectGridFunction(self, src) + ProjectGridFunction = _swig_new_instance_method(_gridfunc.GridFunction_ProjectGridFunction) def ProjectCoefficient(self, *args): r""" @@ -303,6 +363,7 @@ def ProjectCoefficient(self, *args): ProjectCoefficient(GridFunction self, mfem::Coefficient *[] coeff) """ return _gridfunc.GridFunction_ProjectCoefficient(self, *args) + ProjectCoefficient = _swig_new_instance_method(_gridfunc.GridFunction_ProjectCoefficient) ARITHMETIC = _gridfunc.GridFunction_ARITHMETIC HARMONIC = _gridfunc.GridFunction_HARMONIC @@ -315,6 +376,7 @@ def ProjectDiscCoefficient(self, *args): ProjectDiscCoefficient(GridFunction self, VectorCoefficient coeff, mfem::GridFunction::AvgType type) """ return _gridfunc.GridFunction_ProjectDiscCoefficient(self, *args) + ProjectDiscCoefficient = _swig_new_instance_method(_gridfunc.GridFunction_ProjectDiscCoefficient) def ProjectBdrCoefficient(self, *args): r""" @@ -323,14 +385,17 @@ def ProjectBdrCoefficient(self, *args): ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr) """ return _gridfunc.GridFunction_ProjectBdrCoefficient(self, *args) + ProjectBdrCoefficient = _swig_new_instance_method(_gridfunc.GridFunction_ProjectBdrCoefficient) def ProjectBdrCoefficientNormal(self, vcoeff, bdr_attr): r"""ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)""" return _gridfunc.GridFunction_ProjectBdrCoefficientNormal(self, vcoeff, bdr_attr) + ProjectBdrCoefficientNormal = _swig_new_instance_method(_gridfunc.GridFunction_ProjectBdrCoefficientNormal) def ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr): r"""ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)""" return _gridfunc.GridFunction_ProjectBdrCoefficientTangent(self, vcoeff, bdr_attr) + ProjectBdrCoefficientTangent = _swig_new_instance_method(_gridfunc.GridFunction_ProjectBdrCoefficientTangent) def ComputeL2Error(self, *args): r""" @@ -339,10 +404,12 @@ def ComputeL2Error(self, *args): ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double """ return _gridfunc.GridFunction_ComputeL2Error(self, *args) + ComputeL2Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeL2Error) def ComputeH1Error(self, exsol, exgrad, ell_coef, Nu, norm_type): r"""ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double""" return _gridfunc.GridFunction_ComputeH1Error(self, exsol, exgrad, ell_coef, Nu, norm_type) + ComputeH1Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeH1Error) def ComputeMaxError(self, *args): r""" @@ -351,10 +418,12 @@ def ComputeMaxError(self, *args): ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double """ return _gridfunc.GridFunction_ComputeMaxError(self, *args) + ComputeMaxError = _swig_new_instance_method(_gridfunc.GridFunction_ComputeMaxError) def ComputeW11Error(self, exsol, exgrad, norm_type, elems=None, irs=0): r"""ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double""" return _gridfunc.GridFunction_ComputeW11Error(self, exsol, exgrad, norm_type, elems, irs) + ComputeW11Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeW11Error) def ComputeL1Error(self, *args): r""" @@ -362,6 +431,7 @@ def ComputeL1Error(self, *args): ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double """ return _gridfunc.GridFunction_ComputeL1Error(self, *args) + ComputeL1Error = _swig_new_instance_method(_gridfunc.GridFunction_ComputeL1Error) def ComputeLpError(self, *args): r""" @@ -369,6 +439,7 @@ def ComputeLpError(self, *args): ComputeLpError(GridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double """ return _gridfunc.GridFunction_ComputeLpError(self, *args) + ComputeLpError = _swig_new_instance_method(_gridfunc.GridFunction_ComputeLpError) def ComputeElementLpErrors(self, *args): r""" @@ -376,6 +447,7 @@ def ComputeElementLpErrors(self, *args): ComputeElementLpErrors(GridFunction self, double const p, VectorCoefficient exsol, GridFunction error, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementLpErrors(self, *args) + ComputeElementLpErrors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementLpErrors) def ComputeElementL1Errors(self, *args): r""" @@ -383,6 +455,7 @@ def ComputeElementL1Errors(self, *args): ComputeElementL1Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementL1Errors(self, *args) + ComputeElementL1Errors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementL1Errors) def ComputeElementL2Errors(self, *args): r""" @@ -390,6 +463,7 @@ def ComputeElementL2Errors(self, *args): ComputeElementL2Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementL2Errors(self, *args) + ComputeElementL2Errors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementL2Errors) def ComputeElementMaxErrors(self, *args): r""" @@ -397,10 +471,12 @@ def ComputeElementMaxErrors(self, *args): ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0) """ return _gridfunc.GridFunction_ComputeElementMaxErrors(self, *args) + ComputeElementMaxErrors = _swig_new_instance_method(_gridfunc.GridFunction_ComputeElementMaxErrors) - def ComputeFlux(self, blfi, flux, wcoef=1, subdomain=-1): - r"""ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, int wcoef=1, int subdomain=-1)""" + def ComputeFlux(self, blfi, flux, wcoef=True, subdomain=-1): + r"""ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)""" return _gridfunc.GridFunction_ComputeFlux(self, blfi, flux, wcoef, subdomain) + ComputeFlux = _swig_new_instance_method(_gridfunc.GridFunction_ComputeFlux) def Assign(self, *args): r""" @@ -409,10 +485,12 @@ def Assign(self, *args): Assign(GridFunction self, Vector v) -> GridFunction """ return _gridfunc.GridFunction_Assign(self, *args) + Assign = _swig_new_instance_method(_gridfunc.GridFunction_Assign) def Update(self): r"""Update(GridFunction self)""" return _gridfunc.GridFunction_Update(self) + Update = _swig_new_instance_method(_gridfunc.GridFunction_Update) def FESpace(self, *args): r""" @@ -420,17 +498,22 @@ def FESpace(self, *args): FESpace(GridFunction self) -> FiniteElementSpace """ return _gridfunc.GridFunction_FESpace(self, *args) + FESpace = _swig_new_instance_method(_gridfunc.GridFunction_FESpace) def SetSpace(self, f): r"""SetSpace(GridFunction self, FiniteElementSpace f)""" return _gridfunc.GridFunction_SetSpace(self, f) + SetSpace = _swig_new_instance_method(_gridfunc.GridFunction_SetSpace) def MakeRef(self, *args): r""" + MakeRef(GridFunction self, Vector base, int offset, int size) + MakeRef(GridFunction self, Vector base, int offset) MakeRef(GridFunction self, FiniteElementSpace f, double * v) MakeRef(GridFunction self, FiniteElementSpace f, Vector v, int v_offset) """ return _gridfunc.GridFunction_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_gridfunc.GridFunction_MakeRef) def MakeTRef(self, *args): r""" @@ -438,14 +521,17 @@ def MakeTRef(self, *args): MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset) """ return _gridfunc.GridFunction_MakeTRef(self, *args) + MakeTRef = _swig_new_instance_method(_gridfunc.GridFunction_MakeTRef) def SaveVTK(self, out, field_name, ref): r"""SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)""" return _gridfunc.GridFunction_SaveVTK(self, out, field_name, ref) + SaveVTK = _swig_new_instance_method(_gridfunc.GridFunction_SaveVTK) def SaveSTL(self, out, TimesToRefine=1): r"""SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)""" return _gridfunc.GridFunction_SaveSTL(self, out, TimesToRefine) + SaveSTL = _swig_new_instance_method(_gridfunc.GridFunction_SaveSTL) __swig_destroy__ = _gridfunc.delete_GridFunction def __init__(self, *args): @@ -464,10 +550,12 @@ def __init__(self, *args): def SaveToFile(self, gf_file, precision): r"""SaveToFile(GridFunction self, char const * gf_file, int const precision)""" return _gridfunc.GridFunction_SaveToFile(self, gf_file, precision) + SaveToFile = _swig_new_instance_method(_gridfunc.GridFunction_SaveToFile) def iadd(self, c): r"""iadd(GridFunction self, GridFunction c) -> GridFunction""" return _gridfunc.GridFunction_iadd(self, c) + iadd = _swig_new_instance_method(_gridfunc.GridFunction_iadd) def isub(self, *args): r""" @@ -475,14 +563,17 @@ def isub(self, *args): isub(GridFunction self, double c) -> GridFunction """ return _gridfunc.GridFunction_isub(self, *args) + isub = _swig_new_instance_method(_gridfunc.GridFunction_isub) def imul(self, c): r"""imul(GridFunction self, double c) -> GridFunction""" return _gridfunc.GridFunction_imul(self, c) + imul = _swig_new_instance_method(_gridfunc.GridFunction_imul) def idiv(self, c): r"""idiv(GridFunction self, double c) -> GridFunction""" return _gridfunc.GridFunction_idiv(self, c) + idiv = _swig_new_instance_method(_gridfunc.GridFunction_idiv) def Save(self, *args): r""" @@ -490,6 +581,7 @@ def Save(self, *args): Save(GridFunction self, char const * file, int precision=8) """ return _gridfunc.GridFunction_Save(self, *args) + Save = _swig_new_instance_method(_gridfunc.GridFunction_Save) # Register GridFunction in _gridfunc: _gridfunc.GridFunction_swigregister(GridFunction) @@ -514,6 +606,7 @@ def __init__(self, *args): def GetSpace(self): r"""GetSpace(QuadratureFunction self) -> QuadratureSpace""" return _gridfunc.QuadratureFunction_GetSpace(self) + GetSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetSpace) def SetSpace(self, *args): r""" @@ -521,26 +614,32 @@ def SetSpace(self, *args): SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1) """ return _gridfunc.QuadratureFunction_SetSpace(self, *args) + SetSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_SetSpace) def GetVDim(self): r"""GetVDim(QuadratureFunction self) -> int""" return _gridfunc.QuadratureFunction_GetVDim(self) + GetVDim = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetVDim) def SetVDim(self, vdim_): r"""SetVDim(QuadratureFunction self, int vdim_)""" return _gridfunc.QuadratureFunction_SetVDim(self, vdim_) + SetVDim = _swig_new_instance_method(_gridfunc.QuadratureFunction_SetVDim) def OwnsSpace(self): r"""OwnsSpace(QuadratureFunction self) -> bool""" return _gridfunc.QuadratureFunction_OwnsSpace(self) + OwnsSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_OwnsSpace) def SetOwnsSpace(self, own): r"""SetOwnsSpace(QuadratureFunction self, bool own)""" return _gridfunc.QuadratureFunction_SetOwnsSpace(self, own) + SetOwnsSpace = _swig_new_instance_method(_gridfunc.QuadratureFunction_SetOwnsSpace) def GetElementIntRule(self, idx): r"""GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule""" return _gridfunc.QuadratureFunction_GetElementIntRule(self, idx) + GetElementIntRule = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetElementIntRule) def GetElementValues(self, *args): r""" @@ -550,6 +649,7 @@ def GetElementValues(self, *args): GetElementValues(QuadratureFunction self, int idx, DenseMatrix values) """ return _gridfunc.QuadratureFunction_GetElementValues(self, *args) + GetElementValues = _swig_new_instance_method(_gridfunc.QuadratureFunction_GetElementValues) def Save(self, *args): r""" @@ -557,6 +657,7 @@ def Save(self, *args): Save(QuadratureFunction self, char const * file, int precision=8) """ return _gridfunc.QuadratureFunction_Save(self, *args) + Save = _swig_new_instance_method(_gridfunc.QuadratureFunction_Save) # Register QuadratureFunction in _gridfunc: _gridfunc.QuadratureFunction_swigregister(QuadratureFunction) @@ -569,14 +670,17 @@ def __lshift__(*args): __lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream & """ return _gridfunc.__lshift__(*args) +__lshift__ = _gridfunc.__lshift__ -def ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags=None, with_subdomains=1): - r"""ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1) -> double""" - return _gridfunc.ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags, with_subdomains) +def ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags=None, with_subdomains=1, with_coeff=False): + r"""ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double""" + return _gridfunc.ZZErrorEstimator(blfi, u, flux, error_estimates, aniso_flags, with_subdomains, with_coeff) +ZZErrorEstimator = _gridfunc.ZZErrorEstimator def ComputeElementLpDistance(p, i, gf1, gf2): r"""ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double""" return _gridfunc.ComputeElementLpDistance(p, i, gf1, gf2) +ComputeElementLpDistance = _gridfunc.ComputeElementLpDistance class ExtrudeCoefficient(mfem._ser.coefficient.Coefficient): r"""Proxy of C++ mfem::ExtrudeCoefficient class.""" @@ -590,6 +694,7 @@ def __init__(self, m, s, _n): def Eval(self, T, ip): r"""Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double""" return _gridfunc.ExtrudeCoefficient_Eval(self, T, ip) + Eval = _swig_new_instance_method(_gridfunc.ExtrudeCoefficient_Eval) __swig_destroy__ = _gridfunc.delete_ExtrudeCoefficient # Register ExtrudeCoefficient in _gridfunc: @@ -599,6 +704,7 @@ def Eval(self, T, ip): def Extrude1DGridFunction(mesh, mesh2d, sol, ny): r"""Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction""" return _gridfunc.Extrude1DGridFunction(mesh, mesh2d, sol, ny) +Extrude1DGridFunction = _gridfunc.Extrude1DGridFunction def __iadd__(self, v): ret = _gridfunc.GridFunction_iadd(self, v) diff --git a/mfem/_ser/gridfunc_wrap.cxx b/mfem/_ser/gridfunc_wrap.cxx index 0ed70723..c33ddabe 100644 --- a/mfem/_ser/gridfunc_wrap.cxx +++ b/mfem/_ser/gridfunc_wrap.cxx @@ -3066,200 +3066,203 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_double swig_types[2] -#define SWIGTYPE_p_doublep swig_types[3] -#define SWIGTYPE_p_hex_t swig_types[4] -#define SWIGTYPE_p_int swig_types[5] -#define SWIGTYPE_p_intp swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[10] -#define SWIGTYPE_p_mfem__Coefficient swig_types[11] -#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[12] -#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[13] -#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[14] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[16] -#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[17] -#define SWIGTYPE_p_mfem__CubicFECollection swig_types[18] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[19] -#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[20] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[21] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[22] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[23] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[24] -#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[25] -#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[26] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[27] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[29] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[31] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[32] -#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[33] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[34] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[35] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[36] -#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[37] -#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[38] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[39] -#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[40] -#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[41] -#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[42] -#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[43] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[44] -#define SWIGTYPE_p_mfem__GridFunction swig_types[45] -#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[46] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[47] -#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[48] -#define SWIGTYPE_p_mfem__H1_FECollection swig_types[49] -#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[50] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[51] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[52] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[53] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[54] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[56] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[57] -#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[58] -#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[59] -#define SWIGTYPE_p_mfem__LinearFECollection swig_types[60] -#define SWIGTYPE_p_mfem__LinearForm swig_types[61] -#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[62] -#define SWIGTYPE_p_mfem__Local_FECollection swig_types[63] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[66] -#define SWIGTYPE_p_mfem__Mesh swig_types[67] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[74] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[75] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[76] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[77] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[78] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[79] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[80] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[82] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[83] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[86] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[90] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[93] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[94] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[95] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[96] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[97] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[98] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[99] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[100] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[101] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[102] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[103] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[104] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[105] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[106] -#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[107] -#define SWIGTYPE_p_mfem__ND_FECollection swig_types[108] -#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[109] -#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[110] -#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[111] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[112] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[113] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[114] -#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[115] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[116] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[117] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[118] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[119] -#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[120] -#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[121] -#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[122] -#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[123] -#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[124] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[125] -#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[126] -#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[127] -#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[128] -#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[129] -#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[130] -#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[131] -#define SWIGTYPE_p_mfem__RT_FECollection swig_types[132] -#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[133] -#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[134] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[135] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[136] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[137] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[138] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[139] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[140] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[141] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[142] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[143] -#define SWIGTYPE_p_mfem__Vector swig_types[144] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[145] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[146] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[147] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[148] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[149] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[150] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[151] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[152] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[153] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[154] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[155] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[156] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[157] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[158] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[159] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[160] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[161] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[162] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[163] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[164] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[165] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[166] -#define SWIGTYPE_p_p_mfem__Coefficient swig_types[167] -#define SWIGTYPE_p_p_mfem__ConstantCoefficient swig_types[168] -#define SWIGTYPE_p_p_mfem__DeltaCoefficient swig_types[169] -#define SWIGTYPE_p_p_mfem__DeterminantCoefficient swig_types[170] -#define SWIGTYPE_p_p_mfem__DivergenceGridFunctionCoefficient swig_types[171] -#define SWIGTYPE_p_p_mfem__ExtrudeCoefficient swig_types[172] -#define SWIGTYPE_p_p_mfem__FunctionCoefficient swig_types[173] -#define SWIGTYPE_p_p_mfem__GridFunction swig_types[174] -#define SWIGTYPE_p_p_mfem__GridFunctionCoefficient swig_types[175] -#define SWIGTYPE_p_p_mfem__InnerProductCoefficient swig_types[176] -#define SWIGTYPE_p_p_mfem__PWConstCoefficient swig_types[177] -#define SWIGTYPE_p_p_mfem__PowerCoefficient swig_types[178] -#define SWIGTYPE_p_p_mfem__ProductCoefficient swig_types[179] -#define SWIGTYPE_p_p_mfem__PyCoefficientBase swig_types[180] -#define SWIGTYPE_p_p_mfem__RestrictedCoefficient swig_types[181] -#define SWIGTYPE_p_p_mfem__SumCoefficient swig_types[182] -#define SWIGTYPE_p_p_mfem__TransformedCoefficient swig_types[183] -#define SWIGTYPE_p_p_mfem__VectorRotProductCoefficient swig_types[184] -#define SWIGTYPE_p_pri_t swig_types[185] -#define SWIGTYPE_p_quad_t swig_types[186] -#define SWIGTYPE_p_seg_t swig_types[187] -#define SWIGTYPE_p_std__istream swig_types[188] -#define SWIGTYPE_p_std__ostream swig_types[189] -#define SWIGTYPE_p_std__string swig_types[190] -#define SWIGTYPE_p_tet_t swig_types[191] -#define SWIGTYPE_p_tri_t swig_types[192] -static swig_type_info *swig_types[194]; -static swig_module_info swig_module = {swig_types, 193, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_double swig_types[3] +#define SWIGTYPE_p_doublep swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_intp swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[10] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[11] +#define SWIGTYPE_p_mfem__Coefficient swig_types[12] +#define SWIGTYPE_p_mfem__Const2DFECollection swig_types[13] +#define SWIGTYPE_p_mfem__Const3DFECollection swig_types[14] +#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[15] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFECollection swig_types[17] +#define SWIGTYPE_p_mfem__CubicDiscont2DFECollection swig_types[18] +#define SWIGTYPE_p_mfem__CubicFECollection swig_types[19] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[21] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[22] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[23] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[24] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[25] +#define SWIGTYPE_p_mfem__DG_Interface_FECollection swig_types[26] +#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[27] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[28] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[29] +#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[30] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[32] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[34] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[35] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[36] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[37] +#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[38] +#define SWIGTYPE_p_mfem__FiniteElementCollection swig_types[39] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[40] +#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[41] +#define SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection swig_types[42] +#define SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection swig_types[43] +#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[44] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[45] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[46] +#define SWIGTYPE_p_mfem__GridFunction swig_types[47] +#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[48] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[49] +#define SWIGTYPE_p_mfem__H1Pos_FECollection swig_types[50] +#define SWIGTYPE_p_mfem__H1Ser_FECollection swig_types[51] +#define SWIGTYPE_p_mfem__H1_FECollection swig_types[52] +#define SWIGTYPE_p_mfem__H1_Trace_FECollection swig_types[53] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[54] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[55] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[56] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[57] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[59] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[60] +#define SWIGTYPE_p_mfem__LinearDiscont2DFECollection swig_types[61] +#define SWIGTYPE_p_mfem__LinearDiscont3DFECollection swig_types[62] +#define SWIGTYPE_p_mfem__LinearFECollection swig_types[63] +#define SWIGTYPE_p_mfem__LinearForm swig_types[64] +#define SWIGTYPE_p_mfem__LinearNonConf3DFECollection swig_types[65] +#define SWIGTYPE_p_mfem__Local_FECollection swig_types[66] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[69] +#define SWIGTYPE_p_mfem__Mesh swig_types[70] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[74] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[76] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[77] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[78] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[79] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[80] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[81] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[84] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[85] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[91] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[93] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[95] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[96] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[97] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[98] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[99] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[100] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[101] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[102] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[103] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[104] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[105] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[106] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[107] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[108] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[109] +#define SWIGTYPE_p_mfem__ND1_3DFECollection swig_types[110] +#define SWIGTYPE_p_mfem__ND_FECollection swig_types[111] +#define SWIGTYPE_p_mfem__ND_Trace_FECollection swig_types[112] +#define SWIGTYPE_p_mfem__NURBSFECollection swig_types[113] +#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[114] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[115] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[116] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[117] +#define SWIGTYPE_p_mfem__P1OnQuadFECollection swig_types[118] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[119] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[120] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[121] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[122] +#define SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection swig_types[123] +#define SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection swig_types[124] +#define SWIGTYPE_p_mfem__QuadraticFECollection swig_types[125] +#define SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection swig_types[126] +#define SWIGTYPE_p_mfem__QuadraticPosFECollection swig_types[127] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[128] +#define SWIGTYPE_p_mfem__QuadratureSpace swig_types[129] +#define SWIGTYPE_p_mfem__RT0_2DFECollection swig_types[130] +#define SWIGTYPE_p_mfem__RT0_3DFECollection swig_types[131] +#define SWIGTYPE_p_mfem__RT1_2DFECollection swig_types[132] +#define SWIGTYPE_p_mfem__RT1_3DFECollection swig_types[133] +#define SWIGTYPE_p_mfem__RT2_2DFECollection swig_types[134] +#define SWIGTYPE_p_mfem__RT_FECollection swig_types[135] +#define SWIGTYPE_p_mfem__RT_Trace_FECollection swig_types[136] +#define SWIGTYPE_p_mfem__RefinedLinearFECollection swig_types[137] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[138] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[139] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[141] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[142] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[143] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[144] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[145] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[146] +#define SWIGTYPE_p_mfem__Vector swig_types[147] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[148] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[149] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[150] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[151] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[152] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[153] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[154] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[155] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[156] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[157] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[158] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[159] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[160] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[161] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[162] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[163] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[164] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[165] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[166] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[167] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[168] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[169] +#define SWIGTYPE_p_p_mfem__Coefficient swig_types[170] +#define SWIGTYPE_p_p_mfem__ConstantCoefficient swig_types[171] +#define SWIGTYPE_p_p_mfem__DeltaCoefficient swig_types[172] +#define SWIGTYPE_p_p_mfem__DeterminantCoefficient swig_types[173] +#define SWIGTYPE_p_p_mfem__DivergenceGridFunctionCoefficient swig_types[174] +#define SWIGTYPE_p_p_mfem__ExtrudeCoefficient swig_types[175] +#define SWIGTYPE_p_p_mfem__FunctionCoefficient swig_types[176] +#define SWIGTYPE_p_p_mfem__GridFunction swig_types[177] +#define SWIGTYPE_p_p_mfem__GridFunctionCoefficient swig_types[178] +#define SWIGTYPE_p_p_mfem__InnerProductCoefficient swig_types[179] +#define SWIGTYPE_p_p_mfem__PWConstCoefficient swig_types[180] +#define SWIGTYPE_p_p_mfem__PowerCoefficient swig_types[181] +#define SWIGTYPE_p_p_mfem__ProductCoefficient swig_types[182] +#define SWIGTYPE_p_p_mfem__PyCoefficientBase swig_types[183] +#define SWIGTYPE_p_p_mfem__RestrictedCoefficient swig_types[184] +#define SWIGTYPE_p_p_mfem__SumCoefficient swig_types[185] +#define SWIGTYPE_p_p_mfem__TransformedCoefficient swig_types[186] +#define SWIGTYPE_p_p_mfem__VectorRotProductCoefficient swig_types[187] +#define SWIGTYPE_p_pri_t swig_types[188] +#define SWIGTYPE_p_quad_t swig_types[189] +#define SWIGTYPE_p_seg_t swig_types[190] +#define SWIGTYPE_p_std__istream swig_types[191] +#define SWIGTYPE_p_std__ostream swig_types[192] +#define SWIGTYPE_p_std__string swig_types[193] +#define SWIGTYPE_p_tet_t swig_types[194] +#define SWIGTYPE_p_tri_t swig_types[195] +static swig_type_info *swig_types[197]; +static swig_module_info swig_module = {swig_types, 196, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3581,6 +3584,20 @@ SWIGINTERN doublep *doublep_frompointer(double *t){ return (doublep *) t; } +SWIGINTERN int +SWIG_AsVal_bool (PyObject *obj, bool *val) +{ + int r; + if (!PyBool_Check(obj)) + return SWIG_ERROR; + r = PyObject_IsTrue(obj); + if (r == -1) + return SWIG_ERROR; + if (val) *val = r ? true : false; + return SWIG_OK; +} + + SWIGINTERN swig_type_info* SWIG_pchar_descriptor(void) { @@ -3762,20 +3779,6 @@ SWIGINTERNINLINE PyObject* return PyBool_FromLong(value ? 1 : 0); } - -SWIGINTERN int -SWIG_AsVal_bool (PyObject *obj, bool *val) -{ - int r; - if (!PyBool_Check(obj)) - return SWIG_ERROR; - r = PyObject_IsTrue(obj); - if (r == -1) - return SWIG_ERROR; - if (val) *val = r ? true : false; - return SWIG_OK; -} - SWIGINTERN void mfem_QuadratureFunction_Save__SWIG_1(mfem::QuadratureFunction *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) @@ -5670,29 +5673,24 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; - int arg7 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -5701,45 +5699,98 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_0(PyObject *SWIGUNUS }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); - } - arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + { + try { + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6,arg7); + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5756,35 +5807,34 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -5793,39 +5843,39 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_1(PyObject *SWIGUNUS }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5842,64 +5892,949 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetFaceValues", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetFaceValues__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetLaplacians", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_3(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetLaplacians'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetHessians", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetHessians__SWIG_3(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetHessians__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetHessians'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + int arg3 ; + mfem::IntegrationRule *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + int arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + int result; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + } + arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(swig_obj[6]); + } + { + try { + result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6,arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + int arg3 ; + mfem::IntegrationRule *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + int result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + } + arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + { + try { + result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetFaceValues", 0, 7, argv))) SWIG_fail; + --argc; + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetFaceValues__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } if (argc == 7) { int _v; void *vptr = 0; @@ -13735,7 +14670,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSED mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - int arg4 ; + bool arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -13743,6 +14678,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); @@ -13766,12 +14703,11 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -13809,13 +14745,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNUSED mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - int arg4 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); @@ -13835,16 +14773,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNUSED if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { try { (arg1)->ComputeFlux(*arg2,*arg3,arg4); @@ -13973,12 +14910,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *ar _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { return _wrap_GridFunction_ComputeFlux__SWIG_1(self, argc, argv); @@ -14002,12 +14935,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *ar _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { { @@ -14030,8 +14959,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *ar fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeFlux'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,int,int)\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,int)\n" + " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool,int)\n" + " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool)\n" " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &)\n"); return 0; } @@ -14398,7 +15327,120 @@ SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -14452,7 +15494,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -14524,6 +15566,30 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_MakeRef", 0, 4, argv))) SWIG_fail; --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_MakeRef__SWIG_0_1(self, argc, argv); + } + } + } + } if (argc == 3) { int _v; void *vptr = 0; @@ -14538,7 +15604,41 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_0(self, argc, argv); + return _wrap_GridFunction_MakeRef__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_MakeRef__SWIG_0_0(self, argc, argv); + } } } } @@ -14566,7 +15666,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_1(self, argc, argv); + return _wrap_GridFunction_MakeRef__SWIG_2(self, argc, argv); } } } @@ -14576,6 +15676,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_MakeRef'.\n" " Possible C/C++ prototypes are:\n" + " MakeRef(mfem::Vector &,int,int)\n" + " MakeRef(mfem::Vector &,int)\n" " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,double *)\n" " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,mfem::Vector &,int)\n"); return 0; @@ -17759,33 +18861,131 @@ SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { } } } - if (argc == 2) { - int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap___lshift____SWIG_2(self, argc, argv); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = 0 ; + mfem::GridFunction *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; + int arg6 ; + bool arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool val7 ; + int ecode7 = 0 ; + double result; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); + } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ZZErrorEstimator" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + { + try { + result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7); } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap___lshift____SWIG_2(self, argc, argv); - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + return NULL; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; @@ -17875,7 +19075,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; @@ -17958,7 +19158,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; @@ -18035,11 +19235,11 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "ZZErrorEstimator", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "ZZErrorEstimator", 0, 7, argv))) SWIG_fail; --argc; if (argc == 4) { int _v; @@ -18059,7 +19259,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ZZErrorEstimator__SWIG_2(self, argc, argv); + return _wrap_ZZErrorEstimator__SWIG_3(self, argc, argv); } } } @@ -18087,7 +19287,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ZZErrorEstimator__SWIG_1(self, argc, argv); + return _wrap_ZZErrorEstimator__SWIG_2(self, argc, argv); } } } @@ -18125,7 +19325,52 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_ZZErrorEstimator__SWIG_0(self, argc, argv); + return _wrap_ZZErrorEstimator__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_ZZErrorEstimator__SWIG_0(self, argc, argv); + } } } } @@ -18137,6 +19382,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZZErrorEstimator'.\n" " Possible C/C++ prototypes are:\n" + " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int,bool)\n" " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int)\n" " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *)\n" " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &)\n"); @@ -18449,6 +19695,7 @@ SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, @@ -18482,6 +19729,14 @@ static PyMethodDef SwigMethods[] = { "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" ""}, + { "GridFunction_GetLaplacians", _wrap_GridFunction_GetLaplacians, METH_VARARGS, "\n" + "GridFunction_GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, int vdim=1)\n" + "GridFunction_GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetHessians", _wrap_GridFunction_GetHessians, METH_VARARGS, "\n" + "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" + "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" + ""}, { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GridFunction_GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" "GridFunction_GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" @@ -18568,7 +19823,7 @@ static PyMethodDef SwigMethods[] = { "GridFunction_ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" "GridFunction_ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" ""}, - { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, int wcoef=1, int subdomain=-1)"}, + { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" "GridFunction_Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" "GridFunction_Assign(GridFunction self, double value) -> GridFunction\n" @@ -18581,6 +19836,8 @@ static PyMethodDef SwigMethods[] = { ""}, { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "GridFunction_SetSpace(GridFunction self, FiniteElementSpace f)"}, { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" + "GridFunction_MakeRef(GridFunction self, Vector base, int offset, int size)\n" + "GridFunction_MakeRef(GridFunction self, Vector base, int offset)\n" "GridFunction_MakeRef(GridFunction self, FiniteElementSpace f, double * v)\n" "GridFunction_MakeRef(GridFunction self, FiniteElementSpace f, Vector v, int v_offset)\n" ""}, @@ -18650,7 +19907,7 @@ static PyMethodDef SwigMethods[] = { "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" ""}, - { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1) -> double"}, + { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "ExtrudeCoefficient_Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, @@ -18662,6 +19919,227 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, + { "delete_intp", _wrap_delete_intp, METH_O, NULL}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_value", _wrap_intp_value, METH_O, NULL}, + { "intp_cast", _wrap_intp_cast, METH_O, NULL}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, + { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_value", _wrap_doublep_value, METH_O, NULL}, + { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "GridFunction_MakeOwner", _wrap_GridFunction_MakeOwner, METH_VARARGS, "MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, + { "GridFunction_OwnFEC", _wrap_GridFunction_OwnFEC, METH_O, "OwnFEC(GridFunction self) -> FiniteElementCollection"}, + { "GridFunction_VectorDim", _wrap_GridFunction_VectorDim, METH_O, "VectorDim(GridFunction self) -> int"}, + { "GridFunction_GetTrueVector", _wrap_GridFunction_GetTrueVector, METH_VARARGS, "\n" + "GetTrueVector(GridFunction self) -> Vector\n" + "GetTrueVector(GridFunction self) -> Vector\n" + ""}, + { "GridFunction_GetTrueDofs", _wrap_GridFunction_GetTrueDofs, METH_VARARGS, "GetTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetTrueVector", _wrap_GridFunction_SetTrueVector, METH_O, "SetTrueVector(GridFunction self)"}, + { "GridFunction_SetFromTrueDofs", _wrap_GridFunction_SetFromTrueDofs, METH_VARARGS, "SetFromTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetFromTrueVector", _wrap_GridFunction_SetFromTrueVector, METH_O, "SetFromTrueVector(GridFunction self)"}, + { "GridFunction_GetValue", _wrap_GridFunction_GetValue, METH_VARARGS, "GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, + { "GridFunction_GetVectorValue", _wrap_GridFunction_GetVectorValue, METH_VARARGS, "GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, + { "GridFunction_GetValues", _wrap_GridFunction_GetValues, METH_VARARGS, "\n" + "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" + "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetLaplacians", _wrap_GridFunction_GetLaplacians, METH_VARARGS, "\n" + "GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, int vdim=1)\n" + "GetLaplacians(GridFunction self, int i, IntegrationRule ir, Vector laps, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetHessians", _wrap_GridFunction_GetHessians, METH_VARARGS, "\n" + "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" + "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" + ""}, + { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, + { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" + "GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" + "GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr)\n" + ""}, + { "GridFunction_GetFaceVectorValues", _wrap_GridFunction_GetFaceVectorValues, METH_VARARGS, "GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, + { "GridFunction_GetValuesFrom", _wrap_GridFunction_GetValuesFrom, METH_VARARGS, "GetValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetBdrValuesFrom", _wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS, "GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetVectorFieldValues", _wrap_GridFunction_GetVectorFieldValues, METH_VARARGS, "GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, + { "GridFunction_ReorderByNodes", _wrap_GridFunction_ReorderByNodes, METH_O, "ReorderByNodes(GridFunction self)"}, + { "GridFunction_GetNodalValues", _wrap_GridFunction_GetNodalValues, METH_VARARGS, "\n" + "GetNodalValues(GridFunction self, int i, doubleArray nval, int vdim=1)\n" + "GetNodalValues(GridFunction self, Vector nval, int vdim=1)\n" + ""}, + { "GridFunction_GetVectorFieldNodalValues", _wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS, "GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, + { "GridFunction_ProjectVectorFieldOn", _wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS, "ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, + { "GridFunction_GetDerivative", _wrap_GridFunction_GetDerivative, METH_VARARGS, "GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, + { "GridFunction_GetDivergence", _wrap_GridFunction_GetDivergence, METH_VARARGS, "GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, + { "GridFunction_GetCurl", _wrap_GridFunction_GetCurl, METH_VARARGS, "GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, + { "GridFunction_GetGradient", _wrap_GridFunction_GetGradient, METH_VARARGS, "GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, + { "GridFunction_GetGradients", _wrap_GridFunction_GetGradients, METH_VARARGS, "\n" + "GetGradients(GridFunction self, ElementTransformation tr, IntegrationRule ir, DenseMatrix grad)\n" + "GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad)\n" + ""}, + { "GridFunction_GetVectorGradient", _wrap_GridFunction_GetVectorGradient, METH_VARARGS, "GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, + { "GridFunction_GetElementAverages", _wrap_GridFunction_GetElementAverages, METH_VARARGS, "GetElementAverages(GridFunction self, GridFunction avgs)"}, + { "GridFunction_ImposeBounds", _wrap_GridFunction_ImposeBounds, METH_VARARGS, "\n" + "ImposeBounds(GridFunction self, int i, Vector weights, Vector _lo, Vector _hi)\n" + "ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity())\n" + ""}, + { "GridFunction_ProjectGridFunction", _wrap_GridFunction_ProjectGridFunction, METH_VARARGS, "ProjectGridFunction(GridFunction self, GridFunction src)"}, + { "GridFunction_ProjectCoefficient", _wrap_GridFunction_ProjectCoefficient, METH_VARARGS, "\n" + "ProjectCoefficient(GridFunction self, Coefficient coeff)\n" + "ProjectCoefficient(GridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" + "ProjectCoefficient(GridFunction self, VectorCoefficient vcoeff)\n" + "ProjectCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray dofs)\n" + "ProjectCoefficient(GridFunction self, mfem::Coefficient *[] coeff)\n" + ""}, + { "GridFunction_ProjectDiscCoefficient", _wrap_GridFunction_ProjectDiscCoefficient, METH_VARARGS, "\n" + "ProjectDiscCoefficient(GridFunction self, VectorCoefficient coeff)\n" + "ProjectDiscCoefficient(GridFunction self, Coefficient coeff, mfem::GridFunction::AvgType type)\n" + "ProjectDiscCoefficient(GridFunction self, VectorCoefficient coeff, mfem::GridFunction::AvgType type)\n" + ""}, + { "GridFunction_ProjectBdrCoefficient", _wrap_GridFunction_ProjectBdrCoefficient, METH_VARARGS, "\n" + "ProjectBdrCoefficient(GridFunction self, Coefficient coeff, intArray attr)\n" + "ProjectBdrCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray attr)\n" + "ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" + ""}, + { "GridFunction_ProjectBdrCoefficientNormal", _wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS, "ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientTangent", _wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ComputeL2Error", _wrap_GridFunction_ComputeL2Error, METH_VARARGS, "\n" + "ComputeL2Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL2Error(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double\n" + ""}, + { "GridFunction_ComputeH1Error", _wrap_GridFunction_ComputeH1Error, METH_VARARGS, "ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, + { "GridFunction_ComputeMaxError", _wrap_GridFunction_ComputeMaxError, METH_VARARGS, "\n" + "ComputeMaxError(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeMaxError(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "GridFunction_ComputeW11Error", _wrap_GridFunction_ComputeW11Error, METH_VARARGS, "ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, + { "GridFunction_ComputeL1Error", _wrap_GridFunction_ComputeL1Error, METH_VARARGS, "\n" + "ComputeL1Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "GridFunction_ComputeLpError", _wrap_GridFunction_ComputeLpError, METH_VARARGS, "\n" + "ComputeLpError(GridFunction self, double const p, Coefficient exsol, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" + "ComputeLpError(GridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" + ""}, + { "GridFunction_ComputeElementLpErrors", _wrap_GridFunction_ComputeElementLpErrors, METH_VARARGS, "\n" + "ComputeElementLpErrors(GridFunction self, double const p, Coefficient exsol, GridFunction error, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementLpErrors(GridFunction self, double const p, VectorCoefficient exsol, GridFunction error, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeElementL1Errors", _wrap_GridFunction_ComputeElementL1Errors, METH_VARARGS, "\n" + "ComputeElementL1Errors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementL1Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeElementL2Errors", _wrap_GridFunction_ComputeElementL2Errors, METH_VARARGS, "\n" + "ComputeElementL2Errors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementL2Errors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeElementMaxErrors", _wrap_GridFunction_ComputeElementMaxErrors, METH_VARARGS, "\n" + "ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + "ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" + ""}, + { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" + "Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" + "Assign(GridFunction self, double value) -> GridFunction\n" + "Assign(GridFunction self, Vector v) -> GridFunction\n" + ""}, + { "GridFunction_Update", _wrap_GridFunction_Update, METH_O, "Update(GridFunction self)"}, + { "GridFunction_FESpace", _wrap_GridFunction_FESpace, METH_VARARGS, "\n" + "FESpace(GridFunction self) -> FiniteElementSpace\n" + "FESpace(GridFunction self) -> FiniteElementSpace\n" + ""}, + { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "SetSpace(GridFunction self, FiniteElementSpace f)"}, + { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" + "MakeRef(GridFunction self, Vector base, int offset, int size)\n" + "MakeRef(GridFunction self, Vector base, int offset)\n" + "MakeRef(GridFunction self, FiniteElementSpace f, double * v)\n" + "MakeRef(GridFunction self, FiniteElementSpace f, Vector v, int v_offset)\n" + ""}, + { "GridFunction_MakeTRef", _wrap_GridFunction_MakeTRef, METH_VARARGS, "\n" + "MakeTRef(GridFunction self, FiniteElementSpace f, double * tv)\n" + "MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset)\n" + ""}, + { "GridFunction_SaveVTK", _wrap_GridFunction_SaveVTK, METH_VARARGS, "SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, + { "GridFunction_SaveSTL", _wrap_GridFunction_SaveSTL, METH_VARARGS, "SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, + { "delete_GridFunction", _wrap_delete_GridFunction, METH_O, "delete_GridFunction(GridFunction self)"}, + { "new_GridFunction", _wrap_new_GridFunction, METH_VARARGS, "\n" + "GridFunction()\n" + "GridFunction(GridFunction orig)\n" + "GridFunction(FiniteElementSpace f)\n" + "GridFunction(FiniteElementSpace f, double * data)\n" + "GridFunction(Mesh m, std::istream & input)\n" + "GridFunction(Mesh m, mfem::GridFunction *[] gf_array, int num_pieces)\n" + "GridFunction(Mesh m, char const * grid_file)\n" + "new_GridFunction(FiniteElementSpace fes, Vector v, int offset) -> GridFunction\n" + ""}, + { "GridFunction_SaveToFile", _wrap_GridFunction_SaveToFile, METH_VARARGS, "SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, + { "GridFunction_iadd", _wrap_GridFunction_iadd, METH_VARARGS, "iadd(GridFunction self, GridFunction c) -> GridFunction"}, + { "GridFunction_isub", _wrap_GridFunction_isub, METH_VARARGS, "\n" + "isub(GridFunction self, GridFunction c) -> GridFunction\n" + "isub(GridFunction self, double c) -> GridFunction\n" + ""}, + { "GridFunction_imul", _wrap_GridFunction_imul, METH_VARARGS, "imul(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_idiv", _wrap_GridFunction_idiv, METH_VARARGS, "idiv(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_Save", _wrap_GridFunction_Save, METH_VARARGS, "\n" + "Save(GridFunction self, std::ostream & out)\n" + "Save(GridFunction self, char const * file, int precision=8)\n" + ""}, + { "GridFunction_swigregister", GridFunction_swigregister, METH_O, NULL}, + { "GridFunction_swiginit", GridFunction_swiginit, METH_VARARGS, NULL}, + { "new_QuadratureFunction", _wrap_new_QuadratureFunction, METH_VARARGS, "\n" + "QuadratureFunction()\n" + "QuadratureFunction(QuadratureFunction orig)\n" + "QuadratureFunction(QuadratureSpace qspace_, int vdim_=1)\n" + "QuadratureFunction(QuadratureSpace qspace_, double * qf_data, int vdim_=1)\n" + "new_QuadratureFunction(Mesh mesh, std::istream & _in) -> QuadratureFunction\n" + ""}, + { "delete_QuadratureFunction", _wrap_delete_QuadratureFunction, METH_O, "delete_QuadratureFunction(QuadratureFunction self)"}, + { "QuadratureFunction_GetSpace", _wrap_QuadratureFunction_GetSpace, METH_O, "GetSpace(QuadratureFunction self) -> QuadratureSpace"}, + { "QuadratureFunction_SetSpace", _wrap_QuadratureFunction_SetSpace, METH_VARARGS, "\n" + "SetSpace(QuadratureFunction self, QuadratureSpace qspace_, int vdim_=-1)\n" + "SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1)\n" + ""}, + { "QuadratureFunction_GetVDim", _wrap_QuadratureFunction_GetVDim, METH_O, "GetVDim(QuadratureFunction self) -> int"}, + { "QuadratureFunction_SetVDim", _wrap_QuadratureFunction_SetVDim, METH_VARARGS, "SetVDim(QuadratureFunction self, int vdim_)"}, + { "QuadratureFunction_OwnsSpace", _wrap_QuadratureFunction_OwnsSpace, METH_O, "OwnsSpace(QuadratureFunction self) -> bool"}, + { "QuadratureFunction_SetOwnsSpace", _wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS, "SetOwnsSpace(QuadratureFunction self, bool own)"}, + { "QuadratureFunction_GetElementIntRule", _wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, + { "QuadratureFunction_GetElementValues", _wrap_QuadratureFunction_GetElementValues, METH_VARARGS, "\n" + "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" + "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" + "GetElementValues(QuadratureFunction self, int idx, DenseMatrix values)\n" + "GetElementValues(QuadratureFunction self, int idx, DenseMatrix values)\n" + ""}, + { "QuadratureFunction_Save", _wrap_QuadratureFunction_Save, METH_VARARGS, "\n" + "Save(QuadratureFunction self, std::ostream & out)\n" + "Save(QuadratureFunction self, char const * file, int precision=8)\n" + ""}, + { "QuadratureFunction_swigregister", QuadratureFunction_swigregister, METH_O, NULL}, + { "QuadratureFunction_swiginit", QuadratureFunction_swiginit, METH_VARARGS, NULL}, + { "__lshift__", _wrap___lshift__, METH_VARARGS, "\n" + "__lshift__(std::ostream & out, Mesh mesh) -> std::ostream\n" + "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" + "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" + ""}, + { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, + { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, + { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, + { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "delete_ExtrudeCoefficient", _wrap_delete_ExtrudeCoefficient, METH_O, "delete_ExtrudeCoefficient(ExtrudeCoefficient self)"}, + { "ExtrudeCoefficient_swigregister", ExtrudeCoefficient_swigregister, METH_O, NULL}, + { "ExtrudeCoefficient_swiginit", ExtrudeCoefficient_swiginit, METH_VARARGS, NULL}, + { "Extrude1DGridFunction", _wrap_Extrude1DGridFunction, METH_VARARGS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, { NULL, NULL, 0, NULL } }; @@ -18734,6 +20212,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -18863,9 +20344,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -18890,6 +20368,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -19034,9 +20515,6 @@ static void *_p_p_mfem__ConstantCoefficientTo_p_p_mfem__Coefficient(void *x, int static void *_p_p_mfem__ExtrudeCoefficientTo_p_p_mfem__Coefficient(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Coefficient **) ((mfem::ExtrudeCoefficient **) x)); } -static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); -} static void *_p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::RT0_3DFECollection *) x)); } @@ -19094,12 +20572,18 @@ static void *_p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollect static void *_p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::CrouzeixRaviartFECollection *) x)); } +static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +} static void *_p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::H1_FECollection *) x)); } static void *_p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Pos_FECollection *) x)); } +static void *_p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1Ser_FECollection *) x)); +} static void *_p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) (mfem::H1_FECollection *) ((mfem::H1_Trace_FECollection *) x)); } @@ -19133,8 +20617,8 @@ static void *_p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection(vo static void *_p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::QuadraticPosFECollection *) x)); } -static void *_p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElementCollection *) ((mfem::CubicFECollection *) x)); +static void *_p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElementCollection *) ((mfem::RT1_3DFECollection *) x)); } static void *_p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElementCollection *) ((mfem::Local_FECollection *) x)); @@ -19158,6 +20642,7 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; @@ -19167,7 +20652,6 @@ static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_double_t = {"_p_mfem__ArrayT_double_t", "mfem::Array< double > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -19178,6 +20662,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -19199,6 +20684,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -19231,8 +20717,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -19241,6 +20726,7 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Coefficient = {"_p_mfem__Coefficient", "mfem::Coefficient *", 0, 0, (void*)0, 0}; @@ -19264,6 +20750,7 @@ static swig_type_info _swigt__p_mfem__ElementTransformation = {"_p_mfem__Element static swig_type_info _swigt__p_mfem__IsoparametricTransformation = {"_p_mfem__IsoparametricTransformation", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ExtrudeCoefficient = {"_p_mfem__ExtrudeCoefficient", "mfem::ExtrudeCoefficient *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementCollection = {"_p_mfem__FiniteElementCollection", "mfem::FiniteElementCollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GaussLinearDiscont2DFECollection = {"_p_mfem__GaussLinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1OnQuadFECollection = {"_p_mfem__P1OnQuadFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticDiscont2DFECollection = {"_p_mfem__QuadraticDiscont2DFECollection", 0, 0, 0, 0, 0}; @@ -19276,15 +20763,13 @@ static swig_type_info _swigt__p_mfem__QuadraticDiscont3DFECollection = {"_p_mfem static swig_type_info _swigt__p_mfem__RefinedLinearFECollection = {"_p_mfem__RefinedLinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ND1_3DFECollection = {"_p_mfem__ND1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_3DFECollection = {"_p_mfem__RT0_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__LinearDiscont2DFECollection = {"_p_mfem__LinearDiscont2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Const2DFECollection = {"_p_mfem__Const2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT2_2DFECollection = {"_p_mfem__RT2_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1_2DFECollection = {"_p_mfem__RT1_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT0_2DFECollection = {"_p_mfem__RT0_2DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearNonConf3DFECollection = {"_p_mfem__LinearNonConf3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CrouzeixRaviartFECollection = {"_p_mfem__CrouzeixRaviartFECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__QuadraticFECollection = {"_p_mfem__QuadraticFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearFECollection = {"_p_mfem__LinearFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBSFECollection = {"_p_mfem__NURBSFECollection", 0, 0, 0, 0, 0}; @@ -19294,9 +20779,11 @@ static swig_type_info _swigt__p_mfem__DG_Interface_FECollection = {"_p_mfem__DG_ static swig_type_info _swigt__p_mfem__RT_Trace_FECollection = {"_p_mfem__RT_Trace_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT_FECollection = {"_p_mfem__RT_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_Trace_FECollection = {"_p_mfem__H1_Trace_FECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_FECollection = {"_p_mfem__H1Ser_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_FECollection = {"_p_mfem__H1Pos_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_FECollection = {"_p_mfem__H1_FECollection", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__CubicFECollection = {"_p_mfem__CubicFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__QuadraticPosFECollection = {"_p_mfem__QuadraticPosFECollection", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RT1_3DFECollection = {"_p_mfem__RT1_3DFECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Local_FECollection = {"_p_mfem__Local_FECollection", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; @@ -19353,6 +20840,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_doublep, @@ -19396,11 +20884,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__GaussLinearDiscont2DFECollection, &_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, &_swigt__p_mfem__GradientGridFunctionCoefficient, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GridFunctionCoefficient, &_swigt__p_mfem__GroupConvectionIntegrator, &_swigt__p_mfem__H1Pos_FECollection, + &_swigt__p_mfem__H1Ser_FECollection, &_swigt__p_mfem__H1_FECollection, &_swigt__p_mfem__H1_Trace_FECollection, &_swigt__p_mfem__IdentityInterpolator, @@ -19548,6 +21038,7 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0}, {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; @@ -19556,7 +21047,6 @@ static swig_cast_info _swigc__p_int[] = { {&_swigt__p_intp, _p_intpTo_p_int, 0, static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_double_t[] = { {&_swigt__p_mfem__ArrayT_double_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -19567,6 +21057,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -19588,6 +21079,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -19620,8 +21112,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -19630,9 +21121,10 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyCoefficientBase[] = {{&_swigt__p_mfem__PyCoefficientBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DeterminantCoefficient[] = {{&_swigt__p_mfem__DeterminantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorRotProductCoefficient[] = {{&_swigt__p_mfem__VectorRotProductCoefficient, 0, 0, 0},{0, 0, 0, 0}}; @@ -19653,6 +21145,7 @@ static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__Dense static swig_cast_info _swigc__p_mfem__IsoparametricTransformation[] = {{&_swigt__p_mfem__IsoparametricTransformation, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0}, {&_swigt__p_mfem__IsoparametricTransformation, _p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ExtrudeCoefficient[] = { {&_swigt__p_mfem__ExtrudeCoefficient, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GaussLinearDiscont2DFECollection[] = {{&_swigt__p_mfem__GaussLinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1OnQuadFECollection[] = {{&_swigt__p_mfem__P1OnQuadFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticDiscont2DFECollection[] = {{&_swigt__p_mfem__QuadraticDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -19665,15 +21158,13 @@ static swig_cast_info _swigc__p_mfem__QuadraticDiscont3DFECollection[] = {{&_swi static swig_cast_info _swigc__p_mfem__RefinedLinearFECollection[] = {{&_swigt__p_mfem__RefinedLinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ND1_3DFECollection[] = {{&_swigt__p_mfem__ND1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_3DFECollection[] = {{&_swigt__p_mfem__RT0_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__LinearDiscont2DFECollection[] = {{&_swigt__p_mfem__LinearDiscont2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Const2DFECollection[] = {{&_swigt__p_mfem__Const2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT2_2DFECollection[] = {{&_swigt__p_mfem__RT2_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1_2DFECollection[] = {{&_swigt__p_mfem__RT1_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT0_2DFECollection[] = {{&_swigt__p_mfem__RT0_2DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearNonConf3DFECollection[] = {{&_swigt__p_mfem__LinearNonConf3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CrouzeixRaviartFECollection[] = {{&_swigt__p_mfem__CrouzeixRaviartFECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadraticFECollection[] = {{&_swigt__p_mfem__QuadraticFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearFECollection[] = {{&_swigt__p_mfem__LinearFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBSFECollection[] = {{&_swigt__p_mfem__NURBSFECollection, 0, 0, 0},{0, 0, 0, 0}}; @@ -19683,11 +21174,13 @@ static swig_cast_info _swigc__p_mfem__DG_Interface_FECollection[] = {{&_swigt__p static swig_cast_info _swigc__p_mfem__RT_Trace_FECollection[] = {{&_swigt__p_mfem__RT_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT_FECollection[] = {{&_swigt__p_mfem__RT_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_Trace_FECollection[] = {{&_swigt__p_mfem__H1_Trace_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_FECollection[] = {{&_swigt__p_mfem__H1Ser_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_FECollection[] = {{&_swigt__p_mfem__H1Pos_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_FECollection[] = {{&_swigt__p_mfem__H1_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__CubicFECollection[] = {{&_swigt__p_mfem__CubicFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadraticPosFECollection[] = {{&_swigt__p_mfem__QuadraticPosFECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RT1_3DFECollection[] = {{&_swigt__p_mfem__RT1_3DFECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Local_FECollection[] = {{&_swigt__p_mfem__Local_FECollection, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementCollection[] = { {&_swigt__p_mfem__LinearDiscont2DFECollection, _p_mfem__LinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussLinearDiscont2DFECollection, _p_mfem__GaussLinearDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__P1OnQuadFECollection, _p_mfem__P1OnQuadFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont2DFECollection, _p_mfem__QuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosDiscont2DFECollection, _p_mfem__QuadraticPosDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__GaussQuadraticDiscont2DFECollection, _p_mfem__GaussQuadraticDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicDiscont2DFECollection, _p_mfem__CubicDiscont2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const3DFECollection, _p_mfem__Const3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearDiscont3DFECollection, _p_mfem__LinearDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticDiscont3DFECollection, _p_mfem__QuadraticDiscont3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RefinedLinearFECollection, _p_mfem__RefinedLinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND1_3DFECollection, _p_mfem__ND1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_3DFECollection, _p_mfem__RT0_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Const2DFECollection, _p_mfem__Const2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT2_2DFECollection, _p_mfem__RT2_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_2DFECollection, _p_mfem__RT1_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT0_2DFECollection, _p_mfem__RT0_2DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearNonConf3DFECollection, _p_mfem__LinearNonConf3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFECollection, _p_mfem__CrouzeixRaviartFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__CubicFECollection, _p_mfem__CubicFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__FiniteElementCollection, 0, 0, 0}, {&_swigt__p_mfem__QuadraticFECollection, _p_mfem__QuadraticFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__LinearFECollection, _p_mfem__LinearFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__NURBSFECollection, _p_mfem__NURBSFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_Trace_FECollection, _p_mfem__ND_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__ND_FECollection, _p_mfem__ND_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__DG_Interface_FECollection, _p_mfem__DG_Interface_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_Trace_FECollection, _p_mfem__RT_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT_FECollection, _p_mfem__RT_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__L2_FECollection, _p_mfem__L2_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_Trace_FECollection, _p_mfem__H1_Trace_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Ser_FECollection, _p_mfem__H1Ser_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1Pos_FECollection, _p_mfem__H1Pos_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__H1_FECollection, _p_mfem__H1_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__QuadraticPosFECollection, _p_mfem__QuadraticPosFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__RT1_3DFECollection, _p_mfem__RT1_3DFECollectionTo_p_mfem__FiniteElementCollection, 0, 0}, {&_swigt__p_mfem__Local_FECollection, _p_mfem__Local_FECollectionTo_p_mfem__FiniteElementCollection, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationPoint[] = { {&_swigt__p_mfem__IntegrationPoint, 0, 0, 0},{0, 0, 0, 0}}; @@ -19743,6 +21236,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_doublep, @@ -19786,11 +21280,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__GaussLinearDiscont2DFECollection, _swigc__p_mfem__GaussQuadraticDiscont2DFECollection, _swigc__p_mfem__GradientGridFunctionCoefficient, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GridFunctionCoefficient, _swigc__p_mfem__GroupConvectionIntegrator, _swigc__p_mfem__H1Pos_FECollection, + _swigc__p_mfem__H1Ser_FECollection, _swigc__p_mfem__H1_FECollection, _swigc__p_mfem__H1_Trace_FECollection, _swigc__p_mfem__IdentityInterpolator, diff --git a/mfem/_ser/handle.py b/mfem/_ser/handle.py index 41a6affc..de68441f 100644 --- a/mfem/_ser/handle.py +++ b/mfem/_ser/handle.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _handle.SWIG_PyInstanceMethod_New +_swig_new_static_method = _handle.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -106,66 +109,82 @@ def __init__(self, *args): def Ptr(self): r"""Ptr(OperatorHandle self) -> Operator""" return _handle.OperatorHandle_Ptr(self) + Ptr = _swig_new_instance_method(_handle.OperatorHandle_Ptr) def __deref__(self): r"""__deref__(OperatorHandle self) -> Operator""" return _handle.OperatorHandle___deref__(self) + __deref__ = _swig_new_instance_method(_handle.OperatorHandle___deref__) def __ref__(self): r"""__ref__(OperatorHandle self) -> Operator""" return _handle.OperatorHandle___ref__(self) + __ref__ = _swig_new_instance_method(_handle.OperatorHandle___ref__) def Type(self): r"""Type(OperatorHandle self) -> mfem::Operator::Type""" return _handle.OperatorHandle_Type(self) + Type = _swig_new_instance_method(_handle.OperatorHandle_Type) def OwnsOperator(self): r"""OwnsOperator(OperatorHandle self) -> bool""" return _handle.OperatorHandle_OwnsOperator(self) + OwnsOperator = _swig_new_instance_method(_handle.OperatorHandle_OwnsOperator) def SetOperatorOwner(self, own=True): r"""SetOperatorOwner(OperatorHandle self, bool own=True)""" return _handle.OperatorHandle_SetOperatorOwner(self, own) + SetOperatorOwner = _swig_new_instance_method(_handle.OperatorHandle_SetOperatorOwner) def Clear(self): r"""Clear(OperatorHandle self)""" return _handle.OperatorHandle_Clear(self) + Clear = _swig_new_instance_method(_handle.OperatorHandle_Clear) def SetType(self, tid): r"""SetType(OperatorHandle self, mfem::Operator::Type tid)""" return _handle.OperatorHandle_SetType(self, tid) + SetType = _swig_new_instance_method(_handle.OperatorHandle_SetType) def MakePtAP(self, A, P): r"""MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)""" return _handle.OperatorHandle_MakePtAP(self, A, P) + MakePtAP = _swig_new_instance_method(_handle.OperatorHandle_MakePtAP) def MakeRAP(self, Rt, A, P): r"""MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)""" return _handle.OperatorHandle_MakeRAP(self, Rt, A, P) + MakeRAP = _swig_new_instance_method(_handle.OperatorHandle_MakeRAP) def EliminateRowsCols(self, A, ess_dof_list): r"""EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)""" return _handle.OperatorHandle_EliminateRowsCols(self, A, ess_dof_list) + EliminateRowsCols = _swig_new_instance_method(_handle.OperatorHandle_EliminateRowsCols) def EliminateBC(self, A_e, ess_dof_list, X, B): r"""EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)""" return _handle.OperatorHandle_EliminateBC(self, A_e, ess_dof_list, X, B) + EliminateBC = _swig_new_instance_method(_handle.OperatorHandle_EliminateBC) def As(self): r"""As(OperatorHandle self) -> mfem::SparseMatrix *""" return _handle.OperatorHandle_As(self) + As = _swig_new_instance_method(_handle.OperatorHandle_As) def Is(self): r"""Is(OperatorHandle self) -> mfem::SparseMatrix *""" return _handle.OperatorHandle_Is(self) + Is = _swig_new_instance_method(_handle.OperatorHandle_Is) def Get(self, A): r"""Get(OperatorHandle self, mfem::SparseMatrix *& A)""" return _handle.OperatorHandle_Get(self, A) + Get = _swig_new_instance_method(_handle.OperatorHandle_Get) def Reset(self, A, own_A=True): r"""Reset(OperatorHandle self, mfem::SparseMatrix * A, bool own_A=True)""" return _handle.OperatorHandle_Reset(self, A, own_A) + Reset = _swig_new_instance_method(_handle.OperatorHandle_Reset) def ConvertFrom(self, *args): r""" @@ -173,62 +192,112 @@ def ConvertFrom(self, *args): ConvertFrom(OperatorHandle self, mfem::SparseMatrix * A) """ return _handle.OperatorHandle_ConvertFrom(self, *args) + ConvertFrom = _swig_new_instance_method(_handle.OperatorHandle_ConvertFrom) + + def InitTVectors(self, Po, Ri, Pi, x, b, X, B): + r"""InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)""" + return _handle.OperatorHandle_InitTVectors(self, Po, Ri, Pi, x, b, X, B) + InitTVectors = _swig_new_instance_method(_handle.OperatorHandle_InitTVectors) def Height(self): r"""Height(OperatorHandle self) -> int""" return _handle.OperatorHandle_Height(self) + Height = _swig_new_instance_method(_handle.OperatorHandle_Height) def NumRows(self): r"""NumRows(OperatorHandle self) -> int""" return _handle.OperatorHandle_NumRows(self) + NumRows = _swig_new_instance_method(_handle.OperatorHandle_NumRows) def Width(self): r"""Width(OperatorHandle self) -> int""" return _handle.OperatorHandle_Width(self) + Width = _swig_new_instance_method(_handle.OperatorHandle_Width) def NumCols(self): r"""NumCols(OperatorHandle self) -> int""" return _handle.OperatorHandle_NumCols(self) + NumCols = _swig_new_instance_method(_handle.OperatorHandle_NumCols) def GetMemoryClass(self): r"""GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass""" return _handle.OperatorHandle_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_handle.OperatorHandle_GetMemoryClass) def Mult(self, x, y): r"""Mult(OperatorHandle self, Vector x, Vector y)""" return _handle.OperatorHandle_Mult(self, x, y) + Mult = _swig_new_instance_method(_handle.OperatorHandle_Mult) def MultTranspose(self, x, y): r"""MultTranspose(OperatorHandle self, Vector x, Vector y)""" return _handle.OperatorHandle_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_handle.OperatorHandle_MultTranspose) def GetGradient(self, x): r"""GetGradient(OperatorHandle self, Vector x) -> Operator""" return _handle.OperatorHandle_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_handle.OperatorHandle_GetGradient) def GetProlongation(self): r"""GetProlongation(OperatorHandle self) -> Operator""" return _handle.OperatorHandle_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_handle.OperatorHandle_GetProlongation) def GetRestriction(self): r"""GetRestriction(OperatorHandle self) -> Operator""" return _handle.OperatorHandle_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_handle.OperatorHandle_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(OperatorHandle self) -> Operator""" + return _handle.OperatorHandle_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_handle.OperatorHandle_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(OperatorHandle self) -> Operator""" + return _handle.OperatorHandle_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_handle.OperatorHandle_GetOutputRestriction) def FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior=0): r"""FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)""" return _handle.OperatorHandle_FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior) + FormLinearSystem = _swig_new_instance_method(_handle.OperatorHandle_FormLinearSystem) + + def FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B): + r"""FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)""" + return _handle.OperatorHandle_FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B) + FormRectangularLinearSystem = _swig_new_instance_method(_handle.OperatorHandle_FormRectangularLinearSystem) def RecoverFEMSolution(self, X, b, x): r"""RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)""" return _handle.OperatorHandle_RecoverFEMSolution(self, X, b, x) + RecoverFEMSolution = _swig_new_instance_method(_handle.OperatorHandle_RecoverFEMSolution) + + def FormSystemOperator(self, ess_tdof_list, A): + r"""FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)""" + return _handle.OperatorHandle_FormSystemOperator(self, ess_tdof_list, A) + FormSystemOperator = _swig_new_instance_method(_handle.OperatorHandle_FormSystemOperator) + + def FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A): + r"""FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)""" + return _handle.OperatorHandle_FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A) + FormRectangularSystemOperator = _swig_new_instance_method(_handle.OperatorHandle_FormRectangularSystemOperator) + + def FormDiscreteOperator(self, A): + r"""FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)""" + return _handle.OperatorHandle_FormDiscreteOperator(self, A) + FormDiscreteOperator = _swig_new_instance_method(_handle.OperatorHandle_FormDiscreteOperator) def PrintMatlab(self, out, n=0, m=0): r"""PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)""" return _handle.OperatorHandle_PrintMatlab(self, out, n, m) + PrintMatlab = _swig_new_instance_method(_handle.OperatorHandle_PrintMatlab) def GetType(self): r"""GetType(OperatorHandle self) -> mfem::Operator::Type""" return _handle.OperatorHandle_GetType(self) + GetType = _swig_new_instance_method(_handle.OperatorHandle_GetType) # Register OperatorHandle in _handle: _handle.OperatorHandle_swigregister(OperatorHandle) diff --git a/mfem/_ser/handle_wrap.cxx b/mfem/_ser/handle_wrap.cxx index fd4e4024..aa8bff69 100644 --- a/mfem/_ser/handle_wrap.cxx +++ b/mfem/_ser/handle_wrap.cxx @@ -3076,26 +3076,32 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[8] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[9] #define SWIGTYPE_p_mfem__RAPOperator swig_types[10] -#define SWIGTYPE_p_mfem__Solver swig_types[11] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[12] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[13] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[14] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[15] -#define SWIGTYPE_p_mfem__Vector swig_types[16] -#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[17] -#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[18] -#define SWIGTYPE_p_p_mfem__Operator swig_types[19] -#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[20] -#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[21] -#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[22] -#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[23] -#define SWIGTYPE_p_p_mfem__Solver swig_types[24] -#define SWIGTYPE_p_p_mfem__SparseMatrix swig_types[25] -#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[26] -#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[27] -#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[28] -static swig_type_info *swig_types[30]; -static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[11] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[12] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[13] +#define SWIGTYPE_p_mfem__Solver swig_types[14] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[15] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[16] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[17] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[18] +#define SWIGTYPE_p_mfem__Vector swig_types[19] +#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[20] +#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[21] +#define SWIGTYPE_p_p_mfem__Operator swig_types[22] +#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[23] +#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[24] +#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[25] +#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[26] +#define SWIGTYPE_p_p_mfem__RectangularConstrainedOperator swig_types[27] +#define SWIGTYPE_p_p_mfem__ScaledOperator swig_types[28] +#define SWIGTYPE_p_p_mfem__SecondOrderTimeDependentOperator swig_types[29] +#define SWIGTYPE_p_p_mfem__Solver swig_types[30] +#define SWIGTYPE_p_p_mfem__SparseMatrix swig_types[31] +#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[32] +#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[33] +#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[34] +static swig_type_info *swig_types[36]; +static swig_module_info swig_module = {swig_types, 35, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4711,6 +4717,113 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom(PyObject *self, PyObject * } +SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Operator *arg2 = (mfem::Operator *) 0 ; + mfem::Operator *arg3 = (mfem::Operator *) 0 ; + mfem::Operator *arg4 = (mfem::Operator *) 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_InitTVectors", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_InitTVectors" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); + } + arg3 = reinterpret_cast< mfem::Operator * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); + } + arg4 = reinterpret_cast< mfem::Operator * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + (*arg1)->InitTVectors((mfem::Operator const *)arg2,(mfem::Operator const *)arg3,(mfem::Operator const *)arg4,*arg5,*arg6,*arg7,*arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_Height(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5171,6 +5284,88 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetRestriction(PyObject *SWIGUNUSEDPAR } +SWIGINTERN PyObject *_wrap_OperatorHandle_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_GetOutputProlongation" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + { + try { + result = (mfem::Operator *)(*arg1)->GetOutputProlongation(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OperatorHandle_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_GetOutputRestriction" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + { + try { + result = (mfem::Operator *)(*arg1)->GetOutputRestriction(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5490,6 +5685,122 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem(PyObject *self, PyObj } +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Operator **arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + arg6 = reinterpret_cast< mfem::Operator ** >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + (*arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5562,6 +5873,189 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE } +SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Operator **arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); + } + arg3 = reinterpret_cast< mfem::Operator ** >(argp3); + { + try { + (*arg1)->FormSystemOperator((mfem::Array< int > const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Operator **arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + arg4 = reinterpret_cast< mfem::Operator ** >(argp4); + { + try { + (*arg1)->FormRectangularSystemOperator((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Operator **arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + } + arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + arg2 = reinterpret_cast< mfem::Operator ** >(argp2); + { + try { + (*arg1)->FormDiscreteOperator(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -5944,6 +6438,7 @@ SWIGINTERN PyObject *OperatorHandle_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_OperatorHandle", _wrap_new_OperatorHandle, METH_VARARGS, "\n" "OperatorHandle()\n" "new_OperatorHandle(mfem::Operator::Type tid) -> OperatorHandle\n" @@ -5969,6 +6464,7 @@ static PyMethodDef SwigMethods[] = { "OperatorHandle_ConvertFrom(OperatorHandle self, OperatorHandle A)\n" "OperatorHandle_ConvertFrom(OperatorHandle self, mfem::SparseMatrix * A)\n" ""}, + { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "OperatorHandle_InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "OperatorHandle_Height(OperatorHandle self) -> int"}, { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "OperatorHandle_NumRows(OperatorHandle self) -> int"}, { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "OperatorHandle_Width(OperatorHandle self) -> int"}, @@ -5979,8 +6475,14 @@ static PyMethodDef SwigMethods[] = { { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "OperatorHandle_GetGradient(OperatorHandle self, Vector x) -> Operator"}, { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "OperatorHandle_GetProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "OperatorHandle_GetRestriction(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "OperatorHandle_GetOutputProlongation(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "OperatorHandle_GetOutputRestriction(OperatorHandle self) -> Operator"}, { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "OperatorHandle_FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "OperatorHandle_FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "OperatorHandle_RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "OperatorHandle_FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "OperatorHandle_FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "OperatorHandle_FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "OperatorHandle_PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "OperatorHandle_GetType(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, @@ -5989,6 +6491,56 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_OperatorHandle", _wrap_new_OperatorHandle, METH_VARARGS, "\n" + "OperatorHandle()\n" + "new_OperatorHandle(mfem::Operator::Type tid) -> OperatorHandle\n" + ""}, + { "delete_OperatorHandle", _wrap_delete_OperatorHandle, METH_O, "delete_OperatorHandle(OperatorHandle self)"}, + { "OperatorHandle_Ptr", _wrap_OperatorHandle_Ptr, METH_O, "Ptr(OperatorHandle self) -> Operator"}, + { "OperatorHandle___deref__", _wrap_OperatorHandle___deref__, METH_O, "__deref__(OperatorHandle self) -> Operator"}, + { "OperatorHandle___ref__", _wrap_OperatorHandle___ref__, METH_O, "__ref__(OperatorHandle self) -> Operator"}, + { "OperatorHandle_Type", _wrap_OperatorHandle_Type, METH_O, "Type(OperatorHandle self) -> mfem::Operator::Type"}, + { "OperatorHandle_OwnsOperator", _wrap_OperatorHandle_OwnsOperator, METH_O, "OwnsOperator(OperatorHandle self) -> bool"}, + { "OperatorHandle_SetOperatorOwner", _wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS, "SetOperatorOwner(OperatorHandle self, bool own=True)"}, + { "OperatorHandle_Clear", _wrap_OperatorHandle_Clear, METH_O, "Clear(OperatorHandle self)"}, + { "OperatorHandle_SetType", _wrap_OperatorHandle_SetType, METH_VARARGS, "SetType(OperatorHandle self, mfem::Operator::Type tid)"}, + { "OperatorHandle_MakePtAP", _wrap_OperatorHandle_MakePtAP, METH_VARARGS, "MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_MakeRAP", _wrap_OperatorHandle_MakeRAP, METH_VARARGS, "MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_EliminateRowsCols", _wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS, "EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, + { "OperatorHandle_EliminateBC", _wrap_OperatorHandle_EliminateBC, METH_VARARGS, "EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, + { "OperatorHandle_As", _wrap_OperatorHandle_As, METH_O, "As(OperatorHandle self) -> mfem::SparseMatrix *"}, + { "OperatorHandle_Is", _wrap_OperatorHandle_Is, METH_O, "Is(OperatorHandle self) -> mfem::SparseMatrix *"}, + { "OperatorHandle_Get", _wrap_OperatorHandle_Get, METH_VARARGS, "Get(OperatorHandle self, mfem::SparseMatrix *& A)"}, + { "OperatorHandle_Reset", _wrap_OperatorHandle_Reset, METH_VARARGS, "Reset(OperatorHandle self, mfem::SparseMatrix * A, bool own_A=True)"}, + { "OperatorHandle_ConvertFrom", _wrap_OperatorHandle_ConvertFrom, METH_VARARGS, "\n" + "ConvertFrom(OperatorHandle self, OperatorHandle A)\n" + "ConvertFrom(OperatorHandle self, mfem::SparseMatrix * A)\n" + ""}, + { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "Height(OperatorHandle self) -> int"}, + { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "NumRows(OperatorHandle self) -> int"}, + { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "Width(OperatorHandle self) -> int"}, + { "OperatorHandle_NumCols", _wrap_OperatorHandle_NumCols, METH_O, "NumCols(OperatorHandle self) -> int"}, + { "OperatorHandle_GetMemoryClass", _wrap_OperatorHandle_GetMemoryClass, METH_O, "GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass"}, + { "OperatorHandle_Mult", _wrap_OperatorHandle_Mult, METH_VARARGS, "Mult(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_MultTranspose", _wrap_OperatorHandle_MultTranspose, METH_VARARGS, "MultTranspose(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "GetGradient(OperatorHandle self, Vector x) -> Operator"}, + { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "GetProlongation(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "GetRestriction(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "GetOutputProlongation(OperatorHandle self) -> Operator"}, + { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "GetOutputRestriction(OperatorHandle self) -> Operator"}, + { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, + { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, + { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "GetType(OperatorHandle self) -> mfem::Operator::Type"}, + { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, + { "OperatorHandle_swiginit", OperatorHandle_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6001,9 +6553,15 @@ static void *_p_p_mfem__SolverTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM static void *_p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TimeDependentOperator **) x)); } +static void *_p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator **) x)); +} static void *_p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::IdentityOperator **) x)); } +static void *_p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::ScaledOperator **) x)); +} static void *_p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TransposeOperator **) x)); } @@ -6019,6 +6577,9 @@ static void *_p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator(void *x, int static void *_p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::ConstrainedOperator **) x)); } +static void *_p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::RectangularConstrainedOperator **) x)); +} static void *_p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::PyOperatorBase **) x)); } @@ -6031,9 +6592,15 @@ static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(new static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } @@ -6049,6 +6616,9 @@ static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWI static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); } @@ -6059,30 +6629,36 @@ static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wF static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__Operator = {"_p_p_mfem__Operator", "mfem::Operator **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_mfem__PyOperatorBase = {"_p_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__PyTimeDependentOperatorBase = {"_p_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__Solver = {"_p_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TimeDependentOperator = {"_p_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__SecondOrderTimeDependentOperator = {"_p_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__IdentityOperator = {"_p_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__ScaledOperator = {"_p_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TransposeOperator = {"_p_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ProductOperator = {"_p_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__RAPOperator = {"_p_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TripleProductOperator = {"_p_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ConstrainedOperator = {"_p_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_p_mfem__PyOperatorBase = {"_p_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_p_mfem__PyTimeDependentOperatorBase = {"_p_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__RectangularConstrainedOperator = {"_p_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__SparseMatrix = {"_p_p_mfem__SparseMatrix", "mfem::SparseMatrix **", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { @@ -6097,6 +6673,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -6110,6 +6689,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_p_mfem__PyOperatorBase, &_swigt__p_p_mfem__PyTimeDependentOperatorBase, &_swigt__p_p_mfem__RAPOperator, + &_swigt__p_p_mfem__RectangularConstrainedOperator, + &_swigt__p_p_mfem__ScaledOperator, + &_swigt__p_p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_p_mfem__Solver, &_swigt__p_p_mfem__SparseMatrix, &_swigt__p_p_mfem__TimeDependentOperator, @@ -6120,31 +6702,37 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__PyOperatorBase[] = {{&_swigt__p_p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Solver[] = {{&_swigt__p_p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TimeDependentOperator[] = {{&_swigt__p_p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__IdentityOperator[] = {{&_swigt__p_p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__ScaledOperator[] = {{&_swigt__p_p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TransposeOperator[] = {{&_swigt__p_p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ProductOperator[] = {{&_swigt__p_p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__RAPOperator[] = {{&_swigt__p_p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TripleProductOperator[] = {{&_swigt__p_p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ConstrainedOperator[] = {{&_swigt__p_p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__PyOperatorBase[] = {{&_swigt__p_p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, _p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ScaledOperator, _p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RectangularConstrainedOperator, _p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__SparseMatrix[] = { {&_swigt__p_p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { @@ -6159,6 +6747,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, @@ -6172,6 +6763,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_p_mfem__PyOperatorBase, _swigc__p_p_mfem__PyTimeDependentOperatorBase, _swigc__p_p_mfem__RAPOperator, + _swigc__p_p_mfem__RectangularConstrainedOperator, + _swigc__p_p_mfem__ScaledOperator, + _swigc__p_p_mfem__SecondOrderTimeDependentOperator, _swigc__p_p_mfem__Solver, _swigc__p_p_mfem__SparseMatrix, _swigc__p_p_mfem__TimeDependentOperator, @@ -6906,17 +7500,17 @@ SWIG_init(void) { SWIG_InstallConstants(d,swig_const_table); - SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40000))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.0")); - SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40000)%2)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION",SWIG_From_int(static_cast< int >(40100))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_STRING",SWIG_FromCharPtr("4.1.0")); + SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE",SWIG_From_int(static_cast< int >(((40100)%2)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_RELEASE",SWIG_From_int(static_cast< int >(0))); SWIG_Python_SetConstant(d, "MFEM_VERSION_TYPE_DEVELOPMENT",SWIG_From_int(static_cast< int >(1))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40000)/10000)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40000)/100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40000)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/ser")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/ser")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); import_array(); diff --git a/mfem/_ser/hash.py b/mfem/_ser/hash.py index 1df90b8c..ab554e7c 100644 --- a/mfem/_ser/hash.py +++ b/mfem/_ser/hash.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _hash.SWIG_PyInstanceMethod_New +_swig_new_static_method = _hash.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -103,9 +106,16 @@ def __init__(self): def sort3(a, b, c): r"""sort3(int & a, int & b, int & c)""" return _hash.sort3(a, b, c) +sort3 = _hash.sort3 def sort4(a, b, c, d): r"""sort4(int & a, int & b, int & c, int & d)""" return _hash.sort4(a, b, c, d) +sort4 = _hash.sort4 + +def sort4_ext(a, b, c, d): + r"""sort4_ext(int & a, int & b, int & c, int & d)""" + return _hash.sort4_ext(a, b, c, d) +sort4_ext = _hash.sort4_ext diff --git a/mfem/_ser/hash_wrap.cxx b/mfem/_ser/hash_wrap.cxx index b7ec90e4..edf4b001 100644 --- a/mfem/_ser/hash_wrap.cxx +++ b/mfem/_ser/hash_wrap.cxx @@ -3425,8 +3425,81 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } +SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "sort4_ext", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); + } + arg1 = reinterpret_cast< int * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sort4_ext" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); + { + try { + mfem::internal::sort4_ext(*arg1,*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Hashed2_p1_set", _wrap_Hashed2_p1_set, METH_VARARGS, "Hashed2_p1_set(Hashed2 self, int p1)"}, { "Hashed2_p1_get", _wrap_Hashed2_p1_get, METH_O, "Hashed2_p1_get(Hashed2 self) -> int"}, { "Hashed2_p2_set", _wrap_Hashed2_p2_set, METH_VARARGS, "Hashed2_p2_set(Hashed2 self, int p2)"}, @@ -3451,10 +3524,38 @@ static PyMethodDef SwigMethods[] = { { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Hashed2_p1_set", _wrap_Hashed2_p1_set, METH_VARARGS, "Hashed2_p1_set(Hashed2 self, int p1)"}, + { "Hashed2_p1_get", _wrap_Hashed2_p1_get, METH_O, "Hashed2_p1_get(Hashed2 self) -> int"}, + { "Hashed2_p2_set", _wrap_Hashed2_p2_set, METH_VARARGS, "Hashed2_p2_set(Hashed2 self, int p2)"}, + { "Hashed2_p2_get", _wrap_Hashed2_p2_get, METH_O, "Hashed2_p2_get(Hashed2 self) -> int"}, + { "Hashed2_next_set", _wrap_Hashed2_next_set, METH_VARARGS, "Hashed2_next_set(Hashed2 self, int next)"}, + { "Hashed2_next_get", _wrap_Hashed2_next_get, METH_O, "Hashed2_next_get(Hashed2 self) -> int"}, + { "new_Hashed2", _wrap_new_Hashed2, METH_NOARGS, "new_Hashed2() -> Hashed2"}, + { "delete_Hashed2", _wrap_delete_Hashed2, METH_O, "delete_Hashed2(Hashed2 self)"}, + { "Hashed2_swigregister", Hashed2_swigregister, METH_O, NULL}, + { "Hashed2_swiginit", Hashed2_swiginit, METH_VARARGS, NULL}, + { "Hashed4_p1_set", _wrap_Hashed4_p1_set, METH_VARARGS, "Hashed4_p1_set(Hashed4 self, int p1)"}, + { "Hashed4_p1_get", _wrap_Hashed4_p1_get, METH_O, "Hashed4_p1_get(Hashed4 self) -> int"}, + { "Hashed4_p2_set", _wrap_Hashed4_p2_set, METH_VARARGS, "Hashed4_p2_set(Hashed4 self, int p2)"}, + { "Hashed4_p2_get", _wrap_Hashed4_p2_get, METH_O, "Hashed4_p2_get(Hashed4 self) -> int"}, + { "Hashed4_p3_set", _wrap_Hashed4_p3_set, METH_VARARGS, "Hashed4_p3_set(Hashed4 self, int p3)"}, + { "Hashed4_p3_get", _wrap_Hashed4_p3_get, METH_O, "Hashed4_p3_get(Hashed4 self) -> int"}, + { "Hashed4_next_set", _wrap_Hashed4_next_set, METH_VARARGS, "Hashed4_next_set(Hashed4 self, int next)"}, + { "Hashed4_next_get", _wrap_Hashed4_next_get, METH_O, "Hashed4_next_get(Hashed4 self) -> int"}, + { "new_Hashed4", _wrap_new_Hashed4, METH_NOARGS, "new_Hashed4() -> Hashed4"}, + { "delete_Hashed4", _wrap_delete_Hashed4, METH_O, "delete_Hashed4(Hashed4 self)"}, + { "Hashed4_swigregister", Hashed4_swigregister, METH_O, NULL}, + { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, + { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, + { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/hybridization.py b/mfem/_ser/hybridization.py index 29e0abd4..d3cca126 100644 --- a/mfem/_ser/hybridization.py +++ b/mfem/_ser/hybridization.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _hybridization.SWIG_PyInstanceMethod_New +_swig_new_static_method = _hybridization.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,7 +90,9 @@ class _SwigNonDynamicMeta(type): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.handle +import mfem._ser.restriction class Hybridization(object): r"""Proxy of C++ mfem::Hybridization class.""" @@ -102,38 +107,47 @@ def __init__(self, fespace, c_fespace): def SetConstraintIntegrator(self, c_integ): r"""SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)""" return _hybridization.Hybridization_SetConstraintIntegrator(self, c_integ) + SetConstraintIntegrator = _swig_new_instance_method(_hybridization.Hybridization_SetConstraintIntegrator) def Init(self, ess_tdof_list): r"""Init(Hybridization self, intArray ess_tdof_list)""" return _hybridization.Hybridization_Init(self, ess_tdof_list) + Init = _swig_new_instance_method(_hybridization.Hybridization_Init) def AssembleMatrix(self, el, A): r"""AssembleMatrix(Hybridization self, int el, DenseMatrix A)""" return _hybridization.Hybridization_AssembleMatrix(self, el, A) + AssembleMatrix = _swig_new_instance_method(_hybridization.Hybridization_AssembleMatrix) def AssembleBdrMatrix(self, bdr_el, A): r"""AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)""" return _hybridization.Hybridization_AssembleBdrMatrix(self, bdr_el, A) + AssembleBdrMatrix = _swig_new_instance_method(_hybridization.Hybridization_AssembleBdrMatrix) def Finalize(self): r"""Finalize(Hybridization self)""" return _hybridization.Hybridization_Finalize(self) + Finalize = _swig_new_instance_method(_hybridization.Hybridization_Finalize) def GetMatrix(self): r"""GetMatrix(Hybridization self) -> SparseMatrix""" return _hybridization.Hybridization_GetMatrix(self) + GetMatrix = _swig_new_instance_method(_hybridization.Hybridization_GetMatrix) def ReduceRHS(self, b, b_r): r"""ReduceRHS(Hybridization self, Vector b, Vector b_r)""" return _hybridization.Hybridization_ReduceRHS(self, b, b_r) + ReduceRHS = _swig_new_instance_method(_hybridization.Hybridization_ReduceRHS) def ComputeSolution(self, b, sol_r, sol): r"""ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)""" return _hybridization.Hybridization_ComputeSolution(self, b, sol_r, sol) + ComputeSolution = _swig_new_instance_method(_hybridization.Hybridization_ComputeSolution) def Reset(self): r"""Reset(Hybridization self)""" return _hybridization.Hybridization_Reset(self) + Reset = _swig_new_instance_method(_hybridization.Hybridization_Reset) # Register Hybridization in _hybridization: _hybridization.Hybridization_swigregister(Hybridization) diff --git a/mfem/_ser/hybridization_wrap.cxx b/mfem/_ser/hybridization_wrap.cxx index bbc46cb3..32620cc5 100644 --- a/mfem/_ser/hybridization_wrap.cxx +++ b/mfem/_ser/hybridization_wrap.cxx @@ -3066,106 +3066,108 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[5] -#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[6] -#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[7] -#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[8] -#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[10] -#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[11] -#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[12] -#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[14] -#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[17] -#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[18] -#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[19] -#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[20] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[21] -#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[22] -#define SWIGTYPE_p_mfem__GridFunction swig_types[23] -#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[24] -#define SWIGTYPE_p_mfem__Hybridization swig_types[25] -#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[26] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[27] -#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[29] -#define SWIGTYPE_p_mfem__LinearForm swig_types[30] -#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[31] -#define SWIGTYPE_p_mfem__MassIntegrator swig_types[32] -#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[33] -#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[34] -#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[35] -#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[36] -#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[37] -#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[38] -#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[39] -#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[40] -#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[41] -#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[42] -#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[43] -#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[44] -#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[45] -#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[46] -#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[47] -#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[48] -#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[49] -#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[50] -#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[51] -#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[53] -#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[54] -#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[55] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[56] -#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[57] -#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[58] -#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[59] -#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[60] -#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[61] -#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[62] -#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[63] -#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[64] -#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[65] -#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[66] -#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[67] -#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[68] -#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[69] -#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[70] -#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[71] -#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[72] -#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[73] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[74] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[75] -#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[76] -#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[77] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[78] -#define SWIGTYPE_p_mfem__SumIntegrator swig_types[79] -#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[80] -#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[81] -#define SWIGTYPE_p_mfem__Vector swig_types[82] -#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[83] -#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[84] -#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[85] -#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[86] -#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[87] -#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[88] -#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[89] -#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[90] -#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[91] -#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[92] -#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[93] -#define SWIGTYPE_p_pri_t swig_types[94] -#define SWIGTYPE_p_quad_t swig_types[95] -#define SWIGTYPE_p_seg_t swig_types[96] -#define SWIGTYPE_p_tet_t swig_types[97] -#define SWIGTYPE_p_tri_t swig_types[98] -static swig_type_info *swig_types[100]; -static swig_module_info swig_module = {swig_types, 99, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] +#define SWIGTYPE_p_mfem__BilinearFormIntegrator swig_types[7] +#define SWIGTYPE_p_mfem__BoundaryMassIntegrator swig_types[8] +#define SWIGTYPE_p_mfem__ConvectionIntegrator swig_types[9] +#define SWIGTYPE_p_mfem__CurlCurlIntegrator swig_types[10] +#define SWIGTYPE_p_mfem__CurlInterpolator swig_types[11] +#define SWIGTYPE_p_mfem__DGDiffusionIntegrator swig_types[12] +#define SWIGTYPE_p_mfem__DGElasticityIntegrator swig_types[13] +#define SWIGTYPE_p_mfem__DGTraceIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[15] +#define SWIGTYPE_p_mfem__DerivativeIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__DiffusionIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__DiscreteInterpolator swig_types[18] +#define SWIGTYPE_p_mfem__DivDivIntegrator swig_types[19] +#define SWIGTYPE_p_mfem__DivergenceInterpolator swig_types[20] +#define SWIGTYPE_p_mfem__ElasticityIntegrator swig_types[21] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[22] +#define SWIGTYPE_p_mfem__GradientIntegrator swig_types[23] +#define SWIGTYPE_p_mfem__GradientInterpolator swig_types[24] +#define SWIGTYPE_p_mfem__GridFunction swig_types[25] +#define SWIGTYPE_p_mfem__GroupConvectionIntegrator swig_types[26] +#define SWIGTYPE_p_mfem__Hybridization swig_types[27] +#define SWIGTYPE_p_mfem__IdentityInterpolator swig_types[28] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[29] +#define SWIGTYPE_p_mfem__InverseIntegrator swig_types[30] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[31] +#define SWIGTYPE_p_mfem__LinearForm swig_types[32] +#define SWIGTYPE_p_mfem__LumpedIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__MassIntegrator swig_types[34] +#define SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator swig_types[35] +#define SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator swig_types[36] +#define SWIGTYPE_p_mfem__MixedCrossCurlIntegrator swig_types[37] +#define SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator swig_types[38] +#define SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator swig_types[39] +#define SWIGTYPE_p_mfem__MixedCrossGradIntegrator swig_types[40] +#define SWIGTYPE_p_mfem__MixedCrossProductIntegrator swig_types[41] +#define SWIGTYPE_p_mfem__MixedCurlCurlIntegrator swig_types[42] +#define SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator swig_types[43] +#define SWIGTYPE_p_mfem__MixedDivGradIntegrator swig_types[44] +#define SWIGTYPE_p_mfem__MixedDotProductIntegrator swig_types[45] +#define SWIGTYPE_p_mfem__MixedGradDivIntegrator swig_types[46] +#define SWIGTYPE_p_mfem__MixedGradGradIntegrator swig_types[47] +#define SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator swig_types[48] +#define SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator swig_types[49] +#define SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator swig_types[50] +#define SWIGTYPE_p_mfem__MixedScalarCurlIntegrator swig_types[51] +#define SWIGTYPE_p_mfem__MixedScalarDerivativeIntegrator swig_types[52] +#define SWIGTYPE_p_mfem__MixedScalarDivergenceIntegrator swig_types[53] +#define SWIGTYPE_p_mfem__MixedScalarIntegrator swig_types[54] +#define SWIGTYPE_p_mfem__MixedScalarMassIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__MixedScalarVectorIntegrator swig_types[56] +#define SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator swig_types[57] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator swig_types[58] +#define SWIGTYPE_p_mfem__MixedScalarWeakCurlIntegrator swig_types[59] +#define SWIGTYPE_p_mfem__MixedScalarWeakDerivativeIntegrator swig_types[60] +#define SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator swig_types[61] +#define SWIGTYPE_p_mfem__MixedScalarWeakGradientIntegrator swig_types[62] +#define SWIGTYPE_p_mfem__MixedVectorCurlIntegrator swig_types[63] +#define SWIGTYPE_p_mfem__MixedVectorDivergenceIntegrator swig_types[64] +#define SWIGTYPE_p_mfem__MixedVectorGradientIntegrator swig_types[65] +#define SWIGTYPE_p_mfem__MixedVectorIntegrator swig_types[66] +#define SWIGTYPE_p_mfem__MixedVectorMassIntegrator swig_types[67] +#define SWIGTYPE_p_mfem__MixedVectorProductIntegrator swig_types[68] +#define SWIGTYPE_p_mfem__MixedVectorWeakCurlIntegrator swig_types[69] +#define SWIGTYPE_p_mfem__MixedVectorWeakDivergenceIntegrator swig_types[70] +#define SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator swig_types[71] +#define SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator swig_types[72] +#define SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__NormalInterpolator swig_types[74] +#define SWIGTYPE_p_mfem__NormalTraceJumpIntegrator swig_types[75] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[76] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[77] +#define SWIGTYPE_p_mfem__ScalarProductInterpolator swig_types[78] +#define SWIGTYPE_p_mfem__ScalarVectorProductInterpolator swig_types[79] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[80] +#define SWIGTYPE_p_mfem__SumIntegrator swig_types[81] +#define SWIGTYPE_p_mfem__TraceJumpIntegrator swig_types[82] +#define SWIGTYPE_p_mfem__TransposeIntegrator swig_types[83] +#define SWIGTYPE_p_mfem__Vector swig_types[84] +#define SWIGTYPE_p_mfem__VectorCrossProductInterpolator swig_types[85] +#define SWIGTYPE_p_mfem__VectorCurlCurlIntegrator swig_types[86] +#define SWIGTYPE_p_mfem__VectorDiffusionIntegrator swig_types[87] +#define SWIGTYPE_p_mfem__VectorDivergenceIntegrator swig_types[88] +#define SWIGTYPE_p_mfem__VectorFECurlIntegrator swig_types[89] +#define SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator swig_types[90] +#define SWIGTYPE_p_mfem__VectorFEMassIntegrator swig_types[91] +#define SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator swig_types[92] +#define SWIGTYPE_p_mfem__VectorInnerProductInterpolator swig_types[93] +#define SWIGTYPE_p_mfem__VectorMassIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__VectorScalarProductInterpolator swig_types[95] +#define SWIGTYPE_p_pri_t swig_types[96] +#define SWIGTYPE_p_quad_t swig_types[97] +#define SWIGTYPE_p_seg_t swig_types[98] +#define SWIGTYPE_p_tet_t swig_types[99] +#define SWIGTYPE_p_tri_t swig_types[100] +static swig_type_info *swig_types[102]; +static swig_module_info swig_module = {swig_types, 101, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3851,6 +3853,7 @@ SWIGINTERN PyObject *Hybridization_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "Hybridization_SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, @@ -3868,6 +3871,21 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, + { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, + { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, + { "Hybridization_Init", _wrap_Hybridization_Init, METH_VARARGS, "Init(Hybridization self, intArray ess_tdof_list)"}, + { "Hybridization_AssembleMatrix", _wrap_Hybridization_AssembleMatrix, METH_VARARGS, "AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, + { "Hybridization_AssembleBdrMatrix", _wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS, "AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, + { "Hybridization_Finalize", _wrap_Hybridization_Finalize, METH_O, "Finalize(Hybridization self)"}, + { "Hybridization_GetMatrix", _wrap_Hybridization_GetMatrix, METH_O, "GetMatrix(Hybridization self) -> SparseMatrix"}, + { "Hybridization_ReduceRHS", _wrap_Hybridization_ReduceRHS, METH_VARARGS, "ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, + { "Hybridization_ComputeSolution", _wrap_Hybridization_ComputeSolution, METH_VARARGS, "ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, + { "Hybridization_Reset", _wrap_Hybridization_Reset, METH_O, "Reset(Hybridization self)"}, + { "Hybridization_swigregister", Hybridization_swigregister, METH_O, NULL}, + { "Hybridization_swiginit", Hybridization_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -3949,6 +3967,9 @@ static void *_p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, i static void *_p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiffusionIntegrator *) x)); } +static void *_p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) ((mfem::GradientIntegrator *) x)); +} static void *_p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedVectorIntegrator *) ((mfem::MixedVectorWeakDivergenceIntegrator *) x)); } @@ -4078,9 +4099,6 @@ static void *_p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormInteg static void *_p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::MixedScalarVectorIntegrator *) ((mfem::MixedScalarCrossProductIntegrator *) x)); } -static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); -} static void *_p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::ScalarVectorProductInterpolator *) x)); } @@ -4105,6 +4123,9 @@ static void *_p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator(void static void *_p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) ((mfem::DiscreteInterpolator *) x)); } +static void *_p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorScalarProductInterpolator *) x)); +} static void *_p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorCrossProductInterpolator *) x)); } @@ -4112,13 +4133,13 @@ static void *_p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormInteg return (void *)((mfem::BilinearFormIntegrator *) (mfem::DiscreteInterpolator *) ((mfem::VectorInnerProductInterpolator *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BilinearFormIntegrator = {"_p_mfem__BilinearFormIntegrator", "mfem::BilinearFormIntegrator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakGradientIntegrator = {"_p_mfem__MixedScalarWeakGradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakCrossProductIntegrator = {"_p_mfem__MixedScalarWeakCrossProductIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedDirectionalDerivativeIntegrator = {"_p_mfem__MixedDirectionalDerivativeIntegrator", 0, 0, 0, 0, 0}; @@ -4129,6 +4150,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorGradientIntegrator = {"_p_mfem_ static swig_type_info _swigt__p_mfem__MixedVectorCurlIntegrator = {"_p_mfem__MixedVectorCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakCurlIntegrator = {"_p_mfem__MixedVectorWeakCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedVectorWeakDivergenceIntegrator = {"_p_mfem__MixedVectorWeakDivergenceIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__GradientIntegrator = {"_p_mfem__GradientIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiffusionIntegrator = {"_p_mfem__DiffusionIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MassIntegrator = {"_p_mfem__MassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BoundaryMassIntegrator = {"_p_mfem__BoundaryMassIntegrator", 0, 0, 0, 0, 0}; @@ -4150,6 +4172,7 @@ static swig_type_info _swigt__p_mfem__VectorDivergenceIntegrator = {"_p_mfem__Ve static swig_type_info _swigt__p_mfem__VectorFEMassIntegrator = {"_p_mfem__VectorFEMassIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCurlCurlIntegrator = {"_p_mfem__VectorCurlCurlIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__CurlCurlIntegrator = {"_p_mfem__CurlCurlIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedGradGradIntegrator = {"_p_mfem__MixedGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCrossGradGradIntegrator = {"_p_mfem__MixedCrossGradGradIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedCurlCurlIntegrator = {"_p_mfem__MixedCurlCurlIntegrator", 0, 0, 0, 0, 0}; @@ -4182,8 +4205,7 @@ static swig_type_info _swigt__p_mfem__MixedVectorProductIntegrator = {"_p_mfem__ static swig_type_info _swigt__p_mfem__MixedScalarDerivativeIntegrator = {"_p_mfem__MixedScalarDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarWeakDerivativeIntegrator = {"_p_mfem__MixedScalarWeakDerivativeIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MixedScalarDivergenceIntegrator = {"_p_mfem__MixedScalarDivergenceIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DerivativeIntegrator = {"_p_mfem__DerivativeIntegrator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedVectorDivergenceIntegrator = {"_p_mfem__MixedVectorDivergenceIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarVectorProductInterpolator = {"_p_mfem__ScalarVectorProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ScalarProductInterpolator = {"_p_mfem__ScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NormalInterpolator = {"_p_mfem__NormalInterpolator", 0, 0, 0, 0, 0}; @@ -4192,6 +4214,7 @@ static swig_type_info _swigt__p_mfem__CurlInterpolator = {"_p_mfem__CurlInterpol static swig_type_info _swigt__p_mfem__IdentityInterpolator = {"_p_mfem__IdentityInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__GradientInterpolator = {"_p_mfem__GradientInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DiscreteInterpolator = {"_p_mfem__DiscreteInterpolator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorScalarProductInterpolator = {"_p_mfem__VectorScalarProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorCrossProductInterpolator = {"_p_mfem__VectorCrossProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorInnerProductInterpolator = {"_p_mfem__VectorInnerProductInterpolator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mfem::DenseMatrix *", 0, 0, (void*)0, 0}; @@ -4213,6 +4236,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, @@ -4234,6 +4258,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__DivergenceInterpolator, &_swigt__p_mfem__ElasticityIntegrator, &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GradientIntegrator, &_swigt__p_mfem__GradientInterpolator, &_swigt__p_mfem__GridFunction, &_swigt__p_mfem__GroupConvectionIntegrator, @@ -4314,12 +4339,12 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakGradientIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakCrossProductIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedDirectionalDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4330,6 +4355,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorGradientIntegrator[] = {{&_swig static swig_cast_info _swigc__p_mfem__MixedVectorCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakCurlIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedVectorWeakDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GradientIntegrator[] = {{&_swigt__p_mfem__GradientIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiffusionIntegrator[] = {{&_swigt__p_mfem__DiffusionIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MassIntegrator[] = {{&_swigt__p_mfem__MassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BoundaryMassIntegrator[] = {{&_swigt__p_mfem__BoundaryMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4351,6 +4377,7 @@ static swig_cast_info _swigc__p_mfem__VectorDivergenceIntegrator[] = {{&_swigt__ static swig_cast_info _swigc__p_mfem__VectorFEMassIntegrator[] = {{&_swigt__p_mfem__VectorFEMassIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCurlCurlIntegrator[] = {{&_swigt__p_mfem__VectorCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CurlCurlIntegrator[] = {{&_swigt__p_mfem__CurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedGradGradIntegrator[] = {{&_swigt__p_mfem__MixedGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCrossGradGradIntegrator[] = {{&_swigt__p_mfem__MixedCrossGradGradIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedCurlCurlIntegrator[] = {{&_swigt__p_mfem__MixedCurlCurlIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4383,8 +4410,7 @@ static swig_cast_info _swigc__p_mfem__MixedVectorProductIntegrator[] = {{&_swigt static swig_cast_info _swigc__p_mfem__MixedScalarDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarWeakDerivativeIntegrator[] = {{&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MixedScalarDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedScalarDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DerivativeIntegrator[] = {{&_swigt__p_mfem__DerivativeIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedVectorDivergenceIntegrator[] = {{&_swigt__p_mfem__MixedVectorDivergenceIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarVectorProductInterpolator[] = {{&_swigt__p_mfem__ScalarVectorProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ScalarProductInterpolator[] = {{&_swigt__p_mfem__ScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NormalInterpolator[] = {{&_swigt__p_mfem__NormalInterpolator, 0, 0, 0},{0, 0, 0, 0}}; @@ -4393,9 +4419,10 @@ static swig_cast_info _swigc__p_mfem__CurlInterpolator[] = {{&_swigt__p_mfem__Cu static swig_cast_info _swigc__p_mfem__IdentityInterpolator[] = {{&_swigt__p_mfem__IdentityInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GradientInterpolator[] = {{&_swigt__p_mfem__GradientInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DiscreteInterpolator[] = {{&_swigt__p_mfem__DiscreteInterpolator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorScalarProductInterpolator[] = {{&_swigt__p_mfem__VectorScalarProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCrossProductInterpolator[] = {{&_swigt__p_mfem__VectorCrossProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorInnerProductInterpolator[] = {{&_swigt__p_mfem__VectorInnerProductInterpolator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearFormIntegrator[] = { {&_swigt__p_mfem__MixedScalarWeakGradientIntegrator, _p_mfem__MixedScalarWeakGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCrossProductIntegrator, _p_mfem__MixedScalarWeakCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDirectionalDerivativeIntegrator, _p_mfem__MixedDirectionalDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradDivIntegrator, _p_mfem__MixedGradDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDivGradIntegrator, _p_mfem__MixedDivGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDivergenceIntegrator, _p_mfem__MixedScalarWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorGradientIntegrator, _p_mfem__MixedVectorGradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorCurlIntegrator, _p_mfem__MixedVectorCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakCurlIntegrator, _p_mfem__MixedVectorWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorWeakDivergenceIntegrator, _p_mfem__MixedVectorWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientIntegrator, _p_mfem__GradientIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiffusionIntegrator, _p_mfem__DiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MassIntegrator, _p_mfem__MassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryMassIntegrator, _p_mfem__BoundaryMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ConvectionIntegrator, _p_mfem__ConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GroupConvectionIntegrator, _p_mfem__GroupConvectionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorMassIntegrator, _p_mfem__VectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDivergenceIntegrator, _p_mfem__VectorFEDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEWeakDivergenceIntegrator, _p_mfem__VectorFEWeakDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFECurlIntegrator, _p_mfem__VectorFECurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalTraceJumpIntegrator, _p_mfem__NormalTraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TraceJumpIntegrator, _p_mfem__TraceJumpIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGElasticityIntegrator, _p_mfem__DGElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDiffusionIntegrator, _p_mfem__DGDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGTraceIntegrator, _p_mfem__DGTraceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ElasticityIntegrator, _p_mfem__ElasticityIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDiffusionIntegrator, _p_mfem__VectorDiffusionIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivDivIntegrator, _p_mfem__DivDivIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDivergenceIntegrator, _p_mfem__VectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEMassIntegrator, _p_mfem__VectorFEMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCurlCurlIntegrator, _p_mfem__VectorCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlCurlIntegrator, _p_mfem__CurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DerivativeIntegrator, _p_mfem__DerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedGradGradIntegrator, _p_mfem__MixedGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradGradIntegrator, _p_mfem__MixedCrossGradGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCurlCurlIntegrator, _p_mfem__MixedCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlCurlIntegrator, _p_mfem__MixedCrossCurlCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlGradIntegrator, _p_mfem__MixedCrossCurlGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradCurlIntegrator, _p_mfem__MixedCrossGradCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakCurlCrossIntegrator, _p_mfem__MixedWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlCrossIntegrator, _p_mfem__MixedScalarWeakCurlCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossGradIntegrator, _p_mfem__MixedCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossCurlIntegrator, _p_mfem__MixedCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossCurlIntegrator, _p_mfem__MixedScalarCrossCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossGradIntegrator, _p_mfem__MixedScalarCrossGradIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCrossProductIntegrator, _p_mfem__MixedScalarCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BilinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__MixedWeakDivCrossIntegrator, _p_mfem__MixedWeakDivCrossIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedWeakGradDotIntegrator, _p_mfem__MixedWeakGradDotIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedDotProductIntegrator, _p_mfem__MixedDotProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedCrossProductIntegrator, _p_mfem__MixedCrossProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorMassIntegrator, _p_mfem__MixedVectorMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakCurlIntegrator, _p_mfem__MixedScalarWeakCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarCurlIntegrator, _p_mfem__MixedScalarCurlIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__TransposeIntegrator, _p_mfem__TransposeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LumpedIntegrator, _p_mfem__LumpedIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__InverseIntegrator, _p_mfem__InverseIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__SumIntegrator, _p_mfem__SumIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarIntegrator, _p_mfem__MixedScalarIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorIntegrator, _p_mfem__MixedVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarVectorIntegrator, _p_mfem__MixedScalarVectorIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarMassIntegrator, _p_mfem__MixedScalarMassIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorProductIntegrator, _p_mfem__MixedVectorProductIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDerivativeIntegrator, _p_mfem__MixedScalarDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarWeakDerivativeIntegrator, _p_mfem__MixedScalarWeakDerivativeIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedScalarDivergenceIntegrator, _p_mfem__MixedScalarDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__MixedVectorDivergenceIntegrator, _p_mfem__MixedVectorDivergenceIntegratorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductInterpolator, _p_mfem__ScalarVectorProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__ScalarProductInterpolator, _p_mfem__ScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__NormalInterpolator, _p_mfem__NormalInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DivergenceInterpolator, _p_mfem__DivergenceInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__CurlInterpolator, _p_mfem__CurlInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__IdentityInterpolator, _p_mfem__IdentityInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__GradientInterpolator, _p_mfem__GradientInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DiscreteInterpolator, _p_mfem__DiscreteInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorScalarProductInterpolator, _p_mfem__VectorScalarProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorCrossProductInterpolator, _p_mfem__VectorCrossProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorInnerProductInterpolator, _p_mfem__VectorInnerProductInterpolatorTo_p_mfem__BilinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -4415,6 +4442,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, @@ -4436,6 +4464,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__DivergenceInterpolator, _swigc__p_mfem__ElasticityIntegrator, _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GradientIntegrator, _swigc__p_mfem__GradientInterpolator, _swigc__p_mfem__GridFunction, _swigc__p_mfem__GroupConvectionIntegrator, diff --git a/mfem/_ser/intrules.py b/mfem/_ser/intrules.py index 3646f0d1..fd76756c 100644 --- a/mfem/_ser/intrules.py +++ b/mfem/_ser/intrules.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _intrules.SWIG_PyInstanceMethod_New +_swig_new_static_method = _intrules.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -71,7 +74,9 @@ class IntegrationPointArray(object): def __init__(self, *args): r""" - __init__(IntegrationPointArray self, int asize=0) -> IntegrationPointArray + __init__(IntegrationPointArray self) -> IntegrationPointArray + __init__(IntegrationPointArray self, mfem::MemoryType mt) -> IntegrationPointArray + __init__(IntegrationPointArray self, int asize) -> IntegrationPointArray __init__(IntegrationPointArray self, IntegrationPoint _data, int asize) -> IntegrationPointArray __init__(IntegrationPointArray self, IntegrationPointArray src) -> IntegrationPointArray """ @@ -90,6 +95,7 @@ def GetData(self, *args): GetData(IntegrationPointArray self) -> IntegrationPoint """ return _intrules.IntegrationPointArray_GetData(self, *args) + GetData = _swig_new_instance_method(_intrules.IntegrationPointArray_GetData) def GetMemory(self, *args): r""" @@ -97,30 +103,37 @@ def GetMemory(self, *args): GetMemory(IntegrationPointArray self) -> mfem::Memory< mfem::IntegrationPoint > const & """ return _intrules.IntegrationPointArray_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_intrules.IntegrationPointArray_GetMemory) def UseDevice(self): r"""UseDevice(IntegrationPointArray self) -> bool""" return _intrules.IntegrationPointArray_UseDevice(self) + UseDevice = _swig_new_instance_method(_intrules.IntegrationPointArray_UseDevice) def OwnsData(self): r"""OwnsData(IntegrationPointArray self) -> bool""" return _intrules.IntegrationPointArray_OwnsData(self) + OwnsData = _swig_new_instance_method(_intrules.IntegrationPointArray_OwnsData) def StealData(self, p): r"""StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)""" return _intrules.IntegrationPointArray_StealData(self, p) + StealData = _swig_new_instance_method(_intrules.IntegrationPointArray_StealData) def LoseData(self): r"""LoseData(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_LoseData(self) + LoseData = _swig_new_instance_method(_intrules.IntegrationPointArray_LoseData) def MakeDataOwner(self): r"""MakeDataOwner(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_intrules.IntegrationPointArray_MakeDataOwner) def Size(self): r"""Size(IntegrationPointArray self) -> int""" return _intrules.IntegrationPointArray_Size(self) + Size = _swig_new_instance_method(_intrules.IntegrationPointArray_Size) def SetSize(self, *args): r""" @@ -129,14 +142,17 @@ def SetSize(self, *args): SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt) """ return _intrules.IntegrationPointArray_SetSize(self, *args) + SetSize = _swig_new_instance_method(_intrules.IntegrationPointArray_SetSize) def Capacity(self): r"""Capacity(IntegrationPointArray self) -> int""" return _intrules.IntegrationPointArray_Capacity(self) + Capacity = _swig_new_instance_method(_intrules.IntegrationPointArray_Capacity) def Reserve(self, capacity): r"""Reserve(IntegrationPointArray self, int capacity)""" return _intrules.IntegrationPointArray_Reserve(self, capacity) + Reserve = _swig_new_instance_method(_intrules.IntegrationPointArray_Reserve) def Append(self, *args): r""" @@ -145,10 +161,12 @@ def Append(self, *args): Append(IntegrationPointArray self, IntegrationPointArray els) -> int """ return _intrules.IntegrationPointArray_Append(self, *args) + Append = _swig_new_instance_method(_intrules.IntegrationPointArray_Append) def Prepend(self, el): r"""Prepend(IntegrationPointArray self, IntegrationPoint el) -> int""" return _intrules.IntegrationPointArray_Prepend(self, el) + Prepend = _swig_new_instance_method(_intrules.IntegrationPointArray_Prepend) def Last(self, *args): r""" @@ -156,18 +174,22 @@ def Last(self, *args): Last(IntegrationPointArray self) -> IntegrationPoint """ return _intrules.IntegrationPointArray_Last(self, *args) + Last = _swig_new_instance_method(_intrules.IntegrationPointArray_Last) def DeleteLast(self): r"""DeleteLast(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_DeleteLast(self) + DeleteLast = _swig_new_instance_method(_intrules.IntegrationPointArray_DeleteLast) def DeleteAll(self): r"""DeleteAll(IntegrationPointArray self)""" return _intrules.IntegrationPointArray_DeleteAll(self) + DeleteAll = _swig_new_instance_method(_intrules.IntegrationPointArray_DeleteAll) def Copy(self, copy): r"""Copy(IntegrationPointArray self, IntegrationPointArray copy)""" return _intrules.IntegrationPointArray_Copy(self, copy) + Copy = _swig_new_instance_method(_intrules.IntegrationPointArray_Copy) def MakeRef(self, *args): r""" @@ -175,54 +197,73 @@ def MakeRef(self, *args): MakeRef(IntegrationPointArray self, IntegrationPointArray master) """ return _intrules.IntegrationPointArray_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_intrules.IntegrationPointArray_MakeRef) def GetSubArray(self, offset, sa_size, sa): r"""GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)""" return _intrules.IntegrationPointArray_GetSubArray(self, offset, sa_size, sa) + GetSubArray = _swig_new_instance_method(_intrules.IntegrationPointArray_GetSubArray) - def begin(self): - r"""begin(IntegrationPointArray self) -> IntegrationPoint""" - return _intrules.IntegrationPointArray_begin(self) + def begin(self, *args): + r""" + begin(IntegrationPointArray self) -> IntegrationPoint + begin(IntegrationPointArray self) -> IntegrationPoint + """ + return _intrules.IntegrationPointArray_begin(self, *args) + begin = _swig_new_instance_method(_intrules.IntegrationPointArray_begin) - def end(self): - r"""end(IntegrationPointArray self) -> IntegrationPoint""" - return _intrules.IntegrationPointArray_end(self) + def end(self, *args): + r""" + end(IntegrationPointArray self) -> IntegrationPoint + end(IntegrationPointArray self) -> IntegrationPoint + """ + return _intrules.IntegrationPointArray_end(self, *args) + end = _swig_new_instance_method(_intrules.IntegrationPointArray_end) def MemoryUsage(self): r"""MemoryUsage(IntegrationPointArray self) -> long""" return _intrules.IntegrationPointArray_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_intrules.IntegrationPointArray_MemoryUsage) def Read(self, on_dev=True): r"""Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint""" return _intrules.IntegrationPointArray_Read(self, on_dev) + Read = _swig_new_instance_method(_intrules.IntegrationPointArray_Read) def HostRead(self): r"""HostRead(IntegrationPointArray self) -> IntegrationPoint""" return _intrules.IntegrationPointArray_HostRead(self) + HostRead = _swig_new_instance_method(_intrules.IntegrationPointArray_HostRead) def Write(self, on_dev=True): r"""Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint""" return _intrules.IntegrationPointArray_Write(self, on_dev) + Write = _swig_new_instance_method(_intrules.IntegrationPointArray_Write) def HostWrite(self): r"""HostWrite(IntegrationPointArray self) -> IntegrationPoint""" return _intrules.IntegrationPointArray_HostWrite(self) + HostWrite = _swig_new_instance_method(_intrules.IntegrationPointArray_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint""" return _intrules.IntegrationPointArray_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_intrules.IntegrationPointArray_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(IntegrationPointArray self) -> IntegrationPoint""" return _intrules.IntegrationPointArray_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_intrules.IntegrationPointArray_HostReadWrite) def __setitem__(self, i, v): r"""__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)""" return _intrules.IntegrationPointArray___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_intrules.IntegrationPointArray___setitem__) def __getitem__(self, i): r"""__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint""" return _intrules.IntegrationPointArray___getitem__(self, i) + __getitem__ = _swig_new_instance_method(_intrules.IntegrationPointArray___getitem__) def Assign(self, *args): r""" @@ -230,6 +271,7 @@ def Assign(self, *args): Assign(IntegrationPointArray self, IntegrationPoint a) """ return _intrules.IntegrationPointArray_Assign(self, *args) + Assign = _swig_new_instance_method(_intrules.IntegrationPointArray_Assign) def ToList(self): return [self[i] for i in range(self.Size())] @@ -248,14 +290,17 @@ class IntegrationPoint(object): y = property(_intrules.IntegrationPoint_y_get, _intrules.IntegrationPoint_y_set, doc=r"""y : double""") z = property(_intrules.IntegrationPoint_z_get, _intrules.IntegrationPoint_z_set, doc=r"""z : double""") weight = property(_intrules.IntegrationPoint_weight_get, _intrules.IntegrationPoint_weight_set, doc=r"""weight : double""") + index = property(_intrules.IntegrationPoint_index_get, _intrules.IntegrationPoint_index_set, doc=r"""index : int""") - def Init(self): - r"""Init(IntegrationPoint self)""" - return _intrules.IntegrationPoint_Init(self) + def Init(self, i): + r"""Init(IntegrationPoint self, int const i)""" + return _intrules.IntegrationPoint_Init(self, i) + Init = _swig_new_instance_method(_intrules.IntegrationPoint_Init) def Get(self, p, dim): r"""Get(IntegrationPoint self, double * p, int const dim)""" return _intrules.IntegrationPoint_Get(self, p, dim) + Get = _swig_new_instance_method(_intrules.IntegrationPoint_Get) def Set(self, *args): r""" @@ -263,10 +308,12 @@ def Set(self, *args): Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w) """ return _intrules.IntegrationPoint_Set(self, *args) + Set = _swig_new_instance_method(_intrules.IntegrationPoint_Set) def Set3w(self, p): r"""Set3w(IntegrationPoint self, double const * p)""" return _intrules.IntegrationPoint_Set3w(self, p) + Set3w = _swig_new_instance_method(_intrules.IntegrationPoint_Set3w) def Set3(self, *args): r""" @@ -274,6 +321,7 @@ def Set3(self, *args): Set3(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set3(self, *args) + Set3 = _swig_new_instance_method(_intrules.IntegrationPoint_Set3) def Set2w(self, *args): r""" @@ -281,6 +329,7 @@ def Set2w(self, *args): Set2w(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set2w(self, *args) + Set2w = _swig_new_instance_method(_intrules.IntegrationPoint_Set2w) def Set2(self, *args): r""" @@ -288,6 +337,7 @@ def Set2(self, *args): Set2(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set2(self, *args) + Set2 = _swig_new_instance_method(_intrules.IntegrationPoint_Set2) def Set1w(self, *args): r""" @@ -295,6 +345,7 @@ def Set1w(self, *args): Set1w(IntegrationPoint self, double const * p) """ return _intrules.IntegrationPoint_Set1w(self, *args) + Set1w = _swig_new_instance_method(_intrules.IntegrationPoint_Set1w) def __init__(self): r"""__init__(IntegrationPoint self) -> IntegrationPoint""" @@ -322,14 +373,17 @@ def __init__(self, *args): def GetOrder(self): r"""GetOrder(IntegrationRule self) -> int""" return _intrules.IntegrationRule_GetOrder(self) + GetOrder = _swig_new_instance_method(_intrules.IntegrationRule_GetOrder) def SetOrder(self, order): r"""SetOrder(IntegrationRule self, int const order)""" return _intrules.IntegrationRule_SetOrder(self, order) + SetOrder = _swig_new_instance_method(_intrules.IntegrationRule_SetOrder) def GetNPoints(self): r"""GetNPoints(IntegrationRule self) -> int""" return _intrules.IntegrationRule_GetNPoints(self) + GetNPoints = _swig_new_instance_method(_intrules.IntegrationRule_GetNPoints) def IntPoint(self, *args): r""" @@ -337,10 +391,12 @@ def IntPoint(self, *args): IntPoint(IntegrationRule self, int i) -> IntegrationPoint """ return _intrules.IntegrationRule_IntPoint(self, *args) + IntPoint = _swig_new_instance_method(_intrules.IntegrationRule_IntPoint) def GetWeights(self): r"""GetWeights(IntegrationRule self) -> doubleArray""" return _intrules.IntegrationRule_GetWeights(self) + GetWeights = _swig_new_instance_method(_intrules.IntegrationRule_GetWeights) __swig_destroy__ = _intrules.delete_IntegrationRule # Register IntegrationRule in _intrules: @@ -355,26 +411,32 @@ class QuadratureFunctions1D(object): def GaussLegendre(self, np, ir): r"""GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_GaussLegendre(self, np, ir) + GaussLegendre = _swig_new_instance_method(_intrules.QuadratureFunctions1D_GaussLegendre) def GaussLobatto(self, np, ir): r"""GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_GaussLobatto(self, np, ir) + GaussLobatto = _swig_new_instance_method(_intrules.QuadratureFunctions1D_GaussLobatto) def OpenUniform(self, np, ir): r"""OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_OpenUniform(self, np, ir) + OpenUniform = _swig_new_instance_method(_intrules.QuadratureFunctions1D_OpenUniform) def ClosedUniform(self, np, ir): r"""ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_ClosedUniform(self, np, ir) + ClosedUniform = _swig_new_instance_method(_intrules.QuadratureFunctions1D_ClosedUniform) def OpenHalfUniform(self, np, ir): r"""OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)""" return _intrules.QuadratureFunctions1D_OpenHalfUniform(self, np, ir) + OpenHalfUniform = _swig_new_instance_method(_intrules.QuadratureFunctions1D_OpenHalfUniform) def GivePolyPoints(self, np, pts, type): r"""GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)""" return _intrules.QuadratureFunctions1D_GivePolyPoints(self, np, pts, type) + GivePolyPoints = _swig_new_instance_method(_intrules.QuadratureFunctions1D_GivePolyPoints) def __init__(self): r"""__init__(QuadratureFunctions1D self) -> QuadratureFunctions1D""" @@ -406,11 +468,13 @@ class Quadrature1D(object): def CheckClosed(type): r"""CheckClosed(int type) -> int""" return _intrules.Quadrature1D_CheckClosed(type) + CheckClosed = _swig_new_static_method(_intrules.Quadrature1D_CheckClosed) @staticmethod def CheckOpen(type): r"""CheckOpen(int type) -> int""" return _intrules.Quadrature1D_CheckOpen(type) + CheckOpen = _swig_new_static_method(_intrules.Quadrature1D_CheckOpen) def __init__(self): r"""__init__(Quadrature1D self) -> Quadrature1D""" @@ -423,10 +487,12 @@ def __init__(self): def Quadrature1D_CheckClosed(type): r"""Quadrature1D_CheckClosed(int type) -> int""" return _intrules.Quadrature1D_CheckClosed(type) +Quadrature1D_CheckClosed = _intrules.Quadrature1D_CheckClosed def Quadrature1D_CheckOpen(type): r"""Quadrature1D_CheckOpen(int type) -> int""" return _intrules.Quadrature1D_CheckOpen(type) +Quadrature1D_CheckOpen = _intrules.Quadrature1D_CheckOpen class IntegrationRules(object): r"""Proxy of C++ mfem::IntegrationRules class.""" @@ -441,14 +507,17 @@ def __init__(self, *args): def Get(self, GeomType, Order): r"""Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule""" return _intrules.IntegrationRules_Get(self, GeomType, Order) + Get = _swig_new_instance_method(_intrules.IntegrationRules_Get) def Set(self, GeomType, Order, IntRule): r"""Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)""" return _intrules.IntegrationRules_Set(self, GeomType, Order, IntRule) + Set = _swig_new_instance_method(_intrules.IntegrationRules_Set) def SetOwnRules(self, o): r"""SetOwnRules(IntegrationRules self, int o)""" return _intrules.IntegrationRules_SetOwnRules(self, o) + SetOwnRules = _swig_new_instance_method(_intrules.IntegrationRules_SetOwnRules) __swig_destroy__ = _intrules.delete_IntegrationRules # Register IntegrationRules in _intrules: diff --git a/mfem/_ser/intrules_wrap.cxx b/mfem/_ser/intrules_wrap.cxx index 657addca..751a9430 100644 --- a/mfem/_ser/intrules_wrap.cxx +++ b/mfem/_ser/intrules_wrap.cxx @@ -2977,9 +2977,37 @@ SWIGINTERN void mfem_Array_Sl_mfem_IntegrationPoint_Sg__FakeToList(mfem::Array< #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - int arg1 ; + mfem::Array< mfem::IntegrationPoint > *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; mfem::Array< mfem::IntegrationPoint > *result = 0 ; @@ -2987,9 +3015,9 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSE if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationPointArray" "', argument " "1"" of type '" "int""'"); + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationPointArray" "', argument " "1"" of type '" "mfem::MemoryType""'"); } - arg1 = static_cast< int >(val1); + arg1 = static_cast< mfem::MemoryType >(val1); { try { result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(arg1); @@ -3013,14 +3041,22 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; + int arg1 ; + int val1 ; + int ecode1 = 0 ; mfem::Array< mfem::IntegrationPoint > *result = 0 ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationPointArray" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); { try { - result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(); + result = (mfem::Array< mfem::IntegrationPoint > *)new mfem::Array< mfem::IntegrationPoint >(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3041,7 +3077,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; int arg2 ; @@ -3085,7 +3121,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_2(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationPointArray__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = 0 ; void *argp1 = 0 ; @@ -3133,14 +3169,24 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntegrationPointArray", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_IntegrationPointArray__SWIG_1(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_IntegrationPointArray__SWIG_3(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_4(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_int(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_IntegrationPointArray__SWIG_2(self, argc, argv); } } if (argc == 1) { @@ -3150,7 +3196,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_IntegrationPointArray__SWIG_0(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_1(self, argc, argv); } } if (argc == 2) { @@ -3164,7 +3210,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_IntegrationPointArray__SWIG_2(self, argc, argv); + return _wrap_new_IntegrationPointArray__SWIG_3(self, argc, argv); } } } @@ -3172,8 +3218,9 @@ SWIGINTERN PyObject *_wrap_new_IntegrationPointArray(PyObject *self, PyObject *a fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntegrationPointArray'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::Array(int)\n" " mfem::Array< mfem::IntegrationPoint >::Array()\n" + " mfem::Array< mfem::IntegrationPoint >::Array(mfem::MemoryType)\n" + " mfem::Array< mfem::IntegrationPoint >::Array(int)\n" " mfem::Array< mfem::IntegrationPoint >::Array(mfem::IntegrationPoint *,int)\n" " mfem::Array< mfem::IntegrationPoint >::Array(mfem::Array< mfem::IntegrationPoint > const &)\n"); return 0; @@ -4711,16 +4758,14 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Assign__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::IntegrationPoint *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_begin" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); @@ -4749,16 +4794,14 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_end__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::IntegrationPoint *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_end" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); @@ -4787,6 +4830,150 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_end(PyObject *SWIGUNUSEDPARM(se } +SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::IntegrationPoint *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_begin" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); + { + try { + result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->begin(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPointArray_begin(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_begin", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_begin__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_begin__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_begin'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< mfem::IntegrationPoint >::begin()\n" + " mfem::Array< mfem::IntegrationPoint >::begin() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPointArray_end__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::IntegrationPoint *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_end" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); + } + arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); + { + try { + result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->end(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPointArray_end(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_end", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_end__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_IntegrationPointArray_end__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_end'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< mfem::IntegrationPoint >::end()\n" + " mfem::Array< mfem::IntegrationPoint >::end() const\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_IntegrationPointArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5757,23 +5944,82 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_weight_get(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_index_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_index_set" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); + } + arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPoint_index_set" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + if (arg1) (arg1)->index = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPoint_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + int result; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_index_get" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); + } + arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); + result = (int) ((arg1)->index); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Init" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPoint_Init" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); { try { - (arg1)->Init(); + (arg1)->Init(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8296,8 +8542,11 @@ SWIGINTERN PyObject *Swig_var_RefinedIntRules_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_IntegrationPointArray", _wrap_new_IntegrationPointArray, METH_VARARGS, "\n" - "IntegrationPointArray(int asize=0)\n" + "IntegrationPointArray()\n" + "IntegrationPointArray(mfem::MemoryType mt)\n" + "IntegrationPointArray(int asize)\n" "IntegrationPointArray(IntegrationPoint _data, int asize)\n" "new_IntegrationPointArray(IntegrationPointArray src) -> IntegrationPointArray\n" ""}, @@ -8341,8 +8590,14 @@ static PyMethodDef SwigMethods[] = { "IntegrationPointArray_MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" ""}, { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "IntegrationPointArray_GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, - { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_O, "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_end", _wrap_IntegrationPointArray_end, METH_O, "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" + "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" + "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_end", _wrap_IntegrationPointArray_end, METH_VARARGS, "\n" + "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint\n" + "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "IntegrationPointArray_MemoryUsage(IntegrationPointArray self) -> long"}, { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "IntegrationPointArray_Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "IntegrationPointArray_HostRead(IntegrationPointArray self) -> IntegrationPoint"}, @@ -8367,7 +8622,9 @@ static PyMethodDef SwigMethods[] = { { "IntegrationPoint_z_get", _wrap_IntegrationPoint_z_get, METH_O, "IntegrationPoint_z_get(IntegrationPoint self) -> double"}, { "IntegrationPoint_weight_set", _wrap_IntegrationPoint_weight_set, METH_VARARGS, "IntegrationPoint_weight_set(IntegrationPoint self, double weight)"}, { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, - { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_O, "IntegrationPoint_Init(IntegrationPoint self)"}, + { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, + { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, + { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "IntegrationPoint_Init(IntegrationPoint self, int const i)"}, { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "IntegrationPoint_Get(IntegrationPoint self, double * p, int const dim)"}, { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" "IntegrationPoint_Set(IntegrationPoint self, double const * p, int const dim)\n" @@ -8438,6 +8695,156 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_IntegrationPointArray", _wrap_new_IntegrationPointArray, METH_VARARGS, "\n" + "IntegrationPointArray()\n" + "IntegrationPointArray(mfem::MemoryType mt)\n" + "IntegrationPointArray(int asize)\n" + "IntegrationPointArray(IntegrationPoint _data, int asize)\n" + "new_IntegrationPointArray(IntegrationPointArray src) -> IntegrationPointArray\n" + ""}, + { "delete_IntegrationPointArray", _wrap_delete_IntegrationPointArray, METH_O, "delete_IntegrationPointArray(IntegrationPointArray self)"}, + { "IntegrationPointArray_GetData", _wrap_IntegrationPointArray_GetData, METH_VARARGS, "\n" + "GetData(IntegrationPointArray self) -> IntegrationPoint\n" + "GetData(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_GetMemory", _wrap_IntegrationPointArray_GetMemory, METH_VARARGS, "\n" + "GetMemory(IntegrationPointArray self) -> mfem::Memory< mfem::IntegrationPoint >\n" + "GetMemory(IntegrationPointArray self) -> mfem::Memory< mfem::IntegrationPoint > const &\n" + ""}, + { "IntegrationPointArray_UseDevice", _wrap_IntegrationPointArray_UseDevice, METH_O, "UseDevice(IntegrationPointArray self) -> bool"}, + { "IntegrationPointArray_OwnsData", _wrap_IntegrationPointArray_OwnsData, METH_O, "OwnsData(IntegrationPointArray self) -> bool"}, + { "IntegrationPointArray_StealData", _wrap_IntegrationPointArray_StealData, METH_VARARGS, "StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, + { "IntegrationPointArray_LoseData", _wrap_IntegrationPointArray_LoseData, METH_O, "LoseData(IntegrationPointArray self)"}, + { "IntegrationPointArray_MakeDataOwner", _wrap_IntegrationPointArray_MakeDataOwner, METH_O, "MakeDataOwner(IntegrationPointArray self)"}, + { "IntegrationPointArray_Size", _wrap_IntegrationPointArray_Size, METH_O, "Size(IntegrationPointArray self) -> int"}, + { "IntegrationPointArray_SetSize", _wrap_IntegrationPointArray_SetSize, METH_VARARGS, "\n" + "SetSize(IntegrationPointArray self, int nsize)\n" + "SetSize(IntegrationPointArray self, int nsize, IntegrationPoint initval)\n" + "SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt)\n" + ""}, + { "IntegrationPointArray_Capacity", _wrap_IntegrationPointArray_Capacity, METH_O, "Capacity(IntegrationPointArray self) -> int"}, + { "IntegrationPointArray_Reserve", _wrap_IntegrationPointArray_Reserve, METH_VARARGS, "Reserve(IntegrationPointArray self, int capacity)"}, + { "IntegrationPointArray_Append", _wrap_IntegrationPointArray_Append, METH_VARARGS, "\n" + "Append(IntegrationPointArray self, IntegrationPoint el) -> int\n" + "Append(IntegrationPointArray self, IntegrationPoint els, int nels) -> int\n" + "Append(IntegrationPointArray self, IntegrationPointArray els) -> int\n" + ""}, + { "IntegrationPointArray_Prepend", _wrap_IntegrationPointArray_Prepend, METH_VARARGS, "Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, + { "IntegrationPointArray_Last", _wrap_IntegrationPointArray_Last, METH_VARARGS, "\n" + "Last(IntegrationPointArray self) -> IntegrationPoint\n" + "Last(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_DeleteLast", _wrap_IntegrationPointArray_DeleteLast, METH_O, "DeleteLast(IntegrationPointArray self)"}, + { "IntegrationPointArray_DeleteAll", _wrap_IntegrationPointArray_DeleteAll, METH_O, "DeleteAll(IntegrationPointArray self)"}, + { "IntegrationPointArray_Copy", _wrap_IntegrationPointArray_Copy, METH_VARARGS, "Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, + { "IntegrationPointArray_MakeRef", _wrap_IntegrationPointArray_MakeRef, METH_VARARGS, "\n" + "MakeRef(IntegrationPointArray self, IntegrationPoint arg2, int arg3)\n" + "MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" + ""}, + { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, + { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" + "begin(IntegrationPointArray self) -> IntegrationPoint\n" + "begin(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_end", _wrap_IntegrationPointArray_end, METH_VARARGS, "\n" + "end(IntegrationPointArray self) -> IntegrationPoint\n" + "end(IntegrationPointArray self) -> IntegrationPoint\n" + ""}, + { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "MemoryUsage(IntegrationPointArray self) -> long"}, + { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "HostRead(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray_Write", _wrap_IntegrationPointArray_Write, METH_VARARGS, "Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_HostWrite", _wrap_IntegrationPointArray_HostWrite, METH_O, "HostWrite(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray_ReadWrite", _wrap_IntegrationPointArray_ReadWrite, METH_VARARGS, "ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_HostReadWrite", _wrap_IntegrationPointArray_HostReadWrite, METH_O, "HostReadWrite(IntegrationPointArray self) -> IntegrationPoint"}, + { "IntegrationPointArray___setitem__", _wrap_IntegrationPointArray___setitem__, METH_VARARGS, "__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, + { "IntegrationPointArray___getitem__", _wrap_IntegrationPointArray___getitem__, METH_VARARGS, "__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, + { "IntegrationPointArray_Assign", _wrap_IntegrationPointArray_Assign, METH_VARARGS, "\n" + "Assign(IntegrationPointArray self, IntegrationPoint arg2)\n" + "Assign(IntegrationPointArray self, IntegrationPoint a)\n" + ""}, + { "IntegrationPointArray_FakeToList", _wrap_IntegrationPointArray_FakeToList, METH_O, "FakeToList(IntegrationPointArray self)"}, + { "IntegrationPointArray_swigregister", IntegrationPointArray_swigregister, METH_O, NULL}, + { "IntegrationPointArray_swiginit", IntegrationPointArray_swiginit, METH_VARARGS, NULL}, + { "IntegrationPoint_x_set", _wrap_IntegrationPoint_x_set, METH_VARARGS, "IntegrationPoint_x_set(IntegrationPoint self, double x)"}, + { "IntegrationPoint_x_get", _wrap_IntegrationPoint_x_get, METH_O, "IntegrationPoint_x_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_y_set", _wrap_IntegrationPoint_y_set, METH_VARARGS, "IntegrationPoint_y_set(IntegrationPoint self, double y)"}, + { "IntegrationPoint_y_get", _wrap_IntegrationPoint_y_get, METH_O, "IntegrationPoint_y_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_z_set", _wrap_IntegrationPoint_z_set, METH_VARARGS, "IntegrationPoint_z_set(IntegrationPoint self, double z)"}, + { "IntegrationPoint_z_get", _wrap_IntegrationPoint_z_get, METH_O, "IntegrationPoint_z_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_weight_set", _wrap_IntegrationPoint_weight_set, METH_VARARGS, "IntegrationPoint_weight_set(IntegrationPoint self, double weight)"}, + { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, + { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, + { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, + { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "Init(IntegrationPoint self, int const i)"}, + { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "Get(IntegrationPoint self, double * p, int const dim)"}, + { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" + "Set(IntegrationPoint self, double const * p, int const dim)\n" + "Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w)\n" + ""}, + { "IntegrationPoint_Set3w", _wrap_IntegrationPoint_Set3w, METH_VARARGS, "Set3w(IntegrationPoint self, double const * p)"}, + { "IntegrationPoint_Set3", _wrap_IntegrationPoint_Set3, METH_VARARGS, "\n" + "Set3(IntegrationPoint self, double const x1, double const x2, double const x3)\n" + "Set3(IntegrationPoint self, double const * p)\n" + ""}, + { "IntegrationPoint_Set2w", _wrap_IntegrationPoint_Set2w, METH_VARARGS, "\n" + "Set2w(IntegrationPoint self, double const x1, double const x2, double const w)\n" + "Set2w(IntegrationPoint self, double const * p)\n" + ""}, + { "IntegrationPoint_Set2", _wrap_IntegrationPoint_Set2, METH_VARARGS, "\n" + "Set2(IntegrationPoint self, double const x1, double const x2)\n" + "Set2(IntegrationPoint self, double const * p)\n" + ""}, + { "IntegrationPoint_Set1w", _wrap_IntegrationPoint_Set1w, METH_VARARGS, "\n" + "Set1w(IntegrationPoint self, double const x1, double const w)\n" + "Set1w(IntegrationPoint self, double const * p)\n" + ""}, + { "new_IntegrationPoint", _wrap_new_IntegrationPoint, METH_NOARGS, "new_IntegrationPoint() -> IntegrationPoint"}, + { "delete_IntegrationPoint", _wrap_delete_IntegrationPoint, METH_O, "delete_IntegrationPoint(IntegrationPoint self)"}, + { "IntegrationPoint_swigregister", IntegrationPoint_swigregister, METH_O, NULL}, + { "IntegrationPoint_swiginit", IntegrationPoint_swiginit, METH_VARARGS, NULL}, + { "new_IntegrationRule", _wrap_new_IntegrationRule, METH_VARARGS, "\n" + "IntegrationRule()\n" + "IntegrationRule(int NP)\n" + "IntegrationRule(IntegrationRule irx, IntegrationRule iry)\n" + "new_IntegrationRule(IntegrationRule irx, IntegrationRule iry, IntegrationRule irz) -> IntegrationRule\n" + ""}, + { "IntegrationRule_GetOrder", _wrap_IntegrationRule_GetOrder, METH_O, "GetOrder(IntegrationRule self) -> int"}, + { "IntegrationRule_SetOrder", _wrap_IntegrationRule_SetOrder, METH_VARARGS, "SetOrder(IntegrationRule self, int const order)"}, + { "IntegrationRule_GetNPoints", _wrap_IntegrationRule_GetNPoints, METH_O, "GetNPoints(IntegrationRule self) -> int"}, + { "IntegrationRule_IntPoint", _wrap_IntegrationRule_IntPoint, METH_VARARGS, "\n" + "IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" + "IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" + ""}, + { "IntegrationRule_GetWeights", _wrap_IntegrationRule_GetWeights, METH_O, "GetWeights(IntegrationRule self) -> doubleArray"}, + { "delete_IntegrationRule", _wrap_delete_IntegrationRule, METH_O, "delete_IntegrationRule(IntegrationRule self)"}, + { "IntegrationRule_swigregister", IntegrationRule_swigregister, METH_O, NULL}, + { "IntegrationRule_swiginit", IntegrationRule_swiginit, METH_VARARGS, NULL}, + { "QuadratureFunctions1D_GaussLegendre", _wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS, "GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GaussLobatto", _wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS, "GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenUniform", _wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS, "OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_ClosedUniform", _wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS, "ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenHalfUniform", _wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS, "OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GivePolyPoints", _wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS, "GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, + { "new_QuadratureFunctions1D", _wrap_new_QuadratureFunctions1D, METH_NOARGS, "new_QuadratureFunctions1D() -> QuadratureFunctions1D"}, + { "delete_QuadratureFunctions1D", _wrap_delete_QuadratureFunctions1D, METH_O, "delete_QuadratureFunctions1D(QuadratureFunctions1D self)"}, + { "QuadratureFunctions1D_swigregister", QuadratureFunctions1D_swigregister, METH_O, NULL}, + { "QuadratureFunctions1D_swiginit", QuadratureFunctions1D_swiginit, METH_VARARGS, NULL}, + { "Quadrature1D_CheckClosed", _wrap_Quadrature1D_CheckClosed, METH_O, "CheckClosed(int type) -> int"}, + { "Quadrature1D_CheckOpen", _wrap_Quadrature1D_CheckOpen, METH_O, "CheckOpen(int type) -> int"}, + { "new_Quadrature1D", _wrap_new_Quadrature1D, METH_NOARGS, "new_Quadrature1D() -> Quadrature1D"}, + { "delete_Quadrature1D", _wrap_delete_Quadrature1D, METH_O, "delete_Quadrature1D(Quadrature1D self)"}, + { "Quadrature1D_swigregister", Quadrature1D_swigregister, METH_O, NULL}, + { "Quadrature1D_swiginit", Quadrature1D_swiginit, METH_VARARGS, NULL}, + { "new_IntegrationRules", _wrap_new_IntegrationRules, METH_VARARGS, "IntegrationRules(int Ref=0, int type=GaussLegendre)"}, + { "IntegrationRules_Get", _wrap_IntegrationRules_Get, METH_VARARGS, "Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, + { "IntegrationRules_Set", _wrap_IntegrationRules_Set, METH_VARARGS, "Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, + { "IntegrationRules_SetOwnRules", _wrap_IntegrationRules_SetOwnRules, METH_VARARGS, "SetOwnRules(IntegrationRules self, int o)"}, + { "delete_IntegrationRules", _wrap_delete_IntegrationRules, METH_O, "delete_IntegrationRules(IntegrationRules self)"}, + { "IntegrationRules_swigregister", IntegrationRules_swigregister, METH_O, NULL}, + { "IntegrationRules_swiginit", IntegrationRules_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/io_stream.py b/mfem/_ser/io_stream.py index aefd0792..b63a6b7e 100644 --- a/mfem/_ser/io_stream.py +++ b/mfem/_ser/io_stream.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _io_stream.SWIG_PyInstanceMethod_New +_swig_new_static_method = _io_stream.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -77,18 +80,22 @@ def __init__(self, *args): def isSTDOUT(self): r"""isSTDOUT(wFILE self) -> int""" return _io_stream.wFILE_isSTDOUT(self) + isSTDOUT = _swig_new_instance_method(_io_stream.wFILE_isSTDOUT) def getFilename(self): r"""getFilename(wFILE self) -> char *""" return _io_stream.wFILE_getFilename(self) + getFilename = _swig_new_instance_method(_io_stream.wFILE_getFilename) def getPrecision(self): r"""getPrecision(wFILE self) -> int""" return _io_stream.wFILE_getPrecision(self) + getPrecision = _swig_new_instance_method(_io_stream.wFILE_getPrecision) def setPrecision(self, precision): r"""setPrecision(wFILE self, int precision)""" return _io_stream.wFILE_setPrecision(self, precision) + setPrecision = _swig_new_instance_method(_io_stream.wFILE_setPrecision) __swig_destroy__ = _io_stream.delete_wFILE # Register wFILE in _io_stream: diff --git a/mfem/_ser/io_stream_wrap.cxx b/mfem/_ser/io_stream_wrap.cxx index 5234e352..9b6364f4 100644 --- a/mfem/_ser/io_stream_wrap.cxx +++ b/mfem/_ser/io_stream_wrap.cxx @@ -3331,6 +3331,7 @@ SWIGINTERN PyObject *wFILE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *ar static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" "wFILE()\n" "wFILE(char const * filename, int precision=8)\n" @@ -3346,6 +3347,19 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" + "wFILE()\n" + "wFILE(char const * filename, int precision=8)\n" + ""}, + { "wFILE_isSTDOUT", _wrap_wFILE_isSTDOUT, METH_O, "isSTDOUT(wFILE self) -> int"}, + { "wFILE_getFilename", _wrap_wFILE_getFilename, METH_O, "getFilename(wFILE self) -> char *"}, + { "wFILE_getPrecision", _wrap_wFILE_getPrecision, METH_O, "getPrecision(wFILE self) -> int"}, + { "wFILE_setPrecision", _wrap_wFILE_setPrecision, METH_VARARGS, "setPrecision(wFILE self, int precision)"}, + { "delete_wFILE", _wrap_delete_wFILE, METH_O, "delete_wFILE(wFILE self)"}, + { "wFILE_swigregister", wFILE_swigregister, METH_O, NULL}, + { "wFILE_swiginit", wFILE_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/istream_typemap.py b/mfem/_ser/istream_typemap.py index c403dc6e..d66724c6 100644 --- a/mfem/_ser/istream_typemap.py +++ b/mfem/_ser/istream_typemap.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _istream_typemap.SWIG_PyInstanceMethod_New +_swig_new_static_method = _istream_typemap.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() diff --git a/mfem/_ser/istream_typemap_wrap.cxx b/mfem/_ser/istream_typemap_wrap.cxx index 2061a8e6..4b015f3f 100644 --- a/mfem/_ser/istream_typemap_wrap.cxx +++ b/mfem/_ser/istream_typemap_wrap.cxx @@ -2767,10 +2767,13 @@ extern "C" { #endif static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/linearform.i b/mfem/_ser/linearform.i index e316c5c7..e48aa2d3 100644 --- a/mfem/_ser/linearform.i +++ b/mfem/_ser/linearform.i @@ -23,6 +23,7 @@ import_array(); %} %include "exception.i" +%include "../common/cpointers.i" %import "coefficient.i" %import "array.i" %import "mesh.i" diff --git a/mfem/_ser/linearform.py b/mfem/_ser/linearform.py index 16425645..75aa3f71 100644 --- a/mfem/_ser/linearform.py +++ b/mfem/_ser/linearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _linearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _linearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -63,6 +66,70 @@ class _SwigNonDynamicMeta(type): import weakref +class intp(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _linearform.intp_swiginit(self, _linearform.new_intp()) + __swig_destroy__ = _linearform.delete_intp + + def assign(self, value): + return _linearform.intp_assign(self, value) + assign = _swig_new_instance_method(_linearform.intp_assign) + + def value(self): + return _linearform.intp_value(self) + value = _swig_new_instance_method(_linearform.intp_value) + + def cast(self): + return _linearform.intp_cast(self) + cast = _swig_new_instance_method(_linearform.intp_cast) + + @staticmethod + def frompointer(t): + return _linearform.intp_frompointer(t) + frompointer = _swig_new_static_method(_linearform.intp_frompointer) + +# Register intp in _linearform: +_linearform.intp_swigregister(intp) + +def intp_frompointer(t): + return _linearform.intp_frompointer(t) +intp_frompointer = _linearform.intp_frompointer + +class doublep(object): + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + _linearform.doublep_swiginit(self, _linearform.new_doublep()) + __swig_destroy__ = _linearform.delete_doublep + + def assign(self, value): + return _linearform.doublep_assign(self, value) + assign = _swig_new_instance_method(_linearform.doublep_assign) + + def value(self): + return _linearform.doublep_value(self) + value = _swig_new_instance_method(_linearform.doublep_value) + + def cast(self): + return _linearform.doublep_cast(self) + cast = _swig_new_instance_method(_linearform.doublep_cast) + + @staticmethod + def frompointer(t): + return _linearform.doublep_frompointer(t) + frompointer = _swig_new_static_method(_linearform.doublep_frompointer) + +# Register doublep in _linearform: +_linearform.doublep_swigregister(doublep) + +def doublep_frompointer(t): + return _linearform.doublep_frompointer(t) +doublep_frompointer = _linearform.doublep_frompointer + import mfem._ser.coefficient import mfem._ser.array import mfem._ser.mem_manager @@ -82,11 +149,13 @@ class _SwigNonDynamicMeta(type): import mfem._ser.fe_coll import mfem._ser.lininteg import mfem._ser.handle -import mfem._ser.bilininteg +import mfem._ser.restriction import mfem._ser.element import mfem._ser.table import mfem._ser.hash +import mfem._ser.bilininteg import mfem._ser.vertex +import mfem._ser.vtk class LinearForm(mfem._ser.vector.Vector): r"""Proxy of C++ mfem::LinearForm class.""" @@ -98,12 +167,14 @@ def __init__(self, *args): __init__(LinearForm self, FiniteElementSpace f) -> LinearForm __init__(LinearForm self, FiniteElementSpace f, LinearForm lf) -> LinearForm __init__(LinearForm self) -> LinearForm + __init__(LinearForm self, FiniteElementSpace f, double * data) -> LinearForm """ _linearform.LinearForm_swiginit(self, _linearform.new_LinearForm(*args)) def GetFES(self): r"""GetFES(LinearForm self) -> FiniteElementSpace""" return _linearform.LinearForm_GetFES(self) + GetFES = _swig_new_instance_method(_linearform.LinearForm_GetFES) def FESpace(self, *args): r""" @@ -111,6 +182,7 @@ def FESpace(self, *args): FESpace(LinearForm self) -> FiniteElementSpace """ return _linearform.LinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_linearform.LinearForm_FESpace) def AddDomainIntegrator(self, lfi): r"""AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)""" @@ -156,30 +228,37 @@ def AddBdrFaceIntegrator(self, *args): def GetDLFI(self): r"""GetDLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *""" return _linearform.LinearForm_GetDLFI(self) + GetDLFI = _swig_new_instance_method(_linearform.LinearForm_GetDLFI) def GetDLFI_Delta(self): r"""GetDLFI_Delta(LinearForm self) -> mfem::Array< mfem::DeltaLFIntegrator * > *""" return _linearform.LinearForm_GetDLFI_Delta(self) + GetDLFI_Delta = _swig_new_instance_method(_linearform.LinearForm_GetDLFI_Delta) def GetBLFI(self): r"""GetBLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *""" return _linearform.LinearForm_GetBLFI(self) + GetBLFI = _swig_new_instance_method(_linearform.LinearForm_GetBLFI) def GetFLFI(self): r"""GetFLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *""" return _linearform.LinearForm_GetFLFI(self) + GetFLFI = _swig_new_instance_method(_linearform.LinearForm_GetFLFI) def GetFLFI_Marker(self): r"""GetFLFI_Marker(LinearForm self) -> mfem::Array< mfem::Array< int > * > *""" return _linearform.LinearForm_GetFLFI_Marker(self) + GetFLFI_Marker = _swig_new_instance_method(_linearform.LinearForm_GetFLFI_Marker) def Assemble(self): r"""Assemble(LinearForm self)""" return _linearform.LinearForm_Assemble(self) + Assemble = _swig_new_instance_method(_linearform.LinearForm_Assemble) def AssembleDelta(self): r"""AssembleDelta(LinearForm self)""" return _linearform.LinearForm_AssembleDelta(self) + AssembleDelta = _swig_new_instance_method(_linearform.LinearForm_AssembleDelta) def Update(self, *args): r""" @@ -188,10 +267,12 @@ def Update(self, *args): Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset) """ return _linearform.LinearForm_Update(self, *args) + Update = _swig_new_instance_method(_linearform.LinearForm_Update) def __call__(self, gf): r"""__call__(LinearForm self, GridFunction gf) -> double""" return _linearform.LinearForm___call__(self, gf) + __call__ = _swig_new_instance_method(_linearform.LinearForm___call__) __swig_destroy__ = _linearform.delete_LinearForm # Register LinearForm in _linearform: diff --git a/mfem/_ser/linearform_wrap.cxx b/mfem/_ser/linearform_wrap.cxx index 01941632..bc4fcbe7 100644 --- a/mfem/_ser/linearform_wrap.cxx +++ b/mfem/_ser/linearform_wrap.cxx @@ -3066,44 +3066,47 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_mfem__DeltaLFIntegrator_p_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_mfem__LinearFormIntegrator_p_t swig_types[8] -#define SWIGTYPE_p_mfem__BoundaryFlowIntegrator swig_types[9] -#define SWIGTYPE_p_mfem__BoundaryLFIntegrator swig_types[10] -#define SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator swig_types[11] -#define SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator swig_types[12] -#define SWIGTYPE_p_mfem__DGDirichletLFIntegrator swig_types[13] -#define SWIGTYPE_p_mfem__DGElasticityDirichletLFIntegrator swig_types[14] -#define SWIGTYPE_p_mfem__DeltaLFIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__DomainLFIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[17] -#define SWIGTYPE_p_mfem__GridFunction swig_types[18] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[19] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[20] -#define SWIGTYPE_p_mfem__LinearForm swig_types[21] -#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[22] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[23] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[24] -#define SWIGTYPE_p_mfem__Vector swig_types[25] -#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[26] -#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[27] -#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[28] -#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[29] -#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[30] -#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[31] -#define SWIGTYPE_p_pri_t swig_types[32] -#define SWIGTYPE_p_quad_t swig_types[33] -#define SWIGTYPE_p_seg_t swig_types[34] -#define SWIGTYPE_p_tet_t swig_types[35] -#define SWIGTYPE_p_tri_t swig_types[36] -static swig_type_info *swig_types[38]; -static swig_module_info swig_module = {swig_types, 37, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_double swig_types[3] +#define SWIGTYPE_p_doublep swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_intp swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__DeltaLFIntegrator_p_t swig_types[10] +#define SWIGTYPE_p_mfem__ArrayT_mfem__LinearFormIntegrator_p_t swig_types[11] +#define SWIGTYPE_p_mfem__BoundaryFlowIntegrator swig_types[12] +#define SWIGTYPE_p_mfem__BoundaryLFIntegrator swig_types[13] +#define SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator swig_types[14] +#define SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator swig_types[15] +#define SWIGTYPE_p_mfem__DGDirichletLFIntegrator swig_types[16] +#define SWIGTYPE_p_mfem__DGElasticityDirichletLFIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__DeltaLFIntegrator swig_types[18] +#define SWIGTYPE_p_mfem__DomainLFIntegrator swig_types[19] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[20] +#define SWIGTYPE_p_mfem__GridFunction swig_types[21] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[22] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[23] +#define SWIGTYPE_p_mfem__LinearForm swig_types[24] +#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[25] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[26] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[27] +#define SWIGTYPE_p_mfem__Vector swig_types[28] +#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[29] +#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[30] +#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[31] +#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[33] +#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[34] +#define SWIGTYPE_p_pri_t swig_types[35] +#define SWIGTYPE_p_quad_t swig_types[36] +#define SWIGTYPE_p_seg_t swig_types[37] +#define SWIGTYPE_p_tet_t swig_types[38] +#define SWIGTYPE_p_tri_t swig_types[39] +static swig_type_info *swig_types[41]; +static swig_module_info swig_module = {swig_types, 40, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3225,8 +3228,208 @@ namespace swig { #include "pyoperator.hpp" +typedef int intp; + +SWIGINTERN intp *new_intp(){ + return (new int()); + } +SWIGINTERN void delete_intp(intp *self){ + if (self) delete self; + } + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + +SWIGINTERN void intp_assign(intp *self,int value){ + *self = value; + } +SWIGINTERN int intp_value(intp *self){ + return *self; + } + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + +SWIGINTERN int *intp_cast(intp *self){ + return self; + } +SWIGINTERN intp *intp_frompointer(int *t){ + return (intp *) t; + } + +typedef double doublep; + +SWIGINTERN doublep *new_doublep(){ + return (new double()); + } +SWIGINTERN void delete_doublep(doublep *self){ + if (self) delete self; + } +SWIGINTERN void doublep_assign(doublep *self,double value){ + *self = value; + } +SWIGINTERN double doublep_value(doublep *self){ + return *self; + } + #define SWIG_From_double PyFloat_FromDouble +SWIGINTERN double *doublep_cast(doublep *self){ + return self; + } +SWIGINTERN doublep *doublep_frompointer(double *t){ + return (doublep *) t; + } /* --------------------------------------------------- @@ -3238,6 +3441,294 @@ namespace swig { #ifdef __cplusplus extern "C" { #endif +SWIGINTERN PyObject *_wrap_new_intp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + intp *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_intp", 0, 0, 0)) SWIG_fail; + result = (intp *)new_intp(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intp, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + intp *arg1 = (intp *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intp" "', argument " "1"" of type '" "intp *""'"); + } + arg1 = reinterpret_cast< intp * >(argp1); + delete_intp(arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + intp *arg1 = (intp *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); + } + arg1 = reinterpret_cast< intp * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); + intp_assign(arg1,arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intp_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + intp *arg1 = (intp *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_value" "', argument " "1"" of type '" "intp *""'"); + } + arg1 = reinterpret_cast< intp * >(argp1); + result = (int)intp_value(arg1); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + intp *arg1 = (intp *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_cast" "', argument " "1"" of type '" "intp *""'"); + } + arg1 = reinterpret_cast< intp * >(argp1); + result = (int *)intp_cast(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int *arg1 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + intp *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); + } + arg1 = reinterpret_cast< int * >(argp1); + result = (intp *)intp_frompointer(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intp, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *intp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_intp, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *intp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_doublep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + doublep *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_doublep", 0, 0, 0)) SWIG_fail; + result = (doublep *)new_doublep(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doublep, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + doublep *arg1 = (doublep *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doublep" "', argument " "1"" of type '" "doublep *""'"); + } + arg1 = reinterpret_cast< doublep * >(argp1); + delete_doublep(arg1); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + doublep *arg1 = (doublep *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); + } + arg1 = reinterpret_cast< doublep * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + doublep_assign(arg1,arg2); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doublep_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + doublep *arg1 = (doublep *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_value" "', argument " "1"" of type '" "doublep *""'"); + } + arg1 = reinterpret_cast< doublep * >(argp1); + result = (double)doublep_value(arg1); + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + doublep *arg1 = (doublep *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_cast" "', argument " "1"" of type '" "doublep *""'"); + } + arg1 = reinterpret_cast< doublep * >(argp1); + result = (double *)doublep_cast(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + double *arg1 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + doublep *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); + } + arg1 = reinterpret_cast< double * >(argp1); + result = (doublep *)doublep_frompointer(arg1); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doublep, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *doublep_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_doublep, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *doublep_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + SWIGINTERN PyObject *_wrap_new_LinearForm__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -3355,6 +3846,53 @@ SWIGINTERN PyObject *_wrap_new_LinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } +SWIGINTERN PyObject *_wrap_new_LinearForm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + double *arg2 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::LinearForm *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_LinearForm" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (mfem::LinearForm *)new mfem::LinearForm(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LinearForm, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_new_LinearForm(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { @@ -3389,13 +3927,28 @@ SWIGINTERN PyObject *_wrap_new_LinearForm(PyObject *self, PyObject *args) { } } } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_LinearForm__SWIG_3(self, argc, argv); + } + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LinearForm'.\n" " Possible C/C++ prototypes are:\n" " mfem::LinearForm::LinearForm(mfem::FiniteElementSpace *)\n" " mfem::LinearForm::LinearForm(mfem::FiniteElementSpace *,mfem::LinearForm *)\n" - " mfem::LinearForm::LinearForm()\n"); + " mfem::LinearForm::LinearForm()\n" + " mfem::LinearForm::LinearForm(mfem::FiniteElementSpace *,double *)\n"); return 0; } @@ -4518,10 +5071,28 @@ SWIGINTERN PyObject *LinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, + { "delete_intp", _wrap_delete_intp, METH_O, NULL}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_value", _wrap_intp_value, METH_O, NULL}, + { "intp_cast", _wrap_intp_cast, METH_O, NULL}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, + { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_value", _wrap_doublep_value, METH_O, NULL}, + { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "new_LinearForm", _wrap_new_LinearForm, METH_VARARGS, "\n" "LinearForm(FiniteElementSpace f)\n" "LinearForm(FiniteElementSpace f, LinearForm lf)\n" - "new_LinearForm() -> LinearForm\n" + "LinearForm()\n" + "new_LinearForm(FiniteElementSpace f, double * data) -> LinearForm\n" ""}, { "LinearForm_GetFES", _wrap_LinearForm_GetFES, METH_O, "LinearForm_GetFES(LinearForm self) -> FiniteElementSpace"}, { "LinearForm_FESpace", _wrap_LinearForm_FESpace, METH_VARARGS, "\n" @@ -4557,6 +5128,60 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, + { "delete_intp", _wrap_delete_intp, METH_O, NULL}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_value", _wrap_intp_value, METH_O, NULL}, + { "intp_cast", _wrap_intp_cast, METH_O, NULL}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, + { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_value", _wrap_doublep_value, METH_O, NULL}, + { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "new_LinearForm", _wrap_new_LinearForm, METH_VARARGS, "\n" + "LinearForm(FiniteElementSpace f)\n" + "LinearForm(FiniteElementSpace f, LinearForm lf)\n" + "LinearForm()\n" + "new_LinearForm(FiniteElementSpace f, double * data) -> LinearForm\n" + ""}, + { "LinearForm_GetFES", _wrap_LinearForm_GetFES, METH_O, "GetFES(LinearForm self) -> FiniteElementSpace"}, + { "LinearForm_FESpace", _wrap_LinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(LinearForm self) -> FiniteElementSpace\n" + "FESpace(LinearForm self) -> FiniteElementSpace\n" + ""}, + { "LinearForm_AddDomainIntegrator", _wrap_LinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, + { "LinearForm_AddBoundaryIntegrator", _wrap_LinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" + "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" + "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" + ""}, + { "LinearForm_AddBdrFaceIntegrator", _wrap_LinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" + "AddBdrFaceIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" + ""}, + { "LinearForm_GetDLFI", _wrap_LinearForm_GetDLFI, METH_O, "GetDLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *"}, + { "LinearForm_GetDLFI_Delta", _wrap_LinearForm_GetDLFI_Delta, METH_O, "GetDLFI_Delta(LinearForm self) -> mfem::Array< mfem::DeltaLFIntegrator * > *"}, + { "LinearForm_GetBLFI", _wrap_LinearForm_GetBLFI, METH_O, "GetBLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *"}, + { "LinearForm_GetFLFI", _wrap_LinearForm_GetFLFI, METH_O, "GetFLFI(LinearForm self) -> mfem::Array< mfem::LinearFormIntegrator * > *"}, + { "LinearForm_GetFLFI_Marker", _wrap_LinearForm_GetFLFI_Marker, METH_O, "GetFLFI_Marker(LinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, + { "LinearForm_Assemble", _wrap_LinearForm_Assemble, METH_O, "Assemble(LinearForm self)"}, + { "LinearForm_AssembleDelta", _wrap_LinearForm_AssembleDelta, METH_O, "AssembleDelta(LinearForm self)"}, + { "LinearForm_Update", _wrap_LinearForm_Update, METH_VARARGS, "\n" + "Update(LinearForm self)\n" + "Update(LinearForm self, FiniteElementSpace f)\n" + "Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset)\n" + ""}, + { "LinearForm___call__", _wrap_LinearForm___call__, METH_VARARGS, "__call__(LinearForm self, GridFunction gf) -> double"}, + { "delete_LinearForm", _wrap_delete_LinearForm, METH_O, "delete_LinearForm(LinearForm self)"}, + { "LinearForm_swigregister", LinearForm_swigregister, METH_O, NULL}, + { "LinearForm_swiginit", LinearForm_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4572,6 +5197,9 @@ static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUS static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); } +static void *_p_intpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((int *) ((intp *) x)); +} static void *_p_mfem__DGElasticityDirichletLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::LinearFormIntegrator *) ((mfem::DGElasticityDirichletLFIntegrator *) x)); } @@ -4614,10 +5242,16 @@ static void *_p_mfem__DomainLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, static void *_p_mfem__DeltaLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::LinearFormIntegrator *) ((mfem::DeltaLFIntegrator *) x)); } +static void *_p_doublepTo_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((double *) ((doublep *) x)); +} static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t = {"_p_mfem__ArrayT_mfem__ArrayT_int_t_p_t", "mfem::Array< mfem::Array< int > * > *", 0, 0, (void*)0, 0}; @@ -4654,9 +5288,12 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, + &_swigt__p_double, &_swigt__p_doublep, &_swigt__p_hex_t, + &_swigt__p_int, &_swigt__p_intp, &_swigt__p_mfem__ArrayT_int_t, &_swigt__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, @@ -4693,9 +5330,12 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0}, {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_intp, _p_intpTo_p_int, 0, 0}, {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -4732,9 +5372,12 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, + _swigc__p_double, _swigc__p_doublep, _swigc__p_hex_t, + _swigc__p_int, _swigc__p_intp, _swigc__p_mfem__ArrayT_int_t, _swigc__p_mfem__ArrayT_mfem__ArrayT_int_t_p_t, diff --git a/mfem/_ser/lininteg.py b/mfem/_ser/lininteg.py index 7f5039cb..374e8ac1 100644 --- a/mfem/_ser/lininteg.py +++ b/mfem/_ser/lininteg.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _lininteg.SWIG_PyInstanceMethod_New +_swig_new_static_method = _lininteg.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -90,14 +93,17 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.LinearFormIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.LinearFormIntegrator_AssembleRHSElementVect) def SetIntRule(self, ir): r"""SetIntRule(LinearFormIntegrator self, IntegrationRule ir)""" return _lininteg.LinearFormIntegrator_SetIntRule(self, ir) + SetIntRule = _swig_new_instance_method(_lininteg.LinearFormIntegrator_SetIntRule) def GetIntRule(self): r"""GetIntRule(LinearFormIntegrator self) -> IntegrationRule""" return _lininteg.LinearFormIntegrator_GetIntRule(self) + GetIntRule = _swig_new_instance_method(_lininteg.LinearFormIntegrator_GetIntRule) __swig_destroy__ = _lininteg.delete_LinearFormIntegrator # Register LinearFormIntegrator in _lininteg: @@ -115,14 +121,17 @@ def __init__(self, *args, **kwargs): def IsDelta(self): r"""IsDelta(DeltaLFIntegrator self) -> bool""" return _lininteg.DeltaLFIntegrator_IsDelta(self) + IsDelta = _swig_new_instance_method(_lininteg.DeltaLFIntegrator_IsDelta) def GetDeltaCenter(self, center): r"""GetDeltaCenter(DeltaLFIntegrator self, Vector center)""" return _lininteg.DeltaLFIntegrator_GetDeltaCenter(self, center) + GetDeltaCenter = _swig_new_instance_method(_lininteg.DeltaLFIntegrator_GetDeltaCenter) def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.DeltaLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.DeltaLFIntegrator_AssembleDeltaElementVect) __swig_destroy__ = _lininteg.delete_DeltaLFIntegrator # Register DeltaLFIntegrator in _lininteg: @@ -149,6 +158,7 @@ def __init__(self, *args): def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.DomainLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.DomainLFIntegrator_AssembleDeltaElementVect) def AssembleRHSElementVect(self, *args): r""" @@ -156,6 +166,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.DomainLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.DomainLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_DomainLFIntegrator # Register DomainLFIntegrator in _lininteg: @@ -182,6 +193,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryLFIntegrator # Register BoundaryLFIntegrator in _lininteg: @@ -203,6 +215,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryNormalLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryNormalLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryNormalLFIntegrator # Register BoundaryNormalLFIntegrator in _lininteg: @@ -224,6 +237,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryTangentialLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryTangentialLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryTangentialLFIntegrator # Register BoundaryTangentialLFIntegrator in _lininteg: @@ -242,6 +256,7 @@ def __init__(self, QF): def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.VectorDomainLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.VectorDomainLFIntegrator_AssembleDeltaElementVect) def AssembleRHSElementVect(self, *args): r""" @@ -249,6 +264,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorDomainLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorDomainLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorDomainLFIntegrator # Register VectorDomainLFIntegrator in _lininteg: @@ -270,6 +286,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorBoundaryLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorBoundaryLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorBoundaryLFIntegrator # Register VectorBoundaryLFIntegrator in _lininteg: @@ -293,6 +310,7 @@ def __init__(self, F): def AssembleDeltaElementVect(self, fe, Trans, elvect): r"""AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)""" return _lininteg.VectorFEDomainLFIntegrator_AssembleDeltaElementVect(self, fe, Trans, elvect) + AssembleDeltaElementVect = _swig_new_instance_method(_lininteg.VectorFEDomainLFIntegrator_AssembleDeltaElementVect) def AssembleRHSElementVect(self, *args): r""" @@ -300,6 +318,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorFEDomainLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorFEDomainLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorFEDomainLFIntegrator # Register VectorFEDomainLFIntegrator in _lininteg: @@ -321,6 +340,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorBoundaryFluxLFIntegrator # Register VectorBoundaryFluxLFIntegrator in _lininteg: @@ -332,9 +352,12 @@ class VectorFEBoundaryFluxLFIntegrator(LinearFormIntegrator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, f): - r"""__init__(VectorFEBoundaryFluxLFIntegrator self, Coefficient f) -> VectorFEBoundaryFluxLFIntegrator""" - _lininteg.VectorFEBoundaryFluxLFIntegrator_swiginit(self, _lininteg.new_VectorFEBoundaryFluxLFIntegrator(f)) + def __init__(self, *args): + r""" + __init__(VectorFEBoundaryFluxLFIntegrator self) -> VectorFEBoundaryFluxLFIntegrator + __init__(VectorFEBoundaryFluxLFIntegrator self, Coefficient f) -> VectorFEBoundaryFluxLFIntegrator + """ + _lininteg.VectorFEBoundaryFluxLFIntegrator_swiginit(self, _lininteg.new_VectorFEBoundaryFluxLFIntegrator(*args)) def AssembleRHSElementVect(self, *args): r""" @@ -342,6 +365,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorFEBoundaryFluxLFIntegrator # Register VectorFEBoundaryFluxLFIntegrator in _lininteg: @@ -368,6 +392,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_VectorFEBoundaryTangentLFIntegrator # Register VectorFEBoundaryTangentLFIntegrator in _lininteg: @@ -389,6 +414,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.BoundaryFlowIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.BoundaryFlowIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_BoundaryFlowIntegrator # Register BoundaryFlowIntegrator in _lininteg: @@ -414,6 +440,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(DGDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.DGDirichletLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.DGDirichletLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_DGDirichletLFIntegrator # Register DGDirichletLFIntegrator in _lininteg: @@ -435,6 +462,7 @@ def AssembleRHSElementVect(self, *args): AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect) """ return _lininteg.DGElasticityDirichletLFIntegrator_AssembleRHSElementVect(self, *args) + AssembleRHSElementVect = _swig_new_instance_method(_lininteg.DGElasticityDirichletLFIntegrator_AssembleRHSElementVect) __swig_destroy__ = _lininteg.delete_DGElasticityDirichletLFIntegrator # Register DGElasticityDirichletLFIntegrator in _lininteg: diff --git a/mfem/_ser/lininteg_wrap.cxx b/mfem/_ser/lininteg_wrap.cxx index 99d09e2d..dea4b2ca 100644 --- a/mfem/_ser/lininteg_wrap.cxx +++ b/mfem/_ser/lininteg_wrap.cxx @@ -3109,126 +3109,128 @@ namespace Swig { #define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[41] #define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[42] #define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[43] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[44] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[45] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[46] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[47] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[48] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[49] -#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[50] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[51] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[52] -#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[53] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[54] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[55] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[56] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[57] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[59] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[60] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[62] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[63] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[64] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[65] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[66] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[67] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[68] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[69] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[70] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[72] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[73] -#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[74] -#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[75] -#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[76] -#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[77] -#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[78] -#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[79] -#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[80] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[81] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[82] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[83] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[84] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[85] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[88] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[94] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[105] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[109] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[110] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[111] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[114] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[118] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[119] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[123] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[124] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[125] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[126] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[127] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[128] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[129] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[130] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[131] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[132] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[133] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[134] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[135] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[136] -#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[137] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[138] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[139] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[140] -#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[141] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[142] -#define SWIGTYPE_p_mfem__Vector swig_types[143] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[144] -#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[145] -#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[146] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[147] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[148] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[149] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[150] -#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[151] -#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[152] -#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[153] -#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[154] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[155] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[156] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[157] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[158] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[159] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[160] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[161] -static swig_type_info *swig_types[163]; -static swig_module_info swig_module = {swig_types, 162, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[44] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[45] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[46] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[47] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[49] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[50] +#define SWIGTYPE_p_mfem__IdentityMatrixCoefficient swig_types[51] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[52] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[53] +#define SWIGTYPE_p_mfem__InverseMatrixCoefficient swig_types[54] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[55] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[56] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[57] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[58] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[59] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[60] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[61] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[62] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[63] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[64] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[65] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[66] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[67] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[68] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[69] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[70] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[71] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[72] +#define SWIGTYPE_p_mfem__LinearFormIntegrator swig_types[73] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[74] +#define SWIGTYPE_p_mfem__MatrixArrayCoefficient swig_types[75] +#define SWIGTYPE_p_mfem__MatrixCoefficient swig_types[76] +#define SWIGTYPE_p_mfem__MatrixConstantCoefficient swig_types[77] +#define SWIGTYPE_p_mfem__MatrixFunctionCoefficient swig_types[78] +#define SWIGTYPE_p_mfem__MatrixPyCoefficientBase swig_types[79] +#define SWIGTYPE_p_mfem__MatrixRestrictedCoefficient swig_types[80] +#define SWIGTYPE_p_mfem__MatrixSumCoefficient swig_types[81] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[82] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[83] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[84] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[85] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[86] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__OuterProductCoefficient swig_types[95] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[99] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[106] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[110] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[111] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[112] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[117] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[118] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[125] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[126] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[127] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[128] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[129] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[130] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[131] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[132] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[133] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[134] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[135] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[136] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[137] +#define SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient swig_types[138] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[139] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[141] +#define SWIGTYPE_p_mfem__TransposeMatrixCoefficient swig_types[142] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[143] +#define SWIGTYPE_p_mfem__Vector swig_types[144] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[145] +#define SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator swig_types[146] +#define SWIGTYPE_p_mfem__VectorBoundaryLFIntegrator swig_types[147] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[148] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[149] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[150] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[151] +#define SWIGTYPE_p_mfem__VectorDomainLFIntegrator swig_types[152] +#define SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator swig_types[153] +#define SWIGTYPE_p_mfem__VectorFEBoundaryTangentLFIntegrator swig_types[154] +#define SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator swig_types[155] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[156] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[157] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[158] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[159] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[160] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[161] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[162] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[163] +static swig_type_info *swig_types[165]; +static swig_module_info swig_module = {swig_types, 164, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -7532,16 +7534,45 @@ SWIGINTERN PyObject *VectorBoundaryFluxLFIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorFEBoundaryFluxLFIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorFEBoundaryFluxLFIntegrator *)new mfem::VectorFEBoundaryFluxLFIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFEBoundaryFluxLFIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; mfem::VectorFEBoundaryFluxLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -7576,6 +7607,36 @@ SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator(PyObject *SWIGUN } +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryFluxLFIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFEBoundaryFluxLFIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorFEBoundaryFluxLFIntegrator__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFEBoundaryFluxLFIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorFEBoundaryFluxLFIntegrator::VectorFEBoundaryFluxLFIntegrator()\n" + " mfem::VectorFEBoundaryFluxLFIntegrator::VectorFEBoundaryFluxLFIntegrator(mfem::Coefficient &)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorFEBoundaryFluxLFIntegrator *arg1 = (mfem::VectorFEBoundaryFluxLFIntegrator *) 0 ; @@ -9346,6 +9407,7 @@ SWIGINTERN PyObject *DGElasticityDirichletLFIntegrator_swiginit(PyObject *SWIGUN static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "LinearFormIntegrator_AssembleRHSElementVect", _wrap_LinearFormIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9429,7 +9491,10 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorBoundaryFluxLFIntegrator", _wrap_delete_VectorBoundaryFluxLFIntegrator, METH_O, "delete_VectorBoundaryFluxLFIntegrator(VectorBoundaryFluxLFIntegrator self)"}, { "VectorBoundaryFluxLFIntegrator_swigregister", VectorBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, { "VectorBoundaryFluxLFIntegrator_swiginit", VectorBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEBoundaryFluxLFIntegrator", _wrap_new_VectorFEBoundaryFluxLFIntegrator, METH_O, "new_VectorFEBoundaryFluxLFIntegrator(Coefficient f) -> VectorFEBoundaryFluxLFIntegrator"}, + { "new_VectorFEBoundaryFluxLFIntegrator", _wrap_new_VectorFEBoundaryFluxLFIntegrator, METH_VARARGS, "\n" + "VectorFEBoundaryFluxLFIntegrator()\n" + "new_VectorFEBoundaryFluxLFIntegrator(Coefficient f) -> VectorFEBoundaryFluxLFIntegrator\n" + ""}, { "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9477,6 +9542,138 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "LinearFormIntegrator_AssembleRHSElementVect", _wrap_LinearFormIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "LinearFormIntegrator_SetIntRule", _wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, + { "LinearFormIntegrator_GetIntRule", _wrap_LinearFormIntegrator_GetIntRule, METH_O, "GetIntRule(LinearFormIntegrator self) -> IntegrationRule"}, + { "delete_LinearFormIntegrator", _wrap_delete_LinearFormIntegrator, METH_O, "delete_LinearFormIntegrator(LinearFormIntegrator self)"}, + { "LinearFormIntegrator_swigregister", LinearFormIntegrator_swigregister, METH_O, NULL}, + { "DeltaLFIntegrator_IsDelta", _wrap_DeltaLFIntegrator_IsDelta, METH_O, "IsDelta(DeltaLFIntegrator self) -> bool"}, + { "DeltaLFIntegrator_GetDeltaCenter", _wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, + { "DeltaLFIntegrator_AssembleDeltaElementVect", _wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "delete_DeltaLFIntegrator", _wrap_delete_DeltaLFIntegrator, METH_O, "delete_DeltaLFIntegrator(DeltaLFIntegrator self)"}, + { "DeltaLFIntegrator_swigregister", DeltaLFIntegrator_swigregister, METH_O, NULL}, + { "new_DomainLFIntegrator", _wrap_new_DomainLFIntegrator, METH_VARARGS, "\n" + "DomainLFIntegrator(Coefficient QF, int a=2, int b=0)\n" + "new_DomainLFIntegrator(Coefficient QF, IntegrationRule ir) -> DomainLFIntegrator\n" + ""}, + { "DomainLFIntegrator_AssembleDeltaElementVect", _wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DomainLFIntegrator_AssembleRHSElementVect", _wrap_DomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_DomainLFIntegrator", _wrap_delete_DomainLFIntegrator, METH_O, "delete_DomainLFIntegrator(DomainLFIntegrator self)"}, + { "DomainLFIntegrator_swigregister", DomainLFIntegrator_swigregister, METH_O, NULL}, + { "DomainLFIntegrator_swiginit", DomainLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryLFIntegrator", _wrap_new_BoundaryLFIntegrator, METH_VARARGS, "BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1)"}, + { "BoundaryLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryLFIntegrator", _wrap_delete_BoundaryLFIntegrator, METH_O, "delete_BoundaryLFIntegrator(BoundaryLFIntegrator self)"}, + { "BoundaryLFIntegrator_swigregister", BoundaryLFIntegrator_swigregister, METH_O, NULL}, + { "BoundaryLFIntegrator_swiginit", BoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryNormalLFIntegrator", _wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS, "BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "BoundaryNormalLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryNormalLFIntegrator", _wrap_delete_BoundaryNormalLFIntegrator, METH_O, "delete_BoundaryNormalLFIntegrator(BoundaryNormalLFIntegrator self)"}, + { "BoundaryNormalLFIntegrator_swigregister", BoundaryNormalLFIntegrator_swigregister, METH_O, NULL}, + { "BoundaryNormalLFIntegrator_swiginit", BoundaryNormalLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryTangentialLFIntegrator", _wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS, "BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "BoundaryTangentialLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryTangentialLFIntegrator", _wrap_delete_BoundaryTangentialLFIntegrator, METH_O, "delete_BoundaryTangentialLFIntegrator(BoundaryTangentialLFIntegrator self)"}, + { "BoundaryTangentialLFIntegrator_swigregister", BoundaryTangentialLFIntegrator_swigregister, METH_O, NULL}, + { "BoundaryTangentialLFIntegrator_swiginit", BoundaryTangentialLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorDomainLFIntegrator", _wrap_new_VectorDomainLFIntegrator, METH_O, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, + { "VectorDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "VectorDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorDomainLFIntegrator", _wrap_delete_VectorDomainLFIntegrator, METH_O, "delete_VectorDomainLFIntegrator(VectorDomainLFIntegrator self)"}, + { "VectorDomainLFIntegrator_swigregister", VectorDomainLFIntegrator_swigregister, METH_O, NULL}, + { "VectorDomainLFIntegrator_swiginit", VectorDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorBoundaryLFIntegrator", _wrap_new_VectorBoundaryLFIntegrator, METH_O, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, + { "VectorBoundaryLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorBoundaryLFIntegrator", _wrap_delete_VectorBoundaryLFIntegrator, METH_O, "delete_VectorBoundaryLFIntegrator(VectorBoundaryLFIntegrator self)"}, + { "VectorBoundaryLFIntegrator_swigregister", VectorBoundaryLFIntegrator_swigregister, METH_O, NULL}, + { "VectorBoundaryLFIntegrator_swiginit", VectorBoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEDomainLFIntegrator", _wrap_new_VectorFEDomainLFIntegrator, METH_O, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, + { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "VectorFEDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorFEDomainLFIntegrator", _wrap_delete_VectorFEDomainLFIntegrator, METH_O, "delete_VectorFEDomainLFIntegrator(VectorFEDomainLFIntegrator self)"}, + { "VectorFEDomainLFIntegrator_swigregister", VectorFEDomainLFIntegrator_swigregister, METH_O, NULL}, + { "VectorFEDomainLFIntegrator_swiginit", VectorFEDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorBoundaryFluxLFIntegrator", _wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS, "VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None)"}, + { "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorBoundaryFluxLFIntegrator", _wrap_delete_VectorBoundaryFluxLFIntegrator, METH_O, "delete_VectorBoundaryFluxLFIntegrator(VectorBoundaryFluxLFIntegrator self)"}, + { "VectorBoundaryFluxLFIntegrator_swigregister", VectorBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, + { "VectorBoundaryFluxLFIntegrator_swiginit", VectorBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEBoundaryFluxLFIntegrator", _wrap_new_VectorFEBoundaryFluxLFIntegrator, METH_VARARGS, "\n" + "VectorFEBoundaryFluxLFIntegrator()\n" + "new_VectorFEBoundaryFluxLFIntegrator(Coefficient f) -> VectorFEBoundaryFluxLFIntegrator\n" + ""}, + { "VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorFEBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorFEBoundaryFluxLFIntegrator", _wrap_delete_VectorFEBoundaryFluxLFIntegrator, METH_O, "delete_VectorFEBoundaryFluxLFIntegrator(VectorFEBoundaryFluxLFIntegrator self)"}, + { "VectorFEBoundaryFluxLFIntegrator_swigregister", VectorFEBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, + { "VectorFEBoundaryFluxLFIntegrator_swiginit", VectorFEBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorFEBoundaryTangentLFIntegrator", _wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_O, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, + { "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_VectorFEBoundaryTangentLFIntegrator", _wrap_delete_VectorFEBoundaryTangentLFIntegrator, METH_O, "delete_VectorFEBoundaryTangentLFIntegrator(VectorFEBoundaryTangentLFIntegrator self)"}, + { "VectorFEBoundaryTangentLFIntegrator_swigregister", VectorFEBoundaryTangentLFIntegrator_swigregister, METH_O, NULL}, + { "VectorFEBoundaryTangentLFIntegrator_swiginit", VectorFEBoundaryTangentLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_BoundaryFlowIntegrator", _wrap_new_BoundaryFlowIntegrator, METH_VARARGS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, + { "BoundaryFlowIntegrator_AssembleRHSElementVect", _wrap_BoundaryFlowIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_BoundaryFlowIntegrator", _wrap_delete_BoundaryFlowIntegrator, METH_O, "delete_BoundaryFlowIntegrator(BoundaryFlowIntegrator self)"}, + { "BoundaryFlowIntegrator_swigregister", BoundaryFlowIntegrator_swigregister, METH_O, NULL}, + { "BoundaryFlowIntegrator_swiginit", BoundaryFlowIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGDirichletLFIntegrator", _wrap_new_DGDirichletLFIntegrator, METH_VARARGS, "\n" + "DGDirichletLFIntegrator(Coefficient u, double const s, double const k)\n" + "DGDirichletLFIntegrator(Coefficient u, Coefficient q, double const s, double const k)\n" + "new_DGDirichletLFIntegrator(Coefficient u, MatrixCoefficient q, double const s, double const k) -> DGDirichletLFIntegrator\n" + ""}, + { "DGDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(DGDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(DGDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_DGDirichletLFIntegrator", _wrap_delete_DGDirichletLFIntegrator, METH_O, "delete_DGDirichletLFIntegrator(DGDirichletLFIntegrator self)"}, + { "DGDirichletLFIntegrator_swigregister", DGDirichletLFIntegrator_swigregister, METH_O, NULL}, + { "DGDirichletLFIntegrator_swiginit", DGDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_DGElasticityDirichletLFIntegrator", _wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, + { "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGElasticityDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" + "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" + "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" + ""}, + { "delete_DGElasticityDirichletLFIntegrator", _wrap_delete_DGElasticityDirichletLFIntegrator, METH_O, "delete_DGElasticityDirichletLFIntegrator(DGElasticityDirichletLFIntegrator self)"}, + { "DGElasticityDirichletLFIntegrator_swigregister", DGElasticityDirichletLFIntegrator_swigregister, METH_O, NULL}, + { "DGElasticityDirichletLFIntegrator_swiginit", DGElasticityDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -9654,12 +9851,6 @@ static void *_p_mfem__DomainLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, static void *_p_mfem__DeltaLFIntegratorTo_p_mfem__LinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::LinearFormIntegrator *) ((mfem::DeltaLFIntegrator *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -9693,6 +9884,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -9708,6 +9902,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -9876,6 +10073,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -9919,10 +10122,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -9990,13 +10193,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -10008,6 +10209,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -10049,6 +10252,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -10153,6 +10358,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -10271,6 +10477,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorRestrictedCoefficient, &_swigt__p_mfem__VectorRotProductCoefficient, &_swigt__p_mfem__VectorSumCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; @@ -10317,13 +10524,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -10335,6 +10540,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -10376,6 +10583,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -10399,7 +10608,7 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearFormIntegrator[] = { {&_swigt__p_mfem__DGElasticityDirichletLFIntegrator, _p_mfem__DGElasticityDirichletLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DGDirichletLFIntegrator, _p_mfem__DGDirichletLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryFlowIntegrator, _p_mfem__BoundaryFlowIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEBoundaryTangentLFIntegrator, _p_mfem__VectorFEBoundaryTangentLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEBoundaryFluxLFIntegrator, _p_mfem__VectorFEBoundaryFluxLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorBoundaryFluxLFIntegrator, _p_mfem__VectorBoundaryFluxLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorFEDomainLFIntegrator, _p_mfem__VectorFEDomainLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorBoundaryLFIntegrator, _p_mfem__VectorBoundaryLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorDomainLFIntegrator, _p_mfem__VectorDomainLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryTangentialLFIntegrator, _p_mfem__BoundaryTangentialLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryNormalLFIntegrator, _p_mfem__BoundaryNormalLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__BoundaryLFIntegrator, _p_mfem__BoundaryLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__DomainLFIntegrator, _p_mfem__DomainLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__LinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__DeltaLFIntegrator, _p_mfem__DeltaLFIntegratorTo_p_mfem__LinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixConstantCoefficient[] = {{&_swigt__p_mfem__MatrixConstantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; @@ -10481,6 +10690,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -10599,6 +10809,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorRestrictedCoefficient, _swigc__p_mfem__VectorRotProductCoefficient, _swigc__p_mfem__VectorSumCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, }; diff --git a/mfem/_ser/matrix.py b/mfem/_ser/matrix.py index 208f2436..01d4f5bb 100644 --- a/mfem/_ser/matrix.py +++ b/mfem/_ser/matrix.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _matrix.SWIG_PyInstanceMethod_New +_swig_new_static_method = _matrix.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,20 +85,28 @@ def __init__(self, *args, **kwargs): DIAG_KEEP = _matrix.Matrix_DIAG_KEEP + def IsSquare(self): + r"""IsSquare(Matrix self) -> bool""" + return _matrix.Matrix_IsSquare(self) + IsSquare = _swig_new_instance_method(_matrix.Matrix_IsSquare) + def Elem(self, *args): r""" Elem(Matrix self, int i, int j) -> double Elem(Matrix self, int i, int j) -> double const & """ return _matrix.Matrix_Elem(self, *args) + Elem = _swig_new_instance_method(_matrix.Matrix_Elem) def Inverse(self): r"""Inverse(Matrix self) -> MatrixInverse""" return _matrix.Matrix_Inverse(self) + Inverse = _swig_new_instance_method(_matrix.Matrix_Inverse) def Finalize(self, arg2): r"""Finalize(Matrix self, int arg2)""" return _matrix.Matrix_Finalize(self, arg2) + Finalize = _swig_new_instance_method(_matrix.Matrix_Finalize) __swig_destroy__ = _matrix.delete_Matrix def Print(self, *args): @@ -104,6 +115,7 @@ def Print(self, *args): Print(Matrix self, char const * file, int precision=8) """ return _matrix.Matrix_Print(self, *args) + Print = _swig_new_instance_method(_matrix.Matrix_Print) # Register Matrix in _matrix: _matrix.Matrix_swigregister(Matrix) @@ -133,30 +145,37 @@ def __init__(self, *args, **kwargs): def NumNonZeroElems(self): r"""NumNonZeroElems(AbstractSparseMatrix self) -> int""" return _matrix.AbstractSparseMatrix_NumNonZeroElems(self) + NumNonZeroElems = _swig_new_instance_method(_matrix.AbstractSparseMatrix_NumNonZeroElems) def GetRow(self, row, cols, srow): r"""GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int""" return _matrix.AbstractSparseMatrix_GetRow(self, row, cols, srow) + GetRow = _swig_new_instance_method(_matrix.AbstractSparseMatrix_GetRow) def EliminateZeroRows(self, threshold=1e-12): r"""EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)""" return _matrix.AbstractSparseMatrix_EliminateZeroRows(self, threshold) + EliminateZeroRows = _swig_new_instance_method(_matrix.AbstractSparseMatrix_EliminateZeroRows) def Mult(self, x, y): r"""Mult(AbstractSparseMatrix self, Vector x, Vector y)""" return _matrix.AbstractSparseMatrix_Mult(self, x, y) + Mult = _swig_new_instance_method(_matrix.AbstractSparseMatrix_Mult) def AddMult(self, x, y, val=1.): r"""AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)""" return _matrix.AbstractSparseMatrix_AddMult(self, x, y, val) + AddMult = _swig_new_instance_method(_matrix.AbstractSparseMatrix_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)""" return _matrix.AbstractSparseMatrix_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_matrix.AbstractSparseMatrix_MultTranspose) def AddMultTranspose(self, x, y, val=1.): r"""AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)""" return _matrix.AbstractSparseMatrix_AddMultTranspose(self, x, y, val) + AddMultTranspose = _swig_new_instance_method(_matrix.AbstractSparseMatrix_AddMultTranspose) __swig_destroy__ = _matrix.delete_AbstractSparseMatrix # Register AbstractSparseMatrix in _matrix: diff --git a/mfem/_ser/matrix_wrap.cxx b/mfem/_ser/matrix_wrap.cxx index cb8d112b..f420eaf5 100644 --- a/mfem/_ser/matrix_wrap.cxx +++ b/mfem/_ser/matrix_wrap.cxx @@ -3079,13 +3079,16 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[11] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[12] #define SWIGTYPE_p_mfem__RAPOperator swig_types[13] -#define SWIGTYPE_p_mfem__Solver swig_types[14] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[15] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[16] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[17] -#define SWIGTYPE_p_mfem__Vector swig_types[18] -static swig_type_info *swig_types[20]; -static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[14] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[15] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[16] +#define SWIGTYPE_p_mfem__Solver swig_types[17] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[18] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[19] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[20] +#define SWIGTYPE_p_mfem__Vector swig_types[21] +static swig_type_info *swig_types[23]; +static swig_module_info swig_module = {swig_types, 22, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3204,6 +3207,13 @@ SWIGINTERNINLINE PyObject* } +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + #define SWIG_From_double PyFloat_FromDouble @@ -3397,6 +3407,47 @@ SWIG_AsVal_double (PyObject *obj, double *val) #ifdef __cplusplus extern "C" { #endif +SWIGINTERN PyObject *_wrap_Matrix_IsSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_IsSquare" "', argument " "1"" of type '" "mfem::Matrix const *""'"); + } + arg1 = reinterpret_cast< mfem::Matrix * >(argp1); + { + try { + result = (bool)((mfem::Matrix const *)arg1)->IsSquare(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Matrix_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; @@ -4941,6 +4992,8 @@ SWIGINTERN PyObject *AbstractSparseMatrix_swigregister(PyObject *SWIGUNUSEDPARM( static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Matrix_IsSquare", _wrap_Matrix_IsSquare, METH_O, "Matrix_IsSquare(Matrix self) -> bool"}, { "Matrix_Elem", _wrap_Matrix_Elem, METH_VARARGS, "\n" "Matrix_Elem(Matrix self, int i, int j) -> double\n" "Matrix_Elem(Matrix self, int i, int j) -> double const &\n" @@ -4968,6 +5021,32 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Matrix_IsSquare", _wrap_Matrix_IsSquare, METH_O, "IsSquare(Matrix self) -> bool"}, + { "Matrix_Elem", _wrap_Matrix_Elem, METH_VARARGS, "\n" + "Elem(Matrix self, int i, int j) -> double\n" + "Elem(Matrix self, int i, int j) -> double const &\n" + ""}, + { "Matrix_Inverse", _wrap_Matrix_Inverse, METH_O, "Inverse(Matrix self) -> MatrixInverse"}, + { "Matrix_Finalize", _wrap_Matrix_Finalize, METH_VARARGS, "Finalize(Matrix self, int arg2)"}, + { "delete_Matrix", _wrap_delete_Matrix, METH_O, "delete_Matrix(Matrix self)"}, + { "Matrix_Print", _wrap_Matrix_Print, METH_VARARGS, "\n" + "Print(Matrix self, std::ostream & out=mfem::out, int width_=4)\n" + "Print(Matrix self, char const * file, int precision=8)\n" + ""}, + { "Matrix_swigregister", Matrix_swigregister, METH_O, NULL}, + { "delete_MatrixInverse", _wrap_delete_MatrixInverse, METH_O, "delete_MatrixInverse(MatrixInverse self)"}, + { "MatrixInverse_swigregister", MatrixInverse_swigregister, METH_O, NULL}, + { "AbstractSparseMatrix_NumNonZeroElems", _wrap_AbstractSparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(AbstractSparseMatrix self) -> int"}, + { "AbstractSparseMatrix_GetRow", _wrap_AbstractSparseMatrix_GetRow, METH_VARARGS, "GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "AbstractSparseMatrix_EliminateZeroRows", _wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, + { "AbstractSparseMatrix_Mult", _wrap_AbstractSparseMatrix_Mult, METH_VARARGS, "Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMult", _wrap_AbstractSparseMatrix_AddMult, METH_VARARGS, "AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_MultTranspose", _wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMultTranspose", _wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "delete_AbstractSparseMatrix", _wrap_delete_AbstractSparseMatrix, METH_O, "delete_AbstractSparseMatrix(AbstractSparseMatrix self)"}, + { "AbstractSparseMatrix_swigregister", AbstractSparseMatrix_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } }; @@ -4977,44 +5056,53 @@ static PyMethodDef SwigMethods_proxydocs[] = { static void *_p_mfem__MatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) ((mfem::MatrixInverse *) x)); } +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +} static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); -} -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Matrix(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); @@ -5027,15 +5115,18 @@ static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", " static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", "mfem::Matrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", "mfem::MatrixInverse *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -5054,6 +5145,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, @@ -5068,16 +5162,19 @@ static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = { {&_swigt__p_mf static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = { {&_swigt__p_mfem__Matrix, 0, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Matrix, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; @@ -5096,6 +5193,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, diff --git a/mfem/_ser/mem_manager.py b/mfem/_ser/mem_manager.py index 1a957c13..61f282ee 100644 --- a/mfem/_ser/mem_manager.py +++ b/mfem/_ser/mem_manager.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _mem_manager.SWIG_PyInstanceMethod_New +_swig_new_static_method = _mem_manager.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -64,22 +67,34 @@ class _SwigNonDynamicMeta(type): MemoryType_HOST = _mem_manager.MemoryType_HOST MemoryType_HOST_32 = _mem_manager.MemoryType_HOST_32 MemoryType_HOST_64 = _mem_manager.MemoryType_HOST_64 -MemoryType_CUDA = _mem_manager.MemoryType_CUDA -MemoryType_CUDA_UVM = _mem_manager.MemoryType_CUDA_UVM +MemoryType_HOST_DEBUG = _mem_manager.MemoryType_HOST_DEBUG +MemoryType_HOST_UMPIRE = _mem_manager.MemoryType_HOST_UMPIRE +MemoryType_MANAGED = _mem_manager.MemoryType_MANAGED +MemoryType_DEVICE = _mem_manager.MemoryType_DEVICE +MemoryType_DEVICE_DEBUG = _mem_manager.MemoryType_DEVICE_DEBUG +MemoryType_DEVICE_UMPIRE = _mem_manager.MemoryType_DEVICE_UMPIRE +MemoryType_SIZE = _mem_manager.MemoryType_SIZE MemoryClass_HOST = _mem_manager.MemoryClass_HOST MemoryClass_HOST_32 = _mem_manager.MemoryClass_HOST_32 MemoryClass_HOST_64 = _mem_manager.MemoryClass_HOST_64 -MemoryClass_CUDA = _mem_manager.MemoryClass_CUDA -MemoryClass_CUDA_UVM = _mem_manager.MemoryClass_CUDA_UVM +MemoryClass_DEVICE = _mem_manager.MemoryClass_DEVICE +MemoryClass_MANAGED = _mem_manager.MemoryClass_MANAGED def IsHostMemory(mt): return _mem_manager.IsHostMemory(mt) +IsHostMemory = _mem_manager.IsHostMemory + +def IsDeviceMemory(mt): + return _mem_manager.IsDeviceMemory(mt) +IsDeviceMemory = _mem_manager.IsDeviceMemory def GetMemoryType(mc): return _mem_manager.GetMemoryType(mc) +GetMemoryType = _mem_manager.GetMemoryType def __mul__(mc1, mc2): return _mem_manager.__mul__(mc1, mc2) +__mul__ = _mem_manager.__mul__ class MemoryManager(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr @@ -88,28 +103,68 @@ def __init__(self): _mem_manager.MemoryManager_swiginit(self, _mem_manager.new_MemoryManager()) __swig_destroy__ = _mem_manager.delete_MemoryManager + def Init(self): + return _mem_manager.MemoryManager_Init(self) + Init = _swig_new_instance_method(_mem_manager.MemoryManager_Init) + + def Configure(self, h_mt, d_mt): + return _mem_manager.MemoryManager_Configure(self, h_mt, d_mt) + Configure = _swig_new_instance_method(_mem_manager.MemoryManager_Configure) + def Destroy(self): return _mem_manager.MemoryManager_Destroy(self) + Destroy = _swig_new_instance_method(_mem_manager.MemoryManager_Destroy) - @staticmethod - def Exists(): - return _mem_manager.MemoryManager_Exists() + def IsKnown(self, h_ptr): + return _mem_manager.MemoryManager_IsKnown(self, h_ptr) + IsKnown = _swig_new_instance_method(_mem_manager.MemoryManager_IsKnown) + + def IsAlias(self, h_ptr): + return _mem_manager.MemoryManager_IsAlias(self, h_ptr) + IsAlias = _swig_new_instance_method(_mem_manager.MemoryManager_IsAlias) + + def RegisterCheck(self, h_ptr): + return _mem_manager.MemoryManager_RegisterCheck(self, h_ptr) + RegisterCheck = _swig_new_instance_method(_mem_manager.MemoryManager_RegisterCheck) - def RegisterCheck(self, ptr): - return _mem_manager.MemoryManager_RegisterCheck(self, ptr) + def PrintPtrs(self, *args): + return _mem_manager.MemoryManager_PrintPtrs(self, *args) + PrintPtrs = _swig_new_instance_method(_mem_manager.MemoryManager_PrintPtrs) - def PrintPtrs(self): - return _mem_manager.MemoryManager_PrintPtrs(self) + def PrintAliases(self, *args): + return _mem_manager.MemoryManager_PrintAliases(self, *args) + PrintAliases = _swig_new_instance_method(_mem_manager.MemoryManager_PrintAliases) + + @staticmethod + def GetHostMemoryType(): + return _mem_manager.MemoryManager_GetHostMemoryType() + GetHostMemoryType = _swig_new_static_method(_mem_manager.MemoryManager_GetHostMemoryType) + + @staticmethod + def GetDeviceMemoryType(): + return _mem_manager.MemoryManager_GetDeviceMemoryType() + GetDeviceMemoryType = _swig_new_static_method(_mem_manager.MemoryManager_GetDeviceMemoryType) # Register MemoryManager in _mem_manager: _mem_manager.MemoryManager_swigregister(MemoryManager) +cvar = _mem_manager.cvar +MemoryTypeSize = cvar.MemoryTypeSize +HostMemoryType = cvar.HostMemoryType +HostMemoryTypeSize = cvar.HostMemoryTypeSize +DeviceMemoryType = cvar.DeviceMemoryType +DeviceMemoryTypeSize = cvar.DeviceMemoryTypeSize + +def MemoryManager_GetHostMemoryType(): + return _mem_manager.MemoryManager_GetHostMemoryType() +MemoryManager_GetHostMemoryType = _mem_manager.MemoryManager_GetHostMemoryType -def MemoryManager_Exists(): - return _mem_manager.MemoryManager_Exists() +def MemoryManager_GetDeviceMemoryType(): + return _mem_manager.MemoryManager_GetDeviceMemoryType() +MemoryManager_GetDeviceMemoryType = _mem_manager.MemoryManager_GetDeviceMemoryType def MemoryPrintFlags(flags): return _mem_manager.MemoryPrintFlags(flags) +MemoryPrintFlags = _mem_manager.MemoryPrintFlags -cvar = _mem_manager.cvar diff --git a/mfem/_ser/mem_manager_wrap.cxx b/mfem/_ser/mem_manager_wrap.cxx index d497e35c..af5ea2e1 100644 --- a/mfem/_ser/mem_manager_wrap.cxx +++ b/mfem/_ser/mem_manager_wrap.cxx @@ -2662,8 +2662,10 @@ SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyO #define SWIGTYPE_p_char swig_types[0] #define SWIGTYPE_p_mfem__MemoryManager swig_types[1] -static swig_type_info *swig_types[3]; -static swig_module_info swig_module = {swig_types, 2, 0, 0, 0, 0}; +#define SWIGTYPE_p_p_char swig_types[2] +#define SWIGTYPE_p_std__ostream swig_types[3] +static swig_type_info *swig_types[5]; +static swig_module_info swig_module = {swig_types, 4, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3003,6 +3005,103 @@ SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val) #ifdef __cplusplus extern "C" { #endif +SWIGINTERN int Swig_var_MemoryTypeSize_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable MemoryTypeSize is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_MemoryTypeSize_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::MemoryTypeSize)); + return pyobj; +} + + +SWIGINTERN int Swig_var_HostMemoryType_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable HostMemoryType is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_HostMemoryType_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::HostMemoryType)); + return pyobj; +} + + +SWIGINTERN int Swig_var_HostMemoryTypeSize_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable HostMemoryTypeSize is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_HostMemoryTypeSize_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::HostMemoryTypeSize)); + return pyobj; +} + + +SWIGINTERN int Swig_var_DeviceMemoryType_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable DeviceMemoryType is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_DeviceMemoryType_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::DeviceMemoryType)); + return pyobj; +} + + +SWIGINTERN int Swig_var_DeviceMemoryTypeSize_set(PyObject *) { + SWIG_Error(SWIG_AttributeError,"Variable DeviceMemoryTypeSize is read-only."); + return 1; +} + + +SWIGINTERN PyObject *Swig_var_DeviceMemoryTypeSize_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_From_int(static_cast< int >(mfem::DeviceMemoryTypeSize)); + return pyobj; +} + + +SWIGINTERN int Swig_var_MemoryTypeName_set(PyObject *_val) { + { + char const * *inp = 0; + int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char, 0 ); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in variable '""mfem::MemoryTypeName""' of type '""char const *[mfem::MemoryTypeSize]""'"); + } else if (inp) { + size_t ii = 0; + for (; ii < (size_t)mfem::MemoryTypeSize; ++ii) *(char const * *)&mfem::MemoryTypeName[ii] = *((char const * *)inp + ii); + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""mfem::MemoryTypeName""' of type '""char const *[mfem::MemoryTypeSize]""'"); + } + } + return 0; +fail: + return 1; +} + + +SWIGINTERN PyObject *Swig_var_MemoryTypeName_get(void) { + PyObject *pyobj = 0; + + pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mfem::MemoryTypeName), SWIGTYPE_p_p_char, 0 ); + return pyobj; +} + + SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryType arg1 ; @@ -3041,6 +3140,44 @@ SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject } +SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDeviceMemory" "', argument " "1"" of type '" "mfem::MemoryType""'"); + } + arg1 = static_cast< mfem::MemoryType >(val1); + { + try { + result = (bool)mfem::IsDeviceMemory(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryClass arg1 ; @@ -3191,6 +3328,95 @@ SWIGINTERN PyObject *_wrap_delete_MemoryManager(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_MemoryManager_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_Init" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + { + try { + (arg1)->Init(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + mfem::MemoryType arg2 ; + mfem::MemoryType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_Configure", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_Configure" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryManager_Configure" "', argument " "2"" of type '" "mfem::MemoryType""'"); + } + arg2 = static_cast< mfem::MemoryType >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryManager_Configure" "', argument " "3"" of type '" "mfem::MemoryType""'"); + } + arg3 = static_cast< mfem::MemoryType >(val3); + { + try { + (arg1)->Configure(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_MemoryManager_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; @@ -3228,14 +3454,72 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Destroy(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_Exists(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *arg2 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + PyObject *swig_obj[2] ; + bool result; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsKnown", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsKnown" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsKnown" "', argument " "2"" of type '" "void const *""'"); + } + { + try { + result = (bool)(arg1)->IsKnown((void const *)arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *arg2 = (void *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + PyObject *swig_obj[2] ; bool result; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_Exists", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsAlias", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsAlias" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsAlias" "', argument " "2"" of type '" "void const *""'"); + } { try { - result = (bool)mfem::MemoryManager::Exists(); + result = (bool)(arg1)->IsAlias((void const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3298,23 +3582,33 @@ SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); { try { - (arg1)->PrintPtrs(); + result = (int)(arg1)->PrintPtrs(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3328,7 +3622,264 @@ SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + { + try { + result = (int)(arg1)->PrintPtrs(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintPtrs", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintPtrs__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintPtrs__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintPtrs'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MemoryManager::PrintPtrs(std::ostream &)\n" + " mfem::MemoryManager::PrintPtrs()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int result; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); + } + arg2 = reinterpret_cast< std::ostream * >(argp2); + { + try { + result = (int)(arg1)->PrintAliases(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + } + arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); + { + try { + result = (int)(arg1)->PrintAliases(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintAliases", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintAliases__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MemoryManager_PrintAliases__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintAliases'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MemoryManager::PrintAliases(std::ostream &)\n" + " mfem::MemoryManager::PrintAliases()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_GetHostMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_GetHostMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::MemoryManager::GetHostMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MemoryManager_GetDeviceMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MemoryType result; + + if (!SWIG_Python_UnpackTuple(args, "MemoryManager_GetDeviceMemoryType", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MemoryType)mfem::MemoryManager::GetDeviceMemoryType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; @@ -3415,15 +3966,23 @@ SWIGINTERN PyObject *Swig_var_mm_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, + { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, + { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, + { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, - { "MemoryManager_Exists", _wrap_MemoryManager_Exists, METH_NOARGS, NULL}, + { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, + { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, - { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_O, NULL}, + { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, + { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, + { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, @@ -3431,6 +3990,27 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, + { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, + { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, + { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, + { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, + { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, + { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, + { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, + { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, + { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, + { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, + { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, + { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, + { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, + { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, + { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, + { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, + { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, { NULL, NULL, 0, NULL } }; @@ -3439,18 +4019,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__MemoryManager = {"_p_mfem__MemoryManager", "mfem::MemoryManager *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_char, &_swigt__p_mfem__MemoryManager, + &_swigt__p_p_char, + &_swigt__p_std__ostream, }; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MemoryManager[] = { {&_swigt__p_mfem__MemoryManager, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_char, _swigc__p_mfem__MemoryManager, + _swigc__p_p_char, + _swigc__p_std__ostream, }; @@ -4186,13 +4774,13 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MemoryType_HOST",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST))); SWIG_Python_SetConstant(d, "MemoryType_HOST_32",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_32))); SWIG_Python_SetConstant(d, "MemoryType_HOST_64",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_64))); - SWIG_Python_SetConstant(d, "MemoryType_CUDA",SWIG_From_int(static_cast< int >(mfem::MemoryType::CUDA))); - SWIG_Python_SetConstant(d, "MemoryType_CUDA_UVM",SWIG_From_int(static_cast< int >(mfem::MemoryType::CUDA_UVM))); - SWIG_Python_SetConstant(d, "MemoryClass_HOST",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST))); - SWIG_Python_SetConstant(d, "MemoryClass_HOST_32",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_32))); - SWIG_Python_SetConstant(d, "MemoryClass_HOST_64",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_64))); - SWIG_Python_SetConstant(d, "MemoryClass_CUDA",SWIG_From_int(static_cast< int >(mfem::MemoryClass::CUDA))); - SWIG_Python_SetConstant(d, "MemoryClass_CUDA_UVM",SWIG_From_int(static_cast< int >(mfem::MemoryClass::CUDA_UVM))); + SWIG_Python_SetConstant(d, "MemoryType_HOST_DEBUG",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_DEBUG))); + SWIG_Python_SetConstant(d, "MemoryType_HOST_UMPIRE",SWIG_From_int(static_cast< int >(mfem::MemoryType::HOST_UMPIRE))); + SWIG_Python_SetConstant(d, "MemoryType_MANAGED",SWIG_From_int(static_cast< int >(mfem::MemoryType::MANAGED))); + SWIG_Python_SetConstant(d, "MemoryType_DEVICE",SWIG_From_int(static_cast< int >(mfem::MemoryType::DEVICE))); + SWIG_Python_SetConstant(d, "MemoryType_DEVICE_DEBUG",SWIG_From_int(static_cast< int >(mfem::MemoryType::DEVICE_DEBUG))); + SWIG_Python_SetConstant(d, "MemoryType_DEVICE_UMPIRE",SWIG_From_int(static_cast< int >(mfem::MemoryType::DEVICE_UMPIRE))); + SWIG_Python_SetConstant(d, "MemoryType_SIZE",SWIG_From_int(static_cast< int >(mfem::MemoryType::SIZE))); globals = SWIG_globals(); if (!globals) { PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals."); @@ -4204,6 +4792,17 @@ SWIG_init(void) { } PyDict_SetItemString(md, "cvar", globals); Py_DECREF(globals); + SWIG_addvarlink(globals, "MemoryTypeSize", Swig_var_MemoryTypeSize_get, Swig_var_MemoryTypeSize_set); + SWIG_addvarlink(globals, "HostMemoryType", Swig_var_HostMemoryType_get, Swig_var_HostMemoryType_set); + SWIG_addvarlink(globals, "HostMemoryTypeSize", Swig_var_HostMemoryTypeSize_get, Swig_var_HostMemoryTypeSize_set); + SWIG_addvarlink(globals, "DeviceMemoryType", Swig_var_DeviceMemoryType_get, Swig_var_DeviceMemoryType_set); + SWIG_addvarlink(globals, "DeviceMemoryTypeSize", Swig_var_DeviceMemoryTypeSize_get, Swig_var_DeviceMemoryTypeSize_set); + SWIG_addvarlink(globals, "MemoryTypeName", Swig_var_MemoryTypeName_get, Swig_var_MemoryTypeName_set); + SWIG_Python_SetConstant(d, "MemoryClass_HOST",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST))); + SWIG_Python_SetConstant(d, "MemoryClass_HOST_32",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_32))); + SWIG_Python_SetConstant(d, "MemoryClass_HOST_64",SWIG_From_int(static_cast< int >(mfem::MemoryClass::HOST_64))); + SWIG_Python_SetConstant(d, "MemoryClass_DEVICE",SWIG_From_int(static_cast< int >(mfem::MemoryClass::DEVICE))); + SWIG_Python_SetConstant(d, "MemoryClass_MANAGED",SWIG_From_int(static_cast< int >(mfem::MemoryClass::MANAGED))); SWIG_addvarlink(globals, "mm", Swig_var_mm_get, Swig_var_mm_set); #if PY_VERSION_HEX >= 0x03000000 return m; diff --git a/mfem/_ser/mesh.i b/mfem/_ser/mesh.i index 33333837..270fdd0d 100644 --- a/mfem/_ser/mesh.i +++ b/mfem/_ser/mesh.i @@ -31,6 +31,7 @@ import_array(); %import "gridfunc.i" %import "element.i" %import "vertex.i" +%import "vtk.i" %import "mesh/mesquite.hpp" %import "densemat.i" %import "sparsemat.i" diff --git a/mfem/_ser/mesh.py b/mfem/_ser/mesh.py index 361251cf..be734770 100644 --- a/mfem/_ser/mesh.py +++ b/mfem/_ser/mesh.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _mesh.SWIG_PyInstanceMethod_New +_swig_new_static_method = _mesh.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -73,22 +76,27 @@ def __init__(self): def assign(self, value): return _mesh.intp_assign(self, value) + assign = _swig_new_instance_method(_mesh.intp_assign) def value(self): return _mesh.intp_value(self) + value = _swig_new_instance_method(_mesh.intp_value) def cast(self): return _mesh.intp_cast(self) + cast = _swig_new_instance_method(_mesh.intp_cast) @staticmethod def frompointer(t): return _mesh.intp_frompointer(t) + frompointer = _swig_new_static_method(_mesh.intp_frompointer) # Register intp in _mesh: _mesh.intp_swigregister(intp) def intp_frompointer(t): return _mesh.intp_frompointer(t) +intp_frompointer = _mesh.intp_frompointer class doublep(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -100,22 +108,27 @@ def __init__(self): def assign(self, value): return _mesh.doublep_assign(self, value) + assign = _swig_new_instance_method(_mesh.doublep_assign) def value(self): return _mesh.doublep_value(self) + value = _swig_new_instance_method(_mesh.doublep_value) def cast(self): return _mesh.doublep_cast(self) + cast = _swig_new_instance_method(_mesh.doublep_cast) @staticmethod def frompointer(t): return _mesh.doublep_frompointer(t) + frompointer = _swig_new_static_method(_mesh.doublep_frompointer) # Register doublep in _mesh: _mesh.doublep_swigregister(doublep) def doublep_frompointer(t): return _mesh.doublep_frompointer(t) +doublep_frompointer = _mesh.doublep_frompointer import mfem._ser.matrix import mfem._ser.vector @@ -135,12 +148,18 @@ def doublep_frompointer(t): import mfem._ser.fe_coll import mfem._ser.lininteg import mfem._ser.handle -import mfem._ser.bilininteg -import mfem._ser.linearform +import mfem._ser.restriction import mfem._ser.element import mfem._ser.table import mfem._ser.hash +import mfem._ser.bilininteg +import mfem._ser.linearform import mfem._ser.vertex +import mfem._ser.vtk +FaceType_Interior = _mesh.FaceType_Interior + +FaceType_Boundary = _mesh.FaceType_Boundary + class Mesh(object): r"""Proxy of C++ mfem::Mesh class.""" @@ -159,183 +178,248 @@ class Mesh(object): NURBSext = property(_mesh.Mesh_NURBSext_get, _mesh.Mesh_NURBSext_set, doc=r"""NURBSext : p.mfem::NURBSExtension""") ncmesh = property(_mesh.Mesh_ncmesh_get, _mesh.Mesh_ncmesh_set, doc=r"""ncmesh : p.mfem::NCMesh""") geom_factors = property(_mesh.Mesh_geom_factors_get, _mesh.Mesh_geom_factors_set, doc=r"""geom_factors : mfem::Array<(p.mfem::GeometricFactors)>""") + face_geom_factors = property(_mesh.Mesh_face_geom_factors_get, _mesh.Mesh_face_geom_factors_set, doc=r"""face_geom_factors : mfem::Array<(p.mfem::FaceGeometricFactors)>""") remove_unused_vertices = property(_mesh.Mesh_remove_unused_vertices_get, _mesh.Mesh_remove_unused_vertices_set, doc=r"""remove_unused_vertices : bool""") def NewElement(self, geom): r"""NewElement(Mesh self, int geom) -> Element""" return _mesh.Mesh_NewElement(self, geom) + NewElement = _swig_new_instance_method(_mesh.Mesh_NewElement) def AddVertex(self, arg2): r"""AddVertex(Mesh self, double const * arg2)""" return _mesh.Mesh_AddVertex(self, arg2) + AddVertex = _swig_new_instance_method(_mesh.Mesh_AddVertex) + + def AddSegment(self, vi, attr=1): + r"""AddSegment(Mesh self, int const * vi, int attr=1)""" + return _mesh.Mesh_AddSegment(self, vi, attr) + AddSegment = _swig_new_instance_method(_mesh.Mesh_AddSegment) def AddTri(self, vi, attr=1): r"""AddTri(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddTri(self, vi, attr) + AddTri = _swig_new_instance_method(_mesh.Mesh_AddTri) def AddTriangle(self, vi, attr=1): r"""AddTriangle(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddTriangle(self, vi, attr) + AddTriangle = _swig_new_instance_method(_mesh.Mesh_AddTriangle) def AddQuad(self, vi, attr=1): r"""AddQuad(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddQuad(self, vi, attr) + AddQuad = _swig_new_instance_method(_mesh.Mesh_AddQuad) def AddTet(self, vi, attr=1): r"""AddTet(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddTet(self, vi, attr) + AddTet = _swig_new_instance_method(_mesh.Mesh_AddTet) def AddWedge(self, vi, attr=1): r"""AddWedge(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddWedge(self, vi, attr) + AddWedge = _swig_new_instance_method(_mesh.Mesh_AddWedge) def AddHex(self, vi, attr=1): r"""AddHex(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddHex(self, vi, attr) + AddHex = _swig_new_instance_method(_mesh.Mesh_AddHex) def AddHexAsTets(self, vi, attr=1): r"""AddHexAsTets(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddHexAsTets(self, vi, attr) + AddHexAsTets = _swig_new_instance_method(_mesh.Mesh_AddHexAsTets) def AddHexAsWedges(self, vi, attr=1): r"""AddHexAsWedges(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddHexAsWedges(self, vi, attr) + AddHexAsWedges = _swig_new_instance_method(_mesh.Mesh_AddHexAsWedges) def AddElement(self, elem): r"""AddElement(Mesh self, Element elem)""" return _mesh.Mesh_AddElement(self, elem) + AddElement = _swig_new_instance_method(_mesh.Mesh_AddElement) def AddBdrElement(self, elem): r"""AddBdrElement(Mesh self, Element elem)""" return _mesh.Mesh_AddBdrElement(self, elem) + AddBdrElement = _swig_new_instance_method(_mesh.Mesh_AddBdrElement) def AddBdrSegment(self, vi, attr=1): r"""AddBdrSegment(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrSegment(self, vi, attr) + AddBdrSegment = _swig_new_instance_method(_mesh.Mesh_AddBdrSegment) def AddBdrTriangle(self, vi, attr=1): r"""AddBdrTriangle(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrTriangle(self, vi, attr) + AddBdrTriangle = _swig_new_instance_method(_mesh.Mesh_AddBdrTriangle) def AddBdrQuad(self, vi, attr=1): r"""AddBdrQuad(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrQuad(self, vi, attr) + AddBdrQuad = _swig_new_instance_method(_mesh.Mesh_AddBdrQuad) def AddBdrQuadAsTriangles(self, vi, attr=1): r"""AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)""" return _mesh.Mesh_AddBdrQuadAsTriangles(self, vi, attr) + AddBdrQuadAsTriangles = _swig_new_instance_method(_mesh.Mesh_AddBdrQuadAsTriangles) def GenerateBoundaryElements(self): r"""GenerateBoundaryElements(Mesh self)""" return _mesh.Mesh_GenerateBoundaryElements(self) + GenerateBoundaryElements = _swig_new_instance_method(_mesh.Mesh_GenerateBoundaryElements) def FinalizeTriMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeTriMesh(self, generate_edges, refine, fix_orientation) + FinalizeTriMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeTriMesh) def FinalizeQuadMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeQuadMesh(self, generate_edges, refine, fix_orientation) + FinalizeQuadMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeQuadMesh) def FinalizeTetMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeTetMesh(self, generate_edges, refine, fix_orientation) + FinalizeTetMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeTetMesh) def FinalizeWedgeMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeWedgeMesh(self, generate_edges, refine, fix_orientation) + FinalizeWedgeMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeWedgeMesh) def FinalizeHexMesh(self, generate_edges=0, refine=0, fix_orientation=True): r"""FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeHexMesh(self, generate_edges, refine, fix_orientation) + FinalizeHexMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeHexMesh) def FinalizeMesh(self, refine=0, fix_orientation=True): r"""FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)""" return _mesh.Mesh_FinalizeMesh(self, refine, fix_orientation) + FinalizeMesh = _swig_new_instance_method(_mesh.Mesh_FinalizeMesh) - def FinalizeTopology(self): - r"""FinalizeTopology(Mesh self)""" - return _mesh.Mesh_FinalizeTopology(self) + def FinalizeTopology(self, generate_bdr=True): + r"""FinalizeTopology(Mesh self, bool generate_bdr=True)""" + return _mesh.Mesh_FinalizeTopology(self, generate_bdr) + FinalizeTopology = _swig_new_instance_method(_mesh.Mesh_FinalizeTopology) def Finalize(self, refine=False, fix_orientation=False): r"""Finalize(Mesh self, bool refine=False, bool fix_orientation=False)""" return _mesh.Mesh_Finalize(self, refine, fix_orientation) + Finalize = _swig_new_instance_method(_mesh.Mesh_Finalize) def SetAttributes(self): r"""SetAttributes(Mesh self)""" return _mesh.Mesh_SetAttributes(self) + SetAttributes = _swig_new_instance_method(_mesh.Mesh_SetAttributes) + + def GetHilbertElementOrdering(self, ordering): + r"""GetHilbertElementOrdering(Mesh self, intArray ordering)""" + return _mesh.Mesh_GetHilbertElementOrdering(self, ordering) + GetHilbertElementOrdering = _swig_new_instance_method(_mesh.Mesh_GetHilbertElementOrdering) def ReorderElements(self, ordering, reorder_vertices=True): r"""ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)""" return _mesh.Mesh_ReorderElements(self, ordering, reorder_vertices) + ReorderElements = _swig_new_instance_method(_mesh.Mesh_ReorderElements) def Load(self, input, generate_edges=0, refine=1, fix_orientation=True): r"""Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)""" return _mesh.Mesh_Load(self, input, generate_edges, refine, fix_orientation) + Load = _swig_new_instance_method(_mesh.Mesh_Load) def Clear(self): r"""Clear(Mesh self)""" return _mesh.Mesh_Clear(self) + Clear = _swig_new_instance_method(_mesh.Mesh_Clear) def MeshGenerator(self): r"""MeshGenerator(Mesh self) -> int""" return _mesh.Mesh_MeshGenerator(self) + MeshGenerator = _swig_new_instance_method(_mesh.Mesh_MeshGenerator) def GetNV(self): r"""GetNV(Mesh self) -> int""" return _mesh.Mesh_GetNV(self) + GetNV = _swig_new_instance_method(_mesh.Mesh_GetNV) def GetNE(self): r"""GetNE(Mesh self) -> int""" return _mesh.Mesh_GetNE(self) + GetNE = _swig_new_instance_method(_mesh.Mesh_GetNE) def GetNBE(self): r"""GetNBE(Mesh self) -> int""" return _mesh.Mesh_GetNBE(self) + GetNBE = _swig_new_instance_method(_mesh.Mesh_GetNBE) def GetNEdges(self): r"""GetNEdges(Mesh self) -> int""" return _mesh.Mesh_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_mesh.Mesh_GetNEdges) def GetNFaces(self): r"""GetNFaces(Mesh self) -> int""" return _mesh.Mesh_GetNFaces(self) + GetNFaces = _swig_new_instance_method(_mesh.Mesh_GetNFaces) def GetNumFaces(self): r"""GetNumFaces(Mesh self) -> int""" return _mesh.Mesh_GetNumFaces(self) + GetNumFaces = _swig_new_instance_method(_mesh.Mesh_GetNumFaces) + + def GetNFbyType(self, type): + r"""GetNFbyType(Mesh self, mfem::FaceType type) -> int""" + return _mesh.Mesh_GetNFbyType(self, type) + GetNFbyType = _swig_new_instance_method(_mesh.Mesh_GetNFbyType) def ReduceInt(self, value): r"""ReduceInt(Mesh self, int value) -> long""" return _mesh.Mesh_ReduceInt(self, value) + ReduceInt = _swig_new_instance_method(_mesh.Mesh_ReduceInt) def GetGlobalNE(self): r"""GetGlobalNE(Mesh self) -> long""" return _mesh.Mesh_GetGlobalNE(self) + GetGlobalNE = _swig_new_instance_method(_mesh.Mesh_GetGlobalNE) def GetGeometricFactors(self, ir, flags): r"""GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors""" return _mesh.Mesh_GetGeometricFactors(self, ir, flags) + GetGeometricFactors = _swig_new_instance_method(_mesh.Mesh_GetGeometricFactors) + + def GetFaceGeometricFactors(self, ir, flags, type): + r"""GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors""" + return _mesh.Mesh_GetFaceGeometricFactors(self, ir, flags, type) + GetFaceGeometricFactors = _swig_new_instance_method(_mesh.Mesh_GetFaceGeometricFactors) def DeleteGeometricFactors(self): r"""DeleteGeometricFactors(Mesh self)""" return _mesh.Mesh_DeleteGeometricFactors(self) + DeleteGeometricFactors = _swig_new_instance_method(_mesh.Mesh_DeleteGeometricFactors) def EulerNumber(self): r"""EulerNumber(Mesh self) -> int""" return _mesh.Mesh_EulerNumber(self) + EulerNumber = _swig_new_instance_method(_mesh.Mesh_EulerNumber) def EulerNumber2D(self): r"""EulerNumber2D(Mesh self) -> int""" return _mesh.Mesh_EulerNumber2D(self) + EulerNumber2D = _swig_new_instance_method(_mesh.Mesh_EulerNumber2D) def Dimension(self): r"""Dimension(Mesh self) -> int""" return _mesh.Mesh_Dimension(self) + Dimension = _swig_new_instance_method(_mesh.Mesh_Dimension) def SpaceDimension(self): r"""SpaceDimension(Mesh self) -> int""" return _mesh.Mesh_SpaceDimension(self) + SpaceDimension = _swig_new_instance_method(_mesh.Mesh_SpaceDimension) def GetVertex(self, *args): r""" @@ -343,22 +427,27 @@ def GetVertex(self, *args): GetVertex(Mesh self, int i) -> double * """ return _mesh.Mesh_GetVertex(self, *args) + GetVertex = _swig_new_instance_method(_mesh.Mesh_GetVertex) def GetElementData(self, geom, elem_vtx, attr): r"""GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)""" return _mesh.Mesh_GetElementData(self, geom, elem_vtx, attr) + GetElementData = _swig_new_instance_method(_mesh.Mesh_GetElementData) def GetBdrElementData(self, geom, bdr_elem_vtx, bdr_attr): r"""GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)""" return _mesh.Mesh_GetBdrElementData(self, geom, bdr_elem_vtx, bdr_attr) + GetBdrElementData = _swig_new_instance_method(_mesh.Mesh_GetBdrElementData) def ChangeVertexDataOwnership(self, vertices, len_vertices, zerocopy=False): r"""ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)""" return _mesh.Mesh_ChangeVertexDataOwnership(self, vertices, len_vertices, zerocopy) + ChangeVertexDataOwnership = _swig_new_instance_method(_mesh.Mesh_ChangeVertexDataOwnership) def GetElementsArray(self): r"""GetElementsArray(Mesh self) -> mfem::Element const *const *""" return _mesh.Mesh_GetElementsArray(self) + GetElementsArray = _swig_new_instance_method(_mesh.Mesh_GetElementsArray) def GetElement(self, *args): r""" @@ -366,6 +455,7 @@ def GetElement(self, *args): GetElement(Mesh self, int i) -> Element """ return _mesh.Mesh_GetElement(self, *args) + GetElement = _swig_new_instance_method(_mesh.Mesh_GetElement) def GetBdrElement(self, *args): r""" @@ -373,34 +463,42 @@ def GetBdrElement(self, *args): GetBdrElement(Mesh self, int i) -> Element """ return _mesh.Mesh_GetBdrElement(self, *args) + GetBdrElement = _swig_new_instance_method(_mesh.Mesh_GetBdrElement) def GetFace(self, i): r"""GetFace(Mesh self, int i) -> Element""" return _mesh.Mesh_GetFace(self, i) + GetFace = _swig_new_instance_method(_mesh.Mesh_GetFace) def GetFaceBaseGeometry(self, i): r"""GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type""" return _mesh.Mesh_GetFaceBaseGeometry(self, i) + GetFaceBaseGeometry = _swig_new_instance_method(_mesh.Mesh_GetFaceBaseGeometry) def GetElementBaseGeometry(self, i): r"""GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type""" return _mesh.Mesh_GetElementBaseGeometry(self, i) + GetElementBaseGeometry = _swig_new_instance_method(_mesh.Mesh_GetElementBaseGeometry) def GetBdrElementBaseGeometry(self, i): r"""GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type""" return _mesh.Mesh_GetBdrElementBaseGeometry(self, i) + GetBdrElementBaseGeometry = _swig_new_instance_method(_mesh.Mesh_GetBdrElementBaseGeometry) def HasGeometry(self, geom): r"""HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool""" return _mesh.Mesh_HasGeometry(self, geom) + HasGeometry = _swig_new_instance_method(_mesh.Mesh_HasGeometry) def GetNumGeometries(self, dim): r"""GetNumGeometries(Mesh self, int dim) -> int""" return _mesh.Mesh_GetNumGeometries(self, dim) + GetNumGeometries = _swig_new_instance_method(_mesh.Mesh_GetNumGeometries) def GetGeometries(self, dim, el_geoms): r"""GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)""" return _mesh.Mesh_GetGeometries(self, dim, el_geoms) + GetGeometries = _swig_new_instance_method(_mesh.Mesh_GetGeometries) def GetElementVertices(self, i): from .array import intArray @@ -464,10 +562,12 @@ def GetEdgeVertices(self, i): def GetFaceEdgeTable(self): r"""GetFaceEdgeTable(Mesh self) -> Table""" return _mesh.Mesh_GetFaceEdgeTable(self) + GetFaceEdgeTable = _swig_new_instance_method(_mesh.Mesh_GetFaceEdgeTable) def GetEdgeVertexTable(self): r"""GetEdgeVertexTable(Mesh self) -> Table""" return _mesh.Mesh_GetEdgeVertexTable(self) + GetEdgeVertexTable = _swig_new_instance_method(_mesh.Mesh_GetEdgeVertexTable) def GetElementFaces(self, i): from .array import intArray @@ -481,6 +581,7 @@ def GetElementFaces(self, i): def GetBdrElementEdgeIndex(self, i): r"""GetBdrElementEdgeIndex(Mesh self, int i) -> int""" return _mesh.Mesh_GetBdrElementEdgeIndex(self, i) + GetBdrElementEdgeIndex = _swig_new_instance_method(_mesh.Mesh_GetBdrElementEdgeIndex) def GetBdrElementAdjacentElement(self, bdr_el): from mfem.ser import intp @@ -494,23 +595,28 @@ def GetBdrElementAdjacentElement(self, bdr_el): def GetElementType(self, i): r"""GetElementType(Mesh self, int i) -> mfem::Element::Type""" return _mesh.Mesh_GetElementType(self, i) + GetElementType = _swig_new_instance_method(_mesh.Mesh_GetElementType) def GetBdrElementType(self, i): r"""GetBdrElementType(Mesh self, int i) -> mfem::Element::Type""" return _mesh.Mesh_GetBdrElementType(self, i) + GetBdrElementType = _swig_new_instance_method(_mesh.Mesh_GetBdrElementType) def GetPointMatrix(self, i, pointmat): r"""GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)""" return _mesh.Mesh_GetPointMatrix(self, i, pointmat) + GetPointMatrix = _swig_new_instance_method(_mesh.Mesh_GetPointMatrix) def GetBdrPointMatrix(self, i, pointmat): r"""GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)""" return _mesh.Mesh_GetBdrPointMatrix(self, i, pointmat) + GetBdrPointMatrix = _swig_new_instance_method(_mesh.Mesh_GetBdrPointMatrix) @staticmethod def GetTransformationFEforElementType(arg1): r"""GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement""" return _mesh.Mesh_GetTransformationFEforElementType(arg1) + GetTransformationFEforElementType = _swig_new_static_method(_mesh.Mesh_GetTransformationFEforElementType) def GetElementTransformation(self, i): from mfem.ser import IsoparametricTransformation @@ -531,6 +637,7 @@ def GetBdrElementTransformation(self, i): def GetLocalFaceTransformation(self, face_type, elem_type, Transf, info): r"""GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)""" return _mesh.Mesh_GetLocalFaceTransformation(self, face_type, elem_type, Transf, info) + GetLocalFaceTransformation = _swig_new_instance_method(_mesh.Mesh_GetLocalFaceTransformation) def GetFaceTransformation(self, i): from mfem.ser import IsoparametricTransformation @@ -551,18 +658,22 @@ def GetEdgeTransformation(self, i): def GetFaceElementTransformations(self, FaceNo, mask=31): r"""GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations""" return _mesh.Mesh_GetFaceElementTransformations(self, FaceNo, mask) + GetFaceElementTransformations = _swig_new_instance_method(_mesh.Mesh_GetFaceElementTransformations) def GetInteriorFaceTransformations(self, FaceNo): r"""GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations""" return _mesh.Mesh_GetInteriorFaceTransformations(self, FaceNo) + GetInteriorFaceTransformations = _swig_new_instance_method(_mesh.Mesh_GetInteriorFaceTransformations) def GetBdrFaceTransformations(self, BdrElemNo): r"""GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations""" return _mesh.Mesh_GetBdrFaceTransformations(self, BdrElemNo) + GetBdrFaceTransformations = _swig_new_instance_method(_mesh.Mesh_GetBdrFaceTransformations) def FaceIsInterior(self, FaceNo): r"""FaceIsInterior(Mesh self, int FaceNo) -> bool""" return _mesh.Mesh_FaceIsInterior(self, FaceNo) + FaceIsInterior = _swig_new_instance_method(_mesh.Mesh_FaceIsInterior) def GetFaceElements(self, Face): from mfem.ser import intp @@ -576,118 +687,147 @@ def GetFaceElements(self, Face): def GetFaceInfos(self, Face, Inf1, Inf2): r"""GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)""" return _mesh.Mesh_GetFaceInfos(self, Face, Inf1, Inf2) + GetFaceInfos = _swig_new_instance_method(_mesh.Mesh_GetFaceInfos) def GetFaceGeometryType(self, Face): r"""GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type""" return _mesh.Mesh_GetFaceGeometryType(self, Face) + GetFaceGeometryType = _swig_new_instance_method(_mesh.Mesh_GetFaceGeometryType) def GetFaceElementType(self, Face): r"""GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type""" return _mesh.Mesh_GetFaceElementType(self, Face) + GetFaceElementType = _swig_new_instance_method(_mesh.Mesh_GetFaceElementType) def CheckElementOrientation(self, fix_it=True): r"""CheckElementOrientation(Mesh self, bool fix_it=True) -> int""" return _mesh.Mesh_CheckElementOrientation(self, fix_it) + CheckElementOrientation = _swig_new_instance_method(_mesh.Mesh_CheckElementOrientation) def CheckBdrElementOrientation(self, fix_it=True): r"""CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int""" return _mesh.Mesh_CheckBdrElementOrientation(self, fix_it) + CheckBdrElementOrientation = _swig_new_instance_method(_mesh.Mesh_CheckBdrElementOrientation) def GetAttribute(self, i): r"""GetAttribute(Mesh self, int i) -> int""" return _mesh.Mesh_GetAttribute(self, i) + GetAttribute = _swig_new_instance_method(_mesh.Mesh_GetAttribute) def SetAttribute(self, i, attr): r"""SetAttribute(Mesh self, int i, int attr)""" return _mesh.Mesh_SetAttribute(self, i, attr) + SetAttribute = _swig_new_instance_method(_mesh.Mesh_SetAttribute) def GetBdrAttribute(self, i): r"""GetBdrAttribute(Mesh self, int i) -> int""" return _mesh.Mesh_GetBdrAttribute(self, i) + GetBdrAttribute = _swig_new_instance_method(_mesh.Mesh_GetBdrAttribute) def ElementToElementTable(self): r"""ElementToElementTable(Mesh self) -> Table""" return _mesh.Mesh_ElementToElementTable(self) + ElementToElementTable = _swig_new_instance_method(_mesh.Mesh_ElementToElementTable) def ElementToFaceTable(self): r"""ElementToFaceTable(Mesh self) -> Table""" return _mesh.Mesh_ElementToFaceTable(self) + ElementToFaceTable = _swig_new_instance_method(_mesh.Mesh_ElementToFaceTable) def ElementToEdgeTable(self): r"""ElementToEdgeTable(Mesh self) -> Table""" return _mesh.Mesh_ElementToEdgeTable(self) + ElementToEdgeTable = _swig_new_instance_method(_mesh.Mesh_ElementToEdgeTable) def GetVertexToElementTable(self): r"""GetVertexToElementTable(Mesh self) -> Table""" return _mesh.Mesh_GetVertexToElementTable(self) + GetVertexToElementTable = _swig_new_instance_method(_mesh.Mesh_GetVertexToElementTable) def GetFaceToElementTable(self): r"""GetFaceToElementTable(Mesh self) -> Table""" return _mesh.Mesh_GetFaceToElementTable(self) + GetFaceToElementTable = _swig_new_instance_method(_mesh.Mesh_GetFaceToElementTable) def ReorientTetMesh(self): r"""ReorientTetMesh(Mesh self)""" return _mesh.Mesh_ReorientTetMesh(self) + ReorientTetMesh = _swig_new_instance_method(_mesh.Mesh_ReorientTetMesh) def CartesianPartitioning(self, nxyz): r"""CartesianPartitioning(Mesh self, int [] nxyz) -> int *""" return _mesh.Mesh_CartesianPartitioning(self, nxyz) + CartesianPartitioning = _swig_new_instance_method(_mesh.Mesh_CartesianPartitioning) def GeneratePartitioning(self, nparts, part_method=1): r"""GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int""" return _mesh.Mesh_GeneratePartitioning(self, nparts, part_method) + GeneratePartitioning = _swig_new_instance_method(_mesh.Mesh_GeneratePartitioning) def CheckPartitioning(self, partitioning): r"""CheckPartitioning(Mesh self, int * partitioning)""" return _mesh.Mesh_CheckPartitioning(self, partitioning) + CheckPartitioning = _swig_new_instance_method(_mesh.Mesh_CheckPartitioning) def CheckDisplacements(self, displacements, tmax): r"""CheckDisplacements(Mesh self, Vector displacements, double & tmax)""" return _mesh.Mesh_CheckDisplacements(self, displacements, tmax) + CheckDisplacements = _swig_new_instance_method(_mesh.Mesh_CheckDisplacements) def MoveVertices(self, displacements): r"""MoveVertices(Mesh self, Vector displacements)""" return _mesh.Mesh_MoveVertices(self, displacements) + MoveVertices = _swig_new_instance_method(_mesh.Mesh_MoveVertices) def GetVertices(self, vert_coord): r"""GetVertices(Mesh self, Vector vert_coord)""" return _mesh.Mesh_GetVertices(self, vert_coord) + GetVertices = _swig_new_instance_method(_mesh.Mesh_GetVertices) def SetVertices(self, vert_coord): r"""SetVertices(Mesh self, Vector vert_coord)""" return _mesh.Mesh_SetVertices(self, vert_coord) + SetVertices = _swig_new_instance_method(_mesh.Mesh_SetVertices) def GetNode(self, i, coord): r"""GetNode(Mesh self, int i, double * coord)""" return _mesh.Mesh_GetNode(self, i, coord) + GetNode = _swig_new_instance_method(_mesh.Mesh_GetNode) def SetNode(self, i, coord): r"""SetNode(Mesh self, int i, double const * coord)""" return _mesh.Mesh_SetNode(self, i, coord) + SetNode = _swig_new_instance_method(_mesh.Mesh_SetNode) def MoveNodes(self, displacements): r"""MoveNodes(Mesh self, Vector displacements)""" return _mesh.Mesh_MoveNodes(self, displacements) + MoveNodes = _swig_new_instance_method(_mesh.Mesh_MoveNodes) def SetNodes(self, node_coord): r"""SetNodes(Mesh self, Vector node_coord)""" return _mesh.Mesh_SetNodes(self, node_coord) + SetNodes = _swig_new_instance_method(_mesh.Mesh_SetNodes) def OwnsNodes(self): r"""OwnsNodes(Mesh self) -> bool""" return _mesh.Mesh_OwnsNodes(self) + OwnsNodes = _swig_new_instance_method(_mesh.Mesh_OwnsNodes) def SetNodesOwner(self, nodes_owner): r"""SetNodesOwner(Mesh self, bool nodes_owner)""" return _mesh.Mesh_SetNodesOwner(self, nodes_owner) + SetNodesOwner = _swig_new_instance_method(_mesh.Mesh_SetNodesOwner) def NewNodes(self, nodes, make_owner=False): r"""NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)""" return _mesh.Mesh_NewNodes(self, nodes, make_owner) + NewNodes = _swig_new_instance_method(_mesh.Mesh_NewNodes) def SwapNodes(self, nodes, own_nodes_): r"""SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)""" return _mesh.Mesh_SwapNodes(self, nodes, own_nodes_) + SwapNodes = _swig_new_instance_method(_mesh.Mesh_SwapNodes) def GetNodes(self, *args): r""" @@ -697,30 +837,37 @@ def GetNodes(self, *args): GetNodes(Mesh self, GridFunction nodes) """ return _mesh.Mesh_GetNodes(self, *args) + GetNodes = _swig_new_instance_method(_mesh.Mesh_GetNodes) def SetNodalFESpace(self, nfes): r"""SetNodalFESpace(Mesh self, FiniteElementSpace nfes)""" return _mesh.Mesh_SetNodalFESpace(self, nfes) + SetNodalFESpace = _swig_new_instance_method(_mesh.Mesh_SetNodalFESpace) def SetNodalGridFunction(self, nodes, make_owner=False): r"""SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)""" return _mesh.Mesh_SetNodalGridFunction(self, nodes, make_owner) + SetNodalGridFunction = _swig_new_instance_method(_mesh.Mesh_SetNodalGridFunction) def GetNodalFESpace(self): r"""GetNodalFESpace(Mesh self) -> FiniteElementSpace""" return _mesh.Mesh_GetNodalFESpace(self) + GetNodalFESpace = _swig_new_instance_method(_mesh.Mesh_GetNodalFESpace) def EnsureNodes(self): r"""EnsureNodes(Mesh self)""" return _mesh.Mesh_EnsureNodes(self) + EnsureNodes = _swig_new_instance_method(_mesh.Mesh_EnsureNodes) def SetCurvature(self, order, discont=False, space_dim=-1, ordering=1): r"""SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)""" return _mesh.Mesh_SetCurvature(self, order, discont, space_dim, ordering) + SetCurvature = _swig_new_instance_method(_mesh.Mesh_SetCurvature) def UniformRefinement(self, ref_algo=0): r"""UniformRefinement(Mesh self, int ref_algo=0)""" return _mesh.Mesh_UniformRefinement(self, ref_algo) + UniformRefinement = _swig_new_instance_method(_mesh.Mesh_UniformRefinement) def GeneralRefinement(self, *args): r""" @@ -728,14 +875,17 @@ def GeneralRefinement(self, *args): GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0) """ return _mesh.Mesh_GeneralRefinement(self, *args) + GeneralRefinement = _swig_new_instance_method(_mesh.Mesh_GeneralRefinement) def RandomRefinement(self, prob, aniso=False, nonconforming=-1, nc_limit=0): r"""RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)""" return _mesh.Mesh_RandomRefinement(self, prob, aniso, nonconforming, nc_limit) + RandomRefinement = _swig_new_instance_method(_mesh.Mesh_RandomRefinement) def RefineAtVertex(self, vert, eps=0.0, nonconforming=-1): r"""RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)""" return _mesh.Mesh_RefineAtVertex(self, vert, eps, nonconforming) + RefineAtVertex = _swig_new_instance_method(_mesh.Mesh_RefineAtVertex) def RefineByError(self, *args): r""" @@ -743,6 +893,7 @@ def RefineByError(self, *args): RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool """ return _mesh.Mesh_RefineByError(self, *args) + RefineByError = _swig_new_instance_method(_mesh.Mesh_RefineByError) def DerefineByError(self, *args): r""" @@ -750,62 +901,88 @@ def DerefineByError(self, *args): DerefineByError(Mesh self, Vector elem_error, double threshold, int nc_limit=0, int op=1) -> bool """ return _mesh.Mesh_DerefineByError(self, *args) + DerefineByError = _swig_new_instance_method(_mesh.Mesh_DerefineByError) - def KnotInsert(self, kv): - r"""KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)""" - return _mesh.Mesh_KnotInsert(self, kv) + def KnotInsert(self, *args): + r""" + KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv) + KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv) + """ + return _mesh.Mesh_KnotInsert(self, *args) + KnotInsert = _swig_new_instance_method(_mesh.Mesh_KnotInsert) def DegreeElevate(self, rel_degree, degree=16): r"""DegreeElevate(Mesh self, int rel_degree, int degree=16)""" return _mesh.Mesh_DegreeElevate(self, rel_degree, degree) + DegreeElevate = _swig_new_instance_method(_mesh.Mesh_DegreeElevate) - def EnsureNCMesh(self, triangles_nonconforming=False): - r"""EnsureNCMesh(Mesh self, bool triangles_nonconforming=False)""" - return _mesh.Mesh_EnsureNCMesh(self, triangles_nonconforming) + def EnsureNCMesh(self, simplices_nonconforming=False): + r"""EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)""" + return _mesh.Mesh_EnsureNCMesh(self, simplices_nonconforming) + EnsureNCMesh = _swig_new_instance_method(_mesh.Mesh_EnsureNCMesh) def Conforming(self): r"""Conforming(Mesh self) -> bool""" return _mesh.Mesh_Conforming(self) + Conforming = _swig_new_instance_method(_mesh.Mesh_Conforming) def Nonconforming(self): r"""Nonconforming(Mesh self) -> bool""" return _mesh.Mesh_Nonconforming(self) + Nonconforming = _swig_new_instance_method(_mesh.Mesh_Nonconforming) def GetRefinementTransforms(self): r"""GetRefinementTransforms(Mesh self) -> CoarseFineTransformations""" return _mesh.Mesh_GetRefinementTransforms(self) + GetRefinementTransforms = _swig_new_instance_method(_mesh.Mesh_GetRefinementTransforms) def GetLastOperation(self): r"""GetLastOperation(Mesh self) -> mfem::Mesh::Operation""" return _mesh.Mesh_GetLastOperation(self) + GetLastOperation = _swig_new_instance_method(_mesh.Mesh_GetLastOperation) def GetSequence(self): r"""GetSequence(Mesh self) -> long""" return _mesh.Mesh_GetSequence(self) + GetSequence = _swig_new_instance_method(_mesh.Mesh_GetSequence) + + def PrintVTU(self, *args): + r""" + PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0) + PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0) + """ + return _mesh.Mesh_PrintVTU(self, *args) + PrintVTU = _swig_new_instance_method(_mesh.Mesh_PrintVTU) def GetElementColoring(self, colors, el0=0): r"""GetElementColoring(Mesh self, intArray colors, int el0=0)""" return _mesh.Mesh_GetElementColoring(self, colors, el0) + GetElementColoring = _swig_new_instance_method(_mesh.Mesh_GetElementColoring) def PrintWithPartitioning(self, partitioning, out, elem_attr=0): r"""PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)""" return _mesh.Mesh_PrintWithPartitioning(self, partitioning, out, elem_attr) + PrintWithPartitioning = _swig_new_instance_method(_mesh.Mesh_PrintWithPartitioning) def PrintElementsWithPartitioning(self, partitioning, out, interior_faces=0): r"""PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)""" return _mesh.Mesh_PrintElementsWithPartitioning(self, partitioning, out, interior_faces) + PrintElementsWithPartitioning = _swig_new_instance_method(_mesh.Mesh_PrintElementsWithPartitioning) def PrintSurfaces(self, Aface_face, out): r"""PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)""" return _mesh.Mesh_PrintSurfaces(self, Aface_face, out) + PrintSurfaces = _swig_new_instance_method(_mesh.Mesh_PrintSurfaces) def ScaleSubdomains(self, sf): r"""ScaleSubdomains(Mesh self, double sf)""" return _mesh.Mesh_ScaleSubdomains(self, sf) + ScaleSubdomains = _swig_new_instance_method(_mesh.Mesh_ScaleSubdomains) def ScaleElements(self, sf): r"""ScaleElements(Mesh self, double sf)""" return _mesh.Mesh_ScaleElements(self, sf) + ScaleElements = _swig_new_instance_method(_mesh.Mesh_ScaleElements) def Transform(self, *args): r""" @@ -813,14 +990,17 @@ def Transform(self, *args): Transform(Mesh self, VectorCoefficient deformation) """ return _mesh.Mesh_Transform(self, *args) + Transform = _swig_new_instance_method(_mesh.Mesh_Transform) def RemoveUnusedVertices(self): r"""RemoveUnusedVertices(Mesh self)""" return _mesh.Mesh_RemoveUnusedVertices(self) + RemoveUnusedVertices = _swig_new_instance_method(_mesh.Mesh_RemoveUnusedVertices) def RemoveInternalBoundaries(self): r"""RemoveInternalBoundaries(Mesh self)""" return _mesh.Mesh_RemoveInternalBoundaries(self) + RemoveInternalBoundaries = _swig_new_instance_method(_mesh.Mesh_RemoveInternalBoundaries) def GetElementSize(self, *args): r""" @@ -828,10 +1008,12 @@ def GetElementSize(self, *args): GetElementSize(Mesh self, int i, Vector dir) -> double """ return _mesh.Mesh_GetElementSize(self, *args) + GetElementSize = _swig_new_instance_method(_mesh.Mesh_GetElementSize) def GetElementVolume(self, i): r"""GetElementVolume(Mesh self, int i) -> double""" return _mesh.Mesh_GetElementVolume(self, i) + GetElementVolume = _swig_new_instance_method(_mesh.Mesh_GetElementVolume) def GetBoundingBox(self, ref = 2): from .vector import Vector @@ -845,19 +1027,23 @@ def GetBoundingBox(self, ref = 2): def GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max, Vh=None, Vk=None): r"""GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)""" return _mesh.Mesh_GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max, Vh, Vk) + GetCharacteristics = _swig_new_instance_method(_mesh.Mesh_GetCharacteristics) @staticmethod def PrintElementsByGeometry(dim, num_elems_by_geom, out): r"""PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)""" return _mesh.Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out) + PrintElementsByGeometry = _swig_new_static_method(_mesh.Mesh_PrintElementsByGeometry) def PrintCharacteristics(self, *args): r"""PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)""" return _mesh.Mesh_PrintCharacteristics(self, *args) + PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) def FindPoints(self, point_mat, elem_ids, ips, warn=True, inv_trans=None): r"""FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int""" return _mesh.Mesh_FindPoints(self, point_mat, elem_ids, ips, warn, inv_trans) + FindPoints = _swig_new_instance_method(_mesh.Mesh_FindPoints) __swig_destroy__ = _mesh.delete_Mesh def __init__(self, *args): @@ -881,14 +1067,17 @@ def __init__(self, *args): def PrintToFile(self, mesh_file, precision): r"""PrintToFile(Mesh self, char const * mesh_file, int const precision)""" return _mesh.Mesh_PrintToFile(self, mesh_file, precision) + PrintToFile = _swig_new_instance_method(_mesh.Mesh_PrintToFile) def GetAttributeArray(self): r"""GetAttributeArray(Mesh self) -> PyObject *""" return _mesh.Mesh_GetAttributeArray(self) + GetAttributeArray = _swig_new_instance_method(_mesh.Mesh_GetAttributeArray) def GetVertexArray(self, i): r"""GetVertexArray(Mesh self, int i) -> PyObject *""" return _mesh.Mesh_GetVertexArray(self, i) + GetVertexArray = _swig_new_instance_method(_mesh.Mesh_GetVertexArray) def GetBdrElementFace(self, *args): r""" @@ -896,18 +1085,22 @@ def GetBdrElementFace(self, *args): GetBdrElementFace(Mesh self, int i) -> PyObject * """ return _mesh.Mesh_GetBdrElementFace(self, *args) + GetBdrElementFace = _swig_new_instance_method(_mesh.Mesh_GetBdrElementFace) def GetBdrAttributeArray(self): r"""GetBdrAttributeArray(Mesh self) -> PyObject *""" return _mesh.Mesh_GetBdrAttributeArray(self) + GetBdrAttributeArray = _swig_new_instance_method(_mesh.Mesh_GetBdrAttributeArray) def GetBdrArray(self, idx): r"""GetBdrArray(Mesh self, int idx) -> PyObject *""" return _mesh.Mesh_GetBdrArray(self, idx) + GetBdrArray = _swig_new_instance_method(_mesh.Mesh_GetBdrArray) def GetDomainArray(self, idx): r"""GetDomainArray(Mesh self, int idx) -> PyObject *""" return _mesh.Mesh_GetDomainArray(self, idx) + GetDomainArray = _swig_new_instance_method(_mesh.Mesh_GetDomainArray) def PrintInfo(self, *args): r""" @@ -915,6 +1108,7 @@ def PrintInfo(self, *args): PrintInfo(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_PrintInfo(self, *args) + PrintInfo = _swig_new_instance_method(_mesh.Mesh_PrintInfo) def Print(self, *args): r""" @@ -922,6 +1116,7 @@ def Print(self, *args): Print(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_Print(self, *args) + Print = _swig_new_instance_method(_mesh.Mesh_Print) def PrintXG(self, *args): r""" @@ -929,6 +1124,7 @@ def PrintXG(self, *args): PrintXG(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_PrintXG(self, *args) + PrintXG = _swig_new_instance_method(_mesh.Mesh_PrintXG) def PrintVTK(self, *args): r""" @@ -937,6 +1133,7 @@ def PrintVTK(self, *args): PrintVTK(Mesh self, char const * file, int precision=8) """ return _mesh.Mesh_PrintVTK(self, *args) + PrintVTK = _swig_new_instance_method(_mesh.Mesh_PrintVTK) # Register Mesh in _mesh: _mesh.Mesh_swigregister(Mesh) @@ -945,10 +1142,12 @@ def PrintVTK(self, *args): def Mesh_GetTransformationFEforElementType(arg1): r"""Mesh_GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement""" return _mesh.Mesh_GetTransformationFEforElementType(arg1) +Mesh_GetTransformationFEforElementType = _mesh.Mesh_GetTransformationFEforElementType def Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out): r"""Mesh_PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)""" return _mesh.Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out) +Mesh_PrintElementsByGeometry = _mesh.Mesh_PrintElementsByGeometry def __lshift__(*args): @@ -958,6 +1157,7 @@ def __lshift__(*args): __lshift__(std::ostream & out, Mesh mesh) -> std::ostream & """ return _mesh.__lshift__(*args) +__lshift__ = _mesh.__lshift__ class GeometricFactors(object): r"""Proxy of C++ mfem::GeometricFactors class.""" @@ -984,6 +1184,36 @@ def __init__(self, mesh, ir, flags): # Register GeometricFactors in _mesh: _mesh.GeometricFactors_swigregister(GeometricFactors) +class FaceGeometricFactors(object): + r"""Proxy of C++ mfem::FaceGeometricFactors class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + mesh = property(_mesh.FaceGeometricFactors_mesh_get, _mesh.FaceGeometricFactors_mesh_set, doc=r"""mesh : p.q(const).mfem::Mesh""") + IntRule = property(_mesh.FaceGeometricFactors_IntRule_get, _mesh.FaceGeometricFactors_IntRule_set, doc=r"""IntRule : p.q(const).mfem::IntegrationRule""") + computed_factors = property(_mesh.FaceGeometricFactors_computed_factors_get, _mesh.FaceGeometricFactors_computed_factors_set, doc=r"""computed_factors : int""") + type = property(_mesh.FaceGeometricFactors_type_get, _mesh.FaceGeometricFactors_type_set, doc=r"""type : mfem::FaceType""") + COORDINATES = _mesh.FaceGeometricFactors_COORDINATES + + JACOBIANS = _mesh.FaceGeometricFactors_JACOBIANS + + DETERMINANTS = _mesh.FaceGeometricFactors_DETERMINANTS + + NORMALS = _mesh.FaceGeometricFactors_NORMALS + + + def __init__(self, mesh, ir, flags, type): + r"""__init__(FaceGeometricFactors self, Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors""" + _mesh.FaceGeometricFactors_swiginit(self, _mesh.new_FaceGeometricFactors(mesh, ir, flags, type)) + X = property(_mesh.FaceGeometricFactors_X_get, _mesh.FaceGeometricFactors_X_set, doc=r"""X : mfem::Vector""") + J = property(_mesh.FaceGeometricFactors_J_get, _mesh.FaceGeometricFactors_J_set, doc=r"""J : mfem::Vector""") + detJ = property(_mesh.FaceGeometricFactors_detJ_get, _mesh.FaceGeometricFactors_detJ_set, doc=r"""detJ : mfem::Vector""") + normal = property(_mesh.FaceGeometricFactors_normal_get, _mesh.FaceGeometricFactors_normal_set, doc=r"""normal : mfem::Vector""") + __swig_destroy__ = _mesh.delete_FaceGeometricFactors + +# Register FaceGeometricFactors in _mesh: +_mesh.FaceGeometricFactors_swigregister(FaceGeometricFactors) + class NodeExtrudeCoefficient(mfem._ser.coefficient.VectorCoefficient): r"""Proxy of C++ mfem::NodeExtrudeCoefficient class.""" @@ -996,6 +1226,7 @@ def __init__(self, *args, **kwargs): def SetLayer(self, l): r"""SetLayer(NodeExtrudeCoefficient self, int const l)""" return _mesh.NodeExtrudeCoefficient_SetLayer(self, l) + SetLayer = _swig_new_instance_method(_mesh.NodeExtrudeCoefficient_SetLayer) def Eval(self, *args): r""" @@ -1004,6 +1235,7 @@ def Eval(self, *args): Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip) """ return _mesh.NodeExtrudeCoefficient_Eval(self, *args) + Eval = _swig_new_instance_method(_mesh.NodeExtrudeCoefficient_Eval) __swig_destroy__ = _mesh.delete_NodeExtrudeCoefficient # Register NodeExtrudeCoefficient in _mesh: @@ -1013,24 +1245,16 @@ def Eval(self, *args): def Extrude1D(mesh, ny, sy, closed=False): r"""Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh""" return _mesh.Extrude1D(mesh, ny, sy, closed) +Extrude1D = _mesh.Extrude1D def Extrude2D(mesh, nz, sz): r"""Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh""" return _mesh.Extrude2D(mesh, nz, sz) -class named_ifgzstream(object): - r"""Proxy of C++ mfem::named_ifgzstream class.""" - - thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") - __repr__ = _swig_repr - filename = property(_mesh.named_ifgzstream_filename_get, _mesh.named_ifgzstream_filename_set, doc=r"""filename : p.q(const).char""") - - def __init__(self, mesh_name): - r"""__init__(named_ifgzstream self, char const * mesh_name) -> named_ifgzstream""" - _mesh.named_ifgzstream_swiginit(self, _mesh.new_named_ifgzstream(mesh_name)) - __swig_destroy__ = _mesh.delete_named_ifgzstream - -# Register named_ifgzstream in _mesh: -_mesh.named_ifgzstream_swigregister(named_ifgzstream) +Extrude2D = _mesh.Extrude2D +def ShiftRight(a, b, c): + r"""ShiftRight(int & a, int & b, int & c)""" + return _mesh.ShiftRight(a, b, c) +ShiftRight = _mesh.ShiftRight diff --git a/mfem/_ser/mesh_operators.py b/mfem/_ser/mesh_operators.py index 8a37816a..19989790 100644 --- a/mfem/_ser/mesh_operators.py +++ b/mfem/_ser/mesh_operators.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _mesh_operators.SWIG_PyInstanceMethod_New +_swig_new_static_method = _mesh_operators.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,12 +85,14 @@ class _SwigNonDynamicMeta(type): import mfem._ser.fe_coll import mfem._ser.lininteg import mfem._ser.handle -import mfem._ser.bilininteg -import mfem._ser.linearform +import mfem._ser.restriction import mfem._ser.element import mfem._ser.table import mfem._ser.hash +import mfem._ser.bilininteg +import mfem._ser.linearform import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.estimators import mfem._ser.bilinearform class MeshOperator(object): @@ -122,38 +127,47 @@ def __init__(self, *args, **kwargs): def Apply(self, mesh): r"""Apply(MeshOperator self, Mesh mesh) -> bool""" return _mesh_operators.MeshOperator_Apply(self, mesh) + Apply = _swig_new_instance_method(_mesh_operators.MeshOperator_Apply) def Stop(self): r"""Stop(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Stop(self) + Stop = _swig_new_instance_method(_mesh_operators.MeshOperator_Stop) def Repeat(self): r"""Repeat(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Repeat(self) + Repeat = _swig_new_instance_method(_mesh_operators.MeshOperator_Repeat) def Continue(self): r"""Continue(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Continue(self) + Continue = _swig_new_instance_method(_mesh_operators.MeshOperator_Continue) def Refined(self): r"""Refined(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Refined(self) + Refined = _swig_new_instance_method(_mesh_operators.MeshOperator_Refined) def Derefined(self): r"""Derefined(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Derefined(self) + Derefined = _swig_new_instance_method(_mesh_operators.MeshOperator_Derefined) def Rebalanced(self): r"""Rebalanced(MeshOperator self) -> bool""" return _mesh_operators.MeshOperator_Rebalanced(self) + Rebalanced = _swig_new_instance_method(_mesh_operators.MeshOperator_Rebalanced) def GetActionInfo(self): r"""GetActionInfo(MeshOperator self) -> int""" return _mesh_operators.MeshOperator_GetActionInfo(self) + GetActionInfo = _swig_new_instance_method(_mesh_operators.MeshOperator_GetActionInfo) def Reset(self): r"""Reset(MeshOperator self)""" return _mesh_operators.MeshOperator_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.MeshOperator_Reset) __swig_destroy__ = _mesh_operators.delete_MeshOperator # Register MeshOperator in _mesh_operators: @@ -173,14 +187,17 @@ def __init__(self): def Append(self, mc): r"""Append(MeshOperatorSequence self, MeshOperator mc)""" return _mesh_operators.MeshOperatorSequence_Append(self, mc) + Append = _swig_new_instance_method(_mesh_operators.MeshOperatorSequence_Append) def GetSequence(self): r"""GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &""" return _mesh_operators.MeshOperatorSequence_GetSequence(self) + GetSequence = _swig_new_instance_method(_mesh_operators.MeshOperatorSequence_GetSequence) def Reset(self): r"""Reset(MeshOperatorSequence self)""" return _mesh_operators.MeshOperatorSequence_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.MeshOperatorSequence_Reset) # Register MeshOperatorSequence in _mesh_operators: _mesh_operators.MeshOperatorSequence_swigregister(MeshOperatorSequence) @@ -198,46 +215,57 @@ def __init__(self, est): def SetTotalErrorNormP(self, *args): r"""SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())""" return _mesh_operators.ThresholdRefiner_SetTotalErrorNormP(self, *args) + SetTotalErrorNormP = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorNormP) def SetTotalErrorGoal(self, err_goal): r"""SetTotalErrorGoal(ThresholdRefiner self, double err_goal)""" return _mesh_operators.ThresholdRefiner_SetTotalErrorGoal(self, err_goal) + SetTotalErrorGoal = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorGoal) def SetTotalErrorFraction(self, fraction): r"""SetTotalErrorFraction(ThresholdRefiner self, double fraction)""" return _mesh_operators.ThresholdRefiner_SetTotalErrorFraction(self, fraction) + SetTotalErrorFraction = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorFraction) def SetLocalErrorGoal(self, err_goal): r"""SetLocalErrorGoal(ThresholdRefiner self, double err_goal)""" return _mesh_operators.ThresholdRefiner_SetLocalErrorGoal(self, err_goal) + SetLocalErrorGoal = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetLocalErrorGoal) def SetMaxElements(self, max_elem): r"""SetMaxElements(ThresholdRefiner self, long max_elem)""" return _mesh_operators.ThresholdRefiner_SetMaxElements(self, max_elem) + SetMaxElements = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetMaxElements) def PreferNonconformingRefinement(self): r"""PreferNonconformingRefinement(ThresholdRefiner self)""" return _mesh_operators.ThresholdRefiner_PreferNonconformingRefinement(self) + PreferNonconformingRefinement = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_PreferNonconformingRefinement) def PreferConformingRefinement(self): r"""PreferConformingRefinement(ThresholdRefiner self)""" return _mesh_operators.ThresholdRefiner_PreferConformingRefinement(self) + PreferConformingRefinement = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_PreferConformingRefinement) def SetNCLimit(self, nc_limit): r"""SetNCLimit(ThresholdRefiner self, int nc_limit)""" return _mesh_operators.ThresholdRefiner_SetNCLimit(self, nc_limit) + SetNCLimit = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetNCLimit) def GetNumMarkedElements(self): r"""GetNumMarkedElements(ThresholdRefiner self) -> long""" return _mesh_operators.ThresholdRefiner_GetNumMarkedElements(self) + GetNumMarkedElements = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_GetNumMarkedElements) def GetThreshold(self): r"""GetThreshold(ThresholdRefiner self) -> double""" return _mesh_operators.ThresholdRefiner_GetThreshold(self) + GetThreshold = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_GetThreshold) def Reset(self): r"""Reset(ThresholdRefiner self)""" return _mesh_operators.ThresholdRefiner_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_Reset) __swig_destroy__ = _mesh_operators.delete_ThresholdRefiner # Register ThresholdRefiner in _mesh_operators: @@ -256,18 +284,22 @@ def __init__(self, est): def SetThreshold(self, thresh): r"""SetThreshold(ThresholdDerefiner self, double thresh)""" return _mesh_operators.ThresholdDerefiner_SetThreshold(self, thresh) + SetThreshold = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_SetThreshold) def SetOp(self, op): r"""SetOp(ThresholdDerefiner self, int op)""" return _mesh_operators.ThresholdDerefiner_SetOp(self, op) + SetOp = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_SetOp) def SetNCLimit(self, nc_limit): r"""SetNCLimit(ThresholdDerefiner self, int nc_limit)""" return _mesh_operators.ThresholdDerefiner_SetNCLimit(self, nc_limit) + SetNCLimit = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_SetNCLimit) def Reset(self): r"""Reset(ThresholdDerefiner self)""" return _mesh_operators.ThresholdDerefiner_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.ThresholdDerefiner_Reset) __swig_destroy__ = _mesh_operators.delete_ThresholdDerefiner # Register ThresholdDerefiner in _mesh_operators: @@ -282,6 +314,7 @@ class Rebalancer(MeshOperator): def Reset(self): r"""Reset(Rebalancer self)""" return _mesh_operators.Rebalancer_Reset(self) + Reset = _swig_new_instance_method(_mesh_operators.Rebalancer_Reset) def __init__(self): r"""__init__(Rebalancer self) -> Rebalancer""" diff --git a/mfem/_ser/mesh_operators_wrap.cxx b/mfem/_ser/mesh_operators_wrap.cxx index 86aebdda..5c23ef6e 100644 --- a/mfem/_ser/mesh_operators_wrap.cxx +++ b/mfem/_ser/mesh_operators_wrap.cxx @@ -3066,31 +3066,32 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_mfem__MeshOperator_p_t swig_types[6] -#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[7] -#define SWIGTYPE_p_mfem__GridFunction swig_types[8] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[9] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[10] -#define SWIGTYPE_p_mfem__Mesh swig_types[11] -#define SWIGTYPE_p_mfem__MeshOperator swig_types[12] -#define SWIGTYPE_p_mfem__MeshOperatorSequence swig_types[13] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[14] -#define SWIGTYPE_p_mfem__Rebalancer swig_types[15] -#define SWIGTYPE_p_mfem__ThresholdDerefiner swig_types[16] -#define SWIGTYPE_p_mfem__ThresholdRefiner swig_types[17] -#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[18] -#define SWIGTYPE_p_pri_t swig_types[19] -#define SWIGTYPE_p_quad_t swig_types[20] -#define SWIGTYPE_p_seg_t swig_types[21] -#define SWIGTYPE_p_tet_t swig_types[22] -#define SWIGTYPE_p_tri_t swig_types[23] -static swig_type_info *swig_types[25]; -static swig_module_info swig_module = {swig_types, 24, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__AnisotropicErrorEstimator swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_mfem__MeshOperator_p_t swig_types[7] +#define SWIGTYPE_p_mfem__ErrorEstimator swig_types[8] +#define SWIGTYPE_p_mfem__GridFunction swig_types[9] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[10] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[11] +#define SWIGTYPE_p_mfem__Mesh swig_types[12] +#define SWIGTYPE_p_mfem__MeshOperator swig_types[13] +#define SWIGTYPE_p_mfem__MeshOperatorSequence swig_types[14] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[15] +#define SWIGTYPE_p_mfem__Rebalancer swig_types[16] +#define SWIGTYPE_p_mfem__ThresholdDerefiner swig_types[17] +#define SWIGTYPE_p_mfem__ThresholdRefiner swig_types[18] +#define SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator swig_types[19] +#define SWIGTYPE_p_pri_t swig_types[20] +#define SWIGTYPE_p_quad_t swig_types[21] +#define SWIGTYPE_p_seg_t swig_types[22] +#define SWIGTYPE_p_tet_t swig_types[23] +#define SWIGTYPE_p_tri_t swig_types[24] +static swig_type_info *swig_types[26]; +static swig_module_info swig_module = {swig_types, 25, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5066,6 +5067,7 @@ SWIGINTERN PyObject *Rebalancer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "MeshOperator_Apply(MeshOperator self, Mesh mesh) -> bool"}, { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "MeshOperator_Stop(MeshOperator self) -> bool"}, { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "MeshOperator_Repeat(MeshOperator self) -> bool"}, @@ -5116,6 +5118,54 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "Apply(MeshOperator self, Mesh mesh) -> bool"}, + { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "Stop(MeshOperator self) -> bool"}, + { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "Repeat(MeshOperator self) -> bool"}, + { "MeshOperator_Continue", _wrap_MeshOperator_Continue, METH_O, "Continue(MeshOperator self) -> bool"}, + { "MeshOperator_Refined", _wrap_MeshOperator_Refined, METH_O, "Refined(MeshOperator self) -> bool"}, + { "MeshOperator_Derefined", _wrap_MeshOperator_Derefined, METH_O, "Derefined(MeshOperator self) -> bool"}, + { "MeshOperator_Rebalanced", _wrap_MeshOperator_Rebalanced, METH_O, "Rebalanced(MeshOperator self) -> bool"}, + { "MeshOperator_GetActionInfo", _wrap_MeshOperator_GetActionInfo, METH_O, "GetActionInfo(MeshOperator self) -> int"}, + { "MeshOperator_Reset", _wrap_MeshOperator_Reset, METH_O, "Reset(MeshOperator self)"}, + { "delete_MeshOperator", _wrap_delete_MeshOperator, METH_O, "delete_MeshOperator(MeshOperator self)"}, + { "MeshOperator_swigregister", MeshOperator_swigregister, METH_O, NULL}, + { "new_MeshOperatorSequence", _wrap_new_MeshOperatorSequence, METH_VARARGS, NULL}, + { "delete_MeshOperatorSequence", _wrap_delete_MeshOperatorSequence, METH_O, "delete_MeshOperatorSequence(MeshOperatorSequence self)"}, + { "MeshOperatorSequence_Append", _wrap_MeshOperatorSequence_Append, METH_VARARGS, "Append(MeshOperatorSequence self, MeshOperator mc)"}, + { "MeshOperatorSequence_GetSequence", _wrap_MeshOperatorSequence_GetSequence, METH_O, "GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &"}, + { "MeshOperatorSequence_Reset", _wrap_MeshOperatorSequence_Reset, METH_O, "Reset(MeshOperatorSequence self)"}, + { "MeshOperatorSequence_swigregister", MeshOperatorSequence_swigregister, METH_O, NULL}, + { "MeshOperatorSequence_swiginit", MeshOperatorSequence_swiginit, METH_VARARGS, NULL}, + { "new_ThresholdRefiner", _wrap_new_ThresholdRefiner, METH_O, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, + { "ThresholdRefiner_SetTotalErrorNormP", _wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS, "SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, + { "ThresholdRefiner_SetTotalErrorGoal", _wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS, "SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetTotalErrorFraction", _wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS, "SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, + { "ThresholdRefiner_SetLocalErrorGoal", _wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS, "SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetMaxElements", _wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS, "SetMaxElements(ThresholdRefiner self, long max_elem)"}, + { "ThresholdRefiner_PreferNonconformingRefinement", _wrap_ThresholdRefiner_PreferNonconformingRefinement, METH_O, "PreferNonconformingRefinement(ThresholdRefiner self)"}, + { "ThresholdRefiner_PreferConformingRefinement", _wrap_ThresholdRefiner_PreferConformingRefinement, METH_O, "PreferConformingRefinement(ThresholdRefiner self)"}, + { "ThresholdRefiner_SetNCLimit", _wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdRefiner self, int nc_limit)"}, + { "ThresholdRefiner_GetNumMarkedElements", _wrap_ThresholdRefiner_GetNumMarkedElements, METH_O, "GetNumMarkedElements(ThresholdRefiner self) -> long"}, + { "ThresholdRefiner_GetThreshold", _wrap_ThresholdRefiner_GetThreshold, METH_O, "GetThreshold(ThresholdRefiner self) -> double"}, + { "ThresholdRefiner_Reset", _wrap_ThresholdRefiner_Reset, METH_O, "Reset(ThresholdRefiner self)"}, + { "delete_ThresholdRefiner", _wrap_delete_ThresholdRefiner, METH_O, "delete_ThresholdRefiner(ThresholdRefiner self)"}, + { "ThresholdRefiner_swigregister", ThresholdRefiner_swigregister, METH_O, NULL}, + { "ThresholdRefiner_swiginit", ThresholdRefiner_swiginit, METH_VARARGS, NULL}, + { "new_ThresholdDerefiner", _wrap_new_ThresholdDerefiner, METH_O, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, + { "ThresholdDerefiner_SetThreshold", _wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS, "SetThreshold(ThresholdDerefiner self, double thresh)"}, + { "ThresholdDerefiner_SetOp", _wrap_ThresholdDerefiner_SetOp, METH_VARARGS, "SetOp(ThresholdDerefiner self, int op)"}, + { "ThresholdDerefiner_SetNCLimit", _wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, + { "ThresholdDerefiner_Reset", _wrap_ThresholdDerefiner_Reset, METH_O, "Reset(ThresholdDerefiner self)"}, + { "delete_ThresholdDerefiner", _wrap_delete_ThresholdDerefiner, METH_O, "delete_ThresholdDerefiner(ThresholdDerefiner self)"}, + { "ThresholdDerefiner_swigregister", ThresholdDerefiner_swigregister, METH_O, NULL}, + { "ThresholdDerefiner_swiginit", ThresholdDerefiner_swiginit, METH_VARARGS, NULL}, + { "Rebalancer_Reset", _wrap_Rebalancer_Reset, METH_O, "Reset(Rebalancer self)"}, + { "new_Rebalancer", _wrap_new_Rebalancer, METH_NOARGS, "new_Rebalancer() -> Rebalancer"}, + { "delete_Rebalancer", _wrap_delete_Rebalancer, METH_O, "delete_Rebalancer(Rebalancer self)"}, + { "Rebalancer_swigregister", Rebalancer_swigregister, METH_O, NULL}, + { "Rebalancer_swiginit", Rebalancer_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5141,6 +5191,7 @@ static void *_p_mfem__RebalancerTo_p_mfem__MeshOperator(void *x, int *SWIGUNUSED return (void *)((mfem::MeshOperator *) ((mfem::Rebalancer *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -5167,6 +5218,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, @@ -5193,6 +5245,7 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -5219,6 +5272,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, diff --git a/mfem/_ser/mesh_wrap.cxx b/mfem/_ser/mesh_wrap.cxx index fdbbfaca..e68eabd6 100644 --- a/mfem/_ser/mesh_wrap.cxx +++ b/mfem/_ser/mesh_wrap.cxx @@ -3066,169 +3066,175 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_double swig_types[2] -#define SWIGTYPE_p_doublep swig_types[3] -#define SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void swig_types[4] -#define SWIGTYPE_p_hex_t swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_intp swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[9] -#define SWIGTYPE_p_mfem__ArrayT_mfem__GeometricFactors_p_t swig_types[10] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[11] -#define SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t swig_types[12] -#define SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t swig_types[13] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[14] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[15] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[16] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[17] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[18] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[22] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[23] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[24] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[25] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[26] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[27] -#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[28] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[29] -#define SWIGTYPE_p_mfem__Element swig_types[30] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[31] -#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[32] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[33] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[34] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[35] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[36] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[37] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[38] -#define SWIGTYPE_p_mfem__GeometricFactors swig_types[39] -#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[40] -#define SWIGTYPE_p_mfem__GridFunction swig_types[41] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[42] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[43] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[44] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[45] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[46] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[47] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[48] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[49] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[50] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[51] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[52] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[53] -#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[54] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[55] -#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[56] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[57] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[59] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[60] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[62] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[63] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[64] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[65] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[66] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[67] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[68] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[69] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[70] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__LinearForm swig_types[76] -#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[77] -#define SWIGTYPE_p_mfem__Mesh swig_types[78] -#define SWIGTYPE_p_mfem__NCMesh swig_types[79] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[80] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[81] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[82] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[83] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[84] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__NURBSExtension swig_types[88] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[91] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[92] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[94] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[95] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[103] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[107] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[108] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[109] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[110] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[111] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[113] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[114] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[118] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[119] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[123] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[124] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[125] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[126] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[127] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[128] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[129] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[130] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[131] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[132] -#define SWIGTYPE_p_mfem__STable swig_types[133] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[134] -#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[135] -#define SWIGTYPE_p_mfem__Table swig_types[136] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[137] -#define SWIGTYPE_p_mfem__Vector swig_types[138] -#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[139] -#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[140] -#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[141] -#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[142] -#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[143] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[144] -#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[145] -#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[146] -#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[147] -#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[148] -#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[149] -#define SWIGTYPE_p_mfem__Vertex swig_types[150] -#define SWIGTYPE_p_mfem__named_ifgzstream swig_types[151] -#define SWIGTYPE_p_p_mfem__Element swig_types[152] -#define SWIGTYPE_p_p_mfem__GridFunction swig_types[153] -#define SWIGTYPE_p_p_mfem__Mesh swig_types[154] -#define SWIGTYPE_p_pri_t swig_types[155] -#define SWIGTYPE_p_quad_t swig_types[156] -#define SWIGTYPE_p_seg_t swig_types[157] -#define SWIGTYPE_p_std__istream swig_types[158] -#define SWIGTYPE_p_std__ostream swig_types[159] -#define SWIGTYPE_p_tet_t swig_types[160] -#define SWIGTYPE_p_tri_t swig_types[161] -static swig_type_info *swig_types[163]; -static swig_module_info swig_module = {swig_types, 162, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_double swig_types[3] +#define SWIGTYPE_p_doublep swig_types[4] +#define SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void swig_types[5] +#define SWIGTYPE_p_hex_t swig_types[6] +#define SWIGTYPE_p_int swig_types[7] +#define SWIGTYPE_p_intp swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_double_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[10] +#define SWIGTYPE_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t swig_types[11] +#define SWIGTYPE_p_mfem__ArrayT_mfem__GeometricFactors_p_t swig_types[12] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[13] +#define SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t swig_types[14] +#define SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t swig_types[15] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[16] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t swig_types[17] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[18] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[19] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[24] +#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[25] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[26] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[27] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[28] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[29] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[30] +#define SWIGTYPE_p_mfem__CurlGridFunctionCoefficient swig_types[31] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[32] +#define SWIGTYPE_p_mfem__Element swig_types[33] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[34] +#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[35] +#define SWIGTYPE_p_mfem__FaceGeometricFactors swig_types[36] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[37] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[38] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[39] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[40] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[41] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[42] +#define SWIGTYPE_p_mfem__GeometricFactors swig_types[43] +#define SWIGTYPE_p_mfem__GradientGridFunctionCoefficient swig_types[44] +#define SWIGTYPE_p_mfem__GridFunction swig_types[45] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[46] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[47] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[48] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[49] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[50] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[51] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[52] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[53] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[54] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[55] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[56] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[57] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[58] +#define SWIGTYPE_p_mfem__IntegrationPoint swig_types[59] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[60] +#define SWIGTYPE_p_mfem__InverseElementTransformation swig_types[61] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[62] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[63] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[64] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[65] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[66] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[67] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[68] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[69] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[70] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[71] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[72] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[73] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[74] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[75] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[79] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[80] +#define SWIGTYPE_p_mfem__LinearForm swig_types[81] +#define SWIGTYPE_p_mfem__MatVecCoefficient swig_types[82] +#define SWIGTYPE_p_mfem__Mesh swig_types[83] +#define SWIGTYPE_p_mfem__NCMesh swig_types[84] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[85] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[86] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[87] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[88] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[89] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[91] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__NURBSExtension swig_types[93] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[94] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[95] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__NodeExtrudeCoefficient swig_types[99] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[100] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[106] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[110] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[111] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[112] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[117] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[118] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[125] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[126] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[127] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[128] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[129] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[130] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[131] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[132] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[133] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[134] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[135] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[136] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[137] +#define SWIGTYPE_p_mfem__STable swig_types[138] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[139] +#define SWIGTYPE_p_mfem__ScalarVectorProductCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__Table swig_types[141] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[142] +#define SWIGTYPE_p_mfem__Vector swig_types[143] +#define SWIGTYPE_p_mfem__VectorArrayCoefficient swig_types[144] +#define SWIGTYPE_p_mfem__VectorCoefficient swig_types[145] +#define SWIGTYPE_p_mfem__VectorConstantCoefficient swig_types[146] +#define SWIGTYPE_p_mfem__VectorCrossProductCoefficient swig_types[147] +#define SWIGTYPE_p_mfem__VectorDeltaCoefficient swig_types[148] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[149] +#define SWIGTYPE_p_mfem__VectorFunctionCoefficient swig_types[150] +#define SWIGTYPE_p_mfem__VectorGridFunctionCoefficient swig_types[151] +#define SWIGTYPE_p_mfem__VectorPyCoefficientBase swig_types[152] +#define SWIGTYPE_p_mfem__VectorRestrictedCoefficient swig_types[153] +#define SWIGTYPE_p_mfem__VectorSumCoefficient swig_types[154] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[155] +#define SWIGTYPE_p_mfem__Vertex swig_types[156] +#define SWIGTYPE_p_p_mfem__Element swig_types[157] +#define SWIGTYPE_p_p_mfem__GridFunction swig_types[158] +#define SWIGTYPE_p_p_mfem__Mesh swig_types[159] +#define SWIGTYPE_p_pri_t swig_types[160] +#define SWIGTYPE_p_quad_t swig_types[161] +#define SWIGTYPE_p_seg_t swig_types[162] +#define SWIGTYPE_p_std__istream swig_types[163] +#define SWIGTYPE_p_std__ostream swig_types[164] +#define SWIGTYPE_p_std__string swig_types[165] +#define SWIGTYPE_p_tet_t swig_types[166] +#define SWIGTYPE_p_tri_t swig_types[167] +static swig_type_info *swig_types[169]; +static swig_module_info swig_module = {swig_types, 168, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3904,38 +3910,6 @@ SWIGINTERN void mfem_Mesh_PrintVTK__SWIG_3(mfem::Mesh *self,char const *file,int ofile.close(); } -SWIGINTERNINLINE PyObject * -SWIG_FromCharPtrAndSize(const char* carray, size_t size) -{ - if (carray) { - if (size > INT_MAX) { - swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); - return pchar_descriptor ? - SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); - } else { -#if PY_VERSION_HEX >= 0x03000000 -#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) - return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#else - return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); -#endif -#else - return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); -#endif - } - } else { - return SWIG_Py_Void(); - } -} - - -SWIGINTERNINLINE PyObject * -SWIG_FromCharPtr(const char *cptr) -{ - return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); -} - - /* --------------------------------------------------- * C++ director class methods @@ -4436,6 +4410,58 @@ SWIGINTERN PyObject *_wrap_Mesh_geom_factors_get(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_Mesh_face_geom_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Array< mfem::FaceGeometricFactors * > *arg2 = (mfem::Array< mfem::FaceGeometricFactors * > *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_face_geom_factors_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_face_geom_factors_set" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_face_geom_factors_set" "', argument " "2"" of type '" "mfem::Array< mfem::FaceGeometricFactors * > *""'"); + } + arg2 = reinterpret_cast< mfem::Array< mfem::FaceGeometricFactors * > * >(argp2); + if (arg1) (arg1)->face_geom_factors = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_face_geom_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::FaceGeometricFactors * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_face_geom_factors_get" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + result = (mfem::Array< mfem::FaceGeometricFactors * > *)& ((arg1)->face_geom_factors); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN int Swig_var_Mesh_remove_unused_vertices_set(PyObject *_val) { { bool val; @@ -5117,6 +5143,189 @@ SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObje } +SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + int i; + if (!PyList_Check(swig_obj[1])) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(swig_obj[1]); + arg2 = (int *) malloc((l)*sizeof(int)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(swig_obj[1],i); + if (PyInt_Check(s)) { + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); + return NULL; + } + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->AddSegment((int const *)arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + int i; + if (!PyList_Check(swig_obj[1])) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(swig_obj[1]); + arg2 = (int *) malloc((l)*sizeof(int)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(swig_obj[1],i); + if (PyInt_Check(s)) { + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); + return NULL; + } + } + } + { + try { + (arg1)->AddSegment((int const *)arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_AddSegment(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddSegment", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + return _wrap_Mesh_AddSegment__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + _v = PyList_Check(argv[1]) ? 1 : 0; + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_AddSegment__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddSegment'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::AddSegment(int const *,int)\n" + " mfem::Mesh::AddSegment(int const *)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -9190,23 +9399,29 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_FinalizeTopology" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - (arg1)->FinalizeTopology(); + (arg1)->FinalizeTopology(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9230,30 +9445,110 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + { + try { + (arg1)->FinalizeTopology(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTopology", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_FinalizeTopology__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_FinalizeTopology__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTopology'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::FinalizeTopology(bool)\n" + " mfem::Mesh::FinalizeTopology()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 ; + bool arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_Finalize" "', argument " "3"" of type '" "bool""'"); } @@ -9472,6 +9767,56 @@ SWIGINTERN PyObject *_wrap_Mesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), Py } +SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetHilbertElementOrdering", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + (arg1)->GetHilbertElementOrdering(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -11756,6 +12101,54 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNumFaces(PyObject *SWIGUNUSEDPARM(self), PyOb } +SWIGINTERN PyObject *_wrap_Mesh_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::FaceType arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFbyType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); + { + try { + result = (int)((mfem::Mesh const *)arg1)->GetNFbyType(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Mesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -11902,6 +12295,72 @@ SWIGINTERN PyObject *_wrap_Mesh_GetGeometricFactors(PyObject *SWIGUNUSEDPARM(sel } +SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; + int arg3 ; + mfem::FaceType arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + mfem::FaceGeometricFactors *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); + } + arg4 = static_cast< mfem::FaceType >(val4); + { + try { + result = (mfem::FaceGeometricFactors *)(arg1)->GetFaceGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Mesh_DeleteGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; @@ -16721,7 +17180,7 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNode", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -16737,7 +17196,7 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject arg3 = reinterpret_cast< double * >(argp3); { try { - (arg1)->GetNode(arg2,arg3); + ((mfem::Mesh const *)arg1)->GetNode(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20535,7 +20994,7 @@ SWIGINTERN PyObject *_wrap_Mesh_DerefineByError(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::Array< mfem::KnotVector * > *arg2 = 0 ; @@ -20543,9 +21002,8 @@ SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -20585,35 +21043,32 @@ SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; + mfem::Array< mfem::Vector * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); } + arg2 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp2); { try { - (arg1)->DegreeElevate(arg2,arg3); + (arg1)->KnotInsert(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20637,12 +21092,110 @@ SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_KnotInsert'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::KnotVector * > &)\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::Vector * > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->DegreeElevate(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); @@ -21506,39 +22059,69 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + std::ostream *arg2 = 0 ; int arg3 ; + mfem::VTKFormat arg4 ; + bool arg5 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } { try { - (arg1)->GetElementColoring(*arg2,arg3); + (arg1)->PrintVTU(*arg2,arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21556,38 +22139,78 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_0(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; + mfem::VTKFormat arg4 ; + bool arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); { try { - (arg1)->GetElementColoring(*arg2); + (arg1)->PrintVTU(*arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21605,116 +22228,70 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_1(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; + mfem::VTKFormat arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementColoring", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementColoring'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &,int)\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); { try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); + (arg1)->PrintVTU(*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21733,62 +22310,61 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUS } resultobj = SWIG_Py_Void(); { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return resultobj; fail: { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } { try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3); + (arg1)->PrintVTU(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21807,147 +22383,54 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUS } resultobj = SWIG_Py_Void(); { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return resultobj; fail: { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &,int) const\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); + (arg1)->PrintVTU(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21966,62 +22449,75 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject * } resultobj = SWIG_Py_Void(); { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return resultobj; fail: { - if (temp3->isSTDOUT() != 1) { - out3.close(); + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; + std::string arg2 ; + mfem::VTKFormat arg3 ; + bool arg4 ; + int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); + } + arg3 = static_cast< mfem::VTKFormat >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } { try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3); + (arg1)->PrintVTU(arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22039,145 +22535,59 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(PyObject * } } resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return resultobj; fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintElementsWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &,int)\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Table *arg2 = 0 ; - std::ostream *arg3 = 0 ; + std::string arg2 ; + mfem::VTKFormat arg3 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - PyObject *swig_obj[3] ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintSurfaces", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); + } + arg3 = static_cast< mfem::VTKFormat >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); { try { - ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); + (arg1)->PrintVTU(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22195,93 +22605,51 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), Py } } resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return resultobj; fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; + std::string arg2 ; + mfem::VTKFormat arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleSubdomains", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); { - try { - (arg1)->ScaleSubdomains(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); } - arg2 = static_cast< double >(val2); + arg3 = static_cast< mfem::VTKFormat >(val3); { try { - (arg1)->ScaleElements(arg2); + (arg1)->PrintVTU(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22305,28 +22673,37 @@ SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; + std::string arg2 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; } } { try { - (arg1)->Transform(arg2); + (arg1)->PrintVTU(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22350,62 +22727,13 @@ SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - (arg1)->Transform(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTU", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -22413,11 +22741,10 @@ SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); + return _wrap_Mesh_PrintVTU__SWIG_8(self, argc, argv); } } } @@ -22427,180 +22754,309 @@ SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); + return _wrap_Mesh_PrintVTU__SWIG_4(self, argc, argv); } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" - " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveUnusedVertices(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_7(self, argc, argv); + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_3(self, argc, argv); + } + } + } } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveInternalBoundaries(); + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_6(self, argc, argv); + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_2(self, argc, argv); + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_5(self, argc, argv); + } + } + } + } + } } - { - try { - result = (double)(arg1)->GetElementSize(arg2,arg3); + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTU'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool,int)\n" + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool)\n" + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat)\n" + " mfem::Mesh::PrintVTU(std::ostream &,int)\n" + " mfem::Mesh::PrintVTU(std::ostream &)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool,int)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat)\n" + " mfem::Mesh::PrintVTU(std::string)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double result; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (double)(arg1)->GetElementSize(arg2); + (arg1)->GetElementColoring(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22617,47 +23073,39 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); + (arg1)->GetElementColoring(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22674,20 +23122,20 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_2(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementColoring", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -22695,16 +23143,11 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); + return _wrap_Mesh_GetElementColoring__SWIG_1(self, argc, argv); } } } @@ -22714,37 +23157,9 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { @@ -22755,104 +23170,60 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + return _wrap_Mesh_GetElementColoring__SWIG_0(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementColoring'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementSize(int,int)\n" - " mfem::Mesh::GetElementSize(int)\n" - " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); + " mfem::Mesh::GetElementColoring(mfem::Array< int > &,int)\n" + " mfem::Mesh::GetElementColoring(mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVolume", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double)(arg1)->GetElementVolume(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -22861,7 +23232,7 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM( } { try { - (arg1)->GetBoundingBox(*arg2,*arg3,arg4); + ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22879,49 +23250,63 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM( } } resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->GetBoundingBox(*arg2,*arg3); + ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22939,19 +23324,29 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM( } } resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBoundingBox", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintWithPartitioning", 0, 4, argv))) SWIG_fail; --argc; if (argc == 3) { int _v; @@ -22960,14 +23355,20 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_1(self, argc, argv); + return _wrap_Mesh_PrintWithPartitioning__SWIG_1(self, argc, argv); } } } @@ -22979,12 +23380,18 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { @@ -22995,7 +23402,7 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_0(self, argc, argv); + return _wrap_Mesh_PrintWithPartitioning__SWIG_0(self, argc, argv); } } } @@ -23003,179 +23410,62 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBoundingBox'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintWithPartitioning'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &)\n"); + " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &,int) const\n" + " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - mfem::Vector *arg7 = (mfem::Vector *) 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); + arg2 = reinterpret_cast< int * >(argp2); { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6); + (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23193,71 +23483,63 @@ SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_1(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg5 = reinterpret_cast< double * >(argp5); { try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); + (arg1)->PrintElementsWithPartitioning(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23275,159 +23557,127 @@ SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_2(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetCharacteristics", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsWithPartitioning", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_2(self, argc, argv); - } - } + return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(self, argc, argv); } } } } - if (argc == 6) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_1(self, argc, argv); - } - } + { + void *ptr; + if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_0(self, argc, argv); - } - } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(self, argc, argv); + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetCharacteristics'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintElementsWithPartitioning'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &)\n"); + " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &,int)\n" + " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - mfem::Array< int > *arg2 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Table *arg2 = 0 ; std::ostream *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyMFEM::wFILE *temp3 = 0 ; std::ofstream out3 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsByGeometry", 3, 3, swig_obj)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintSurfaces", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + arg2 = reinterpret_cast< mfem::Table * >(argp2); { if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); @@ -23445,7 +23695,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM } { try { - mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); + ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23479,55 +23729,30 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - std::ostream *arg4 = 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyMFEM::wFILE *temp4 = 0 ; - std::ofstream out4 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleSubdomains", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if (SWIG_ConvertPtr(swig_obj[3], (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp4->isSTDOUT() == 1) { - arg4 = &std::cout; - } - else { - out4.open(temp4->getFilename()); - out4.precision(temp4->getPrecision()); - arg4 = &out4; - } - } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - (arg1)->PrintCharacteristics(arg2,arg3,*arg4); + (arg1)->ScaleSubdomains(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23545,53 +23770,36 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_0(PyObject *SWIGUNUSE } } resultobj = SWIG_Py_Void(); - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } return resultobj; fail: - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleElements", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - (arg1)->PrintCharacteristics(arg2,arg3); + (arg1)->ScaleElements(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23615,29 +23823,28 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); + { + int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); + } } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->PrintCharacteristics(arg2); + (arg1)->Transform(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23661,21 +23868,32 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - (arg1)->PrintCharacteristics(); + (arg1)->Transform(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23699,131 +23917,69 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintCharacteristics", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_3(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_1(self, argc, argv); - } + return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); } } } - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[3], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintCharacteristics'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *,std::ostream &)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics()\n"); + " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" + " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } { try { - (arg1)->PrintInfo(*arg2); + (arg1)->RemoveUnusedVertices(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23841,37 +23997,29 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self) } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->PrintInfo(); + (arg1)->RemoveInternalBoundaries(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23895,71 +24043,36 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) 0 ; + int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; + double result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); { try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); + result = (double)(arg1)->GetElementSize(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -23976,70 +24089,36 @@ SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - int result; + double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); { try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5); + result = (double)(arg1)->GetElementSize(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24056,62 +24135,47 @@ SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int result; + double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4); + result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24128,138 +24192,127 @@ SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FindPoints", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_2(self, argc, argv); - } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); + } } } - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_1(self, argc, argv); - } - } + return _wrap_Mesh_GetElementSize__SWIG_2(self, argc, argv); } } } } - if (argc == 6) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__InverseElementTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_0(self, argc, argv); - } - } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FindPoints'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool,mfem::InverseElementTransformation *)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &)\n"); + " mfem::Mesh::GetElementSize(int,int)\n" + " mfem::Mesh::GetElementSize(int)\n" + " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject *swig_obj[2] ; + double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVolume", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - delete arg1; + result = (double)(arg1)->GetElementVolume(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24276,82 +24329,57 @@ SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_32(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< char * >(buf4); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); + (arg1)->GetBoundingBox(*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24368,76 +24396,50 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_32(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_33(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7); + (arg1)->GetBoundingBox(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24454,138 +24456,154 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_33(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_34(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBoundingBox", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetBoundingBox__SWIG_1(self, argc, argv); + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetBoundingBox__SWIG_0(self, argc, argv); + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; + fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBoundingBox'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &,int)\n" + " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_35(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + mfem::Vector *arg6 = (mfem::Vector *) 0 ; + mfem::Vector *arg7 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); } + arg5 = reinterpret_cast< double * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24602,53 +24620,80 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_35(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_36(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + mfem::Vector *arg6 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } - arg4 = reinterpret_cast< char * >(buf4); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24665,69 +24710,72 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_36(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_37(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - double arg6 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24744,124 +24792,178 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_37(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_38(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetCharacteristics", 0, 7, argv))) SWIG_fail; + --argc; + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetCharacteristics__SWIG_2(self, argc, argv); + } + } + } + } + } } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5); + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetCharacteristics__SWIG_1(self, argc, argv); + } + } + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 7) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetCharacteristics__SWIG_0(self, argc, argv); + } + } + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; + fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetCharacteristics'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *,mfem::Vector *)\n" + " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *)\n" + " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_39(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Array< int > *arg2 = 0 ; + std::ostream *arg3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject *swig_obj[3] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsByGeometry", 3, 3, swig_obj)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< char * >(buf3); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4); + mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24878,46 +24980,136 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_39(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_40(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = (mfem::Vector *) 0 ; + std::ostream *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyMFEM::wFILE *temp4 = 0 ; + std::ofstream out4 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (SWIG_ConvertPtr(swig_obj[3], (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp4->isSTDOUT() == 1) { + arg4 = &std::cout; + } + else { + out4.open(temp4->getFilename()); + out4.precision(temp4->getPrecision()); + arg4 = &out4; + } } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + { + try { + (arg1)->PrintCharacteristics(arg2,arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + if (temp4->isSTDOUT() != 1) { + out4.close(); + } + } + return resultobj; +fail: + { + if (temp4->isSTDOUT() != 1) { + out4.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); } - arg3 = reinterpret_cast< char * >(buf3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3); + (arg1)->PrintCharacteristics(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -24934,252 +25126,1578 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_40(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + (arg1)->PrintCharacteristics(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + (arg1)->PrintCharacteristics(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[13] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintCharacteristics", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_Mesh__SWIG_1(self, argc, argv); - } if (argc == 1) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_3(self, argc, argv); + return _wrap_Mesh_PrintCharacteristics__SWIG_3(self, argc, argv); } } - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_29(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintCharacteristics__SWIG_2(self, argc, argv); + } } } - if (argc == 1) { + if (argc == 3) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_21(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintCharacteristics__SWIG_1(self, argc, argv); + } + } } } - if (argc == 1) { + if (argc == 4) { int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_25(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Mesh__SWIG_28(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[3], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintCharacteristics__SWIG_0(self, argc, argv); + } } } - if (_v) { - return _wrap_new_Mesh__SWIG_30(self, argc, argv); - } } } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintCharacteristics'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *,std::ostream &)\n" + " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *)\n" + " mfem::Mesh::PrintCharacteristics(mfem::Vector *)\n" + " mfem::Mesh::PrintCharacteristics()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_20(self, argc, argv); - } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } - if (argc == 2) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_24(self, argc, argv); - } + { + try { + (arg1)->PrintInfo(*arg2); } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_27(self, argc, argv); - } - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_31(self, argc, argv); - } - } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); } } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_8(self, argc, argv); - } - } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); } } - if (argc == 3) { - int _v; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + (arg1)->PrintInfo(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + bool arg5 ; + mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + int result; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); + } + arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); + { + try { + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + bool arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + int result; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + { + try { + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int result; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + { + try { + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FindPoints", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_FindPoints__SWIG_2(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_Mesh_FindPoints__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__InverseElementTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_FindPoints__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FindPoints'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool,mfem::InverseElementTransformation *)\n" + " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool)\n" + " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_32(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + double arg6 ; + double arg7 ; + double arg8 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_33(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + double arg6 ; + double arg7 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_34(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + double arg6 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_35(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_36(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return resultobj; +fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_37(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + double arg5 ; + double arg6 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_38(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + double arg5 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + double val5 ; + int ecode5 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_39(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_40(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[13] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_Mesh__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Mesh__SWIG_3(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Mesh__SWIG_29(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_21(self, argc, argv); + } + } + if (argc == 1) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_Mesh__SWIG_25(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_28(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_2(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_30(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_20(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_24(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_27(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_31(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_8(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -26105,11 +27623,183 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } if (_v) { { - int res = SWIG_AsVal_bool(argv[8], NULL); - _v = SWIG_CheckState(res); + int res = SWIG_AsVal_bool(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 11) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } + } + } + } + } + } + } + } + } + } + } + } + if (argc == 12) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_new_Mesh__SWIG_9(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[11]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_4(self, argc, argv); + } + } + } + } + } + } } } } @@ -26117,10 +27807,257 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 11) { + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Mesh'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::Mesh()\n" + " mfem::Mesh::Mesh(mfem::Mesh const &,bool)\n" + " mfem::Mesh::Mesh(mfem::Mesh const &)\n" + " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int,int)\n" + " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,int)\n" + " mfem::Mesh::Mesh(int,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double,bool)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool)\n" + " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double,bool)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool)\n" + " mfem::Mesh::Mesh(int,int,mfem::Element::Type)\n" + " mfem::Mesh::Mesh(int,double)\n" + " mfem::Mesh::Mesh(int)\n" + " mfem::Mesh::Mesh(char const *,int,int,bool)\n" + " mfem::Mesh::Mesh(char const *,int,int)\n" + " mfem::Mesh::Mesh(char const *,int)\n" + " mfem::Mesh::Mesh(char const *)\n" + " mfem::Mesh::Mesh(std::istream &,int,int,bool)\n" + " mfem::Mesh::Mesh(std::istream &,int,int)\n" + " mfem::Mesh::Mesh(std::istream &,int)\n" + " mfem::Mesh::Mesh(std::istream &)\n" + " mfem::Mesh::Mesh(mfem::Mesh *[],int)\n" + " mfem::Mesh::Mesh(mfem::Mesh *,int,int)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int,double)\n" + " mfem::Mesh::Mesh(int,int,int,char const *,int)\n" + " mfem::Mesh::Mesh(int,int,int,char const *)\n" + " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n" + " mfem::Mesh::Mesh(int,int,char const *,int,double)\n" + " mfem::Mesh::Mesh(int,int,char const *,int)\n" + " mfem::Mesh::Mesh(int,int,char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintToFile", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintToFile" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintToFile" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + mfem_Mesh_PrintToFile((mfem::Mesh const *)arg1,(char const *)arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return resultobj; +fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (PyObject *)mfem_Mesh_GetAttributeArray((mfem::Mesh const *)arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + PyObject *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertexArray", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (PyObject *)mfem_Mesh_GetVertexArray((mfem::Mesh const *)arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (PyObject *)mfem_Mesh_GetBdrElementFace__SWIG_1((mfem::Mesh const *)arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementFace", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { @@ -26132,76 +28069,14 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - } + return _wrap_Mesh_GetBdrElementFace__SWIG_1(self, argc, argv); } } } - if (argc == 12) { + if (argc == 4) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { @@ -26217,73 +28092,11 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[11]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_4(self, argc, argv); - } - } - } - } - } - } - } - } + return _wrap_Mesh_GetBdrElementFace__SWIG_0(self, argc, argv); } } } @@ -26291,53 +28104,150 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Mesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Mesh()\n" - " mfem::Mesh::Mesh(mfem::Mesh const &,bool)\n" - " mfem::Mesh::Mesh(mfem::Mesh const &)\n" - " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int,int)\n" - " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type)\n" - " mfem::Mesh::Mesh(int,double)\n" - " mfem::Mesh::Mesh(int)\n" - " mfem::Mesh::Mesh(char const *,int,int,bool)\n" - " mfem::Mesh::Mesh(char const *,int,int)\n" - " mfem::Mesh::Mesh(char const *,int)\n" - " mfem::Mesh::Mesh(char const *)\n" - " mfem::Mesh::Mesh(std::istream &,int,int,bool)\n" - " mfem::Mesh::Mesh(std::istream &,int,int)\n" - " mfem::Mesh::Mesh(std::istream &,int)\n" - " mfem::Mesh::Mesh(std::istream &)\n" - " mfem::Mesh::Mesh(mfem::Mesh *[],int)\n" - " mfem::Mesh::Mesh(mfem::Mesh *,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,int,char const *)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,char const *)\n"); - return 0; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementFace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetBdrElementFace(int,int *,int *) const\n" + " mfem::Mesh::GetBdrElementFace(int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + PyObject *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (PyObject *)mfem_Mesh_GetBdrAttributeArray((mfem::Mesh const *)arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + PyObject *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrArray", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (PyObject *)mfem_Mesh_GetBdrArray((mfem::Mesh const *)arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = result; + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + PyObject *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "Mesh_GetDomainArray", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetDomainArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (PyObject *)mfem_Mesh_GetDomainArray((mfem::Mesh const *)arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = result; + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; @@ -26347,17 +28257,16 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintToFile", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintToFile" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintToFile" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { @@ -26368,7 +28277,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb } { try { - mfem_Mesh_PrintToFile((mfem::Mesh const *)arg1,(char const *)arg2,arg3); + mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26394,24 +28303,30 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Mesh_GetAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); { try { - result = (PyObject *)mfem_Mesh_GetAttributeArray((mfem::Mesh const *)arg1); + mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26428,37 +28343,131 @@ SWIGINTERN PyObject *_wrap_Mesh_GetAttributeArray(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintInfo", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_3(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintInfo__SWIG_2(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintInfo'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintInfo(std::ostream &)\n" + " mfem::Mesh::PrintInfo()\n" + " mfem::Mesh::PrintInfo(char const *,int)\n" + " mfem::Mesh::PrintInfo(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + char *arg2 = (char *) 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertexArray", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (PyObject *)mfem_Mesh_GetVertexArray((mfem::Mesh const *)arg1,arg2); + mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26475,36 +28484,39 @@ SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); } + arg2 = reinterpret_cast< char * >(buf2); { try { - result = (PyObject *)mfem_Mesh_GetBdrElementFace__SWIG_1((mfem::Mesh const *)arg1,arg2); + mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26521,48 +28533,54 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementFace", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Print", 0, 3, argv))) SWIG_fail; --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_Print__SWIG_1(self, argc, argv); + } + } if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetBdrElementFace__SWIG_1(self, argc, argv); + return _wrap_Mesh_Print__SWIG_3(self, argc, argv); } } } - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { PyErr_Clear(); _v = 0; } else { @@ -26570,48 +28588,76 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace(PyObject *self, PyObject *args } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetBdrElementFace__SWIG_0(self, argc, argv); + return _wrap_Mesh_Print__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_Mesh_Print__SWIG_2(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementFace'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Print'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBdrElementFace(int,int *,int *) const\n" - " mfem::Mesh::GetBdrElementFace(int) const\n"); + " mfem::Mesh::Print(std::ostream &) const\n" + " mfem::Mesh::Print() const\n" + " mfem::Mesh::Print(char const *,int)\n" + " mfem::Mesh::Print(char const *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttributeArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttributeArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); + } + arg2 = reinterpret_cast< char * >(buf2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } { try { - result = (PyObject *)mfem_Mesh_GetBdrAttributeArray((mfem::Mesh const *)arg1); + mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26628,37 +28674,39 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttributeArray(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrArray", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); } + arg2 = reinterpret_cast< char * >(buf2); { try { - result = (PyObject *)mfem_Mesh_GetBdrArray((mfem::Mesh const *)arg1,arg2); + mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26675,61 +28723,101 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = result; + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - PyObject *result = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetDomainArray", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetDomainArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintXG", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); + } } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_3(self, argc, argv); + } + } } - { - try { - result = (PyObject *)mfem_Mesh_GetDomainArray((mfem::Mesh const *)arg1,arg2); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_2(self, argc, argv); + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = result; - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintXG'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintXG(std::ostream &) const\n" + " mfem::Mesh::PrintXG() const\n" + " mfem::Mesh::PrintXG(char const *,int)\n" + " mfem::Mesh::PrintXG(char const *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; @@ -26743,12 +28831,12 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self) if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { @@ -26759,7 +28847,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } { try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); + mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26785,7 +28873,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; @@ -26798,17 +28886,17 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self) if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2); + mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -26834,24 +28922,48 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintInfo", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTK", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_4(self, argc, argv); + } } } if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -26860,11 +28972,21 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_3(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_3(self, argc, argv); + } } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -26880,257 +29002,371 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_0(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); + } } } } - if (argc == 3) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTK__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTK'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintVTK(std::ostream &)\n" + " mfem::Mesh::PrintVTK(std::ostream &,int,int)\n" + " mfem::Mesh::PrintVTK(std::ostream &,int)\n" + " mfem::Mesh::PrintVTK(char const *,int)\n" + " mfem::Mesh::PrintVTK(char const *)\n"); + return 0; +} + + +SWIGINTERN PyObject *Mesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__Mesh, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *Mesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::ostream *arg1 = 0 ; + mfem::Mesh *arg2 = 0 ; + PyMFEM::wFILE *temp1 = 0 ; + std::ofstream out1 ; + void *argp2 = 0 ; + int res2 = 0 ; + std::ostream *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp1->isSTDOUT() == 1) { + arg1 = &std::cout; + } + else { + out1.open(temp1->getFilename()); + out1.precision(temp1->getPrecision()); + arg1 = &out1; + } + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); + } + arg2 = reinterpret_cast< mfem::Mesh * >(argp2); + { + try { + result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::Mesh const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + return resultobj; +fail: + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_2(self, argc, argv); - } + return _wrap___lshift____SWIG_2(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintInfo'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintInfo(std::ostream &)\n" - " mfem::Mesh::PrintInfo()\n" - " mfem::Mesh::PrintInfo(char const *,int)\n" - " mfem::Mesh::PrintInfo(char const *)\n"); - return 0; + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_mesh_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_mesh_set" "', argument " "2"" of type '" "mfem::Mesh const *""'"); } + arg2 = reinterpret_cast< mfem::Mesh * >(argp2); + if (arg1) (arg1)->mesh = (mfem::Mesh const *)arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + PyObject *swig_obj[1] ; + mfem::Mesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Mesh *) ((arg1)->mesh); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_IntRule_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_IntRule_set" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + if (arg1) (arg1)->IntRule = (mfem::IntegrationRule const *)arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::IntegrationRule *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Print", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_3(self, argc, argv); - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Print__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::IntegrationRule *) ((arg1)->IntRule); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_computed_factors_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Print__SWIG_2(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + if (arg1) (arg1)->computed_factors = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (int) ((arg1)->computed_factors); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Print'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Print(std::ostream &) const\n" - " mfem::Mesh::Print() const\n" - " mfem::Mesh::Print(char const *,int)\n" - " mfem::Mesh::Print(char const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::IntegrationRule *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[3] ; + mfem::GeometricFactors *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_GeometricFactors", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } - arg2 = reinterpret_cast< char * >(buf2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -27139,7 +29375,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } { try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2,arg3); + result = (mfem::GeometricFactors *)new mfem::GeometricFactors((mfem::Mesh const *)arg1,(mfem::IntegrationRule const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27156,449 +29392,186 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_NEW | 0 ); return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_X_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_X_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->X = *arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintXG", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_2(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->X); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintXG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintXG(std::ostream &) const\n" - " mfem::Mesh::PrintXG() const\n" - " mfem::Mesh::PrintXG(char const *,int)\n" - " mfem::Mesh::PrintXG(char const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_J_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_J_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->J = *arg2; resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->J); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTK", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); - } - } - } + if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_detJ_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_1(self, argc, argv); - } - } - } - } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_detJ_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } - + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->detJ = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTK'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintVTK(std::ostream &)\n" - " mfem::Mesh::PrintVTK(std::ostream &,int,int)\n" - " mfem::Mesh::PrintVTK(std::ostream &,int)\n" - " mfem::Mesh::PrintVTK(char const *,int)\n" - " mfem::Mesh::PrintVTK(char const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *Mesh_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__Mesh, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *Mesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); +SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->detJ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + +SWIGINTERN PyObject *_wrap_delete_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - std::ostream *arg1 = 0 ; - mfem::Mesh *arg2 = 0 ; - PyMFEM::wFILE *temp1 = 0 ; - std::ofstream out1 ; - void *argp2 = 0 ; - int res2 = 0 ; - std::ostream *result = 0 ; + mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp1->isSTDOUT() == 1) { - arg1 = &std::cout; - } - else { - out1.open(temp1->getFilename()); - out1.precision(temp1->getPrecision()); - arg1 = &out1; - } - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::Mesh const &""'"); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeometricFactors" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); + arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); { try { - result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::Mesh const &)*arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27615,62 +29588,27 @@ SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } + resultobj = SWIG_Py_Void(); return resultobj; fail: - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } - PyErr_Clear(); - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + return NULL; } -SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap___lshift____SWIG_2(self, argc, argv); - } - } - } - -fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; +SWIGINTERN PyObject *GeometricFactors_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeometricFactors, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } +SWIGINTERN PyObject *GeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} -SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27678,15 +29616,15 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_mesh_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_mesh_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_mesh_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_mesh_set" "', argument " "2"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_mesh_set" "', argument " "2"" of type '" "mfem::Mesh const *""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); if (arg1) (arg1)->mesh = (mfem::Mesh const *)arg2; @@ -27697,9 +29635,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_set(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27707,11 +29645,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(se if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_mesh_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_mesh_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (mfem::Mesh *) ((arg1)->mesh); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); return resultobj; @@ -27720,9 +29658,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_mesh_get(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27730,15 +29668,15 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_IntRule_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_IntRule_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_IntRule_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_IntRule_set" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_IntRule_set" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); if (arg1) (arg1)->IntRule = (mfem::IntegrationRule const *)arg2; @@ -27749,9 +29687,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_set(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27759,11 +29697,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_IntRule_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_IntRule_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (mfem::IntegrationRule *) ((arg1)->IntRule); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; @@ -27772,20 +29710,20 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_IntRule_get(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_computed_factors_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_computed_factors_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_computed_factors_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_computed_factors_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -27800,9 +29738,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_set(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_computed_factors_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27810,11 +29748,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGU if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_computed_factors_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_computed_factors_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (int) ((arg1)->computed_factors); resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; @@ -27823,30 +29761,85 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + mfem::FaceType arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_type_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_type_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FaceGeometricFactors_type_set" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); + if (arg1) (arg1)->type = arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::FaceType result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_type_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::FaceType) ((arg1)->type); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::IntegrationRule *arg2 = 0 ; int arg3 ; + mfem::FaceType arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; - mfem::GeometricFactors *result = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + mfem::FaceGeometricFactors *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_GeometricFactors", 3, 3, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_FaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { @@ -27855,9 +29848,14 @@ SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); + } + arg4 = static_cast< mfem::FaceType >(val4); { try { - result = (mfem::GeometricFactors *)new mfem::GeometricFactors((mfem::Mesh const *)arg1,(mfem::IntegrationRule const &)*arg2,arg3); + result = (mfem::FaceGeometricFactors *)new mfem::FaceGeometricFactors((mfem::Mesh const *)arg1,(mfem::IntegrationRule const &)*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27874,16 +29872,16 @@ SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27891,15 +29889,15 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_X_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_X_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_X_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_X_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_X_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); if (arg1) (arg1)->X = *arg2; @@ -27910,9 +29908,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27920,11 +29918,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self) if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_X_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_X_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (mfem::Vector *)& ((arg1)->X); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; @@ -27933,9 +29931,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_X_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27943,15 +29941,15 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_J_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_J_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_J_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_J_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_J_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); if (arg1) (arg1)->J = *arg2; @@ -27962,9 +29960,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_set(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -27972,11 +29970,11 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self) if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_J_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_J_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); result = (mfem::Vector *)& ((arg1)->J); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; @@ -27985,9 +29983,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_J_get(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; mfem::Vector *arg2 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -27995,18 +29993,70 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeometricFactors_detJ_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_detJ_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_set" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_detJ_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_detJ_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (arg1) (arg1)->detJ = *arg2; + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_detJ_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->detJ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_normal_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "FaceGeometricFactors_normal_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_normal_set" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); + } + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeometricFactors_detJ_set" "', argument " "2"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FaceGeometricFactors_normal_set" "', argument " "2"" of type '" "mfem::Vector *""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - if (arg1) (arg1)->detJ = *arg2; + if (arg1) (arg1)->normal = *arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -28014,9 +30064,9 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_set(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FaceGeometricFactors_normal_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -28024,12 +30074,12 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(se if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometricFactors_detJ_get" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FaceGeometricFactors_normal_get" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); - result = (mfem::Vector *)& ((arg1)->detJ); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); + result = (mfem::Vector *)& ((arg1)->normal); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: @@ -28037,20 +30087,20 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_detJ_get(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_delete_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeometricFactors *arg1 = (mfem::GeometricFactors *) 0 ; + mfem::FaceGeometricFactors *arg1 = (mfem::FaceGeometricFactors *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometricFactors, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FaceGeometricFactors, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeometricFactors" "', argument " "1"" of type '" "mfem::GeometricFactors *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FaceGeometricFactors" "', argument " "1"" of type '" "mfem::FaceGeometricFactors *""'"); } - arg1 = reinterpret_cast< mfem::GeometricFactors * >(argp1); + arg1 = reinterpret_cast< mfem::FaceGeometricFactors * >(argp1); { try { delete arg1; @@ -28077,14 +30127,14 @@ SWIGINTERN PyObject *_wrap_delete_GeometricFactors(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *GeometricFactors_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FaceGeometricFactors_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeometricFactors, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FaceGeometricFactors, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *GeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *FaceGeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } @@ -28733,127 +30783,47 @@ SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_named_ifgzstream_filename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::named_ifgzstream *arg1 = (mfem::named_ifgzstream *) 0 ; - char *arg2 = (char *) 0 ; + int *arg1 = 0 ; + int *arg2 = 0 ; + int *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "named_ifgzstream_filename_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__named_ifgzstream, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ShiftRight", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "named_ifgzstream_filename_set" "', argument " "1"" of type '" "mfem::named_ifgzstream *""'"); - } - arg1 = reinterpret_cast< mfem::named_ifgzstream * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "named_ifgzstream_filename_set" "', argument " "2"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } - arg2 = reinterpret_cast< char * >(buf2); - if (arg2) { - size_t size = strlen(reinterpret_cast< const char * >(reinterpret_cast< const char * >(arg2))) + 1; - arg1->filename = (char const *)reinterpret_cast< char* >(memcpy(new char[size], arg2, sizeof(char)*(size))); - } else { - arg1->filename = 0; + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_named_ifgzstream_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::named_ifgzstream *arg1 = (mfem::named_ifgzstream *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - char *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__named_ifgzstream, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "named_ifgzstream_filename_get" "', argument " "1"" of type '" "mfem::named_ifgzstream *""'"); + arg1 = reinterpret_cast< int * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } - arg1 = reinterpret_cast< mfem::named_ifgzstream * >(argp1); - result = (char *) ((arg1)->filename); - resultobj = SWIG_FromCharPtr((const char *)result); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_named_ifgzstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - PyObject *swig_obj[1] ; - mfem::named_ifgzstream *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_named_ifgzstream" "', argument " "1"" of type '" "char const *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } - arg1 = reinterpret_cast< char * >(buf1); - { - try { - result = (mfem::named_ifgzstream *)new mfem::named_ifgzstream((char const *)arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg2 = reinterpret_cast< int * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShiftRight" "', argument " "3"" of type '" "int &""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__named_ifgzstream, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return resultobj; -fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_named_ifgzstream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::named_ifgzstream *arg1 = (mfem::named_ifgzstream *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__named_ifgzstream, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_named_ifgzstream" "', argument " "1"" of type '" "mfem::named_ifgzstream *""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "3"" of type '" "int &""'"); } - arg1 = reinterpret_cast< mfem::named_ifgzstream * >(argp1); + arg3 = reinterpret_cast< int * >(argp3); { try { - delete arg1; + mfem::ShiftRight(*arg1,*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28877,19 +30847,9 @@ SWIGINTERN PyObject *_wrap_delete_named_ifgzstream(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *named_ifgzstream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__named_ifgzstream, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *named_ifgzstream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, @@ -28914,10 +30874,13 @@ static PyMethodDef SwigMethods[] = { { "Mesh_ncmesh_get", _wrap_Mesh_ncmesh_get, METH_O, "Mesh_ncmesh_get(Mesh self) -> NCMesh"}, { "Mesh_geom_factors_set", _wrap_Mesh_geom_factors_set, METH_VARARGS, "Mesh_geom_factors_set(Mesh self, mfem::Array< mfem::GeometricFactors * > * geom_factors)"}, { "Mesh_geom_factors_get", _wrap_Mesh_geom_factors_get, METH_O, "Mesh_geom_factors_get(Mesh self) -> mfem::Array< mfem::GeometricFactors * > *"}, + { "Mesh_face_geom_factors_set", _wrap_Mesh_face_geom_factors_set, METH_VARARGS, "Mesh_face_geom_factors_set(Mesh self, mfem::Array< mfem::FaceGeometricFactors * > * face_geom_factors)"}, + { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "Mesh_NewElement(Mesh self, int geom) -> Element"}, { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "Mesh_AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "Mesh_AddSegment(Mesh self, int const * vi, int attr=1)"}, { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "Mesh_AddTri(Mesh self, int const * vi, int attr=1)"}, { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "Mesh_AddTriangle(Mesh self, int const * vi, int attr=1)"}, { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "Mesh_AddQuad(Mesh self, int const * vi, int attr=1)"}, @@ -28939,9 +30902,10 @@ static PyMethodDef SwigMethods[] = { { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "Mesh_FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "Mesh_FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "Mesh_FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_O, "Mesh_FinalizeTopology(Mesh self)"}, + { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "Mesh_FinalizeTopology(Mesh self, bool generate_bdr=True)"}, { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Mesh_Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "Mesh_SetAttributes(Mesh self)"}, + { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "Mesh_GetHilbertElementOrdering(Mesh self, intArray ordering)"}, { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "Mesh_ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Mesh_Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Mesh_Clear(Mesh self)"}, @@ -28952,9 +30916,11 @@ static PyMethodDef SwigMethods[] = { { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "Mesh_GetNEdges(Mesh self) -> int"}, { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "Mesh_GetNFaces(Mesh self) -> int"}, { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "Mesh_GetNumFaces(Mesh self) -> int"}, + { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "Mesh_GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "Mesh_ReduceInt(Mesh self, int value) -> long"}, { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "Mesh_GetGlobalNE(Mesh self) -> long"}, { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "Mesh_GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "Mesh_GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "Mesh_DeleteGeometricFactors(Mesh self)"}, { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "Mesh_EulerNumber(Mesh self) -> int"}, { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "Mesh_EulerNumber2D(Mesh self) -> int"}, @@ -29078,14 +31044,21 @@ static PyMethodDef SwigMethods[] = { "Mesh_DerefineByError(Mesh self, doubleArray elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" "Mesh_DerefineByError(Mesh self, Vector elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" ""}, - { "Mesh_KnotInsert", _wrap_Mesh_KnotInsert, METH_VARARGS, "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)"}, + { "Mesh_KnotInsert", _wrap_Mesh_KnotInsert, METH_VARARGS, "\n" + "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" + "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" + ""}, { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "Mesh_DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, - { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "Mesh_EnsureNCMesh(Mesh self, bool triangles_nonconforming=False)"}, + { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "Mesh_EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Mesh_Conforming(Mesh self) -> bool"}, { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Mesh_Nonconforming(Mesh self) -> bool"}, { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "Mesh_GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, { "Mesh_GetLastOperation", _wrap_Mesh_GetLastOperation, METH_O, "Mesh_GetLastOperation(Mesh self) -> mfem::Mesh::Operation"}, { "Mesh_GetSequence", _wrap_Mesh_GetSequence, METH_O, "Mesh_GetSequence(Mesh self) -> long"}, + { "Mesh_PrintVTU", _wrap_Mesh_PrintVTU, METH_VARARGS, "\n" + "Mesh_PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + "Mesh_PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + ""}, { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "Mesh_GetElementColoring(Mesh self, intArray colors, int el0=0)"}, { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "Mesh_PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "Mesh_PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, @@ -29174,6 +31147,26 @@ static PyMethodDef SwigMethods[] = { { "delete_GeometricFactors", _wrap_delete_GeometricFactors, METH_O, "delete_GeometricFactors(GeometricFactors self)"}, { "GeometricFactors_swigregister", GeometricFactors_swigregister, METH_O, NULL}, { "GeometricFactors_swiginit", GeometricFactors_swiginit, METH_VARARGS, NULL}, + { "FaceGeometricFactors_mesh_set", _wrap_FaceGeometricFactors_mesh_set, METH_VARARGS, "FaceGeometricFactors_mesh_set(FaceGeometricFactors self, Mesh mesh)"}, + { "FaceGeometricFactors_mesh_get", _wrap_FaceGeometricFactors_mesh_get, METH_O, "FaceGeometricFactors_mesh_get(FaceGeometricFactors self) -> Mesh"}, + { "FaceGeometricFactors_IntRule_set", _wrap_FaceGeometricFactors_IntRule_set, METH_VARARGS, "FaceGeometricFactors_IntRule_set(FaceGeometricFactors self, IntegrationRule IntRule)"}, + { "FaceGeometricFactors_IntRule_get", _wrap_FaceGeometricFactors_IntRule_get, METH_O, "FaceGeometricFactors_IntRule_get(FaceGeometricFactors self) -> IntegrationRule"}, + { "FaceGeometricFactors_computed_factors_set", _wrap_FaceGeometricFactors_computed_factors_set, METH_VARARGS, "FaceGeometricFactors_computed_factors_set(FaceGeometricFactors self, int computed_factors)"}, + { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, + { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, + { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, + { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, + { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, + { "FaceGeometricFactors_J_get", _wrap_FaceGeometricFactors_J_get, METH_O, "FaceGeometricFactors_J_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_detJ_set", _wrap_FaceGeometricFactors_detJ_set, METH_VARARGS, "FaceGeometricFactors_detJ_set(FaceGeometricFactors self, Vector detJ)"}, + { "FaceGeometricFactors_detJ_get", _wrap_FaceGeometricFactors_detJ_get, METH_O, "FaceGeometricFactors_detJ_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_normal_set", _wrap_FaceGeometricFactors_normal_set, METH_VARARGS, "FaceGeometricFactors_normal_set(FaceGeometricFactors self, Vector normal)"}, + { "FaceGeometricFactors_normal_get", _wrap_FaceGeometricFactors_normal_get, METH_O, "FaceGeometricFactors_normal_get(FaceGeometricFactors self) -> Vector"}, + { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, + { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, + { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "NodeExtrudeCoefficient_SetLayer(NodeExtrudeCoefficient self, int const l)"}, { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" "NodeExtrudeCoefficient_Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -29184,16 +31177,341 @@ static PyMethodDef SwigMethods[] = { { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, - { "named_ifgzstream_filename_set", _wrap_named_ifgzstream_filename_set, METH_VARARGS, "named_ifgzstream_filename_set(named_ifgzstream self, char const * filename)"}, - { "named_ifgzstream_filename_get", _wrap_named_ifgzstream_filename_get, METH_O, "named_ifgzstream_filename_get(named_ifgzstream self) -> char const *"}, - { "new_named_ifgzstream", _wrap_new_named_ifgzstream, METH_O, "new_named_ifgzstream(char const * mesh_name) -> named_ifgzstream"}, - { "delete_named_ifgzstream", _wrap_delete_named_ifgzstream, METH_O, "delete_named_ifgzstream(named_ifgzstream self)"}, - { "named_ifgzstream_swigregister", named_ifgzstream_swigregister, METH_O, NULL}, - { "named_ifgzstream_swiginit", named_ifgzstream_swiginit, METH_VARARGS, NULL}, + { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, + { "delete_intp", _wrap_delete_intp, METH_O, NULL}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_value", _wrap_intp_value, METH_O, NULL}, + { "intp_cast", _wrap_intp_cast, METH_O, NULL}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, + { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_value", _wrap_doublep_value, METH_O, NULL}, + { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "Mesh_attributes_get", _wrap_Mesh_attributes_get, METH_O, "Mesh_attributes_get(Mesh self) -> intArray"}, + { "Mesh_bdr_attributes_get", _wrap_Mesh_bdr_attributes_get, METH_O, "Mesh_bdr_attributes_get(Mesh self) -> intArray"}, + { "Mesh_NURBSext_set", _wrap_Mesh_NURBSext_set, METH_VARARGS, "Mesh_NURBSext_set(Mesh self, mfem::NURBSExtension * NURBSext)"}, + { "Mesh_NURBSext_get", _wrap_Mesh_NURBSext_get, METH_O, "Mesh_NURBSext_get(Mesh self) -> mfem::NURBSExtension *"}, + { "Mesh_ncmesh_set", _wrap_Mesh_ncmesh_set, METH_VARARGS, "Mesh_ncmesh_set(Mesh self, NCMesh ncmesh)"}, + { "Mesh_ncmesh_get", _wrap_Mesh_ncmesh_get, METH_O, "Mesh_ncmesh_get(Mesh self) -> NCMesh"}, + { "Mesh_geom_factors_set", _wrap_Mesh_geom_factors_set, METH_VARARGS, "Mesh_geom_factors_set(Mesh self, mfem::Array< mfem::GeometricFactors * > * geom_factors)"}, + { "Mesh_geom_factors_get", _wrap_Mesh_geom_factors_get, METH_O, "Mesh_geom_factors_get(Mesh self) -> mfem::Array< mfem::GeometricFactors * > *"}, + { "Mesh_face_geom_factors_set", _wrap_Mesh_face_geom_factors_set, METH_VARARGS, "Mesh_face_geom_factors_set(Mesh self, mfem::Array< mfem::FaceGeometricFactors * > * face_geom_factors)"}, + { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, + { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, + { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, + { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "NewElement(Mesh self, int geom) -> Element"}, + { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "AddSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "AddTri(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "AddTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "AddQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTet", _wrap_Mesh_AddTet, METH_VARARGS, "AddTet(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddWedge", _wrap_Mesh_AddWedge, METH_VARARGS, "AddWedge(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHex", _wrap_Mesh_AddHex, METH_VARARGS, "AddHex(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsTets", _wrap_Mesh_AddHexAsTets, METH_VARARGS, "AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsWedges", _wrap_Mesh_AddHexAsWedges, METH_VARARGS, "AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddElement", _wrap_Mesh_AddElement, METH_VARARGS, "AddElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrElement", _wrap_Mesh_AddBdrElement, METH_VARARGS, "AddBdrElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrSegment", _wrap_Mesh_AddBdrSegment, METH_VARARGS, "AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrTriangle", _wrap_Mesh_AddBdrTriangle, METH_VARARGS, "AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuad", _wrap_Mesh_AddBdrQuad, METH_VARARGS, "AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuadAsTriangles", _wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS, "AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_GenerateBoundaryElements", _wrap_Mesh_GenerateBoundaryElements, METH_O, "GenerateBoundaryElements(Mesh self)"}, + { "Mesh_FinalizeTriMesh", _wrap_Mesh_FinalizeTriMesh, METH_VARARGS, "FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeQuadMesh", _wrap_Mesh_FinalizeQuadMesh, METH_VARARGS, "FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTetMesh", _wrap_Mesh_FinalizeTetMesh, METH_VARARGS, "FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "FinalizeTopology(Mesh self, bool generate_bdr=True)"}, + { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, + { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "SetAttributes(Mesh self)"}, + { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "GetHilbertElementOrdering(Mesh self, intArray ordering)"}, + { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, + { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Clear(Mesh self)"}, + { "Mesh_MeshGenerator", _wrap_Mesh_MeshGenerator, METH_O, "MeshGenerator(Mesh self) -> int"}, + { "Mesh_GetNV", _wrap_Mesh_GetNV, METH_O, "GetNV(Mesh self) -> int"}, + { "Mesh_GetNE", _wrap_Mesh_GetNE, METH_O, "GetNE(Mesh self) -> int"}, + { "Mesh_GetNBE", _wrap_Mesh_GetNBE, METH_O, "GetNBE(Mesh self) -> int"}, + { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "GetNEdges(Mesh self) -> int"}, + { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "GetNFaces(Mesh self) -> int"}, + { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "GetNumFaces(Mesh self) -> int"}, + { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, + { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "ReduceInt(Mesh self, int value) -> long"}, + { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "GetGlobalNE(Mesh self) -> long"}, + { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "DeleteGeometricFactors(Mesh self)"}, + { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "EulerNumber(Mesh self) -> int"}, + { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "EulerNumber2D(Mesh self) -> int"}, + { "Mesh_Dimension", _wrap_Mesh_Dimension, METH_O, "Dimension(Mesh self) -> int"}, + { "Mesh_SpaceDimension", _wrap_Mesh_SpaceDimension, METH_O, "SpaceDimension(Mesh self) -> int"}, + { "Mesh_GetVertex", _wrap_Mesh_GetVertex, METH_VARARGS, "\n" + "GetVertex(Mesh self, int i) -> double const\n" + "GetVertex(Mesh self, int i) -> double *\n" + ""}, + { "Mesh_GetElementData", _wrap_Mesh_GetElementData, METH_VARARGS, "GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, + { "Mesh_GetBdrElementData", _wrap_Mesh_GetBdrElementData, METH_VARARGS, "GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, + { "Mesh_ChangeVertexDataOwnership", _wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS, "ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, + { "Mesh_GetElementsArray", _wrap_Mesh_GetElementsArray, METH_O, "GetElementsArray(Mesh self) -> mfem::Element const *const *"}, + { "Mesh_GetElement", _wrap_Mesh_GetElement, METH_VARARGS, "\n" + "GetElement(Mesh self, int i) -> Element\n" + "GetElement(Mesh self, int i) -> Element\n" + ""}, + { "Mesh_GetBdrElement", _wrap_Mesh_GetBdrElement, METH_VARARGS, "\n" + "GetBdrElement(Mesh self, int i) -> Element\n" + "GetBdrElement(Mesh self, int i) -> Element\n" + ""}, + { "Mesh_GetFace", _wrap_Mesh_GetFace, METH_VARARGS, "GetFace(Mesh self, int i) -> Element"}, + { "Mesh_GetFaceBaseGeometry", _wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS, "GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetElementBaseGeometry", _wrap_Mesh_GetElementBaseGeometry, METH_VARARGS, "GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetBdrElementBaseGeometry", _wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS, "GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_HasGeometry", _wrap_Mesh_HasGeometry, METH_VARARGS, "HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, + { "Mesh_GetNumGeometries", _wrap_Mesh_GetNumGeometries, METH_VARARGS, "GetNumGeometries(Mesh self, int dim) -> int"}, + { "Mesh_GetGeometries", _wrap_Mesh_GetGeometries, METH_VARARGS, "GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, + { "Mesh_GetElementVertices", _wrap_Mesh_GetElementVertices, METH_VARARGS, "GetElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetBdrElementVertices", _wrap_Mesh_GetBdrElementVertices, METH_VARARGS, "GetBdrElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetElementEdges", _wrap_Mesh_GetElementEdges, METH_VARARGS, "GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetBdrElementEdges", _wrap_Mesh_GetBdrElementEdges, METH_VARARGS, "GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetFaceEdges", _wrap_Mesh_GetFaceEdges, METH_VARARGS, "GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetFaceVertices", _wrap_Mesh_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetEdgeVertices", _wrap_Mesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetFaceEdgeTable", _wrap_Mesh_GetFaceEdgeTable, METH_O, "GetFaceEdgeTable(Mesh self) -> Table"}, + { "Mesh_GetEdgeVertexTable", _wrap_Mesh_GetEdgeVertexTable, METH_O, "GetEdgeVertexTable(Mesh self) -> Table"}, + { "Mesh_GetElementFaces", _wrap_Mesh_GetElementFaces, METH_VARARGS, "GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetBdrElementEdgeIndex", _wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS, "GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, + { "Mesh_GetBdrElementAdjacentElement", _wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS, "GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, + { "Mesh_GetElementType", _wrap_Mesh_GetElementType, METH_VARARGS, "GetElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetBdrElementType", _wrap_Mesh_GetBdrElementType, METH_VARARGS, "GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetPointMatrix", _wrap_Mesh_GetPointMatrix, METH_VARARGS, "GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetBdrPointMatrix", _wrap_Mesh_GetBdrPointMatrix, METH_VARARGS, "GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetTransformationFEforElementType", _wrap_Mesh_GetTransformationFEforElementType, METH_O, "GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, + { "Mesh_GetElementTransformation", _wrap_Mesh_GetElementTransformation, METH_VARARGS, "\n" + "GetElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" + "GetElementTransformation(Mesh self, int i) -> ElementTransformation\n" + "GetElementTransformation(Mesh self, int i, Vector nodes, IsoparametricTransformation ElTr)\n" + ""}, + { "Mesh_GetBdrElementTransformation", _wrap_Mesh_GetBdrElementTransformation, METH_VARARGS, "\n" + "GetBdrElementTransformation(Mesh self, int i) -> ElementTransformation\n" + "GetBdrElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" + ""}, + { "Mesh_GetLocalFaceTransformation", _wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS, "GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, + { "Mesh_GetFaceTransformation", _wrap_Mesh_GetFaceTransformation, METH_VARARGS, "\n" + "GetFaceTransformation(Mesh self, int i, IsoparametricTransformation FTr)\n" + "GetFaceTransformation(Mesh self, int FaceNo) -> ElementTransformation\n" + ""}, + { "Mesh_GetEdgeTransformation", _wrap_Mesh_GetEdgeTransformation, METH_VARARGS, "\n" + "GetEdgeTransformation(Mesh self, int i, IsoparametricTransformation EdTr)\n" + "GetEdgeTransformation(Mesh self, int EdgeNo) -> ElementTransformation\n" + ""}, + { "Mesh_GetFaceElementTransformations", _wrap_Mesh_GetFaceElementTransformations, METH_VARARGS, "GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, + { "Mesh_GetInteriorFaceTransformations", _wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS, "GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, + { "Mesh_GetBdrFaceTransformations", _wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS, "GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, + { "Mesh_FaceIsInterior", _wrap_Mesh_FaceIsInterior, METH_VARARGS, "FaceIsInterior(Mesh self, int FaceNo) -> bool"}, + { "Mesh_GetFaceElements", _wrap_Mesh_GetFaceElements, METH_VARARGS, "GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, + { "Mesh_GetFaceInfos", _wrap_Mesh_GetFaceInfos, METH_VARARGS, "GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, + { "Mesh_GetFaceGeometryType", _wrap_Mesh_GetFaceGeometryType, METH_VARARGS, "GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, + { "Mesh_GetFaceElementType", _wrap_Mesh_GetFaceElementType, METH_VARARGS, "GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, + { "Mesh_CheckElementOrientation", _wrap_Mesh_CheckElementOrientation, METH_VARARGS, "CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_CheckBdrElementOrientation", _wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS, "CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_GetAttribute", _wrap_Mesh_GetAttribute, METH_VARARGS, "GetAttribute(Mesh self, int i) -> int"}, + { "Mesh_SetAttribute", _wrap_Mesh_SetAttribute, METH_VARARGS, "SetAttribute(Mesh self, int i, int attr)"}, + { "Mesh_GetBdrAttribute", _wrap_Mesh_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(Mesh self, int i) -> int"}, + { "Mesh_ElementToElementTable", _wrap_Mesh_ElementToElementTable, METH_O, "ElementToElementTable(Mesh self) -> Table"}, + { "Mesh_ElementToFaceTable", _wrap_Mesh_ElementToFaceTable, METH_O, "ElementToFaceTable(Mesh self) -> Table"}, + { "Mesh_ElementToEdgeTable", _wrap_Mesh_ElementToEdgeTable, METH_O, "ElementToEdgeTable(Mesh self) -> Table"}, + { "Mesh_GetVertexToElementTable", _wrap_Mesh_GetVertexToElementTable, METH_O, "GetVertexToElementTable(Mesh self) -> Table"}, + { "Mesh_GetFaceToElementTable", _wrap_Mesh_GetFaceToElementTable, METH_O, "GetFaceToElementTable(Mesh self) -> Table"}, + { "Mesh_ReorientTetMesh", _wrap_Mesh_ReorientTetMesh, METH_O, "ReorientTetMesh(Mesh self)"}, + { "Mesh_CartesianPartitioning", _wrap_Mesh_CartesianPartitioning, METH_VARARGS, "CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, + { "Mesh_GeneratePartitioning", _wrap_Mesh_GeneratePartitioning, METH_VARARGS, "GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int"}, + { "Mesh_CheckPartitioning", _wrap_Mesh_CheckPartitioning, METH_VARARGS, "CheckPartitioning(Mesh self, int * partitioning)"}, + { "Mesh_CheckDisplacements", _wrap_Mesh_CheckDisplacements, METH_VARARGS, "CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, + { "Mesh_MoveVertices", _wrap_Mesh_MoveVertices, METH_VARARGS, "MoveVertices(Mesh self, Vector displacements)"}, + { "Mesh_GetVertices", _wrap_Mesh_GetVertices, METH_VARARGS, "GetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_SetVertices", _wrap_Mesh_SetVertices, METH_VARARGS, "SetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_GetNode", _wrap_Mesh_GetNode, METH_VARARGS, "GetNode(Mesh self, int i, double * coord)"}, + { "Mesh_SetNode", _wrap_Mesh_SetNode, METH_VARARGS, "SetNode(Mesh self, int i, double const * coord)"}, + { "Mesh_MoveNodes", _wrap_Mesh_MoveNodes, METH_VARARGS, "MoveNodes(Mesh self, Vector displacements)"}, + { "Mesh_SetNodes", _wrap_Mesh_SetNodes, METH_VARARGS, "SetNodes(Mesh self, Vector node_coord)"}, + { "Mesh_OwnsNodes", _wrap_Mesh_OwnsNodes, METH_O, "OwnsNodes(Mesh self) -> bool"}, + { "Mesh_SetNodesOwner", _wrap_Mesh_SetNodesOwner, METH_VARARGS, "SetNodesOwner(Mesh self, bool nodes_owner)"}, + { "Mesh_NewNodes", _wrap_Mesh_NewNodes, METH_VARARGS, "NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SwapNodes", _wrap_Mesh_SwapNodes, METH_VARARGS, "SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, + { "Mesh_GetNodes", _wrap_Mesh_GetNodes, METH_VARARGS, "\n" + "GetNodes(Mesh self, Vector node_coord)\n" + "GetNodes(Mesh self) -> GridFunction\n" + "GetNodes(Mesh self) -> GridFunction\n" + "GetNodes(Mesh self, GridFunction nodes)\n" + ""}, + { "Mesh_SetNodalFESpace", _wrap_Mesh_SetNodalFESpace, METH_VARARGS, "SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, + { "Mesh_SetNodalGridFunction", _wrap_Mesh_SetNodalGridFunction, METH_VARARGS, "SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_GetNodalFESpace", _wrap_Mesh_GetNodalFESpace, METH_O, "GetNodalFESpace(Mesh self) -> FiniteElementSpace"}, + { "Mesh_EnsureNodes", _wrap_Mesh_EnsureNodes, METH_O, "EnsureNodes(Mesh self)"}, + { "Mesh_SetCurvature", _wrap_Mesh_SetCurvature, METH_VARARGS, "SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "Mesh_UniformRefinement", _wrap_Mesh_UniformRefinement, METH_VARARGS, "UniformRefinement(Mesh self, int ref_algo=0)"}, + { "Mesh_GeneralRefinement", _wrap_Mesh_GeneralRefinement, METH_VARARGS, "\n" + "GeneralRefinement(Mesh self, mfem::Array< mfem::Refinement > const & refinements, int nonconforming=-1, int nc_limit=0)\n" + "GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0)\n" + ""}, + { "Mesh_RandomRefinement", _wrap_Mesh_RandomRefinement, METH_VARARGS, "RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, + { "Mesh_RefineAtVertex", _wrap_Mesh_RefineAtVertex, METH_VARARGS, "RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, + { "Mesh_RefineByError", _wrap_Mesh_RefineByError, METH_VARARGS, "\n" + "RefineByError(Mesh self, doubleArray elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" + "RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" + ""}, + { "Mesh_DerefineByError", _wrap_Mesh_DerefineByError, METH_VARARGS, "\n" + "DerefineByError(Mesh self, doubleArray elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" + "DerefineByError(Mesh self, Vector elem_error, double threshold, int nc_limit=0, int op=1) -> bool\n" + ""}, + { "Mesh_KnotInsert", _wrap_Mesh_KnotInsert, METH_VARARGS, "\n" + "KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" + "KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" + ""}, + { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, + { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, + { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Conforming(Mesh self) -> bool"}, + { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Nonconforming(Mesh self) -> bool"}, + { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, + { "Mesh_GetLastOperation", _wrap_Mesh_GetLastOperation, METH_O, "GetLastOperation(Mesh self) -> mfem::Mesh::Operation"}, + { "Mesh_GetSequence", _wrap_Mesh_GetSequence, METH_O, "GetSequence(Mesh self) -> long"}, + { "Mesh_PrintVTU", _wrap_Mesh_PrintVTU, METH_VARARGS, "\n" + "PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + "PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" + ""}, + { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "GetElementColoring(Mesh self, intArray colors, int el0=0)"}, + { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, + { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, + { "Mesh_PrintSurfaces", _wrap_Mesh_PrintSurfaces, METH_VARARGS, "PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, + { "Mesh_ScaleSubdomains", _wrap_Mesh_ScaleSubdomains, METH_VARARGS, "ScaleSubdomains(Mesh self, double sf)"}, + { "Mesh_ScaleElements", _wrap_Mesh_ScaleElements, METH_VARARGS, "ScaleElements(Mesh self, double sf)"}, + { "Mesh_Transform", _wrap_Mesh_Transform, METH_VARARGS, "\n" + "Transform(Mesh self, void (*)(mfem::Vector const &,mfem::Vector &) f)\n" + "Transform(Mesh self, VectorCoefficient deformation)\n" + ""}, + { "Mesh_RemoveUnusedVertices", _wrap_Mesh_RemoveUnusedVertices, METH_O, "RemoveUnusedVertices(Mesh self)"}, + { "Mesh_RemoveInternalBoundaries", _wrap_Mesh_RemoveInternalBoundaries, METH_O, "RemoveInternalBoundaries(Mesh self)"}, + { "Mesh_GetElementSize", _wrap_Mesh_GetElementSize, METH_VARARGS, "\n" + "GetElementSize(Mesh self, int i, int type=0) -> double\n" + "GetElementSize(Mesh self, int i, Vector dir) -> double\n" + ""}, + { "Mesh_GetElementVolume", _wrap_Mesh_GetElementVolume, METH_VARARGS, "GetElementVolume(Mesh self, int i) -> double"}, + { "Mesh_GetBoundingBox", _wrap_Mesh_GetBoundingBox, METH_VARARGS, "GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, + { "Mesh_GetCharacteristics", _wrap_Mesh_GetCharacteristics, METH_VARARGS, "GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, + { "Mesh_PrintElementsByGeometry", _wrap_Mesh_PrintElementsByGeometry, METH_VARARGS, "PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, + { "Mesh_PrintCharacteristics", _wrap_Mesh_PrintCharacteristics, METH_VARARGS, "PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, + { "Mesh_FindPoints", _wrap_Mesh_FindPoints, METH_VARARGS, "FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "delete_Mesh", _wrap_delete_Mesh, METH_O, "delete_Mesh(Mesh self)"}, + { "new_Mesh", _wrap_new_Mesh, METH_VARARGS, "\n" + "Mesh()\n" + "Mesh(Mesh mesh, bool copy_nodes=True)\n" + "Mesh(double * vertices, int num_vertices, int * element_indices, mfem::Geometry::Type element_type, int * element_attributes, int num_elements, int * boundary_indices, mfem::Geometry::Type boundary_type, int * boundary_attributes, int num_boundary_elements, int dimension, int space_dimension=-1)\n" + "Mesh(int _Dim, int NVert, int NElem, int NBdrElem=0, int _spaceDim=-1)\n" + "Mesh(int nx, int ny, int nz, mfem::Element::Type type, bool generate_edges=False, double sx=1.0, double sy=1.0, double sz=1.0, bool sfc_ordering=True)\n" + "Mesh(int nx, int ny, mfem::Element::Type type, bool generate_edges=False, double sx=1.0, double sy=1.0, bool sfc_ordering=True)\n" + "Mesh(int n, double sx=1.0)\n" + "Mesh(char const * filename, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + "Mesh(std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" + "Mesh(mfem::Mesh *[] mesh_array, int num_pieces)\n" + "Mesh(Mesh orig_mesh, int ref_factor, int ref_type)\n" + "Mesh(int nx, int ny, int nz, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0, double sz=1.0)\n" + "Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0)\n" + ""}, + { "Mesh_PrintToFile", _wrap_Mesh_PrintToFile, METH_VARARGS, "PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, + { "Mesh_GetAttributeArray", _wrap_Mesh_GetAttributeArray, METH_O, "GetAttributeArray(Mesh self) -> PyObject *"}, + { "Mesh_GetVertexArray", _wrap_Mesh_GetVertexArray, METH_VARARGS, "GetVertexArray(Mesh self, int i) -> PyObject *"}, + { "Mesh_GetBdrElementFace", _wrap_Mesh_GetBdrElementFace, METH_VARARGS, "\n" + "GetBdrElementFace(Mesh self, int i, int * arg3, int * arg4)\n" + "GetBdrElementFace(Mesh self, int i) -> PyObject *\n" + ""}, + { "Mesh_GetBdrAttributeArray", _wrap_Mesh_GetBdrAttributeArray, METH_O, "GetBdrAttributeArray(Mesh self) -> PyObject *"}, + { "Mesh_GetBdrArray", _wrap_Mesh_GetBdrArray, METH_VARARGS, "GetBdrArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetDomainArray", _wrap_Mesh_GetDomainArray, METH_VARARGS, "GetDomainArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_PrintInfo", _wrap_Mesh_PrintInfo, METH_VARARGS, "\n" + "PrintInfo(Mesh self, std::ostream & out=mfem::out)\n" + "PrintInfo(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_Print", _wrap_Mesh_Print, METH_VARARGS, "\n" + "Print(Mesh self, std::ostream & out=mfem::out)\n" + "Print(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_PrintXG", _wrap_Mesh_PrintXG, METH_VARARGS, "\n" + "PrintXG(Mesh self, std::ostream & out=mfem::out)\n" + "PrintXG(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_PrintVTK", _wrap_Mesh_PrintVTK, METH_VARARGS, "\n" + "PrintVTK(Mesh self, std::ostream & out)\n" + "PrintVTK(Mesh self, std::ostream & out, int ref, int field_data=0)\n" + "PrintVTK(Mesh self, char const * file, int precision=8)\n" + ""}, + { "Mesh_swigregister", Mesh_swigregister, METH_O, NULL}, + { "Mesh_swiginit", Mesh_swiginit, METH_VARARGS, NULL}, + { "__lshift__", _wrap___lshift__, METH_VARARGS, "\n" + "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" + "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream\n" + "__lshift__(std::ostream & out, Mesh mesh) -> std::ostream &\n" + ""}, + { "GeometricFactors_mesh_set", _wrap_GeometricFactors_mesh_set, METH_VARARGS, "GeometricFactors_mesh_set(GeometricFactors self, Mesh mesh)"}, + { "GeometricFactors_mesh_get", _wrap_GeometricFactors_mesh_get, METH_O, "GeometricFactors_mesh_get(GeometricFactors self) -> Mesh"}, + { "GeometricFactors_IntRule_set", _wrap_GeometricFactors_IntRule_set, METH_VARARGS, "GeometricFactors_IntRule_set(GeometricFactors self, IntegrationRule IntRule)"}, + { "GeometricFactors_IntRule_get", _wrap_GeometricFactors_IntRule_get, METH_O, "GeometricFactors_IntRule_get(GeometricFactors self) -> IntegrationRule"}, + { "GeometricFactors_computed_factors_set", _wrap_GeometricFactors_computed_factors_set, METH_VARARGS, "GeometricFactors_computed_factors_set(GeometricFactors self, int computed_factors)"}, + { "GeometricFactors_computed_factors_get", _wrap_GeometricFactors_computed_factors_get, METH_O, "GeometricFactors_computed_factors_get(GeometricFactors self) -> int"}, + { "new_GeometricFactors", _wrap_new_GeometricFactors, METH_VARARGS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, + { "GeometricFactors_X_set", _wrap_GeometricFactors_X_set, METH_VARARGS, "GeometricFactors_X_set(GeometricFactors self, Vector X)"}, + { "GeometricFactors_X_get", _wrap_GeometricFactors_X_get, METH_O, "GeometricFactors_X_get(GeometricFactors self) -> Vector"}, + { "GeometricFactors_J_set", _wrap_GeometricFactors_J_set, METH_VARARGS, "GeometricFactors_J_set(GeometricFactors self, Vector J)"}, + { "GeometricFactors_J_get", _wrap_GeometricFactors_J_get, METH_O, "GeometricFactors_J_get(GeometricFactors self) -> Vector"}, + { "GeometricFactors_detJ_set", _wrap_GeometricFactors_detJ_set, METH_VARARGS, "GeometricFactors_detJ_set(GeometricFactors self, Vector detJ)"}, + { "GeometricFactors_detJ_get", _wrap_GeometricFactors_detJ_get, METH_O, "GeometricFactors_detJ_get(GeometricFactors self) -> Vector"}, + { "delete_GeometricFactors", _wrap_delete_GeometricFactors, METH_O, "delete_GeometricFactors(GeometricFactors self)"}, + { "GeometricFactors_swigregister", GeometricFactors_swigregister, METH_O, NULL}, + { "GeometricFactors_swiginit", GeometricFactors_swiginit, METH_VARARGS, NULL}, + { "FaceGeometricFactors_mesh_set", _wrap_FaceGeometricFactors_mesh_set, METH_VARARGS, "FaceGeometricFactors_mesh_set(FaceGeometricFactors self, Mesh mesh)"}, + { "FaceGeometricFactors_mesh_get", _wrap_FaceGeometricFactors_mesh_get, METH_O, "FaceGeometricFactors_mesh_get(FaceGeometricFactors self) -> Mesh"}, + { "FaceGeometricFactors_IntRule_set", _wrap_FaceGeometricFactors_IntRule_set, METH_VARARGS, "FaceGeometricFactors_IntRule_set(FaceGeometricFactors self, IntegrationRule IntRule)"}, + { "FaceGeometricFactors_IntRule_get", _wrap_FaceGeometricFactors_IntRule_get, METH_O, "FaceGeometricFactors_IntRule_get(FaceGeometricFactors self) -> IntegrationRule"}, + { "FaceGeometricFactors_computed_factors_set", _wrap_FaceGeometricFactors_computed_factors_set, METH_VARARGS, "FaceGeometricFactors_computed_factors_set(FaceGeometricFactors self, int computed_factors)"}, + { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, + { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, + { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, + { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, + { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, + { "FaceGeometricFactors_J_get", _wrap_FaceGeometricFactors_J_get, METH_O, "FaceGeometricFactors_J_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_detJ_set", _wrap_FaceGeometricFactors_detJ_set, METH_VARARGS, "FaceGeometricFactors_detJ_set(FaceGeometricFactors self, Vector detJ)"}, + { "FaceGeometricFactors_detJ_get", _wrap_FaceGeometricFactors_detJ_get, METH_O, "FaceGeometricFactors_detJ_get(FaceGeometricFactors self) -> Vector"}, + { "FaceGeometricFactors_normal_set", _wrap_FaceGeometricFactors_normal_set, METH_VARARGS, "FaceGeometricFactors_normal_set(FaceGeometricFactors self, Vector normal)"}, + { "FaceGeometricFactors_normal_get", _wrap_FaceGeometricFactors_normal_get, METH_O, "FaceGeometricFactors_normal_get(FaceGeometricFactors self) -> Vector"}, + { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, + { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, + { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, + { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "SetLayer(NodeExtrudeCoefficient self, int const l)"}, + { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" + "Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + "Eval(NodeExtrudeCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" + "Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" + ""}, + { "delete_NodeExtrudeCoefficient", _wrap_delete_NodeExtrudeCoefficient, METH_O, "delete_NodeExtrudeCoefficient(NodeExtrudeCoefficient self)"}, + { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, + { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, + { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, + { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; @@ -29266,12 +31584,6 @@ static void *_p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformatio static void *_p_mfem__IntegrationRuleTo_p_mfem__ArrayT_mfem__IntegrationPoint_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Array< mfem::IntegrationPoint > *) ((mfem::IntegrationRule *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -29305,6 +31617,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -29320,6 +31635,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -29488,6 +31806,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -29531,10 +31855,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -29558,6 +31882,7 @@ static void *_p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NURBSFiniteElement *) ((mfem::NURBS3DFiniteElement *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; @@ -29567,16 +31892,19 @@ static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_double_t = {"_p_mfem__ArrayT_double_t", "mfem::Array< double > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t = {"_p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t", "mfem::Array< mfem::FaceGeometricFactors * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__GeometricFactors_p_t = {"_p_mfem__ArrayT_mfem__GeometricFactors_p_t", "mfem::Array< mfem::GeometricFactors * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__Geometry__Type_t = {"_p_mfem__ArrayT_mfem__Geometry__Type_t", "mfem::Array< enum mfem::Geometry::Type > *|mfem::Array< mfem::Geometry::Type > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__IntegrationPoint_t = {"_p_mfem__ArrayT_mfem__IntegrationPoint_t", "mfem::Array< mfem::IntegrationPoint > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__KnotVector_p_t = {"_p_mfem__ArrayT_mfem__KnotVector_p_t", "mfem::Array< mfem::KnotVector * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_mfem__Refinement_t = {"_p_mfem__ArrayT_mfem__Refinement_t", "mfem::Array< mfem::Refinement > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_mfem__Vector_p_t = {"_p_mfem__ArrayT_mfem__Vector_p_t", "mfem::Array< mfem::Vector * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__CoarseFineTransformations = {"_p_mfem__CoarseFineTransformations", "mfem::CoarseFineTransformations *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mfem::DenseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Element = {"_p_mfem__Element", "mfem::Element *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ElementTransformation = {"_p_mfem__ElementTransformation", "mfem::ElementTransformation *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FaceElementTransformations = {"_p_mfem__FaceElementTransformations", "mfem::FaceElementTransformations *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FaceGeometricFactors = {"_p_mfem__FaceGeometricFactors", "mfem::FaceGeometricFactors *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FiniteElement = {"_p_mfem__FiniteElement", "mfem::FiniteElement *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__P0HexFiniteElement = {"_p_mfem__P0HexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LagrangeHexFiniteElement = {"_p_mfem__LagrangeHexFiniteElement", 0, 0, 0, 0, 0}; @@ -29593,13 +31921,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -29611,6 +31937,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -29652,6 +31980,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -29708,7 +32038,6 @@ static swig_type_info _swigt__p_mfem__VectorArrayCoefficient = {"_p_mfem__Vector static swig_type_info _swigt__p_mfem__VectorFunctionCoefficient = {"_p_mfem__VectorFunctionCoefficient", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__VectorConstantCoefficient = {"_p_mfem__VectorConstantCoefficient", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Vertex = {"_p_mfem__Vertex", "mfem::Vertex *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_mfem__named_ifgzstream = {"_p_mfem__named_ifgzstream", "mfem::named_ifgzstream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__Element = {"_p_p_mfem__Element", "mfem::Element **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__GridFunction = {"_p_p_mfem__GridFunction", "mfem::GridFunction **", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__Mesh = {"_p_p_mfem__Mesh", "mfem::Mesh **", 0, 0, (void*)0, 0}; @@ -29717,11 +32046,13 @@ static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*) static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_doublep, @@ -29731,11 +32062,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_intp, &_swigt__p_mfem__ArrayT_double_t, &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, &_swigt__p_mfem__ArrayT_mfem__GeometricFactors_p_t, &_swigt__p_mfem__ArrayT_mfem__Geometry__Type_t, &_swigt__p_mfem__ArrayT_mfem__IntegrationPoint_t, &_swigt__p_mfem__ArrayT_mfem__KnotVector_p_t, &_swigt__p_mfem__ArrayT_mfem__Refinement_t, + &_swigt__p_mfem__ArrayT_mfem__Vector_p_t, &_swigt__p_mfem__BiCubic2DFiniteElement, &_swigt__p_mfem__BiCubic3DFiniteElement, &_swigt__p_mfem__BiLinear2DFiniteElement, @@ -29754,6 +32087,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__Element, &_swigt__p_mfem__ElementTransformation, &_swigt__p_mfem__FaceElementTransformations, + &_swigt__p_mfem__FaceGeometricFactors, &_swigt__p_mfem__FiniteElement, &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__GaussBiLinear2DFiniteElement, @@ -29769,6 +32103,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -29871,8 +32206,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__VectorPyCoefficientBase, &_swigt__p_mfem__VectorRestrictedCoefficient, &_swigt__p_mfem__VectorSumCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_mfem__Vertex, - &_swigt__p_mfem__named_ifgzstream, &_swigt__p_p_mfem__Element, &_swigt__p_p_mfem__GridFunction, &_swigt__p_p_mfem__Mesh, @@ -29881,11 +32216,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_seg_t, &_swigt__p_std__istream, &_swigt__p_std__ostream, + &_swigt__p_std__string, &_swigt__p_tet_t, &_swigt__p_tri_t, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0}, {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; @@ -29895,16 +32232,19 @@ static swig_cast_info _swigc__p_int[] = { {&_swigt__p_intp, _p_intpTo_p_int, 0, static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_double_t[] = { {&_swigt__p_mfem__ArrayT_double_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__GeometricFactors_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__GeometricFactors_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__Geometry__Type_t[] = { {&_swigt__p_mfem__ArrayT_mfem__Geometry__Type_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__IntegrationPoint_t[] = { {&_swigt__p_mfem__ArrayT_mfem__IntegrationPoint_t, 0, 0, 0}, {&_swigt__p_mfem__IntegrationRule, _p_mfem__IntegrationRuleTo_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__KnotVector_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__KnotVector_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_mfem__Refinement_t[] = { {&_swigt__p_mfem__ArrayT_mfem__Refinement_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_mfem__Vector_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__Vector_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CoarseFineTransformations[] = { {&_swigt__p_mfem__CoarseFineTransformations, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Element[] = { {&_swigt__p_mfem__Element, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementTransformation[] = { {&_swigt__p_mfem__ElementTransformation, 0, 0, 0}, {&_swigt__p_mfem__IsoparametricTransformation, _p_mfem__IsoparametricTransformationTo_p_mfem__ElementTransformation, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FaceElementTransformations[] = { {&_swigt__p_mfem__FaceElementTransformations, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FaceGeometricFactors[] = { {&_swigt__p_mfem__FaceGeometricFactors, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0HexFiniteElement[] = {{&_swigt__p_mfem__P0HexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LagrangeHexFiniteElement[] = {{&_swigt__p_mfem__LagrangeHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RefinedLinear1DFiniteElement[] = {{&_swigt__p_mfem__RefinedLinear1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -29920,13 +32260,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -29938,6 +32276,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -29979,6 +32319,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -30002,7 +32344,7 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GeometricFactors[] = { {&_swigt__p_mfem__GeometricFactors, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -30036,7 +32378,6 @@ static swig_cast_info _swigc__p_mfem__VectorFunctionCoefficient[] = {{&_swigt__p static swig_cast_info _swigc__p_mfem__VectorConstantCoefficient[] = {{&_swigt__p_mfem__VectorConstantCoefficient, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__VectorCoefficient[] = { {&_swigt__p_mfem__VectorPyCoefficientBase, _p_mfem__VectorPyCoefficientBaseTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__NodeExtrudeCoefficient, _p_mfem__NodeExtrudeCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__MatVecCoefficient, _p_mfem__MatVecCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorCrossProductCoefficient, _p_mfem__VectorCrossProductCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__ScalarVectorProductCoefficient, _p_mfem__ScalarVectorProductCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorSumCoefficient, _p_mfem__VectorSumCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorRestrictedCoefficient, _p_mfem__VectorRestrictedCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorDeltaCoefficient, _p_mfem__VectorDeltaCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__CurlGridFunctionCoefficient, _p_mfem__CurlGridFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__GradientGridFunctionCoefficient, _p_mfem__GradientGridFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorGridFunctionCoefficient, _p_mfem__VectorGridFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorArrayCoefficient, _p_mfem__VectorArrayCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorFunctionCoefficient, _p_mfem__VectorFunctionCoefficientTo_p_mfem__VectorCoefficient, 0, 0}, {&_swigt__p_mfem__VectorCoefficient, 0, 0, 0}, {&_swigt__p_mfem__VectorConstantCoefficient, _p_mfem__VectorConstantCoefficientTo_p_mfem__VectorCoefficient, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vertex[] = { {&_swigt__p_mfem__Vertex, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__named_ifgzstream[] = { {&_swigt__p_mfem__named_ifgzstream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Element[] = { {&_swigt__p_p_mfem__Element, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__GridFunction[] = { {&_swigt__p_p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Mesh[] = { {&_swigt__p_p_mfem__Mesh, 0, 0, 0},{0, 0, 0, 0}}; @@ -30045,11 +32386,13 @@ static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0 static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_doublep, @@ -30059,11 +32402,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_intp, _swigc__p_mfem__ArrayT_double_t, _swigc__p_mfem__ArrayT_int_t, + _swigc__p_mfem__ArrayT_mfem__FaceGeometricFactors_p_t, _swigc__p_mfem__ArrayT_mfem__GeometricFactors_p_t, _swigc__p_mfem__ArrayT_mfem__Geometry__Type_t, _swigc__p_mfem__ArrayT_mfem__IntegrationPoint_t, _swigc__p_mfem__ArrayT_mfem__KnotVector_p_t, _swigc__p_mfem__ArrayT_mfem__Refinement_t, + _swigc__p_mfem__ArrayT_mfem__Vector_p_t, _swigc__p_mfem__BiCubic2DFiniteElement, _swigc__p_mfem__BiCubic3DFiniteElement, _swigc__p_mfem__BiLinear2DFiniteElement, @@ -30082,6 +32427,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__Element, _swigc__p_mfem__ElementTransformation, _swigc__p_mfem__FaceElementTransformations, + _swigc__p_mfem__FaceGeometricFactors, _swigc__p_mfem__FiniteElement, _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__GaussBiLinear2DFiniteElement, @@ -30097,6 +32443,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -30199,8 +32546,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__VectorPyCoefficientBase, _swigc__p_mfem__VectorRestrictedCoefficient, _swigc__p_mfem__VectorSumCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_mfem__Vertex, - _swigc__p_mfem__named_ifgzstream, _swigc__p_p_mfem__Element, _swigc__p_p_mfem__GridFunction, _swigc__p_p_mfem__Mesh, @@ -30209,6 +32556,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_seg_t, _swigc__p_std__istream, _swigc__p_std__ostream, + _swigc__p_std__string, _swigc__p_tet_t, _swigc__p_tri_t, }; @@ -30943,6 +33291,8 @@ SWIG_init(void) { import_array(); + SWIG_Python_SetConstant(d, "FaceType_Interior",SWIG_From_int(static_cast< int >(mfem::FaceType::Interior))); + SWIG_Python_SetConstant(d, "FaceType_Boundary",SWIG_From_int(static_cast< int >(mfem::FaceType::Boundary))); SWIG_Python_SetConstant(d, "Mesh_NONE",SWIG_From_int(static_cast< int >(mfem::Mesh::NONE))); SWIG_Python_SetConstant(d, "Mesh_REFINE",SWIG_From_int(static_cast< int >(mfem::Mesh::REFINE))); SWIG_Python_SetConstant(d, "Mesh_DEREFINE",SWIG_From_int(static_cast< int >(mfem::Mesh::DEREFINE))); @@ -30962,6 +33312,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "GeometricFactors_COORDINATES",SWIG_From_int(static_cast< int >(mfem::GeometricFactors::COORDINATES))); SWIG_Python_SetConstant(d, "GeometricFactors_JACOBIANS",SWIG_From_int(static_cast< int >(mfem::GeometricFactors::JACOBIANS))); SWIG_Python_SetConstant(d, "GeometricFactors_DETERMINANTS",SWIG_From_int(static_cast< int >(mfem::GeometricFactors::DETERMINANTS))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_COORDINATES",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::COORDINATES))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_JACOBIANS",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::JACOBIANS))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_DETERMINANTS",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::DETERMINANTS))); + SWIG_Python_SetConstant(d, "FaceGeometricFactors_NORMALS",SWIG_From_int(static_cast< int >(mfem::FaceGeometricFactors::NORMALS))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_ser/ncmesh.py b/mfem/_ser/ncmesh.py index 650836cf..980aded9 100644 --- a/mfem/_ser/ncmesh.py +++ b/mfem/_ser/ncmesh.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _ncmesh.SWIG_PyInstanceMethod_New +_swig_new_static_method = _ncmesh.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -77,19 +80,23 @@ def __init__(self): def assign(self, value): r"""assign(intp self, int value)""" return _ncmesh.intp_assign(self, value) + assign = _swig_new_instance_method(_ncmesh.intp_assign) def value(self): r"""value(intp self) -> int""" return _ncmesh.intp_value(self) + value = _swig_new_instance_method(_ncmesh.intp_value) def cast(self): r"""cast(intp self) -> int *""" return _ncmesh.intp_cast(self) + cast = _swig_new_instance_method(_ncmesh.intp_cast) @staticmethod def frompointer(t): r"""frompointer(int * t) -> intp""" return _ncmesh.intp_frompointer(t) + frompointer = _swig_new_static_method(_ncmesh.intp_frompointer) # Register intp in _ncmesh: _ncmesh.intp_swigregister(intp) @@ -97,6 +104,7 @@ def frompointer(t): def intp_frompointer(t): r"""intp_frompointer(int * t) -> intp""" return _ncmesh.intp_frompointer(t) +intp_frompointer = _ncmesh.intp_frompointer class doublep(object): r"""Proxy of C++ doublep class.""" @@ -112,19 +120,23 @@ def __init__(self): def assign(self, value): r"""assign(doublep self, double value)""" return _ncmesh.doublep_assign(self, value) + assign = _swig_new_instance_method(_ncmesh.doublep_assign) def value(self): r"""value(doublep self) -> double""" return _ncmesh.doublep_value(self) + value = _swig_new_instance_method(_ncmesh.doublep_value) def cast(self): r"""cast(doublep self) -> double *""" return _ncmesh.doublep_cast(self) + cast = _swig_new_instance_method(_ncmesh.doublep_cast) @staticmethod def frompointer(t): r"""frompointer(double * t) -> doublep""" return _ncmesh.doublep_frompointer(t) + frompointer = _swig_new_static_method(_ncmesh.doublep_frompointer) # Register doublep in _ncmesh: _ncmesh.doublep_swigregister(doublep) @@ -132,6 +144,7 @@ def frompointer(t): def doublep_frompointer(t): r"""doublep_frompointer(double * t) -> doublep""" return _ncmesh.doublep_frompointer(t) +doublep_frompointer = _ncmesh.doublep_frompointer import mfem._ser.mesh import mfem._ser.matrix @@ -151,12 +164,14 @@ def doublep_frompointer(t): import mfem._ser.fe_coll import mfem._ser.lininteg import mfem._ser.handle -import mfem._ser.bilininteg -import mfem._ser.linearform +import mfem._ser.restriction import mfem._ser.element import mfem._ser.table import mfem._ser.hash +import mfem._ser.bilininteg +import mfem._ser.linearform import mfem._ser.vertex +import mfem._ser.vtk class Refinement(object): r"""Proxy of C++ mfem::Refinement class.""" @@ -200,24 +215,28 @@ class CoarseFineTransformations(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - point_matrices = property(_ncmesh.CoarseFineTransformations_point_matrices_get, _ncmesh.CoarseFineTransformations_point_matrices_set, doc=r"""point_matrices : std::map<(mfem::Geometry::Type,mfem::DenseTensor)>""") + point_matrices = property(_ncmesh.CoarseFineTransformations_point_matrices_get, _ncmesh.CoarseFineTransformations_point_matrices_set, doc=r"""point_matrices : a(mfem::Geometry::NumGeom).mfem::DenseTensor""") embeddings = property(_ncmesh.CoarseFineTransformations_embeddings_get, doc=r"""embeddings : mfem::Array<(mfem::Embedding)>""") - def GetPointMatrices(self, geom): - r"""GetPointMatrices(CoarseFineTransformations self, mfem::Geometry::Type geom) -> DenseTensor""" - return _ncmesh.CoarseFineTransformations_GetPointMatrices(self, geom) - def GetCoarseToFineMap(self, fine_mesh, coarse_to_fine, coarse_to_ref_type, ref_type_to_matrix, ref_type_to_geom): r"""GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)""" return _ncmesh.CoarseFineTransformations_GetCoarseToFineMap(self, fine_mesh, coarse_to_fine, coarse_to_ref_type, ref_type_to_matrix, ref_type_to_geom) + GetCoarseToFineMap = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_GetCoarseToFineMap) def Clear(self): r"""Clear(CoarseFineTransformations self)""" return _ncmesh.CoarseFineTransformations_Clear(self) + Clear = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_Clear) + + def IsInitialized(self): + r"""IsInitialized(CoarseFineTransformations self) -> bool""" + return _ncmesh.CoarseFineTransformations_IsInitialized(self) + IsInitialized = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_IsInitialized) def MemoryUsage(self): r"""MemoryUsage(CoarseFineTransformations self) -> long""" return _ncmesh.CoarseFineTransformations_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_ncmesh.CoarseFineTransformations_MemoryUsage) def __init__(self): r"""__init__(CoarseFineTransformations self) -> CoarseFineTransformations""" @@ -244,140 +263,189 @@ def __init__(self, *args): def Dimension(self): r"""Dimension(NCMesh self) -> int""" return _ncmesh.NCMesh_Dimension(self) + Dimension = _swig_new_instance_method(_ncmesh.NCMesh_Dimension) def SpaceDimension(self): r"""SpaceDimension(NCMesh self) -> int""" return _ncmesh.NCMesh_SpaceDimension(self) + SpaceDimension = _swig_new_instance_method(_ncmesh.NCMesh_SpaceDimension) def GetNVertices(self): r"""GetNVertices(NCMesh self) -> int""" return _ncmesh.NCMesh_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_ncmesh.NCMesh_GetNVertices) def GetNEdges(self): r"""GetNEdges(NCMesh self) -> int""" return _ncmesh.NCMesh_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_ncmesh.NCMesh_GetNEdges) def GetNFaces(self): r"""GetNFaces(NCMesh self) -> int""" return _ncmesh.NCMesh_GetNFaces(self) + GetNFaces = _swig_new_instance_method(_ncmesh.NCMesh_GetNFaces) def Refine(self, refinements): r"""Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)""" return _ncmesh.NCMesh_Refine(self, refinements) + Refine = _swig_new_instance_method(_ncmesh.NCMesh_Refine) def LimitNCLevel(self, max_nc_level): r"""LimitNCLevel(NCMesh self, int max_nc_level)""" return _ncmesh.NCMesh_LimitNCLevel(self, max_nc_level) + LimitNCLevel = _swig_new_instance_method(_ncmesh.NCMesh_LimitNCLevel) def GetDerefinementTable(self): r"""GetDerefinementTable(NCMesh self) -> Table""" return _ncmesh.NCMesh_GetDerefinementTable(self) + GetDerefinementTable = _swig_new_instance_method(_ncmesh.NCMesh_GetDerefinementTable) def CheckDerefinementNCLevel(self, deref_table, level_ok, max_nc_level): r"""CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)""" return _ncmesh.NCMesh_CheckDerefinementNCLevel(self, deref_table, level_ok, max_nc_level) + CheckDerefinementNCLevel = _swig_new_instance_method(_ncmesh.NCMesh_CheckDerefinementNCLevel) def Derefine(self, derefs): r"""Derefine(NCMesh self, intArray derefs)""" return _ncmesh.NCMesh_Derefine(self, derefs) + Derefine = _swig_new_instance_method(_ncmesh.NCMesh_Derefine) def GetFaceList(self): r"""GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetFaceList(self) + GetFaceList = _swig_new_instance_method(_ncmesh.NCMesh_GetFaceList) def GetEdgeList(self): r"""GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetEdgeList(self) + GetEdgeList = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeList) def GetVertexList(self): r"""GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetVertexList(self) + GetVertexList = _swig_new_instance_method(_ncmesh.NCMesh_GetVertexList) def GetNCList(self, entity): r"""GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &""" return _ncmesh.NCMesh_GetNCList(self, entity) + GetNCList = _swig_new_instance_method(_ncmesh.NCMesh_GetNCList) def MarkCoarseLevel(self): r"""MarkCoarseLevel(NCMesh self)""" return _ncmesh.NCMesh_MarkCoarseLevel(self) + MarkCoarseLevel = _swig_new_instance_method(_ncmesh.NCMesh_MarkCoarseLevel) def GetRefinementTransforms(self): r"""GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations""" return _ncmesh.NCMesh_GetRefinementTransforms(self) + GetRefinementTransforms = _swig_new_instance_method(_ncmesh.NCMesh_GetRefinementTransforms) def GetDerefinementTransforms(self): r"""GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations""" return _ncmesh.NCMesh_GetDerefinementTransforms(self) + GetDerefinementTransforms = _swig_new_instance_method(_ncmesh.NCMesh_GetDerefinementTransforms) def ClearTransforms(self): r"""ClearTransforms(NCMesh self)""" return _ncmesh.NCMesh_ClearTransforms(self) + ClearTransforms = _swig_new_instance_method(_ncmesh.NCMesh_ClearTransforms) @staticmethod def GridSfcOrdering2D(width, height, coords): r"""GridSfcOrdering2D(int width, int height, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering2D(width, height, coords) + GridSfcOrdering2D = _swig_new_static_method(_ncmesh.NCMesh_GridSfcOrdering2D) @staticmethod def GridSfcOrdering3D(width, height, depth, coords): r"""GridSfcOrdering3D(int width, int height, int depth, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering3D(width, height, depth, coords) + GridSfcOrdering3D = _swig_new_static_method(_ncmesh.NCMesh_GridSfcOrdering3D) def GetEdgeVertices(self, edge_id, vert_index, oriented=True): r"""GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)""" return _ncmesh.NCMesh_GetEdgeVertices(self, edge_id, vert_index, oriented) + GetEdgeVertices = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeVertices) def GetEdgeNCOrientation(self, edge_id): r"""GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int""" return _ncmesh.NCMesh_GetEdgeNCOrientation(self, edge_id) + GetEdgeNCOrientation = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeNCOrientation) def GetFaceVerticesEdges(self, face_id, vert_index, edge_index, edge_orientation): - r"""GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation)""" + r"""GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int""" return _ncmesh.NCMesh_GetFaceVerticesEdges(self, face_id, vert_index, edge_index, edge_orientation) + GetFaceVerticesEdges = _swig_new_instance_method(_ncmesh.NCMesh_GetFaceVerticesEdges) def GetEdgeMaster(self, v1, v2): r"""GetEdgeMaster(NCMesh self, int v1, int v2) -> int""" return _ncmesh.NCMesh_GetEdgeMaster(self, v1, v2) + GetEdgeMaster = _swig_new_instance_method(_ncmesh.NCMesh_GetEdgeMaster) def GetBoundaryClosure(self, bdr_attr_is_ess, bdr_vertices, bdr_edges): r"""GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)""" return _ncmesh.NCMesh_GetBoundaryClosure(self, bdr_attr_is_ess, bdr_vertices, bdr_edges) + GetBoundaryClosure = _swig_new_instance_method(_ncmesh.NCMesh_GetBoundaryClosure) + + def GetElementGeometry(self, index): + r"""GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type""" + return _ncmesh.NCMesh_GetElementGeometry(self, index) + GetElementGeometry = _swig_new_instance_method(_ncmesh.NCMesh_GetElementGeometry) - def GetElementGeometry(self): - r"""GetElementGeometry(NCMesh self) -> mfem::Geometry::Type""" - return _ncmesh.NCMesh_GetElementGeometry(self) + def GetFaceGeometry(self, index): + r"""GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type""" + return _ncmesh.NCMesh_GetFaceGeometry(self, index) + GetFaceGeometry = _swig_new_instance_method(_ncmesh.NCMesh_GetFaceGeometry) - def GetFaceGeometry(self): - r"""GetFaceGeometry(NCMesh self) -> mfem::Geometry::Type""" - return _ncmesh.NCMesh_GetFaceGeometry(self) + def GetNumRootElements(self): + r"""GetNumRootElements(NCMesh self) -> int""" + return _ncmesh.NCMesh_GetNumRootElements(self) + GetNumRootElements = _swig_new_instance_method(_ncmesh.NCMesh_GetNumRootElements) def GetElementDepth(self, i): r"""GetElementDepth(NCMesh self, int i) -> int""" return _ncmesh.NCMesh_GetElementDepth(self, i) + GetElementDepth = _swig_new_instance_method(_ncmesh.NCMesh_GetElementDepth) + + def GetElementSizeReduction(self, i): + r"""GetElementSizeReduction(NCMesh self, int i) -> int""" + return _ncmesh.NCMesh_GetElementSizeReduction(self, i) + GetElementSizeReduction = _swig_new_instance_method(_ncmesh.NCMesh_GetElementSizeReduction) + + def GetElementFacesAttributes(self, i, faces, fattr): + r"""GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)""" + return _ncmesh.NCMesh_GetElementFacesAttributes(self, i, faces, fattr) + GetElementFacesAttributes = _swig_new_instance_method(_ncmesh.NCMesh_GetElementFacesAttributes) def LoadVertexParents(self, input): r"""LoadVertexParents(NCMesh self, std::istream & input)""" return _ncmesh.NCMesh_LoadVertexParents(self, input) + LoadVertexParents = _swig_new_instance_method(_ncmesh.NCMesh_LoadVertexParents) def LoadCoarseElements(self, input): r"""LoadCoarseElements(NCMesh self, std::istream & input)""" return _ncmesh.NCMesh_LoadCoarseElements(self, input) + LoadCoarseElements = _swig_new_instance_method(_ncmesh.NCMesh_LoadCoarseElements) def SetVertexPositions(self, vertices): r"""SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)""" return _ncmesh.NCMesh_SetVertexPositions(self, vertices) + SetVertexPositions = _swig_new_instance_method(_ncmesh.NCMesh_SetVertexPositions) def Trim(self): r"""Trim(NCMesh self)""" return _ncmesh.NCMesh_Trim(self) + Trim = _swig_new_instance_method(_ncmesh.NCMesh_Trim) def MemoryUsage(self): r"""MemoryUsage(NCMesh self) -> long""" return _ncmesh.NCMesh_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_ncmesh.NCMesh_MemoryUsage) def PrintMemoryDetail(self): r"""PrintMemoryDetail(NCMesh self) -> int""" return _ncmesh.NCMesh_PrintMemoryDetail(self) + PrintMemoryDetail = _swig_new_instance_method(_ncmesh.NCMesh_PrintMemoryDetail) def PrintVertexParents(self, *args): r""" @@ -386,6 +454,7 @@ def PrintVertexParents(self, *args): PrintVertexParents(NCMesh self) """ return _ncmesh.NCMesh_PrintVertexParents(self, *args) + PrintVertexParents = _swig_new_instance_method(_ncmesh.NCMesh_PrintVertexParents) def PrintCoarseElements(self, *args): r""" @@ -394,6 +463,7 @@ def PrintCoarseElements(self, *args): PrintCoarseElements(NCMesh self) """ return _ncmesh.NCMesh_PrintCoarseElements(self, *args) + PrintCoarseElements = _swig_new_instance_method(_ncmesh.NCMesh_PrintCoarseElements) def PrintStats(self, *args): r""" @@ -401,6 +471,7 @@ def PrintStats(self, *args): PrintStats(NCMesh self, char const * file, int precision=8) """ return _ncmesh.NCMesh_PrintStats(self, *args) + PrintStats = _swig_new_instance_method(_ncmesh.NCMesh_PrintStats) # Register NCMesh in _ncmesh: _ncmesh.NCMesh_swigregister(NCMesh) @@ -408,10 +479,12 @@ def PrintStats(self, *args): def NCMesh_GridSfcOrdering2D(width, height, coords): r"""NCMesh_GridSfcOrdering2D(int width, int height, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering2D(width, height, coords) +NCMesh_GridSfcOrdering2D = _ncmesh.NCMesh_GridSfcOrdering2D def NCMesh_GridSfcOrdering3D(width, height, depth, coords): r"""NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)""" return _ncmesh.NCMesh_GridSfcOrdering3D(width, height, depth, coords) +NCMesh_GridSfcOrdering3D = _ncmesh.NCMesh_GridSfcOrdering3D diff --git a/mfem/_ser/ncmesh_wrap.cxx b/mfem/_ser/ncmesh_wrap.cxx index 0a1ece2d..ac80e880 100644 --- a/mfem/_ser/ncmesh_wrap.cxx +++ b/mfem/_ser/ncmesh_wrap.cxx @@ -3066,36 +3066,36 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_double swig_types[2] -#define SWIGTYPE_p_doublep swig_types[3] -#define SWIGTYPE_p_hex_t swig_types[4] -#define SWIGTYPE_p_int swig_types[5] -#define SWIGTYPE_p_intp swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Embedding_t swig_types[8] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[9] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[10] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t swig_types[11] -#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[12] -#define SWIGTYPE_p_mfem__DenseTensor swig_types[13] -#define SWIGTYPE_p_mfem__Embedding swig_types[14] -#define SWIGTYPE_p_mfem__GridFunction swig_types[15] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[16] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[17] -#define SWIGTYPE_p_mfem__Mesh swig_types[18] -#define SWIGTYPE_p_mfem__NCMesh swig_types[19] -#define SWIGTYPE_p_mfem__NCMesh__MeshId swig_types[20] -#define SWIGTYPE_p_mfem__NCMesh__NCList swig_types[21] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[22] -#define SWIGTYPE_p_mfem__Refinement swig_types[23] -#define SWIGTYPE_p_mfem__STable swig_types[24] -#define SWIGTYPE_p_mfem__Table swig_types[25] -#define SWIGTYPE_p_pri_t swig_types[26] -#define SWIGTYPE_p_quad_t swig_types[27] -#define SWIGTYPE_p_seg_t swig_types[28] -#define SWIGTYPE_p_std__istream swig_types[29] -#define SWIGTYPE_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t swig_types[30] +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_double swig_types[3] +#define SWIGTYPE_p_doublep swig_types[4] +#define SWIGTYPE_p_hex_t swig_types[5] +#define SWIGTYPE_p_int swig_types[6] +#define SWIGTYPE_p_intp swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Embedding_t swig_types[9] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t swig_types[10] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t swig_types[11] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t swig_types[12] +#define SWIGTYPE_p_mfem__CoarseFineTransformations swig_types[13] +#define SWIGTYPE_p_mfem__DenseTensor swig_types[14] +#define SWIGTYPE_p_mfem__Embedding swig_types[15] +#define SWIGTYPE_p_mfem__GridFunction swig_types[16] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[17] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[18] +#define SWIGTYPE_p_mfem__Mesh swig_types[19] +#define SWIGTYPE_p_mfem__NCMesh swig_types[20] +#define SWIGTYPE_p_mfem__NCMesh__MeshId swig_types[21] +#define SWIGTYPE_p_mfem__NCMesh__NCList swig_types[22] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[23] +#define SWIGTYPE_p_mfem__Refinement swig_types[24] +#define SWIGTYPE_p_mfem__STable swig_types[25] +#define SWIGTYPE_p_mfem__Table swig_types[26] +#define SWIGTYPE_p_pri_t swig_types[27] +#define SWIGTYPE_p_quad_t swig_types[28] +#define SWIGTYPE_p_seg_t swig_types[29] +#define SWIGTYPE_p_std__istream swig_types[30] #define SWIGTYPE_p_tet_t swig_types[31] #define SWIGTYPE_p_tri_t swig_types[32] #define SWIGTYPE_p_void swig_types[33] @@ -3610,6 +3610,13 @@ SWIG_From_char (char c) } +SWIGINTERNINLINE PyObject* + SWIG_From_bool (bool value) +{ + return PyBool_FromLong(value ? 1 : 0); +} + + #define SWIG_From_long PyInt_FromLong @@ -4625,7 +4632,7 @@ SWIGINTERN PyObject *Embedding_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; - std::map< mfem::Geometry::Type,mfem::DenseTensor > *arg2 = (std::map< mfem::Geometry::Type,mfem::DenseTensor > *) 0 ; + mfem::DenseTensor *arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4638,12 +4645,19 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_set(PyObject SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_point_matrices_set" "', argument " "1"" of type '" "mfem::CoarseFineTransformations *""'"); } arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoarseFineTransformations_point_matrices_set" "', argument " "2"" of type '" "std::map< mfem::Geometry::Type,mfem::DenseTensor > *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoarseFineTransformations_point_matrices_set" "', argument " "2"" of type '" "mfem::DenseTensor [mfem::Geometry::NumGeom]""'"); + } + arg2 = reinterpret_cast< mfem::DenseTensor * >(argp2); + { + if (arg2) { + size_t ii = 0; + for (; ii < (size_t)mfem::Geometry::NumGeom; ++ii) *(mfem::DenseTensor *)&arg1->point_matrices[ii] = *((mfem::DenseTensor *)arg2 + ii); + } else { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""point_matrices""' of type '""mfem::DenseTensor [mfem::Geometry::NumGeom]""'"); + } } - arg2 = reinterpret_cast< std::map< mfem::Geometry::Type,mfem::DenseTensor > * >(argp2); - if (arg1) (arg1)->point_matrices = *arg2; resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -4657,7 +4671,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_get(PyObject void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - std::map< mfem::Geometry::Type,mfem::DenseTensor > *result = 0 ; + mfem::DenseTensor *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; @@ -4666,8 +4680,8 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_point_matrices_get(PyObject SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_point_matrices_get" "', argument " "1"" of type '" "mfem::CoarseFineTransformations *""'"); } arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - result = (std::map< mfem::Geometry::Type,mfem::DenseTensor > *)& ((arg1)->point_matrices); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, 0 | 0 ); + result = (mfem::DenseTensor *)(mfem::DenseTensor *) ((arg1)->point_matrices); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); return resultobj; fail: return NULL; @@ -4697,54 +4711,6 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_embeddings_get(PyObject *SW } -SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetPointMatrices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::DenseTensor *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "CoarseFineTransformations_GetPointMatrices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_GetPointMatrices" "', argument " "1"" of type '" "mfem::CoarseFineTransformations const *""'"); - } - arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoarseFineTransformations_GetPointMatrices" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (mfem::DenseTensor *) &((mfem::CoarseFineTransformations const *)arg1)->GetPointMatrices(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; @@ -4879,6 +4845,47 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_Clear(PyObject *SWIGUNUSEDP } +SWIGINTERN PyObject *_wrap_CoarseFineTransformations_IsInitialized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_IsInitialized" "', argument " "1"" of type '" "mfem::CoarseFineTransformations const *""'"); + } + arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); + { + try { + result = (bool)((mfem::CoarseFineTransformations const *)arg1)->IsInitialized(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_CoarseFineTransformations_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; @@ -6382,6 +6389,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( void *argp5 = 0 ; int res5 = 0 ; PyObject *swig_obj[5] ; + int result; if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceVerticesEdges", 5, 5, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); @@ -6414,7 +6422,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( arg5 = reinterpret_cast< int * >(argp5); { try { - ((mfem::NCMesh const *)arg1)->GetFaceVerticesEdges((mfem::NCMesh::MeshId const &)*arg2,arg3,arg4,arg5); + result = (int)((mfem::NCMesh const *)arg1)->GetFaceVerticesEdges((mfem::NCMesh::MeshId const &)*arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6431,7 +6439,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; @@ -6567,21 +6575,27 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject *swig_obj[2] ; mfem::Geometry::Type result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementGeometry", 2, 2, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetElementGeometry(); + result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetElementGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6608,21 +6622,68 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *_wrap_NCMesh_GetFaceGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject *swig_obj[2] ; mfem::Geometry::Type result; + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceGeometry", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + } + arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetFaceGeometry(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NCMesh_GetNumRootElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetNumRootElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { try { - result = (mfem::Geometry::Type)((mfem::NCMesh const *)arg1)->GetFaceGeometry(); + result = (int)(arg1)->GetNumRootElements(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6693,6 +6754,121 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self) } +SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementSizeReduction", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementSizeReduction" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + } + arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::NCMesh const *)arg1)->GetElementSizeReduction(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementFacesAttributes", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + } + arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + try { + ((mfem::NCMesh const *)arg1)->GetElementFacesAttributes(arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; @@ -7860,6 +8036,7 @@ SWIGINTERN PyObject *NCMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, { "intp_assign", _wrap_intp_assign, METH_VARARGS, "intp_assign(intp self, int value)"}, @@ -7898,12 +8075,12 @@ static PyMethodDef SwigMethods[] = { { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, { "Embedding_swiginit", Embedding_swiginit, METH_VARARGS, NULL}, - { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, std::map< mfem::Geometry::Type,mfem::DenseTensor > * point_matrices)"}, - { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> std::map< mfem::Geometry::Type,mfem::DenseTensor > *"}, + { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, + { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, - { "CoarseFineTransformations_GetPointMatrices", _wrap_CoarseFineTransformations_GetPointMatrices, METH_VARARGS, "CoarseFineTransformations_GetPointMatrices(CoarseFineTransformations self, mfem::Geometry::Type geom) -> DenseTensor"}, { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "CoarseFineTransformations_GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "CoarseFineTransformations_Clear(CoarseFineTransformations self)"}, + { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "CoarseFineTransformations_IsInitialized(CoarseFineTransformations self) -> bool"}, { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "CoarseFineTransformations_MemoryUsage(CoarseFineTransformations self) -> long"}, { "new_CoarseFineTransformations", _wrap_new_CoarseFineTransformations, METH_NOARGS, "new_CoarseFineTransformations() -> CoarseFineTransformations"}, { "delete_CoarseFineTransformations", _wrap_delete_CoarseFineTransformations, METH_O, "delete_CoarseFineTransformations(CoarseFineTransformations self)"}, @@ -7936,12 +8113,15 @@ static PyMethodDef SwigMethods[] = { { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "NCMesh_GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "NCMesh_GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, - { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation)"}, + { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "NCMesh_GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "NCMesh_GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, - { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_O, "NCMesh_GetElementGeometry(NCMesh self) -> mfem::Geometry::Type"}, - { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_O, "NCMesh_GetFaceGeometry(NCMesh self) -> mfem::Geometry::Type"}, + { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "NCMesh_GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "NCMesh_GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "NCMesh_GetNumRootElements(NCMesh self) -> int"}, { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "NCMesh_GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "NCMesh_GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "NCMesh_GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "NCMesh_LoadVertexParents(NCMesh self, std::istream & input)"}, { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "NCMesh_LoadCoarseElements(NCMesh self, std::istream & input)"}, { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "NCMesh_SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, @@ -7968,6 +8148,115 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, + { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, + { "intp_assign", _wrap_intp_assign, METH_VARARGS, "assign(intp self, int value)"}, + { "intp_value", _wrap_intp_value, METH_O, "value(intp self) -> int"}, + { "intp_cast", _wrap_intp_cast, METH_O, "cast(intp self) -> int *"}, + { "intp_frompointer", _wrap_intp_frompointer, METH_O, "frompointer(int * t) -> intp"}, + { "intp_swigregister", intp_swigregister, METH_O, NULL}, + { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, + { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, + { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, + { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "assign(doublep self, double value)"}, + { "doublep_value", _wrap_doublep_value, METH_O, "value(doublep self) -> double"}, + { "doublep_cast", _wrap_doublep_cast, METH_O, "cast(doublep self) -> double *"}, + { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "frompointer(double * t) -> doublep"}, + { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, + { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, + { "Refinement_index_set", _wrap_Refinement_index_set, METH_VARARGS, "Refinement_index_set(Refinement self, int index)"}, + { "Refinement_index_get", _wrap_Refinement_index_get, METH_O, "Refinement_index_get(Refinement self) -> int"}, + { "Refinement_ref_type_set", _wrap_Refinement_ref_type_set, METH_VARARGS, "Refinement_ref_type_set(Refinement self, char ref_type)"}, + { "Refinement_ref_type_get", _wrap_Refinement_ref_type_get, METH_O, "Refinement_ref_type_get(Refinement self) -> char"}, + { "new_Refinement", _wrap_new_Refinement, METH_VARARGS, "\n" + "Refinement()\n" + "Refinement(int index, int type=7)\n" + ""}, + { "delete_Refinement", _wrap_delete_Refinement, METH_O, "delete_Refinement(Refinement self)"}, + { "Refinement_swigregister", Refinement_swigregister, METH_O, NULL}, + { "Refinement_swiginit", Refinement_swiginit, METH_VARARGS, NULL}, + { "Embedding_parent_set", _wrap_Embedding_parent_set, METH_VARARGS, "Embedding_parent_set(Embedding self, int parent)"}, + { "Embedding_parent_get", _wrap_Embedding_parent_get, METH_O, "Embedding_parent_get(Embedding self) -> int"}, + { "Embedding_matrix_set", _wrap_Embedding_matrix_set, METH_VARARGS, "Embedding_matrix_set(Embedding self, int matrix)"}, + { "Embedding_matrix_get", _wrap_Embedding_matrix_get, METH_O, "Embedding_matrix_get(Embedding self) -> int"}, + { "new_Embedding", _wrap_new_Embedding, METH_VARARGS, "\n" + "Embedding()\n" + "Embedding(int elem, int matrix=0)\n" + ""}, + { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, + { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, + { "Embedding_swiginit", Embedding_swiginit, METH_VARARGS, NULL}, + { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, + { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, + { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, + { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, + { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "Clear(CoarseFineTransformations self)"}, + { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "IsInitialized(CoarseFineTransformations self) -> bool"}, + { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "MemoryUsage(CoarseFineTransformations self) -> long"}, + { "new_CoarseFineTransformations", _wrap_new_CoarseFineTransformations, METH_NOARGS, "new_CoarseFineTransformations() -> CoarseFineTransformations"}, + { "delete_CoarseFineTransformations", _wrap_delete_CoarseFineTransformations, METH_O, "delete_CoarseFineTransformations(CoarseFineTransformations self)"}, + { "CoarseFineTransformations_swigregister", CoarseFineTransformations_swigregister, METH_O, NULL}, + { "CoarseFineTransformations_swiginit", CoarseFineTransformations_swiginit, METH_VARARGS, NULL}, + { "new_NCMesh", _wrap_new_NCMesh, METH_VARARGS, "\n" + "NCMesh(Mesh mesh, std::istream * vertex_parents=None)\n" + "new_NCMesh(NCMesh other) -> NCMesh\n" + ""}, + { "delete_NCMesh", _wrap_delete_NCMesh, METH_O, "delete_NCMesh(NCMesh self)"}, + { "NCMesh_Dimension", _wrap_NCMesh_Dimension, METH_O, "Dimension(NCMesh self) -> int"}, + { "NCMesh_SpaceDimension", _wrap_NCMesh_SpaceDimension, METH_O, "SpaceDimension(NCMesh self) -> int"}, + { "NCMesh_GetNVertices", _wrap_NCMesh_GetNVertices, METH_O, "GetNVertices(NCMesh self) -> int"}, + { "NCMesh_GetNEdges", _wrap_NCMesh_GetNEdges, METH_O, "GetNEdges(NCMesh self) -> int"}, + { "NCMesh_GetNFaces", _wrap_NCMesh_GetNFaces, METH_O, "GetNFaces(NCMesh self) -> int"}, + { "NCMesh_Refine", _wrap_NCMesh_Refine, METH_VARARGS, "Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "NCMesh_LimitNCLevel", _wrap_NCMesh_LimitNCLevel, METH_VARARGS, "LimitNCLevel(NCMesh self, int max_nc_level)"}, + { "NCMesh_GetDerefinementTable", _wrap_NCMesh_GetDerefinementTable, METH_O, "GetDerefinementTable(NCMesh self) -> Table"}, + { "NCMesh_CheckDerefinementNCLevel", _wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS, "CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "NCMesh_Derefine", _wrap_NCMesh_Derefine, METH_VARARGS, "Derefine(NCMesh self, intArray derefs)"}, + { "NCMesh_GetFaceList", _wrap_NCMesh_GetFaceList, METH_O, "GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetEdgeList", _wrap_NCMesh_GetEdgeList, METH_O, "GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetVertexList", _wrap_NCMesh_GetVertexList, METH_O, "GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetNCList", _wrap_NCMesh_GetNCList, METH_VARARGS, "GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_MarkCoarseLevel", _wrap_NCMesh_MarkCoarseLevel, METH_O, "MarkCoarseLevel(NCMesh self)"}, + { "NCMesh_GetRefinementTransforms", _wrap_NCMesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, + { "NCMesh_GetDerefinementTransforms", _wrap_NCMesh_GetDerefinementTransforms, METH_O, "GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, + { "NCMesh_ClearTransforms", _wrap_NCMesh_ClearTransforms, METH_O, "ClearTransforms(NCMesh self)"}, + { "NCMesh_GridSfcOrdering2D", _wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS, "GridSfcOrdering2D(int width, int height, intArray coords)"}, + { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, + { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, + { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, + { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, + { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, + { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "GetNumRootElements(NCMesh self) -> int"}, + { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, + { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "LoadVertexParents(NCMesh self, std::istream & input)"}, + { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "LoadCoarseElements(NCMesh self, std::istream & input)"}, + { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, + { "NCMesh_Trim", _wrap_NCMesh_Trim, METH_O, "Trim(NCMesh self)"}, + { "NCMesh_MemoryUsage", _wrap_NCMesh_MemoryUsage, METH_O, "MemoryUsage(NCMesh self) -> long"}, + { "NCMesh_PrintMemoryDetail", _wrap_NCMesh_PrintMemoryDetail, METH_O, "PrintMemoryDetail(NCMesh self) -> int"}, + { "NCMesh_PrintVertexParents", _wrap_NCMesh_PrintVertexParents, METH_VARARGS, "\n" + "PrintVertexParents(NCMesh self, std::ostream & out)\n" + "PrintVertexParents(NCMesh self, char const * file, int precision=8)\n" + "PrintVertexParents(NCMesh self)\n" + ""}, + { "NCMesh_PrintCoarseElements", _wrap_NCMesh_PrintCoarseElements, METH_VARARGS, "\n" + "PrintCoarseElements(NCMesh self, std::ostream & out)\n" + "PrintCoarseElements(NCMesh self, char const * file, int precision=8)\n" + "PrintCoarseElements(NCMesh self)\n" + ""}, + { "NCMesh_PrintStats", _wrap_NCMesh_PrintStats, METH_VARARGS, "\n" + "PrintStats(NCMesh self, std::ostream & out=mfem::out)\n" + "PrintStats(NCMesh self, char const * file, int precision=8)\n" + ""}, + { "NCMesh_swigregister", NCMesh_swigregister, METH_O, NULL}, + { "NCMesh_swiginit", NCMesh_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -7984,6 +8273,7 @@ static void *_p_mfem__STableTo_p_mfem__Table(void *x, int *SWIGUNUSEDPARM(newmem return (void *)((mfem::Table *) ((mfem::STable *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; @@ -8013,13 +8303,13 @@ static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t = {"_p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t", "std::map< mfem::Geometry::Type,mfem::DenseTensor > *|std::map< enum mfem::Geometry::Type,mfem::DenseTensor > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_double, &_swigt__p_doublep, @@ -8049,13 +8339,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_quad_t, &_swigt__p_seg_t, &_swigt__p_std__istream, - &_swigt__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, &_swigt__p_tet_t, &_swigt__p_tri_t, &_swigt__p_void, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0}, {&_swigt__p_doublep, _p_doublepTo_p_double, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; @@ -8085,13 +8375,13 @@ static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t[] = { {&_swigt__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_double, _swigc__p_doublep, @@ -8121,7 +8411,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_quad_t, _swigc__p_seg_t, _swigc__p_std__istream, - _swigc__p_std__mapT_mfem__Geometry__Type_mfem__DenseTensor_t, _swigc__p_tet_t, _swigc__p_tri_t, _swigc__p_void, diff --git a/mfem/_ser/nonlinearform.i b/mfem/_ser/nonlinearform.i index 1f6b283e..05cb1649 100644 --- a/mfem/_ser/nonlinearform.i +++ b/mfem/_ser/nonlinearform.i @@ -16,6 +16,7 @@ import_array(); %include "exception.i" %import "operators.i" %import "fespace.i" +%import "bilinearform.i" %import "nonlininteg.i" %import "../common/exception.i" %include "../common/typemap_macros.i" diff --git a/mfem/_ser/nonlinearform.py b/mfem/_ser/nonlinearform.py index 5408b030..92059c19 100644 --- a/mfem/_ser/nonlinearform.py +++ b/mfem/_ser/nonlinearform.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _nonlinearform.SWIG_PyInstanceMethod_New +_swig_new_static_method = _nonlinearform.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,7 +90,10 @@ class _SwigNonDynamicMeta(type): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.handle +import mfem._ser.restriction +import mfem._ser.bilinearform import mfem._ser.nonlininteg class NonlinearForm(mfem._ser.operators.Operator): r"""Proxy of C++ mfem::NonlinearForm class.""" @@ -99,12 +105,18 @@ def __init__(self, f): r"""__init__(NonlinearForm self, FiniteElementSpace f) -> NonlinearForm""" _nonlinearform.NonlinearForm_swiginit(self, _nonlinearform.new_NonlinearForm(f)) + def SetAssemblyLevel(self, assembly_level): + r"""SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)""" + return _nonlinearform.NonlinearForm_SetAssemblyLevel(self, assembly_level) + SetAssemblyLevel = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetAssemblyLevel) + def FESpace(self, *args): r""" FESpace(NonlinearForm self) -> FiniteElementSpace FESpace(NonlinearForm self) -> FiniteElementSpace """ return _nonlinearform.NonlinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_nonlinearform.NonlinearForm_FESpace) def AddDomainIntegrator(self, nlfi): r"""AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)""" @@ -117,6 +129,11 @@ def AddDomainIntegrator(self, nlfi): return _nonlinearform.NonlinearForm_AddDomainIntegrator(self, nlfi) + def GetDNFI(self): + r"""GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *""" + return _nonlinearform.NonlinearForm_GetDNFI(self) + GetDNFI = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetDNFI) + def AddInteriorFaceIntegrator(self, nlfi): r"""AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)""" @@ -146,51 +163,68 @@ def AddBdrFaceIntegrator(self, *args): def SetEssentialBC(self, bdr_attr_is_ess, rhs=None): r"""SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)""" return _nonlinearform.NonlinearForm_SetEssentialBC(self, bdr_attr_is_ess, rhs) + SetEssentialBC = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetEssentialBC) def SetEssentialVDofs(self, ess_vdofs_list): r"""SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)""" return _nonlinearform.NonlinearForm_SetEssentialVDofs(self, ess_vdofs_list) + SetEssentialVDofs = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetEssentialVDofs) def SetEssentialTrueDofs(self, ess_tdof_list): r"""SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)""" return _nonlinearform.NonlinearForm_SetEssentialTrueDofs(self, ess_tdof_list) + SetEssentialTrueDofs = _swig_new_instance_method(_nonlinearform.NonlinearForm_SetEssentialTrueDofs) def GetEssentialTrueDofs(self): r"""GetEssentialTrueDofs(NonlinearForm self) -> intArray""" return _nonlinearform.NonlinearForm_GetEssentialTrueDofs(self) + GetEssentialTrueDofs = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetEssentialTrueDofs) def GetGridFunctionEnergy(self, x): r"""GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double""" return _nonlinearform.NonlinearForm_GetGridFunctionEnergy(self, x) + GetGridFunctionEnergy = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetGridFunctionEnergy) def GetEnergy(self, x): r"""GetEnergy(NonlinearForm self, Vector x) -> double""" return _nonlinearform.NonlinearForm_GetEnergy(self, x) + GetEnergy = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetEnergy) def Mult(self, x, y): r"""Mult(NonlinearForm self, Vector x, Vector y)""" return _nonlinearform.NonlinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_nonlinearform.NonlinearForm_Mult) def GetGradient(self, x): r"""GetGradient(NonlinearForm self, Vector x) -> Operator""" return _nonlinearform.NonlinearForm_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetGradient) def Update(self): r"""Update(NonlinearForm self)""" return _nonlinearform.NonlinearForm_Update(self) + Update = _swig_new_instance_method(_nonlinearform.NonlinearForm_Update) + + def Setup(self): + r"""Setup(NonlinearForm self)""" + return _nonlinearform.NonlinearForm_Setup(self) + Setup = _swig_new_instance_method(_nonlinearform.NonlinearForm_Setup) def GetProlongation(self): r"""GetProlongation(NonlinearForm self) -> Operator""" return _nonlinearform.NonlinearForm_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetProlongation) def GetRestriction(self): r"""GetRestriction(NonlinearForm self) -> Operator""" return _nonlinearform.NonlinearForm_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetRestriction) __swig_destroy__ = _nonlinearform.delete_NonlinearForm def GetGradientMatrix(self, x): r"""GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix""" return _nonlinearform.NonlinearForm_GetGradientMatrix(self, x) + GetGradientMatrix = _swig_new_instance_method(_nonlinearform.NonlinearForm_GetGradientMatrix) # Register NonlinearForm in _nonlinearform: _nonlinearform.NonlinearForm_swigregister(NonlinearForm) @@ -214,18 +248,22 @@ def FESpace(self, *args): FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace """ return _nonlinearform.BlockNonlinearForm_FESpace(self, *args) + FESpace = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_FESpace) def SetSpaces(self, f): r"""SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)""" return _nonlinearform.BlockNonlinearForm_SetSpaces(self, f) + SetSpaces = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_SetSpaces) def GetBlockOffsets(self): r"""GetBlockOffsets(BlockNonlinearForm self) -> intArray""" return _nonlinearform.BlockNonlinearForm_GetBlockOffsets(self) + GetBlockOffsets = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetBlockOffsets) def GetBlockTrueOffsets(self): r"""GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray""" return _nonlinearform.BlockNonlinearForm_GetBlockTrueOffsets(self) + GetBlockTrueOffsets = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetBlockTrueOffsets) def AddDomainIntegrator(self, nlfi): r"""AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)""" @@ -267,18 +305,22 @@ def AddBdrFaceIntegrator(self, *args): def SetEssentialBC(self, bdr_attr_is_ess, rhs): r"""SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)""" return _nonlinearform.BlockNonlinearForm_SetEssentialBC(self, bdr_attr_is_ess, rhs) + SetEssentialBC = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_SetEssentialBC) def GetEnergy(self, x): r"""GetEnergy(BlockNonlinearForm self, Vector x) -> double""" return _nonlinearform.BlockNonlinearForm_GetEnergy(self, x) + GetEnergy = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetEnergy) def Mult(self, x, y): r"""Mult(BlockNonlinearForm self, Vector x, Vector y)""" return _nonlinearform.BlockNonlinearForm_Mult(self, x, y) + Mult = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_Mult) def GetGradient(self, x): r"""GetGradient(BlockNonlinearForm self, Vector x) -> Operator""" return _nonlinearform.BlockNonlinearForm_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_nonlinearform.BlockNonlinearForm_GetGradient) __swig_destroy__ = _nonlinearform.delete_BlockNonlinearForm # Register BlockNonlinearForm in _nonlinearform: diff --git a/mfem/_ser/nonlinearform_wrap.cxx b/mfem/_ser/nonlinearform_wrap.cxx index a919b47f..d8980a08 100644 --- a/mfem/_ser/nonlinearform_wrap.cxx +++ b/mfem/_ser/nonlinearform_wrap.cxx @@ -3066,50 +3066,62 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[6] -#define SWIGTYPE_p_mfem__BlockNonlinearForm swig_types[7] -#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[8] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[9] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[10] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[11] -#define SWIGTYPE_p_mfem__ElementRestriction swig_types[12] -#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[13] -#define SWIGTYPE_p_mfem__GridFunction swig_types[14] -#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[15] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[16] -#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[17] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[18] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[19] -#define SWIGTYPE_p_mfem__LinearForm swig_types[20] -#define SWIGTYPE_p_mfem__Matrix swig_types[21] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[22] -#define SWIGTYPE_p_mfem__NonlinearForm swig_types[23] -#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[24] -#define SWIGTYPE_p_mfem__Operator swig_types[25] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[26] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[27] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[28] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[29] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[30] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[31] -#define SWIGTYPE_p_mfem__Solver swig_types[32] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[33] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[34] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[35] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[36] -#define SWIGTYPE_p_mfem__Vector swig_types[37] -#define SWIGTYPE_p_pri_t swig_types[38] -#define SWIGTYPE_p_quad_t swig_types[39] -#define SWIGTYPE_p_seg_t swig_types[40] -#define SWIGTYPE_p_tet_t swig_types[41] -#define SWIGTYPE_p_tri_t swig_types[42] -static swig_type_info *swig_types[44]; -static swig_module_info swig_module = {swig_types, 43, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t swig_types[8] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[9] +#define SWIGTYPE_p_mfem__BlockNonlinearForm swig_types[10] +#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[11] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[12] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[13] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[14] +#define SWIGTYPE_p_mfem__DiscreteLinearOperator swig_types[15] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[16] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[17] +#define SWIGTYPE_p_mfem__GridFunction swig_types[18] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[19] +#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[20] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[21] +#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[22] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[23] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[24] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[25] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[26] +#define SWIGTYPE_p_mfem__LinearForm swig_types[27] +#define SWIGTYPE_p_mfem__Matrix swig_types[28] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[29] +#define SWIGTYPE_p_mfem__MixedBilinearForm swig_types[30] +#define SWIGTYPE_p_mfem__NonlinearForm swig_types[31] +#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[32] +#define SWIGTYPE_p_mfem__Operator swig_types[33] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[34] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[35] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[36] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[37] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[38] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[39] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[40] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[41] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[42] +#define SWIGTYPE_p_mfem__Solver swig_types[43] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[44] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[45] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[46] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[47] +#define SWIGTYPE_p_mfem__Vector swig_types[48] +#define SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator swig_types[49] +#define SWIGTYPE_p_pri_t swig_types[50] +#define SWIGTYPE_p_quad_t swig_types[51] +#define SWIGTYPE_p_seg_t swig_types[52] +#define SWIGTYPE_p_tet_t swig_types[53] +#define SWIGTYPE_p_tri_t swig_types[54] +static swig_type_info *swig_types[56]; +static swig_module_info swig_module = {swig_types, 55, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3222,6 +3234,157 @@ namespace swig { #include "pyoperator.hpp" +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + #define SWIG_From_double PyFloat_FromDouble SWIGINTERN mfem::SparseMatrix *mfem_NonlinearForm_GetGradientMatrix(mfem::NonlinearForm const *self,mfem::Vector const &x){ @@ -3279,6 +3442,53 @@ SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyO } +SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; + mfem::AssemblyLevel arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); + } + arg2 = static_cast< mfem::AssemblyLevel >(val2); + { + try { + (arg1)->SetAssemblyLevel(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NonlinearForm_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; @@ -3440,6 +3650,47 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSE } +SWIGINTERN PyObject *_wrap_NonlinearForm_GetDNFI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Array< mfem::NonlinearFormIntegrator * > *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetDNFI" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); + { + try { + result = (mfem::Array< mfem::NonlinearFormIntegrator * > *)(arg1)->GetDNFI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; @@ -4191,6 +4442,46 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Update(PyObject *SWIGUNUSEDPARM(self), } +SWIGINTERN PyObject *_wrap_NonlinearForm_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_Setup" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); + { + try { + (arg1)->Setup(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_NonlinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; @@ -5469,12 +5760,15 @@ SWIGINTERN PyObject *BlockNonlinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "NonlinearForm_SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" ""}, { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "NonlinearForm_AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "NonlinearForm_GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "NonlinearForm_AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "NonlinearForm_AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" @@ -5489,6 +5783,7 @@ static PyMethodDef SwigMethods[] = { { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "NonlinearForm_Mult(NonlinearForm self, Vector x, Vector y)"}, { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "NonlinearForm_GetGradient(NonlinearForm self, Vector x) -> Operator"}, { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "NonlinearForm_Update(NonlinearForm self)"}, + { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "NonlinearForm_Setup(NonlinearForm self)"}, { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "NonlinearForm_GetProlongation(NonlinearForm self) -> Operator"}, { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "NonlinearForm_GetRestriction(NonlinearForm self) -> Operator"}, { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, @@ -5523,6 +5818,61 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(NonlinearForm self) -> FiniteElementSpace\n" + "FESpace(NonlinearForm self) -> FiniteElementSpace\n" + ""}, + { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, + { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" + "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nfi, intArray bdr_marker)\n" + ""}, + { "NonlinearForm_SetEssentialBC", _wrap_NonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, + { "NonlinearForm_SetEssentialVDofs", _wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS, "SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, + { "NonlinearForm_SetEssentialTrueDofs", _wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS, "SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, + { "NonlinearForm_GetEssentialTrueDofs", _wrap_NonlinearForm_GetEssentialTrueDofs, METH_O, "GetEssentialTrueDofs(NonlinearForm self) -> intArray"}, + { "NonlinearForm_GetGridFunctionEnergy", _wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS, "GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_GetEnergy", _wrap_NonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "Mult(NonlinearForm self, Vector x, Vector y)"}, + { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "GetGradient(NonlinearForm self, Vector x) -> Operator"}, + { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "Update(NonlinearForm self)"}, + { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "Setup(NonlinearForm self)"}, + { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "GetProlongation(NonlinearForm self) -> Operator"}, + { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "GetRestriction(NonlinearForm self) -> Operator"}, + { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, + { "NonlinearForm_GetGradientMatrix", _wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS, "GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, + { "NonlinearForm_swigregister", NonlinearForm_swigregister, METH_O, NULL}, + { "NonlinearForm_swiginit", NonlinearForm_swiginit, METH_VARARGS, NULL}, + { "new_BlockNonlinearForm", _wrap_new_BlockNonlinearForm, METH_VARARGS, "\n" + "BlockNonlinearForm()\n" + "new_BlockNonlinearForm(mfem::Array< mfem::FiniteElementSpace * > & f) -> BlockNonlinearForm\n" + ""}, + { "BlockNonlinearForm_FESpace", _wrap_BlockNonlinearForm_FESpace, METH_VARARGS, "\n" + "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" + "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" + ""}, + { "BlockNonlinearForm_SetSpaces", _wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS, "SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, + { "BlockNonlinearForm_GetBlockOffsets", _wrap_BlockNonlinearForm_GetBlockOffsets, METH_O, "GetBlockOffsets(BlockNonlinearForm self) -> intArray"}, + { "BlockNonlinearForm_GetBlockTrueOffsets", _wrap_BlockNonlinearForm_GetBlockTrueOffsets, METH_O, "GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray"}, + { "BlockNonlinearForm_AddDomainIntegrator", _wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddInteriorFaceIntegrator", _wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddBdrFaceIntegrator", _wrap_BlockNonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" + "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)\n" + "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi, intArray bdr_marker)\n" + ""}, + { "BlockNonlinearForm_SetEssentialBC", _wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "BlockNonlinearForm_GetEnergy", _wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, + { "BlockNonlinearForm_Mult", _wrap_BlockNonlinearForm_Mult, METH_VARARGS, "Mult(BlockNonlinearForm self, Vector x, Vector y)"}, + { "BlockNonlinearForm_GetGradient", _wrap_BlockNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, + { "delete_BlockNonlinearForm", _wrap_delete_BlockNonlinearForm, METH_O, "delete_BlockNonlinearForm(BlockNonlinearForm self)"}, + { "BlockNonlinearForm_swigregister", BlockNonlinearForm_swigregister, METH_O, NULL}, + { "BlockNonlinearForm_swiginit", BlockNonlinearForm_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5541,6 +5891,9 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n static void *_p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::HyperelasticNLFIntegrator *) x)); } +static void *_p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::VectorConvectionNLFIntegrator *) x)); +} static void *_p_mfem__IncompressibleNeoHookeanIntegratorTo_p_mfem__BlockNonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BlockNonlinearFormIntegrator *) ((mfem::IncompressibleNeoHookeanIntegrator *) x)); } @@ -5559,18 +5912,33 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); } +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} +static void *_p_mfem__BilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::BilinearForm *) x)); +} +static void *_p_mfem__MixedBilinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::MixedBilinearForm *) x)); +} static void *_p_mfem__NonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::NonlinearForm *) x)); } @@ -5580,6 +5948,9 @@ static void *_p_mfem__BlockNonlinearFormTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -5595,18 +5966,29 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::MixedBilinearForm *) ((mfem::DiscreteLinearOperator *) x)); +} static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t = {"_p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t", "mfem::Array< mfem::NonlinearFormIntegrator * > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BlockNonlinearForm = {"_p_mfem__BlockNonlinearForm", "mfem::BlockNonlinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BlockNonlinearFormIntegrator = {"_p_mfem__BlockNonlinearFormIntegrator", "mfem::BlockNonlinearFormIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__IncompressibleNeoHookeanIntegrator = {"_p_mfem__IncompressibleNeoHookeanIntegrator", 0, 0, 0, 0, 0}; @@ -5617,23 +5999,33 @@ static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollecti static swig_type_info _swigt__p_mfem__NonlinearForm = {"_p_mfem__NonlinearForm", "mfem::NonlinearForm *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__NonlinearFormIntegrator = {"_p_mfem__NonlinearFormIntegrator", "mfem::NonlinearFormIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HyperelasticNLFIntegrator = {"_p_mfem__HyperelasticNLFIntegrator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorConvectionNLFIntegrator = {"_p_mfem__VectorConvectionNLFIntegrator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__BilinearForm = {"_p_mfem__BilinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MixedBilinearForm = {"_p_mfem__MixedBilinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DiscreteLinearOperator = {"_p_mfem__DiscreteLinearOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; @@ -5647,28 +6039,36 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, &_swigt__p_intp, &_swigt__p_mfem__AbstractSparseMatrix, &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, + &_swigt__p_mfem__BilinearForm, &_swigt__p_mfem__BlockNonlinearForm, &_swigt__p_mfem__BlockNonlinearFormIntegrator, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__DenseMatrix, &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__DiscreteLinearOperator, &_swigt__p_mfem__ElementRestriction, &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__H1FaceRestriction, &_swigt__p_mfem__HyperelasticNLFIntegrator, &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__IncompressibleNeoHookeanIntegrator, &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, &_swigt__p_mfem__L2_FECollection, &_swigt__p_mfem__LinearForm, &_swigt__p_mfem__Matrix, &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__MixedBilinearForm, &_swigt__p_mfem__NonlinearForm, &_swigt__p_mfem__NonlinearFormIntegrator, &_swigt__p_mfem__Operator, @@ -5678,12 +6078,16 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__QuadratureFunction, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, &_swigt__p_mfem__TripleProductOperator, &_swigt__p_mfem__Vector, + &_swigt__p_mfem__VectorConvectionNLFIntegrator, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -5692,11 +6096,13 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t[] = { {&_swigt__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockNonlinearForm[] = { {&_swigt__p_mfem__BlockNonlinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IncompressibleNeoHookeanIntegrator[] = {{&_swigt__p_mfem__IncompressibleNeoHookeanIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BlockNonlinearFormIntegrator[] = { {&_swigt__p_mfem__BlockNonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__IncompressibleNeoHookeanIntegrator, _p_mfem__IncompressibleNeoHookeanIntegratorTo_p_mfem__BlockNonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; @@ -5706,24 +6112,34 @@ static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__I static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NonlinearForm[] = { {&_swigt__p_mfem__NonlinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyperelasticNLFIntegrator[] = {{&_swigt__p_mfem__HyperelasticNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorConvectionNLFIntegrator[] = {{&_swigt__p_mfem__VectorConvectionNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorConvectionNLFIntegrator, _p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ElementRestriction[] = {{&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = {{&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = {{&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = {{&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearForm[] = {{&_swigt__p_mfem__BilinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MixedBilinearForm[] = {{&_swigt__p_mfem__MixedBilinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NonlinearForm, _p_mfem__NonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockNonlinearForm, _p_mfem__BlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DiscreteLinearOperator[] = {{&_swigt__p_mfem__DiscreteLinearOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BilinearForm, _p_mfem__BilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MixedBilinearForm, _p_mfem__MixedBilinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NonlinearForm, _p_mfem__NonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockNonlinearForm, _p_mfem__BlockNonlinearFormTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DiscreteLinearOperator, _p_mfem__DiscreteLinearOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; @@ -5737,28 +6153,36 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, _swigc__p_intp, _swigc__p_mfem__AbstractSparseMatrix, _swigc__p_mfem__ArrayT_int_t, + _swigc__p_mfem__ArrayT_mfem__NonlinearFormIntegrator_p_t, + _swigc__p_mfem__BilinearForm, _swigc__p_mfem__BlockNonlinearForm, _swigc__p_mfem__BlockNonlinearFormIntegrator, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__DenseMatrix, _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__DiscreteLinearOperator, _swigc__p_mfem__ElementRestriction, _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__GridFunction, + _swigc__p_mfem__H1FaceRestriction, _swigc__p_mfem__HyperelasticNLFIntegrator, _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__IncompressibleNeoHookeanIntegrator, _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, _swigc__p_mfem__L2_FECollection, _swigc__p_mfem__LinearForm, _swigc__p_mfem__Matrix, _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__MixedBilinearForm, _swigc__p_mfem__NonlinearForm, _swigc__p_mfem__NonlinearFormIntegrator, _swigc__p_mfem__Operator, @@ -5768,12 +6192,16 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__QuadratureFunction, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, _swigc__p_mfem__TripleProductOperator, _swigc__p_mfem__Vector, + _swigc__p_mfem__VectorConvectionNLFIntegrator, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_ser/nonlininteg.py b/mfem/_ser/nonlininteg.py index 78e9cd5a..d9d01fab 100644 --- a/mfem/_ser/nonlininteg.py +++ b/mfem/_ser/nonlininteg.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _nonlininteg.SWIG_PyInstanceMethod_New +_swig_new_static_method = _nonlininteg.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -87,7 +90,9 @@ class _SwigNonDynamicMeta(type): import mfem._ser.table import mfem._ser.hash import mfem._ser.vertex +import mfem._ser.vtk import mfem._ser.handle +import mfem._ser.restriction class NonlinearFormIntegrator(object): r"""Proxy of C++ mfem::NonlinearFormIntegrator class.""" @@ -105,30 +110,50 @@ def __init__(self, ir=None): def SetIntRule(self, ir): r"""SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)""" return _nonlininteg.NonlinearFormIntegrator_SetIntRule(self, ir) + SetIntRule = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_SetIntRule) def SetIntegrationRule(self, irule): r"""SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)""" return _nonlininteg.NonlinearFormIntegrator_SetIntegrationRule(self, irule) + SetIntegrationRule = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_SetIntegrationRule) def AssembleElementVector(self, el, Tr, elfun, elvect): r"""AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)""" return _nonlininteg.NonlinearFormIntegrator_AssembleElementVector(self, el, Tr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleElementVector) def AssembleFaceVector(self, el1, el2, Tr, elfun, elvect): r"""AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)""" return _nonlininteg.NonlinearFormIntegrator_AssembleFaceVector(self, el1, el2, Tr, elfun, elvect) + AssembleFaceVector = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleFaceVector) def AssembleElementGrad(self, el, Tr, elfun, elmat): r"""AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)""" return _nonlininteg.NonlinearFormIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleElementGrad) def AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat): r"""AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)""" return _nonlininteg.NonlinearFormIntegrator_AssembleFaceGrad(self, el1, el2, Tr, elfun, elmat) + AssembleFaceGrad = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssembleFaceGrad) def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double""" return _nonlininteg.NonlinearFormIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_GetElementEnergy) + + def AssemblePA(self, *args): + r""" + AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes) + AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + """ + return _nonlininteg.NonlinearFormIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)""" + return _nonlininteg.NonlinearFormIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_nonlininteg.NonlinearFormIntegrator_AddMultPA) __swig_destroy__ = _nonlininteg.delete_NonlinearFormIntegrator def __disown__(self): self.this.disown() @@ -147,22 +172,27 @@ class BlockNonlinearFormIntegrator(object): def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double""" return _nonlininteg.BlockNonlinearFormIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_GetElementEnergy) def AssembleElementVector(self, el, Tr, elfun, elvec): r"""AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleElementVector(self, el, Tr, elfun, elvec) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleElementVector) def AssembleFaceVector(self, el1, el2, Tr, elfun, elvect): r"""AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceVector(self, el1, el2, Tr, elfun, elvect) + AssembleFaceVector = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceVector) def AssembleElementGrad(self, el, Tr, elfun, elmats): r"""AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmats) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleElementGrad) def AssembleFaceGrad(self, el1, el2, Tr, elfun, elmats): r"""AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)""" return _nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceGrad(self, el1, el2, Tr, elfun, elmats) + AssembleFaceGrad = _swig_new_instance_method(_nonlininteg.BlockNonlinearFormIntegrator_AssembleFaceGrad) __swig_destroy__ = _nonlininteg.delete_BlockNonlinearFormIntegrator def __init__(self): @@ -185,18 +215,22 @@ def __init__(self, *args, **kwargs): def SetTransformation(self, _Ttr): r"""SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)""" return _nonlininteg.HyperelasticModel_SetTransformation(self, _Ttr) + SetTransformation = _swig_new_instance_method(_nonlininteg.HyperelasticModel_SetTransformation) def EvalW(self, Jpt): r"""EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double""" return _nonlininteg.HyperelasticModel_EvalW(self, Jpt) + EvalW = _swig_new_instance_method(_nonlininteg.HyperelasticModel_EvalW) def EvalP(self, Jpt, P): r"""EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)""" return _nonlininteg.HyperelasticModel_EvalP(self, Jpt, P) + EvalP = _swig_new_instance_method(_nonlininteg.HyperelasticModel_EvalP) def AssembleH(self, Jpt, DS, weight, A): r"""AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)""" return _nonlininteg.HyperelasticModel_AssembleH(self, Jpt, DS, weight, A) + AssembleH = _swig_new_instance_method(_nonlininteg.HyperelasticModel_AssembleH) # Register HyperelasticModel in _nonlininteg: _nonlininteg.HyperelasticModel_swigregister(HyperelasticModel) @@ -210,14 +244,17 @@ class InverseHarmonicModel(HyperelasticModel): def EvalW(self, J): r"""EvalW(InverseHarmonicModel self, DenseMatrix J) -> double""" return _nonlininteg.InverseHarmonicModel_EvalW(self, J) + EvalW = _swig_new_instance_method(_nonlininteg.InverseHarmonicModel_EvalW) def EvalP(self, J, P): r"""EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)""" return _nonlininteg.InverseHarmonicModel_EvalP(self, J, P) + EvalP = _swig_new_instance_method(_nonlininteg.InverseHarmonicModel_EvalP) def AssembleH(self, J, DS, weight, A): r"""AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)""" return _nonlininteg.InverseHarmonicModel_AssembleH(self, J, DS, weight, A) + AssembleH = _swig_new_instance_method(_nonlininteg.InverseHarmonicModel_AssembleH) def __init__(self): r"""__init__(InverseHarmonicModel self) -> InverseHarmonicModel""" @@ -243,14 +280,17 @@ def __init__(self, *args): def EvalW(self, J): r"""EvalW(NeoHookeanModel self, DenseMatrix J) -> double""" return _nonlininteg.NeoHookeanModel_EvalW(self, J) + EvalW = _swig_new_instance_method(_nonlininteg.NeoHookeanModel_EvalW) def EvalP(self, J, P): r"""EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)""" return _nonlininteg.NeoHookeanModel_EvalP(self, J, P) + EvalP = _swig_new_instance_method(_nonlininteg.NeoHookeanModel_EvalP) def AssembleH(self, J, DS, weight, A): r"""AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)""" return _nonlininteg.NeoHookeanModel_AssembleH(self, J, DS, weight, A) + AssembleH = _swig_new_instance_method(_nonlininteg.NeoHookeanModel_AssembleH) __swig_destroy__ = _nonlininteg.delete_NeoHookeanModel # Register NeoHookeanModel in _nonlininteg: @@ -269,14 +309,17 @@ def __init__(self, m): def GetElementEnergy(self, el, Ttr, elfun): r"""GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double""" return _nonlininteg.HyperelasticNLFIntegrator_GetElementEnergy(self, el, Ttr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.HyperelasticNLFIntegrator_GetElementEnergy) def AssembleElementVector(self, el, Ttr, elfun, elvect): r"""AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)""" return _nonlininteg.HyperelasticNLFIntegrator_AssembleElementVector(self, el, Ttr, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.HyperelasticNLFIntegrator_AssembleElementVector) def AssembleElementGrad(self, el, Ttr, elfun, elmat): r"""AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)""" return _nonlininteg.HyperelasticNLFIntegrator_AssembleElementGrad(self, el, Ttr, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.HyperelasticNLFIntegrator_AssembleElementGrad) __swig_destroy__ = _nonlininteg.delete_HyperelasticNLFIntegrator # Register HyperelasticNLFIntegrator in _nonlininteg: @@ -295,18 +338,73 @@ def __init__(self, _mu): def GetElementEnergy(self, el, Tr, elfun): r"""GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double""" return _nonlininteg.IncompressibleNeoHookeanIntegrator_GetElementEnergy(self, el, Tr, elfun) + GetElementEnergy = _swig_new_instance_method(_nonlininteg.IncompressibleNeoHookeanIntegrator_GetElementEnergy) def AssembleElementVector(self, el, Tr, elfun, elvec): r"""AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)""" return _nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementVector(self, el, Tr, elfun, elvec) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementVector) def AssembleElementGrad(self, el, Tr, elfun, elmats): r"""AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)""" return _nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementGrad(self, el, Tr, elfun, elmats) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.IncompressibleNeoHookeanIntegrator_AssembleElementGrad) __swig_destroy__ = _nonlininteg.delete_IncompressibleNeoHookeanIntegrator # Register IncompressibleNeoHookeanIntegrator in _nonlininteg: _nonlininteg.IncompressibleNeoHookeanIntegrator_swigregister(IncompressibleNeoHookeanIntegrator) +class VectorConvectionNLFIntegrator(NonlinearFormIntegrator): + r"""Proxy of C++ mfem::VectorConvectionNLFIntegrator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(VectorConvectionNLFIntegrator self, Coefficient q) -> VectorConvectionNLFIntegrator + __init__(VectorConvectionNLFIntegrator self) -> VectorConvectionNLFIntegrator + """ + _nonlininteg.VectorConvectionNLFIntegrator_swiginit(self, _nonlininteg.new_VectorConvectionNLFIntegrator(*args)) + + @staticmethod + def GetRule(fe, T): + r"""GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule""" + return _nonlininteg.VectorConvectionNLFIntegrator_GetRule(fe, T) + GetRule = _swig_new_static_method(_nonlininteg.VectorConvectionNLFIntegrator_GetRule) + + def AssembleElementVector(self, el, trans, elfun, elvect): + r"""AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)""" + return _nonlininteg.VectorConvectionNLFIntegrator_AssembleElementVector(self, el, trans, elfun, elvect) + AssembleElementVector = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AssembleElementVector) + + def AssembleElementGrad(self, el, trans, elfun, elmat): + r"""AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)""" + return _nonlininteg.VectorConvectionNLFIntegrator_AssembleElementGrad(self, el, trans, elfun, elmat) + AssembleElementGrad = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AssembleElementGrad) + + def AssemblePA(self, *args): + r""" + AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes) + AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes) + AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes) + """ + return _nonlininteg.VectorConvectionNLFIntegrator_AssemblePA(self, *args) + AssemblePA = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AssemblePA) + + def AddMultPA(self, x, y): + r"""AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)""" + return _nonlininteg.VectorConvectionNLFIntegrator_AddMultPA(self, x, y) + AddMultPA = _swig_new_instance_method(_nonlininteg.VectorConvectionNLFIntegrator_AddMultPA) + __swig_destroy__ = _nonlininteg.delete_VectorConvectionNLFIntegrator + +# Register VectorConvectionNLFIntegrator in _nonlininteg: +_nonlininteg.VectorConvectionNLFIntegrator_swigregister(VectorConvectionNLFIntegrator) + +def VectorConvectionNLFIntegrator_GetRule(fe, T): + r"""VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule""" + return _nonlininteg.VectorConvectionNLFIntegrator_GetRule(fe, T) +VectorConvectionNLFIntegrator_GetRule = _nonlininteg.VectorConvectionNLFIntegrator_GetRule + diff --git a/mfem/_ser/nonlininteg_wrap.cxx b/mfem/_ser/nonlininteg_wrap.cxx index 068385c1..8047b191 100644 --- a/mfem/_ser/nonlininteg_wrap.cxx +++ b/mfem/_ser/nonlininteg_wrap.cxx @@ -3066,154 +3066,159 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t swig_types[5] -#define SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t swig_types[6] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t swig_types[7] -#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t swig_types[8] -#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[9] -#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[10] -#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[11] -#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[12] -#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[13] -#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[14] -#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[15] -#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[16] -#define SWIGTYPE_p_mfem__Coefficient swig_types[17] -#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[18] -#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[19] -#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[20] -#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[21] -#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[22] -#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[23] -#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[24] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[25] -#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[26] -#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[27] -#define SWIGTYPE_p_mfem__ElementTransformation swig_types[28] -#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[29] -#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[30] -#define SWIGTYPE_p_mfem__FiniteElement swig_types[31] -#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[32] -#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[33] -#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[34] -#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[35] -#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[36] -#define SWIGTYPE_p_mfem__GridFunction swig_types[37] -#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[38] -#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[39] -#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[40] -#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[41] -#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[42] -#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[43] -#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[44] -#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[45] -#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[46] -#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[47] -#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[48] -#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[49] -#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[50] -#define SWIGTYPE_p_mfem__HyperelasticModel swig_types[51] -#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[52] -#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[53] -#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[54] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[55] -#define SWIGTYPE_p_mfem__InverseHarmonicModel swig_types[56] -#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[57] -#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[58] -#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[59] -#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[60] -#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[61] -#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[62] -#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[63] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[64] -#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[65] -#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[66] -#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[67] -#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[68] -#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[69] -#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[70] -#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[71] -#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[72] -#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[73] -#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[74] -#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[75] -#define SWIGTYPE_p_mfem__LinearForm swig_types[76] -#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[77] -#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[78] -#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[79] -#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[80] -#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[81] -#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[82] -#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[83] -#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[84] -#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[85] -#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[86] -#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[87] -#define SWIGTYPE_p_mfem__NeoHookeanModel swig_types[88] -#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[89] -#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[90] -#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[91] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[92] -#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[93] -#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[94] -#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[95] -#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[96] -#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[97] -#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[98] -#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[99] -#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[100] -#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[101] -#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[102] -#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[103] -#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[104] -#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[105] -#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[106] -#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[107] -#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[108] -#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[109] -#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[110] -#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[111] -#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[112] -#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[113] -#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[114] -#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[115] -#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[116] -#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[117] -#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[118] -#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[119] -#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[120] -#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[121] -#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[122] -#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[123] -#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[124] -#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[125] -#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[126] -#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[127] -#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[128] -#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[129] -#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[130] -#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[131] -#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[132] -#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[133] -#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[134] -#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[135] -#define SWIGTYPE_p_mfem__SumCoefficient swig_types[136] -#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[137] -#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[138] -#define SWIGTYPE_p_mfem__Vector swig_types[139] -#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[140] -#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[141] -#define SWIGTYPE_p_pri_t swig_types[142] -#define SWIGTYPE_p_quad_t swig_types[143] -#define SWIGTYPE_p_seg_t swig_types[144] -#define SWIGTYPE_p_tet_t swig_types[145] -#define SWIGTYPE_p_tri_t swig_types[146] -static swig_type_info *swig_types[148]; -static swig_module_info swig_module = {swig_types, 147, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t swig_types[7] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t swig_types[8] +#define SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t swig_types[9] +#define SWIGTYPE_p_mfem__BiCubic2DFiniteElement swig_types[10] +#define SWIGTYPE_p_mfem__BiCubic3DFiniteElement swig_types[11] +#define SWIGTYPE_p_mfem__BiLinear2DFiniteElement swig_types[12] +#define SWIGTYPE_p_mfem__BiLinear3DFiniteElement swig_types[13] +#define SWIGTYPE_p_mfem__BiQuad2DFiniteElement swig_types[14] +#define SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement swig_types[15] +#define SWIGTYPE_p_mfem__BiQuadratic3DFiniteElement swig_types[16] +#define SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator swig_types[17] +#define SWIGTYPE_p_mfem__Coefficient swig_types[18] +#define SWIGTYPE_p_mfem__ConstantCoefficient swig_types[19] +#define SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement swig_types[20] +#define SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement swig_types[21] +#define SWIGTYPE_p_mfem__Cubic1DFiniteElement swig_types[22] +#define SWIGTYPE_p_mfem__Cubic2DFiniteElement swig_types[23] +#define SWIGTYPE_p_mfem__Cubic3DFiniteElement swig_types[24] +#define SWIGTYPE_p_mfem__DeltaCoefficient swig_types[25] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[26] +#define SWIGTYPE_p_mfem__DeterminantCoefficient swig_types[27] +#define SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient swig_types[28] +#define SWIGTYPE_p_mfem__ElementTransformation swig_types[29] +#define SWIGTYPE_p_mfem__ExtrudeCoefficient swig_types[30] +#define SWIGTYPE_p_mfem__FaceElementTransformations swig_types[31] +#define SWIGTYPE_p_mfem__FiniteElement swig_types[32] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[33] +#define SWIGTYPE_p_mfem__FunctionCoefficient swig_types[34] +#define SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement swig_types[35] +#define SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement swig_types[36] +#define SWIGTYPE_p_mfem__GaussLinear2DFiniteElement swig_types[37] +#define SWIGTYPE_p_mfem__GaussQuad2DFiniteElement swig_types[38] +#define SWIGTYPE_p_mfem__GridFunction swig_types[39] +#define SWIGTYPE_p_mfem__GridFunctionCoefficient swig_types[40] +#define SWIGTYPE_p_mfem__H1Pos_HexahedronElement swig_types[41] +#define SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement swig_types[42] +#define SWIGTYPE_p_mfem__H1Pos_SegmentElement swig_types[43] +#define SWIGTYPE_p_mfem__H1Pos_TetrahedronElement swig_types[44] +#define SWIGTYPE_p_mfem__H1Pos_TriangleElement swig_types[45] +#define SWIGTYPE_p_mfem__H1Pos_WedgeElement swig_types[46] +#define SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement swig_types[47] +#define SWIGTYPE_p_mfem__H1_HexahedronElement swig_types[48] +#define SWIGTYPE_p_mfem__H1_QuadrilateralElement swig_types[49] +#define SWIGTYPE_p_mfem__H1_SegmentElement swig_types[50] +#define SWIGTYPE_p_mfem__H1_TetrahedronElement swig_types[51] +#define SWIGTYPE_p_mfem__H1_TriangleElement swig_types[52] +#define SWIGTYPE_p_mfem__H1_WedgeElement swig_types[53] +#define SWIGTYPE_p_mfem__HyperelasticModel swig_types[54] +#define SWIGTYPE_p_mfem__HyperelasticNLFIntegrator swig_types[55] +#define SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator swig_types[56] +#define SWIGTYPE_p_mfem__InnerProductCoefficient swig_types[57] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[58] +#define SWIGTYPE_p_mfem__InverseHarmonicModel swig_types[59] +#define SWIGTYPE_p_mfem__IsoparametricTransformation swig_types[60] +#define SWIGTYPE_p_mfem__L2Pos_HexahedronElement swig_types[61] +#define SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement swig_types[62] +#define SWIGTYPE_p_mfem__L2Pos_SegmentElement swig_types[63] +#define SWIGTYPE_p_mfem__L2Pos_TetrahedronElement swig_types[64] +#define SWIGTYPE_p_mfem__L2Pos_TriangleElement swig_types[65] +#define SWIGTYPE_p_mfem__L2Pos_WedgeElement swig_types[66] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[67] +#define SWIGTYPE_p_mfem__L2_HexahedronElement swig_types[68] +#define SWIGTYPE_p_mfem__L2_QuadrilateralElement swig_types[69] +#define SWIGTYPE_p_mfem__L2_SegmentElement swig_types[70] +#define SWIGTYPE_p_mfem__L2_TetrahedronElement swig_types[71] +#define SWIGTYPE_p_mfem__L2_TriangleElement swig_types[72] +#define SWIGTYPE_p_mfem__L2_WedgeElement swig_types[73] +#define SWIGTYPE_p_mfem__Lagrange1DFiniteElement swig_types[74] +#define SWIGTYPE_p_mfem__LagrangeHexFiniteElement swig_types[75] +#define SWIGTYPE_p_mfem__Linear1DFiniteElement swig_types[76] +#define SWIGTYPE_p_mfem__Linear2DFiniteElement swig_types[77] +#define SWIGTYPE_p_mfem__Linear3DFiniteElement swig_types[78] +#define SWIGTYPE_p_mfem__LinearForm swig_types[79] +#define SWIGTYPE_p_mfem__ND_HexahedronElement swig_types[80] +#define SWIGTYPE_p_mfem__ND_QuadrilateralElement swig_types[81] +#define SWIGTYPE_p_mfem__ND_SegmentElement swig_types[82] +#define SWIGTYPE_p_mfem__ND_TetrahedronElement swig_types[83] +#define SWIGTYPE_p_mfem__ND_TriangleElement swig_types[84] +#define SWIGTYPE_p_mfem__NURBS1DFiniteElement swig_types[85] +#define SWIGTYPE_p_mfem__NURBS2DFiniteElement swig_types[86] +#define SWIGTYPE_p_mfem__NURBS3DFiniteElement swig_types[87] +#define SWIGTYPE_p_mfem__NURBSFiniteElement swig_types[88] +#define SWIGTYPE_p_mfem__Nedelec1HexFiniteElement swig_types[89] +#define SWIGTYPE_p_mfem__Nedelec1TetFiniteElement swig_types[90] +#define SWIGTYPE_p_mfem__NeoHookeanModel swig_types[91] +#define SWIGTYPE_p_mfem__NodalFiniteElement swig_types[92] +#define SWIGTYPE_p_mfem__NodalTensorFiniteElement swig_types[93] +#define SWIGTYPE_p_mfem__NonlinearFormIntegrator swig_types[94] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[95] +#define SWIGTYPE_p_mfem__P0HexFiniteElement swig_types[96] +#define SWIGTYPE_p_mfem__P0QuadFiniteElement swig_types[97] +#define SWIGTYPE_p_mfem__P0SegmentFiniteElement swig_types[98] +#define SWIGTYPE_p_mfem__P0TetFiniteElement swig_types[99] +#define SWIGTYPE_p_mfem__P0TriangleFiniteElement swig_types[100] +#define SWIGTYPE_p_mfem__P0WedgeFiniteElement swig_types[101] +#define SWIGTYPE_p_mfem__P1OnQuadFiniteElement swig_types[102] +#define SWIGTYPE_p_mfem__P1SegmentFiniteElement swig_types[103] +#define SWIGTYPE_p_mfem__P1TetNonConfFiniteElement swig_types[104] +#define SWIGTYPE_p_mfem__P2SegmentFiniteElement swig_types[105] +#define SWIGTYPE_p_mfem__PWConstCoefficient swig_types[106] +#define SWIGTYPE_p_mfem__PointFiniteElement swig_types[107] +#define SWIGTYPE_p_mfem__PositiveFiniteElement swig_types[108] +#define SWIGTYPE_p_mfem__PositiveTensorFiniteElement swig_types[109] +#define SWIGTYPE_p_mfem__PowerCoefficient swig_types[110] +#define SWIGTYPE_p_mfem__ProductCoefficient swig_types[111] +#define SWIGTYPE_p_mfem__PyCoefficientBase swig_types[112] +#define SWIGTYPE_p_mfem__Quad1DFiniteElement swig_types[113] +#define SWIGTYPE_p_mfem__Quad2DFiniteElement swig_types[114] +#define SWIGTYPE_p_mfem__QuadPos1DFiniteElement swig_types[115] +#define SWIGTYPE_p_mfem__Quadratic3DFiniteElement swig_types[116] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[117] +#define SWIGTYPE_p_mfem__RT0HexFiniteElement swig_types[118] +#define SWIGTYPE_p_mfem__RT0QuadFiniteElement swig_types[119] +#define SWIGTYPE_p_mfem__RT0TetFiniteElement swig_types[120] +#define SWIGTYPE_p_mfem__RT0TriangleFiniteElement swig_types[121] +#define SWIGTYPE_p_mfem__RT1HexFiniteElement swig_types[122] +#define SWIGTYPE_p_mfem__RT1QuadFiniteElement swig_types[123] +#define SWIGTYPE_p_mfem__RT1TriangleFiniteElement swig_types[124] +#define SWIGTYPE_p_mfem__RT2QuadFiniteElement swig_types[125] +#define SWIGTYPE_p_mfem__RT2TriangleFiniteElement swig_types[126] +#define SWIGTYPE_p_mfem__RT_HexahedronElement swig_types[127] +#define SWIGTYPE_p_mfem__RT_QuadrilateralElement swig_types[128] +#define SWIGTYPE_p_mfem__RT_TetrahedronElement swig_types[129] +#define SWIGTYPE_p_mfem__RT_TriangleElement swig_types[130] +#define SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement swig_types[131] +#define SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement swig_types[132] +#define SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement swig_types[133] +#define SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement swig_types[134] +#define SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement swig_types[135] +#define SWIGTYPE_p_mfem__RestrictedCoefficient swig_types[136] +#define SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement swig_types[137] +#define SWIGTYPE_p_mfem__ScalarFiniteElement swig_types[138] +#define SWIGTYPE_p_mfem__SumCoefficient swig_types[139] +#define SWIGTYPE_p_mfem__TransformedCoefficient swig_types[140] +#define SWIGTYPE_p_mfem__TriLinear3DFiniteElement swig_types[141] +#define SWIGTYPE_p_mfem__Vector swig_types[142] +#define SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator swig_types[143] +#define SWIGTYPE_p_mfem__VectorFiniteElement swig_types[144] +#define SWIGTYPE_p_mfem__VectorRotProductCoefficient swig_types[145] +#define SWIGTYPE_p_mfem__VectorTensorFiniteElement swig_types[146] +#define SWIGTYPE_p_pri_t swig_types[147] +#define SWIGTYPE_p_quad_t swig_types[148] +#define SWIGTYPE_p_seg_t swig_types[149] +#define SWIGTYPE_p_tet_t swig_types[150] +#define SWIGTYPE_p_tri_t swig_types[151] +static swig_type_info *swig_types[153]; +static swig_module_info swig_module = {swig_types, 152, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3557,6 +3562,88 @@ double SwigDirector_NonlinearFormIntegrator::GetElementEnergy(mfem::FiniteElemen } +void SwigDirector_NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call NonlinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 5; + const char *const swig_method_name = "AssemblePA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&trial_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&test_fes), SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call NonlinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "AssemblePA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AssemblePA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_NonlinearFormIntegrator::AddMultPA(mfem::Vector const &x, mfem::Vector &y) const { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call NonlinearFormIntegrator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "AddMultPA"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("AddMultPA"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + SwigDirector_NonlinearFormIntegrator::~SwigDirector_NonlinearFormIntegrator() { } @@ -4272,38 +4359,59 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW } -SWIGINTERN PyObject *_wrap_delete_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + Swig::Director *director = 0; + bool upcall = false; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonlinearFormIntegrator" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - { - try { - delete arg1; - } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::NonlinearFormIntegrator::AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } else { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); + } + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } #endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } resultobj = SWIG_Py_Void(); return resultobj; @@ -4312,25 +4420,71 @@ SWIGINTERN PyObject *_wrap_delete_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_disown_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + Swig::Director *director = 0; + bool upcall = false; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_NonlinearFormIntegrator" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - { - Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); - if (director) director->swig_disown(); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + (arg1)->mfem::NonlinearFormIntegrator::AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); + } else { + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } - resultobj = SWIG_Py_Void(); return resultobj; fail: @@ -4338,71 +4492,258 @@ SWIGINTERN PyObject *_wrap_disown_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *NonlinearFormIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NonlinearFormIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NonlinearFormIntegrator_AssemblePA__SWIG_0(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NonlinearFormIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NonlinearFormIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n" + " mfem::NonlinearFormIntegrator::AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n"); + return 0; } -SWIGINTERN PyObject *NonlinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; - mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Array< mfem::Vector const * > *arg4 = 0 ; + mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - double result; + PyObject *swig_obj[3] ; + Swig::Director *director = 0; + bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - { - try { - result = (double)(arg1)->GetElementEnergy((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4); - } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + ((mfem::NonlinearFormIntegrator const *)arg1)->mfem::NonlinearFormIntegrator::AddMultPA((mfem::Vector const &)*arg2,*arg3); + } else { + ((mfem::NonlinearFormIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); + } + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NonlinearFormIntegrator" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_disown_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_NonlinearFormIntegrator" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *NonlinearFormIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NonlinearFormIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NonlinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; + mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Array< mfem::Vector const * > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); + { + try { + result = (double)(arg1)->GetElementEnergy((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); s = s + s2; SWIG_exception(SWIG_RuntimeError, s.c_str()); } @@ -6325,19 +6666,681 @@ SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIG PyObject *swig_obj[1] ; mfem::IncompressibleNeoHookeanIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::IncompressibleNeoHookeanIntegrator *)new mfem::IncompressibleNeoHookeanIntegrator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; + mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Array< mfem::Vector const * > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); + { + try { + result = (double)(arg1)->GetElementEnergy((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; + mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Array< mfem::Vector const * > *arg4 = 0 ; + mfem::Array< mfem::Vector * > *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); + } + arg5 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp5); + { + try { + (arg1)->AssembleElementVector((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4,(mfem::Array< mfem::Vector * > const &)*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; + mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Array< mfem::Vector const * > *arg4 = 0 ; + mfem::Array2D< mfem::DenseMatrix * > *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); + } + arg5 = reinterpret_cast< mfem::Array2D< mfem::DenseMatrix * > * >(argp5); + { + try { + (arg1)->AssembleElementGrad((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4,(mfem::Array2D< mfem::DenseMatrix * > const &)*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_IncompressibleNeoHookeanIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IncompressibleNeoHookeanIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *IncompressibleNeoHookeanIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Coefficient *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::VectorConvectionNLFIntegrator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorConvectionNLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorConvectionNLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + } + arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + { + try { + result = (mfem::VectorConvectionNLFIntegrator *)new mfem::VectorConvectionNLFIntegrator(*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::VectorConvectionNLFIntegrator *)new mfem::VectorConvectionNLFIntegrator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorConvectionNLFIntegrator", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorConvectionNLFIntegrator__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_VectorConvectionNLFIntegrator__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorConvectionNLFIntegrator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::VectorConvectionNLFIntegrator::VectorConvectionNLFIntegrator(mfem::Coefficient &)\n" + " mfem::VectorConvectionNLFIntegrator::VectorConvectionNLFIntegrator()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElement *arg1 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::IntegrationRule *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + { + try { + result = (mfem::IntegrationRule *) &mfem::VectorConvectionNLFIntegrator::GetRule((mfem::FiniteElement const &)*arg1,*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + { + try { + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + { + try { + (arg1)->AssembleElementGrad((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::IncompressibleNeoHookeanIntegrator *)new mfem::IncompressibleNeoHookeanIntegrator(*arg1); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6354,63 +7357,50 @@ SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIG SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; - mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Array< mfem::Vector const * > *arg4 = 0 ; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + mfem::FiniteElementSpace *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - double result; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "3"" of type '" "mfem::FiniteElementSpace const &""'"); } - arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); + arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); { try { - result = (double)(arg1)->GetElementEnergy((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2,(mfem::FiniteElementSpace const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6427,73 +7417,39 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; - mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Array< mfem::Vector const * > *arg4 = 0 ; - mfem::Array< mfem::Vector * > *arg5 = 0 ; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssemblePA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); - } - arg5 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp5); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->AssembleElementVector((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4,(mfem::Array< mfem::Vector * > const &)*arg5); + (arg1)->AssemblePA((mfem::FiniteElementSpace const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6517,66 +7473,106 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssemblePA", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_VectorConvectionNLFIntegrator_AssemblePA__SWIG_0_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorConvectionNLFIntegrator_AssemblePA'.\n" + " Possible C/C++ prototypes are:\n" + " AssemblePA(mfem::FiniteElementSpace const &)\n" + " AssemblePA(mfem::FiniteElementSpace const &,mfem::FiniteElementSpace const &)\n" + " mfem::VectorConvectionNLFIntegrator::AssemblePA(mfem::FiniteElementSpace const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; - mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Array< mfem::Vector const * > *arg4 = 0 ; - mfem::Array2D< mfem::DenseMatrix * > *arg5 = 0 ; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator const *""'"); } - arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::Array2D< mfem::DenseMatrix * > * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->AssembleElementGrad((mfem::Array< mfem::FiniteElement const * > const &)*arg2,*arg3,(mfem::Array< mfem::Vector const * > const &)*arg4,(mfem::Array2D< mfem::DenseMatrix * > const &)*arg5); + ((mfem::VectorConvectionNLFIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6600,20 +7596,20 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra } -SWIGINTERN PyObject *_wrap_delete_IncompressibleNeoHookeanIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_VectorConvectionNLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; + mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VectorConvectionNLFIntegrator" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); + arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); { try { delete arg1; @@ -6640,19 +7636,20 @@ SWIGINTERN PyObject *_wrap_delete_IncompressibleNeoHookeanIntegrator(PyObject *S } -SWIGINTERN PyObject *IncompressibleNeoHookeanIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorConvectionNLFIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *IncompressibleNeoHookeanIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *VectorConvectionNLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, @@ -6661,6 +7658,11 @@ static PyMethodDef SwigMethods[] = { { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "NonlinearFormIntegrator_GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" + "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "NonlinearFormIntegrator_AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, @@ -6711,10 +7713,107 @@ static PyMethodDef SwigMethods[] = { { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorConvectionNLFIntegrator", _wrap_new_VectorConvectionNLFIntegrator, METH_VARARGS, "\n" + "VectorConvectionNLFIntegrator(Coefficient q)\n" + "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" + ""}, + { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" + "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + ""}, + { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "VectorConvectionNLFIntegrator_AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, + { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, + { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, + { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, + { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, + { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" + "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + ""}, + { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, + { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, + { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, + { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, + { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, + { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, + { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, + { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, + { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, + { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, + { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, + { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, + { "HyperelasticModel_EvalP", _wrap_HyperelasticModel_EvalP, METH_VARARGS, "EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, + { "HyperelasticModel_AssembleH", _wrap_HyperelasticModel_AssembleH, METH_VARARGS, "AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "HyperelasticModel_swigregister", HyperelasticModel_swigregister, METH_O, NULL}, + { "InverseHarmonicModel_EvalW", _wrap_InverseHarmonicModel_EvalW, METH_VARARGS, "EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, + { "InverseHarmonicModel_EvalP", _wrap_InverseHarmonicModel_EvalP, METH_VARARGS, "EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, + { "InverseHarmonicModel_AssembleH", _wrap_InverseHarmonicModel_AssembleH, METH_VARARGS, "AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "new_InverseHarmonicModel", _wrap_new_InverseHarmonicModel, METH_NOARGS, "new_InverseHarmonicModel() -> InverseHarmonicModel"}, + { "delete_InverseHarmonicModel", _wrap_delete_InverseHarmonicModel, METH_O, "delete_InverseHarmonicModel(InverseHarmonicModel self)"}, + { "InverseHarmonicModel_swigregister", InverseHarmonicModel_swigregister, METH_O, NULL}, + { "InverseHarmonicModel_swiginit", InverseHarmonicModel_swiginit, METH_VARARGS, NULL}, + { "new_NeoHookeanModel", _wrap_new_NeoHookeanModel, METH_VARARGS, "\n" + "NeoHookeanModel(double _mu, double _K, double _g=1.0)\n" + "NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None)\n" + ""}, + { "NeoHookeanModel_EvalW", _wrap_NeoHookeanModel_EvalW, METH_VARARGS, "EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, + { "NeoHookeanModel_EvalP", _wrap_NeoHookeanModel_EvalP, METH_VARARGS, "EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, + { "NeoHookeanModel_AssembleH", _wrap_NeoHookeanModel_AssembleH, METH_VARARGS, "AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "delete_NeoHookeanModel", _wrap_delete_NeoHookeanModel, METH_O, "delete_NeoHookeanModel(NeoHookeanModel self)"}, + { "NeoHookeanModel_swigregister", NeoHookeanModel_swigregister, METH_O, NULL}, + { "NeoHookeanModel_swiginit", NeoHookeanModel_swiginit, METH_VARARGS, NULL}, + { "new_HyperelasticNLFIntegrator", _wrap_new_HyperelasticNLFIntegrator, METH_O, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, + { "HyperelasticNLFIntegrator_GetElementEnergy", _wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, + { "HyperelasticNLFIntegrator_AssembleElementVector", _wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, + { "HyperelasticNLFIntegrator_AssembleElementGrad", _wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, + { "delete_HyperelasticNLFIntegrator", _wrap_delete_HyperelasticNLFIntegrator, METH_O, "delete_HyperelasticNLFIntegrator(HyperelasticNLFIntegrator self)"}, + { "HyperelasticNLFIntegrator_swigregister", HyperelasticNLFIntegrator_swigregister, METH_O, NULL}, + { "HyperelasticNLFIntegrator_swiginit", HyperelasticNLFIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_IncompressibleNeoHookeanIntegrator", _wrap_new_IncompressibleNeoHookeanIntegrator, METH_O, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, + { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", _wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, + { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, + { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, + { "new_VectorConvectionNLFIntegrator", _wrap_new_VectorConvectionNLFIntegrator, METH_VARARGS, "\n" + "VectorConvectionNLFIntegrator(Coefficient q)\n" + "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" + ""}, + { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" + "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" + "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" + ""}, + { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, + { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, + { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -6730,6 +7829,9 @@ static void *_p_mfem__NeoHookeanModelTo_p_mfem__HyperelasticModel(void *x, int * static void *_p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::HyperelasticNLFIntegrator *) x)); } +static void *_p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NonlinearFormIntegrator *) ((mfem::VectorConvectionNLFIntegrator *) x)); +} static void *_p_mfem__IncompressibleNeoHookeanIntegratorTo_p_mfem__BlockNonlinearFormIntegrator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::BlockNonlinearFormIntegrator *) ((mfem::IncompressibleNeoHookeanIntegrator *) x)); } @@ -6781,12 +7883,6 @@ static void *_p_mfem__ConstantCoefficientTo_p_mfem__Coefficient(void *x, int *SW static void *_p_mfem__ExtrudeCoefficientTo_p_mfem__Coefficient(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Coefficient *) ((mfem::ExtrudeCoefficient *) x)); } -static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); -} -static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); -} static void *_p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_SegmentElement *) x)); } @@ -6820,6 +7916,9 @@ static void *_p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement(void *x, int *S static void *_p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_HexahedronElement *) x)); } +static void *_p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *) ((mfem::H1Ser_QuadrilateralElement *) x)); +} static void *_p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::H1Pos_QuadrilateralElement *) x)); } @@ -6835,6 +7934,9 @@ static void *_p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, i static void *_p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::H1_SegmentElement *) x)); } +static void *_p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::VectorTensorFiniteElement *) x)); +} static void *_p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *) ((mfem::PositiveTensorFiniteElement *) x)); } @@ -7003,6 +8105,12 @@ static void *_p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement(void *x, static void *_p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT1QuadFiniteElement *) x)); } +static void *_p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_SegmentElement *) x)); +} +static void *_p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::NodalFiniteElement *)(mfem::NodalTensorFiniteElement *) ((mfem::L2_QuadrilateralElement *) x)); +} static void *_p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::ScalarFiniteElement *)(mfem::PositiveFiniteElement *)(mfem::PositiveTensorFiniteElement *) ((mfem::L2Pos_QuadrilateralElement *) x)); } @@ -7046,10 +8154,10 @@ static void *_p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::RT_TetrahedronElement *) x)); } static void *_p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_HexahedronElement *) x)); } static void *_p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); + return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *)(mfem::VectorTensorFiniteElement *) ((mfem::ND_QuadrilateralElement *) x)); } static void *_p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::FiniteElement *) (mfem::VectorFiniteElement *) ((mfem::ND_TetrahedronElement *) x)); @@ -7085,6 +8193,7 @@ static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(n return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -7131,13 +8240,11 @@ static swig_type_info _swigt__p_mfem__RT0TetFiniteElement = {"_p_mfem__RT0TetFin static swig_type_info _swigt__p_mfem__RotTriLinearHexFiniteElement = {"_p_mfem__RotTriLinearHexFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NodalTensorFiniteElement = {"_p_mfem__NodalTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PositiveTensorFiniteElement = {"_p_mfem__PositiveTensorFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorTensorFiniteElement = {"_p_mfem__VectorTensorFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_SegmentElement = {"_p_mfem__H1_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_QuadrilateralElement = {"_p_mfem__H1_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_HexahedronElement = {"_p_mfem__H1_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_SegmentElement = {"_p_mfem__H1Pos_SegmentElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_SegmentElement = {"_p_mfem__L2_SegmentElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_WedgeElement = {"_p_mfem__H1Pos_WedgeElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__BiCubic3DFiniteElement = {"_p_mfem__BiCubic3DFiniteElement", 0, 0, 0, 0, 0}; @@ -7149,6 +8256,8 @@ static swig_type_info _swigt__p_mfem__H1Pos_TriangleElement = {"_p_mfem__H1Pos_T static swig_type_info _swigt__p_mfem__H1_TetrahedronElement = {"_p_mfem__H1_TetrahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1_TriangleElement = {"_p_mfem__H1_TriangleElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__H1Pos_HexahedronElement = {"_p_mfem__H1Pos_HexahedronElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Ser_QuadrilateralElement = {"_p_mfem__H1Ser_QuadrilateralElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__H1Pos_QuadrilateralElement = {"_p_mfem__H1Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P0TetFiniteElement = {"_p_mfem__P0TetFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__P1TetNonConfFiniteElement = {"_p_mfem__P1TetNonConfFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Lagrange1DFiniteElement = {"_p_mfem__Lagrange1DFiniteElement", 0, 0, 0, 0, 0}; @@ -7190,6 +8299,8 @@ static swig_type_info _swigt__p_mfem__Quad1DFiniteElement = {"_p_mfem__Quad1DFin static swig_type_info _swigt__p_mfem__QuadPos1DFiniteElement = {"_p_mfem__QuadPos1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Quad2DFiniteElement = {"_p_mfem__Quad2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RT1QuadFiniteElement = {"_p_mfem__RT1QuadFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2Pos_SegmentElement = {"_p_mfem__L2Pos_SegmentElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__L2_QuadrilateralElement = {"_p_mfem__L2_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_QuadrilateralElement = {"_p_mfem__L2Pos_QuadrilateralElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2_HexahedronElement = {"_p_mfem__L2_HexahedronElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__L2Pos_HexahedronElement = {"_p_mfem__L2Pos_HexahedronElement", 0, 0, 0, 0, 0}; @@ -7213,6 +8324,7 @@ static swig_type_info _swigt__p_mfem__NURBSFiniteElement = {"_p_mfem__NURBSFinit static swig_type_info _swigt__p_mfem__NURBS1DFiniteElement = {"_p_mfem__NURBS1DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS2DFiniteElement = {"_p_mfem__NURBS2DFiniteElement", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__NURBS3DFiniteElement = {"_p_mfem__NURBS3DFiniteElement", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HyperelasticModel = {"_p_mfem__HyperelasticModel", "mfem::HyperelasticModel *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__HyperelasticNLFIntegrator = {"_p_mfem__HyperelasticNLFIntegrator", "mfem::HyperelasticNLFIntegrator *", 0, 0, (void*)0, 0}; @@ -7226,6 +8338,7 @@ static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__VectorConvectionNLFIntegrator = {"_p_mfem__VectorConvectionNLFIntegrator", "mfem::VectorConvectionNLFIntegrator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; @@ -7234,6 +8347,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, @@ -7265,6 +8379,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__ExtrudeCoefficient, &_swigt__p_mfem__FaceElementTransformations, &_swigt__p_mfem__FiniteElement, + &_swigt__p_mfem__FiniteElementSpace, &_swigt__p_mfem__FunctionCoefficient, &_swigt__p_mfem__GaussBiLinear2DFiniteElement, &_swigt__p_mfem__GaussBiQuad2DFiniteElement, @@ -7278,6 +8393,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__H1Pos_TetrahedronElement, &_swigt__p_mfem__H1Pos_TriangleElement, &_swigt__p_mfem__H1Pos_WedgeElement, + &_swigt__p_mfem__H1Ser_QuadrilateralElement, &_swigt__p_mfem__H1_HexahedronElement, &_swigt__p_mfem__H1_QuadrilateralElement, &_swigt__p_mfem__H1_SegmentElement, @@ -7373,8 +8489,10 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__TransformedCoefficient, &_swigt__p_mfem__TriLinear3DFiniteElement, &_swigt__p_mfem__Vector, + &_swigt__p_mfem__VectorConvectionNLFIntegrator, &_swigt__p_mfem__VectorFiniteElement, &_swigt__p_mfem__VectorRotProductCoefficient, + &_swigt__p_mfem__VectorTensorFiniteElement, &_swigt__p_pri_t, &_swigt__p_quad_t, &_swigt__p_seg_t, @@ -7383,6 +8501,7 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -7428,13 +8547,11 @@ static swig_cast_info _swigc__p_mfem__RT0TetFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__RotTriLinearHexFiniteElement[] = {{&_swigt__p_mfem__RotTriLinearHexFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NodalTensorFiniteElement[] = {{&_swigt__p_mfem__NodalTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PositiveTensorFiniteElement[] = {{&_swigt__p_mfem__PositiveTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorTensorFiniteElement[] = {{&_swigt__p_mfem__VectorTensorFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_SegmentElement[] = {{&_swigt__p_mfem__H1_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_QuadrilateralElement[] = {{&_swigt__p_mfem__H1_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_HexahedronElement[] = {{&_swigt__p_mfem__H1_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_SegmentElement[] = {{&_swigt__p_mfem__H1Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_SegmentElement[] = {{&_swigt__p_mfem__L2_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_WedgeElement[] = {{&_swigt__p_mfem__H1Pos_WedgeElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCubic3DFiniteElement[] = {{&_swigt__p_mfem__BiCubic3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7446,6 +8563,8 @@ static swig_cast_info _swigc__p_mfem__H1Pos_TriangleElement[] = {{&_swigt__p_mfe static swig_cast_info _swigc__p_mfem__H1_TetrahedronElement[] = {{&_swigt__p_mfem__H1_TetrahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1_TriangleElement[] = {{&_swigt__p_mfem__H1_TriangleElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__H1Pos_HexahedronElement[] = {{&_swigt__p_mfem__H1Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Ser_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Ser_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__H1Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P0TetFiniteElement[] = {{&_swigt__p_mfem__P0TetFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__P1TetNonConfFiniteElement[] = {{&_swigt__p_mfem__P1TetNonConfFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Lagrange1DFiniteElement[] = {{&_swigt__p_mfem__Lagrange1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7487,6 +8606,8 @@ static swig_cast_info _swigc__p_mfem__Quad1DFiniteElement[] = {{&_swigt__p_mfem_ static swig_cast_info _swigc__p_mfem__QuadPos1DFiniteElement[] = {{&_swigt__p_mfem__QuadPos1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Quad2DFiniteElement[] = {{&_swigt__p_mfem__Quad2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RT1QuadFiniteElement[] = {{&_swigt__p_mfem__RT1QuadFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2Pos_SegmentElement[] = {{&_swigt__p_mfem__L2Pos_SegmentElement, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_QuadrilateralElement[] = {{&_swigt__p_mfem__L2_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_QuadrilateralElement[] = {{&_swigt__p_mfem__L2Pos_QuadrilateralElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_HexahedronElement[] = {{&_swigt__p_mfem__L2_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2Pos_HexahedronElement[] = {{&_swigt__p_mfem__L2Pos_HexahedronElement, 0, 0, 0},{0, 0, 0, 0}}; @@ -7510,7 +8631,8 @@ static swig_cast_info _swigc__p_mfem__NURBSFiniteElement[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__NURBS1DFiniteElement[] = {{&_swigt__p_mfem__NURBS1DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS2DFiniteElement[] = {{&_swigt__p_mfem__NURBS2DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NURBS3DFiniteElement[] = {{&_swigt__p_mfem__NURBS3DFiniteElement, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElement[] = { {&_swigt__p_mfem__P0HexFiniteElement, _p_mfem__P0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__LagrangeHexFiniteElement, _p_mfem__LagrangeHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear1DFiniteElement, _p_mfem__RefinedLinear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear2DFiniteElement, _p_mfem__RefinedLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedLinear3DFiniteElement, _p_mfem__RefinedLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedBiLinear2DFiniteElement, _p_mfem__RefinedBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RefinedTriLinear3DFiniteElement, _p_mfem__RefinedTriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1HexFiniteElement, _p_mfem__Nedelec1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Nedelec1TetFiniteElement, _p_mfem__Nedelec1TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0HexFiniteElement, _p_mfem__RT0HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1HexFiniteElement, _p_mfem__RT1HexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TetFiniteElement, _p_mfem__RT0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RotTriLinearHexFiniteElement, _p_mfem__RotTriLinearHexFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalTensorFiniteElement, _p_mfem__NodalTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveTensorFiniteElement, _p_mfem__PositiveTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorTensorFiniteElement, _p_mfem__VectorTensorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_SegmentElement, _p_mfem__H1_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_QuadrilateralElement, _p_mfem__H1_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_HexahedronElement, _p_mfem__H1_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_SegmentElement, _p_mfem__H1Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_SegmentElement, _p_mfem__L2_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_WedgeElement, _p_mfem__H1Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic3DFiniteElement, _p_mfem__BiCubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadratic3DFiniteElement, _p_mfem__BiQuadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear3DFiniteElement, _p_mfem__BiLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_WedgeElement, _p_mfem__H1_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TetrahedronElement, _p_mfem__H1Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_TriangleElement, _p_mfem__H1Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TetrahedronElement, _p_mfem__H1_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1_TriangleElement, _p_mfem__H1_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_HexahedronElement, _p_mfem__H1Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Ser_QuadrilateralElement, _p_mfem__H1Ser_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__H1Pos_QuadrilateralElement, _p_mfem__H1Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TetFiniteElement, _p_mfem__P0TetFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1TetNonConfFiniteElement, _p_mfem__P1TetNonConfFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Lagrange1DFiniteElement, _p_mfem__Lagrange1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P2SegmentFiniteElement, _p_mfem__P2SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1SegmentFiniteElement, _p_mfem__P1SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2QuadFiniteElement, _p_mfem__RT2QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT2TriangleFiniteElement, _p_mfem__RT2TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic2DFiniteElement, _p_mfem__Cubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Cubic3DFiniteElement, _p_mfem__Cubic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0TriangleFiniteElement, _p_mfem__P0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0QuadFiniteElement, _p_mfem__P0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear3DFiniteElement, _p_mfem__Linear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quadratic3DFiniteElement, _p_mfem__Quadratic3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__TriLinear3DFiniteElement, _p_mfem__TriLinear3DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartFiniteElement, _p_mfem__CrouzeixRaviartFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__CrouzeixRaviartQuadFiniteElement, _p_mfem__CrouzeixRaviartQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0SegmentFiniteElement, _p_mfem__P0SegmentFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0TriangleFiniteElement, _p_mfem__RT0TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT0QuadFiniteElement, _p_mfem__RT0QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1TriangleFiniteElement, _p_mfem__RT1TriangleFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__FiniteElement, 0, 0, 0}, {&_swigt__p_mfem__Cubic1DFiniteElement, _p_mfem__Cubic1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiCubic2DFiniteElement, _p_mfem__BiCubic2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiQuad2DFiniteElement, _p_mfem__GaussBiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuadPos2DFiniteElement, _p_mfem__BiQuadPos2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiQuad2DFiniteElement, _p_mfem__BiQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussQuad2DFiniteElement, _p_mfem__GaussQuad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ScalarFiniteElement, _p_mfem__ScalarFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NodalFiniteElement, _p_mfem__NodalFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PositiveFiniteElement, _p_mfem__PositiveFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__VectorFiniteElement, _p_mfem__VectorFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__PointFiniteElement, _p_mfem__PointFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear1DFiniteElement, _p_mfem__Linear1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Linear2DFiniteElement, _p_mfem__Linear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__BiLinear2DFiniteElement, _p_mfem__BiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussLinear2DFiniteElement, _p_mfem__GaussLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__GaussBiLinear2DFiniteElement, _p_mfem__GaussBiLinear2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P1OnQuadFiniteElement, _p_mfem__P1OnQuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad1DFiniteElement, _p_mfem__Quad1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__QuadPos1DFiniteElement, _p_mfem__QuadPos1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__Quad2DFiniteElement, _p_mfem__Quad2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT1QuadFiniteElement, _p_mfem__RT1QuadFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_SegmentElement, _p_mfem__L2Pos_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_QuadrilateralElement, _p_mfem__L2_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_QuadrilateralElement, _p_mfem__L2Pos_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_HexahedronElement, _p_mfem__L2_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_HexahedronElement, _p_mfem__L2Pos_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TriangleElement, _p_mfem__L2_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TriangleElement, _p_mfem__L2Pos_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_TetrahedronElement, _p_mfem__L2_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_TetrahedronElement, _p_mfem__L2Pos_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2_WedgeElement, _p_mfem__L2_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__P0WedgeFiniteElement, _p_mfem__P0WedgeFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__L2Pos_WedgeElement, _p_mfem__L2Pos_WedgeElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_QuadrilateralElement, _p_mfem__RT_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_HexahedronElement, _p_mfem__RT_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TriangleElement, _p_mfem__RT_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__RT_TetrahedronElement, _p_mfem__RT_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_HexahedronElement, _p_mfem__ND_HexahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_QuadrilateralElement, _p_mfem__ND_QuadrilateralElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TetrahedronElement, _p_mfem__ND_TetrahedronElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_TriangleElement, _p_mfem__ND_TriangleElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__ND_SegmentElement, _p_mfem__ND_SegmentElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBSFiniteElement, _p_mfem__NURBSFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS1DFiniteElement, _p_mfem__NURBS1DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS2DFiniteElement, _p_mfem__NURBS2DFiniteElementTo_p_mfem__FiniteElement, 0, 0}, {&_swigt__p_mfem__NURBS3DFiniteElement, _p_mfem__NURBS3DFiniteElementTo_p_mfem__FiniteElement, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyperelasticModel[] = { {&_swigt__p_mfem__HyperelasticModel, 0, 0, 0}, {&_swigt__p_mfem__InverseHarmonicModel, _p_mfem__InverseHarmonicModelTo_p_mfem__HyperelasticModel, 0, 0}, {&_swigt__p_mfem__NeoHookeanModel, _p_mfem__NeoHookeanModelTo_p_mfem__HyperelasticModel, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__HyperelasticNLFIntegrator[] = { {&_swigt__p_mfem__HyperelasticNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; @@ -7519,11 +8641,12 @@ static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__I static swig_cast_info _swigc__p_mfem__InverseHarmonicModel[] = { {&_swigt__p_mfem__InverseHarmonicModel, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NeoHookeanModel[] = { {&_swigt__p_mfem__NeoHookeanModel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__NonlinearFormIntegrator[] = { {&_swigt__p_mfem__NonlinearFormIntegrator, 0, 0, 0}, {&_swigt__p_mfem__HyperelasticNLFIntegrator, _p_mfem__HyperelasticNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0}, {&_swigt__p_mfem__VectorConvectionNLFIntegrator, _p_mfem__VectorConvectionNLFIntegratorTo_p_mfem__NonlinearFormIntegrator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__VectorConvectionNLFIntegrator[] = { {&_swigt__p_mfem__VectorConvectionNLFIntegrator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -7532,6 +8655,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, @@ -7563,6 +8687,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__ExtrudeCoefficient, _swigc__p_mfem__FaceElementTransformations, _swigc__p_mfem__FiniteElement, + _swigc__p_mfem__FiniteElementSpace, _swigc__p_mfem__FunctionCoefficient, _swigc__p_mfem__GaussBiLinear2DFiniteElement, _swigc__p_mfem__GaussBiQuad2DFiniteElement, @@ -7576,6 +8701,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__H1Pos_TetrahedronElement, _swigc__p_mfem__H1Pos_TriangleElement, _swigc__p_mfem__H1Pos_WedgeElement, + _swigc__p_mfem__H1Ser_QuadrilateralElement, _swigc__p_mfem__H1_HexahedronElement, _swigc__p_mfem__H1_QuadrilateralElement, _swigc__p_mfem__H1_SegmentElement, @@ -7671,8 +8797,10 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__TransformedCoefficient, _swigc__p_mfem__TriLinear3DFiniteElement, _swigc__p_mfem__Vector, + _swigc__p_mfem__VectorConvectionNLFIntegrator, _swigc__p_mfem__VectorFiniteElement, _swigc__p_mfem__VectorRotProductCoefficient, + _swigc__p_mfem__VectorTensorFiniteElement, _swigc__p_pri_t, _swigc__p_quad_t, _swigc__p_seg_t, diff --git a/mfem/_ser/nonlininteg_wrap.h b/mfem/_ser/nonlininteg_wrap.h index 3d3e67f9..9d048bb4 100644 --- a/mfem/_ser/nonlininteg_wrap.h +++ b/mfem/_ser/nonlininteg_wrap.h @@ -24,6 +24,9 @@ class SwigDirector_NonlinearFormIntegrator : public mfem::NonlinearFormIntegrato virtual void AssembleElementGrad(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); virtual void AssembleFaceGrad(mfem::FiniteElement const &el1, mfem::FiniteElement const &el2, mfem::FaceElementTransformations &Tr, mfem::Vector const &elfun, mfem::DenseMatrix &elmat); virtual double GetElementEnergy(mfem::FiniteElement const &el, mfem::ElementTransformation &Tr, mfem::Vector const &elfun); + virtual void AssemblePA(mfem::FiniteElementSpace const &fes); + virtual void AssemblePA(mfem::FiniteElementSpace const &trial_fes, mfem::FiniteElementSpace const &test_fes); + virtual void AddMultPA(mfem::Vector const &x, mfem::Vector &y) const; virtual ~SwigDirector_NonlinearFormIntegrator(); /* Internal director utilities */ @@ -55,7 +58,7 @@ class SwigDirector_NonlinearFormIntegrator : public mfem::NonlinearFormIntegrato return method; } private: - mutable swig::SwigVar_PyObject vtable[5]; + mutable swig::SwigVar_PyObject vtable[8]; #endif }; diff --git a/mfem/_ser/ode.i b/mfem/_ser/ode.i index ce5c340f..b7cab3f6 100644 --- a/mfem/_ser/ode.i +++ b/mfem/_ser/ode.i @@ -1,8 +1,10 @@ %module(package="mfem._ser") ode %{ +#include "mfem.hpp" #include "linalg/ode.hpp" #include "pyoperator.hpp" #include "numpy/arrayobject.h" +#include "io_stream.hpp" %} %init %{ @@ -14,6 +16,9 @@ import_array(); %import "array.i" %import "operators.i" %import "../common/exception.i" +%import "../common/io_stream_typemap.i" +OSTREAM_TYPEMAP(std::ostream&) + %typemap(in) double &t (double temp){ temp = PyFloat_AsDouble($input); diff --git a/mfem/_ser/ode.py b/mfem/_ser/ode.py index 4503934b..24005df9 100644 --- a/mfem/_ser/ode.py +++ b/mfem/_ser/ode.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _ode.SWIG_PyInstanceMethod_New +_swig_new_static_method = _ode.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -79,14 +82,17 @@ def __init__(self, *args, **kwargs): def Init(self, f): r"""Init(ODESolver self, TimeDependentOperator f)""" return _ode.ODESolver_Init(self, f) + Init = _swig_new_instance_method(_ode.ODESolver_Init) def Step(self, x, t, dt): r"""Step(ODESolver self, Vector x, double & t, double & dt)""" return _ode.ODESolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ODESolver_Step) def Run(self, x, t, dt, tf): r"""Run(ODESolver self, Vector x, double & t, double & dt, double tf)""" return _ode.ODESolver_Run(self, x, t, dt, tf) + Run = _swig_new_instance_method(_ode.ODESolver_Run) __swig_destroy__ = _ode.delete_ODESolver # Register ODESolver in _ode: @@ -101,10 +107,12 @@ class ForwardEulerSolver(ODESolver): def Init(self, _f): r"""Init(ForwardEulerSolver self, TimeDependentOperator _f)""" return _ode.ForwardEulerSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.ForwardEulerSolver_Init) def Step(self, x, t, dt): r"""Step(ForwardEulerSolver self, Vector x, double & t, double & dt)""" return _ode.ForwardEulerSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ForwardEulerSolver_Step) def __init__(self): r"""__init__(ForwardEulerSolver self) -> ForwardEulerSolver""" @@ -127,10 +135,12 @@ def __init__(self, *args): def Init(self, _f): r"""Init(RK2Solver self, TimeDependentOperator _f)""" return _ode.RK2Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.RK2Solver_Init) def Step(self, x, t, dt): r"""Step(RK2Solver self, Vector x, double & t, double & dt)""" return _ode.RK2Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.RK2Solver_Step) __swig_destroy__ = _ode.delete_RK2Solver # Register RK2Solver in _ode: @@ -145,10 +155,12 @@ class RK3SSPSolver(ODESolver): def Init(self, _f): r"""Init(RK3SSPSolver self, TimeDependentOperator _f)""" return _ode.RK3SSPSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.RK3SSPSolver_Init) def Step(self, x, t, dt): r"""Step(RK3SSPSolver self, Vector x, double & t, double & dt)""" return _ode.RK3SSPSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.RK3SSPSolver_Step) def __init__(self): r"""__init__(RK3SSPSolver self) -> RK3SSPSolver""" @@ -167,10 +179,12 @@ class RK4Solver(ODESolver): def Init(self, _f): r"""Init(RK4Solver self, TimeDependentOperator _f)""" return _ode.RK4Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.RK4Solver_Init) def Step(self, x, t, dt): r"""Step(RK4Solver self, Vector x, double & t, double & dt)""" return _ode.RK4Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.RK4Solver_Step) def __init__(self): r"""__init__(RK4Solver self) -> RK4Solver""" @@ -193,10 +207,12 @@ def __init__(self, _s, _a, _b, _c): def Init(self, _f): r"""Init(ExplicitRKSolver self, TimeDependentOperator _f)""" return _ode.ExplicitRKSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.ExplicitRKSolver_Init) def Step(self, x, t, dt): r"""Step(ExplicitRKSolver self, Vector x, double & t, double & dt)""" return _ode.ExplicitRKSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ExplicitRKSolver_Step) __swig_destroy__ = _ode.delete_ExplicitRKSolver # Register ExplicitRKSolver in _ode: @@ -230,6 +246,194 @@ def __init__(self): # Register RK8Solver in _ode: _ode.RK8Solver_swigregister(RK8Solver) +class AdamsBashforthSolver(ODESolver): + r"""Proxy of C++ mfem::AdamsBashforthSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, _s, _a): + r"""__init__(AdamsBashforthSolver self, int _s, double const * _a) -> AdamsBashforthSolver""" + _ode.AdamsBashforthSolver_swiginit(self, _ode.new_AdamsBashforthSolver(_s, _a)) + + def Init(self, _f): + r"""Init(AdamsBashforthSolver self, TimeDependentOperator _f)""" + return _ode.AdamsBashforthSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.AdamsBashforthSolver_Init) + + def Step(self, x, t, dt): + r"""Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)""" + return _ode.AdamsBashforthSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.AdamsBashforthSolver_Step) + __swig_destroy__ = _ode.delete_AdamsBashforthSolver + +# Register AdamsBashforthSolver in _ode: +_ode.AdamsBashforthSolver_swigregister(AdamsBashforthSolver) + +class AB1Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB1Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB1Solver self) -> AB1Solver""" + _ode.AB1Solver_swiginit(self, _ode.new_AB1Solver()) + __swig_destroy__ = _ode.delete_AB1Solver + +# Register AB1Solver in _ode: +_ode.AB1Solver_swigregister(AB1Solver) + +class AB2Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB2Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB2Solver self) -> AB2Solver""" + _ode.AB2Solver_swiginit(self, _ode.new_AB2Solver()) + __swig_destroy__ = _ode.delete_AB2Solver + +# Register AB2Solver in _ode: +_ode.AB2Solver_swigregister(AB2Solver) + +class AB3Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB3Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB3Solver self) -> AB3Solver""" + _ode.AB3Solver_swiginit(self, _ode.new_AB3Solver()) + __swig_destroy__ = _ode.delete_AB3Solver + +# Register AB3Solver in _ode: +_ode.AB3Solver_swigregister(AB3Solver) + +class AB4Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB4Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB4Solver self) -> AB4Solver""" + _ode.AB4Solver_swiginit(self, _ode.new_AB4Solver()) + __swig_destroy__ = _ode.delete_AB4Solver + +# Register AB4Solver in _ode: +_ode.AB4Solver_swigregister(AB4Solver) + +class AB5Solver(AdamsBashforthSolver): + r"""Proxy of C++ mfem::AB5Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AB5Solver self) -> AB5Solver""" + _ode.AB5Solver_swiginit(self, _ode.new_AB5Solver()) + __swig_destroy__ = _ode.delete_AB5Solver + +# Register AB5Solver in _ode: +_ode.AB5Solver_swigregister(AB5Solver) + +class AdamsMoultonSolver(ODESolver): + r"""Proxy of C++ mfem::AdamsMoultonSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, _s, _a): + r"""__init__(AdamsMoultonSolver self, int _s, double const * _a) -> AdamsMoultonSolver""" + _ode.AdamsMoultonSolver_swiginit(self, _ode.new_AdamsMoultonSolver(_s, _a)) + + def Init(self, _f): + r"""Init(AdamsMoultonSolver self, TimeDependentOperator _f)""" + return _ode.AdamsMoultonSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.AdamsMoultonSolver_Init) + + def Step(self, x, t, dt): + r"""Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)""" + return _ode.AdamsMoultonSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.AdamsMoultonSolver_Step) + __swig_destroy__ = _ode.delete_AdamsMoultonSolver + +# Register AdamsMoultonSolver in _ode: +_ode.AdamsMoultonSolver_swigregister(AdamsMoultonSolver) + +class AM0Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM0Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM0Solver self) -> AM0Solver""" + _ode.AM0Solver_swiginit(self, _ode.new_AM0Solver()) + __swig_destroy__ = _ode.delete_AM0Solver + +# Register AM0Solver in _ode: +_ode.AM0Solver_swigregister(AM0Solver) + +class AM1Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM1Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM1Solver self) -> AM1Solver""" + _ode.AM1Solver_swiginit(self, _ode.new_AM1Solver()) + __swig_destroy__ = _ode.delete_AM1Solver + +# Register AM1Solver in _ode: +_ode.AM1Solver_swigregister(AM1Solver) + +class AM2Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM2Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM2Solver self) -> AM2Solver""" + _ode.AM2Solver_swiginit(self, _ode.new_AM2Solver()) + __swig_destroy__ = _ode.delete_AM2Solver + +# Register AM2Solver in _ode: +_ode.AM2Solver_swigregister(AM2Solver) + +class AM3Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM3Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM3Solver self) -> AM3Solver""" + _ode.AM3Solver_swiginit(self, _ode.new_AM3Solver()) + __swig_destroy__ = _ode.delete_AM3Solver + +# Register AM3Solver in _ode: +_ode.AM3Solver_swigregister(AM3Solver) + +class AM4Solver(AdamsMoultonSolver): + r"""Proxy of C++ mfem::AM4Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AM4Solver self) -> AM4Solver""" + _ode.AM4Solver_swiginit(self, _ode.new_AM4Solver()) + __swig_destroy__ = _ode.delete_AM4Solver + +# Register AM4Solver in _ode: +_ode.AM4Solver_swigregister(AM4Solver) + class BackwardEulerSolver(ODESolver): r"""Proxy of C++ mfem::BackwardEulerSolver class.""" @@ -239,10 +443,12 @@ class BackwardEulerSolver(ODESolver): def Init(self, _f): r"""Init(BackwardEulerSolver self, TimeDependentOperator _f)""" return _ode.BackwardEulerSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.BackwardEulerSolver_Init) def Step(self, x, t, dt): r"""Step(BackwardEulerSolver self, Vector x, double & t, double & dt)""" return _ode.BackwardEulerSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.BackwardEulerSolver_Step) def __init__(self): r"""__init__(BackwardEulerSolver self) -> BackwardEulerSolver""" @@ -261,10 +467,12 @@ class ImplicitMidpointSolver(ODESolver): def Init(self, _f): r"""Init(ImplicitMidpointSolver self, TimeDependentOperator _f)""" return _ode.ImplicitMidpointSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.ImplicitMidpointSolver_Init) def Step(self, x, t, dt): r"""Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)""" return _ode.ImplicitMidpointSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.ImplicitMidpointSolver_Step) def __init__(self): r"""__init__(ImplicitMidpointSolver self) -> ImplicitMidpointSolver""" @@ -287,10 +495,12 @@ def __init__(self, gamma_opt=1): def Init(self, _f): r"""Init(SDIRK23Solver self, TimeDependentOperator _f)""" return _ode.SDIRK23Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.SDIRK23Solver_Init) def Step(self, x, t, dt): r"""Step(SDIRK23Solver self, Vector x, double & t, double & dt)""" return _ode.SDIRK23Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.SDIRK23Solver_Step) __swig_destroy__ = _ode.delete_SDIRK23Solver # Register SDIRK23Solver in _ode: @@ -305,10 +515,12 @@ class SDIRK34Solver(ODESolver): def Init(self, _f): r"""Init(SDIRK34Solver self, TimeDependentOperator _f)""" return _ode.SDIRK34Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.SDIRK34Solver_Init) def Step(self, x, t, dt): r"""Step(SDIRK34Solver self, Vector x, double & t, double & dt)""" return _ode.SDIRK34Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.SDIRK34Solver_Step) def __init__(self): r"""__init__(SDIRK34Solver self) -> SDIRK34Solver""" @@ -327,10 +539,12 @@ class SDIRK33Solver(ODESolver): def Init(self, _f): r"""Init(SDIRK33Solver self, TimeDependentOperator _f)""" return _ode.SDIRK33Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.SDIRK33Solver_Init) def Step(self, x, t, dt): r"""Step(SDIRK33Solver self, Vector x, double & t, double & dt)""" return _ode.SDIRK33Solver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.SDIRK33Solver_Step) def __init__(self): r"""__init__(SDIRK33Solver self) -> SDIRK33Solver""" @@ -353,10 +567,12 @@ def __init__(self, rho=1.0): def Init(self, _f): r"""Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)""" return _ode.GeneralizedAlphaSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.GeneralizedAlphaSolver_Init) def Step(self, x, t, dt): r"""Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)""" return _ode.GeneralizedAlphaSolver_Step(self, x, t, dt) + Step = _swig_new_instance_method(_ode.GeneralizedAlphaSolver_Step) __swig_destroy__ = _ode.delete_GeneralizedAlphaSolver # Register GeneralizedAlphaSolver in _ode: @@ -374,14 +590,17 @@ def __init__(self, *args, **kwargs): def Init(self, P, F): r"""Init(SIASolver self, Operator P, TimeDependentOperator F)""" return _ode.SIASolver_Init(self, P, F) + Init = _swig_new_instance_method(_ode.SIASolver_Init) def Step(self, q, p, t, dt): r"""Step(SIASolver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIASolver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIASolver_Step) def Run(self, q, p, t, dt, tf): r"""Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)""" return _ode.SIASolver_Run(self, q, p, t, dt, tf) + Run = _swig_new_instance_method(_ode.SIASolver_Run) __swig_destroy__ = _ode.delete_SIASolver # Register SIASolver in _ode: @@ -400,6 +619,7 @@ def __init__(self): def Step(self, q, p, t, dt): r"""Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIA1Solver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIA1Solver_Step) __swig_destroy__ = _ode.delete_SIA1Solver # Register SIA1Solver in _ode: @@ -418,6 +638,7 @@ def __init__(self): def Step(self, q, p, t, dt): r"""Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIA2Solver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIA2Solver_Step) __swig_destroy__ = _ode.delete_SIA2Solver # Register SIA2Solver in _ode: @@ -436,10 +657,181 @@ def __init__(self, order): def Step(self, q, p, t, dt): r"""Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)""" return _ode.SIAVSolver_Step(self, q, p, t, dt) + Step = _swig_new_instance_method(_ode.SIAVSolver_Step) __swig_destroy__ = _ode.delete_SIAVSolver # Register SIAVSolver in _ode: _ode.SIAVSolver_swigregister(SIAVSolver) +class SecondOrderODESolver(object): + r"""Proxy of C++ mfem::SecondOrderODESolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + + def Init(self, f): + r"""Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)""" + return _ode.SecondOrderODESolver_Init(self, f) + Init = _swig_new_instance_method(_ode.SecondOrderODESolver_Init) + + def Step(self, x, dxdt, t, dt): + r"""Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)""" + return _ode.SecondOrderODESolver_Step(self, x, dxdt, t, dt) + Step = _swig_new_instance_method(_ode.SecondOrderODESolver_Step) + + def Run(self, x, dxdt, t, dt, tf): + r"""Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)""" + return _ode.SecondOrderODESolver_Run(self, x, dxdt, t, dt, tf) + Run = _swig_new_instance_method(_ode.SecondOrderODESolver_Run) + __swig_destroy__ = _ode.delete_SecondOrderODESolver + +# Register SecondOrderODESolver in _ode: +_ode.SecondOrderODESolver_swigregister(SecondOrderODESolver) + +class NewmarkSolver(SecondOrderODESolver): + r"""Proxy of C++ mfem::NewmarkSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, beta_=0.25, gamma_=0.5): + r"""__init__(NewmarkSolver self, double beta_=0.25, double gamma_=0.5) -> NewmarkSolver""" + _ode.NewmarkSolver_swiginit(self, _ode.new_NewmarkSolver(beta_, gamma_)) + + def PrintProperties(self, *args): + r"""PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)""" + return _ode.NewmarkSolver_PrintProperties(self, *args) + PrintProperties = _swig_new_instance_method(_ode.NewmarkSolver_PrintProperties) + + def Init(self, _f): + r"""Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)""" + return _ode.NewmarkSolver_Init(self, _f) + Init = _swig_new_instance_method(_ode.NewmarkSolver_Init) + + def Step(self, x, dxdt, t, dt): + r"""Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)""" + return _ode.NewmarkSolver_Step(self, x, dxdt, t, dt) + Step = _swig_new_instance_method(_ode.NewmarkSolver_Step) + __swig_destroy__ = _ode.delete_NewmarkSolver + +# Register NewmarkSolver in _ode: +_ode.NewmarkSolver_swigregister(NewmarkSolver) + +class LinearAccelerationSolver(NewmarkSolver): + r"""Proxy of C++ mfem::LinearAccelerationSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(LinearAccelerationSolver self) -> LinearAccelerationSolver""" + _ode.LinearAccelerationSolver_swiginit(self, _ode.new_LinearAccelerationSolver()) + __swig_destroy__ = _ode.delete_LinearAccelerationSolver + +# Register LinearAccelerationSolver in _ode: +_ode.LinearAccelerationSolver_swigregister(LinearAccelerationSolver) + +class CentralDifferenceSolver(NewmarkSolver): + r"""Proxy of C++ mfem::CentralDifferenceSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(CentralDifferenceSolver self) -> CentralDifferenceSolver""" + _ode.CentralDifferenceSolver_swiginit(self, _ode.new_CentralDifferenceSolver()) + __swig_destroy__ = _ode.delete_CentralDifferenceSolver + +# Register CentralDifferenceSolver in _ode: +_ode.CentralDifferenceSolver_swigregister(CentralDifferenceSolver) + +class FoxGoodwinSolver(NewmarkSolver): + r"""Proxy of C++ mfem::FoxGoodwinSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(FoxGoodwinSolver self) -> FoxGoodwinSolver""" + _ode.FoxGoodwinSolver_swiginit(self, _ode.new_FoxGoodwinSolver()) + __swig_destroy__ = _ode.delete_FoxGoodwinSolver + +# Register FoxGoodwinSolver in _ode: +_ode.FoxGoodwinSolver_swigregister(FoxGoodwinSolver) + +class GeneralizedAlpha2Solver(SecondOrderODESolver): + r"""Proxy of C++ mfem::GeneralizedAlpha2Solver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, rho_inf=1.0): + r"""__init__(GeneralizedAlpha2Solver self, double rho_inf=1.0) -> GeneralizedAlpha2Solver""" + _ode.GeneralizedAlpha2Solver_swiginit(self, _ode.new_GeneralizedAlpha2Solver(rho_inf)) + + def PrintProperties(self, *args): + r"""PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)""" + return _ode.GeneralizedAlpha2Solver_PrintProperties(self, *args) + PrintProperties = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_PrintProperties) + + def Init(self, _f): + r"""Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)""" + return _ode.GeneralizedAlpha2Solver_Init(self, _f) + Init = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_Init) + + def Step(self, x, dxdt, t, dt): + r"""Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)""" + return _ode.GeneralizedAlpha2Solver_Step(self, x, dxdt, t, dt) + Step = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_Step) + __swig_destroy__ = _ode.delete_GeneralizedAlpha2Solver + +# Register GeneralizedAlpha2Solver in _ode: +_ode.GeneralizedAlpha2Solver_swigregister(GeneralizedAlpha2Solver) + +class AverageAccelerationSolver(GeneralizedAlpha2Solver): + r"""Proxy of C++ mfem::AverageAccelerationSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self): + r"""__init__(AverageAccelerationSolver self) -> AverageAccelerationSolver""" + _ode.AverageAccelerationSolver_swiginit(self, _ode.new_AverageAccelerationSolver()) + __swig_destroy__ = _ode.delete_AverageAccelerationSolver + +# Register AverageAccelerationSolver in _ode: +_ode.AverageAccelerationSolver_swigregister(AverageAccelerationSolver) + +class HHTAlphaSolver(GeneralizedAlpha2Solver): + r"""Proxy of C++ mfem::HHTAlphaSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, alpha=1.0): + r"""__init__(HHTAlphaSolver self, double alpha=1.0) -> HHTAlphaSolver""" + _ode.HHTAlphaSolver_swiginit(self, _ode.new_HHTAlphaSolver(alpha)) + __swig_destroy__ = _ode.delete_HHTAlphaSolver + +# Register HHTAlphaSolver in _ode: +_ode.HHTAlphaSolver_swigregister(HHTAlphaSolver) + +class WBZAlphaSolver(GeneralizedAlpha2Solver): + r"""Proxy of C++ mfem::WBZAlphaSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, rho_inf=1.0): + r"""__init__(WBZAlphaSolver self, double rho_inf=1.0) -> WBZAlphaSolver""" + _ode.WBZAlphaSolver_swiginit(self, _ode.new_WBZAlphaSolver(rho_inf)) + __swig_destroy__ = _ode.delete_WBZAlphaSolver + +# Register WBZAlphaSolver in _ode: +_ode.WBZAlphaSolver_swigregister(WBZAlphaSolver) + diff --git a/mfem/_ser/ode_wrap.cxx b/mfem/_ser/ode_wrap.cxx index aa01865a..b1b58a3b 100644 --- a/mfem/_ser/ode_wrap.cxx +++ b/mfem/_ser/ode_wrap.cxx @@ -3068,38 +3068,62 @@ namespace Swig { #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] #define SWIGTYPE_p_char swig_types[1] #define SWIGTYPE_p_double swig_types[2] -#define SWIGTYPE_p_mfem__BackwardEulerSolver swig_types[3] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[4] -#define SWIGTYPE_p_mfem__ExplicitRKSolver swig_types[5] -#define SWIGTYPE_p_mfem__ForwardEulerSolver swig_types[6] -#define SWIGTYPE_p_mfem__GeneralizedAlphaSolver swig_types[7] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[8] -#define SWIGTYPE_p_mfem__ImplicitMidpointSolver swig_types[9] -#define SWIGTYPE_p_mfem__ODESolver swig_types[10] -#define SWIGTYPE_p_mfem__Operator swig_types[11] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[12] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[13] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[14] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[15] -#define SWIGTYPE_p_mfem__RK2Solver swig_types[16] -#define SWIGTYPE_p_mfem__RK3SSPSolver swig_types[17] -#define SWIGTYPE_p_mfem__RK4Solver swig_types[18] -#define SWIGTYPE_p_mfem__RK6Solver swig_types[19] -#define SWIGTYPE_p_mfem__RK8Solver swig_types[20] -#define SWIGTYPE_p_mfem__SDIRK23Solver swig_types[21] -#define SWIGTYPE_p_mfem__SDIRK33Solver swig_types[22] -#define SWIGTYPE_p_mfem__SDIRK34Solver swig_types[23] -#define SWIGTYPE_p_mfem__SIA1Solver swig_types[24] -#define SWIGTYPE_p_mfem__SIA2Solver swig_types[25] -#define SWIGTYPE_p_mfem__SIASolver swig_types[26] -#define SWIGTYPE_p_mfem__SIAVSolver swig_types[27] -#define SWIGTYPE_p_mfem__Solver swig_types[28] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[29] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[30] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[31] -#define SWIGTYPE_p_mfem__Vector swig_types[32] -static swig_type_info *swig_types[34]; -static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__AB1Solver swig_types[3] +#define SWIGTYPE_p_mfem__AB2Solver swig_types[4] +#define SWIGTYPE_p_mfem__AB3Solver swig_types[5] +#define SWIGTYPE_p_mfem__AB4Solver swig_types[6] +#define SWIGTYPE_p_mfem__AB5Solver swig_types[7] +#define SWIGTYPE_p_mfem__AM0Solver swig_types[8] +#define SWIGTYPE_p_mfem__AM1Solver swig_types[9] +#define SWIGTYPE_p_mfem__AM2Solver swig_types[10] +#define SWIGTYPE_p_mfem__AM3Solver swig_types[11] +#define SWIGTYPE_p_mfem__AM4Solver swig_types[12] +#define SWIGTYPE_p_mfem__AdamsBashforthSolver swig_types[13] +#define SWIGTYPE_p_mfem__AdamsMoultonSolver swig_types[14] +#define SWIGTYPE_p_mfem__AverageAccelerationSolver swig_types[15] +#define SWIGTYPE_p_mfem__BackwardEulerSolver swig_types[16] +#define SWIGTYPE_p_mfem__CentralDifferenceSolver swig_types[17] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[18] +#define SWIGTYPE_p_mfem__ExplicitRKSolver swig_types[19] +#define SWIGTYPE_p_mfem__ForwardEulerSolver swig_types[20] +#define SWIGTYPE_p_mfem__FoxGoodwinSolver swig_types[21] +#define SWIGTYPE_p_mfem__GeneralizedAlpha2Solver swig_types[22] +#define SWIGTYPE_p_mfem__GeneralizedAlphaSolver swig_types[23] +#define SWIGTYPE_p_mfem__HHTAlphaSolver swig_types[24] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[25] +#define SWIGTYPE_p_mfem__ImplicitMidpointSolver swig_types[26] +#define SWIGTYPE_p_mfem__LinearAccelerationSolver swig_types[27] +#define SWIGTYPE_p_mfem__NewmarkSolver swig_types[28] +#define SWIGTYPE_p_mfem__ODESolver swig_types[29] +#define SWIGTYPE_p_mfem__Operator swig_types[30] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[31] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[32] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[33] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[34] +#define SWIGTYPE_p_mfem__RK2Solver swig_types[35] +#define SWIGTYPE_p_mfem__RK3SSPSolver swig_types[36] +#define SWIGTYPE_p_mfem__RK4Solver swig_types[37] +#define SWIGTYPE_p_mfem__RK6Solver swig_types[38] +#define SWIGTYPE_p_mfem__RK8Solver swig_types[39] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[40] +#define SWIGTYPE_p_mfem__SDIRK23Solver swig_types[41] +#define SWIGTYPE_p_mfem__SDIRK33Solver swig_types[42] +#define SWIGTYPE_p_mfem__SDIRK34Solver swig_types[43] +#define SWIGTYPE_p_mfem__SIA1Solver swig_types[44] +#define SWIGTYPE_p_mfem__SIA2Solver swig_types[45] +#define SWIGTYPE_p_mfem__SIASolver swig_types[46] +#define SWIGTYPE_p_mfem__SIAVSolver swig_types[47] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[48] +#define SWIGTYPE_p_mfem__SecondOrderODESolver swig_types[49] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[50] +#define SWIGTYPE_p_mfem__Solver swig_types[51] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[52] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[53] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[54] +#define SWIGTYPE_p_mfem__Vector swig_types[55] +#define SWIGTYPE_p_mfem__WBZAlphaSolver swig_types[56] +static swig_type_info *swig_types[58]; +static swig_module_info swig_module = {swig_types, 57, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3203,9 +3227,11 @@ namespace swig { } +#include "mfem.hpp" #include "linalg/ode.hpp" #include "pyoperator.hpp" #include "numpy/arrayobject.h" +#include "io_stream.hpp" SWIGINTERN int @@ -4771,9 +4797,56 @@ SWIGINTERN PyObject *RK8Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; + int arg1 ; + double *arg2 = (double *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::AdamsBashforthSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_AdamsBashforthSolver", 2, 2, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsBashforthSolver" "', argument " "2"" of type '" "double const *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (mfem::AdamsBashforthSolver *)new mfem::AdamsBashforthSolver(arg1,(double const *)arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AdamsBashforthSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4781,18 +4854,18 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Init" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } - arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsBashforthSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { @@ -4821,9 +4894,9 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; + mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::Vector *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; @@ -4835,18 +4908,18 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel double dtemp4 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Step" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } - arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsBashforthSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { @@ -4889,14 +4962,23 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *result = 0 ; + mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "new_BackwardEulerSolver", 0, 0, 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdamsBashforthSolver" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); + } + arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); { try { - result = (mfem::BackwardEulerSolver *)new mfem::BackwardEulerSolver(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4913,27 +4995,69 @@ SWIGINTERN PyObject *_wrap_new_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AdamsBashforthSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AdamsBashforthSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AdamsBashforthSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AB1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; + mfem::AB1Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_AB1Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::AB1Solver *)new mfem::AB1Solver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB1Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_AB1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AB1Solver *arg1 = (mfem::AB1Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB1Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BackwardEulerSolver" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB1Solver" "', argument " "1"" of type '" "mfem::AB1Solver *""'"); } - arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AB1Solver * >(argp1); { try { delete arg1; @@ -4960,44 +5084,25 @@ SWIGINTERN PyObject *_wrap_delete_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *BackwardEulerSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB1Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *BackwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AB2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; - mfem::TimeDependentOperator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::AB2Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Init" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); - } - arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + if (!SWIG_Python_UnpackTuple(args, "new_AB2Solver", 0, 0, 0)) SWIG_fail; { try { - (arg1)->Init(*arg2); + result = (mfem::AB2Solver *)new mfem::AB2Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5014,52 +5119,30 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB2Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AB2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; + mfem::AB2Solver *arg1 = (mfem::AB2Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double temp3 ; - double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB2Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Step" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); - } - arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - temp3 = PyFloat_AsDouble(swig_obj[2]); - arg3 = &temp3; - } - { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &dtemp4; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB2Solver" "', argument " "1"" of type '" "mfem::AB2Solver *""'"); } + arg1 = reinterpret_cast< mfem::AB2Solver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5077,26 +5160,31 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM( } } resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB2Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AB2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AB3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *result = 0 ; + mfem::AB3Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ImplicitMidpointSolver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AB3Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::ImplicitMidpointSolver *)new mfem::ImplicitMidpointSolver(); + result = (mfem::AB3Solver *)new mfem::AB3Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5113,27 +5201,27 @@ SWIGINTERN PyObject *_wrap_new_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB3Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AB3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; + mfem::AB3Solver *arg1 = (mfem::AB3Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB3Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImplicitMidpointSolver" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB3Solver" "', argument " "1"" of type '" "mfem::AB3Solver *""'"); } - arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); + arg1 = reinterpret_cast< mfem::AB3Solver * >(argp1); { try { delete arg1; @@ -5160,32 +5248,25 @@ SWIGINTERN PyObject *_wrap_delete_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *ImplicitMidpointSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB3Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB3Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ImplicitMidpointSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB3Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_AB4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - mfem::SDIRK23Solver *result = 0 ; + mfem::AB4Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!SWIG_Python_UnpackTuple(args, "new_AB4Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); + result = (mfem::AB4Solver *)new mfem::AB4Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5202,21 +5283,30 @@ SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB4Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_delete_AB4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *result = 0 ; + mfem::AB4Solver *arg1 = (mfem::AB4Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB4Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB4Solver" "', argument " "1"" of type '" "mfem::AB4Solver *""'"); + } + arg1 = reinterpret_cast< mfem::AB4Solver * >(argp1); { try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5233,51 +5323,156 @@ SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; +SWIGINTERN PyObject *AB4Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB4Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AB4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AB5Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AB5Solver *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SDIRK23Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SDIRK23Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (!SWIG_Python_UnpackTuple(args, "new_AB5Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::AB5Solver *)new mfem::AB5Solver(); } - if (_v) { - return _wrap_new_SDIRK23Solver__SWIG_0(self, argc, argv); +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AB5Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_AB5Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AB5Solver *arg1 = (mfem::AB5Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AB5Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AB5Solver" "', argument " "1"" of type '" "mfem::AB5Solver *""'"); + } + arg1 = reinterpret_cast< mfem::AB5Solver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SDIRK23Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SDIRK23Solver::SDIRK23Solver(int)\n" - " mfem::SDIRK23Solver::SDIRK23Solver()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AB5Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AB5Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AB5Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + int arg1 ; + double *arg2 = (double *) 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + mfem::AdamsMoultonSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_AdamsMoultonSolver", 2, 2, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsMoultonSolver" "', argument " "2"" of type '" "double const *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + try { + result = (mfem::AdamsMoultonSolver *)new mfem::AdamsMoultonSolver(arg1,(double const *)arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AdamsMoultonSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -5285,18 +5480,18 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Init" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsMoultonSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { @@ -5325,9 +5520,9 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::Vector *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; @@ -5339,18 +5534,18 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py double dtemp4 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Step" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AdamsMoultonSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { @@ -5393,20 +5588,20 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_delete_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK23Solver" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AdamsMoultonSolver" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); { try { delete arg1; @@ -5433,44 +5628,25 @@ SWIGINTERN PyObject *_wrap_delete_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SDIRK23Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AdamsMoultonSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AdamsMoultonSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SDIRK23Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AdamsMoultonSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AM0Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; - mfem::TimeDependentOperator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::AM0Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + if (!SWIG_Python_UnpackTuple(args, "new_AM0Solver", 0, 0, 0)) SWIG_fail; { try { - (arg1)->Init(*arg2); + result = (mfem::AM0Solver *)new mfem::AM0Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5487,52 +5663,30 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM0Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AM0Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; + mfem::AM0Solver *arg1 = (mfem::AM0Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double temp3 ; - double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM0Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - temp3 = PyFloat_AsDouble(swig_obj[2]); - arg3 = &temp3; - } - { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &dtemp4; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM0Solver" "', argument " "1"" of type '" "mfem::AM0Solver *""'"); } + arg1 = reinterpret_cast< mfem::AM0Solver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5550,26 +5704,31 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } } resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM0Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM0Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AM0Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AM1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK34Solver *result = 0 ; + mfem::AM1Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_SDIRK34Solver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AM1Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::SDIRK34Solver *)new mfem::SDIRK34Solver(); + result = (mfem::AM1Solver *)new mfem::AM1Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5586,27 +5745,27 @@ SWIGINTERN PyObject *_wrap_new_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM1Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AM1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::AM1Solver *arg1 = (mfem::AM1Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM1Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK34Solver" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM1Solver" "', argument " "1"" of type '" "mfem::AM1Solver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AM1Solver * >(argp1); { try { delete arg1; @@ -5633,44 +5792,25 @@ SWIGINTERN PyObject *_wrap_delete_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SDIRK34Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM1Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SDIRK34Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AM2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; - mfem::TimeDependentOperator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::AM2Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); - } - arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + if (!SWIG_Python_UnpackTuple(args, "new_AM2Solver", 0, 0, 0)) SWIG_fail; { try { - (arg1)->Init(*arg2); + result = (mfem::AM2Solver *)new mfem::AM2Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5687,52 +5827,30 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM2Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AM2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; + mfem::AM2Solver *arg1 = (mfem::AM2Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double temp3 ; - double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM2Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - temp3 = PyFloat_AsDouble(swig_obj[2]); - arg3 = &temp3; - } - { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &dtemp4; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM2Solver" "', argument " "1"" of type '" "mfem::AM2Solver *""'"); } + arg1 = reinterpret_cast< mfem::AM2Solver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5750,26 +5868,31 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } } resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM2Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AM2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_AM3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *result = 0 ; + mfem::AM3Solver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_SDIRK33Solver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AM3Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::SDIRK33Solver *)new mfem::SDIRK33Solver(); + result = (mfem::AM3Solver *)new mfem::AM3Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5786,27 +5909,27 @@ SWIGINTERN PyObject *_wrap_new_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM3Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AM3Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + mfem::AM3Solver *arg1 = (mfem::AM3Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM3Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK33Solver" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM3Solver" "', argument " "1"" of type '" "mfem::AM3Solver *""'"); } - arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + arg1 = reinterpret_cast< mfem::AM3Solver * >(argp1); { try { delete arg1; @@ -5833,33 +5956,25 @@ SWIGINTERN PyObject *_wrap_delete_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SDIRK33Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM3Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM3Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SDIRK33Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *AM3Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_AM4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - double arg1 ; - double val1 ; - int ecode1 = 0 ; - mfem::GeneralizedAlphaSolver *result = 0 ; + mfem::AM4Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); + if (!SWIG_Python_UnpackTuple(args, "new_AM4Solver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); + result = (mfem::AM4Solver *)new mfem::AM4Solver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5876,21 +5991,30 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AM4Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_delete_AM4Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *result = 0 ; + mfem::AM4Solver *arg1 = (mfem::AM4Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AM4Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AM4Solver" "', argument " "1"" of type '" "mfem::AM4Solver *""'"); + } + arg1 = reinterpret_cast< mfem::AM4Solver * >(argp1); { try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5907,47 +6031,27 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver(double)\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver()\n"); - return 0; +SWIGINTERN PyObject *AM4Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AM4Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } +SWIGINTERN PyObject *AM4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; @@ -5955,18 +6059,18 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } - arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { @@ -5995,9 +6099,9 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::Vector *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; @@ -6009,18 +6113,18 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( double dtemp4 ; PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } - arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { @@ -6063,20 +6167,51 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_delete_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::BackwardEulerSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_BackwardEulerSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::BackwardEulerSolver *)new mfem::BackwardEulerSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_BackwardEulerSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeneralizedAlphaSolver" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BackwardEulerSolver" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } - arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); { try { delete arg1; @@ -6103,55 +6238,44 @@ SWIGINTERN PyObject *_wrap_delete_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *GeneralizedAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BackwardEulerSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BackwardEulerSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *GeneralizedAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BackwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; - mfem::Operator *arg2 = 0 ; - mfem::TimeDependentOperator *arg3 = 0 ; + mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Init", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Init" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Init" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } - arg3 = reinterpret_cast< mfem::TimeDependentOperator * >(argp3); + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { try { - (arg1)->Init(*arg2,*arg3); + (arg1)->Init(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6175,56 +6299,45 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + double *arg3 = 0 ; double *arg4 = 0 ; - double *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - PyObject *swig_obj[5] ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Step" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Step" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; } { try { - (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + (arg1)->Step(*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6242,76 +6355,115 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } } resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } { resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ImplicitMidpointSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ImplicitMidpointSolver", 0, 0, 0)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + try { + result = (mfem::ImplicitMidpointSolver *)new mfem::ImplicitMidpointSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ImplicitMidpointSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - double arg6 ; + mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - double val6 ; - int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Run", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Run" "', argument " "1"" of type '" "mfem::SIASolver *""'"); - } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ImplicitMidpointSolver" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ImplicitMidpointSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ImplicitMidpointSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ImplicitMidpointSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::SDIRK23Solver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SIASolver_Run" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); { try { - (arg1)->Run(*arg2,*arg3,*arg4,*arg5,arg6); + result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6328,36 +6480,106 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::SDIRK23Solver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + try { + result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SIASolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SDIRK23Solver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SDIRK23Solver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SDIRK23Solver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SDIRK23Solver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SDIRK23Solver::SDIRK23Solver(int)\n" + " mfem::SDIRK23Solver::SDIRK23Solver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIASolver" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); } - arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); { try { - delete arg1; + (arg1)->Init(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6381,21 +6603,2845 @@ SWIGINTERN PyObject *_wrap_delete_SIASolver(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *SIASolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIASolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK23Solver" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SDIRK23Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SDIRK23Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SDIRK34Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SDIRK34Solver *)new mfem::SDIRK34Solver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SDIRK34Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK34Solver" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SDIRK34Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK34Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SDIRK34Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SDIRK33Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SDIRK33Solver *)new mfem::SDIRK33Solver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SDIRK33Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SDIRK33Solver" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SDIRK33Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SDIRK33Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SDIRK33Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::GeneralizedAlphaSolver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + { + try { + result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlphaSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_GeneralizedAlphaSolver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_GeneralizedAlphaSolver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlphaSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver(double)\n" + " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::TimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::TimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double temp3 ; + double dtemp4 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Step", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + temp3 = PyFloat_AsDouble(swig_obj[2]); + arg3 = &temp3; + } + { + dtemp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &dtemp4; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg3)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeneralizedAlphaSolver" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GeneralizedAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GeneralizedAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::Operator *arg2 = 0 ; + mfem::TimeDependentOperator *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "SIASolver_Init", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Init" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); + } + arg3 = reinterpret_cast< mfem::TimeDependentOperator * >(argp3); + { + try { + (arg1)->Init(*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIASolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Step" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + double val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + + if (!SWIG_Python_UnpackTuple(args, "SIASolver_Run", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Run" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SIASolver_Run" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + (arg1)->Run(*arg2,*arg3,*arg4,*arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIASolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIASolver" "', argument " "1"" of type '" "mfem::SIASolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIASolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIASolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA1Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SIA1Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SIA1Solver *)new mfem::SIA1Solver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIA1Solver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA1Solver_Step" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA1Solver" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIA1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA1Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SIA1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA2Solver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SIA2Solver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SIA2Solver *)new mfem::SIA2Solver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIA2Solver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA2Solver_Step" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA2Solver" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIA2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA2Solver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SIA2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + PyObject *swig_obj[1] ; + mfem::SIAVSolver *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::SIAVSolver *)new mfem::SIAVSolver(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SIAVSolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIAVSolver_Step" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIAVSolver" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); + } + arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SIAVSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIAVSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SIAVSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Init" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Step" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + double val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + + if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Run", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Run" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SecondOrderODESolver_Run" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + (arg1)->Run(*arg2,*arg3,*arg4,*arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_SecondOrderODESolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondOrderODESolver" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SecondOrderODESolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SecondOrderODESolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double arg2 ; + double val1 ; + int ecode1 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::NewmarkSolver *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewmarkSolver" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::NewmarkSolver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + { + try { + result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_NewmarkSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_NewmarkSolver", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_NewmarkSolver__SWIG_2(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_NewmarkSolver__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_NewmarkSolver__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NewmarkSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::NewmarkSolver::NewmarkSolver(double,double)\n" + " mfem::NewmarkSolver::NewmarkSolver(double)\n" + " mfem::NewmarkSolver::NewmarkSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + try { + (arg1)->PrintProperties(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + { + try { + (arg1)->PrintProperties(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "NewmarkSolver_PrintProperties", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_NewmarkSolver_PrintProperties__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_NewmarkSolver_PrintProperties__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NewmarkSolver_PrintProperties'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::NewmarkSolver::PrintProperties(std::ostream &)\n" + " mfem::NewmarkSolver::PrintProperties()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Init" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); + { + try { + (arg1)->Init(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double temp4 ; + double dtemp5 ; + PyObject *swig_obj[5] ; + + if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Step" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewmarkSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + temp4 = PyFloat_AsDouble(swig_obj[3]); + arg4 = &temp4; + } + { + dtemp5 = PyFloat_AsDouble(swig_obj[4]); + arg5 = &dtemp5; + } + { + try { + (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_NewmarkSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewmarkSolver" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *NewmarkSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NewmarkSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NewmarkSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_LinearAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::LinearAccelerationSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_LinearAccelerationSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::LinearAccelerationSolver *)new mfem::LinearAccelerationSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LinearAccelerationSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_LinearAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::LinearAccelerationSolver *arg1 = (mfem::LinearAccelerationSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearAccelerationSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LinearAccelerationSolver" "', argument " "1"" of type '" "mfem::LinearAccelerationSolver *""'"); + } + arg1 = reinterpret_cast< mfem::LinearAccelerationSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *LinearAccelerationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__LinearAccelerationSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *LinearAccelerationSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_CentralDifferenceSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CentralDifferenceSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_CentralDifferenceSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::CentralDifferenceSolver *)new mfem::CentralDifferenceSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CentralDifferenceSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_CentralDifferenceSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CentralDifferenceSolver *arg1 = (mfem::CentralDifferenceSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CentralDifferenceSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CentralDifferenceSolver" "', argument " "1"" of type '" "mfem::CentralDifferenceSolver *""'"); + } + arg1 = reinterpret_cast< mfem::CentralDifferenceSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CentralDifferenceSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CentralDifferenceSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CentralDifferenceSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_FoxGoodwinSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FoxGoodwinSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_FoxGoodwinSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::FoxGoodwinSolver *)new mfem::FoxGoodwinSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FoxGoodwinSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_FoxGoodwinSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FoxGoodwinSolver *arg1 = (mfem::FoxGoodwinSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FoxGoodwinSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FoxGoodwinSolver" "', argument " "1"" of type '" "mfem::FoxGoodwinSolver *""'"); + } + arg1 = reinterpret_cast< mfem::FoxGoodwinSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *FoxGoodwinSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FoxGoodwinSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *FoxGoodwinSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::GeneralizedAlpha2Solver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + { + try { + result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::GeneralizedAlpha2Solver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlpha2Solver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_GeneralizedAlpha2Solver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_GeneralizedAlpha2Solver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlpha2Solver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver(double)\n" + " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; + std::ostream *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + try { + (arg1)->PrintProperties(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); + { + try { + (arg1)->PrintProperties(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_PrintProperties", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GeneralizedAlpha2Solver_PrintProperties'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GeneralizedAlpha2Solver::PrintProperties(std::ostream &)\n" + " mfem::GeneralizedAlpha2Solver::PrintProperties()\n"); + return 0; } -SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA1Solver *result = 0 ; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "new_SIA1Solver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Init", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); + } + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); { try { - result = (mfem::SIA1Solver *)new mfem::SIA1Solver(); + (arg1)->Init(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6412,16 +9458,16 @@ SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; double *arg4 = 0 ; @@ -6436,26 +9482,26 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj double dtemp5 ; PyObject *swig_obj[5] ; - if (!SWIG_Python_UnpackTuple(args, "SIA1Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Step", 5, 5, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA1Solver_Step" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } - arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { @@ -6498,20 +9544,20 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_delete_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_GeneralizedAlpha2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; + mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA1Solver" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } - arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); + arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); { try { delete arg1; @@ -6538,25 +9584,25 @@ SWIGINTERN PyObject *_wrap_delete_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *SIA1Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GeneralizedAlpha2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA1Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SIA1Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GeneralizedAlpha2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AverageAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA2Solver *result = 0 ; + mfem::AverageAccelerationSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_SIA2Solver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_AverageAccelerationSolver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::SIA2Solver *)new mfem::SIA2Solver(); + result = (mfem::AverageAccelerationSolver *)new mfem::AverageAccelerationSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6573,63 +9619,30 @@ SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__AverageAccelerationSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_AverageAccelerationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; + mfem::AverageAccelerationSolver *arg1 = (mfem::AverageAccelerationSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SIA2Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AverageAccelerationSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA2Solver_Step" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); - } - arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; - } - { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AverageAccelerationSolver" "', argument " "1"" of type '" "mfem::AverageAccelerationSolver *""'"); } + arg1 = reinterpret_cast< mfem::AverageAccelerationSolver * >(argp1); { try { - (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6647,32 +9660,138 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } } resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *AverageAccelerationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__AverageAccelerationSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *AverageAccelerationSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::HHTAlphaSolver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HHTAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); + try { + result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::HHTAlphaSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); + try { + result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HHTAlphaSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_HHTAlphaSolver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_HHTAlphaSolver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HHTAlphaSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HHTAlphaSolver::HHTAlphaSolver(double)\n" + " mfem::HHTAlphaSolver::HHTAlphaSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_HHTAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; + mfem::HHTAlphaSolver *arg1 = (mfem::HHTAlphaSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIA2Solver" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HHTAlphaSolver" "', argument " "1"" of type '" "mfem::HHTAlphaSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); + arg1 = reinterpret_cast< mfem::HHTAlphaSolver * >(argp1); { try { delete arg1; @@ -6699,34 +9818,33 @@ SWIGINTERN PyObject *_wrap_delete_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *SIA2Solver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *HHTAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIA2Solver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SIA2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *HHTAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - PyObject *swig_obj[1] ; - mfem::SIAVSolver *result = 0 ; + double arg1 ; + double val1 ; + int ecode1 = 0 ; + mfem::WBZAlphaSolver *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WBZAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); { try { - result = (mfem::SIAVSolver *)new mfem::SIAVSolver(arg1); + result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6743,63 +9861,21 @@ SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double temp4 ; - double dtemp5 ; - PyObject *swig_obj[5] ; + mfem::WBZAlphaSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SIAVSolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIAVSolver_Step" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); - } - arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - temp4 = PyFloat_AsDouble(swig_obj[3]); - arg4 = &temp4; - } - { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); - arg5 = &dtemp5; - } + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - (arg1)->Step(*arg2,*arg3,*arg4,*arg5); + result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6816,33 +9892,58 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg4)); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble(*arg5)); - } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_WBZAlphaSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_WBZAlphaSolver__SWIG_1(self, argc, argv); + } + if (argc == 1) { + int _v; + { + int res = SWIG_AsVal_double(argv[0], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_WBZAlphaSolver__SWIG_0(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WBZAlphaSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::WBZAlphaSolver::WBZAlphaSolver(double)\n" + " mfem::WBZAlphaSolver::WBZAlphaSolver()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_WBZAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; + mfem::WBZAlphaSolver *arg1 = (mfem::WBZAlphaSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SIAVSolver" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_WBZAlphaSolver" "', argument " "1"" of type '" "mfem::WBZAlphaSolver *""'"); } - arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); + arg1 = reinterpret_cast< mfem::WBZAlphaSolver * >(argp1); { try { delete arg1; @@ -6869,19 +9970,20 @@ SWIGINTERN PyObject *_wrap_delete_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *SIAVSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *WBZAlphaSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SIAVSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SIAVSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *WBZAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "ODESolver_Init(ODESolver self, TimeDependentOperator f)"}, { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "ODESolver_Step(ODESolver self, Vector x, double & t, double & dt)"}, { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "ODESolver_Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, @@ -6925,6 +10027,58 @@ static PyMethodDef SwigMethods[] = { { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "AdamsBashforthSolver_Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "AdamsBashforthSolver_Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, + { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, + { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, + { "new_AB1Solver", _wrap_new_AB1Solver, METH_NOARGS, "new_AB1Solver() -> AB1Solver"}, + { "delete_AB1Solver", _wrap_delete_AB1Solver, METH_O, "delete_AB1Solver(AB1Solver self)"}, + { "AB1Solver_swigregister", AB1Solver_swigregister, METH_O, NULL}, + { "AB1Solver_swiginit", AB1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB2Solver", _wrap_new_AB2Solver, METH_NOARGS, "new_AB2Solver() -> AB2Solver"}, + { "delete_AB2Solver", _wrap_delete_AB2Solver, METH_O, "delete_AB2Solver(AB2Solver self)"}, + { "AB2Solver_swigregister", AB2Solver_swigregister, METH_O, NULL}, + { "AB2Solver_swiginit", AB2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB3Solver", _wrap_new_AB3Solver, METH_NOARGS, "new_AB3Solver() -> AB3Solver"}, + { "delete_AB3Solver", _wrap_delete_AB3Solver, METH_O, "delete_AB3Solver(AB3Solver self)"}, + { "AB3Solver_swigregister", AB3Solver_swigregister, METH_O, NULL}, + { "AB3Solver_swiginit", AB3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB4Solver", _wrap_new_AB4Solver, METH_NOARGS, "new_AB4Solver() -> AB4Solver"}, + { "delete_AB4Solver", _wrap_delete_AB4Solver, METH_O, "delete_AB4Solver(AB4Solver self)"}, + { "AB4Solver_swigregister", AB4Solver_swigregister, METH_O, NULL}, + { "AB4Solver_swiginit", AB4Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB5Solver", _wrap_new_AB5Solver, METH_NOARGS, "new_AB5Solver() -> AB5Solver"}, + { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, + { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, + { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "AdamsMoultonSolver_Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "AdamsMoultonSolver_Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, + { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, + { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, + { "new_AM0Solver", _wrap_new_AM0Solver, METH_NOARGS, "new_AM0Solver() -> AM0Solver"}, + { "delete_AM0Solver", _wrap_delete_AM0Solver, METH_O, "delete_AM0Solver(AM0Solver self)"}, + { "AM0Solver_swigregister", AM0Solver_swigregister, METH_O, NULL}, + { "AM0Solver_swiginit", AM0Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM1Solver", _wrap_new_AM1Solver, METH_NOARGS, "new_AM1Solver() -> AM1Solver"}, + { "delete_AM1Solver", _wrap_delete_AM1Solver, METH_O, "delete_AM1Solver(AM1Solver self)"}, + { "AM1Solver_swigregister", AM1Solver_swigregister, METH_O, NULL}, + { "AM1Solver_swiginit", AM1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM2Solver", _wrap_new_AM2Solver, METH_NOARGS, "new_AM2Solver() -> AM2Solver"}, + { "delete_AM2Solver", _wrap_delete_AM2Solver, METH_O, "delete_AM2Solver(AM2Solver self)"}, + { "AM2Solver_swigregister", AM2Solver_swigregister, METH_O, NULL}, + { "AM2Solver_swiginit", AM2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM3Solver", _wrap_new_AM3Solver, METH_NOARGS, "new_AM3Solver() -> AM3Solver"}, + { "delete_AM3Solver", _wrap_delete_AM3Solver, METH_O, "delete_AM3Solver(AM3Solver self)"}, + { "AM3Solver_swigregister", AM3Solver_swigregister, METH_O, NULL}, + { "AM3Solver_swiginit", AM3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM4Solver", _wrap_new_AM4Solver, METH_NOARGS, "new_AM4Solver() -> AM4Solver"}, + { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, + { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, + { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "BackwardEulerSolver_Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "BackwardEulerSolver_Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, @@ -6981,61 +10135,357 @@ static PyMethodDef SwigMethods[] = { { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, + { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "SecondOrderODESolver_Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "SecondOrderODESolver_Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "SecondOrderODESolver_Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, + { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, + { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, + { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "NewmarkSolver_PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "NewmarkSolver_Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "NewmarkSolver_Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, + { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, + { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, + { "new_LinearAccelerationSolver", _wrap_new_LinearAccelerationSolver, METH_NOARGS, "new_LinearAccelerationSolver() -> LinearAccelerationSolver"}, + { "delete_LinearAccelerationSolver", _wrap_delete_LinearAccelerationSolver, METH_O, "delete_LinearAccelerationSolver(LinearAccelerationSolver self)"}, + { "LinearAccelerationSolver_swigregister", LinearAccelerationSolver_swigregister, METH_O, NULL}, + { "LinearAccelerationSolver_swiginit", LinearAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_CentralDifferenceSolver", _wrap_new_CentralDifferenceSolver, METH_NOARGS, "new_CentralDifferenceSolver() -> CentralDifferenceSolver"}, + { "delete_CentralDifferenceSolver", _wrap_delete_CentralDifferenceSolver, METH_O, "delete_CentralDifferenceSolver(CentralDifferenceSolver self)"}, + { "CentralDifferenceSolver_swigregister", CentralDifferenceSolver_swigregister, METH_O, NULL}, + { "CentralDifferenceSolver_swiginit", CentralDifferenceSolver_swiginit, METH_VARARGS, NULL}, + { "new_FoxGoodwinSolver", _wrap_new_FoxGoodwinSolver, METH_NOARGS, "new_FoxGoodwinSolver() -> FoxGoodwinSolver"}, + { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, + { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, + { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, + { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, + { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "GeneralizedAlpha2Solver_PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "GeneralizedAlpha2Solver_Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "GeneralizedAlpha2Solver_Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, + { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, + { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AverageAccelerationSolver", _wrap_new_AverageAccelerationSolver, METH_NOARGS, "new_AverageAccelerationSolver() -> AverageAccelerationSolver"}, + { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, + { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, + { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, + { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, + { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, + { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, + { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, + { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "Init(ODESolver self, TimeDependentOperator f)"}, + { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "Step(ODESolver self, Vector x, double & t, double & dt)"}, + { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, + { "delete_ODESolver", _wrap_delete_ODESolver, METH_O, "delete_ODESolver(ODESolver self)"}, + { "ODESolver_swigregister", ODESolver_swigregister, METH_O, NULL}, + { "ForwardEulerSolver_Init", _wrap_ForwardEulerSolver_Init, METH_VARARGS, "Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, + { "ForwardEulerSolver_Step", _wrap_ForwardEulerSolver_Step, METH_VARARGS, "Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "new_ForwardEulerSolver", _wrap_new_ForwardEulerSolver, METH_NOARGS, "new_ForwardEulerSolver() -> ForwardEulerSolver"}, + { "delete_ForwardEulerSolver", _wrap_delete_ForwardEulerSolver, METH_O, "delete_ForwardEulerSolver(ForwardEulerSolver self)"}, + { "ForwardEulerSolver_swigregister", ForwardEulerSolver_swigregister, METH_O, NULL}, + { "ForwardEulerSolver_swiginit", ForwardEulerSolver_swiginit, METH_VARARGS, NULL}, + { "new_RK2Solver", _wrap_new_RK2Solver, METH_VARARGS, "RK2Solver(double const _a=2./3.)"}, + { "RK2Solver_Init", _wrap_RK2Solver_Init, METH_VARARGS, "Init(RK2Solver self, TimeDependentOperator _f)"}, + { "RK2Solver_Step", _wrap_RK2Solver_Step, METH_VARARGS, "Step(RK2Solver self, Vector x, double & t, double & dt)"}, + { "delete_RK2Solver", _wrap_delete_RK2Solver, METH_O, "delete_RK2Solver(RK2Solver self)"}, + { "RK2Solver_swigregister", RK2Solver_swigregister, METH_O, NULL}, + { "RK2Solver_swiginit", RK2Solver_swiginit, METH_VARARGS, NULL}, + { "RK3SSPSolver_Init", _wrap_RK3SSPSolver_Init, METH_VARARGS, "Init(RK3SSPSolver self, TimeDependentOperator _f)"}, + { "RK3SSPSolver_Step", _wrap_RK3SSPSolver_Step, METH_VARARGS, "Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, + { "new_RK3SSPSolver", _wrap_new_RK3SSPSolver, METH_NOARGS, "new_RK3SSPSolver() -> RK3SSPSolver"}, + { "delete_RK3SSPSolver", _wrap_delete_RK3SSPSolver, METH_O, "delete_RK3SSPSolver(RK3SSPSolver self)"}, + { "RK3SSPSolver_swigregister", RK3SSPSolver_swigregister, METH_O, NULL}, + { "RK3SSPSolver_swiginit", RK3SSPSolver_swiginit, METH_VARARGS, NULL}, + { "RK4Solver_Init", _wrap_RK4Solver_Init, METH_VARARGS, "Init(RK4Solver self, TimeDependentOperator _f)"}, + { "RK4Solver_Step", _wrap_RK4Solver_Step, METH_VARARGS, "Step(RK4Solver self, Vector x, double & t, double & dt)"}, + { "new_RK4Solver", _wrap_new_RK4Solver, METH_NOARGS, "new_RK4Solver() -> RK4Solver"}, + { "delete_RK4Solver", _wrap_delete_RK4Solver, METH_O, "delete_RK4Solver(RK4Solver self)"}, + { "RK4Solver_swigregister", RK4Solver_swigregister, METH_O, NULL}, + { "RK4Solver_swiginit", RK4Solver_swiginit, METH_VARARGS, NULL}, + { "new_ExplicitRKSolver", _wrap_new_ExplicitRKSolver, METH_VARARGS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, + { "ExplicitRKSolver_Init", _wrap_ExplicitRKSolver_Init, METH_VARARGS, "Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, + { "ExplicitRKSolver_Step", _wrap_ExplicitRKSolver_Step, METH_VARARGS, "Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, + { "delete_ExplicitRKSolver", _wrap_delete_ExplicitRKSolver, METH_O, "delete_ExplicitRKSolver(ExplicitRKSolver self)"}, + { "ExplicitRKSolver_swigregister", ExplicitRKSolver_swigregister, METH_O, NULL}, + { "ExplicitRKSolver_swiginit", ExplicitRKSolver_swiginit, METH_VARARGS, NULL}, + { "new_RK6Solver", _wrap_new_RK6Solver, METH_NOARGS, "new_RK6Solver() -> RK6Solver"}, + { "delete_RK6Solver", _wrap_delete_RK6Solver, METH_O, "delete_RK6Solver(RK6Solver self)"}, + { "RK6Solver_swigregister", RK6Solver_swigregister, METH_O, NULL}, + { "RK6Solver_swiginit", RK6Solver_swiginit, METH_VARARGS, NULL}, + { "new_RK8Solver", _wrap_new_RK8Solver, METH_NOARGS, "new_RK8Solver() -> RK8Solver"}, + { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, + { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, + { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, + { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, + { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, + { "new_AB1Solver", _wrap_new_AB1Solver, METH_NOARGS, "new_AB1Solver() -> AB1Solver"}, + { "delete_AB1Solver", _wrap_delete_AB1Solver, METH_O, "delete_AB1Solver(AB1Solver self)"}, + { "AB1Solver_swigregister", AB1Solver_swigregister, METH_O, NULL}, + { "AB1Solver_swiginit", AB1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB2Solver", _wrap_new_AB2Solver, METH_NOARGS, "new_AB2Solver() -> AB2Solver"}, + { "delete_AB2Solver", _wrap_delete_AB2Solver, METH_O, "delete_AB2Solver(AB2Solver self)"}, + { "AB2Solver_swigregister", AB2Solver_swigregister, METH_O, NULL}, + { "AB2Solver_swiginit", AB2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB3Solver", _wrap_new_AB3Solver, METH_NOARGS, "new_AB3Solver() -> AB3Solver"}, + { "delete_AB3Solver", _wrap_delete_AB3Solver, METH_O, "delete_AB3Solver(AB3Solver self)"}, + { "AB3Solver_swigregister", AB3Solver_swigregister, METH_O, NULL}, + { "AB3Solver_swiginit", AB3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB4Solver", _wrap_new_AB4Solver, METH_NOARGS, "new_AB4Solver() -> AB4Solver"}, + { "delete_AB4Solver", _wrap_delete_AB4Solver, METH_O, "delete_AB4Solver(AB4Solver self)"}, + { "AB4Solver_swigregister", AB4Solver_swigregister, METH_O, NULL}, + { "AB4Solver_swiginit", AB4Solver_swiginit, METH_VARARGS, NULL}, + { "new_AB5Solver", _wrap_new_AB5Solver, METH_NOARGS, "new_AB5Solver() -> AB5Solver"}, + { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, + { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, + { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, + { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, + { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, + { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, + { "new_AM0Solver", _wrap_new_AM0Solver, METH_NOARGS, "new_AM0Solver() -> AM0Solver"}, + { "delete_AM0Solver", _wrap_delete_AM0Solver, METH_O, "delete_AM0Solver(AM0Solver self)"}, + { "AM0Solver_swigregister", AM0Solver_swigregister, METH_O, NULL}, + { "AM0Solver_swiginit", AM0Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM1Solver", _wrap_new_AM1Solver, METH_NOARGS, "new_AM1Solver() -> AM1Solver"}, + { "delete_AM1Solver", _wrap_delete_AM1Solver, METH_O, "delete_AM1Solver(AM1Solver self)"}, + { "AM1Solver_swigregister", AM1Solver_swigregister, METH_O, NULL}, + { "AM1Solver_swiginit", AM1Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM2Solver", _wrap_new_AM2Solver, METH_NOARGS, "new_AM2Solver() -> AM2Solver"}, + { "delete_AM2Solver", _wrap_delete_AM2Solver, METH_O, "delete_AM2Solver(AM2Solver self)"}, + { "AM2Solver_swigregister", AM2Solver_swigregister, METH_O, NULL}, + { "AM2Solver_swiginit", AM2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM3Solver", _wrap_new_AM3Solver, METH_NOARGS, "new_AM3Solver() -> AM3Solver"}, + { "delete_AM3Solver", _wrap_delete_AM3Solver, METH_O, "delete_AM3Solver(AM3Solver self)"}, + { "AM3Solver_swigregister", AM3Solver_swigregister, METH_O, NULL}, + { "AM3Solver_swiginit", AM3Solver_swiginit, METH_VARARGS, NULL}, + { "new_AM4Solver", _wrap_new_AM4Solver, METH_NOARGS, "new_AM4Solver() -> AM4Solver"}, + { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, + { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, + { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, + { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, + { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, + { "delete_BackwardEulerSolver", _wrap_delete_BackwardEulerSolver, METH_O, "delete_BackwardEulerSolver(BackwardEulerSolver self)"}, + { "BackwardEulerSolver_swigregister", BackwardEulerSolver_swigregister, METH_O, NULL}, + { "BackwardEulerSolver_swiginit", BackwardEulerSolver_swiginit, METH_VARARGS, NULL}, + { "ImplicitMidpointSolver_Init", _wrap_ImplicitMidpointSolver_Init, METH_VARARGS, "Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, + { "ImplicitMidpointSolver_Step", _wrap_ImplicitMidpointSolver_Step, METH_VARARGS, "Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, + { "new_ImplicitMidpointSolver", _wrap_new_ImplicitMidpointSolver, METH_NOARGS, "new_ImplicitMidpointSolver() -> ImplicitMidpointSolver"}, + { "delete_ImplicitMidpointSolver", _wrap_delete_ImplicitMidpointSolver, METH_O, "delete_ImplicitMidpointSolver(ImplicitMidpointSolver self)"}, + { "ImplicitMidpointSolver_swigregister", ImplicitMidpointSolver_swigregister, METH_O, NULL}, + { "ImplicitMidpointSolver_swiginit", ImplicitMidpointSolver_swiginit, METH_VARARGS, NULL}, + { "new_SDIRK23Solver", _wrap_new_SDIRK23Solver, METH_VARARGS, "SDIRK23Solver(int gamma_opt=1)"}, + { "SDIRK23Solver_Init", _wrap_SDIRK23Solver_Init, METH_VARARGS, "Init(SDIRK23Solver self, TimeDependentOperator _f)"}, + { "SDIRK23Solver_Step", _wrap_SDIRK23Solver_Step, METH_VARARGS, "Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, + { "delete_SDIRK23Solver", _wrap_delete_SDIRK23Solver, METH_O, "delete_SDIRK23Solver(SDIRK23Solver self)"}, + { "SDIRK23Solver_swigregister", SDIRK23Solver_swigregister, METH_O, NULL}, + { "SDIRK23Solver_swiginit", SDIRK23Solver_swiginit, METH_VARARGS, NULL}, + { "SDIRK34Solver_Init", _wrap_SDIRK34Solver_Init, METH_VARARGS, "Init(SDIRK34Solver self, TimeDependentOperator _f)"}, + { "SDIRK34Solver_Step", _wrap_SDIRK34Solver_Step, METH_VARARGS, "Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK34Solver", _wrap_new_SDIRK34Solver, METH_NOARGS, "new_SDIRK34Solver() -> SDIRK34Solver"}, + { "delete_SDIRK34Solver", _wrap_delete_SDIRK34Solver, METH_O, "delete_SDIRK34Solver(SDIRK34Solver self)"}, + { "SDIRK34Solver_swigregister", SDIRK34Solver_swigregister, METH_O, NULL}, + { "SDIRK34Solver_swiginit", SDIRK34Solver_swiginit, METH_VARARGS, NULL}, + { "SDIRK33Solver_Init", _wrap_SDIRK33Solver_Init, METH_VARARGS, "Init(SDIRK33Solver self, TimeDependentOperator _f)"}, + { "SDIRK33Solver_Step", _wrap_SDIRK33Solver_Step, METH_VARARGS, "Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK33Solver", _wrap_new_SDIRK33Solver, METH_NOARGS, "new_SDIRK33Solver() -> SDIRK33Solver"}, + { "delete_SDIRK33Solver", _wrap_delete_SDIRK33Solver, METH_O, "delete_SDIRK33Solver(SDIRK33Solver self)"}, + { "SDIRK33Solver_swigregister", SDIRK33Solver_swigregister, METH_O, NULL}, + { "SDIRK33Solver_swiginit", SDIRK33Solver_swiginit, METH_VARARGS, NULL}, + { "new_GeneralizedAlphaSolver", _wrap_new_GeneralizedAlphaSolver, METH_VARARGS, "GeneralizedAlphaSolver(double rho=1.0)"}, + { "GeneralizedAlphaSolver_Init", _wrap_GeneralizedAlphaSolver_Init, METH_VARARGS, "Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, + { "GeneralizedAlphaSolver_Step", _wrap_GeneralizedAlphaSolver_Step, METH_VARARGS, "Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, + { "delete_GeneralizedAlphaSolver", _wrap_delete_GeneralizedAlphaSolver, METH_O, "delete_GeneralizedAlphaSolver(GeneralizedAlphaSolver self)"}, + { "GeneralizedAlphaSolver_swigregister", GeneralizedAlphaSolver_swigregister, METH_O, NULL}, + { "GeneralizedAlphaSolver_swiginit", GeneralizedAlphaSolver_swiginit, METH_VARARGS, NULL}, + { "SIASolver_Init", _wrap_SIASolver_Init, METH_VARARGS, "Init(SIASolver self, Operator P, TimeDependentOperator F)"}, + { "SIASolver_Step", _wrap_SIASolver_Step, METH_VARARGS, "Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIASolver_Run", _wrap_SIASolver_Run, METH_VARARGS, "Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, + { "delete_SIASolver", _wrap_delete_SIASolver, METH_O, "delete_SIASolver(SIASolver self)"}, + { "SIASolver_swigregister", SIASolver_swigregister, METH_O, NULL}, + { "new_SIA1Solver", _wrap_new_SIA1Solver, METH_NOARGS, "new_SIA1Solver() -> SIA1Solver"}, + { "SIA1Solver_Step", _wrap_SIA1Solver_Step, METH_VARARGS, "Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "delete_SIA1Solver", _wrap_delete_SIA1Solver, METH_O, "delete_SIA1Solver(SIA1Solver self)"}, + { "SIA1Solver_swigregister", SIA1Solver_swigregister, METH_O, NULL}, + { "SIA1Solver_swiginit", SIA1Solver_swiginit, METH_VARARGS, NULL}, + { "new_SIA2Solver", _wrap_new_SIA2Solver, METH_NOARGS, "new_SIA2Solver() -> SIA2Solver"}, + { "SIA2Solver_Step", _wrap_SIA2Solver_Step, METH_VARARGS, "Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "delete_SIA2Solver", _wrap_delete_SIA2Solver, METH_O, "delete_SIA2Solver(SIA2Solver self)"}, + { "SIA2Solver_swigregister", SIA2Solver_swigregister, METH_O, NULL}, + { "SIA2Solver_swiginit", SIA2Solver_swiginit, METH_VARARGS, NULL}, + { "new_SIAVSolver", _wrap_new_SIAVSolver, METH_O, "new_SIAVSolver(int order) -> SIAVSolver"}, + { "SIAVSolver_Step", _wrap_SIAVSolver_Step, METH_VARARGS, "Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, + { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, + { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, + { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, + { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, + { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, + { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, + { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, + { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, + { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, + { "new_LinearAccelerationSolver", _wrap_new_LinearAccelerationSolver, METH_NOARGS, "new_LinearAccelerationSolver() -> LinearAccelerationSolver"}, + { "delete_LinearAccelerationSolver", _wrap_delete_LinearAccelerationSolver, METH_O, "delete_LinearAccelerationSolver(LinearAccelerationSolver self)"}, + { "LinearAccelerationSolver_swigregister", LinearAccelerationSolver_swigregister, METH_O, NULL}, + { "LinearAccelerationSolver_swiginit", LinearAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_CentralDifferenceSolver", _wrap_new_CentralDifferenceSolver, METH_NOARGS, "new_CentralDifferenceSolver() -> CentralDifferenceSolver"}, + { "delete_CentralDifferenceSolver", _wrap_delete_CentralDifferenceSolver, METH_O, "delete_CentralDifferenceSolver(CentralDifferenceSolver self)"}, + { "CentralDifferenceSolver_swigregister", CentralDifferenceSolver_swigregister, METH_O, NULL}, + { "CentralDifferenceSolver_swiginit", CentralDifferenceSolver_swiginit, METH_VARARGS, NULL}, + { "new_FoxGoodwinSolver", _wrap_new_FoxGoodwinSolver, METH_NOARGS, "new_FoxGoodwinSolver() -> FoxGoodwinSolver"}, + { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, + { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, + { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, + { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, + { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, + { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, + { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, + { "new_AverageAccelerationSolver", _wrap_new_AverageAccelerationSolver, METH_NOARGS, "new_AverageAccelerationSolver() -> AverageAccelerationSolver"}, + { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, + { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, + { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, + { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, + { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, + { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, + { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, + { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, + { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ -static void *_p_mfem__SIA2SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::SIASolver *) ((mfem::SIA2Solver *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__SIAVSolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::SIASolver *) ((mfem::SIAVSolver *) x)); +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } -static void *_p_mfem__SIA1SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::SIASolver *) ((mfem::SIA1Solver *) x)); +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__RK6SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } -static void *_p_mfem__RK8SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); } -static void *_p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::ForwardEulerSolver *) x)); +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } -static void *_p_mfem__RK2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::RK2Solver *) x)); +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); } -static void *_p_mfem__RK3SSPSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::RK3SSPSolver *) x)); +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } -static void *_p_mfem__RK4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::RK4Solver *) x)); +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); } -static void *_p_mfem__RK6SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); } -static void *_p_mfem__RK8SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); } -static void *_p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::BackwardEulerSolver *) x)); +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } -static void *_p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::ImplicitMidpointSolver *) x)); +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); } -static void *_p_mfem__SDIRK34SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::ODESolver *) ((mfem::SDIRK34Solver *) x)); +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__AB2SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB2Solver *) x)); +} +static void *_p_mfem__AB4SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB4Solver *) x)); +} +static void *_p_mfem__AB1SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB1Solver *) x)); +} +static void *_p_mfem__AB3SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB3Solver *) x)); +} +static void *_p_mfem__AB5SolverTo_p_mfem__AdamsBashforthSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsBashforthSolver *) ((mfem::AB5Solver *) x)); +} +static void *_p_mfem__AM0SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM0Solver *) x)); +} +static void *_p_mfem__AM2SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM2Solver *) x)); +} +static void *_p_mfem__AM4SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM4Solver *) x)); +} +static void *_p_mfem__AM1SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM1Solver *) x)); +} +static void *_p_mfem__AM3SolverTo_p_mfem__AdamsMoultonSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::AdamsMoultonSolver *) ((mfem::AM3Solver *) x)); +} +static void *_p_mfem__AverageAccelerationSolverTo_p_mfem__GeneralizedAlpha2Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GeneralizedAlpha2Solver *) ((mfem::AverageAccelerationSolver *) x)); +} +static void *_p_mfem__HHTAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GeneralizedAlpha2Solver *) ((mfem::HHTAlphaSolver *) x)); +} +static void *_p_mfem__WBZAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::GeneralizedAlpha2Solver *) ((mfem::WBZAlphaSolver *) x)); +} +static void *_p_mfem__AB5SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB5Solver *) x)); +} +static void *_p_mfem__AB3SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB3Solver *) x)); +} +static void *_p_mfem__AB1SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB1Solver *) x)); } static void *_p_mfem__ExplicitRKSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ODESolver *) ((mfem::ExplicitRKSolver *) x)); } +static void *_p_mfem__AM1SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM1Solver *) x)); +} +static void *_p_mfem__AM3SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM3Solver *) x)); +} static void *_p_mfem__SDIRK23SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ODESolver *) ((mfem::SDIRK23Solver *) x)); } @@ -7045,58 +10495,142 @@ static void *_p_mfem__SDIRK33SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSED static void *_p_mfem__GeneralizedAlphaSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::ODESolver *) ((mfem::GeneralizedAlphaSolver *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__AdamsMoultonSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::AdamsMoultonSolver *) x)); } -static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +static void *_p_mfem__AB4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB4Solver *) x)); } -static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +static void *_p_mfem__AB2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsBashforthSolver *) ((mfem::AB2Solver *) x)); } -static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +static void *_p_mfem__AdamsBashforthSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::AdamsBashforthSolver *) x)); } -static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +static void *_p_mfem__RK8SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); } -static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +static void *_p_mfem__RK6SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); } -static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +static void *_p_mfem__RK4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::RK4Solver *) x)); } -static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +static void *_p_mfem__RK3SSPSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::RK3SSPSolver *) x)); } -static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +static void *_p_mfem__RK2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::RK2Solver *) x)); } -static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +static void *_p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::ForwardEulerSolver *) x)); } -static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +static void *_p_mfem__AM0SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM0Solver *) x)); +} +static void *_p_mfem__AM2SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM2Solver *) x)); +} +static void *_p_mfem__AM4SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) (mfem::AdamsMoultonSolver *) ((mfem::AM4Solver *) x)); +} +static void *_p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::BackwardEulerSolver *) x)); +} +static void *_p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::ImplicitMidpointSolver *) x)); +} +static void *_p_mfem__SDIRK34SolverTo_p_mfem__ODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ODESolver *) ((mfem::SDIRK34Solver *) x)); +} +static void *_p_mfem__RK6SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK6Solver *) x)); +} +static void *_p_mfem__RK8SolverTo_p_mfem__ExplicitRKSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::ExplicitRKSolver *) ((mfem::RK8Solver *) x)); +} +static void *_p_mfem__SIA2SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SIASolver *) ((mfem::SIA2Solver *) x)); +} +static void *_p_mfem__SIAVSolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SIASolver *) ((mfem::SIAVSolver *) x)); +} +static void *_p_mfem__SIA1SolverTo_p_mfem__SIASolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SIASolver *) ((mfem::SIA1Solver *) x)); +} +static void *_p_mfem__LinearAccelerationSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::NewmarkSolver *) ((mfem::LinearAccelerationSolver *) x)); +} +static void *_p_mfem__FoxGoodwinSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::NewmarkSolver *) ((mfem::FoxGoodwinSolver *) x)); +} +static void *_p_mfem__GeneralizedAlpha2SolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) ((mfem::GeneralizedAlpha2Solver *) x)); +} +static void *_p_mfem__AverageAccelerationSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::GeneralizedAlpha2Solver *) ((mfem::AverageAccelerationSolver *) x)); +} +static void *_p_mfem__NewmarkSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) ((mfem::NewmarkSolver *) x)); +} +static void *_p_mfem__CentralDifferenceSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::NewmarkSolver *) ((mfem::CentralDifferenceSolver *) x)); +} +static void *_p_mfem__HHTAlphaSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::GeneralizedAlpha2Solver *) ((mfem::HHTAlphaSolver *) x)); +} +static void *_p_mfem__WBZAlphaSolverTo_p_mfem__SecondOrderODESolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::SecondOrderODESolver *) (mfem::GeneralizedAlpha2Solver *) ((mfem::WBZAlphaSolver *) x)); +} +static void *_p_mfem__LinearAccelerationSolverTo_p_mfem__NewmarkSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NewmarkSolver *) ((mfem::LinearAccelerationSolver *) x)); +} +static void *_p_mfem__FoxGoodwinSolverTo_p_mfem__NewmarkSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NewmarkSolver *) ((mfem::FoxGoodwinSolver *) x)); +} +static void *_p_mfem__CentralDifferenceSolverTo_p_mfem__NewmarkSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::NewmarkSolver *) ((mfem::CentralDifferenceSolver *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB1Solver = {"_p_mfem__AB1Solver", "mfem::AB1Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB2Solver = {"_p_mfem__AB2Solver", "mfem::AB2Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB3Solver = {"_p_mfem__AB3Solver", "mfem::AB3Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB4Solver = {"_p_mfem__AB4Solver", "mfem::AB4Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AB5Solver = {"_p_mfem__AB5Solver", "mfem::AB5Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM0Solver = {"_p_mfem__AM0Solver", "mfem::AM0Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM1Solver = {"_p_mfem__AM1Solver", "mfem::AM1Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM2Solver = {"_p_mfem__AM2Solver", "mfem::AM2Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM3Solver = {"_p_mfem__AM3Solver", "mfem::AM3Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AM4Solver = {"_p_mfem__AM4Solver", "mfem::AM4Solver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AdamsBashforthSolver = {"_p_mfem__AdamsBashforthSolver", "mfem::AdamsBashforthSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AdamsMoultonSolver = {"_p_mfem__AdamsMoultonSolver", "mfem::AdamsMoultonSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__AverageAccelerationSolver = {"_p_mfem__AverageAccelerationSolver", "mfem::AverageAccelerationSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BackwardEulerSolver = {"_p_mfem__BackwardEulerSolver", "mfem::BackwardEulerSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__CentralDifferenceSolver = {"_p_mfem__CentralDifferenceSolver", "mfem::CentralDifferenceSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ExplicitRKSolver = {"_p_mfem__ExplicitRKSolver", "mfem::ExplicitRKSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ForwardEulerSolver = {"_p_mfem__ForwardEulerSolver", "mfem::ForwardEulerSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FoxGoodwinSolver = {"_p_mfem__FoxGoodwinSolver", "mfem::FoxGoodwinSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__GeneralizedAlpha2Solver = {"_p_mfem__GeneralizedAlpha2Solver", "mfem::GeneralizedAlpha2Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GeneralizedAlphaSolver = {"_p_mfem__GeneralizedAlphaSolver", "mfem::GeneralizedAlphaSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__HHTAlphaSolver = {"_p_mfem__HHTAlphaSolver", "mfem::HHTAlphaSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ImplicitMidpointSolver = {"_p_mfem__ImplicitMidpointSolver", "mfem::ImplicitMidpointSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__LinearAccelerationSolver = {"_p_mfem__LinearAccelerationSolver", "mfem::LinearAccelerationSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__NewmarkSolver = {"_p_mfem__NewmarkSolver", "mfem::NewmarkSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ODESolver = {"_p_mfem__ODESolver", "mfem::ODESolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RK2Solver = {"_p_mfem__RK2Solver", "mfem::RK2Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__RK3SSPSolver = {"_p_mfem__RK3SSPSolver", "mfem::RK3SSPSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__RK4Solver = {"_p_mfem__RK4Solver", "mfem::RK4Solver *", 0, 0, (void*)0, 0}; @@ -7109,20 +10643,42 @@ static swig_type_info _swigt__p_mfem__SIA1Solver = {"_p_mfem__SIA1Solver", "mfem static swig_type_info _swigt__p_mfem__SIA2Solver = {"_p_mfem__SIA2Solver", "mfem::SIA2Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SIASolver = {"_p_mfem__SIASolver", "mfem::SIASolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SIAVSolver = {"_p_mfem__SIAVSolver", "mfem::SIAVSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderODESolver = {"_p_mfem__SecondOrderODESolver", "mfem::SecondOrderODESolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", "mfem::SecondOrderTimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", "mfem::TimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__WBZAlphaSolver = {"_p_mfem__WBZAlphaSolver", "mfem::WBZAlphaSolver *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, &_swigt__p_char, &_swigt__p_double, + &_swigt__p_mfem__AB1Solver, + &_swigt__p_mfem__AB2Solver, + &_swigt__p_mfem__AB3Solver, + &_swigt__p_mfem__AB4Solver, + &_swigt__p_mfem__AB5Solver, + &_swigt__p_mfem__AM0Solver, + &_swigt__p_mfem__AM1Solver, + &_swigt__p_mfem__AM2Solver, + &_swigt__p_mfem__AM3Solver, + &_swigt__p_mfem__AM4Solver, + &_swigt__p_mfem__AdamsBashforthSolver, + &_swigt__p_mfem__AdamsMoultonSolver, + &_swigt__p_mfem__AverageAccelerationSolver, &_swigt__p_mfem__BackwardEulerSolver, + &_swigt__p_mfem__CentralDifferenceSolver, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__ExplicitRKSolver, &_swigt__p_mfem__ForwardEulerSolver, + &_swigt__p_mfem__FoxGoodwinSolver, + &_swigt__p_mfem__GeneralizedAlpha2Solver, &_swigt__p_mfem__GeneralizedAlphaSolver, + &_swigt__p_mfem__HHTAlphaSolver, &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__ImplicitMidpointSolver, + &_swigt__p_mfem__LinearAccelerationSolver, + &_swigt__p_mfem__NewmarkSolver, &_swigt__p_mfem__ODESolver, &_swigt__p_mfem__Operator, &_swigt__p_mfem__ProductOperator, @@ -7134,6 +10690,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__RK4Solver, &_swigt__p_mfem__RK6Solver, &_swigt__p_mfem__RK8Solver, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__SDIRK23Solver, &_swigt__p_mfem__SDIRK33Solver, &_swigt__p_mfem__SDIRK34Solver, @@ -7141,32 +10698,57 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__SIA2Solver, &_swigt__p_mfem__SIASolver, &_swigt__p_mfem__SIAVSolver, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderODESolver, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, &_swigt__p_mfem__TripleProductOperator, &_swigt__p_mfem__Vector, + &_swigt__p_mfem__WBZAlphaSolver, }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB1Solver[] = { {&_swigt__p_mfem__AB1Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB2Solver[] = { {&_swigt__p_mfem__AB2Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB3Solver[] = { {&_swigt__p_mfem__AB3Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB4Solver[] = { {&_swigt__p_mfem__AB4Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AB5Solver[] = { {&_swigt__p_mfem__AB5Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM0Solver[] = { {&_swigt__p_mfem__AM0Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM1Solver[] = { {&_swigt__p_mfem__AM1Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM2Solver[] = { {&_swigt__p_mfem__AM2Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM3Solver[] = { {&_swigt__p_mfem__AM3Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AM4Solver[] = { {&_swigt__p_mfem__AM4Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AdamsBashforthSolver[] = { {&_swigt__p_mfem__AdamsBashforthSolver, 0, 0, 0}, {&_swigt__p_mfem__AB2Solver, _p_mfem__AB2SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB4Solver, _p_mfem__AB4SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB1Solver, _p_mfem__AB1SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB3Solver, _p_mfem__AB3SolverTo_p_mfem__AdamsBashforthSolver, 0, 0}, {&_swigt__p_mfem__AB5Solver, _p_mfem__AB5SolverTo_p_mfem__AdamsBashforthSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AdamsMoultonSolver[] = { {&_swigt__p_mfem__AdamsMoultonSolver, 0, 0, 0}, {&_swigt__p_mfem__AM0Solver, _p_mfem__AM0SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM2Solver, _p_mfem__AM2SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM4Solver, _p_mfem__AM4SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM1Solver, _p_mfem__AM1SolverTo_p_mfem__AdamsMoultonSolver, 0, 0}, {&_swigt__p_mfem__AM3Solver, _p_mfem__AM3SolverTo_p_mfem__AdamsMoultonSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AverageAccelerationSolver[] = { {&_swigt__p_mfem__AverageAccelerationSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BackwardEulerSolver[] = { {&_swigt__p_mfem__BackwardEulerSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__CentralDifferenceSolver[] = { {&_swigt__p_mfem__CentralDifferenceSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ExplicitRKSolver[] = { {&_swigt__p_mfem__RK6Solver, _p_mfem__RK6SolverTo_p_mfem__ExplicitRKSolver, 0, 0}, {&_swigt__p_mfem__RK8Solver, _p_mfem__RK8SolverTo_p_mfem__ExplicitRKSolver, 0, 0}, {&_swigt__p_mfem__ExplicitRKSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ForwardEulerSolver[] = { {&_swigt__p_mfem__ForwardEulerSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FoxGoodwinSolver[] = { {&_swigt__p_mfem__FoxGoodwinSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GeneralizedAlpha2Solver[] = { {&_swigt__p_mfem__GeneralizedAlpha2Solver, 0, 0, 0}, {&_swigt__p_mfem__AverageAccelerationSolver, _p_mfem__AverageAccelerationSolverTo_p_mfem__GeneralizedAlpha2Solver, 0, 0}, {&_swigt__p_mfem__HHTAlphaSolver, _p_mfem__HHTAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver, 0, 0}, {&_swigt__p_mfem__WBZAlphaSolver, _p_mfem__WBZAlphaSolverTo_p_mfem__GeneralizedAlpha2Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GeneralizedAlphaSolver[] = { {&_swigt__p_mfem__GeneralizedAlphaSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__HHTAlphaSolver[] = { {&_swigt__p_mfem__HHTAlphaSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ImplicitMidpointSolver[] = { {&_swigt__p_mfem__ImplicitMidpointSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ODESolver[] = { {&_swigt__p_mfem__ExplicitRKSolver, _p_mfem__ExplicitRKSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK23Solver, _p_mfem__SDIRK23SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK33Solver, _p_mfem__SDIRK33SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__GeneralizedAlphaSolver, _p_mfem__GeneralizedAlphaSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ODESolver, 0, 0, 0}, {&_swigt__p_mfem__ForwardEulerSolver, _p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK2Solver, _p_mfem__RK2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK3SSPSolver, _p_mfem__RK3SSPSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK4Solver, _p_mfem__RK4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__BackwardEulerSolver, _p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ImplicitMidpointSolver, _p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK34Solver, _p_mfem__SDIRK34SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK8Solver, _p_mfem__RK8SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK6Solver, _p_mfem__RK6SolverTo_p_mfem__ODESolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearAccelerationSolver[] = { {&_swigt__p_mfem__LinearAccelerationSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__NewmarkSolver[] = { {&_swigt__p_mfem__LinearAccelerationSolver, _p_mfem__LinearAccelerationSolverTo_p_mfem__NewmarkSolver, 0, 0}, {&_swigt__p_mfem__FoxGoodwinSolver, _p_mfem__FoxGoodwinSolverTo_p_mfem__NewmarkSolver, 0, 0}, {&_swigt__p_mfem__NewmarkSolver, 0, 0, 0}, {&_swigt__p_mfem__CentralDifferenceSolver, _p_mfem__CentralDifferenceSolverTo_p_mfem__NewmarkSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ODESolver[] = { {&_swigt__p_mfem__AB5Solver, _p_mfem__AB5SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AB3Solver, _p_mfem__AB3SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AB1Solver, _p_mfem__AB1SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ExplicitRKSolver, _p_mfem__ExplicitRKSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM1Solver, _p_mfem__AM1SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM3Solver, _p_mfem__AM3SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK23Solver, _p_mfem__SDIRK23SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK33Solver, _p_mfem__SDIRK33SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__GeneralizedAlphaSolver, _p_mfem__GeneralizedAlphaSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ODESolver, 0, 0, 0}, {&_swigt__p_mfem__AB2Solver, _p_mfem__AB2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AdamsBashforthSolver, _p_mfem__AdamsBashforthSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK8Solver, _p_mfem__RK8SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK6Solver, _p_mfem__RK6SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AB4Solver, _p_mfem__AB4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AdamsMoultonSolver, _p_mfem__AdamsMoultonSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM0Solver, _p_mfem__AM0SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM2Solver, _p_mfem__AM2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__AM4Solver, _p_mfem__AM4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK4Solver, _p_mfem__RK4SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK3SSPSolver, _p_mfem__RK3SSPSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__RK2Solver, _p_mfem__RK2SolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ForwardEulerSolver, _p_mfem__ForwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__BackwardEulerSolver, _p_mfem__BackwardEulerSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__ImplicitMidpointSolver, _p_mfem__ImplicitMidpointSolverTo_p_mfem__ODESolver, 0, 0}, {&_swigt__p_mfem__SDIRK34Solver, _p_mfem__SDIRK34SolverTo_p_mfem__ODESolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RK2Solver[] = { {&_swigt__p_mfem__RK2Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RK3SSPSolver[] = { {&_swigt__p_mfem__RK3SSPSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RK4Solver[] = { {&_swigt__p_mfem__RK4Solver, 0, 0, 0},{0, 0, 0, 0}}; @@ -7179,20 +10761,42 @@ static swig_cast_info _swigc__p_mfem__SIA1Solver[] = { {&_swigt__p_mfem__SIA1So static swig_cast_info _swigc__p_mfem__SIA2Solver[] = { {&_swigt__p_mfem__SIA2Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SIASolver[] = { {&_swigt__p_mfem__SIA2Solver, _p_mfem__SIA2SolverTo_p_mfem__SIASolver, 0, 0}, {&_swigt__p_mfem__SIAVSolver, _p_mfem__SIAVSolverTo_p_mfem__SIASolver, 0, 0}, {&_swigt__p_mfem__SIASolver, 0, 0, 0}, {&_swigt__p_mfem__SIA1Solver, _p_mfem__SIA1SolverTo_p_mfem__SIASolver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SIAVSolver[] = { {&_swigt__p_mfem__SIAVSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderODESolver[] = { {&_swigt__p_mfem__LinearAccelerationSolver, _p_mfem__LinearAccelerationSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__FoxGoodwinSolver, _p_mfem__FoxGoodwinSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__GeneralizedAlpha2Solver, _p_mfem__GeneralizedAlpha2SolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__AverageAccelerationSolver, _p_mfem__AverageAccelerationSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__SecondOrderODESolver, 0, 0, 0}, {&_swigt__p_mfem__HHTAlphaSolver, _p_mfem__HHTAlphaSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__WBZAlphaSolver, _p_mfem__WBZAlphaSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__NewmarkSolver, _p_mfem__NewmarkSolverTo_p_mfem__SecondOrderODESolver, 0, 0}, {&_swigt__p_mfem__CentralDifferenceSolver, _p_mfem__CentralDifferenceSolverTo_p_mfem__SecondOrderODESolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = { {&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__WBZAlphaSolver[] = { {&_swigt__p_mfem__WBZAlphaSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, _swigc__p_char, _swigc__p_double, + _swigc__p_mfem__AB1Solver, + _swigc__p_mfem__AB2Solver, + _swigc__p_mfem__AB3Solver, + _swigc__p_mfem__AB4Solver, + _swigc__p_mfem__AB5Solver, + _swigc__p_mfem__AM0Solver, + _swigc__p_mfem__AM1Solver, + _swigc__p_mfem__AM2Solver, + _swigc__p_mfem__AM3Solver, + _swigc__p_mfem__AM4Solver, + _swigc__p_mfem__AdamsBashforthSolver, + _swigc__p_mfem__AdamsMoultonSolver, + _swigc__p_mfem__AverageAccelerationSolver, _swigc__p_mfem__BackwardEulerSolver, + _swigc__p_mfem__CentralDifferenceSolver, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__ExplicitRKSolver, _swigc__p_mfem__ForwardEulerSolver, + _swigc__p_mfem__FoxGoodwinSolver, + _swigc__p_mfem__GeneralizedAlpha2Solver, _swigc__p_mfem__GeneralizedAlphaSolver, + _swigc__p_mfem__HHTAlphaSolver, _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__ImplicitMidpointSolver, + _swigc__p_mfem__LinearAccelerationSolver, + _swigc__p_mfem__NewmarkSolver, _swigc__p_mfem__ODESolver, _swigc__p_mfem__Operator, _swigc__p_mfem__ProductOperator, @@ -7204,6 +10808,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__RK4Solver, _swigc__p_mfem__RK6Solver, _swigc__p_mfem__RK8Solver, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__SDIRK23Solver, _swigc__p_mfem__SDIRK33Solver, _swigc__p_mfem__SDIRK34Solver, @@ -7211,11 +10816,15 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__SIA2Solver, _swigc__p_mfem__SIASolver, _swigc__p_mfem__SIAVSolver, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderODESolver, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, _swigc__p_mfem__TripleProductOperator, _swigc__p_mfem__Vector, + _swigc__p_mfem__WBZAlphaSolver, }; diff --git a/mfem/_ser/operators.py b/mfem/_ser/operators.py index 854ce776..3e04f9a9 100644 --- a/mfem/_ser/operators.py +++ b/mfem/_ser/operators.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _operators.SWIG_PyInstanceMethod_New +_swig_new_static_method = _operators.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -72,6 +75,11 @@ class Operator(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr + def InitTVectors(self, Po, Ri, Pi, x, b, X, B): + r"""InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)""" + return _operators.Operator_InitTVectors(self, Po, Ri, Pi, x, b, X, B) + InitTVectors = _swig_new_instance_method(_operators.Operator_InitTVectors) + def __init__(self, *args): r""" __init__(Operator self, int s=0) -> Operator @@ -86,50 +94,92 @@ def __init__(self, *args): def Height(self): r"""Height(Operator self) -> int""" return _operators.Operator_Height(self) + Height = _swig_new_instance_method(_operators.Operator_Height) def NumRows(self): r"""NumRows(Operator self) -> int""" return _operators.Operator_NumRows(self) + NumRows = _swig_new_instance_method(_operators.Operator_NumRows) def Width(self): r"""Width(Operator self) -> int""" return _operators.Operator_Width(self) + Width = _swig_new_instance_method(_operators.Operator_Width) def NumCols(self): r"""NumCols(Operator self) -> int""" return _operators.Operator_NumCols(self) + NumCols = _swig_new_instance_method(_operators.Operator_NumCols) def GetMemoryClass(self): r"""GetMemoryClass(Operator self) -> mfem::MemoryClass""" return _operators.Operator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.Operator_GetMemoryClass) def Mult(self, x, y): r"""Mult(Operator self, Vector x, Vector y)""" return _operators.Operator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.Operator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(Operator self, Vector x, Vector y)""" return _operators.Operator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.Operator_MultTranspose) def GetGradient(self, x): r"""GetGradient(Operator self, Vector x) -> Operator""" return _operators.Operator_GetGradient(self, x) + GetGradient = _swig_new_instance_method(_operators.Operator_GetGradient) def GetProlongation(self): r"""GetProlongation(Operator self) -> Operator""" return _operators.Operator_GetProlongation(self) + GetProlongation = _swig_new_instance_method(_operators.Operator_GetProlongation) def GetRestriction(self): r"""GetRestriction(Operator self) -> Operator""" return _operators.Operator_GetRestriction(self) + GetRestriction = _swig_new_instance_method(_operators.Operator_GetRestriction) + + def GetOutputProlongation(self): + r"""GetOutputProlongation(Operator self) -> Operator""" + return _operators.Operator_GetOutputProlongation(self) + GetOutputProlongation = _swig_new_instance_method(_operators.Operator_GetOutputProlongation) + + def GetOutputRestriction(self): + r"""GetOutputRestriction(Operator self) -> Operator""" + return _operators.Operator_GetOutputRestriction(self) + GetOutputRestriction = _swig_new_instance_method(_operators.Operator_GetOutputRestriction) def FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior=0): r"""FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)""" return _operators.Operator_FormLinearSystem(self, ess_tdof_list, x, b, A, X, B, copy_interior) + FormLinearSystem = _swig_new_instance_method(_operators.Operator_FormLinearSystem) + + def FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B): + r"""FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)""" + return _operators.Operator_FormRectangularLinearSystem(self, trial_tdof_list, test_tdof_list, x, b, A, X, B) + FormRectangularLinearSystem = _swig_new_instance_method(_operators.Operator_FormRectangularLinearSystem) def RecoverFEMSolution(self, X, b, x): r"""RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)""" return _operators.Operator_RecoverFEMSolution(self, X, b, x) + RecoverFEMSolution = _swig_new_instance_method(_operators.Operator_RecoverFEMSolution) + + def FormSystemOperator(self, ess_tdof_list, A): + r"""FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)""" + return _operators.Operator_FormSystemOperator(self, ess_tdof_list, A) + FormSystemOperator = _swig_new_instance_method(_operators.Operator_FormSystemOperator) + + def FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A): + r"""FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)""" + return _operators.Operator_FormRectangularSystemOperator(self, trial_tdof_list, test_tdof_list, A) + FormRectangularSystemOperator = _swig_new_instance_method(_operators.Operator_FormRectangularSystemOperator) + + def FormDiscreteOperator(self, A): + r"""FormDiscreteOperator(Operator self, mfem::Operator *& A)""" + return _operators.Operator_FormDiscreteOperator(self, A) + FormDiscreteOperator = _swig_new_instance_method(_operators.Operator_FormDiscreteOperator) __swig_destroy__ = _operators.delete_Operator ANY_TYPE = _operators.Operator_ANY_TYPE @@ -149,10 +199,17 @@ def RecoverFEMSolution(self, X, b, x): PETSC_MATGENERIC = _operators.Operator_PETSC_MATGENERIC + Complex_Operator = _operators.Operator_Complex_Operator + + MFEM_ComplexSparseMat = _operators.Operator_MFEM_ComplexSparseMat + + Complex_Hypre_ParCSR = _operators.Operator_Complex_Hypre_ParCSR + def GetType(self): r"""GetType(Operator self) -> mfem::Operator::Type""" return _operators.Operator_GetType(self) + GetType = _swig_new_instance_method(_operators.Operator_GetType) def PrintMatlab(self, *args): r""" @@ -160,6 +217,7 @@ def PrintMatlab(self, *args): PrintMatlab(Operator self, char const * file, int precision=8) """ return _operators.Operator_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_operators.Operator_PrintMatlab) def __disown__(self): self.this.disown() _operators.disown_Operator(self) @@ -179,6 +237,12 @@ class TimeDependentOperator(Operator): HOMOGENEOUS = _operators.TimeDependentOperator_HOMOGENEOUS + NORMAL = _operators.TimeDependentOperator_NORMAL + + ADDITIVE_TERM_1 = _operators.TimeDependentOperator_ADDITIVE_TERM_1 + + ADDITIVE_TERM_2 = _operators.TimeDependentOperator_ADDITIVE_TERM_2 + def __init__(self, *args): r""" @@ -194,46 +258,92 @@ def __init__(self, *args): def GetTime(self): r"""GetTime(TimeDependentOperator self) -> double""" return _operators.TimeDependentOperator_GetTime(self) + GetTime = _swig_new_instance_method(_operators.TimeDependentOperator_GetTime) def SetTime(self, _t): r"""SetTime(TimeDependentOperator self, double const _t)""" return _operators.TimeDependentOperator_SetTime(self, _t) + SetTime = _swig_new_instance_method(_operators.TimeDependentOperator_SetTime) def isExplicit(self): r"""isExplicit(TimeDependentOperator self) -> bool""" return _operators.TimeDependentOperator_isExplicit(self) + isExplicit = _swig_new_instance_method(_operators.TimeDependentOperator_isExplicit) def isImplicit(self): r"""isImplicit(TimeDependentOperator self) -> bool""" return _operators.TimeDependentOperator_isImplicit(self) + isImplicit = _swig_new_instance_method(_operators.TimeDependentOperator_isImplicit) def isHomogeneous(self): r"""isHomogeneous(TimeDependentOperator self) -> bool""" return _operators.TimeDependentOperator_isHomogeneous(self) + isHomogeneous = _swig_new_instance_method(_operators.TimeDependentOperator_isHomogeneous) + + def GetEvalMode(self): + r"""GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode""" + return _operators.TimeDependentOperator_GetEvalMode(self) + GetEvalMode = _swig_new_instance_method(_operators.TimeDependentOperator_GetEvalMode) + + def SetEvalMode(self, new_eval_mode): + r"""SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)""" + return _operators.TimeDependentOperator_SetEvalMode(self, new_eval_mode) + SetEvalMode = _swig_new_instance_method(_operators.TimeDependentOperator_SetEvalMode) def ExplicitMult(self, x, y): r"""ExplicitMult(TimeDependentOperator self, Vector x, Vector y)""" return _operators.TimeDependentOperator_ExplicitMult(self, x, y) + ExplicitMult = _swig_new_instance_method(_operators.TimeDependentOperator_ExplicitMult) def ImplicitMult(self, x, k, y): r"""ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)""" return _operators.TimeDependentOperator_ImplicitMult(self, x, k, y) + ImplicitMult = _swig_new_instance_method(_operators.TimeDependentOperator_ImplicitMult) def Mult(self, x, y): r"""Mult(TimeDependentOperator self, Vector x, Vector y)""" return _operators.TimeDependentOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.TimeDependentOperator_Mult) def ImplicitSolve(self, dt, x, k): r"""ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)""" return _operators.TimeDependentOperator_ImplicitSolve(self, dt, x, k) + ImplicitSolve = _swig_new_instance_method(_operators.TimeDependentOperator_ImplicitSolve) def GetImplicitGradient(self, x, k, shift): r"""GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator""" return _operators.TimeDependentOperator_GetImplicitGradient(self, x, k, shift) + GetImplicitGradient = _swig_new_instance_method(_operators.TimeDependentOperator_GetImplicitGradient) def GetExplicitGradient(self, x): r"""GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator""" return _operators.TimeDependentOperator_GetExplicitGradient(self, x) + GetExplicitGradient = _swig_new_instance_method(_operators.TimeDependentOperator_GetExplicitGradient) + + def SUNImplicitSetup(self, x, fx, jok, jcur, gamma): + r"""SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int""" + return _operators.TimeDependentOperator_SUNImplicitSetup(self, x, fx, jok, jcur, gamma) + SUNImplicitSetup = _swig_new_instance_method(_operators.TimeDependentOperator_SUNImplicitSetup) + + def SUNImplicitSolve(self, b, x, tol): + r"""SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int""" + return _operators.TimeDependentOperator_SUNImplicitSolve(self, b, x, tol) + SUNImplicitSolve = _swig_new_instance_method(_operators.TimeDependentOperator_SUNImplicitSolve) + + def SUNMassSetup(self): + r"""SUNMassSetup(TimeDependentOperator self) -> int""" + return _operators.TimeDependentOperator_SUNMassSetup(self) + SUNMassSetup = _swig_new_instance_method(_operators.TimeDependentOperator_SUNMassSetup) + + def SUNMassSolve(self, b, x, tol): + r"""SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int""" + return _operators.TimeDependentOperator_SUNMassSolve(self, b, x, tol) + SUNMassSolve = _swig_new_instance_method(_operators.TimeDependentOperator_SUNMassSolve) + + def SUNMassMult(self, x, v): + r"""SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int""" + return _operators.TimeDependentOperator_SUNMassMult(self, x, v) + SUNMassMult = _swig_new_instance_method(_operators.TimeDependentOperator_SUNMassMult) __swig_destroy__ = _operators.delete_TimeDependentOperator def __disown__(self): self.this.disown() @@ -243,6 +353,39 @@ def __disown__(self): # Register TimeDependentOperator in _operators: _operators.TimeDependentOperator_swigregister(TimeDependentOperator) +class SecondOrderTimeDependentOperator(TimeDependentOperator): + r"""Proxy of C++ mfem::SecondOrderTimeDependentOperator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(SecondOrderTimeDependentOperator self, int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator + __init__(SecondOrderTimeDependentOperator self, int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator + """ + _operators.SecondOrderTimeDependentOperator_swiginit(self, _operators.new_SecondOrderTimeDependentOperator(*args)) + + def Mult(self, *args): + r""" + Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y) + Mult(SecondOrderTimeDependentOperator self, Vector x, Vector dxdt, Vector y) + """ + return _operators.SecondOrderTimeDependentOperator_Mult(self, *args) + Mult = _swig_new_instance_method(_operators.SecondOrderTimeDependentOperator_Mult) + + def ImplicitSolve(self, *args): + r""" + ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt, Vector x, Vector k) + ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt0, double const dt1, Vector x, Vector dxdt, Vector k) + """ + return _operators.SecondOrderTimeDependentOperator_ImplicitSolve(self, *args) + ImplicitSolve = _swig_new_instance_method(_operators.SecondOrderTimeDependentOperator_ImplicitSolve) + __swig_destroy__ = _operators.delete_SecondOrderTimeDependentOperator + +# Register SecondOrderTimeDependentOperator in _operators: +_operators.SecondOrderTimeDependentOperator_swigregister(SecondOrderTimeDependentOperator) + class Solver(Operator): r"""Proxy of C++ mfem::Solver class.""" @@ -264,6 +407,7 @@ def __init__(self, *args): def SetOperator(self, op): r"""SetOperator(Solver self, Operator op)""" return _operators.Solver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_operators.Solver_SetOperator) __swig_destroy__ = _operators.delete_Solver def __disown__(self): self.this.disown() @@ -286,15 +430,41 @@ def __init__(self, n): def Mult(self, x, y): r"""Mult(IdentityOperator self, Vector x, Vector y)""" return _operators.IdentityOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.IdentityOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(IdentityOperator self, Vector x, Vector y)""" return _operators.IdentityOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.IdentityOperator_MultTranspose) __swig_destroy__ = _operators.delete_IdentityOperator # Register IdentityOperator in _operators: _operators.IdentityOperator_swigregister(IdentityOperator) + +def IsIdentityProlongation(P): + r"""IsIdentityProlongation(Operator P) -> bool""" + return _operators.IsIdentityProlongation(P) +IsIdentityProlongation = _operators.IsIdentityProlongation +class ScaledOperator(Operator): + r"""Proxy of C++ mfem::ScaledOperator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, A, a): + r"""__init__(ScaledOperator self, Operator A, double a) -> ScaledOperator""" + _operators.ScaledOperator_swiginit(self, _operators.new_ScaledOperator(A, a)) + + def Mult(self, x, y): + r"""Mult(ScaledOperator self, Vector x, Vector y)""" + return _operators.ScaledOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.ScaledOperator_Mult) + __swig_destroy__ = _operators.delete_ScaledOperator + +# Register ScaledOperator in _operators: +_operators.ScaledOperator_swigregister(ScaledOperator) + class TransposeOperator(Operator): r"""Proxy of C++ mfem::TransposeOperator class.""" @@ -311,10 +481,12 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(TransposeOperator self, Vector x, Vector y)""" return _operators.TransposeOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.TransposeOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(TransposeOperator self, Vector x, Vector y)""" return _operators.TransposeOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.TransposeOperator_MultTranspose) __swig_destroy__ = _operators.delete_TransposeOperator # Register TransposeOperator in _operators: @@ -333,10 +505,12 @@ def __init__(self, A, B, ownA, ownB): def Mult(self, x, y): r"""Mult(ProductOperator self, Vector x, Vector y)""" return _operators.ProductOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.ProductOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(ProductOperator self, Vector x, Vector y)""" return _operators.ProductOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.ProductOperator_MultTranspose) __swig_destroy__ = _operators.delete_ProductOperator # Register ProductOperator in _operators: @@ -355,14 +529,17 @@ def __init__(self, Rt_, A_, P_): def GetMemoryClass(self): r"""GetMemoryClass(RAPOperator self) -> mfem::MemoryClass""" return _operators.RAPOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.RAPOperator_GetMemoryClass) def Mult(self, x, y): r"""Mult(RAPOperator self, Vector x, Vector y)""" return _operators.RAPOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.RAPOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(RAPOperator self, Vector x, Vector y)""" return _operators.RAPOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.RAPOperator_MultTranspose) __swig_destroy__ = _operators.delete_RAPOperator # Register RAPOperator in _operators: @@ -381,14 +558,17 @@ def __init__(self, A, B, C, ownA, ownB, ownC): def GetMemoryClass(self): r"""GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass""" return _operators.TripleProductOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.TripleProductOperator_GetMemoryClass) def Mult(self, x, y): r"""Mult(TripleProductOperator self, Vector x, Vector y)""" return _operators.TripleProductOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.TripleProductOperator_Mult) def MultTranspose(self, x, y): r"""MultTranspose(TripleProductOperator self, Vector x, Vector y)""" return _operators.TripleProductOperator_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_operators.TripleProductOperator_MultTranspose) __swig_destroy__ = _operators.delete_TripleProductOperator # Register TripleProductOperator in _operators: @@ -407,19 +587,51 @@ def __init__(self, A, list, own_A=False): def GetMemoryClass(self): r"""GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass""" return _operators.ConstrainedOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.ConstrainedOperator_GetMemoryClass) def EliminateRHS(self, x, b): r"""EliminateRHS(ConstrainedOperator self, Vector x, Vector b)""" return _operators.ConstrainedOperator_EliminateRHS(self, x, b) + EliminateRHS = _swig_new_instance_method(_operators.ConstrainedOperator_EliminateRHS) def Mult(self, x, y): r"""Mult(ConstrainedOperator self, Vector x, Vector y)""" return _operators.ConstrainedOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.ConstrainedOperator_Mult) __swig_destroy__ = _operators.delete_ConstrainedOperator # Register ConstrainedOperator in _operators: _operators.ConstrainedOperator_swigregister(ConstrainedOperator) +class RectangularConstrainedOperator(Operator): + r"""Proxy of C++ mfem::RectangularConstrainedOperator class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, A, trial_list, test_list, own_A=False): + r"""__init__(RectangularConstrainedOperator self, Operator A, intArray trial_list, intArray test_list, bool own_A=False) -> RectangularConstrainedOperator""" + _operators.RectangularConstrainedOperator_swiginit(self, _operators.new_RectangularConstrainedOperator(A, trial_list, test_list, own_A)) + + def GetMemoryClass(self): + r"""GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass""" + return _operators.RectangularConstrainedOperator_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_operators.RectangularConstrainedOperator_GetMemoryClass) + + def EliminateRHS(self, x, b): + r"""EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)""" + return _operators.RectangularConstrainedOperator_EliminateRHS(self, x, b) + EliminateRHS = _swig_new_instance_method(_operators.RectangularConstrainedOperator_EliminateRHS) + + def Mult(self, x, y): + r"""Mult(RectangularConstrainedOperator self, Vector x, Vector y)""" + return _operators.RectangularConstrainedOperator_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.RectangularConstrainedOperator_Mult) + __swig_destroy__ = _operators.delete_RectangularConstrainedOperator + +# Register RectangularConstrainedOperator in _operators: +_operators.RectangularConstrainedOperator_swigregister(RectangularConstrainedOperator) + class PyOperatorBase(Operator): r"""Proxy of C++ mfem::PyOperatorBase class.""" @@ -440,10 +652,12 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(PyOperatorBase self, Vector x, Vector y)""" return _operators.PyOperatorBase_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.PyOperatorBase_Mult) def _EvalMult(self, arg0): r"""_EvalMult(PyOperatorBase self, Vector arg0) -> Vector""" return _operators.PyOperatorBase__EvalMult(self, arg0) + _EvalMult = _swig_new_instance_method(_operators.PyOperatorBase__EvalMult) __swig_destroy__ = _operators.delete_PyOperatorBase def __disown__(self): self.this.disown() @@ -473,10 +687,12 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)""" return _operators.PyTimeDependentOperatorBase_Mult(self, x, y) + Mult = _swig_new_instance_method(_operators.PyTimeDependentOperatorBase_Mult) def _EvalMult(self, arg0): r"""_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector""" return _operators.PyTimeDependentOperatorBase__EvalMult(self, arg0) + _EvalMult = _swig_new_instance_method(_operators.PyTimeDependentOperatorBase__EvalMult) __swig_destroy__ = _operators.delete_PyTimeDependentOperatorBase def __disown__(self): self.this.disown() diff --git a/mfem/_ser/operators_wrap.cxx b/mfem/_ser/operators_wrap.cxx index b8bfc601..33b3b5f1 100644 --- a/mfem/_ser/operators_wrap.cxx +++ b/mfem/_ser/operators_wrap.cxx @@ -3067,32 +3067,39 @@ namespace Swig { #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] #define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[2] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[3] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[4] -#define SWIGTYPE_p_mfem__Operator swig_types[5] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[6] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[7] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[8] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[9] -#define SWIGTYPE_p_mfem__Solver swig_types[10] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[11] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[12] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[13] -#define SWIGTYPE_p_mfem__Vector swig_types[14] -#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[15] -#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[16] -#define SWIGTYPE_p_p_mfem__Operator swig_types[17] -#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[18] -#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[19] -#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[20] -#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[21] -#define SWIGTYPE_p_p_mfem__Solver swig_types[22] -#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[23] -#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[24] -#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[25] -static swig_type_info *swig_types[27]; -static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0}; +#define SWIGTYPE_p_int swig_types[2] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[3] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[4] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[5] +#define SWIGTYPE_p_mfem__Operator swig_types[6] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[7] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[8] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[9] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[10] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[11] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[12] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[13] +#define SWIGTYPE_p_mfem__Solver swig_types[14] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[15] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[16] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[17] +#define SWIGTYPE_p_mfem__Vector swig_types[18] +#define SWIGTYPE_p_p_mfem__ConstrainedOperator swig_types[19] +#define SWIGTYPE_p_p_mfem__IdentityOperator swig_types[20] +#define SWIGTYPE_p_p_mfem__Operator swig_types[21] +#define SWIGTYPE_p_p_mfem__ProductOperator swig_types[22] +#define SWIGTYPE_p_p_mfem__PyOperatorBase swig_types[23] +#define SWIGTYPE_p_p_mfem__PyTimeDependentOperatorBase swig_types[24] +#define SWIGTYPE_p_p_mfem__RAPOperator swig_types[25] +#define SWIGTYPE_p_p_mfem__RectangularConstrainedOperator swig_types[26] +#define SWIGTYPE_p_p_mfem__ScaledOperator swig_types[27] +#define SWIGTYPE_p_p_mfem__SecondOrderTimeDependentOperator swig_types[28] +#define SWIGTYPE_p_p_mfem__Solver swig_types[29] +#define SWIGTYPE_p_p_mfem__TimeDependentOperator swig_types[30] +#define SWIGTYPE_p_p_mfem__TransposeOperator swig_types[31] +#define SWIGTYPE_p_p_mfem__TripleProductOperator swig_types[32] +static swig_type_info *swig_types[34]; +static swig_module_info swig_module = {swig_types, 33, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3757,6 +3764,80 @@ mfem::Operator const *SwigDirector_Operator::GetRestriction() const { } +mfem::Operator const *SwigDirector_Operator::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Operator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_Operator::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Operator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_Operator::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -3768,7 +3849,7 @@ void SwigDirector_Operator::RecoverFEMSolution(mfem::Vector const &X, mfem::Vect Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Operator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4009,6 +4090,80 @@ mfem::Operator const *SwigDirector_TimeDependentOperator::GetRestriction() const } +mfem::Operator const *SwigDirector_TimeDependentOperator::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_TimeDependentOperator::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_TimeDependentOperator::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -4020,7 +4175,7 @@ void SwigDirector_TimeDependentOperator::RecoverFEMSolution(mfem::Vector const & Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4049,7 +4204,7 @@ double SwigDirector_TimeDependentOperator::GetTime() const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "GetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject args = PyTuple_New(0); @@ -4083,7 +4238,7 @@ void SwigDirector_TimeDependentOperator::SetTime(double const _t) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 10; const char *const swig_method_name = "SetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4102,6 +4257,32 @@ void SwigDirector_TimeDependentOperator::SetTime(double const _t) { } +void SwigDirector_TimeDependentOperator::SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_From_int(static_cast< int >(new_eval_mode)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 11; + const char *const swig_method_name = "SetEvalMode"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SetEvalMode"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + void SwigDirector_TimeDependentOperator::ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); @@ -4111,7 +4292,7 @@ void SwigDirector_TimeDependentOperator::ExplicitMult(mfem::Vector const &x, mfe Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 12; const char *const swig_method_name = "ExplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -4141,7 +4322,7 @@ void SwigDirector_TimeDependentOperator::ImplicitMult(mfem::Vector const &x, mfe Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 13; const char *const swig_method_name = "ImplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4171,7 +4352,7 @@ void SwigDirector_TimeDependentOperator::ImplicitSolve(double const dt, mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 11; + const size_t swig_method_index = 14; const char *const swig_method_name = "ImplicitSolve"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4206,7 +4387,7 @@ mfem::Operator &SwigDirector_TimeDependentOperator::GetImplicitGradient(mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 12; + const size_t swig_method_index = 15; const char *const swig_method_name = "GetImplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4247,7 +4428,7 @@ mfem::Operator &SwigDirector_TimeDependentOperator::GetExplicitGradient(mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 13; + const size_t swig_method_index = 16; const char *const swig_method_name = "GetExplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4276,35 +4457,30 @@ mfem::Operator &SwigDirector_TimeDependentOperator::GetExplicitGradient(mfem::Ve } -SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int s, bool iter_mode): mfem::Solver(s, iter_mode), Swig::Director(self) { - SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); -} - - - - -SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int h, int w, bool iter_mode): mfem::Solver(h, w, iter_mode), Swig::Director(self) { - SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); -} - - - - -mfem::MemoryClass SwigDirector_Solver::GetMemoryClass() const { - mfem::MemoryClass c_result = SwigValueInit< mfem::MemoryClass >() ; +int SwigDirector_TimeDependentOperator::SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma) { + int c_result = SwigValueInit< int >() ; + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&fx), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_int(static_cast< int >(jok)); + swig::SwigVar_PyObject obj3; + obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(jcur), SWIGTYPE_p_int, 0 ); + swig::SwigVar_PyObject obj4; + obj4 = SWIG_From_double(static_cast< double >(gamma)); if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 0; - const char *const swig_method_name = "GetMemoryClass"; + const size_t swig_method_index = 17; + const char *const swig_method_name = "SUNImplicitSetup"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject args = PyTuple_New(0); - swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetMemoryClass"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4317,29 +4493,33 @@ mfem::MemoryClass SwigDirector_Solver::GetMemoryClass() const { int swig_val; int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) { - Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::MemoryClass""'"); + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); } - c_result = static_cast< mfem::MemoryClass >(swig_val); - return (mfem::MemoryClass) c_result; + c_result = static_cast< int >(swig_val); + return (int) c_result; } -void SwigDirector_Solver::Mult(mfem::Vector const &x, mfem::Vector &y) const { +int SwigDirector_TimeDependentOperator::SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; + swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); swig::SwigVar_PyObject obj1; - obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 1; - const char *const swig_method_name = "Mult"; + const size_t swig_method_index = 18; + const char *const swig_method_name = "SUNImplicitSolve"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("Mult"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4349,25 +4529,31 @@ void SwigDirector_Solver::Mult(mfem::Vector const &x, mfem::Vector &y) const { } } } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; } -void SwigDirector_Solver::MultTranspose(mfem::Vector const &x, mfem::Vector &y) const { - swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); - swig::SwigVar_PyObject obj1; - obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); +int SwigDirector_TimeDependentOperator::SUNMassSetup() { + int c_result = SwigValueInit< int >() ; + if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 2; - const char *const swig_method_name = "MultTranspose"; + const size_t swig_method_index = 19; + const char *const swig_method_name = "SUNMassSetup"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("MultTranspose"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4377,22 +4563,209 @@ void SwigDirector_Solver::MultTranspose(mfem::Vector const &x, mfem::Vector &y) } } } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; } -mfem::Operator &SwigDirector_Solver::GetGradient(mfem::Vector const &x) const { - mfem::Operator *c_result = 0 ; - void *swig_argp ; - int swig_res ; - swig_owntype own ; +int SwigDirector_TimeDependentOperator::SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); if (!swig_get_self()) { - Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 3; + const size_t swig_method_index = 20; + const char *const swig_method_name = "SUNMassSolve"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_TimeDependentOperator::SUNMassMult(mfem::Vector const &x, mfem::Vector &v) { + int c_result = SwigValueInit< int >() ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&v), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call TimeDependentOperator.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 21; + const char *const swig_method_name = "SUNMassMult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassMult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int s, bool iter_mode): mfem::Solver(s, iter_mode), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); +} + + + + +SwigDirector_Solver::SwigDirector_Solver(PyObject *self, int h, int w, bool iter_mode): mfem::Solver(h, w, iter_mode), Swig::Director(self) { + SWIG_DIRECTOR_RGTR((mfem::Solver *)this, this); +} + + + + +mfem::MemoryClass SwigDirector_Solver::GetMemoryClass() const { + mfem::MemoryClass c_result = SwigValueInit< mfem::MemoryClass >() ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 0; + const char *const swig_method_name = "GetMemoryClass"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetMemoryClass"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::MemoryClass""'"); + } + c_result = static_cast< mfem::MemoryClass >(swig_val); + return (mfem::MemoryClass) c_result; +} + + +void SwigDirector_Solver::Mult(mfem::Vector const &x, mfem::Vector &y) const { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 1; + const char *const swig_method_name = "Mult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("Mult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +void SwigDirector_Solver::MultTranspose(mfem::Vector const &x, mfem::Vector &y) const { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&y), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 2; + const char *const swig_method_name = "MultTranspose"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("MultTranspose"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + +mfem::Operator &SwigDirector_Solver::GetGradient(mfem::Vector const &x) const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 3; const char *const swig_method_name = "GetGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4495,6 +4868,80 @@ mfem::Operator const *SwigDirector_Solver::GetRestriction() const { } +mfem::Operator const *SwigDirector_Solver::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_Solver::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_Solver::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -4506,7 +4953,7 @@ void SwigDirector_Solver::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4535,7 +4982,7 @@ void SwigDirector_Solver::SetOperator(mfem::Operator const &op) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call Solver.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "SetOperator"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4773,24 +5220,98 @@ mfem::Operator const *SwigDirector_PyOperatorBase::GetRestriction() const { } -void SwigDirector_PyOperatorBase::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { - swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); - swig::SwigVar_PyObject obj1; - obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); - swig::SwigVar_PyObject obj2; - obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); +mfem::Operator const *SwigDirector_PyOperatorBase::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + if (!swig_get_self()) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) const size_t swig_method_index = 6; - const char *const swig_method_name = "RecoverFEMSolution"; + const char *const swig_method_name = "GetOutputProlongation"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("RecoverFEMSolution"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_PyOperatorBase::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +void SwigDirector_PyOperatorBase::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 8; + const char *const swig_method_name = "RecoverFEMSolution"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("RecoverFEMSolution"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -4818,7 +5339,7 @@ mfem::Vector &SwigDirector_PyOperatorBase::_EvalMult(mfem::Vector const &arg0) c Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "_EvalMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -5066,6 +5587,80 @@ mfem::Operator const *SwigDirector_PyTimeDependentOperatorBase::GetRestriction() } +mfem::Operator const *SwigDirector_PyTimeDependentOperatorBase::GetOutputProlongation() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 6; + const char *const swig_method_name = "GetOutputProlongation"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputProlongation"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + +mfem::Operator const *SwigDirector_PyTimeDependentOperatorBase::GetOutputRestriction() const { + mfem::Operator *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 7; + const char *const swig_method_name = "GetOutputRestriction"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("GetOutputRestriction"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Operator, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Operator const *""'"); + } + c_result = reinterpret_cast< mfem::Operator * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Operator const *) c_result; +} + + void SwigDirector_PyTimeDependentOperatorBase::RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x) { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&X), SWIGTYPE_p_mfem__Vector, 0 ); @@ -5077,7 +5672,7 @@ void SwigDirector_PyTimeDependentOperatorBase::RecoverFEMSolution(mfem::Vector c Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 6; + const size_t swig_method_index = 8; const char *const swig_method_name = "RecoverFEMSolution"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5106,7 +5701,7 @@ double SwigDirector_PyTimeDependentOperatorBase::GetTime() const { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 7; + const size_t swig_method_index = 9; const char *const swig_method_name = "GetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject args = PyTuple_New(0); @@ -5140,7 +5735,7 @@ void SwigDirector_PyTimeDependentOperatorBase::SetTime(double const _t) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 8; + const size_t swig_method_index = 10; const char *const swig_method_name = "SetTime"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -5159,6 +5754,32 @@ void SwigDirector_PyTimeDependentOperatorBase::SetTime(double const _t) { } +void SwigDirector_PyTimeDependentOperatorBase::SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode) { + swig::SwigVar_PyObject obj0; + obj0 = SWIG_From_int(static_cast< int >(new_eval_mode)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 11; + const char *const swig_method_name = "SetEvalMode"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SetEvalMode"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } +} + + void SwigDirector_PyTimeDependentOperatorBase::ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const { swig::SwigVar_PyObject obj0; obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); @@ -5168,7 +5789,7 @@ void SwigDirector_PyTimeDependentOperatorBase::ExplicitMult(mfem::Vector const & Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 9; + const size_t swig_method_index = 12; const char *const swig_method_name = "ExplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -5198,7 +5819,7 @@ void SwigDirector_PyTimeDependentOperatorBase::ImplicitMult(mfem::Vector const & Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 10; + const size_t swig_method_index = 13; const char *const swig_method_name = "ImplicitMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5228,7 +5849,7 @@ void SwigDirector_PyTimeDependentOperatorBase::ImplicitSolve(double const dt, mf Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 11; + const size_t swig_method_index = 14; const char *const swig_method_name = "ImplicitSolve"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5263,7 +5884,7 @@ mfem::Operator &SwigDirector_PyTimeDependentOperatorBase::GetImplicitGradient(mf Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 12; + const size_t swig_method_index = 15; const char *const swig_method_name = "GetImplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -5304,7 +5925,7 @@ mfem::Operator &SwigDirector_PyTimeDependentOperatorBase::GetExplicitGradient(mf Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 13; + const size_t swig_method_index = 16; const char *const swig_method_name = "GetExplicitGradient"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -5333,25 +5954,30 @@ mfem::Operator &SwigDirector_PyTimeDependentOperatorBase::GetExplicitGradient(mf } -mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector const &arg0) const { - mfem::Vector *c_result = 0 ; - void *swig_argp ; - int swig_res ; - swig_owntype own ; +int SwigDirector_PyTimeDependentOperatorBase::SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma) { + int c_result = SwigValueInit< int >() ; swig::SwigVar_PyObject obj0; - obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_mfem__Vector, 0 ); + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&fx), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_int(static_cast< int >(jok)); + swig::SwigVar_PyObject obj3; + obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(jcur), SWIGTYPE_p_int, 0 ); + swig::SwigVar_PyObject obj4; + obj4 = SWIG_From_double(static_cast< double >(gamma)); if (!swig_get_self()) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 14; - const char *const swig_method_name = "_EvalMult"; + const size_t swig_method_index = 17; + const char *const swig_method_name = "SUNImplicitSetup"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); - swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #else - swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("_EvalMult"); - swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4, NULL); #endif if (!result) { PyObject *error = PyErr_Occurred(); @@ -5361,61 +5987,355 @@ mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector c } } } - swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Vector, 0 | SWIG_POINTER_DISOWN, &own); + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); if (!SWIG_IsOK(swig_res)) { - Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Vector &""'"); - } - if (!swig_argp) { - Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ValueError), "invalid null reference " "in output value of type '""mfem::Vector &""'"); + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); } - c_result = reinterpret_cast< mfem::Vector * >(swig_argp); - swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); - return (mfem::Vector &) *c_result; + c_result = static_cast< int >(swig_val); + return (int) c_result; } -#ifdef __cplusplus -extern "C" { -#endif -SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::Operator *result = 0 ; +int SwigDirector_PyTimeDependentOperatorBase::SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Operator *)new SwigDirector_Operator(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 18; + const char *const swig_method_name = "SUNImplicitSolve"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNImplicitSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_PyTimeDependentOperatorBase::SUNMassSetup() { + int c_result = SwigValueInit< int >() ; + + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 19; + const char *const swig_method_name = "SUNMassSetup"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject args = PyTuple_New(0); + swig::SwigVar_PyObject result = PyObject_Call(method, (PyObject *) args, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSetup"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_PyTimeDependentOperatorBase::SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol) { + int c_result = SwigValueInit< int >() ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&b), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj2; + obj2 = SWIG_From_double(static_cast< double >(tol)); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 20; + const char *const swig_method_name = "SUNMassSolve"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassSolve"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +int SwigDirector_PyTimeDependentOperatorBase::SUNMassMult(mfem::Vector const &x, mfem::Vector &v) { + int c_result = SwigValueInit< int >() ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&x), SWIGTYPE_p_mfem__Vector, 0 ); + swig::SwigVar_PyObject obj1; + obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(&v), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 21; + const char *const swig_method_name = "SUNMassMult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("SUNMassMult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0,(PyObject *)obj1, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + int swig_val; + int swig_res = SWIG_AsVal_int(result, &swig_val); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""int""'"); + } + c_result = static_cast< int >(swig_val); + return (int) c_result; +} + + +mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector const &arg0) const { + mfem::Vector *c_result = 0 ; + void *swig_argp ; + int swig_res ; + swig_owntype own ; + + swig::SwigVar_PyObject obj0; + obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&arg0), SWIGTYPE_p_mfem__Vector, 0 ); + if (!swig_get_self()) { + Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call PyTimeDependentOperatorBase.__init__."); + } +#if defined(SWIG_PYTHON_DIRECTOR_VTABLE) + const size_t swig_method_index = 22; + const char *const swig_method_name = "_EvalMult"; + PyObject *method = swig_get_method(swig_method_index, swig_method_name); + swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); +#else + swig::SwigVar_PyObject swig_method_name = SWIG_Python_str_FromChar("_EvalMult"); + swig::SwigVar_PyObject result = PyObject_CallMethodObjArgs(swig_get_self(), (PyObject *) swig_method_name ,(PyObject *)obj0, NULL); +#endif + if (!result) { + PyObject *error = PyErr_Occurred(); + { + if (error != NULL) { + throw Swig::DirectorMethodException(); + } + } + } + swig_res = SWIG_ConvertPtrAndOwn(result, &swig_argp, SWIGTYPE_p_mfem__Vector, 0 | SWIG_POINTER_DISOWN, &own); + if (!SWIG_IsOK(swig_res)) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""mfem::Vector &""'"); + } + if (!swig_argp) { + Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ValueError), "invalid null reference " "in output value of type '""mfem::Vector &""'"); + } + c_result = reinterpret_cast< mfem::Vector * >(swig_argp); + swig_acquire_ownership_obj(SWIG_as_voidptr(c_result), own /* & TODO: SWIG_POINTER_OWN */); + return (mfem::Vector &) *c_result; +} + + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Operator *arg2 = (mfem::Operator *) 0 ; + mfem::Operator *arg3 = (mfem::Operator *) 0 ; + mfem::Operator *arg4 = (mfem::Operator *) 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_InitTVectors", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_InitTVectors" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); + } + arg3 = reinterpret_cast< mfem::Operator * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); + } + arg4 = reinterpret_cast< mfem::Operator * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + ((mfem::Operator const *)arg1)->InitTVectors((mfem::Operator const *)arg2,(mfem::Operator const *)arg3,(mfem::Operator const *)arg4,*arg5,*arg6,*arg7,*arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + PyObject *arg1 = (PyObject *) 0 ; + int arg2 ; + mfem::Operator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + arg1 = swig_obj[0]; + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + if ( arg1 != Py_None ) { + /* subclassed */ + result = (mfem::Operator *)new SwigDirector_Operator(arg1,arg2); + } else { + SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); + SWIG_fail; + } + + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NEW | 0 ); return resultobj; @@ -6147,13 +7067,137 @@ SWIGINTERN PyObject *_wrap_Operator_GetRestriction(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_GetOutputProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Operator **arg5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_GetOutputProlongation" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->mfem::Operator::GetOutputProlongation(); + } else { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->GetOutputProlongation(); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + director = SWIG_DIRECTOR_CAST(result); + if (director) { + resultobj = director->swig_get_self(); + Py_INCREF(resultobj); + } else { + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + } + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_GetOutputRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_GetOutputRestriction" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->mfem::Operator::GetOutputRestriction(); + } else { + result = (mfem::Operator *)((mfem::Operator const *)arg1)->GetOutputRestriction(); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + director = SWIG_DIRECTOR_CAST(result); + if (director) { + resultobj = director->swig_get_self(); + Py_INCREF(resultobj); + } else { + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + } + if (director) { + SWIG_AcquirePtr(resultobj, director->swig_release_ownership(SWIG_as_voidptr(result))); + } + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Operator **arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; int arg8 ; @@ -6466,6 +7510,122 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem(PyObject *self, PyObject *a } +SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Operator **arg6 = 0 ; + mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject *swig_obj[8] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); + } + arg6 = reinterpret_cast< mfem::Operator ** >(argp6); + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); + { + try { + (arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; @@ -6550,53 +7710,44 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Operator **arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "Operator_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); } + arg3 = reinterpret_cast< mfem::Operator ** >(argp3); { try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); + (arg1)->FormSystemOperator((mfem::Array< int > const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6614,16 +7765,208 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Operator **arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); + } + arg4 = reinterpret_cast< mfem::Operator ** >(argp4); + { + try { + (arg1)->FormRectangularSystemOperator((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Operator **arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Operator_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); + } + arg2 = reinterpret_cast< mfem::Operator ** >(argp2); + { + try { + (arg1)->FormDiscreteOperator(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + std::ostream *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); } } return NULL; @@ -7956,52 +9299,79 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_isHomogeneous(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - Swig::Director *director = 0; - bool upcall = false; + PyObject *swig_obj[1] ; + mfem::TimeDependentOperator::EvalMode result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ExplicitMult", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_GetEvalMode" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + try { + result = (mfem::TimeDependentOperator::EvalMode)((mfem::TimeDependentOperator const *)arg1)->GetEvalMode(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::TimeDependentOperator::EvalMode arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SetEvalMode", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "2"" of type '" "mfem::TimeDependentOperator::EvalMode""'"); + } + arg2 = static_cast< mfem::TimeDependentOperator::EvalMode >(val2); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - ((mfem::TimeDependentOperator const *)arg1)->mfem::TimeDependentOperator::ExplicitMult((mfem::Vector const &)*arg2,*arg3); + (arg1)->mfem::TimeDependentOperator::SetEvalMode(arg2); } else { - ((mfem::TimeDependentOperator const *)arg1)->ExplicitMult((mfem::Vector const &)*arg2,*arg3); + (arg1)->SetEvalMode(arg2); } } #ifdef MFEM_USE_EXCEPTIONS @@ -8029,33 +9399,106 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[3] ; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ImplicitMult", 4, 4, swig_obj)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ExplicitMult", 3, 3, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + ((mfem::TimeDependentOperator const *)arg1)->mfem::TimeDependentOperator::ExplicitMult((mfem::Vector const &)*arg2,*arg3); + } else { + ((mfem::TimeDependentOperator const *)arg1)->ExplicitMult((mfem::Vector const &)*arg2,*arg3); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + Swig::Director *director = 0; + bool upcall = false; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ImplicitMult", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); @@ -8430,100 +9873,1463 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S } -SWIGINTERN PyObject *_wrap_delete_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int *arg5 = (int *) 0 ; + double arg6 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + Swig::Director *director = 0; + bool upcall = false; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSetup", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - try { - delete arg1; - } + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "5"" of type '" "int *""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNImplicitSetup((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,arg4,arg5,arg6); + } else { + result = (int)(arg1)->SUNImplicitSetup((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,arg4,arg5,arg6); + } + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } #endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + Swig::Director *director = 0; + bool upcall = false; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSolve", 4, 4, swig_obj)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - { - Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); - if (director) director->swig_disown(); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - - resultobj = SWIG_Py_Void(); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNImplicitSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } else { + result = (int)(arg1)->SUNImplicitSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_Solver_iterative_mode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Solver *arg1 = (mfem::Solver *) 0 ; - bool arg2 ; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; + Swig::Director *director = 0; + bool upcall = false; + int result; - if (!SWIG_Python_UnpackTuple(args, "Solver_iterative_mode_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_set" "', argument " "1"" of type '" "mfem::Solver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassSetup" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } - arg1 = reinterpret_cast< mfem::Solver * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNMassSetup(); + } else { + result = (int)(arg1)->SUNMassSetup(); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + Swig::Director *director = 0; + bool upcall = false; + int result; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassSolve", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNMassSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } else { + result = (int)(arg1)->SUNMassSolve((mfem::Vector const &)*arg2,*arg3,arg4); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + Swig::Director *director = 0; + bool upcall = false; + int result; + + if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassMult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + director = SWIG_DIRECTOR_CAST(arg1); + upcall = (director && (director->swig_get_self()==swig_obj[0])); + try { + { + try { + if (upcall) { + result = (int)(arg1)->mfem::TimeDependentOperator::SUNMassMult((mfem::Vector const &)*arg2,*arg3); + } else { + result = (int)(arg1)->SUNMassMult((mfem::Vector const &)*arg2,*arg3); + } + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + } catch (Swig::DirectorException&) { + SWIG_fail; + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); + { + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); + } + + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + mfem::TimeDependentOperator::Type arg3 ; + double val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg3 = static_cast< mfem::TimeDependentOperator::Type >(val3); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + double arg2 ; + double val2 ; + int ecode2 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + double arg3 ; + mfem::TimeDependentOperator::Type arg4 ; + double val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + double arg3 ; + double val3 ; + int ecode3 = 0 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + mfem::SecondOrderTimeDependentOperator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_SecondOrderTimeDependentOperator", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_3(self, argc, argv); + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_2(self, argc, argv); + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_6(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_5(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_4(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SecondOrderTimeDependentOperator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double,mfem::TimeDependentOperator::Type)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator()\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double)\n" + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_Mult__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::SecondOrderTimeDependentOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_Mult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_Mult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + ((mfem::SecondOrderTimeDependentOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_Mult(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SecondOrderTimeDependentOperator_Mult", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_Mult__SWIG_0_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_Mult__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SecondOrderTimeDependentOperator_Mult'.\n" + " Possible C/C++ prototypes are:\n" + " Mult(mfem::Vector const &,mfem::Vector &) const\n" + " mfem::SecondOrderTimeDependentOperator::Mult(mfem::Vector const &,mfem::Vector const &,mfem::Vector &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + double arg2 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + (arg1)->ImplicitSolve(arg2,(mfem::Vector const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + double arg2 ; + double arg3 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + double val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderTimeDependentOperator_ImplicitSolve" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + { + try { + (arg1)->ImplicitSolve(arg2,arg3,(mfem::Vector const &)*arg4,(mfem::Vector const &)*arg5,*arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SecondOrderTimeDependentOperator_ImplicitSolve(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SecondOrderTimeDependentOperator_ImplicitSolve", 0, 6, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_0_0(self, argc, argv); + } + } + } + } + } + if (argc == 6) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SecondOrderTimeDependentOperator_ImplicitSolve__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SecondOrderTimeDependentOperator_ImplicitSolve'.\n" + " Possible C/C++ prototypes are:\n" + " ImplicitSolve(double const,mfem::Vector const &,mfem::Vector &)\n" + " mfem::SecondOrderTimeDependentOperator::ImplicitSolve(double const,double const,mfem::Vector const &,mfem::Vector const &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_SecondOrderTimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SecondOrderTimeDependentOperator *arg1 = (mfem::SecondOrderTimeDependentOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SecondOrderTimeDependentOperator" "', argument " "1"" of type '" "mfem::SecondOrderTimeDependentOperator *""'"); + } + arg1 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *SecondOrderTimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SecondOrderTimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_Solver_iterative_mode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Solver *arg1 = (mfem::Solver *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Solver_iterative_mode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_set" "', argument " "1"" of type '" "mfem::Solver *""'"); + } + arg1 = reinterpret_cast< mfem::Solver * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Solver_iterative_mode_set" "', argument " "2"" of type '" "bool""'"); } @@ -9185,9 +11991,210 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "IdentityOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityOperator_MultTranspose" "', argument " "1"" of type '" "mfem::IdentityOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::IdentityOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentityOperator" "', argument " "1"" of type '" "mfem::IdentityOperator *""'"); + } + arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *IdentityOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *IdentityOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsIdentityProlongation" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + try { + result = (bool)mfem::IsIdentityProlongation((mfem::Operator const *)arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_bool(static_cast< bool >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + mfem::ScaledOperator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ScaledOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScaledOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScaledOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (mfem::ScaledOperator *)new mfem::ScaledOperator((mfem::Operator const *)arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ScaledOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; + mfem::ScaledOperator *arg1 = (mfem::ScaledOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9198,31 +12205,31 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPA int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "IdentityOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ScaledOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScaledOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityOperator_MultTranspose" "', argument " "1"" of type '" "mfem::IdentityOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScaledOperator_Mult" "', argument " "1"" of type '" "mfem::ScaledOperator const *""'"); } - arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ScaledOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScaledOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScaledOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::IdentityOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::ScaledOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9246,20 +12253,20 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_delete_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; + mfem::ScaledOperator *arg1 = (mfem::ScaledOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScaledOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IdentityOperator" "', argument " "1"" of type '" "mfem::IdentityOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScaledOperator" "', argument " "1"" of type '" "mfem::ScaledOperator *""'"); } - arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ScaledOperator * >(argp1); { try { delete arg1; @@ -9286,14 +12293,14 @@ SWIGINTERN PyObject *_wrap_delete_IdentityOperator(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *IdentityOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ScaledOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__IdentityOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ScaledOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *IdentityOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ScaledOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } @@ -9442,15 +12449,252 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::TransposeOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "TransposeOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TransposeOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::TransposeOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_TransposeOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeOperator" "', argument " "1"" of type '" "mfem::TransposeOperator *""'"); + } + arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *TransposeOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TransposeOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Operator *arg2 = (mfem::Operator *) 0 ; + bool arg3 ; + bool arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject *swig_obj[4] ; + mfem::ProductOperator *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ProductOperator", 4, 4, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProductOperator" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ProductOperator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + { + try { + result = (mfem::ProductOperator *)new mfem::ProductOperator((mfem::Operator const *)arg1,(mfem::Operator const *)arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ProductOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_Mult" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::TransposeOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::ProductOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9474,9 +12718,9 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; + mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9487,31 +12731,31 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDP int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "TransposeOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TransposeOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); } - arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::TransposeOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::ProductOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9535,20 +12779,20 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_delete_TransposeOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; + mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeOperator" "', argument " "1"" of type '" "mfem::TransposeOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProductOperator" "', argument " "1"" of type '" "mfem::ProductOperator *""'"); } - arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); { try { delete arg1; @@ -9575,58 +12819,59 @@ SWIGINTERN PyObject *_wrap_delete_TransposeOperator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *TransposeOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ProductOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *TransposeOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - bool arg3 ; - bool arg4 ; + mfem::Operator *arg1 = 0 ; + mfem::Operator *arg2 = 0 ; + mfem::Operator *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - PyObject *swig_obj[4] ; - mfem::ProductOperator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + mfem::RAPOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ProductOperator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "new_RAPOperator", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProductOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ProductOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RAPOperator" "', argument " "3"" of type '" "mfem::Operator const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "3"" of type '" "mfem::Operator const &""'"); + } + arg3 = reinterpret_cast< mfem::Operator * >(argp3); { try { - result = (mfem::ProductOperator *)new mfem::ProductOperator((mfem::Operator const *)arg1,(mfem::Operator const *)arg2,arg3,arg4); + result = (mfem::RAPOperator *)new mfem::RAPOperator((mfem::Operator const &)*arg1,(mfem::Operator const &)*arg2,(mfem::Operator const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9643,16 +12888,57 @@ SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ProductOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MemoryClass result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + } + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + { + try { + result = (mfem::MemoryClass)((mfem::RAPOperator const *)arg1)->GetMemoryClass(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9663,31 +12949,31 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "ProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RAPOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_Mult" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_Mult" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ProductOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::RAPOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9711,9 +12997,9 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9724,31 +13010,31 @@ SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPAR int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "ProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RAPOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_MultTranspose" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ProductOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::RAPOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9772,20 +13058,20 @@ SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_delete_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; + mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ProductOperator" "', argument " "1"" of type '" "mfem::ProductOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RAPOperator" "', argument " "1"" of type '" "mfem::RAPOperator *""'"); } - arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); { try { delete arg1; @@ -9812,59 +13098,74 @@ SWIGINTERN PyObject *_wrap_delete_ProductOperator(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *ProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *RAPOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ProductOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RAPOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *RAPOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Operator *arg2 = 0 ; - mfem::Operator *arg3 = 0 ; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Operator *arg2 = (mfem::Operator *) 0 ; + mfem::Operator *arg3 = (mfem::Operator *) 0 ; + bool arg4 ; + bool arg5 ; + bool arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; - mfem::RAPOperator *result = 0 ; + bool val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + bool val6 ; + int ecode6 = 0 ; + PyObject *swig_obj[6] ; + mfem::TripleProductOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_RAPOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "new_TripleProductOperator", 6, 6, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TripleProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TripleProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Operator, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RAPOperator" "', argument " "3"" of type '" "mfem::Operator const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "3"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TripleProductOperator" "', argument " "3"" of type '" "mfem::Operator const *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TripleProductOperator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TripleProductOperator" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TripleProductOperator" "', argument " "6"" of type '" "bool""'"); + } + arg6 = static_cast< bool >(val6); { try { - result = (mfem::RAPOperator *)new mfem::RAPOperator((mfem::Operator const &)*arg1,(mfem::Operator const &)*arg2,(mfem::Operator const &)*arg3); + result = (mfem::TripleProductOperator *)new mfem::TripleProductOperator((mfem::Operator const *)arg1,(mfem::Operator const *)arg2,(mfem::Operator const *)arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9881,16 +13182,16 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -9898,14 +13199,14 @@ SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(s if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); { try { - result = (mfem::MemoryClass)((mfem::RAPOperator const *)arg1)->GetMemoryClass(); + result = (mfem::MemoryClass)((mfem::TripleProductOperator const *)arg1)->GetMemoryClass(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9929,9 +13230,9 @@ SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9942,31 +13243,31 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_Mult" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_Mult" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::RAPOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::TripleProductOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9990,9 +13291,9 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -10003,31 +13304,31 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_MultTranspose" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::RAPOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::TripleProductOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10051,20 +13352,20 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_delete_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; + mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RAPOperator" "', argument " "1"" of type '" "mfem::RAPOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); } - arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); { try { delete arg1; @@ -10091,74 +13392,52 @@ SWIGINTERN PyObject *_wrap_delete_RAPOperator(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *RAPOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RAPOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *RAPOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - mfem::Operator *arg3 = (mfem::Operator *) 0 ; - bool arg4 ; - bool arg5 ; - bool arg6 ; + mfem::Array< int > *arg2 = 0 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - bool val6 ; - int ecode6 = 0 ; - PyObject *swig_obj[6] ; - mfem::TripleProductOperator *result = 0 ; + bool val3 ; + int ecode3 = 0 ; + mfem::ConstrainedOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_TripleProductOperator", 6, 6, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TripleProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TripleProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TripleProductOperator" "', argument " "3"" of type '" "mfem::Operator const *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< mfem::Operator * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TripleProductOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TripleProductOperator" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TripleProductOperator" "', argument " "6"" of type '" "bool""'"); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); } - arg6 = static_cast< bool >(val6); + arg3 = static_cast< bool >(val3); { try { - result = (mfem::TripleProductOperator *)new mfem::TripleProductOperator((mfem::Operator const *)arg1,(mfem::Operator const *)arg2,(mfem::Operator const *)arg3,arg4,arg5,arg6); + result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10175,16 +13454,116 @@ SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::ConstrainedOperator *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + try { + result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstrainedOperator", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ConstrainedOperator__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ConstrainedOperator__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstrainedOperator'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,bool)\n" + " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10192,14 +13571,14 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUN if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); { try { - result = (mfem::MemoryClass)((mfem::TripleProductOperator const *)arg1)->GetMemoryClass(); + result = (mfem::MemoryClass)((mfem::ConstrainedOperator const *)arg1)->GetMemoryClass(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10223,9 +13602,9 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -10236,31 +13615,31 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_Mult" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::TripleProductOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::ConstrainedOperator const *)arg1)->EliminateRHS((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10284,9 +13663,9 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -10297,31 +13676,31 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::TripleProductOperator const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::ConstrainedOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10345,20 +13724,20 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; + mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstrainedOperator" "', argument " "1"" of type '" "mfem::ConstrainedOperator *""'"); } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); + arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); { try { delete arg1; @@ -10385,52 +13764,63 @@ SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; - bool arg3 ; + mfem::Array< int > *arg3 = 0 ; + bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - mfem::ConstrainedOperator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + mfem::RectangularConstrainedOperator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RectangularConstrainedOperator" "', argument " "4"" of type '" "bool""'"); } - arg3 = static_cast< bool >(val3); + arg4 = static_cast< bool >(val4); { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); + result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10447,40 +13837,51 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::ConstrainedOperator *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + mfem::RectangularConstrainedOperator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2); + result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10497,22 +13898,22 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstrainedOperator", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_RectangularConstrainedOperator", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -10521,11 +13922,15 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_1(self, argc, argv); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_RectangularConstrainedOperator__SWIG_1(self, argc, argv); + } } } } - if (argc == 3) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -10534,29 +13939,33 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_0(self, argc, argv); + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_RectangularConstrainedOperator__SWIG_0(self, argc, argv); + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstrainedOperator'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RectangularConstrainedOperator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,bool)\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &)\n"); + " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &,bool)\n" + " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; @@ -10564,14 +13973,14 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUS if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_GetMemoryClass" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); { try { - result = (mfem::MemoryClass)((mfem::ConstrainedOperator const *)arg1)->GetMemoryClass(); + result = (mfem::MemoryClass)((mfem::RectangularConstrainedOperator const *)arg1)->GetMemoryClass(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10595,9 +14004,9 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -10608,31 +14017,31 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ConstrainedOperator const *)arg1)->EliminateRHS((mfem::Vector const &)*arg2,*arg3); + ((mfem::RectangularConstrainedOperator const *)arg1)->EliminateRHS((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10656,9 +14065,9 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -10669,31 +14078,31 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ConstrainedOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::RectangularConstrainedOperator const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10717,20 +14126,20 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_delete_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_RectangularConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; + mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstrainedOperator" "', argument " "1"" of type '" "mfem::ConstrainedOperator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator *""'"); } - arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); { try { delete arg1; @@ -10757,14 +14166,14 @@ SWIGINTERN PyObject *_wrap_delete_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *ConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *RectangularConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *RectangularConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } @@ -11799,6 +15208,8 @@ SWIGINTERN PyObject *PyTimeDependentOperatorBase_swiginit(PyObject *SWIGUNUSEDPA static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "Operator_InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" "Operator(int s=0)\n" "new_Operator(PyObject * _self, int h, int w) -> Operator\n" @@ -11813,8 +15224,14 @@ static PyMethodDef SwigMethods[] = { { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "Operator_GetGradient(Operator self, Vector x) -> Operator"}, { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "Operator_GetProlongation(Operator self) -> Operator"}, { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "Operator_GetRestriction(Operator self) -> Operator"}, + { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "Operator_GetOutputProlongation(Operator self) -> Operator"}, + { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "Operator_GetOutputRestriction(Operator self) -> Operator"}, { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "Operator_FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "Operator_FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "Operator_RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "Operator_FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "Operator_FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "Operator_FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, { "Operator_GetType", _wrap_Operator_GetType, METH_O, "Operator_GetType(Operator self) -> mfem::Operator::Type"}, { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" @@ -11833,16 +15250,38 @@ static PyMethodDef SwigMethods[] = { { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "TimeDependentOperator_isExplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "TimeDependentOperator_isImplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "TimeDependentOperator_isHomogeneous(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "TimeDependentOperator_GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, + { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "TimeDependentOperator_SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "TimeDependentOperator_ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "TimeDependentOperator_ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "TimeDependentOperator_Mult(TimeDependentOperator self, Vector x, Vector y)"}, { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "TimeDependentOperator_ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "TimeDependentOperator_GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "TimeDependentOperator_GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "TimeDependentOperator_SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "TimeDependentOperator_SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "TimeDependentOperator_SUNMassSetup(TimeDependentOperator self) -> int"}, + { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "TimeDependentOperator_SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "TimeDependentOperator_SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, + { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + ""}, + { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator_Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" + "SecondOrderTimeDependentOperator_Mult(SecondOrderTimeDependentOperator self, Vector x, Vector dxdt, Vector y)\n" + ""}, + { "SecondOrderTimeDependentOperator_ImplicitSolve", _wrap_SecondOrderTimeDependentOperator_ImplicitSolve, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator_ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt, Vector x, Vector k)\n" + "SecondOrderTimeDependentOperator_ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt0, double const dt1, Vector x, Vector dxdt, Vector k)\n" + ""}, + { "delete_SecondOrderTimeDependentOperator", _wrap_delete_SecondOrderTimeDependentOperator, METH_O, "delete_SecondOrderTimeDependentOperator(SecondOrderTimeDependentOperator self)"}, + { "SecondOrderTimeDependentOperator_swigregister", SecondOrderTimeDependentOperator_swigregister, METH_O, NULL}, + { "SecondOrderTimeDependentOperator_swiginit", SecondOrderTimeDependentOperator_swiginit, METH_VARARGS, NULL}, { "Solver_iterative_mode_set", _wrap_Solver_iterative_mode_set, METH_VARARGS, "Solver_iterative_mode_set(Solver self, bool iterative_mode)"}, { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" @@ -11860,6 +15299,12 @@ static PyMethodDef SwigMethods[] = { { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, + { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "ScaledOperator_Mult(ScaledOperator self, Vector x, Vector y)"}, + { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, + { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, + { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, { "new_TransposeOperator", _wrap_new_TransposeOperator, METH_VARARGS, "\n" "TransposeOperator(Operator a)\n" "new_TransposeOperator(Operator a) -> TransposeOperator\n" @@ -11896,6 +15341,13 @@ static PyMethodDef SwigMethods[] = { { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, + { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "RectangularConstrainedOperator_GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, + { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "RectangularConstrainedOperator_EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "RectangularConstrainedOperator_Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, + { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, + { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, { "new_PyOperatorBase", _wrap_new_PyOperatorBase, METH_VARARGS, "\n" "PyOperatorBase(int s=0)\n" "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" @@ -11920,6 +15372,167 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" + "Operator(int s=0)\n" + "new_Operator(PyObject * _self, int h, int w) -> Operator\n" + ""}, + { "Operator_Height", _wrap_Operator_Height, METH_O, "Height(Operator self) -> int"}, + { "Operator_NumRows", _wrap_Operator_NumRows, METH_O, "NumRows(Operator self) -> int"}, + { "Operator_Width", _wrap_Operator_Width, METH_O, "Width(Operator self) -> int"}, + { "Operator_NumCols", _wrap_Operator_NumCols, METH_O, "NumCols(Operator self) -> int"}, + { "Operator_GetMemoryClass", _wrap_Operator_GetMemoryClass, METH_O, "GetMemoryClass(Operator self) -> mfem::MemoryClass"}, + { "Operator_Mult", _wrap_Operator_Mult, METH_VARARGS, "Mult(Operator self, Vector x, Vector y)"}, + { "Operator_MultTranspose", _wrap_Operator_MultTranspose, METH_VARARGS, "MultTranspose(Operator self, Vector x, Vector y)"}, + { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "GetGradient(Operator self, Vector x) -> Operator"}, + { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "GetProlongation(Operator self) -> Operator"}, + { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "GetRestriction(Operator self) -> Operator"}, + { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "GetOutputProlongation(Operator self) -> Operator"}, + { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "GetOutputRestriction(Operator self) -> Operator"}, + { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, + { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, + { "Operator_GetType", _wrap_Operator_GetType, METH_O, "GetType(Operator self) -> mfem::Operator::Type"}, + { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(Operator self, std::ostream & out, int n=0, int m=0)\n" + "PrintMatlab(Operator self, char const * file, int precision=8)\n" + ""}, + { "disown_Operator", _wrap_disown_Operator, METH_O, NULL}, + { "Operator_swigregister", Operator_swigregister, METH_O, NULL}, + { "Operator_swiginit", Operator_swiginit, METH_VARARGS, NULL}, + { "new_TimeDependentOperator", _wrap_new_TimeDependentOperator, METH_VARARGS, "\n" + "TimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "TimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + ""}, + { "TimeDependentOperator_GetTime", _wrap_TimeDependentOperator_GetTime, METH_O, "GetTime(TimeDependentOperator self) -> double"}, + { "TimeDependentOperator_SetTime", _wrap_TimeDependentOperator_SetTime, METH_VARARGS, "SetTime(TimeDependentOperator self, double const _t)"}, + { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "isExplicit(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "isImplicit(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "isHomogeneous(TimeDependentOperator self) -> bool"}, + { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, + { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, + { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, + { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "Mult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, + { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, + { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "SUNMassSetup(TimeDependentOperator self) -> int"}, + { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, + { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, + { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, + { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, + { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, + { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" + "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + ""}, + { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" + "Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" + "Mult(SecondOrderTimeDependentOperator self, Vector x, Vector dxdt, Vector y)\n" + ""}, + { "SecondOrderTimeDependentOperator_ImplicitSolve", _wrap_SecondOrderTimeDependentOperator_ImplicitSolve, METH_VARARGS, "\n" + "ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt, Vector x, Vector k)\n" + "ImplicitSolve(SecondOrderTimeDependentOperator self, double const dt0, double const dt1, Vector x, Vector dxdt, Vector k)\n" + ""}, + { "delete_SecondOrderTimeDependentOperator", _wrap_delete_SecondOrderTimeDependentOperator, METH_O, "delete_SecondOrderTimeDependentOperator(SecondOrderTimeDependentOperator self)"}, + { "SecondOrderTimeDependentOperator_swigregister", SecondOrderTimeDependentOperator_swigregister, METH_O, NULL}, + { "SecondOrderTimeDependentOperator_swiginit", SecondOrderTimeDependentOperator_swiginit, METH_VARARGS, NULL}, + { "Solver_iterative_mode_set", _wrap_Solver_iterative_mode_set, METH_VARARGS, "Solver_iterative_mode_set(Solver self, bool iterative_mode)"}, + { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, + { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" + "Solver(int s=0, bool iter_mode=False)\n" + "Solver(int h, int w, bool iter_mode=False)\n" + ""}, + { "Solver_SetOperator", _wrap_Solver_SetOperator, METH_VARARGS, "SetOperator(Solver self, Operator op)"}, + { "delete_Solver", _wrap_delete_Solver, METH_O, "delete_Solver(Solver self)"}, + { "disown_Solver", _wrap_disown_Solver, METH_O, NULL}, + { "Solver_swigregister", Solver_swigregister, METH_O, NULL}, + { "Solver_swiginit", Solver_swiginit, METH_VARARGS, NULL}, + { "new_IdentityOperator", _wrap_new_IdentityOperator, METH_O, "new_IdentityOperator(int n) -> IdentityOperator"}, + { "IdentityOperator_Mult", _wrap_IdentityOperator_Mult, METH_VARARGS, "Mult(IdentityOperator self, Vector x, Vector y)"}, + { "IdentityOperator_MultTranspose", _wrap_IdentityOperator_MultTranspose, METH_VARARGS, "MultTranspose(IdentityOperator self, Vector x, Vector y)"}, + { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, + { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, + { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, + { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "Mult(ScaledOperator self, Vector x, Vector y)"}, + { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, + { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, + { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, + { "new_TransposeOperator", _wrap_new_TransposeOperator, METH_VARARGS, "\n" + "TransposeOperator(Operator a)\n" + "new_TransposeOperator(Operator a) -> TransposeOperator\n" + ""}, + { "TransposeOperator_Mult", _wrap_TransposeOperator_Mult, METH_VARARGS, "Mult(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_MultTranspose", _wrap_TransposeOperator_MultTranspose, METH_VARARGS, "MultTranspose(TransposeOperator self, Vector x, Vector y)"}, + { "delete_TransposeOperator", _wrap_delete_TransposeOperator, METH_O, "delete_TransposeOperator(TransposeOperator self)"}, + { "TransposeOperator_swigregister", TransposeOperator_swigregister, METH_O, NULL}, + { "TransposeOperator_swiginit", TransposeOperator_swiginit, METH_VARARGS, NULL}, + { "new_ProductOperator", _wrap_new_ProductOperator, METH_VARARGS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, + { "ProductOperator_Mult", _wrap_ProductOperator_Mult, METH_VARARGS, "Mult(ProductOperator self, Vector x, Vector y)"}, + { "ProductOperator_MultTranspose", _wrap_ProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(ProductOperator self, Vector x, Vector y)"}, + { "delete_ProductOperator", _wrap_delete_ProductOperator, METH_O, "delete_ProductOperator(ProductOperator self)"}, + { "ProductOperator_swigregister", ProductOperator_swigregister, METH_O, NULL}, + { "ProductOperator_swiginit", ProductOperator_swiginit, METH_VARARGS, NULL}, + { "new_RAPOperator", _wrap_new_RAPOperator, METH_VARARGS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, + { "RAPOperator_GetMemoryClass", _wrap_RAPOperator_GetMemoryClass, METH_O, "GetMemoryClass(RAPOperator self) -> mfem::MemoryClass"}, + { "RAPOperator_Mult", _wrap_RAPOperator_Mult, METH_VARARGS, "Mult(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_MultTranspose", _wrap_RAPOperator_MultTranspose, METH_VARARGS, "MultTranspose(RAPOperator self, Vector x, Vector y)"}, + { "delete_RAPOperator", _wrap_delete_RAPOperator, METH_O, "delete_RAPOperator(RAPOperator self)"}, + { "RAPOperator_swigregister", RAPOperator_swigregister, METH_O, NULL}, + { "RAPOperator_swiginit", RAPOperator_swiginit, METH_VARARGS, NULL}, + { "new_TripleProductOperator", _wrap_new_TripleProductOperator, METH_VARARGS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, + { "TripleProductOperator_GetMemoryClass", _wrap_TripleProductOperator_GetMemoryClass, METH_O, "GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass"}, + { "TripleProductOperator_Mult", _wrap_TripleProductOperator_Mult, METH_VARARGS, "Mult(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_MultTranspose", _wrap_TripleProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, + { "delete_TripleProductOperator", _wrap_delete_TripleProductOperator, METH_O, "delete_TripleProductOperator(TripleProductOperator self)"}, + { "TripleProductOperator_swigregister", TripleProductOperator_swigregister, METH_O, NULL}, + { "TripleProductOperator_swiginit", TripleProductOperator_swiginit, METH_VARARGS, NULL}, + { "new_ConstrainedOperator", _wrap_new_ConstrainedOperator, METH_VARARGS, "ConstrainedOperator(Operator A, intArray list, bool own_A=False)"}, + { "ConstrainedOperator_GetMemoryClass", _wrap_ConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass"}, + { "ConstrainedOperator_EliminateRHS", _wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, + { "ConstrainedOperator_Mult", _wrap_ConstrainedOperator_Mult, METH_VARARGS, "Mult(ConstrainedOperator self, Vector x, Vector y)"}, + { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, + { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, + { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, + { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, + { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, + { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, + { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, + { "new_PyOperatorBase", _wrap_new_PyOperatorBase, METH_VARARGS, "\n" + "PyOperatorBase(int s=0)\n" + "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" + ""}, + { "PyOperatorBase_Mult", _wrap_PyOperatorBase_Mult, METH_VARARGS, "Mult(PyOperatorBase self, Vector x, Vector y)"}, + { "PyOperatorBase__EvalMult", _wrap_PyOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, + { "delete_PyOperatorBase", _wrap_delete_PyOperatorBase, METH_O, "delete_PyOperatorBase(PyOperatorBase self)"}, + { "disown_PyOperatorBase", _wrap_disown_PyOperatorBase, METH_O, NULL}, + { "PyOperatorBase_swigregister", PyOperatorBase_swigregister, METH_O, NULL}, + { "PyOperatorBase_swiginit", PyOperatorBase_swiginit, METH_VARARGS, NULL}, + { "new_PyTimeDependentOperatorBase", _wrap_new_PyTimeDependentOperatorBase, METH_VARARGS, "\n" + "PyTimeDependentOperatorBase(int n=0, double _t=0.0)\n" + "PyTimeDependentOperatorBase(int h, int w, double _t=0.0)\n" + ""}, + { "PyTimeDependentOperatorBase_Mult", _wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS, "Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, + { "PyTimeDependentOperatorBase__EvalMult", _wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, + { "delete_PyTimeDependentOperatorBase", _wrap_delete_PyTimeDependentOperatorBase, METH_O, "delete_PyTimeDependentOperatorBase(PyTimeDependentOperatorBase self)"}, + { "disown_PyTimeDependentOperatorBase", _wrap_disown_PyTimeDependentOperatorBase, METH_O, NULL}, + { "PyTimeDependentOperatorBase_swigregister", PyTimeDependentOperatorBase_swigregister, METH_O, NULL}, + { "PyTimeDependentOperatorBase_swiginit", PyTimeDependentOperatorBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -11932,9 +15545,15 @@ static void *_p_p_mfem__SolverTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM static void *_p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TimeDependentOperator **) x)); } +static void *_p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator **) x)); +} static void *_p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::IdentityOperator **) x)); } +static void *_p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::ScaledOperator **) x)); +} static void *_p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::TransposeOperator **) x)); } @@ -11950,6 +15569,9 @@ static void *_p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator(void *x, int static void *_p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::ConstrainedOperator **) x)); } +static void *_p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator **) ((mfem::RectangularConstrainedOperator **) x)); +} static void *_p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator **) ((mfem::PyOperatorBase **) x)); } @@ -11962,9 +15584,15 @@ static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(new static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } @@ -11980,17 +15608,24 @@ static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWI static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); } static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); } static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", "mfem::ConstrainedOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", "mfem::IdentityOperator *", 0, 0, (void*)0, 0}; @@ -11999,26 +15634,33 @@ static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperat static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", "mfem::PyOperatorBase *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", "mfem::PyTimeDependentOperatorBase *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", "mfem::RAPOperator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", "mfem::RectangularConstrainedOperator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", "mfem::ScaledOperator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", "mfem::SecondOrderTimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", "mfem::TimeDependentOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", "mfem::TransposeOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", "mfem::TripleProductOperator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_p_mfem__Operator = {"_p_p_mfem__Operator", "mfem::Operator **", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_p_mfem__PyOperatorBase = {"_p_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__PyTimeDependentOperatorBase = {"_p_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__Solver = {"_p_p_mfem__Solver", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TimeDependentOperator = {"_p_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__SecondOrderTimeDependentOperator = {"_p_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__IdentityOperator = {"_p_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__ScaledOperator = {"_p_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TransposeOperator = {"_p_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ProductOperator = {"_p_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__RAPOperator = {"_p_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__TripleProductOperator = {"_p_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_p_mfem__ConstrainedOperator = {"_p_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_p_mfem__PyOperatorBase = {"_p_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_p_mfem__PyTimeDependentOperatorBase = {"_p_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_p_mfem__RectangularConstrainedOperator = {"_p_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, &_swigt__p_char, + &_swigt__p_int, &_swigt__p_mfem__ArrayT_int_t, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__IdentityOperator, @@ -12027,6 +15669,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__TimeDependentOperator, &_swigt__p_mfem__TransposeOperator, @@ -12039,6 +15684,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_p_mfem__PyOperatorBase, &_swigt__p_p_mfem__PyTimeDependentOperatorBase, &_swigt__p_p_mfem__RAPOperator, + &_swigt__p_p_mfem__RectangularConstrainedOperator, + &_swigt__p_p_mfem__ScaledOperator, + &_swigt__p_p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_p_mfem__Solver, &_swigt__p_p_mfem__TimeDependentOperator, &_swigt__p_p_mfem__TransposeOperator, @@ -12047,34 +15695,42 @@ static swig_type_info *swig_type_initial[] = { static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = { {&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = { {&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = { {&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = { {&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = { {&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = { {&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = { {&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = { {&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = { {&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__TimeDependentOperator, 0, 0}, {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__TimeDependentOperator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = { {&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = { {&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__PyOperatorBase[] = {{&_swigt__p_p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__Solver[] = {{&_swigt__p_p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TimeDependentOperator[] = {{&_swigt__p_p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__IdentityOperator[] = {{&_swigt__p_p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__ScaledOperator[] = {{&_swigt__p_p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TransposeOperator[] = {{&_swigt__p_p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ProductOperator[] = {{&_swigt__p_p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__RAPOperator[] = {{&_swigt__p_p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__TripleProductOperator[] = {{&_swigt__p_p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_p_mfem__ConstrainedOperator[] = {{&_swigt__p_p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__PyOperatorBase[] = {{&_swigt__p_p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_mfem__Operator[] = { {&_swigt__p_p_mfem__PyOperatorBase, _p_p_mfem__PyOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__PyTimeDependentOperatorBase, _p_p_mfem__PyTimeDependentOperatorBaseTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Solver, _p_p_mfem__SolverTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TimeDependentOperator, _p_p_mfem__TimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__SecondOrderTimeDependentOperator, _p_p_mfem__SecondOrderTimeDependentOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__IdentityOperator, _p_p_mfem__IdentityOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ScaledOperator, _p_p_mfem__ScaledOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TransposeOperator, _p_p_mfem__TransposeOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ProductOperator, _p_p_mfem__ProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RAPOperator, _p_p_mfem__RAPOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__TripleProductOperator, _p_p_mfem__TripleProductOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__ConstrainedOperator, _p_p_mfem__ConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__RectangularConstrainedOperator, _p_p_mfem__RectangularConstrainedOperatorTo_p_p_mfem__Operator, 0, 0}, {&_swigt__p_p_mfem__Operator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, _swigc__p_char, + _swigc__p_int, _swigc__p_mfem__ArrayT_int_t, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__IdentityOperator, @@ -12083,6 +15739,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__TimeDependentOperator, _swigc__p_mfem__TransposeOperator, @@ -12095,6 +15754,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_p_mfem__PyOperatorBase, _swigc__p_p_mfem__PyTimeDependentOperatorBase, _swigc__p_p_mfem__RAPOperator, + _swigc__p_p_mfem__RectangularConstrainedOperator, + _swigc__p_p_mfem__ScaledOperator, + _swigc__p_p_mfem__SecondOrderTimeDependentOperator, _swigc__p_p_mfem__Solver, _swigc__p_p_mfem__TimeDependentOperator, _swigc__p_p_mfem__TransposeOperator, @@ -12840,9 +16502,15 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "Operator_PETSC_MATNEST",SWIG_From_int(static_cast< int >(mfem::Operator::PETSC_MATNEST))); SWIG_Python_SetConstant(d, "Operator_PETSC_MATHYPRE",SWIG_From_int(static_cast< int >(mfem::Operator::PETSC_MATHYPRE))); SWIG_Python_SetConstant(d, "Operator_PETSC_MATGENERIC",SWIG_From_int(static_cast< int >(mfem::Operator::PETSC_MATGENERIC))); + SWIG_Python_SetConstant(d, "Operator_Complex_Operator",SWIG_From_int(static_cast< int >(mfem::Operator::Complex_Operator))); + SWIG_Python_SetConstant(d, "Operator_MFEM_ComplexSparseMat",SWIG_From_int(static_cast< int >(mfem::Operator::MFEM_ComplexSparseMat))); + SWIG_Python_SetConstant(d, "Operator_Complex_Hypre_ParCSR",SWIG_From_int(static_cast< int >(mfem::Operator::Complex_Hypre_ParCSR))); SWIG_Python_SetConstant(d, "TimeDependentOperator_EXPLICIT",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::EXPLICIT))); SWIG_Python_SetConstant(d, "TimeDependentOperator_IMPLICIT",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::IMPLICIT))); SWIG_Python_SetConstant(d, "TimeDependentOperator_HOMOGENEOUS",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::HOMOGENEOUS))); + SWIG_Python_SetConstant(d, "TimeDependentOperator_NORMAL",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::NORMAL))); + SWIG_Python_SetConstant(d, "TimeDependentOperator_ADDITIVE_TERM_1",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::ADDITIVE_TERM_1))); + SWIG_Python_SetConstant(d, "TimeDependentOperator_ADDITIVE_TERM_2",SWIG_From_int(static_cast< int >(mfem::TimeDependentOperator::ADDITIVE_TERM_2))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_ser/operators_wrap.h b/mfem/_ser/operators_wrap.h index ff187fbf..5ceff3f2 100644 --- a/mfem/_ser/operators_wrap.h +++ b/mfem/_ser/operators_wrap.h @@ -26,6 +26,8 @@ class SwigDirector_Operator : public mfem::Operator, public Swig::Director { virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_Operator(); @@ -58,7 +60,7 @@ class SwigDirector_Operator : public mfem::Operator, public Swig::Director { return method; } private: - mutable swig::SwigVar_PyObject vtable[7]; + mutable swig::SwigVar_PyObject vtable[9]; #endif }; @@ -75,15 +77,23 @@ class SwigDirector_TimeDependentOperator : public mfem::TimeDependentOperator, p virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_TimeDependentOperator(); virtual double GetTime() const; virtual void SetTime(double const _t); + virtual void SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode); virtual void ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const; virtual void ImplicitMult(mfem::Vector const &x, mfem::Vector const &k, mfem::Vector &y) const; virtual void ImplicitSolve(double const dt, mfem::Vector const &x, mfem::Vector &k); virtual mfem::Operator &GetImplicitGradient(mfem::Vector const &x, mfem::Vector const &k, double shift) const; virtual mfem::Operator &GetExplicitGradient(mfem::Vector const &x) const; + virtual int SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma); + virtual int SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassSetup(); + virtual int SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassMult(mfem::Vector const &x, mfem::Vector &v); /* Internal director utilities */ public: @@ -114,7 +124,7 @@ class SwigDirector_TimeDependentOperator : public mfem::TimeDependentOperator, p return method; } private: - mutable swig::SwigVar_PyObject vtable[14]; + mutable swig::SwigVar_PyObject vtable[22]; #endif }; @@ -131,6 +141,8 @@ class SwigDirector_Solver : public mfem::Solver, public Swig::Director { virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_Solver(); virtual void SetOperator(mfem::Operator const &op); @@ -164,7 +176,7 @@ class SwigDirector_Solver : public mfem::Solver, public Swig::Director { return method; } private: - mutable swig::SwigVar_PyObject vtable[8]; + mutable swig::SwigVar_PyObject vtable[10]; #endif }; @@ -181,6 +193,8 @@ class SwigDirector_PyOperatorBase : public mfem::PyOperatorBase, public Swig::Di virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_PyOperatorBase(); virtual mfem::Vector &_EvalMult(mfem::Vector const &arg0) const; @@ -214,7 +228,7 @@ class SwigDirector_PyOperatorBase : public mfem::PyOperatorBase, public Swig::Di return method; } private: - mutable swig::SwigVar_PyObject vtable[8]; + mutable swig::SwigVar_PyObject vtable[10]; #endif }; @@ -231,15 +245,23 @@ class SwigDirector_PyTimeDependentOperatorBase : public mfem::PyTimeDependentOpe virtual mfem::Operator &GetGradient(mfem::Vector const &x) const; virtual mfem::Operator const *GetProlongation() const; virtual mfem::Operator const *GetRestriction() const; + virtual mfem::Operator const *GetOutputProlongation() const; + virtual mfem::Operator const *GetOutputRestriction() const; virtual void RecoverFEMSolution(mfem::Vector const &X, mfem::Vector const &b, mfem::Vector &x); virtual ~SwigDirector_PyTimeDependentOperatorBase(); virtual double GetTime() const; virtual void SetTime(double const _t); + virtual void SetEvalMode(mfem::TimeDependentOperator::EvalMode const new_eval_mode); virtual void ExplicitMult(mfem::Vector const &x, mfem::Vector &y) const; virtual void ImplicitMult(mfem::Vector const &x, mfem::Vector const &k, mfem::Vector &y) const; virtual void ImplicitSolve(double const dt, mfem::Vector const &x, mfem::Vector &k); virtual mfem::Operator &GetImplicitGradient(mfem::Vector const &x, mfem::Vector const &k, double shift) const; virtual mfem::Operator &GetExplicitGradient(mfem::Vector const &x) const; + virtual int SUNImplicitSetup(mfem::Vector const &x, mfem::Vector const &fx, int jok, int *jcur, double gamma); + virtual int SUNImplicitSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassSetup(); + virtual int SUNMassSolve(mfem::Vector const &b, mfem::Vector &x, double tol); + virtual int SUNMassMult(mfem::Vector const &x, mfem::Vector &v); virtual mfem::Vector &_EvalMult(mfem::Vector const &arg0) const; /* Internal director utilities */ @@ -271,7 +293,7 @@ class SwigDirector_PyTimeDependentOperatorBase : public mfem::PyTimeDependentOpe return method; } private: - mutable swig::SwigVar_PyObject vtable[15]; + mutable swig::SwigVar_PyObject vtable[23]; #endif }; diff --git a/mfem/_ser/ostream_typemap.py b/mfem/_ser/ostream_typemap.py index b2139007..8aa920ec 100644 --- a/mfem/_ser/ostream_typemap.py +++ b/mfem/_ser/ostream_typemap.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _ostream_typemap.SWIG_PyInstanceMethod_New +_swig_new_static_method = _ostream_typemap.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() diff --git a/mfem/_ser/ostream_typemap_wrap.cxx b/mfem/_ser/ostream_typemap_wrap.cxx index a3a0709b..7641861b 100644 --- a/mfem/_ser/ostream_typemap_wrap.cxx +++ b/mfem/_ser/ostream_typemap_wrap.cxx @@ -2767,10 +2767,13 @@ extern "C" { #endif static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/point.py b/mfem/_ser/point.py index 5cc34b47..1ccad2c4 100644 --- a/mfem/_ser/point.py +++ b/mfem/_ser/point.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _point.SWIG_PyInstanceMethod_New +_swig_new_static_method = _point.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -90,6 +93,7 @@ def __init__(self, *args): def GetType(self): r"""GetType(Point self) -> mfem::Element::Type""" return _point.Point_GetType(self) + GetType = _swig_new_instance_method(_point.Point_GetType) def GetVertices(self, *args): r""" @@ -97,30 +101,45 @@ def GetVertices(self, *args): GetVertices(Point self) -> int * """ return _point.Point_GetVertices(self, *args) + GetVertices = _swig_new_instance_method(_point.Point_GetVertices) def GetNVertices(self): r"""GetNVertices(Point self) -> int""" return _point.Point_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_point.Point_GetNVertices) def GetNEdges(self): r"""GetNEdges(Point self) -> int""" return _point.Point_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_point.Point_GetNEdges) def GetEdgeVertices(self, ei): r"""GetEdgeVertices(Point self, int ei) -> int const *""" return _point.Point_GetEdgeVertices(self, ei) + GetEdgeVertices = _swig_new_instance_method(_point.Point_GetEdgeVertices) + + def GetNFaces(self, *args): + r""" + GetNFaces(Point self, int & nFaceVertices) -> int + GetNFaces(Point self) -> int + """ + return _point.Point_GetNFaces(self, *args) + GetNFaces = _swig_new_instance_method(_point.Point_GetNFaces) - def GetNFaces(self, nFaceVertices): - r"""GetNFaces(Point self, int & nFaceVertices) -> int""" - return _point.Point_GetNFaces(self, nFaceVertices) + def GetNFaceVertices(self, arg2): + r"""GetNFaceVertices(Point self, int arg2) -> int""" + return _point.Point_GetNFaceVertices(self, arg2) + GetNFaceVertices = _swig_new_instance_method(_point.Point_GetNFaceVertices) def GetFaceVertices(self, fi): r"""GetFaceVertices(Point self, int fi) -> int const *""" return _point.Point_GetFaceVertices(self, fi) + GetFaceVertices = _swig_new_instance_method(_point.Point_GetFaceVertices) def Duplicate(self, m): r"""Duplicate(Point self, mfem::Mesh * m) -> Element""" return _point.Point_Duplicate(self, m) + Duplicate = _swig_new_instance_method(_point.Point_Duplicate) __swig_destroy__ = _point.delete_Point # Register Point in _point: diff --git a/mfem/_ser/point_wrap.cxx b/mfem/_ser/point_wrap.cxx index 5013b7f9..33aa3da0 100644 --- a/mfem/_ser/point_wrap.cxx +++ b/mfem/_ser/point_wrap.cxx @@ -3695,7 +3695,7 @@ SWIGINTERN PyObject *_wrap_Point_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetNFaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int *arg2 = 0 ; @@ -3703,10 +3703,9 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; int result; - if (!SWIG_Python_UnpackTuple(args, "Point_GetNFaces", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaces" "', argument " "1"" of type '" "mfem::Point const *""'"); @@ -3746,6 +3745,133 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObj } +SWIGINTERN PyObject *_wrap_Point_GetNFaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Point *arg1 = (mfem::Point *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaces" "', argument " "1"" of type '" "mfem::Point const *""'"); + } + arg1 = reinterpret_cast< mfem::Point * >(argp1); + { + try { + result = (int)((mfem::Point const *)arg1)->GetNFaces(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Point_GetNFaces", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Point, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point_GetNFaces__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Point, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Point_GetNFaces__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Point_GetNFaces'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Point::GetNFaces(int &) const\n" + " mfem::Point::GetNFaces() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Point *arg1 = (mfem::Point *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Point_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); + } + arg1 = reinterpret_cast< mfem::Point * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::Point const *)arg1)->GetNFaceVertices(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; @@ -3924,6 +4050,7 @@ SWIGINTERN PyObject *Swig_var_PointFE_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" "Point()\n" "Point(int const * ind, int attr=-1)\n" @@ -3936,7 +4063,11 @@ static PyMethodDef SwigMethods[] = { { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "Point_GetNVertices(Point self) -> int"}, { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "Point_GetNEdges(Point self) -> int"}, { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "Point_GetEdgeVertices(Point self, int ei) -> int const *"}, - { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "Point_GetNFaces(Point self, int & nFaceVertices) -> int"}, + { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" + "Point_GetNFaces(Point self, int & nFaceVertices) -> int\n" + "Point_GetNFaces(Point self) -> int\n" + ""}, + { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "Point_GetNFaceVertices(Point self, int arg2) -> int"}, { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "Point_GetFaceVertices(Point self, int fi) -> int const *"}, { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Point_Duplicate(Point self, mfem::Mesh * m) -> Element"}, { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, @@ -3946,6 +4077,30 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" + "Point()\n" + "Point(int const * ind, int attr=-1)\n" + ""}, + { "Point_GetType", _wrap_Point_GetType, METH_O, "GetType(Point self) -> mfem::Element::Type"}, + { "Point_GetVertices", _wrap_Point_GetVertices, METH_VARARGS, "\n" + "GetVertices(Point self, intArray v)\n" + "GetVertices(Point self) -> int *\n" + ""}, + { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "GetNVertices(Point self) -> int"}, + { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "GetNEdges(Point self) -> int"}, + { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Point self, int ei) -> int const *"}, + { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" + "GetNFaces(Point self, int & nFaceVertices) -> int\n" + "GetNFaces(Point self) -> int\n" + ""}, + { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Point self, int arg2) -> int"}, + { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Point self, int fi) -> int const *"}, + { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Duplicate(Point self, mfem::Mesh * m) -> Element"}, + { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, + { "Point_swigregister", Point_swigregister, METH_O, NULL}, + { "Point_swiginit", Point_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/restriction.i b/mfem/_ser/restriction.i new file mode 100644 index 00000000..582a81a9 --- /dev/null +++ b/mfem/_ser/restriction.i @@ -0,0 +1,21 @@ +%module(package="mfem._ser") restriction +%{ +#include "mfem.hpp" +#include "fem/restriction.hpp" +#include "numpy/arrayobject.h" +#include "pyoperator.hpp" +%} + +%init %{ +import_array(); +%} +%include "exception.i" +%import "element.i" +%include "../common/exception.i" +%import "../common/numpy_int_typemap.i" + +%import "operators.i" +%import "mesh.i" + +%include "fem/restriction.hpp" + diff --git a/mfem/_ser/restriction.py b/mfem/_ser/restriction.py new file mode 100644 index 00000000..e9d6ef7f --- /dev/null +++ b/mfem/_ser/restriction.py @@ -0,0 +1,216 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 4.0.1 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info as _swig_python_version_info +if _swig_python_version_info < (2, 7, 0): + raise RuntimeError("Python 2.7 or later required") + +# Import the low-level C/C++ module +if __package__ or "." in __name__: + from . import _restriction +else: + import _restriction + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + +_swig_new_instance_method = _restriction.SWIG_PyInstanceMethod_New +_swig_new_static_method = _restriction.SWIG_PyStaticMethod_New + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +def _swig_setattr_nondynamic_instance_variable(set): + def set_instance_attr(self, name, value): + if name == "thisown": + self.this.own(value) + elif name == "this": + set(self, name, value) + elif hasattr(self, name) and isinstance(getattr(type(self), name), property): + set(self, name, value) + else: + raise AttributeError("You cannot add instance attributes to %s" % self) + return set_instance_attr + + +def _swig_setattr_nondynamic_class_variable(set): + def set_class_attr(cls, name, value): + if hasattr(cls, name) and not isinstance(getattr(cls, name), property): + set(cls, name, value) + else: + raise AttributeError("You cannot add class attributes to %s" % cls) + return set_class_attr + + +def _swig_add_metaclass(metaclass): + """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" + def wrapper(cls): + return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) + return wrapper + + +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) + + +import weakref + +import mfem._ser.element +import mfem._ser.array +import mfem._ser.mem_manager +import mfem._ser.densemat +import mfem._ser.vector +import mfem._ser.operators +import mfem._ser.matrix +import mfem._ser.geom +import mfem._ser.intrules +import mfem._ser.table +import mfem._ser.hash +import mfem._ser.mesh +import mfem._ser.ncmesh +import mfem._ser.gridfunc +import mfem._ser.coefficient +import mfem._ser.sparsemat +import mfem._ser.eltrans +import mfem._ser.fe +import mfem._ser.fespace +import mfem._ser.fe_coll +import mfem._ser.lininteg +import mfem._ser.handle +import mfem._ser.bilininteg +import mfem._ser.linearform +import mfem._ser.vertex +import mfem._ser.vtk +L2FaceValues_SingleValued = _restriction.L2FaceValues_SingleValued + +L2FaceValues_DoubleValued = _restriction.L2FaceValues_DoubleValued + +class ElementRestriction(mfem._ser.operators.Operator): + r"""Proxy of C++ mfem::ElementRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, arg2, arg3): + r"""__init__(ElementRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering arg3) -> ElementRestriction""" + _restriction.ElementRestriction_swiginit(self, _restriction.new_ElementRestriction(arg2, arg3)) + + def Mult(self, x, y): + r"""Mult(ElementRestriction self, Vector x, Vector y)""" + return _restriction.ElementRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.ElementRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(ElementRestriction self, Vector x, Vector y)""" + return _restriction.ElementRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.ElementRestriction_MultTranspose) + + def MultTransposeUnsigned(self, x, y): + r"""MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)""" + return _restriction.ElementRestriction_MultTransposeUnsigned(self, x, y) + MultTransposeUnsigned = _swig_new_instance_method(_restriction.ElementRestriction_MultTransposeUnsigned) + __swig_destroy__ = _restriction.delete_ElementRestriction + +# Register ElementRestriction in _restriction: +_restriction.ElementRestriction_swigregister(ElementRestriction) + +class L2ElementRestriction(mfem._ser.operators.Operator): + r"""Proxy of C++ mfem::L2ElementRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, arg2): + r"""__init__(L2ElementRestriction self, FiniteElementSpace arg2) -> L2ElementRestriction""" + _restriction.L2ElementRestriction_swiginit(self, _restriction.new_L2ElementRestriction(arg2)) + + def Mult(self, x, y): + r"""Mult(L2ElementRestriction self, Vector x, Vector y)""" + return _restriction.L2ElementRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.L2ElementRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(L2ElementRestriction self, Vector x, Vector y)""" + return _restriction.L2ElementRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.L2ElementRestriction_MultTranspose) + __swig_destroy__ = _restriction.delete_L2ElementRestriction + +# Register L2ElementRestriction in _restriction: +_restriction.L2ElementRestriction_swigregister(L2ElementRestriction) + +class H1FaceRestriction(mfem._ser.operators.Operator): + r"""Proxy of C++ mfem::H1FaceRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, arg2, arg3, arg4): + r"""__init__(H1FaceRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering const arg3, mfem::FaceType const arg4) -> H1FaceRestriction""" + _restriction.H1FaceRestriction_swiginit(self, _restriction.new_H1FaceRestriction(arg2, arg3, arg4)) + + def Mult(self, x, y): + r"""Mult(H1FaceRestriction self, Vector x, Vector y)""" + return _restriction.H1FaceRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.H1FaceRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(H1FaceRestriction self, Vector x, Vector y)""" + return _restriction.H1FaceRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.H1FaceRestriction_MultTranspose) + __swig_destroy__ = _restriction.delete_H1FaceRestriction + +# Register H1FaceRestriction in _restriction: +_restriction.H1FaceRestriction_swigregister(H1FaceRestriction) + +class L2FaceRestriction(mfem._ser.operators.Operator): + r"""Proxy of C++ mfem::L2FaceRestriction class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r"""__init__(L2FaceRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering const arg3, mfem::FaceType const arg4, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction""" + _restriction.L2FaceRestriction_swiginit(self, _restriction.new_L2FaceRestriction(*args)) + + def Mult(self, x, y): + r"""Mult(L2FaceRestriction self, Vector x, Vector y)""" + return _restriction.L2FaceRestriction_Mult(self, x, y) + Mult = _swig_new_instance_method(_restriction.L2FaceRestriction_Mult) + + def MultTranspose(self, x, y): + r"""MultTranspose(L2FaceRestriction self, Vector x, Vector y)""" + return _restriction.L2FaceRestriction_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_restriction.L2FaceRestriction_MultTranspose) + __swig_destroy__ = _restriction.delete_L2FaceRestriction + +# Register L2FaceRestriction in _restriction: +_restriction.L2FaceRestriction_swigregister(L2FaceRestriction) + + +def GetFaceDofs(dim, face_id, dof1d, faceMap): + r"""GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)""" + return _restriction.GetFaceDofs(dim, face_id, dof1d, faceMap) +GetFaceDofs = _restriction.GetFaceDofs + +def ToLexOrdering(dim, face_id, size1d, index): + r"""ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int""" + return _restriction.ToLexOrdering(dim, face_id, size1d, index) +ToLexOrdering = _restriction.ToLexOrdering + +def PermuteFaceL2(dim, face_id1, face_id2, orientation, size1d, index): + r"""PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int""" + return _restriction.PermuteFaceL2(dim, face_id1, face_id2, orientation, size1d, index) +PermuteFaceL2 = _restriction.PermuteFaceL2 + + diff --git a/mfem/_ser/restriction_wrap.cxx b/mfem/_ser/restriction_wrap.cxx new file mode 100644 index 00000000..14586468 --- /dev/null +++ b/mfem/_ser/restriction_wrap.cxx @@ -0,0 +1,5754 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGPYTHON +#define SWIGPYTHON +#endif + +#define SWIG_DIRECTORS +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + + +#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) +/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ +# include +#endif + +#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) +/* Use debug wrappers with the Python release dll */ +# undef _DEBUG +# include +# define _DEBUG 1 +#else +# include +#endif + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = (unsigned char)((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = (unsigned char)((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (unsigned char)(d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (unsigned char)(d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Warning: This function will allocate a new string in Python 3, + * so please call SWIG_Python_str_DelForPy3(x) to free the space. + */ +SWIGINTERN char* +SWIG_Python_str_AsChar(PyObject *str) +{ +#if PY_VERSION_HEX >= 0x03000000 + char *newstr = 0; + str = PyUnicode_AsUTF8String(str); + if (str) { + char *cstr; + Py_ssize_t len; + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char *) malloc(len+1); + memcpy(newstr, cstr, len+1); + Py_XDECREF(str); + } + return newstr; +#else + return PyString_AsString(str); +#endif +} + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#else +# define SWIG_Python_str_DelForPy3(x) +#endif + + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user +// interface files check for it. +# define SWIGPY_USE_CAPSULE +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define Py_hash_t long +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + PyErr_Clear(); + Py_XINCREF(type); + if (tmp) + PyErr_Format(type, "%s %s", tmp, mesg); + else + PyErr_Format(type, "%s", mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +SWIGRUNTIME int +SWIG_Python_TypeErrorOccurred(PyObject *obj) +{ + PyObject *error; + if (obj) + return 0; + error = PyErr_Occurred(); + return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError); +} + +SWIGRUNTIME void +SWIG_Python_RaiseOrModifyTypeError(const char *message) +{ + if (SWIG_Python_TypeErrorOccurred(NULL)) { + /* Use existing TypeError to preserve stacktrace and enhance with given message */ + PyObject *newvalue; + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); +#if PY_VERSION_HEX >= 0x03000000 + newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message); +#else + newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); +#endif + Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + /* Raise TypeError using given message */ + PyErr_SetString(PyExc_TypeError, message); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# define SWIG_PYTHON_USE_GIL +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + const char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */ +# error "This version of SWIG only supports Python >= 2.7" +#endif + +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000 +# error "This version of SWIG only supports Python 3 >= 3.2" +#endif + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +} + +/* Unpack the argument tuple */ + +SWIGINTERN Py_ssize_t +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + Py_ssize_t i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + Py_ssize_t i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + int fail = data ? data->implicitconv : 0; + if (fail) + PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors."); + return fail; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { + data->newraw = PyObject_GetAttrString(data->klass, "__new__"); + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); + data->delargs = !(flags & (METH_O)); + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + + +#ifdef SWIGPYTHON_BUILTIN + +SWIGRUNTIME PyObject * +SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + + if (!sobj->dict) + sobj->dict = PyDict_New(); + + Py_INCREF(sobj->dict); + return sobj->dict; +} + +#endif + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { + PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_repr(SwigPyObject *v) +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (v->next) { + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } + return repr; +} + +/* We need a version taking two PyObject* parameters so it's a valid + * PyCFunction to use in swigobject_methods[]. */ +SWIGRUNTIME PyObject * +SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + return SwigPyObject_repr((SwigPyObject*)v); +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res; + if( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { +#ifdef SWIGPYTHON_BUILTIN + PyTypeObject *target_tp = SwigPyObject_type(); + if (PyType_IsSubtype(op->ob_type, target_tp)) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); +#else + return (Py_TYPE(op) == SwigPyObject_type()) + || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + + /* PyObject_CallFunction() has the potential to silently drop + the active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); + + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if (!res) + PyErr_WriteUnraisable(destroy); + + PyErr_Restore(type, value, traceback); + + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (!SwigPyObject_Check(next)) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) { + return NULL; + } else { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v,args); + } else { + SwigPyObject_disown(v,args); + } + } + return obj; + } +} + +static PyMethodDef +swigobject_methods[] = { + {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"}, + {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"}, + {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"}, + {"append", SwigPyObject_append, METH_O, "appends another 'this' object"}, + {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"}, + {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"}, + {0, 0, 0, 0} +}; + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ +#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#else + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpyobject_type) < 0) + return NULL; + } + return &swigpyobject_type; +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) + || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpypacked_type) < 0) + return NULL; + } + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +static PyObject *Swig_This_global = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (Swig_This_global == NULL) + Swig_This_global = SWIG_Python_str_FromChar("this"); + return Swig_This_global; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None && !implicit_conv) { + if (ptr) + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + res = SWIG_OK; + } else { + if (implicit_conv) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + swig_cast_info *tc; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) + return SWIG_ERROR; + tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + return SWIG_OK; + } +} + +/* Convert a packed pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *empty_args = PyTuple_New(0); + if (empty_args) { + PyObject *empty_kwargs = PyDict_New(); + if (empty_kwargs) { + inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + Py_DECREF(empty_kwargs); + if (inst) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } + } + Py_DECREF(empty_args); + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, "__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { + PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +SWIGRUNTIME void +SWIG_Python_DestroyModule(PyObject *obj) +{ + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + Swig_This_global = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { + obj = PyCapsule_New((void*) descriptor, NULL, NULL); + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + const char *errmesg = tmp ? tmp : "Invalid error message"; + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, errmesg); + } else { + PyErr_Format(type, "%s %s", errmesg, mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +#if SWIG_POINTER_EXCEPTION + if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } +#endif + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res = -1; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) < 0) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + if (!encoded_name) + return -1; + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Method creation and docstring support functions */ + +SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name); +SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); +SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); + +#ifdef __cplusplus +} +#endif + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Python proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ +#define SWIG_DIRECTOR_PYTHON_HEADER_ + +#include +#include +#include +#include +#include + + +/* + Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual + table', and avoid multiple GetAttr calls to retrieve the python + methods. +*/ + +#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE +#ifndef SWIG_PYTHON_DIRECTOR_VTABLE +#define SWIG_PYTHON_DIRECTOR_VTABLE +#endif +#endif + + + +/* + Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the + Undefined Exception Handler provided by swig. +*/ +#ifndef SWIG_DIRECTOR_NO_UEH +#ifndef SWIG_DIRECTOR_UEH +#define SWIG_DIRECTOR_UEH +#endif +#endif + + +/* + Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the + native C++ RTTI and dynamic_cast<>. But be aware that directors + could stop working when using this option. +*/ +#ifdef SWIG_DIRECTOR_NORTTI +/* + When we don't use the native C++ RTTI, we implement a minimal one + only for Directors. +*/ +# ifndef SWIG_DIRECTOR_RTDIR +# define SWIG_DIRECTOR_RTDIR + +namespace Swig { + class Director; + SWIGINTERN std::map& get_rtdir_map() { + static std::map rtdir_map; + return rtdir_map; + } + + SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { + get_rtdir_map()[vptr] = rtdir; + } + + SWIGINTERNINLINE Director *get_rtdir(void *vptr) { + std::map::const_iterator pos = get_rtdir_map().find(vptr); + Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; + return rtdir; + } +} +# endif /* SWIG_DIRECTOR_RTDIR */ + +# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) + +#else + +# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) + +#endif /* SWIG_DIRECTOR_NORTTI */ + +extern "C" { + struct swig_type_info; +} + +namespace Swig { + + /* memory handler */ + struct GCItem { + virtual ~GCItem() {} + + virtual int get_own() const { + return 0; + } + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem * operator->() const { + return _item; + } + + private: + GCItem *_item; + }; + + struct GCItem_Object : GCItem { + GCItem_Object(int own) : _own(own) { + } + + virtual ~GCItem_Object() { + } + + int get_own() const { + return _own; + } + + private: + int _own; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; + + template + struct GCArray_T : GCItem { + GCArray_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCArray_T() { + delete[] _ptr; + } + + private: + Type *_ptr; + }; + + /* base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + public: + DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (msg[0]) { + swig_msg += " "; + swig_msg += msg; + } + if (!PyErr_Occurred()) { + PyErr_SetString(error, what()); + } + SWIG_PYTHON_THREAD_END_BLOCK; + } + + virtual ~DirectorException() throw() { + } + + /* Deprecated, use what() instead */ + const char *getMessage() const { + return what(); + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorException(error, msg); + } + + static void raise(const char *msg) { + raise(PyExc_RuntimeError, msg); + } + }; + + /* type mismatch in the return value from a python method call */ + class DirectorTypeMismatchException : public DirectorException { + public: + DirectorTypeMismatchException(PyObject *error, const char *msg="") + : DirectorException(error, "SWIG director type mismatch", msg) { + } + + DirectorTypeMismatchException(const char *msg="") + : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorTypeMismatchException(error, msg); + } + + static void raise(const char *msg) { + throw DirectorTypeMismatchException(msg); + } + }; + + /* any python exception that occurs during a director method call */ + class DirectorMethodException : public DirectorException { + public: + DirectorMethodException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { + } + + static void raise(const char *msg) { + throw DirectorMethodException(msg); + } + }; + + /* attempt to call a pure virtual method via a director method */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { + } + + static void raise(const char *msg) { + throw DirectorPureVirtualException(msg); + } + }; + + +#if defined(SWIG_PYTHON_THREADS) +/* __THREAD__ is the old macro to activate some thread support */ +# if !defined(__THREAD__) +# define __THREAD__ 1 +# endif +#endif + +#ifdef __THREAD__ +# include "pythread.h" + class Guard { + PyThread_type_lock &mutex_; + + public: + Guard(PyThread_type_lock & mutex) : mutex_(mutex) { + PyThread_acquire_lock(mutex_, WAIT_LOCK); + } + + ~Guard() { + PyThread_release_lock(mutex_); + } + }; +# define SWIG_GUARD(mutex) Guard _guard(mutex) +#else +# define SWIG_GUARD(mutex) +#endif + + /* director base class */ + class Director { + private: + /* pointer to the wrapped python object */ + PyObject *swig_self; + /* flag indicating whether the object is owned by python or c++ */ + mutable bool swig_disown_flag; + + /* decrement the reference count of the wrapped python object */ + void swig_decref() const { + if (swig_disown_flag) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_DECREF(swig_self); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + public: + /* wrap a python object. */ + Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { + } + + /* discard our reference at destruction */ + virtual ~Director() { + swig_decref(); + } + + /* return a pointer to the wrapped python object */ + PyObject *swig_get_self() const { + return swig_self; + } + + /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); + } + } + + /* increase the reference count of the wrapped python object */ + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); + } + } + + /* methods to implement pseudo protected director members */ + virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { + return true; + } + + virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { + } + + /* ownership management */ + private: + typedef std::map swig_ownership_map; + mutable swig_ownership_map swig_owner; +#ifdef __THREAD__ + static PyThread_type_lock swig_mutex_own; +#endif + + public: + template + void swig_acquire_ownership_array(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCArray_T(vptr); + } + } + + template + void swig_acquire_ownership(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_T(vptr); + } + } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_Object(own); + } + } + + int swig_release_ownership(void *vptr) const { + int own = 0; + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_ownership_map::iterator iter = swig_owner.find(vptr); + if (iter != swig_owner.end()) { + own = iter->second->get_own(); + swig_owner.erase(iter); + } + } + return own; + } + + template + static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { + SwigPyObject *sobj = (SwigPyObject *)pyobj; + sobj->own = 0; + Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); + if (d) + d->swig_disown(); + return PyWeakref_NewProxy(pyobj, NULL); + } + }; + +#ifdef __THREAD__ + PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock(); +#endif +} + +#endif + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[6] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[7] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[8] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[9] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[10] +#define SWIGTYPE_p_mfem__ElementRestriction swig_types[11] +#define SWIGTYPE_p_mfem__FiniteElementSpace swig_types[12] +#define SWIGTYPE_p_mfem__GridFunction swig_types[13] +#define SWIGTYPE_p_mfem__H1FaceRestriction swig_types[14] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[15] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[16] +#define SWIGTYPE_p_mfem__L2ElementRestriction swig_types[17] +#define SWIGTYPE_p_mfem__L2FaceRestriction swig_types[18] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[19] +#define SWIGTYPE_p_mfem__LinearForm swig_types[20] +#define SWIGTYPE_p_mfem__Matrix swig_types[21] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[22] +#define SWIGTYPE_p_mfem__Operator swig_types[23] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[24] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[25] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[26] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[27] +#define SWIGTYPE_p_mfem__QuadratureFunction swig_types[28] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[29] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[30] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[31] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[32] +#define SWIGTYPE_p_mfem__Solver swig_types[33] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[34] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[35] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[36] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[37] +#define SWIGTYPE_p_mfem__Vector swig_types[38] +#define SWIGTYPE_p_pri_t swig_types[39] +#define SWIGTYPE_p_quad_t swig_types[40] +#define SWIGTYPE_p_seg_t swig_types[41] +#define SWIGTYPE_p_tet_t swig_types[42] +#define SWIGTYPE_p_tri_t swig_types[43] +static swig_type_info *swig_types[45]; +static swig_module_info swig_module = {swig_types, 44, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#ifdef SWIG_TypeQuery +# undef SWIG_TypeQuery +#endif +#define SWIG_TypeQuery SWIG_Python_TypeQuery + +/*----------------------------------------------- + @(target):= _restriction.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__restriction + +#else +# define SWIG_init init_restriction + +#endif +#define SWIG_name "_restriction" + +#define SWIGVERSION 0x040001 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include "mfem.hpp" +#include "fem/restriction.hpp" +#include "numpy/arrayobject.h" +#include "pyoperator.hpp" + + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "restriction_wrap.h" + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + mfem::ElementRestriction *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_ElementRestriction", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + { + try { + result = (mfem::ElementRestriction *)new mfem::ElementRestriction((mfem::FiniteElementSpace const &)*arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ElementRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ElementRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTransposeUnsigned", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::ElementRestriction const *)arg1)->MultTransposeUnsigned((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElementRestriction" "', argument " "1"" of type '" "mfem::ElementRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *ElementRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ElementRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::L2ElementRestriction *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + { + try { + result = (mfem::L2ElementRestriction *)new mfem::L2ElementRestriction((mfem::FiniteElementSpace const &)*arg1); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2ElementRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2ElementRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2ElementRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_L2ElementRestriction" "', argument " "1"" of type '" "mfem::L2ElementRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *L2ElementRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__L2ElementRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *L2ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; + mfem::H1FaceRestriction *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_H1FaceRestriction", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_H1FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_H1FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::H1FaceRestriction *)new mfem::H1FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::H1FaceRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::H1FaceRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1FaceRestriction" "', argument " "1"" of type '" "mfem::H1FaceRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *H1FaceRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1FaceRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + mfem::L2FaceValues arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + mfem::L2FaceRestriction *result = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); + { + try { + result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = 0 ; + mfem::ElementDofOrdering arg2 ; + mfem::FaceType arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + mfem::L2FaceRestriction *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); + } + arg2 = static_cast< mfem::ElementDofOrdering >(val2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); + } + arg3 = static_cast< mfem::FaceType >(val3); + { + try { + result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2FaceRestriction", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_L2FaceRestriction__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_L2FaceRestriction__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2FaceRestriction'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const,mfem::L2FaceValues const)\n" + " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2FaceRestriction const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); + } + arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::L2FaceRestriction const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_L2FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_L2FaceRestriction" "', argument " "1"" of type '" "mfem::L2FaceRestriction *""'"); + } + arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *L2FaceRestriction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *L2FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + mfem::Array< int > *arg4 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetFaceDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GetFaceDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + try { + mfem::GetFaceDofs(arg1,arg2,arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + PyObject *swig_obj[4] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "ToLexOrdering", 4, 4, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + result = (int)mfem::ToLexOrdering(arg1,arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + int arg4 ; + int arg5 ; + int arg6 ; + PyObject *swig_obj[6] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "PermuteFaceL2", 6, 6, swig_obj)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + result = (int)mfem::PermuteFaceL2(arg1,arg2,arg3,arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "ElementRestriction_MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, + { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, + { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "L2ElementRestriction_Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "L2ElementRestriction_MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, + { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, + { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "H1FaceRestriction_Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "H1FaceRestriction_MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, + { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, + { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, + { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "L2FaceRestriction_Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "L2FaceRestriction_MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, + { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, + { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, + { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, + { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, + { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, + { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, + { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, + { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, + { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, + { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, + { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, + { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, + { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static void *_p_mfem__GridFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::GridFunction *) x)); +} +static void *_p_mfem__QuadratureFunctionTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::QuadratureFunction *) x)); +} +static void *_p_mfem__LinearFormTo_p_mfem__Vector(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Vector *) ((mfem::LinearForm *) x)); +} +static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); +} +static void *_p_mfem__PyOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::PyOperatorBase *) x)); +} +static void *_p_mfem__MatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::MatrixInverse *) x)); +} +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +} +static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Solver *) x)); +} +static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); +} +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} +static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); +} +static void *_p_mfem__ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ElementRestriction *) x)); +} +static void *_p_mfem__L2ElementRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2ElementRestriction *) x)); +} +static void *_p_mfem__H1FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::H1FaceRestriction *) x)); +} +static void *_p_mfem__L2FaceRestrictionTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::L2FaceRestriction *) x)); +} +static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); +} +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} +static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); +} +static void *_p_mfem__TripleProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TripleProductOperator *) x)); +} +static void *_p_mfem__RAPOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RAPOperator *) x)); +} +static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ProductOperator *) x)); +} +static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); +} +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} +static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); +} +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} +static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); +} +static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_intp = {"_p_intp", "intp *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ElementRestriction = {"_p_mfem__ElementRestriction", "mfem::ElementRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__FiniteElementSpace = {"_p_mfem__FiniteElementSpace", "mfem::FiniteElementSpace *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__GridFunction = {"_p_mfem__GridFunction", "mfem::GridFunction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__H1FaceRestriction = {"_p_mfem__H1FaceRestriction", "mfem::H1FaceRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__IntegrationRule = {"_p_mfem__IntegrationRule", "mfem::IntegrationRule *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__L2ElementRestriction = {"_p_mfem__L2ElementRestriction", "mfem::L2ElementRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__L2FaceRestriction = {"_p_mfem__L2FaceRestriction", "mfem::L2FaceRestriction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__L2_FECollection = {"_p_mfem__L2_FECollection", "mfem::L2_FECollection *|mfem::DG_FECollection *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorPtr *|mfem::OperatorHandle *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__Vector = {"_p_mfem__Vector", "mfem::Vector *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__QuadratureFunction = {"_p_mfem__QuadratureFunction", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__LinearForm = {"_p_mfem__LinearForm", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_pri_t = {"_p_pri_t", "pri_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_quad_t = {"_p_quad_t", "quad_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_seg_t = {"_p_seg_t", "seg_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_tet_t = {"_p_tet_t", "tet_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, + &_swigt__p_char, + &_swigt__p_doublep, + &_swigt__p_hex_t, + &_swigt__p_intp, + &_swigt__p_mfem__AbstractSparseMatrix, + &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_mfem__ConstrainedOperator, + &_swigt__p_mfem__DenseMatrix, + &_swigt__p_mfem__DenseMatrixInverse, + &_swigt__p_mfem__ElementRestriction, + &_swigt__p_mfem__FiniteElementSpace, + &_swigt__p_mfem__GridFunction, + &_swigt__p_mfem__H1FaceRestriction, + &_swigt__p_mfem__IdentityOperator, + &_swigt__p_mfem__IntegrationRule, + &_swigt__p_mfem__L2ElementRestriction, + &_swigt__p_mfem__L2FaceRestriction, + &_swigt__p_mfem__L2_FECollection, + &_swigt__p_mfem__LinearForm, + &_swigt__p_mfem__Matrix, + &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__Operator, + &_swigt__p_mfem__OperatorHandle, + &_swigt__p_mfem__ProductOperator, + &_swigt__p_mfem__PyOperatorBase, + &_swigt__p_mfem__PyTimeDependentOperatorBase, + &_swigt__p_mfem__QuadratureFunction, + &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, + &_swigt__p_mfem__Solver, + &_swigt__p_mfem__SparseMatrix, + &_swigt__p_mfem__TimeDependentOperator, + &_swigt__p_mfem__TransposeOperator, + &_swigt__p_mfem__TripleProductOperator, + &_swigt__p_mfem__Vector, + &_swigt__p_pri_t, + &_swigt__p_quad_t, + &_swigt__p_seg_t, + &_swigt__p_tet_t, + &_swigt__p_tri_t, +}; + +static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_intp[] = { {&_swigt__p_intp, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ElementRestriction[] = { {&_swigt__p_mfem__ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__FiniteElementSpace[] = { {&_swigt__p_mfem__FiniteElementSpace, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__GridFunction[] = { {&_swigt__p_mfem__GridFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__H1FaceRestriction[] = { {&_swigt__p_mfem__H1FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IntegrationRule[] = { {&_swigt__p_mfem__IntegrationRule, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2ElementRestriction[] = { {&_swigt__p_mfem__L2ElementRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2FaceRestriction[] = { {&_swigt__p_mfem__L2FaceRestriction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__L2_FECollection[] = { {&_swigt__p_mfem__L2_FECollection, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SparseMatrix[] = {{&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ElementRestriction, _p_mfem__ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2ElementRestriction, _p_mfem__L2ElementRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__H1FaceRestriction, _p_mfem__H1FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__L2FaceRestriction, _p_mfem__L2FaceRestrictionTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__QuadratureFunction[] = {{&_swigt__p_mfem__QuadratureFunction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__LinearForm[] = {{&_swigt__p_mfem__LinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0}, {&_swigt__p_mfem__GridFunction, _p_mfem__GridFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__QuadratureFunction, _p_mfem__QuadratureFunctionTo_p_mfem__Vector, 0, 0}, {&_swigt__p_mfem__LinearForm, _p_mfem__LinearFormTo_p_mfem__Vector, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_pri_t[] = { {&_swigt__p_pri_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_quad_t[] = { {&_swigt__p_quad_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_seg_t[] = { {&_swigt__p_seg_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_tet_t[] = { {&_swigt__p_tet_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, + _swigc__p_char, + _swigc__p_doublep, + _swigc__p_hex_t, + _swigc__p_intp, + _swigc__p_mfem__AbstractSparseMatrix, + _swigc__p_mfem__ArrayT_int_t, + _swigc__p_mfem__ConstrainedOperator, + _swigc__p_mfem__DenseMatrix, + _swigc__p_mfem__DenseMatrixInverse, + _swigc__p_mfem__ElementRestriction, + _swigc__p_mfem__FiniteElementSpace, + _swigc__p_mfem__GridFunction, + _swigc__p_mfem__H1FaceRestriction, + _swigc__p_mfem__IdentityOperator, + _swigc__p_mfem__IntegrationRule, + _swigc__p_mfem__L2ElementRestriction, + _swigc__p_mfem__L2FaceRestriction, + _swigc__p_mfem__L2_FECollection, + _swigc__p_mfem__LinearForm, + _swigc__p_mfem__Matrix, + _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__Operator, + _swigc__p_mfem__OperatorHandle, + _swigc__p_mfem__ProductOperator, + _swigc__p_mfem__PyOperatorBase, + _swigc__p_mfem__PyTimeDependentOperatorBase, + _swigc__p_mfem__QuadratureFunction, + _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, + _swigc__p_mfem__Solver, + _swigc__p_mfem__SparseMatrix, + _swigc__p_mfem__TimeDependentOperator, + _swigc__p_mfem__TransposeOperator, + _swigc__p_mfem__TripleProductOperator, + _swigc__p_mfem__Vector, + _swigc__p_pri_t, + _swigc__p_quad_t, + _swigc__p_seg_t, + _swigc__p_tet_t, + _swigc__p_tri_t, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *globals = 0; + if (!globals) { + globals = SWIG_newvarlink(); + } + return globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (!c) continue; + c = strstr(c, "swig_ptr: "); + if (c) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + memcpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + memcpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + + /* ----------------------------------------------------------------------------- + * Method creation and docstring support functions + * ----------------------------------------------------------------------------- */ + + /* ----------------------------------------------------------------------------- + * Function to find the method definition with the correct docstring for the + * proxy module as opposed to the low-level API + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) { + /* Find the function in the modified method table */ + size_t offset = 0; + int found = 0; + while (SwigMethods_proxydocs[offset].ml_meth != NULL) { + if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) { + found = 1; + break; + } + offset++; + } + /* Use the copy with the modified docstring if available */ + return found ? &SwigMethods_proxydocs[offset] : NULL; + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyInstanceMethod_New() used in Python 3 + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } +#if PY_VERSION_HEX >= 0x03000000 + return PyInstanceMethod_New(func); +#else + return PyMethod_New(func, NULL, NULL); +#endif + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyStaticMethod_New() + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } + return PyStaticMethod_New(func); + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md, *globals; + +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { + PyModuleDef_HEAD_INIT, + SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + SwigPyObject_own, + SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + PyTypeObject *swigpyobject; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + PyObject *self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); + assert(metatype); +#endif + + (void)globals; + + /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */ + SWIG_This(); + SWIG_Python_TypeCache(); + SwigPyPacked_type(); +#ifndef SWIGPYTHON_BUILTIN + SwigPyObject_type(); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule(SWIG_name, SwigMethods); +#endif + + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + swigpyobject = SwigPyObject_TypeOnce(); + + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = swigpyobject; + } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + + import_array(); + + SWIG_Python_SetConstant(d, "L2FaceValues_SingleValued",SWIG_From_int(static_cast< int >(mfem::L2FaceValues::SingleValued))); + SWIG_Python_SetConstant(d, "L2FaceValues_DoubleValued",SWIG_From_int(static_cast< int >(mfem::L2FaceValues::DoubleValued))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/mfem/_ser/restriction_wrap.h b/mfem/_ser/restriction_wrap.h new file mode 100644 index 00000000..9b86ae20 --- /dev/null +++ b/mfem/_ser/restriction_wrap.h @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_restriction_WRAP_H_ +#define SWIG_restriction_WRAP_H_ + +#include +#include + + +#endif diff --git a/mfem/_ser/segment.py b/mfem/_ser/segment.py index 0ce7c3dd..3c7e89b4 100644 --- a/mfem/_ser/segment.py +++ b/mfem/_ser/segment.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _segment.SWIG_PyInstanceMethod_New +_swig_new_static_method = _segment.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -91,10 +94,12 @@ def __init__(self, *args): def SetVertices(self, ind): r"""SetVertices(Segment self, int const * ind)""" return _segment.Segment_SetVertices(self, ind) + SetVertices = _swig_new_instance_method(_segment.Segment_SetVertices) def GetType(self): r"""GetType(Segment self) -> mfem::Element::Type""" return _segment.Segment_GetType(self) + GetType = _swig_new_instance_method(_segment.Segment_GetType) def GetVertices(self, *args): r""" @@ -102,30 +107,45 @@ def GetVertices(self, *args): GetVertices(Segment self) -> int * """ return _segment.Segment_GetVertices(self, *args) + GetVertices = _swig_new_instance_method(_segment.Segment_GetVertices) def GetNVertices(self): r"""GetNVertices(Segment self) -> int""" return _segment.Segment_GetNVertices(self) + GetNVertices = _swig_new_instance_method(_segment.Segment_GetNVertices) def GetNEdges(self): r"""GetNEdges(Segment self) -> int""" return _segment.Segment_GetNEdges(self) + GetNEdges = _swig_new_instance_method(_segment.Segment_GetNEdges) def GetEdgeVertices(self, ei): r"""GetEdgeVertices(Segment self, int ei) -> int const *""" return _segment.Segment_GetEdgeVertices(self, ei) + GetEdgeVertices = _swig_new_instance_method(_segment.Segment_GetEdgeVertices) + + def GetNFaces(self, *args): + r""" + GetNFaces(Segment self, int & nFaceVertices) -> int + GetNFaces(Segment self) -> int + """ + return _segment.Segment_GetNFaces(self, *args) + GetNFaces = _swig_new_instance_method(_segment.Segment_GetNFaces) - def GetNFaces(self, nFaceVertices): - r"""GetNFaces(Segment self, int & nFaceVertices) -> int""" - return _segment.Segment_GetNFaces(self, nFaceVertices) + def GetNFaceVertices(self, arg2): + r"""GetNFaceVertices(Segment self, int arg2) -> int""" + return _segment.Segment_GetNFaceVertices(self, arg2) + GetNFaceVertices = _swig_new_instance_method(_segment.Segment_GetNFaceVertices) def GetFaceVertices(self, fi): r"""GetFaceVertices(Segment self, int fi) -> int const *""" return _segment.Segment_GetFaceVertices(self, fi) + GetFaceVertices = _swig_new_instance_method(_segment.Segment_GetFaceVertices) def Duplicate(self, m): r"""Duplicate(Segment self, mfem::Mesh * m) -> Element""" return _segment.Segment_Duplicate(self, m) + Duplicate = _swig_new_instance_method(_segment.Segment_Duplicate) __swig_destroy__ = _segment.delete_Segment # Register Segment in _segment: diff --git a/mfem/_ser/segment_wrap.cxx b/mfem/_ser/segment_wrap.cxx index c8028f36..f791c049 100644 --- a/mfem/_ser/segment_wrap.cxx +++ b/mfem/_ser/segment_wrap.cxx @@ -3939,7 +3939,7 @@ SWIGINTERN PyObject *_wrap_Segment_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetNFaces__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int *arg2 = 0 ; @@ -3947,10 +3947,9 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; int result; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetNFaces", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaces" "', argument " "1"" of type '" "mfem::Segment const *""'"); @@ -3990,6 +3989,133 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyO } +SWIGINTERN PyObject *_wrap_Segment_GetNFaces__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Segment *arg1 = (mfem::Segment *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int result; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaces" "', argument " "1"" of type '" "mfem::Segment const *""'"); + } + arg1 = reinterpret_cast< mfem::Segment * >(argp1); + { + try { + result = (int)((mfem::Segment const *)arg1)->GetNFaces(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Segment_GetNFaces", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Segment, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Segment_GetNFaces__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Segment, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Segment_GetNFaces__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Segment_GetNFaces'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Segment::GetNFaces(int &) const\n" + " mfem::Segment::GetNFaces() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Segment *arg1 = (mfem::Segment *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[2] ; + int result; + + if (!SWIG_Python_UnpackTuple(args, "Segment_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); + } + arg1 = reinterpret_cast< mfem::Segment * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (int)((mfem::Segment const *)arg1)->GetNFaceVertices(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; @@ -4168,6 +4294,7 @@ SWIGINTERN PyObject *Swig_var_SegmentFE_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" "Segment()\n" "Segment(int const * ind, int attr=1)\n" @@ -4182,7 +4309,11 @@ static PyMethodDef SwigMethods[] = { { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "Segment_GetNVertices(Segment self) -> int"}, { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "Segment_GetNEdges(Segment self) -> int"}, { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "Segment_GetEdgeVertices(Segment self, int ei) -> int const *"}, - { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "Segment_GetNFaces(Segment self, int & nFaceVertices) -> int"}, + { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" + "Segment_GetNFaces(Segment self, int & nFaceVertices) -> int\n" + "Segment_GetNFaces(Segment self) -> int\n" + ""}, + { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "Segment_GetNFaceVertices(Segment self, int arg2) -> int"}, { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "Segment_GetFaceVertices(Segment self, int fi) -> int const *"}, { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Segment_Duplicate(Segment self, mfem::Mesh * m) -> Element"}, { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, @@ -4192,6 +4323,32 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" + "Segment()\n" + "Segment(int const * ind, int attr=1)\n" + "Segment(int ind1, int ind2, int attr=1)\n" + ""}, + { "Segment_SetVertices", _wrap_Segment_SetVertices, METH_VARARGS, "SetVertices(Segment self, int const * ind)"}, + { "Segment_GetType", _wrap_Segment_GetType, METH_O, "GetType(Segment self) -> mfem::Element::Type"}, + { "Segment_GetVertices", _wrap_Segment_GetVertices, METH_VARARGS, "\n" + "GetVertices(Segment self, intArray v)\n" + "GetVertices(Segment self) -> int *\n" + ""}, + { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "GetNVertices(Segment self) -> int"}, + { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "GetNEdges(Segment self) -> int"}, + { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Segment self, int ei) -> int const *"}, + { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" + "GetNFaces(Segment self, int & nFaceVertices) -> int\n" + "GetNFaces(Segment self) -> int\n" + ""}, + { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Segment self, int arg2) -> int"}, + { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Segment self, int fi) -> int const *"}, + { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Duplicate(Segment self, mfem::Mesh * m) -> Element"}, + { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, + { "Segment_swigregister", Segment_swigregister, METH_O, NULL}, + { "Segment_swiginit", Segment_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/sets.py b/mfem/_ser/sets.py index 0734ba5e..c6c2d8de 100644 --- a/mfem/_ser/sets.py +++ b/mfem/_ser/sets.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _sets.SWIG_PyInstanceMethod_New +_swig_new_static_method = _sets.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -81,22 +84,27 @@ def __init__(self, *args): def Size(self): r"""Size(IntegerSet self) -> int""" return _sets.IntegerSet_Size(self) + Size = _swig_new_instance_method(_sets.IntegerSet_Size) def PickElement(self): r"""PickElement(IntegerSet self) -> int""" return _sets.IntegerSet_PickElement(self) + PickElement = _swig_new_instance_method(_sets.IntegerSet_PickElement) def PickRandomElement(self): r"""PickRandomElement(IntegerSet self) -> int""" return _sets.IntegerSet_PickRandomElement(self) + PickRandomElement = _swig_new_instance_method(_sets.IntegerSet_PickRandomElement) def __eq__(self, s): r"""__eq__(IntegerSet self, IntegerSet s) -> int""" return _sets.IntegerSet___eq__(self, s) + __eq__ = _swig_new_instance_method(_sets.IntegerSet___eq__) def Recreate(self, n, p): r"""Recreate(IntegerSet self, int const n, int const * p)""" return _sets.IntegerSet_Recreate(self, n, p) + Recreate = _swig_new_instance_method(_sets.IntegerSet_Recreate) __swig_destroy__ = _sets.delete_IntegerSet # Register IntegerSet in _sets: @@ -111,26 +119,32 @@ class ListOfIntegerSets(object): def Size(self): r"""Size(ListOfIntegerSets self) -> int""" return _sets.ListOfIntegerSets_Size(self) + Size = _swig_new_instance_method(_sets.ListOfIntegerSets_Size) def PickElementInSet(self, i): r"""PickElementInSet(ListOfIntegerSets self, int i) -> int""" return _sets.ListOfIntegerSets_PickElementInSet(self, i) + PickElementInSet = _swig_new_instance_method(_sets.ListOfIntegerSets_PickElementInSet) def PickRandomElementInSet(self, i): r"""PickRandomElementInSet(ListOfIntegerSets self, int i) -> int""" return _sets.ListOfIntegerSets_PickRandomElementInSet(self, i) + PickRandomElementInSet = _swig_new_instance_method(_sets.ListOfIntegerSets_PickRandomElementInSet) def Insert(self, s): r"""Insert(ListOfIntegerSets self, IntegerSet s) -> int""" return _sets.ListOfIntegerSets_Insert(self, s) + Insert = _swig_new_instance_method(_sets.ListOfIntegerSets_Insert) def Lookup(self, s): r"""Lookup(ListOfIntegerSets self, IntegerSet s) -> int""" return _sets.ListOfIntegerSets_Lookup(self, s) + Lookup = _swig_new_instance_method(_sets.ListOfIntegerSets_Lookup) def AsTable(self, t): r"""AsTable(ListOfIntegerSets self, Table t)""" return _sets.ListOfIntegerSets_AsTable(self, t) + AsTable = _swig_new_instance_method(_sets.ListOfIntegerSets_AsTable) __swig_destroy__ = _sets.delete_ListOfIntegerSets def __init__(self): diff --git a/mfem/_ser/sets_wrap.cxx b/mfem/_ser/sets_wrap.cxx index 54ad47af..1e7f5756 100644 --- a/mfem/_ser/sets_wrap.cxx +++ b/mfem/_ser/sets_wrap.cxx @@ -3555,6 +3555,7 @@ SWIGINTERN PyObject *ListOfIntegerSets_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_IntegerSet", _wrap_new_IntegerSet, METH_VARARGS, "\n" "IntegerSet()\n" "IntegerSet(IntegerSet s)\n" @@ -3582,6 +3583,31 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_IntegerSet", _wrap_new_IntegerSet, METH_VARARGS, "\n" + "IntegerSet()\n" + "IntegerSet(IntegerSet s)\n" + "new_IntegerSet(int const n, int const * p) -> IntegerSet\n" + ""}, + { "IntegerSet_Size", _wrap_IntegerSet_Size, METH_O, "Size(IntegerSet self) -> int"}, + { "IntegerSet_PickElement", _wrap_IntegerSet_PickElement, METH_O, "PickElement(IntegerSet self) -> int"}, + { "IntegerSet_PickRandomElement", _wrap_IntegerSet_PickRandomElement, METH_O, "PickRandomElement(IntegerSet self) -> int"}, + { "IntegerSet___eq__", _wrap_IntegerSet___eq__, METH_VARARGS, "__eq__(IntegerSet self, IntegerSet s) -> int"}, + { "IntegerSet_Recreate", _wrap_IntegerSet_Recreate, METH_VARARGS, "Recreate(IntegerSet self, int const n, int const * p)"}, + { "delete_IntegerSet", _wrap_delete_IntegerSet, METH_O, "delete_IntegerSet(IntegerSet self)"}, + { "IntegerSet_swigregister", IntegerSet_swigregister, METH_O, NULL}, + { "IntegerSet_swiginit", IntegerSet_swiginit, METH_VARARGS, NULL}, + { "ListOfIntegerSets_Size", _wrap_ListOfIntegerSets_Size, METH_O, "Size(ListOfIntegerSets self) -> int"}, + { "ListOfIntegerSets_PickElementInSet", _wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS, "PickElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_PickRandomElementInSet", _wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS, "PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_Insert", _wrap_ListOfIntegerSets_Insert, METH_VARARGS, "Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_Lookup", _wrap_ListOfIntegerSets_Lookup, METH_VARARGS, "Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_AsTable", _wrap_ListOfIntegerSets_AsTable, METH_VARARGS, "AsTable(ListOfIntegerSets self, Table t)"}, + { "delete_ListOfIntegerSets", _wrap_delete_ListOfIntegerSets, METH_O, "delete_ListOfIntegerSets(ListOfIntegerSets self)"}, + { "new_ListOfIntegerSets", _wrap_new_ListOfIntegerSets, METH_NOARGS, "new_ListOfIntegerSets() -> ListOfIntegerSets"}, + { "ListOfIntegerSets_swigregister", ListOfIntegerSets_swigregister, METH_O, NULL}, + { "ListOfIntegerSets_swiginit", ListOfIntegerSets_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/setup.py b/mfem/_ser/setup.py index 54504889..ec5392ff 100644 --- a/mfem/_ser/setup.py +++ b/mfem/_ser/setup.py @@ -22,7 +22,7 @@ from distutils.core import * from distutils import sysconfig -modules= ["io_stream", +modules= ["io_stream", "vtk", "globals", "mem_manager", "device", "hash", "stable3d", "error", "array", "common_functions", "socketstream", "handle", "segment", "point", @@ -36,7 +36,7 @@ "solvers", "estimators", "mesh_operators", "ode", "sparsesmoothers", "matrix", "operators", "ncmesh", "eltrans", "geom", - "nonlininteg", "nonlinearform",] + "nonlininteg", "nonlinearform", "restriction"] sources = {name: [name + "_wrap.cxx"] for name in modules} proxy_names = {name: '_'+name for name in modules} diff --git a/mfem/_ser/socketstream.py b/mfem/_ser/socketstream.py index 6ee42dca..4b6ebde9 100644 --- a/mfem/_ser/socketstream.py +++ b/mfem/_ser/socketstream.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _socketstream.SWIG_PyInstanceMethod_New +_swig_new_static_method = _socketstream.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,12 +85,14 @@ class _SwigNonDynamicMeta(type): import mfem._ser.fe_coll import mfem._ser.lininteg import mfem._ser.handle -import mfem._ser.bilininteg -import mfem._ser.linearform +import mfem._ser.restriction import mfem._ser.element import mfem._ser.table import mfem._ser.hash +import mfem._ser.bilininteg +import mfem._ser.linearform import mfem._ser.vertex +import mfem._ser.vtk class socketbuf(object): r"""Proxy of C++ mfem::socketbuf class.""" @@ -105,26 +110,32 @@ def __init__(self, *args): def attach(self, sd): r"""attach(socketbuf self, int sd) -> int""" return _socketstream.socketbuf_attach(self, sd) + attach = _swig_new_instance_method(_socketstream.socketbuf_attach) def detach(self): r"""detach(socketbuf self) -> int""" return _socketstream.socketbuf_detach(self) + detach = _swig_new_instance_method(_socketstream.socketbuf_detach) def open(self, hostname, port): r"""open(socketbuf self, char const [] hostname, int port) -> int""" return _socketstream.socketbuf_open(self, hostname, port) + open = _swig_new_instance_method(_socketstream.socketbuf_open) def close(self): r"""close(socketbuf self) -> int""" return _socketstream.socketbuf_close(self) + close = _swig_new_instance_method(_socketstream.socketbuf_close) def getsocketdescriptor(self): r"""getsocketdescriptor(socketbuf self) -> int""" return _socketstream.socketbuf_getsocketdescriptor(self) + getsocketdescriptor = _swig_new_instance_method(_socketstream.socketbuf_getsocketdescriptor) def is_open(self): r"""is_open(socketbuf self) -> bool""" return _socketstream.socketbuf_is_open(self) + is_open = _swig_new_instance_method(_socketstream.socketbuf_is_open) __swig_destroy__ = _socketstream.delete_socketbuf # Register socketbuf in _socketstream: @@ -150,18 +161,22 @@ def __init__(self, *args): def rdbuf(self): r"""rdbuf(socketstream self) -> socketbuf""" return _socketstream.socketstream_rdbuf(self) + rdbuf = _swig_new_instance_method(_socketstream.socketstream_rdbuf) def open(self, hostname, port): r"""open(socketstream self, char const [] hostname, int port) -> int""" return _socketstream.socketstream_open(self, hostname, port) + open = _swig_new_instance_method(_socketstream.socketstream_open) def close(self): r"""close(socketstream self) -> int""" return _socketstream.socketstream_close(self) + close = _swig_new_instance_method(_socketstream.socketstream_close) def is_open(self): r"""is_open(socketstream self) -> bool""" return _socketstream.socketstream_is_open(self) + is_open = _swig_new_instance_method(_socketstream.socketstream_is_open) __swig_destroy__ = _socketstream.delete_socketstream def precision(self, *args): @@ -170,18 +185,22 @@ def precision(self, *args): precision(socketstream self) -> int """ return _socketstream.socketstream_precision(self, *args) + precision = _swig_new_instance_method(_socketstream.socketstream_precision) def send_solution(self, mesh, gf): r"""send_solution(socketstream self, Mesh mesh, GridFunction gf)""" return _socketstream.socketstream_send_solution(self, mesh, gf) + send_solution = _swig_new_instance_method(_socketstream.socketstream_send_solution) def send_text(self, ostr): r"""send_text(socketstream self, char const [] ostr)""" return _socketstream.socketstream_send_text(self, ostr) + send_text = _swig_new_instance_method(_socketstream.socketstream_send_text) def flush(self): r"""flush(socketstream self)""" return _socketstream.socketstream_flush(self) + flush = _swig_new_instance_method(_socketstream.socketstream_flush) def __lshift__(self, *args): r""" @@ -191,10 +210,12 @@ def __lshift__(self, *args): __lshift__(socketstream self, GridFunction gf) -> socketstream """ return _socketstream.socketstream___lshift__(self, *args) + __lshift__ = _swig_new_instance_method(_socketstream.socketstream___lshift__) def endline(self): r"""endline(socketstream self) -> socketstream""" return _socketstream.socketstream_endline(self) + endline = _swig_new_instance_method(_socketstream.socketstream_endline) # Register socketstream in _socketstream: _socketstream.socketstream_swigregister(socketstream) @@ -212,10 +233,12 @@ def __init__(self, port, backlog=4): def good(self): r"""good(socketserver self) -> bool""" return _socketstream.socketserver_good(self) + good = _swig_new_instance_method(_socketstream.socketserver_good) def close(self): r"""close(socketserver self) -> int""" return _socketstream.socketserver_close(self) + close = _swig_new_instance_method(_socketstream.socketserver_close) def accept(self, *args): r""" @@ -223,6 +246,7 @@ def accept(self, *args): accept(socketserver self, socketstream sockstr) -> int """ return _socketstream.socketserver_accept(self, *args) + accept = _swig_new_instance_method(_socketstream.socketserver_accept) __swig_destroy__ = _socketstream.delete_socketserver # Register socketserver in _socketstream: diff --git a/mfem/_ser/socketstream_wrap.cxx b/mfem/_ser/socketstream_wrap.cxx index c7aa009b..ba0faf81 100644 --- a/mfem/_ser/socketstream_wrap.cxx +++ b/mfem/_ser/socketstream_wrap.cxx @@ -3066,25 +3066,26 @@ namespace Swig { /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] -#define SWIGTYPE_p_char swig_types[1] -#define SWIGTYPE_p_doublep swig_types[2] -#define SWIGTYPE_p_hex_t swig_types[3] -#define SWIGTYPE_p_intp swig_types[4] -#define SWIGTYPE_p_mfem__GridFunction swig_types[5] -#define SWIGTYPE_p_mfem__IntegrationRule swig_types[6] -#define SWIGTYPE_p_mfem__L2_FECollection swig_types[7] -#define SWIGTYPE_p_mfem__Mesh swig_types[8] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[9] -#define SWIGTYPE_p_mfem__socketbuf swig_types[10] -#define SWIGTYPE_p_mfem__socketserver swig_types[11] -#define SWIGTYPE_p_mfem__socketstream swig_types[12] -#define SWIGTYPE_p_pri_t swig_types[13] -#define SWIGTYPE_p_quad_t swig_types[14] -#define SWIGTYPE_p_seg_t swig_types[15] -#define SWIGTYPE_p_tet_t swig_types[16] -#define SWIGTYPE_p_tri_t swig_types[17] -static swig_type_info *swig_types[19]; -static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0}; +#define SWIGTYPE_p_RefCoord swig_types[1] +#define SWIGTYPE_p_char swig_types[2] +#define SWIGTYPE_p_doublep swig_types[3] +#define SWIGTYPE_p_hex_t swig_types[4] +#define SWIGTYPE_p_intp swig_types[5] +#define SWIGTYPE_p_mfem__GridFunction swig_types[6] +#define SWIGTYPE_p_mfem__IntegrationRule swig_types[7] +#define SWIGTYPE_p_mfem__L2_FECollection swig_types[8] +#define SWIGTYPE_p_mfem__Mesh swig_types[9] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[10] +#define SWIGTYPE_p_mfem__socketbuf swig_types[11] +#define SWIGTYPE_p_mfem__socketserver swig_types[12] +#define SWIGTYPE_p_mfem__socketstream swig_types[13] +#define SWIGTYPE_p_pri_t swig_types[14] +#define SWIGTYPE_p_quad_t swig_types[15] +#define SWIGTYPE_p_seg_t swig_types[16] +#define SWIGTYPE_p_tet_t swig_types[17] +#define SWIGTYPE_p_tri_t swig_types[18] +static swig_type_info *swig_types[20]; +static swig_module_info swig_module = {swig_types, 19, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5664,6 +5665,7 @@ SWIGINTERN PyObject *socketserver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_socketbuf", _wrap_new_socketbuf, METH_VARARGS, "\n" "socketbuf()\n" "socketbuf(int sd)\n" @@ -5719,6 +5721,59 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_socketbuf", _wrap_new_socketbuf, METH_VARARGS, "\n" + "socketbuf()\n" + "socketbuf(int sd)\n" + "new_socketbuf(char const [] hostname, int port) -> socketbuf\n" + ""}, + { "socketbuf_attach", _wrap_socketbuf_attach, METH_VARARGS, "attach(socketbuf self, int sd) -> int"}, + { "socketbuf_detach", _wrap_socketbuf_detach, METH_O, "detach(socketbuf self) -> int"}, + { "socketbuf_open", _wrap_socketbuf_open, METH_VARARGS, "open(socketbuf self, char const [] hostname, int port) -> int"}, + { "socketbuf_close", _wrap_socketbuf_close, METH_O, "close(socketbuf self) -> int"}, + { "socketbuf_getsocketdescriptor", _wrap_socketbuf_getsocketdescriptor, METH_O, "getsocketdescriptor(socketbuf self) -> int"}, + { "socketbuf_is_open", _wrap_socketbuf_is_open, METH_O, "is_open(socketbuf self) -> bool"}, + { "delete_socketbuf", _wrap_delete_socketbuf, METH_O, "delete_socketbuf(socketbuf self)"}, + { "socketbuf_swigregister", socketbuf_swigregister, METH_O, NULL}, + { "socketbuf_swiginit", socketbuf_swiginit, METH_VARARGS, NULL}, + { "new_socketstream", _wrap_new_socketstream, METH_VARARGS, "\n" + "socketstream(bool secure=secure_default)\n" + "socketstream(socketbuf buf)\n" + "socketstream(int s, bool secure=secure_default)\n" + "socketstream(char const [] hostname, int port, bool secure=secure_default)\n" + ""}, + { "socketstream_rdbuf", _wrap_socketstream_rdbuf, METH_O, "rdbuf(socketstream self) -> socketbuf"}, + { "socketstream_open", _wrap_socketstream_open, METH_VARARGS, "open(socketstream self, char const [] hostname, int port) -> int"}, + { "socketstream_close", _wrap_socketstream_close, METH_O, "close(socketstream self) -> int"}, + { "socketstream_is_open", _wrap_socketstream_is_open, METH_O, "is_open(socketstream self) -> bool"}, + { "delete_socketstream", _wrap_delete_socketstream, METH_O, "delete_socketstream(socketstream self)"}, + { "socketstream_precision", _wrap_socketstream_precision, METH_VARARGS, "\n" + "precision(socketstream self, int const p) -> int\n" + "precision(socketstream self) -> int\n" + ""}, + { "socketstream_send_solution", _wrap_socketstream_send_solution, METH_VARARGS, "send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, + { "socketstream_send_text", _wrap_socketstream_send_text, METH_VARARGS, "send_text(socketstream self, char const [] ostr)"}, + { "socketstream_flush", _wrap_socketstream_flush, METH_O, "flush(socketstream self)"}, + { "socketstream___lshift__", _wrap_socketstream___lshift__, METH_VARARGS, "\n" + "__lshift__(socketstream self, char const [] ostr) -> socketstream\n" + "__lshift__(socketstream self, int const x) -> socketstream\n" + "__lshift__(socketstream self, Mesh mesh) -> socketstream\n" + "__lshift__(socketstream self, GridFunction gf) -> socketstream\n" + ""}, + { "socketstream_endline", _wrap_socketstream_endline, METH_O, "endline(socketstream self) -> socketstream"}, + { "socketstream_swigregister", socketstream_swigregister, METH_O, NULL}, + { "socketstream_swiginit", socketstream_swiginit, METH_VARARGS, NULL}, + { "new_socketserver", _wrap_new_socketserver, METH_VARARGS, "socketserver(int port, int backlog=4)"}, + { "socketserver_good", _wrap_socketserver_good, METH_O, "good(socketserver self) -> bool"}, + { "socketserver_close", _wrap_socketserver_close, METH_O, "close(socketserver self) -> int"}, + { "socketserver_accept", _wrap_socketserver_accept, METH_VARARGS, "\n" + "accept(socketserver self) -> int\n" + "accept(socketserver self, socketstream sockstr) -> int\n" + ""}, + { "delete_socketserver", _wrap_delete_socketserver, METH_O, "delete_socketserver(socketserver self)"}, + { "socketserver_swigregister", socketserver_swigregister, METH_O, NULL}, + { "socketserver_swiginit", socketserver_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -5726,6 +5781,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_RefCoord = {"_p_RefCoord", "RefCoord *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_doublep = {"_p_doublep", "doublep *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_hex_t = {"_p_hex_t", "hex_t *", 0, 0, (void*)0, 0}; @@ -5746,6 +5802,7 @@ static swig_type_info _swigt__p_tri_t = {"_p_tri_t", "tri_t *", 0, 0, (void*)0, static swig_type_info *swig_type_initial[] = { &_swigt__p_PyMFEM__wFILE, + &_swigt__p_RefCoord, &_swigt__p_char, &_swigt__p_doublep, &_swigt__p_hex_t, @@ -5766,6 +5823,7 @@ static swig_type_info *swig_type_initial[] = { }; static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_RefCoord[] = { {&_swigt__p_RefCoord, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_doublep[] = { {&_swigt__p_doublep, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_hex_t[] = { {&_swigt__p_hex_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -5786,6 +5844,7 @@ static swig_cast_info _swigc__p_tri_t[] = { {&_swigt__p_tri_t, 0, 0, 0},{0, 0, static swig_cast_info *swig_cast_initial[] = { _swigc__p_PyMFEM__wFILE, + _swigc__p_RefCoord, _swigc__p_char, _swigc__p_doublep, _swigc__p_hex_t, diff --git a/mfem/_ser/solvers.py b/mfem/_ser/solvers.py index a16652a2..ea5c2e8b 100644 --- a/mfem/_ser/solvers.py +++ b/mfem/_ser/solvers.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _solvers.SWIG_PyInstanceMethod_New +_swig_new_static_method = _solvers.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,43 +85,84 @@ def __init__(self, *args, **kwargs): def SetRelTol(self, rtol): r"""SetRelTol(IterativeSolver self, double rtol)""" return _solvers.IterativeSolver_SetRelTol(self, rtol) + SetRelTol = _swig_new_instance_method(_solvers.IterativeSolver_SetRelTol) def SetAbsTol(self, atol): r"""SetAbsTol(IterativeSolver self, double atol)""" return _solvers.IterativeSolver_SetAbsTol(self, atol) + SetAbsTol = _swig_new_instance_method(_solvers.IterativeSolver_SetAbsTol) def SetMaxIter(self, max_it): r"""SetMaxIter(IterativeSolver self, int max_it)""" return _solvers.IterativeSolver_SetMaxIter(self, max_it) + SetMaxIter = _swig_new_instance_method(_solvers.IterativeSolver_SetMaxIter) def SetPrintLevel(self, print_lvl): r"""SetPrintLevel(IterativeSolver self, int print_lvl)""" return _solvers.IterativeSolver_SetPrintLevel(self, print_lvl) + SetPrintLevel = _swig_new_instance_method(_solvers.IterativeSolver_SetPrintLevel) def GetNumIterations(self): r"""GetNumIterations(IterativeSolver self) -> int""" return _solvers.IterativeSolver_GetNumIterations(self) + GetNumIterations = _swig_new_instance_method(_solvers.IterativeSolver_GetNumIterations) def GetConverged(self): r"""GetConverged(IterativeSolver self) -> int""" return _solvers.IterativeSolver_GetConverged(self) + GetConverged = _swig_new_instance_method(_solvers.IterativeSolver_GetConverged) def GetFinalNorm(self): r"""GetFinalNorm(IterativeSolver self) -> double""" return _solvers.IterativeSolver_GetFinalNorm(self) + GetFinalNorm = _swig_new_instance_method(_solvers.IterativeSolver_GetFinalNorm) def SetPreconditioner(self, pr): r"""SetPreconditioner(IterativeSolver self, Solver pr)""" return _solvers.IterativeSolver_SetPreconditioner(self, pr) + SetPreconditioner = _swig_new_instance_method(_solvers.IterativeSolver_SetPreconditioner) def SetOperator(self, op): r"""SetOperator(IterativeSolver self, Operator op)""" return _solvers.IterativeSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.IterativeSolver_SetOperator) __swig_destroy__ = _solvers.delete_IterativeSolver # Register IterativeSolver in _solvers: _solvers.IterativeSolver_swigregister(IterativeSolver) +class OperatorJacobiSmoother(mfem._ser.operators.Solver): + r"""Proxy of C++ mfem::OperatorJacobiSmoother class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + + def __init__(self, *args): + r""" + __init__(OperatorJacobiSmoother self, mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother + __init__(OperatorJacobiSmoother self, Vector d, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother + """ + _solvers.OperatorJacobiSmoother_swiginit(self, _solvers.new_OperatorJacobiSmoother(*args)) + __swig_destroy__ = _solvers.delete_OperatorJacobiSmoother + + def Mult(self, x, y): + r"""Mult(OperatorJacobiSmoother self, Vector x, Vector y)""" + return _solvers.OperatorJacobiSmoother_Mult(self, x, y) + Mult = _swig_new_instance_method(_solvers.OperatorJacobiSmoother_Mult) + + def SetOperator(self, op): + r"""SetOperator(OperatorJacobiSmoother self, Operator op)""" + return _solvers.OperatorJacobiSmoother_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.OperatorJacobiSmoother_SetOperator) + + def Setup(self, diag): + r"""Setup(OperatorJacobiSmoother self, Vector diag)""" + return _solvers.OperatorJacobiSmoother_Setup(self, diag) + Setup = _swig_new_instance_method(_solvers.OperatorJacobiSmoother_Setup) + +# Register OperatorJacobiSmoother in _solvers: +_solvers.OperatorJacobiSmoother_swigregister(OperatorJacobiSmoother) + class SLISolver(IterativeSolver): r"""Proxy of C++ mfem::SLISolver class.""" @@ -132,10 +176,12 @@ def __init__(self): def SetOperator(self, op): r"""SetOperator(SLISolver self, Operator op)""" return _solvers.SLISolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.SLISolver_SetOperator) def Mult(self, b, x): r"""Mult(SLISolver self, Vector b, Vector x)""" return _solvers.SLISolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.SLISolver_Mult) __swig_destroy__ = _solvers.delete_SLISolver # Register SLISolver in _solvers: @@ -148,6 +194,7 @@ def SLI(*args): SLI(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24) """ return _solvers.SLI(*args) +SLI = _solvers.SLI class CGSolver(IterativeSolver): r"""Proxy of C++ mfem::CGSolver class.""" @@ -161,10 +208,12 @@ def __init__(self): def SetOperator(self, op): r"""SetOperator(CGSolver self, Operator op)""" return _solvers.CGSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.CGSolver_SetOperator) def Mult(self, b, x): r"""Mult(CGSolver self, Vector b, Vector x)""" return _solvers.CGSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.CGSolver_Mult) __swig_destroy__ = _solvers.delete_CGSolver # Register CGSolver in _solvers: @@ -174,10 +223,12 @@ def Mult(self, b, x): def CG(A, b, x, print_iter=0, max_num_iter=1000, RTOLERANCE=1e-12, ATOLERANCE=1e-24): r"""CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)""" return _solvers.CG(A, b, x, print_iter, max_num_iter, RTOLERANCE, ATOLERANCE) +CG = _solvers.CG def PCG(A, B, b, x, print_iter=0, max_num_iter=1000, RTOLERANCE=1e-12, ATOLERANCE=1e-24): r"""PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)""" return _solvers.PCG(A, B, b, x, print_iter, max_num_iter, RTOLERANCE, ATOLERANCE) +PCG = _solvers.PCG class GMRESSolver(IterativeSolver): r"""Proxy of C++ mfem::GMRESSolver class.""" @@ -191,10 +242,12 @@ def __init__(self): def SetKDim(self, dim): r"""SetKDim(GMRESSolver self, int dim)""" return _solvers.GMRESSolver_SetKDim(self, dim) + SetKDim = _swig_new_instance_method(_solvers.GMRESSolver_SetKDim) def Mult(self, b, x): r"""Mult(GMRESSolver self, Vector b, Vector x)""" return _solvers.GMRESSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.GMRESSolver_Mult) __swig_destroy__ = _solvers.delete_GMRESSolver # Register GMRESSolver in _solvers: @@ -213,10 +266,12 @@ def __init__(self): def SetKDim(self, dim): r"""SetKDim(FGMRESSolver self, int dim)""" return _solvers.FGMRESSolver_SetKDim(self, dim) + SetKDim = _swig_new_instance_method(_solvers.FGMRESSolver_SetKDim) def Mult(self, b, x): r"""Mult(FGMRESSolver self, Vector b, Vector x)""" return _solvers.FGMRESSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.FGMRESSolver_Mult) __swig_destroy__ = _solvers.delete_FGMRESSolver # Register FGMRESSolver in _solvers: @@ -229,6 +284,7 @@ def GMRES(*args): GMRES(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, int m=50, double rtol=1e-12, double atol=1e-24) """ return _solvers.GMRES(*args) +GMRES = _solvers.GMRES class BiCGSTABSolver(IterativeSolver): r"""Proxy of C++ mfem::BiCGSTABSolver class.""" @@ -242,10 +298,12 @@ def __init__(self): def SetOperator(self, op): r"""SetOperator(BiCGSTABSolver self, Operator op)""" return _solvers.BiCGSTABSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.BiCGSTABSolver_SetOperator) def Mult(self, b, x): r"""Mult(BiCGSTABSolver self, Vector b, Vector x)""" return _solvers.BiCGSTABSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.BiCGSTABSolver_Mult) __swig_destroy__ = _solvers.delete_BiCGSTABSolver # Register BiCGSTABSolver in _solvers: @@ -258,6 +316,7 @@ def BiCGSTAB(*args): BiCGSTAB(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double rtol=1e-12, double atol=1e-24) """ return _solvers.BiCGSTAB(*args) +BiCGSTAB = _solvers.BiCGSTAB class MINRESSolver(IterativeSolver): r"""Proxy of C++ mfem::MINRESSolver class.""" @@ -271,14 +330,17 @@ def __init__(self): def SetPreconditioner(self, pr): r"""SetPreconditioner(MINRESSolver self, Solver pr)""" return _solvers.MINRESSolver_SetPreconditioner(self, pr) + SetPreconditioner = _swig_new_instance_method(_solvers.MINRESSolver_SetPreconditioner) def SetOperator(self, op): r"""SetOperator(MINRESSolver self, Operator op)""" return _solvers.MINRESSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.MINRESSolver_SetOperator) def Mult(self, b, x): r"""Mult(MINRESSolver self, Vector b, Vector x)""" return _solvers.MINRESSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.MINRESSolver_Mult) __swig_destroy__ = _solvers.delete_MINRESSolver # Register MINRESSolver in _solvers: @@ -291,6 +353,7 @@ def MINRES(*args): MINRES(Operator A, Solver B, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24) """ return _solvers.MINRES(*args) +MINRES = _solvers.MINRES class NewtonSolver(IterativeSolver): r"""Proxy of C++ mfem::NewtonSolver class.""" @@ -304,18 +367,27 @@ def __init__(self): def SetOperator(self, op): r"""SetOperator(NewtonSolver self, Operator op)""" return _solvers.NewtonSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.NewtonSolver_SetOperator) def SetSolver(self, solver): r"""SetSolver(NewtonSolver self, Solver solver)""" return _solvers.NewtonSolver_SetSolver(self, solver) + SetSolver = _swig_new_instance_method(_solvers.NewtonSolver_SetSolver) def Mult(self, b, x): r"""Mult(NewtonSolver self, Vector b, Vector x)""" return _solvers.NewtonSolver_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.NewtonSolver_Mult) def ComputeScalingFactor(self, x, b): r"""ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double""" return _solvers.NewtonSolver_ComputeScalingFactor(self, x, b) + ComputeScalingFactor = _swig_new_instance_method(_solvers.NewtonSolver_ComputeScalingFactor) + + def ProcessNewState(self, x): + r"""ProcessNewState(NewtonSolver self, Vector x)""" + return _solvers.NewtonSolver_ProcessNewState(self, x) + ProcessNewState = _swig_new_instance_method(_solvers.NewtonSolver_ProcessNewState) __swig_destroy__ = _solvers.delete_NewtonSolver # Register NewtonSolver in _solvers: @@ -325,7 +397,120 @@ def ComputeScalingFactor(self, x, b): def aGMRES(A, x, b, M, max_iter, m_max, m_min, m_step, cf, tol, atol, printit): r"""aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int""" return _solvers.aGMRES(A, x, b, M, max_iter, m_max, m_min, m_step, cf, tol, atol, printit) -class SLBQPOptimizer(IterativeSolver): +aGMRES = _solvers.aGMRES +class OptimizationProblem(object): + r"""Proxy of C++ mfem::OptimizationProblem class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + input_size = property(_solvers.OptimizationProblem_input_size_get, doc=r"""input_size : q(const).int""") + + def CalcObjective(self, x): + r"""CalcObjective(OptimizationProblem self, Vector x) -> double""" + return _solvers.OptimizationProblem_CalcObjective(self, x) + CalcObjective = _swig_new_instance_method(_solvers.OptimizationProblem_CalcObjective) + + def CalcObjectiveGrad(self, x, grad): + r"""CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)""" + return _solvers.OptimizationProblem_CalcObjectiveGrad(self, x, grad) + CalcObjectiveGrad = _swig_new_instance_method(_solvers.OptimizationProblem_CalcObjectiveGrad) + + def SetEqualityConstraint(self, c): + r"""SetEqualityConstraint(OptimizationProblem self, Vector c)""" + return _solvers.OptimizationProblem_SetEqualityConstraint(self, c) + SetEqualityConstraint = _swig_new_instance_method(_solvers.OptimizationProblem_SetEqualityConstraint) + + def SetInequalityConstraint(self, dl, dh): + r"""SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)""" + return _solvers.OptimizationProblem_SetInequalityConstraint(self, dl, dh) + SetInequalityConstraint = _swig_new_instance_method(_solvers.OptimizationProblem_SetInequalityConstraint) + + def SetSolutionBounds(self, xl, xh): + r"""SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)""" + return _solvers.OptimizationProblem_SetSolutionBounds(self, xl, xh) + SetSolutionBounds = _swig_new_instance_method(_solvers.OptimizationProblem_SetSolutionBounds) + + def GetC(self): + r"""GetC(OptimizationProblem self) -> Operator""" + return _solvers.OptimizationProblem_GetC(self) + GetC = _swig_new_instance_method(_solvers.OptimizationProblem_GetC) + + def GetD(self): + r"""GetD(OptimizationProblem self) -> Operator""" + return _solvers.OptimizationProblem_GetD(self) + GetD = _swig_new_instance_method(_solvers.OptimizationProblem_GetD) + + def GetEqualityVec(self): + r"""GetEqualityVec(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetEqualityVec(self) + GetEqualityVec = _swig_new_instance_method(_solvers.OptimizationProblem_GetEqualityVec) + + def GetInequalityVec_Lo(self): + r"""GetInequalityVec_Lo(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetInequalityVec_Lo(self) + GetInequalityVec_Lo = _swig_new_instance_method(_solvers.OptimizationProblem_GetInequalityVec_Lo) + + def GetInequalityVec_Hi(self): + r"""GetInequalityVec_Hi(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetInequalityVec_Hi(self) + GetInequalityVec_Hi = _swig_new_instance_method(_solvers.OptimizationProblem_GetInequalityVec_Hi) + + def GetBoundsVec_Lo(self): + r"""GetBoundsVec_Lo(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetBoundsVec_Lo(self) + GetBoundsVec_Lo = _swig_new_instance_method(_solvers.OptimizationProblem_GetBoundsVec_Lo) + + def GetBoundsVec_Hi(self): + r"""GetBoundsVec_Hi(OptimizationProblem self) -> Vector""" + return _solvers.OptimizationProblem_GetBoundsVec_Hi(self) + GetBoundsVec_Hi = _swig_new_instance_method(_solvers.OptimizationProblem_GetBoundsVec_Hi) + + def GetNumConstraints(self): + r"""GetNumConstraints(OptimizationProblem self) -> int""" + return _solvers.OptimizationProblem_GetNumConstraints(self) + GetNumConstraints = _swig_new_instance_method(_solvers.OptimizationProblem_GetNumConstraints) + __swig_destroy__ = _solvers.delete_OptimizationProblem + +# Register OptimizationProblem in _solvers: +_solvers.OptimizationProblem_swigregister(OptimizationProblem) + +class OptimizationSolver(IterativeSolver): + r"""Proxy of C++ mfem::OptimizationSolver class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + + def __init__(self, *args, **kwargs): + raise AttributeError("No constructor defined - class is abstract") + __repr__ = _swig_repr + __swig_destroy__ = _solvers.delete_OptimizationSolver + + def SetOptimizationProblem(self, prob): + r"""SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)""" + return _solvers.OptimizationSolver_SetOptimizationProblem(self, prob) + SetOptimizationProblem = _swig_new_instance_method(_solvers.OptimizationSolver_SetOptimizationProblem) + + def Mult(self, xt, x): + r"""Mult(OptimizationSolver self, Vector xt, Vector x)""" + return _solvers.OptimizationSolver_Mult(self, xt, x) + Mult = _swig_new_instance_method(_solvers.OptimizationSolver_Mult) + + def SetPreconditioner(self, pr): + r"""SetPreconditioner(OptimizationSolver self, Solver pr)""" + return _solvers.OptimizationSolver_SetPreconditioner(self, pr) + SetPreconditioner = _swig_new_instance_method(_solvers.OptimizationSolver_SetPreconditioner) + + def SetOperator(self, op): + r"""SetOperator(OptimizationSolver self, Operator op)""" + return _solvers.OptimizationSolver_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.OptimizationSolver_SetOperator) + +# Register OptimizationSolver in _solvers: +_solvers.OptimizationSolver_swigregister(OptimizationSolver) + +class SLBQPOptimizer(OptimizationSolver): r"""Proxy of C++ mfem::SLBQPOptimizer class.""" thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") @@ -335,29 +520,75 @@ def __init__(self): r"""__init__(SLBQPOptimizer self) -> SLBQPOptimizer""" _solvers.SLBQPOptimizer_swiginit(self, _solvers.new_SLBQPOptimizer()) + def SetOptimizationProblem(self, prob): + r"""SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)""" + return _solvers.SLBQPOptimizer_SetOptimizationProblem(self, prob) + SetOptimizationProblem = _swig_new_instance_method(_solvers.SLBQPOptimizer_SetOptimizationProblem) + def SetBounds(self, _lo, _hi): r"""SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)""" return _solvers.SLBQPOptimizer_SetBounds(self, _lo, _hi) + SetBounds = _swig_new_instance_method(_solvers.SLBQPOptimizer_SetBounds) def SetLinearConstraint(self, _w, _a): r"""SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)""" return _solvers.SLBQPOptimizer_SetLinearConstraint(self, _w, _a) + SetLinearConstraint = _swig_new_instance_method(_solvers.SLBQPOptimizer_SetLinearConstraint) def Mult(self, xt, x): r"""Mult(SLBQPOptimizer self, Vector xt, Vector x)""" return _solvers.SLBQPOptimizer_Mult(self, xt, x) - - def SetPreconditioner(self, pr): - r"""SetPreconditioner(SLBQPOptimizer self, Solver pr)""" - return _solvers.SLBQPOptimizer_SetPreconditioner(self, pr) - - def SetOperator(self, op): - r"""SetOperator(SLBQPOptimizer self, Operator op)""" - return _solvers.SLBQPOptimizer_SetOperator(self, op) + Mult = _swig_new_instance_method(_solvers.SLBQPOptimizer_Mult) __swig_destroy__ = _solvers.delete_SLBQPOptimizer # Register SLBQPOptimizer in _solvers: _solvers.SLBQPOptimizer_swigregister(SLBQPOptimizer) +class BlockILU(mfem._ser.operators.Solver): + r"""Proxy of C++ mfem::BlockILU class.""" + + thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") + __repr__ = _swig_repr + Reordering_MINIMUM_DISCARDED_FILL = _solvers.BlockILU_Reordering_MINIMUM_DISCARDED_FILL + + Reordering_NONE = _solvers.BlockILU_Reordering_NONE + + + def __init__(self, *args): + r""" + __init__(BlockILU self, int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU + __init__(BlockILU self, Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU + """ + _solvers.BlockILU_swiginit(self, _solvers.new_BlockILU(*args)) + + def SetOperator(self, op): + r"""SetOperator(BlockILU self, Operator op)""" + return _solvers.BlockILU_SetOperator(self, op) + SetOperator = _swig_new_instance_method(_solvers.BlockILU_SetOperator) + + def Mult(self, b, x): + r"""Mult(BlockILU self, Vector b, Vector x)""" + return _solvers.BlockILU_Mult(self, b, x) + Mult = _swig_new_instance_method(_solvers.BlockILU_Mult) + + def GetBlockI(self): + r"""GetBlockI(BlockILU self) -> int *""" + return _solvers.BlockILU_GetBlockI(self) + GetBlockI = _swig_new_instance_method(_solvers.BlockILU_GetBlockI) + + def GetBlockJ(self): + r"""GetBlockJ(BlockILU self) -> int *""" + return _solvers.BlockILU_GetBlockJ(self) + GetBlockJ = _swig_new_instance_method(_solvers.BlockILU_GetBlockJ) + + def GetBlockData(self): + r"""GetBlockData(BlockILU self) -> double *""" + return _solvers.BlockILU_GetBlockData(self) + GetBlockData = _swig_new_instance_method(_solvers.BlockILU_GetBlockData) + __swig_destroy__ = _solvers.delete_BlockILU + +# Register BlockILU in _solvers: +_solvers.BlockILU_swigregister(BlockILU) + diff --git a/mfem/_ser/solvers_wrap.cxx b/mfem/_ser/solvers_wrap.cxx index 9596d830..2343ab02 100644 --- a/mfem/_ser/solvers_wrap.cxx +++ b/mfem/_ser/solvers_wrap.cxx @@ -3070,34 +3070,43 @@ namespace Swig { #define SWIGTYPE_p_double swig_types[2] #define SWIGTYPE_p_int swig_types[3] #define SWIGTYPE_p_mfem__AbstractSparseMatrix swig_types[4] -#define SWIGTYPE_p_mfem__BiCGSTABSolver swig_types[5] -#define SWIGTYPE_p_mfem__CGSolver swig_types[6] -#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[7] -#define SWIGTYPE_p_mfem__DenseMatrix swig_types[8] -#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[9] -#define SWIGTYPE_p_mfem__FGMRESSolver swig_types[10] -#define SWIGTYPE_p_mfem__GMRESSolver swig_types[11] -#define SWIGTYPE_p_mfem__IdentityOperator swig_types[12] -#define SWIGTYPE_p_mfem__IterativeSolver swig_types[13] -#define SWIGTYPE_p_mfem__MINRESSolver swig_types[14] -#define SWIGTYPE_p_mfem__Matrix swig_types[15] -#define SWIGTYPE_p_mfem__MatrixInverse swig_types[16] -#define SWIGTYPE_p_mfem__NewtonSolver swig_types[17] -#define SWIGTYPE_p_mfem__Operator swig_types[18] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[19] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[20] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[21] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[22] -#define SWIGTYPE_p_mfem__SLBQPOptimizer swig_types[23] -#define SWIGTYPE_p_mfem__SLISolver swig_types[24] -#define SWIGTYPE_p_mfem__Solver swig_types[25] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[26] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[27] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[28] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[29] -#define SWIGTYPE_p_mfem__Vector swig_types[30] -static swig_type_info *swig_types[32]; -static swig_module_info swig_module = {swig_types, 31, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[5] +#define SWIGTYPE_p_mfem__BiCGSTABSolver swig_types[6] +#define SWIGTYPE_p_mfem__BilinearForm swig_types[7] +#define SWIGTYPE_p_mfem__BlockILU swig_types[8] +#define SWIGTYPE_p_mfem__CGSolver swig_types[9] +#define SWIGTYPE_p_mfem__ConstrainedOperator swig_types[10] +#define SWIGTYPE_p_mfem__DenseMatrix swig_types[11] +#define SWIGTYPE_p_mfem__DenseMatrixInverse swig_types[12] +#define SWIGTYPE_p_mfem__FGMRESSolver swig_types[13] +#define SWIGTYPE_p_mfem__GMRESSolver swig_types[14] +#define SWIGTYPE_p_mfem__IdentityOperator swig_types[15] +#define SWIGTYPE_p_mfem__IterativeSolver swig_types[16] +#define SWIGTYPE_p_mfem__MINRESSolver swig_types[17] +#define SWIGTYPE_p_mfem__Matrix swig_types[18] +#define SWIGTYPE_p_mfem__MatrixInverse swig_types[19] +#define SWIGTYPE_p_mfem__NewtonSolver swig_types[20] +#define SWIGTYPE_p_mfem__Operator swig_types[21] +#define SWIGTYPE_p_mfem__OperatorJacobiSmoother swig_types[22] +#define SWIGTYPE_p_mfem__OptimizationProblem swig_types[23] +#define SWIGTYPE_p_mfem__OptimizationSolver swig_types[24] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[25] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[26] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[27] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[28] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[29] +#define SWIGTYPE_p_mfem__SLBQPOptimizer swig_types[30] +#define SWIGTYPE_p_mfem__SLISolver swig_types[31] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[32] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[33] +#define SWIGTYPE_p_mfem__Solver swig_types[34] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[35] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[36] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[37] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[38] +#define SWIGTYPE_p_mfem__Vector swig_types[39] +static swig_type_info *swig_types[41]; +static swig_module_info swig_module = {swig_types, 40, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3264,6 +3273,111 @@ SWIGINTERNINLINE PyObject* #define SWIG_From_double PyFloat_FromDouble +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + /* --------------------------------------------------- * C++ director class methods @@ -3730,14 +3844,44 @@ SWIGINTERN PyObject *IterativeSolver_swigregister(PyObject *SWIGUNUSEDPARM(self) return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SLISolver *result = 0 ; + mfem::BilinearForm *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + mfem::OperatorJacobiSmoother *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_SLISolver", 0, 0, 0)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::SLISolver *)new mfem::SLISolver(); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3754,40 +3898,43 @@ SWIGINTERN PyObject *_wrap_new_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::BilinearForm *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + mfem::OperatorJacobiSmoother *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_SetOperator" "', argument " "1"" of type '" "mfem::SLISolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); } - arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3804,51 +3951,104 @@ SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Vector *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + double val3 ; + int ecode3 = 0 ; + mfem::OperatorJacobiSmoother *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_Mult" "', argument " "1"" of type '" "mfem::SLISolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); } - arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + { + try { + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Vector *arg1 = 0 ; + mfem::Array< int > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::OperatorJacobiSmoother *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - ((mfem::SLISolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3865,27 +4065,107 @@ SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_OperatorJacobiSmoother", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_3(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OperatorJacobiSmoother'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &,double const)\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &)\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &,double const)\n" + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_delete_OperatorJacobiSmoother(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLISolver" "', argument " "1"" of type '" "mfem::SLISolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } - arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); { try { delete arg1; @@ -3912,87 +4192,44 @@ SWIGINTERN PyObject *_wrap_delete_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *SLISolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLISolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *SLISolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + ((mfem::OperatorJacobiSmoother const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4016,68 +4253,33 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4101,60 +4303,75 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Setup", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Setup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + try { + (arg1)->Setup((mfem::Vector const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *OperatorJacobiSmoother_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *OperatorJacobiSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLISolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SLISolver", 0, 0, 0)) SWIG_fail; { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + result = (mfem::SLISolver *)new mfem::SLISolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4171,60 +4388,40 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; + mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "SLISolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_SetOperator" "', argument " "1"" of type '" "mfem::SLISolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4248,9 +4445,9 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -4259,35 +4456,33 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "SLISolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_Mult" "', argument " "1"" of type '" "mfem::SLISolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + ((mfem::SLISolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4311,87 +4506,23 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; + mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLISolver" "', argument " "1"" of type '" "mfem::SLISolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4415,14 +4546,25 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *SLISolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLISolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SLISolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg4 ; int arg5 ; - int arg6 ; + double arg6 ; double arg7 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4430,8 +4572,8 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; double val7 ; int ecode7 = 0 ; @@ -4444,42 +4586,39 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); @@ -4487,7 +4626,7 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ arg7 = static_cast< double >(val7); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4511,22 +4650,22 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg4 ; int arg5 ; - int arg6 ; + double arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); @@ -4537,45 +4676,42 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4599,12 +4735,12 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg4 ; int arg5 ; void *argp1 = 0 ; int res1 = 0 ; @@ -4612,8 +4748,6 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); @@ -4624,30 +4758,28 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -4656,7 +4788,7 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4680,20 +4812,18 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); @@ -4704,33 +4834,31 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4754,411 +4882,150 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; +SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "SLI", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SLI__SWIG_4(self, argc, argv); - } - } - } + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_3(self, argc, argv); - } - } - } - } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SLI__SWIG_9(self, argc, argv); - } - } - } - } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_8(self, argc, argv); - } - } - } - } - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_2(self, argc, argv); - } - } - } - } - } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_1(self, argc, argv); - } - } - } - } - } - } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_7(self, argc, argv); - } - } - } - } - } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_6(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SLI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_new_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::CGSolver *result = 0 ; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; + double arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_CGSolver", 0, 0, 0)) SWIG_fail; + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); { try { - result = (mfem::CGSolver *)new mfem::CGSolver(); + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5175,40 +5042,86 @@ SWIGINTERN PyObject *_wrap_new_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_CGSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CGSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_SetOperator" "', argument " "1"" of type '" "mfem::CGSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5232,84 +5145,71 @@ SWIGINTERN PyObject *_wrap_CGSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_CGSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CGSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_Mult" "', argument " "1"" of type '" "mfem::CGSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - try { - ((mfem::CGSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CGSolver" "', argument " "1"" of type '" "mfem::CGSolver *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); { try { - delete arg1; + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5333,87 +5233,64 @@ SWIGINTERN PyObject *_wrap_delete_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *CGSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CGSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *CGSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_CG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; + mfem::Vector *arg4 = 0 ; int arg5 ; - double arg6 ; - double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5437,278 +5314,57 @@ SWIGINTERN PyObject *_wrap_CG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t } -SWIGINTERN PyObject *_wrap_CG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5732,13 +5388,13 @@ SWIGINTERN PyObject *_wrap_CG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t } -SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SLI(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[9] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "CG", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SLI", 0, 8, argv))) SWIG_fail; --argc; if (argc == 3) { int _v; @@ -5752,7 +5408,7 @@ SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_CG__SWIG_4(self, argc, argv); + return _wrap_SLI__SWIG_4(self, argc, argv); } } } @@ -5778,43 +5434,97 @@ SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_CG__SWIG_3(self, argc, argv); + return _wrap_SLI__SWIG_3(self, argc, argv); } } } } } - if (argc == 5) { + if (argc == 4) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; + return _wrap_SLI__SWIG_9(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; } else { _v = 1; } } if (_v) { - return _wrap_CG__SWIG_2(self, argc, argv); + return _wrap_SLI__SWIG_8(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SLI__SWIG_2(self, argc, argv); } } } @@ -5856,7 +5566,97 @@ SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_CG__SWIG_1(self, argc, argv); + return _wrap_SLI__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 6) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SLI__SWIG_7(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SLI__SWIG_6(self, argc, argv); + } } } } @@ -5904,7 +5704,61 @@ SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_CG__SWIG_0(self, argc, argv); + return _wrap_SLI__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SLI__SWIG_5(self, argc, argv); + } } } } @@ -5915,98 +5769,30 @@ SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CG'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SLI'.\n" " Possible C/C++ prototypes are:\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n"); + " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" + " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" + " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_PCG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + mfem::CGSolver *result = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PCG" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + if (!SWIG_Python_UnpackTuple(args, "new_CGSolver", 0, 0, 0)) SWIG_fail; { try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + result = (mfem::CGSolver *)new mfem::CGSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6023,86 +5809,40 @@ SWIGINTERN PyObject *_wrap_PCG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_PCG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CGSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "CGSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_SetOperator" "', argument " "1"" of type '" "mfem::CGSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6126,71 +5866,44 @@ SWIGINTERN PyObject *_wrap_PCG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_PCG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CGSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "CGSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_Mult" "', argument " "1"" of type '" "mfem::CGSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } { try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + ((mfem::CGSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6214,64 +5927,23 @@ SWIGINTERN PyObject *_wrap_PCG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_PCG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CGSolver" "', argument " "1"" of type '" "mfem::CGSolver *""'"); } + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); { try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6295,57 +5967,87 @@ SWIGINTERN PyObject *_wrap_PCG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_PCG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; +SWIGINTERN PyObject *CGSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CGSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CGSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_CG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int arg5 ; + double arg6 ; + double arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CG" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); { try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6369,233 +6071,68 @@ SWIGINTERN PyObject *_wrap_PCG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_PCG(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; +SWIGINTERN PyObject *_wrap_CG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int arg5 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val6 ; + int ecode6 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "PCG", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_PCG__SWIG_4(self, argc, argv); - } - } - } - } + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PCG__SWIG_3(self, argc, argv); - } - } - } - } - } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PCG__SWIG_2(self, argc, argv); - } - } - } - } - } - } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PCG__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PCG__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PCG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_GMRESSolver", 0, 0, 0)) SWIG_fail; + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); { try { - result = (mfem::GMRESSolver *)new mfem::GMRESSolver(); + mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6612,36 +6149,67 @@ SWIGINTERN PyObject *_wrap_new_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; - int arg2 ; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } { try { - (arg1)->SetKDim(arg2); + mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6665,44 +6233,53 @@ SWIGINTERN PyObject *_wrap_GMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_GMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; + mfem::Operator *arg1 = 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_Mult" "', argument " "1"" of type '" "mfem::GMRESSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } { try { - ((mfem::GMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6726,23 +6303,46 @@ SWIGINTERN PyObject *_wrap_GMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_delete_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_DISOWN | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GMRESSolver" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - delete arg1; + mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6766,172 +6366,281 @@ SWIGINTERN PyObject *_wrap_delete_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *GMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GMRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *GMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *result = 0 ; +SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "new_FGMRESSolver", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!(argc = SWIG_Python_UnpackTuple(args, "CG", 0, 7, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_CG__SWIG_4(self, argc, argv); + } + } + } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FGMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_CG__SWIG_3(self, argc, argv); + } + } + } + } } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (argc == 5) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_CG__SWIG_2(self, argc, argv); + } + } + } + } + } } - { - try { - (arg1)->SetKDim(arg2); + if (argc == 6) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CG__SWIG_1(self, argc, argv); + } + } + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 7) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_CG__SWIG_0(self, argc, argv); + } + } + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CG'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" + " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_FGMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PCG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; + double arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_Mult" "', argument " "1"" of type '" "mfem::FGMRESSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - try { - ((mfem::FGMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FGMRESSolver" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PCG" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); { try { - delete arg1; + mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6955,28 +6664,15 @@ SWIGINTERN PyObject *_wrap_delete_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *FGMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FGMRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *FGMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PCG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Solver *arg4 = 0 ; - int *arg5 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; int arg6 ; - double *arg7 = 0 ; - double arg8 ; - int arg9 ; + double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6985,83 +6681,62 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssiz int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - double val8 ; - int ecode8 = 0 ; - int result; + double val7 ; + int ecode7 = 0 ; - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - arg4 = reinterpret_cast< mfem::Solver * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< int * >(argp5); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - arg7 = reinterpret_cast< double * >(argp7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { - if ((PyArray_PyIntAsInt(swig_obj[8]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg9 = PyArray_PyIntAsInt(swig_obj[8]); + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); { try { - result = (int)mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,arg6,*arg7,arg8,arg9); + mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7078,14 +6753,14 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssiz SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PCG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; @@ -7093,9 +6768,6 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssiz mfem::Vector *arg4 = 0 ; int arg5 ; int arg6 ; - int arg7 ; - double arg8 ; - double arg9 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7104,42 +6776,38 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssiz int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - double val8 ; - int ecode8 = 0 ; - double val9 ; - int ecode9 = 0 ; - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { @@ -7154,25 +6822,9 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssiz }; arg6 = PyArray_PyIntAsInt(swig_obj[5]); } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); - if (!SWIG_IsOK(ecode9)) { - SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GMRES" "', argument " "9"" of type '" "double""'"); - } - arg9 = static_cast< double >(val9); { try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9); + mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7196,16 +6848,13 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssiz } -SWIGINTERN PyObject *_wrap_GMRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PCG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; int arg5 ; - int arg6 ; - int arg7 ; - double arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7214,40 +6863,38 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssiz int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - double val8 ; - int ecode8 = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { @@ -7256,26 +6903,9 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssiz }; arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7299,15 +6929,12 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssiz } -SWIGINTERN PyObject *_wrap_GMRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PCG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - int arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7317,60 +6944,42 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssiz void *argp4 = 0 ; int res4 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } { try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7394,312 +7003,111 @@ SWIGINTERN PyObject *_wrap_GMRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssiz } -SWIGINTERN PyObject *_wrap_GMRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; +SWIGINTERN PyObject *_wrap_PCG(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (!(argc = SWIG_Python_UnpackTuple(args, "PCG", 0, 8, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_PCG__SWIG_4(self, argc, argv); + } + } + } + } } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + if (argc == 5) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_PCG__SWIG_3(self, argc, argv); + } + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 6) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_PCG__SWIG_2(self, argc, argv); + } + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[10] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES", 0, 9, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GMRES__SWIG_6(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_5(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { + if (argc == 7) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -7733,7 +7141,13 @@ SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_GMRES__SWIG_4(self, argc, argv); + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_PCG__SWIG_1(self, argc, argv); + } } } } @@ -7741,7 +7155,7 @@ SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { } } } - if (argc == 7) { + if (argc == 8) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -7776,195 +7190,17 @@ SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { } if (_v) { { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); } if (_v) { - return _wrap_GMRES__SWIG_3(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GMRES__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - } - } - if (argc == 9) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[8], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GMRES__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - } - } - if (argc == 9) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[8]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_0(self, argc, argv); - } - } + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_PCG__SWIG_0(self, argc, argv); + } } } } @@ -7975,27 +7211,25 @@ SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PCG'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GMRES(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,int,double &,double,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double,double)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); + " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" + " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BiCGSTABSolver *result = 0 ; + mfem::GMRESSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_BiCGSTABSolver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "new_GMRESSolver", 0, 0, 0)) SWIG_fail; { try { - result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(); + result = (mfem::GMRESSolver *)new mfem::GMRESSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8012,40 +7246,36 @@ SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); - } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + (arg1)->SetKDim(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8069,9 +7299,9 @@ SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -8082,31 +7312,31 @@ SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_Mult" "', argument " "1"" of type '" "mfem::BiCGSTABSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_Mult" "', argument " "1"" of type '" "mfem::GMRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::BiCGSTABSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::GMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8130,20 +7360,20 @@ SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCGSTABSolver" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GMRESSolver" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); { try { delete arg1; @@ -8170,106 +7400,25 @@ SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *BiCGSTABSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GMRESSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *BiCGSTABSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *GMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Solver *arg4 = 0 ; - int *arg5 = 0 ; - double *arg6 = 0 ; - double arg7 ; - int arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - double val7 ; - int ecode7 = 0 ; - int result; + mfem::FGMRESSolver *result = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - arg4 = reinterpret_cast< mfem::Solver * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); - } - arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); - } - arg6 = reinterpret_cast< double * >(argp6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } + if (!SWIG_Python_UnpackTuple(args, "new_FGMRESSolver", 0, 0, 0)) SWIG_fail; { try { - result = (int)mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,*arg6,arg7,arg8); + result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8286,94 +7435,36 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FGMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); } + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BiCGSTAB" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + (arg1)->SetKDim(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8397,79 +7488,44 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FGMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_Mult" "', argument " "1"" of type '" "mfem::FGMRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + ((mfem::FGMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8493,71 +7549,153 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FGMRESSolver" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); + } + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *FGMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FGMRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *FGMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Solver *arg4 = 0 ; + int *arg5 = 0 ; + int arg6 ; + double *arg7 = 0 ; + double arg8 ; + int arg9 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + double val8 ; + int ecode8 = 0 ; + int result; + + if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::Solver * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); } + arg7 = reinterpret_cast< double * >(argp7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[8]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg9 = PyArray_PyIntAsInt(swig_obj[8]); } { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + result = (int)mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,arg6,*arg7,arg8,arg9); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8574,20 +7712,24 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; int arg5 ; + int arg6 ; + int arg7 ; + double arg8 ; + double arg9 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8596,38 +7738,42 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val8 ; + int ecode8 = 0 ; + double val9 ; + int ecode9 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); { @@ -8636,9 +7782,31 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s }; arg5 = PyArray_PyIntAsInt(swig_obj[4]); } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(swig_obj[6]); + } + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GMRES" "', argument " "9"" of type '" "double""'"); + } + arg9 = static_cast< double >(val9); { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8662,12 +7830,16 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GMRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + int arg7 ; + double arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8676,43 +7848,68 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_s int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(swig_obj[6]); + } + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8736,16 +7933,2839 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GMRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + int arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "BiCGSTAB", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(swig_obj[6]); + } + { + try { + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GMRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GMRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GMRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[10] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES", 0, 9, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GMRES__SWIG_6(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GMRES__SWIG_5(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GMRES__SWIG_4(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GMRES__SWIG_3(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GMRES__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + } + } + if (argc == 9) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } + } + } + if (argc == 9) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[8]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GMRES__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GMRES(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,int,double &,double,int)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double,double)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BiCGSTABSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_BiCGSTABSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); + } + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_Mult" "', argument " "1"" of type '" "mfem::BiCGSTABSolver const *""'"); + } + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::BiCGSTABSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCGSTABSolver" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); + } + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *BiCGSTABSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BiCGSTABSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Solver *arg4 = 0 ; + int *arg5 = 0 ; + double *arg6 = 0 ; + double arg7 ; + int arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + double val7 ; + int ecode7 = 0 ; + int result; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); + } + arg4 = reinterpret_cast< mfem::Solver * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); + } + arg6 = reinterpret_cast< double * >(argp6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + { + try { + result = (int)mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,*arg6,arg7,arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; + double arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BiCGSTAB" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + { + try { + mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + { + try { + mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BiCGSTAB", 0, 8, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BiCGSTAB__SWIG_5(self, argc, argv); + } + } + } + } + } + if (argc == 5) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_4(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_3(self, argc, argv); + } + } + } + } + } + } + } + if (argc == 7) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_2(self, argc, argv); + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BiCGSTAB'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,double &,double,int)\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MINRESSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_MINRESSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::MINRESSolver *)new mfem::MINRESSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Solver *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + } + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + { + try { + (arg1)->SetPreconditioner(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetOperator" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + } + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_Mult" "', argument " "1"" of type '" "mfem::MINRESSolver const *""'"); + } + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::MINRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MINRESSolver" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + } + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *MINRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MINRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MINRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int arg5 ; + double arg6 ; + double arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int arg5 ; + double arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val6 ; + int ecode6 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; + double arg8 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "MINRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + double arg7 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + + if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + int arg6 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MINRES", 0, 8, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_MINRES__SWIG_4(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MINRES__SWIG_3(self, argc, argv); + } + } + } + } + } + if (argc == 4) { + int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { @@ -8760,7 +10780,7 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BiCGSTAB__SWIG_5(self, argc, argv); + return _wrap_MINRES__SWIG_9(self, argc, argv); } } } @@ -8791,7 +10811,87 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_BiCGSTAB__SWIG_4(self, argc, argv); + return _wrap_MINRES__SWIG_8(self, argc, argv); + } + } + } + } + } + } + if (argc == 5) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MINRES__SWIG_2(self, argc, argv); + } + } + } + } + } + } + if (argc == 6) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } } } } @@ -8832,7 +10932,7 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_BiCGSTAB__SWIG_3(self, argc, argv); + return _wrap_MINRES__SWIG_7(self, argc, argv); } } } @@ -8879,7 +10979,7 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BiCGSTAB__SWIG_2(self, argc, argv); + return _wrap_MINRES__SWIG_6(self, argc, argv); } } } @@ -8888,46 +10988,47 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } } } - if (argc == 8) { + if (argc == 7) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } if (_v) { { int res = SWIG_AsVal_double(argv[6], NULL); _v = SWIG_CheckState(res); } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_0(self, argc, argv); - } + return _wrap_MINRES__SWIG_0(self, argc, argv); } } } @@ -8980,7 +11081,7 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + return _wrap_MINRES__SWIG_5(self, argc, argv); } } } @@ -8992,26 +11093,343 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BiCGSTAB'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,double &,double,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MINRES'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" + " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewtonSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_NewtonSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::NewtonSolver *)new mfem::NewtonSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewtonSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetOperator" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + mfem::Solver *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetSolver", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetSolver" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetSolver" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_SetSolver" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + { + try { + (arg1)->SetSolver(*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_Mult" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); + } + arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::NewtonSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + double result; + + if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ComputeScalingFactor", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); + } + arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + result = (double)((mfem::NewtonSolver const *)arg1)->ComputeScalingFactor((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ProcessNewState", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ProcessNewState" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); + } + arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ProcessNewState" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ProcessNewState" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + ((mfem::NewtonSolver const *)arg1)->ProcessNewState((mfem::Vector const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MINRESSolver *result = 0 ; + mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "new_MINRESSolver", 0, 0, 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewtonSolver" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); { try { - result = (mfem::MINRESSolver *)new mfem::MINRESSolver(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9028,40 +11446,146 @@ SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *NewtonSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NewtonSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *NewtonSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Operator *arg4 = 0 ; + int *arg5 = 0 ; + int arg6 ; + int arg7 ; + int arg8 ; + double arg9 ; + double *arg10 = 0 ; + double *arg11 = 0 ; + int arg12 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double val9 ; + int ecode9 = 0 ; + void *argp10 = 0 ; + int res10 = 0 ; + void *argp11 = 0 ; + int res11 = 0 ; + PyObject *swig_obj[12] ; + int result; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "aGMRES", 12, 12, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); + } + arg4 = reinterpret_cast< mfem::Operator * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "aGMRES" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(swig_obj[6]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "aGMRES" "', argument " "9"" of type '" "double""'"); + } + arg9 = static_cast< double >(val9); + res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res10)) { + SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); + } + if (!argp10) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); + } + arg10 = reinterpret_cast< double * >(argp10); + res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res11)) { + SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "aGMRES" "', argument " "11"" of type '" "double &""'"); + } + if (!argp11) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "11"" of type '" "double &""'"); + } + arg11 = reinterpret_cast< double * >(argp11); + { + if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg12 = PyArray_PyIntAsInt(swig_obj[11]); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); { try { - (arg1)->SetPreconditioner(*arg2); + result = (int)mfem::aGMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,(mfem::Operator const &)*arg4,*arg5,arg6,arg7,arg8,arg9,*arg10,*arg11,arg12); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9078,40 +11602,64 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_input_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_input_size_get" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + result = (int)(int) ((arg1)->input_size); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; PyObject *swig_obj[2] ; + double result; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjective", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetOperator" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjective" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjective" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjective" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + result = (double)((mfem::OptimizationProblem const *)arg1)->CalcObjective((mfem::Vector const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9128,16 +11676,16 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9148,31 +11696,31 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjectiveGrad", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_Mult" "', argument " "1"" of type '" "mfem::MINRESSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MINRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::OptimizationProblem const *)arg1)->CalcObjectiveGrad((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9196,23 +11744,33 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetEqualityConstraint", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MINRESSolver" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - delete arg1; + (arg1)->SetEqualityConstraint((mfem::Vector const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9236,87 +11794,44 @@ SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *MINRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MINRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MINRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetInequalityConstraint", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + (arg1)->SetInequalityConstraint((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9340,68 +11855,44 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetSolutionBounds", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + (arg1)->SetSolutionBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9425,60 +11916,106 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetC" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); + { + try { + result = (mfem::Operator *)((mfem::OptimizationProblem const *)arg1)->GetC(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Operator *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetD" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + try { + result = (mfem::Operator *)((mfem::OptimizationProblem const *)arg1)->GetD(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetEqualityVec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetEqualityVec" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetEqualityVec(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9495,60 +12032,31 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetInequalityVec_Lo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetInequalityVec_Lo" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetInequalityVec_Lo(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9565,53 +12073,31 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetInequalityVec_Hi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetInequalityVec_Hi" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetInequalityVec_Hi(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9628,94 +12114,72 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetBoundsVec_Lo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetBoundsVec_Lo" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + try { + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetBoundsVec_Lo(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetBoundsVec_Hi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Vector *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetBoundsVec_Hi" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "MINRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + result = (mfem::Vector *)((mfem::OptimizationProblem const *)arg1)->GetBoundsVec_Hi(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9732,86 +12196,71 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Vector, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_GetNumConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetNumConstraints" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + try { + result = (int)((mfem::OptimizationProblem const *)arg1)->GetNumConstraints(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_OptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9835,71 +12284,30 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *OptimizationProblem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationProblem, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_delete_OptimizationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationSolver" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9923,64 +12331,33 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::OptimizationProblem *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[2] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); } + arg2 = reinterpret_cast< mfem::OptimizationProblem * >(argp2); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->SetOptimizationProblem((mfem::OptimizationProblem const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10004,57 +12381,44 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[3] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_Mult" "', argument " "1"" of type '" "mfem::OptimizationSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + ((mfem::OptimizationSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10078,411 +12442,290 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Solver *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "MINRES", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MINRES__SWIG_4(self, argc, argv); - } - } - } + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_3(self, argc, argv); - } - } - } - } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MINRES__SWIG_9(self, argc, argv); - } - } - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + } + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + { + try { + (arg1)->SetPreconditioner(*arg2); } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_8(self, argc, argv); - } - } - } - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_2(self, argc, argv); - } - } - } - } - } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Operator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOperator" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_1(self, argc, argv); - } - } - } - } - } - } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_7(self, argc, argv); - } - } - } - } - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); + { + try { + (arg1)->SetOperator((mfem::Operator const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_6(self, argc, argv); - } - } - } - } - } - } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *OptimizationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_SLBQPOptimizer", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(); } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_0(self, argc, argv); - } - } - } - } - } - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::OptimizationProblem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + } + arg2 = reinterpret_cast< mfem::OptimizationProblem * >(argp2); + { + try { + (arg1)->SetOptimizationProblem((mfem::OptimizationProblem const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetBounds", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + (arg1)->SetBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MINRES'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_new_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NewtonSolver *result = 0 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "new_NewtonSolver", 0, 0, 0)) SWIG_fail; + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetLinearConstraint", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::NewtonSolver *)new mfem::NewtonSolver(); + (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10499,40 +12742,51 @@ SWIGINTERN PyObject *_wrap_new_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewtonSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetOperator" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); } - arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10556,33 +12810,23 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; - mfem::Solver *arg2 = 0 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetSolver", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetSolver" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); - } - arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetSolver" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_SetSolver" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); { try { - (arg1)->SetSolver(*arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10606,44 +12850,131 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + int arg1 ; + mfem::BlockILU::Reordering arg2 ; + int arg3 ; + int val2 ; + int ecode2 = 0 ; + mfem::BlockILU *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_Mult" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg2 = static_cast< mfem::BlockILU::Reordering >(val2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::BlockILU::Reordering arg2 ; + int val2 ; + int ecode2 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg2 = static_cast< mfem::BlockILU::Reordering >(val2); + { + try { + result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::NewtonSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + result = (mfem::BlockILU *)new mfem::BlockILU(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10660,52 +12991,54 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Operator *arg1 = 0 ; + int arg2 ; + mfem::BlockILU::Reordering arg3 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - double result; + int val3 ; + int ecode3 = 0 ; + mfem::BlockILU *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ComputeScalingFactor", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); } - arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "3"" of type '" "mfem::Vector const &""'"); + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "3"" of type '" "mfem::Vector const &""'"); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg3 = static_cast< mfem::BlockILU::Reordering >(val3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (double)((mfem::NewtonSolver const *)arg1)->ComputeScalingFactor((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10722,30 +13055,47 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; + mfem::Operator *arg1 = 0 ; + int arg2 ; + mfem::BlockILU::Reordering arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, SWIG_POINTER_DISOWN | 0 ); + int val3 ; + int ecode3 = 0 ; + mfem::BlockILU *result = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_NewtonSolver" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); } - arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg3 = static_cast< mfem::BlockILU::Reordering >(val3); { try { - delete arg1; + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10762,146 +13112,39 @@ SWIGINTERN PyObject *_wrap_delete_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *NewtonSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__NewtonSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *NewtonSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Operator *arg4 = 0 ; - int *arg5 = 0 ; - int arg6 ; - int arg7 ; - int arg8 ; - double arg9 ; - double *arg10 = 0 ; - double *arg11 = 0 ; - int arg12 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double val9 ; - int ecode9 = 0 ; - void *argp10 = 0 ; - int res10 = 0 ; - void *argp11 = 0 ; - int res11 = 0 ; - PyObject *swig_obj[12] ; - int result; + mfem::BlockILU *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "aGMRES", 12, 12, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); - } - arg4 = reinterpret_cast< mfem::Operator * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "aGMRES" "', argument " "5"" of type '" "int &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "5"" of type '" "int &""'"); - } - arg5 = reinterpret_cast< int * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); - if (!SWIG_IsOK(ecode9)) { - SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "aGMRES" "', argument " "9"" of type '" "double""'"); - } - arg9 = static_cast< double >(val9); - res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res10)) { - SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); - } - if (!argp10) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); - } - arg10 = reinterpret_cast< double * >(argp10); - res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res11)) { - SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "aGMRES" "', argument " "11"" of type '" "double &""'"); - } - if (!argp11) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "11"" of type '" "double &""'"); - } - arg11 = reinterpret_cast< double * >(argp11); { - if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg12 = PyArray_PyIntAsInt(swig_obj[11]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - result = (int)mfem::aGMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,(mfem::Operator const &)*arg4,*arg5,arg6,arg7,arg8,arg9,*arg10,*arg11,arg12); + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10918,21 +13161,32 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *result = 0 ; + mfem::Operator *arg1 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::BlockILU *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_SLBQPOptimizer", 0, 0, 0)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); { try { - result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(); + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10949,51 +13203,215 @@ SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); - return resultobj; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlockILU", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_BlockILU__SWIG_6(self, argc, argv); + } + } + if (argc == 1) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_2(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_5(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_BlockILU__SWIG_4(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + { + if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_3(self, argc, argv); + } + } + } + } + } + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlockILU'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering,int)\n" + " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering)\n" + " mfem::BlockILU::BlockILU(int)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering,int)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &,int)\n" + " mfem::BlockILU::BlockILU(mfem::Operator &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[2] ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetBounds", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BlockILU_SetOperator", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_SetOperator" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - (arg1)->SetBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11017,41 +13435,44 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; mfem::Vector *arg2 = 0 ; - double arg3 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetLinearConstraint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_Python_UnpackTuple(args, "BlockILU_Mult", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_Mult" "', argument " "1"" of type '" "mfem::BlockILU const *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockILU_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); + ((mfem::BlockILU const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11075,44 +13496,24 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_GetBlockI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; + int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); - } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_GetBlockI" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); { try { - ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + result = (int *)(arg1)->GetBlockI(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11129,40 +13530,31 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_GetBlockJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Solver *arg2 = 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; + int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetPreconditioner" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); - } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_GetBlockJ" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); { try { - (arg1)->SetPreconditioner(*arg2); + result = (int *)(arg1)->GetBlockJ(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11179,40 +13571,31 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetPreconditioner(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_GetBlockData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; + double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetOperator" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_GetBlockData" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + result = (double *)(arg1)->GetBlockData(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11229,27 +13612,27 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOperator(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_BlockILU(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BlockILU" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); { try { delete arg1; @@ -11276,19 +13659,20 @@ SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BlockILU_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BlockILU, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BlockILU_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "IterativeSolver_SetRelTol(IterativeSolver self, double rtol)"}, { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "IterativeSolver_SetAbsTol(IterativeSolver self, double atol)"}, { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "IterativeSolver_SetMaxIter(IterativeSolver self, int max_it)"}, @@ -11300,6 +13684,16 @@ static PyMethodDef SwigMethods[] = { { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "IterativeSolver_SetOperator(IterativeSolver self, Operator op)"}, { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, + { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" + "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" + "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + ""}, + { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, + { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "OperatorJacobiSmoother_Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "OperatorJacobiSmoother_SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "OperatorJacobiSmoother_Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, + { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, { "new_SLISolver", _wrap_new_SLISolver, METH_NOARGS, "new_SLISolver() -> SLISolver"}, { "SLISolver_SetOperator", _wrap_SLISolver_SetOperator, METH_VARARGS, "SLISolver_SetOperator(SLISolver self, Operator op)"}, { "SLISolver_Mult", _wrap_SLISolver_Mult, METH_VARARGS, "SLISolver_Mult(SLISolver self, Vector b, Vector x)"}, @@ -11360,23 +13754,187 @@ static PyMethodDef SwigMethods[] = { { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "NewtonSolver_SetSolver(NewtonSolver self, Solver solver)"}, { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "NewtonSolver_Mult(NewtonSolver self, Vector b, Vector x)"}, { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "NewtonSolver_ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "NewtonSolver_ProcessNewState(NewtonSolver self, Vector x)"}, { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, + { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "OptimizationProblem_CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "OptimizationProblem_CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "OptimizationProblem_SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "OptimizationProblem_SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "OptimizationProblem_SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "OptimizationProblem_GetC(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "OptimizationProblem_GetD(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "OptimizationProblem_GetEqualityVec(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Lo", _wrap_OptimizationProblem_GetInequalityVec_Lo, METH_O, "OptimizationProblem_GetInequalityVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Hi", _wrap_OptimizationProblem_GetInequalityVec_Hi, METH_O, "OptimizationProblem_GetInequalityVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Lo", _wrap_OptimizationProblem_GetBoundsVec_Lo, METH_O, "OptimizationProblem_GetBoundsVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Hi", _wrap_OptimizationProblem_GetBoundsVec_Hi, METH_O, "OptimizationProblem_GetBoundsVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetNumConstraints", _wrap_OptimizationProblem_GetNumConstraints, METH_O, "OptimizationProblem_GetNumConstraints(OptimizationProblem self) -> int"}, + { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, + { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, + { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, + { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "OptimizationSolver_SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "OptimizationSolver_Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "OptimizationSolver_SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "OptimizationSolver_SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_NOARGS, "new_SLBQPOptimizer() -> SLBQPOptimizer"}, + { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SLBQPOptimizer_SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SLBQPOptimizer_SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SLBQPOptimizer_SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "SLBQPOptimizer_Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, - { "SLBQPOptimizer_SetPreconditioner", _wrap_SLBQPOptimizer_SetPreconditioner, METH_VARARGS, "SLBQPOptimizer_SetPreconditioner(SLBQPOptimizer self, Solver pr)"}, - { "SLBQPOptimizer_SetOperator", _wrap_SLBQPOptimizer_SetOperator, METH_VARARGS, "SLBQPOptimizer_SetOperator(SLBQPOptimizer self, Operator op)"}, { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, + { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" + "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + ""}, + { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "BlockILU_SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "BlockILU_Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "BlockILU_GetBlockI(BlockILU self) -> int *"}, + { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "BlockILU_GetBlockJ(BlockILU self) -> int *"}, + { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "BlockILU_GetBlockData(BlockILU self) -> double *"}, + { "delete_BlockILU", _wrap_delete_BlockILU, METH_O, "delete_BlockILU(BlockILU self)"}, + { "BlockILU_swigregister", BlockILU_swigregister, METH_O, NULL}, + { "BlockILU_swiginit", BlockILU_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "SetRelTol(IterativeSolver self, double rtol)"}, + { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "SetAbsTol(IterativeSolver self, double atol)"}, + { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "SetMaxIter(IterativeSolver self, int max_it)"}, + { "IterativeSolver_SetPrintLevel", _wrap_IterativeSolver_SetPrintLevel, METH_VARARGS, "SetPrintLevel(IterativeSolver self, int print_lvl)"}, + { "IterativeSolver_GetNumIterations", _wrap_IterativeSolver_GetNumIterations, METH_O, "GetNumIterations(IterativeSolver self) -> int"}, + { "IterativeSolver_GetConverged", _wrap_IterativeSolver_GetConverged, METH_O, "GetConverged(IterativeSolver self) -> int"}, + { "IterativeSolver_GetFinalNorm", _wrap_IterativeSolver_GetFinalNorm, METH_O, "GetFinalNorm(IterativeSolver self) -> double"}, + { "IterativeSolver_SetPreconditioner", _wrap_IterativeSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(IterativeSolver self, Solver pr)"}, + { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "SetOperator(IterativeSolver self, Operator op)"}, + { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, + { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, + { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" + "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" + "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + ""}, + { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, + { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, + { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, + { "new_SLISolver", _wrap_new_SLISolver, METH_NOARGS, "new_SLISolver() -> SLISolver"}, + { "SLISolver_SetOperator", _wrap_SLISolver_SetOperator, METH_VARARGS, "SetOperator(SLISolver self, Operator op)"}, + { "SLISolver_Mult", _wrap_SLISolver_Mult, METH_VARARGS, "Mult(SLISolver self, Vector b, Vector x)"}, + { "delete_SLISolver", _wrap_delete_SLISolver, METH_O, "delete_SLISolver(SLISolver self)"}, + { "SLISolver_swigregister", SLISolver_swigregister, METH_O, NULL}, + { "SLISolver_swiginit", SLISolver_swiginit, METH_VARARGS, NULL}, + { "SLI", _wrap_SLI, METH_VARARGS, "\n" + "SLI(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)\n" + "SLI(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)\n" + ""}, + { "new_CGSolver", _wrap_new_CGSolver, METH_NOARGS, "new_CGSolver() -> CGSolver"}, + { "CGSolver_SetOperator", _wrap_CGSolver_SetOperator, METH_VARARGS, "SetOperator(CGSolver self, Operator op)"}, + { "CGSolver_Mult", _wrap_CGSolver_Mult, METH_VARARGS, "Mult(CGSolver self, Vector b, Vector x)"}, + { "delete_CGSolver", _wrap_delete_CGSolver, METH_O, "delete_CGSolver(CGSolver self)"}, + { "CGSolver_swigregister", CGSolver_swigregister, METH_O, NULL}, + { "CGSolver_swiginit", CGSolver_swiginit, METH_VARARGS, NULL}, + { "CG", _wrap_CG, METH_VARARGS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "PCG", _wrap_PCG, METH_VARARGS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "new_GMRESSolver", _wrap_new_GMRESSolver, METH_NOARGS, "new_GMRESSolver() -> GMRESSolver"}, + { "GMRESSolver_SetKDim", _wrap_GMRESSolver_SetKDim, METH_VARARGS, "SetKDim(GMRESSolver self, int dim)"}, + { "GMRESSolver_Mult", _wrap_GMRESSolver_Mult, METH_VARARGS, "Mult(GMRESSolver self, Vector b, Vector x)"}, + { "delete_GMRESSolver", _wrap_delete_GMRESSolver, METH_O, "delete_GMRESSolver(GMRESSolver self)"}, + { "GMRESSolver_swigregister", GMRESSolver_swigregister, METH_O, NULL}, + { "GMRESSolver_swiginit", GMRESSolver_swiginit, METH_VARARGS, NULL}, + { "new_FGMRESSolver", _wrap_new_FGMRESSolver, METH_NOARGS, "new_FGMRESSolver() -> FGMRESSolver"}, + { "FGMRESSolver_SetKDim", _wrap_FGMRESSolver_SetKDim, METH_VARARGS, "SetKDim(FGMRESSolver self, int dim)"}, + { "FGMRESSolver_Mult", _wrap_FGMRESSolver_Mult, METH_VARARGS, "Mult(FGMRESSolver self, Vector b, Vector x)"}, + { "delete_FGMRESSolver", _wrap_delete_FGMRESSolver, METH_O, "delete_FGMRESSolver(FGMRESSolver self)"}, + { "FGMRESSolver_swigregister", FGMRESSolver_swigregister, METH_O, NULL}, + { "FGMRESSolver_swiginit", FGMRESSolver_swiginit, METH_VARARGS, NULL}, + { "GMRES", _wrap_GMRES, METH_VARARGS, "\n" + "GMRES(Operator A, Vector x, Vector b, Solver M, int & max_iter, int m, double & tol, double atol, int printit) -> int\n" + "GMRES(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, int m=50, double rtol=1e-12, double atol=1e-24)\n" + ""}, + { "new_BiCGSTABSolver", _wrap_new_BiCGSTABSolver, METH_NOARGS, "new_BiCGSTABSolver() -> BiCGSTABSolver"}, + { "BiCGSTABSolver_SetOperator", _wrap_BiCGSTABSolver_SetOperator, METH_VARARGS, "SetOperator(BiCGSTABSolver self, Operator op)"}, + { "BiCGSTABSolver_Mult", _wrap_BiCGSTABSolver_Mult, METH_VARARGS, "Mult(BiCGSTABSolver self, Vector b, Vector x)"}, + { "delete_BiCGSTABSolver", _wrap_delete_BiCGSTABSolver, METH_O, "delete_BiCGSTABSolver(BiCGSTABSolver self)"}, + { "BiCGSTABSolver_swigregister", BiCGSTABSolver_swigregister, METH_O, NULL}, + { "BiCGSTABSolver_swiginit", BiCGSTABSolver_swiginit, METH_VARARGS, NULL}, + { "BiCGSTAB", _wrap_BiCGSTAB, METH_VARARGS, "\n" + "BiCGSTAB(Operator A, Vector x, Vector b, Solver M, int & max_iter, double & tol, double atol, int printit) -> int\n" + "BiCGSTAB(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double rtol=1e-12, double atol=1e-24)\n" + ""}, + { "new_MINRESSolver", _wrap_new_MINRESSolver, METH_NOARGS, "new_MINRESSolver() -> MINRESSolver"}, + { "MINRESSolver_SetPreconditioner", _wrap_MINRESSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(MINRESSolver self, Solver pr)"}, + { "MINRESSolver_SetOperator", _wrap_MINRESSolver_SetOperator, METH_VARARGS, "SetOperator(MINRESSolver self, Operator op)"}, + { "MINRESSolver_Mult", _wrap_MINRESSolver_Mult, METH_VARARGS, "Mult(MINRESSolver self, Vector b, Vector x)"}, + { "delete_MINRESSolver", _wrap_delete_MINRESSolver, METH_O, "delete_MINRESSolver(MINRESSolver self)"}, + { "MINRESSolver_swigregister", MINRESSolver_swigregister, METH_O, NULL}, + { "MINRESSolver_swiginit", MINRESSolver_swiginit, METH_VARARGS, NULL}, + { "MINRES", _wrap_MINRES, METH_VARARGS, "\n" + "MINRES(Operator A, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24)\n" + "MINRES(Operator A, Solver B, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24)\n" + ""}, + { "new_NewtonSolver", _wrap_new_NewtonSolver, METH_NOARGS, "new_NewtonSolver() -> NewtonSolver"}, + { "NewtonSolver_SetOperator", _wrap_NewtonSolver_SetOperator, METH_VARARGS, "SetOperator(NewtonSolver self, Operator op)"}, + { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "SetSolver(NewtonSolver self, Solver solver)"}, + { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "Mult(NewtonSolver self, Vector b, Vector x)"}, + { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "ProcessNewState(NewtonSolver self, Vector x)"}, + { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, + { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, + { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, + { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, + { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "GetC(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "GetD(OptimizationProblem self) -> Operator"}, + { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "GetEqualityVec(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Lo", _wrap_OptimizationProblem_GetInequalityVec_Lo, METH_O, "GetInequalityVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetInequalityVec_Hi", _wrap_OptimizationProblem_GetInequalityVec_Hi, METH_O, "GetInequalityVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Lo", _wrap_OptimizationProblem_GetBoundsVec_Lo, METH_O, "GetBoundsVec_Lo(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetBoundsVec_Hi", _wrap_OptimizationProblem_GetBoundsVec_Hi, METH_O, "GetBoundsVec_Hi(OptimizationProblem self) -> Vector"}, + { "OptimizationProblem_GetNumConstraints", _wrap_OptimizationProblem_GetNumConstraints, METH_O, "GetNumConstraints(OptimizationProblem self) -> int"}, + { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, + { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, + { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, + { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, + { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_NOARGS, "new_SLBQPOptimizer() -> SLBQPOptimizer"}, + { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, + { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, + { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, + { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, + { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, + { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, + { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, + { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" + "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + ""}, + { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "GetBlockI(BlockILU self) -> int *"}, + { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "GetBlockJ(BlockILU self) -> int *"}, + { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "GetBlockData(BlockILU self) -> double *"}, + { "delete_BlockILU", _wrap_delete_BlockILU, METH_O, "delete_BlockILU(BlockILU self)"}, + { "BlockILU_swigregister", BlockILU_swigregister, METH_O, NULL}, + { "BlockILU_swiginit", BlockILU_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -11389,6 +13947,9 @@ static void *_p_mfem__BiCGSTABSolverTo_p_mfem__IterativeSolver(void *x, int *SWI static void *_p_mfem__NewtonSolverTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); } +static void *_p_mfem__OptimizationSolverTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::IterativeSolver *) ((mfem::OptimizationSolver *) x)); +} static void *_p_mfem__SLISolverTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::IterativeSolver *) ((mfem::SLISolver *) x)); } @@ -11405,40 +13966,52 @@ static void *_p_mfem__MINRESSolverTo_p_mfem__IterativeSolver(void *x, int *SWIGU return (void *)((mfem::IterativeSolver *) ((mfem::MINRESSolver *) x)); } static void *_p_mfem__SLBQPOptimizerTo_p_mfem__IterativeSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::IterativeSolver *) ((mfem::SLBQPOptimizer *) x)); + return (void *)((mfem::IterativeSolver *) (mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); } -static void *_p_mfem__BiCGSTABSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::BiCGSTABSolver *) x)); -} -static void *_p_mfem__NewtonSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); +static void *_p_mfem__MINRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::MINRESSolver *) x)); } -static void *_p_mfem__IterativeSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) ((mfem::IterativeSolver *) x)); +static void *_p_mfem__FGMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::FGMRESSolver *) x)); } -static void *_p_mfem__SLISolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::SLISolver *) x)); +static void *_p_mfem__GMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::GMRESSolver *) x)); } static void *_p_mfem__CGSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::CGSolver *) x)); } -static void *_p_mfem__GMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::GMRESSolver *) x)); +static void *_p_mfem__SLISolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::SLISolver *) x)); } -static void *_p_mfem__FGMRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::FGMRESSolver *) x)); +static void *_p_mfem__IterativeSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) ((mfem::IterativeSolver *) x)); } -static void *_p_mfem__MINRESSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::MINRESSolver *) x)); +static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); } static void *_p_mfem__MatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Solver *) ((mfem::MatrixInverse *) x)); } -static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::MatrixInverse *) ((mfem::DenseMatrixInverse *) x)); +static void *_p_mfem__OptimizationSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::OptimizationSolver *) x)); +} +static void *_p_mfem__NewtonSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); +} +static void *_p_mfem__BiCGSTABSolverTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::BiCGSTABSolver *) x)); } static void *_p_mfem__SLBQPOptimizerTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Solver *) (mfem::IterativeSolver *) ((mfem::SLBQPOptimizer *) x)); + return (void *)((mfem::Solver *) (mfem::IterativeSolver *)(mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); +} +static void *_p_mfem__BlockILUTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) ((mfem::BlockILU *) x)); +} +static void *_p_mfem__OperatorJacobiSmootherTo_p_mfem__Solver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Solver *) ((mfem::OperatorJacobiSmoother *) x)); +} +static void *_p_mfem__SLBQPOptimizerTo_p_mfem__OptimizationSolver(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); } static void *_p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::PyTimeDependentOperatorBase *) x)); @@ -11479,21 +14052,30 @@ static void *_p_mfem__BiCGSTABSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSED static void *_p_mfem__NewtonSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *) ((mfem::NewtonSolver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +static void *_p_mfem__OptimizationSolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *) ((mfem::OptimizationSolver *) x)); } static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__SLBQPOptimizerTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *) ((mfem::SLBQPOptimizer *) x)); + return (void *)((mfem::Operator *) (mfem::Solver *)(mfem::IterativeSolver *)(mfem::OptimizationSolver *) ((mfem::SLBQPOptimizer *) x)); +} +static void *_p_mfem__BlockILUTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::BlockILU *) x)); } static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -11509,17 +14091,29 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } +static void *_p_mfem__OperatorJacobiSmootherTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Solver *) ((mfem::OperatorJacobiSmoother *) x)); +} static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__BiCGSTABSolver = {"_p_mfem__BiCGSTABSolver", "mfem::BiCGSTABSolver *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__BilinearForm = {"_p_mfem__BilinearForm", "mfem::BilinearForm *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__BlockILU = {"_p_mfem__BlockILU", "mfem::BlockILU *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__CGSolver = {"_p_mfem__CGSolver", "mfem::CGSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__FGMRESSolver = {"_p_mfem__FGMRESSolver", "mfem::FGMRESSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__GMRESSolver = {"_p_mfem__GMRESSolver", "mfem::GMRESSolver *", 0, 0, (void*)0, 0}; @@ -11531,17 +14125,23 @@ static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__P static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__OperatorJacobiSmoother = {"_p_mfem__OperatorJacobiSmoother", "mfem::OperatorJacobiSmoother *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__OptimizationProblem = {"_p_mfem__OptimizationProblem", "mfem::OptimizationProblem *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__OptimizationSolver = {"_p_mfem__OptimizationSolver", "mfem::OptimizationSolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SLBQPOptimizer = {"_p_mfem__SLBQPOptimizer", "mfem::SLBQPOptimizer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SLISolver = {"_p_mfem__SLISolver", "mfem::SLISolver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; @@ -11553,7 +14153,10 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_double, &_swigt__p_int, &_swigt__p_mfem__AbstractSparseMatrix, + &_swigt__p_mfem__ArrayT_int_t, &_swigt__p_mfem__BiCGSTABSolver, + &_swigt__p_mfem__BilinearForm, + &_swigt__p_mfem__BlockILU, &_swigt__p_mfem__CGSolver, &_swigt__p_mfem__ConstrainedOperator, &_swigt__p_mfem__DenseMatrix, @@ -11567,12 +14170,18 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__MatrixInverse, &_swigt__p_mfem__NewtonSolver, &_swigt__p_mfem__Operator, + &_swigt__p_mfem__OperatorJacobiSmoother, + &_swigt__p_mfem__OptimizationProblem, + &_swigt__p_mfem__OptimizationSolver, &_swigt__p_mfem__ProductOperator, &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__SLBQPOptimizer, &_swigt__p_mfem__SLISolver, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -11585,32 +14194,41 @@ static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__BiCGSTABSolver[] = { {&_swigt__p_mfem__BiCGSTABSolver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BilinearForm[] = { {&_swigt__p_mfem__BilinearForm, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__BlockILU[] = { {&_swigt__p_mfem__BlockILU, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__CGSolver[] = { {&_swigt__p_mfem__CGSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__FGMRESSolver[] = { {&_swigt__p_mfem__FGMRESSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__GMRESSolver[] = { {&_swigt__p_mfem__GMRESSolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__IterativeSolver[] = { {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__IterativeSolver, 0, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__IterativeSolver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__IterativeSolver[] = { {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__OptimizationSolver, _p_mfem__OptimizationSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__IterativeSolver, 0, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__IterativeSolver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__IterativeSolver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MINRESSolver[] = { {&_swigt__p_mfem__MINRESSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__NewtonSolver[] = { {&_swigt__p_mfem__NewtonSolver, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = {{&_swigt__p_mfem__MatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = {{&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__OptimizationSolver, _p_mfem__OptimizationSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__BlockILU, _p_mfem__BlockILUTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__OperatorJacobiSmoother, _p_mfem__OperatorJacobiSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OperatorJacobiSmoother[] = { {&_swigt__p_mfem__OperatorJacobiSmoother, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OptimizationProblem[] = { {&_swigt__p_mfem__OptimizationProblem, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__OptimizationSolver[] = { {&_swigt__p_mfem__OptimizationSolver, 0, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__OptimizationSolver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SLBQPOptimizer[] = { {&_swigt__p_mfem__SLBQPOptimizer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SLISolver[] = { {&_swigt__p_mfem__SLISolver, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__MINRESSolver, _p_mfem__MINRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__FGMRESSolver, _p_mfem__FGMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__GMRESSolver, _p_mfem__GMRESSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__CGSolver, _p_mfem__CGSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLISolver, _p_mfem__SLISolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__IterativeSolver, _p_mfem__IterativeSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__OptimizationSolver, _p_mfem__OptimizationSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__NewtonSolver, _p_mfem__NewtonSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__BiCGSTABSolver, _p_mfem__BiCGSTABSolverTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__SLBQPOptimizer, _p_mfem__SLBQPOptimizerTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__BlockILU, _p_mfem__BlockILUTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__OperatorJacobiSmoother, _p_mfem__OperatorJacobiSmootherTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Vector[] = { {&_swigt__p_mfem__Vector, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { @@ -11619,7 +14237,10 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_double, _swigc__p_int, _swigc__p_mfem__AbstractSparseMatrix, + _swigc__p_mfem__ArrayT_int_t, _swigc__p_mfem__BiCGSTABSolver, + _swigc__p_mfem__BilinearForm, + _swigc__p_mfem__BlockILU, _swigc__p_mfem__CGSolver, _swigc__p_mfem__ConstrainedOperator, _swigc__p_mfem__DenseMatrix, @@ -11633,12 +14254,18 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__MatrixInverse, _swigc__p_mfem__NewtonSolver, _swigc__p_mfem__Operator, + _swigc__p_mfem__OperatorJacobiSmoother, + _swigc__p_mfem__OptimizationProblem, + _swigc__p_mfem__OptimizationSolver, _swigc__p_mfem__ProductOperator, _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__SLBQPOptimizer, _swigc__p_mfem__SLISolver, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, @@ -12377,6 +15004,8 @@ SWIG_init(void) { import_array(); + SWIG_Python_SetConstant(d, "BlockILU_Reordering_MINIMUM_DISCARDED_FILL",SWIG_From_int(static_cast< int >(mfem::BlockILU::Reordering::MINIMUM_DISCARDED_FILL))); + SWIG_Python_SetConstant(d, "BlockILU_Reordering_NONE",SWIG_From_int(static_cast< int >(mfem::BlockILU::Reordering::NONE))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_ser/sparsemat.py b/mfem/_ser/sparsemat.py index a3a0a5b9..b00c1a99 100644 --- a/mfem/_ser/sparsemat.py +++ b/mfem/_ser/sparsemat.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _sparsemat.SWIG_PyInstanceMethod_New +_swig_new_static_method = _sparsemat.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -73,18 +76,22 @@ class _SwigNonDynamicMeta(type): def RAP_P(A, R, ORAP): r"""RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix""" return _sparsemat.RAP_P(A, R, ORAP) +RAP_P = _sparsemat.RAP_P def RAP_R(Rt, A, P): r"""RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix""" return _sparsemat.RAP_R(Rt, A, P) +RAP_R = _sparsemat.RAP_R def OperatorPtr2SparseMatrix(op): r"""OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix""" return _sparsemat.OperatorPtr2SparseMatrix(op) +OperatorPtr2SparseMatrix = _sparsemat.OperatorPtr2SparseMatrix def OperatorHandle2SparseMatrix(op): r"""OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix""" return _sparsemat.OperatorHandle2SparseMatrix(op) +OperatorHandle2SparseMatrix = _sparsemat.OperatorHandle2SparseMatrix class RowNode(object): r"""Proxy of C++ mfem::RowNode class.""" @@ -148,18 +155,22 @@ def __init__(self, *args): def MakeRef(self, master): r"""MakeRef(SparseMatrix self, SparseMatrix master)""" return _sparsemat.SparseMatrix_MakeRef(self, master) + MakeRef = _swig_new_instance_method(_sparsemat.SparseMatrix_MakeRef) def Size(self): r"""Size(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_Size(self) + Size = _swig_new_instance_method(_sparsemat.SparseMatrix_Size) def Clear(self): r"""Clear(SparseMatrix self)""" return _sparsemat.SparseMatrix_Clear(self) + Clear = _swig_new_instance_method(_sparsemat.SparseMatrix_Clear) def Empty(self): r"""Empty(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_Empty(self) + Empty = _swig_new_instance_method(_sparsemat.SparseMatrix_Empty) def GetI(self, *args): r""" @@ -167,6 +178,7 @@ def GetI(self, *args): GetI(SparseMatrix self) -> int const * """ return _sparsemat.SparseMatrix_GetI(self, *args) + GetI = _swig_new_instance_method(_sparsemat.SparseMatrix_GetI) def GetJ(self, *args): r""" @@ -174,6 +186,7 @@ def GetJ(self, *args): GetJ(SparseMatrix self) -> int const * """ return _sparsemat.SparseMatrix_GetJ(self, *args) + GetJ = _swig_new_instance_method(_sparsemat.SparseMatrix_GetJ) def GetData(self, *args): r""" @@ -181,14 +194,131 @@ def GetData(self, *args): GetData(SparseMatrix self) -> double const * """ return _sparsemat.SparseMatrix_GetData(self, *args) + GetData = _swig_new_instance_method(_sparsemat.SparseMatrix_GetData) + + def GetMemoryI(self, *args): + r""" + GetMemoryI(SparseMatrix self) -> mfem::Memory< int > + GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const & + """ + return _sparsemat.SparseMatrix_GetMemoryI(self, *args) + GetMemoryI = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryI) + + def ReadI(self, on_dev=True): + r"""ReadI(SparseMatrix self, bool on_dev=True) -> int const""" + return _sparsemat.SparseMatrix_ReadI(self, on_dev) + ReadI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadI) + + def WriteI(self, on_dev=True): + r"""WriteI(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_WriteI(self, on_dev) + WriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteI) + + def ReadWriteI(self, on_dev=True): + r"""ReadWriteI(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_ReadWriteI(self, on_dev) + ReadWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteI) + + def HostReadI(self): + r"""HostReadI(SparseMatrix self) -> int const *""" + return _sparsemat.SparseMatrix_HostReadI(self) + HostReadI = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadI) + + def HostWriteI(self): + r"""HostWriteI(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostWriteI(self) + HostWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_HostWriteI) + + def HostReadWriteI(self): + r"""HostReadWriteI(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostReadWriteI(self) + HostReadWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadWriteI) + + def GetMemoryJ(self, *args): + r""" + GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > + GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const & + """ + return _sparsemat.SparseMatrix_GetMemoryJ(self, *args) + GetMemoryJ = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryJ) + + def ReadJ(self, on_dev=True): + r"""ReadJ(SparseMatrix self, bool on_dev=True) -> int const""" + return _sparsemat.SparseMatrix_ReadJ(self, on_dev) + ReadJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadJ) + + def WriteJ(self, on_dev=True): + r"""WriteJ(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_WriteJ(self, on_dev) + WriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteJ) + + def ReadWriteJ(self, on_dev=True): + r"""ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int""" + return _sparsemat.SparseMatrix_ReadWriteJ(self, on_dev) + ReadWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteJ) + + def HostReadJ(self): + r"""HostReadJ(SparseMatrix self) -> int const *""" + return _sparsemat.SparseMatrix_HostReadJ(self) + HostReadJ = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadJ) + + def HostWriteJ(self): + r"""HostWriteJ(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostWriteJ(self) + HostWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_HostWriteJ) + + def HostReadWriteJ(self): + r"""HostReadWriteJ(SparseMatrix self) -> int *""" + return _sparsemat.SparseMatrix_HostReadWriteJ(self) + HostReadWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadWriteJ) + + def GetMemoryData(self, *args): + r""" + GetMemoryData(SparseMatrix self) -> mfem::Memory< double > + GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const & + """ + return _sparsemat.SparseMatrix_GetMemoryData(self, *args) + GetMemoryData = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryData) + + def ReadData(self, on_dev=True): + r"""ReadData(SparseMatrix self, bool on_dev=True) -> double const""" + return _sparsemat.SparseMatrix_ReadData(self, on_dev) + ReadData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadData) + + def WriteData(self, on_dev=True): + r"""WriteData(SparseMatrix self, bool on_dev=True) -> double""" + return _sparsemat.SparseMatrix_WriteData(self, on_dev) + WriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteData) + + def ReadWriteData(self, on_dev=True): + r"""ReadWriteData(SparseMatrix self, bool on_dev=True) -> double""" + return _sparsemat.SparseMatrix_ReadWriteData(self, on_dev) + ReadWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteData) + + def HostReadData(self): + r"""HostReadData(SparseMatrix self) -> double const *""" + return _sparsemat.SparseMatrix_HostReadData(self) + HostReadData = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadData) + + def HostWriteData(self): + r"""HostWriteData(SparseMatrix self) -> double *""" + return _sparsemat.SparseMatrix_HostWriteData(self) + HostWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_HostWriteData) + + def HostReadWriteData(self): + r"""HostReadWriteData(SparseMatrix self) -> double *""" + return _sparsemat.SparseMatrix_HostReadWriteData(self) + HostReadWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_HostReadWriteData) def RowSize(self, i): r"""RowSize(SparseMatrix self, int const i) -> int""" return _sparsemat.SparseMatrix_RowSize(self, i) + RowSize = _swig_new_instance_method(_sparsemat.SparseMatrix_RowSize) def MaxRowSize(self): r"""MaxRowSize(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_MaxRowSize(self) + MaxRowSize = _swig_new_instance_method(_sparsemat.SparseMatrix_MaxRowSize) def GetRowColumns(self, *args): r""" @@ -196,6 +326,7 @@ def GetRowColumns(self, *args): GetRowColumns(SparseMatrix self, int const row) -> int const * """ return _sparsemat.SparseMatrix_GetRowColumns(self, *args) + GetRowColumns = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowColumns) def GetRowEntries(self, *args): r""" @@ -203,22 +334,27 @@ def GetRowEntries(self, *args): GetRowEntries(SparseMatrix self, int const row) -> double const * """ return _sparsemat.SparseMatrix_GetRowEntries(self, *args) + GetRowEntries = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowEntries) def SetWidth(self, width_=-1): r"""SetWidth(SparseMatrix self, int width_=-1)""" return _sparsemat.SparseMatrix_SetWidth(self, width_) + SetWidth = _swig_new_instance_method(_sparsemat.SparseMatrix_SetWidth) def ActualWidth(self): r"""ActualWidth(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_ActualWidth(self) + ActualWidth = _swig_new_instance_method(_sparsemat.SparseMatrix_ActualWidth) def SortColumnIndices(self): r"""SortColumnIndices(SparseMatrix self)""" return _sparsemat.SparseMatrix_SortColumnIndices(self) + SortColumnIndices = _swig_new_instance_method(_sparsemat.SparseMatrix_SortColumnIndices) def MoveDiagonalFirst(self): r"""MoveDiagonalFirst(SparseMatrix self)""" return _sparsemat.SparseMatrix_MoveDiagonalFirst(self) + MoveDiagonalFirst = _swig_new_instance_method(_sparsemat.SparseMatrix_MoveDiagonalFirst) def Elem(self, *args): r""" @@ -226,6 +362,7 @@ def Elem(self, *args): Elem(SparseMatrix self, int i, int j) -> double const & """ return _sparsemat.SparseMatrix_Elem(self, *args) + Elem = _swig_new_instance_method(_sparsemat.SparseMatrix_Elem) def __call__(self, *args): r""" @@ -233,10 +370,12 @@ def __call__(self, *args): __call__(SparseMatrix self, int i, int j) -> double const & """ return _sparsemat.SparseMatrix___call__(self, *args) + __call__ = _swig_new_instance_method(_sparsemat.SparseMatrix___call__) def GetDiag(self, d): r"""GetDiag(SparseMatrix self, Vector d)""" return _sparsemat.SparseMatrix_GetDiag(self, d) + GetDiag = _swig_new_instance_method(_sparsemat.SparseMatrix_GetDiag) def ToDenseMatrix(self, *args): r""" @@ -244,66 +383,82 @@ def ToDenseMatrix(self, *args): ToDenseMatrix(SparseMatrix self, DenseMatrix B) """ return _sparsemat.SparseMatrix_ToDenseMatrix(self, *args) + ToDenseMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_ToDenseMatrix) def GetMemoryClass(self): r"""GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass""" return _sparsemat.SparseMatrix_GetMemoryClass(self) + GetMemoryClass = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryClass) def Mult(self, x, y): r"""Mult(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_Mult(self, x, y) + Mult = _swig_new_instance_method(_sparsemat.SparseMatrix_Mult) def AddMult(self, x, y, a=1.0): r"""AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)""" return _sparsemat.SparseMatrix_AddMult(self, x, y, a) + AddMult = _swig_new_instance_method(_sparsemat.SparseMatrix_AddMult) def MultTranspose(self, x, y): r"""MultTranspose(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_MultTranspose(self, x, y) + MultTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_MultTranspose) def AddMultTranspose(self, x, y, a=1.0): r"""AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)""" return _sparsemat.SparseMatrix_AddMultTranspose(self, x, y, a) + AddMultTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_AddMultTranspose) def BuildTranspose(self): r"""BuildTranspose(SparseMatrix self)""" return _sparsemat.SparseMatrix_BuildTranspose(self) + BuildTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_BuildTranspose) def ResetTranspose(self): r"""ResetTranspose(SparseMatrix self)""" return _sparsemat.SparseMatrix_ResetTranspose(self) + ResetTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_ResetTranspose) def PartMult(self, rows, x, y): r"""PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)""" return _sparsemat.SparseMatrix_PartMult(self, rows, x, y) + PartMult = _swig_new_instance_method(_sparsemat.SparseMatrix_PartMult) def PartAddMult(self, rows, x, y, a=1.0): r"""PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)""" return _sparsemat.SparseMatrix_PartAddMult(self, rows, x, y, a) + PartAddMult = _swig_new_instance_method(_sparsemat.SparseMatrix_PartAddMult) def BooleanMult(self, x, y): r"""BooleanMult(SparseMatrix self, intArray x, intArray y)""" return _sparsemat.SparseMatrix_BooleanMult(self, x, y) + BooleanMult = _swig_new_instance_method(_sparsemat.SparseMatrix_BooleanMult) def BooleanMultTranspose(self, x, y): r"""BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)""" return _sparsemat.SparseMatrix_BooleanMultTranspose(self, x, y) + BooleanMultTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_BooleanMultTranspose) def InnerProduct(self, x, y): r"""InnerProduct(SparseMatrix self, Vector x, Vector y) -> double""" return _sparsemat.SparseMatrix_InnerProduct(self, x, y) + InnerProduct = _swig_new_instance_method(_sparsemat.SparseMatrix_InnerProduct) def GetRowSums(self, x): r"""GetRowSums(SparseMatrix self, Vector x)""" return _sparsemat.SparseMatrix_GetRowSums(self, x) + GetRowSums = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowSums) def GetRowNorml1(self, irow): r"""GetRowNorml1(SparseMatrix self, int irow) -> double""" return _sparsemat.SparseMatrix_GetRowNorml1(self, irow) + GetRowNorml1 = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRowNorml1) def Inverse(self): r"""Inverse(SparseMatrix self) -> MatrixInverse""" return _sparsemat.SparseMatrix_Inverse(self) + Inverse = _swig_new_instance_method(_sparsemat.SparseMatrix_Inverse) def EliminateRow(self, *args): r""" @@ -311,22 +466,30 @@ def EliminateRow(self, *args): EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO) """ return _sparsemat.SparseMatrix_EliminateRow(self, *args) + EliminateRow = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRow) def EliminateCol(self, *args): r"""EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)""" return _sparsemat.SparseMatrix_EliminateCol(self, *args) + EliminateCol = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCol) - def EliminateCols(self, cols, x=None, b=None): - r"""EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)""" - return _sparsemat.SparseMatrix_EliminateCols(self, cols, x, b) + def EliminateCols(self, *args): + r""" + EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None) + EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae) + """ + return _sparsemat.SparseMatrix_EliminateCols(self, *args) + EliminateCols = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCols) def EliminateRowColMultipleRHS(self, *args): r"""EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)""" return _sparsemat.SparseMatrix_EliminateRowColMultipleRHS(self, *args) + EliminateRowColMultipleRHS = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowColMultipleRHS) def EliminateRowColDiag(self, rc, value): r"""EliminateRowColDiag(SparseMatrix self, int rc, double value)""" return _sparsemat.SparseMatrix_EliminateRowColDiag(self, rc, value) + EliminateRowColDiag = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowColDiag) def EliminateRowCol(self, *args): r""" @@ -335,42 +498,52 @@ def EliminateRowCol(self, *args): EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE) """ return _sparsemat.SparseMatrix_EliminateRowCol(self, *args) + EliminateRowCol = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowCol) def SetDiagIdentity(self): r"""SetDiagIdentity(SparseMatrix self)""" return _sparsemat.SparseMatrix_SetDiagIdentity(self) + SetDiagIdentity = _swig_new_instance_method(_sparsemat.SparseMatrix_SetDiagIdentity) def EliminateZeroRows(self, threshold=1e-12): r"""EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)""" return _sparsemat.SparseMatrix_EliminateZeroRows(self, threshold) + EliminateZeroRows = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateZeroRows) def Gauss_Seidel_forw(self, x, y): r"""Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_Gauss_Seidel_forw(self, x, y) + Gauss_Seidel_forw = _swig_new_instance_method(_sparsemat.SparseMatrix_Gauss_Seidel_forw) def Gauss_Seidel_back(self, x, y): r"""Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)""" return _sparsemat.SparseMatrix_Gauss_Seidel_back(self, x, y) + Gauss_Seidel_back = _swig_new_instance_method(_sparsemat.SparseMatrix_Gauss_Seidel_back) def GetJacobiScaling(self): r"""GetJacobiScaling(SparseMatrix self) -> double""" return _sparsemat.SparseMatrix_GetJacobiScaling(self) + GetJacobiScaling = _swig_new_instance_method(_sparsemat.SparseMatrix_GetJacobiScaling) def Jacobi(self, b, x0, x1, sc): r"""Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)""" return _sparsemat.SparseMatrix_Jacobi(self, b, x0, x1, sc) + Jacobi = _swig_new_instance_method(_sparsemat.SparseMatrix_Jacobi) def DiagScale(self, b, x, sc=1.0): r"""DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)""" return _sparsemat.SparseMatrix_DiagScale(self, b, x, sc) + DiagScale = _swig_new_instance_method(_sparsemat.SparseMatrix_DiagScale) def Jacobi2(self, b, x0, x1, sc=1.0): r"""Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)""" return _sparsemat.SparseMatrix_Jacobi2(self, b, x0, x1, sc) + Jacobi2 = _swig_new_instance_method(_sparsemat.SparseMatrix_Jacobi2) def Jacobi3(self, b, x0, x1, sc=1.0): r"""Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)""" return _sparsemat.SparseMatrix_Jacobi3(self, b, x0, x1, sc) + Jacobi3 = _swig_new_instance_method(_sparsemat.SparseMatrix_Jacobi3) def Finalize(self, *args): r""" @@ -378,38 +551,47 @@ def Finalize(self, *args): Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows) """ return _sparsemat.SparseMatrix_Finalize(self, *args) + Finalize = _swig_new_instance_method(_sparsemat.SparseMatrix_Finalize) def Finalized(self): r"""Finalized(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_Finalized(self) + Finalized = _swig_new_instance_method(_sparsemat.SparseMatrix_Finalized) - def areColumnsSorted(self): - r"""areColumnsSorted(SparseMatrix self) -> bool""" - return _sparsemat.SparseMatrix_areColumnsSorted(self) + def ColumnsAreSorted(self): + r"""ColumnsAreSorted(SparseMatrix self) -> bool""" + return _sparsemat.SparseMatrix_ColumnsAreSorted(self) + ColumnsAreSorted = _swig_new_instance_method(_sparsemat.SparseMatrix_ColumnsAreSorted) def Threshold(self, tol, fix_empty_rows=False): r"""Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)""" return _sparsemat.SparseMatrix_Threshold(self, tol, fix_empty_rows) + Threshold = _swig_new_instance_method(_sparsemat.SparseMatrix_Threshold) def GetBlocks(self, blocks): r"""GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)""" return _sparsemat.SparseMatrix_GetBlocks(self, blocks) + GetBlocks = _swig_new_instance_method(_sparsemat.SparseMatrix_GetBlocks) def GetSubMatrix(self, rows, cols, subm): r"""GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)""" return _sparsemat.SparseMatrix_GetSubMatrix(self, rows, cols, subm) + GetSubMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_GetSubMatrix) def SetColPtr(self, row): r"""SetColPtr(SparseMatrix self, int const row)""" return _sparsemat.SparseMatrix_SetColPtr(self, row) + SetColPtr = _swig_new_instance_method(_sparsemat.SparseMatrix_SetColPtr) def ClearColPtr(self): r"""ClearColPtr(SparseMatrix self)""" return _sparsemat.SparseMatrix_ClearColPtr(self) + ClearColPtr = _swig_new_instance_method(_sparsemat.SparseMatrix_ClearColPtr) def _Get_(self, col): r"""_Get_(SparseMatrix self, int const col) -> double""" return _sparsemat.SparseMatrix__Get_(self, col) + _Get_ = _swig_new_instance_method(_sparsemat.SparseMatrix__Get_) def SearchRow(self, *args): r""" @@ -417,6 +599,7 @@ def SearchRow(self, *args): SearchRow(SparseMatrix self, int const row, int const col) -> double & """ return _sparsemat.SparseMatrix_SearchRow(self, *args) + SearchRow = _swig_new_instance_method(_sparsemat.SparseMatrix_SearchRow) def _Add_(self, *args): r""" @@ -424,6 +607,7 @@ def _Add_(self, *args): _Add_(SparseMatrix self, int const row, int const col, double const a) """ return _sparsemat.SparseMatrix__Add_(self, *args) + _Add_ = _swig_new_instance_method(_sparsemat.SparseMatrix__Add_) def _Set_(self, *args): r""" @@ -431,50 +615,62 @@ def _Set_(self, *args): _Set_(SparseMatrix self, int const row, int const col, double const a) """ return _sparsemat.SparseMatrix__Set_(self, *args) + _Set_ = _swig_new_instance_method(_sparsemat.SparseMatrix__Set_) def Set(self, i, j, a): r"""Set(SparseMatrix self, int const i, int const j, double const a)""" return _sparsemat.SparseMatrix_Set(self, i, j, a) + Set = _swig_new_instance_method(_sparsemat.SparseMatrix_Set) def SetSubMatrix(self, rows, cols, subm, skip_zeros=1): r"""SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)""" return _sparsemat.SparseMatrix_SetSubMatrix(self, rows, cols, subm, skip_zeros) + SetSubMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_SetSubMatrix) def SetSubMatrixTranspose(self, rows, cols, subm, skip_zeros=1): r"""SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)""" return _sparsemat.SparseMatrix_SetSubMatrixTranspose(self, rows, cols, subm, skip_zeros) + SetSubMatrixTranspose = _swig_new_instance_method(_sparsemat.SparseMatrix_SetSubMatrixTranspose) def AddSubMatrix(self, rows, cols, subm, skip_zeros=1): r"""AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)""" return _sparsemat.SparseMatrix_AddSubMatrix(self, rows, cols, subm, skip_zeros) + AddSubMatrix = _swig_new_instance_method(_sparsemat.SparseMatrix_AddSubMatrix) def RowIsEmpty(self, row): r"""RowIsEmpty(SparseMatrix self, int const row) -> bool""" return _sparsemat.SparseMatrix_RowIsEmpty(self, row) + RowIsEmpty = _swig_new_instance_method(_sparsemat.SparseMatrix_RowIsEmpty) def GetRow(self, row, cols, srow): r"""GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int""" return _sparsemat.SparseMatrix_GetRow(self, row, cols, srow) + GetRow = _swig_new_instance_method(_sparsemat.SparseMatrix_GetRow) def SetRow(self, row, cols, srow): r"""SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)""" return _sparsemat.SparseMatrix_SetRow(self, row, cols, srow) + SetRow = _swig_new_instance_method(_sparsemat.SparseMatrix_SetRow) def AddRow(self, row, cols, srow): r"""AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)""" return _sparsemat.SparseMatrix_AddRow(self, row, cols, srow) + AddRow = _swig_new_instance_method(_sparsemat.SparseMatrix_AddRow) def ScaleRow(self, row, scale): r"""ScaleRow(SparseMatrix self, int const row, double const scale)""" return _sparsemat.SparseMatrix_ScaleRow(self, row, scale) + ScaleRow = _swig_new_instance_method(_sparsemat.SparseMatrix_ScaleRow) def ScaleRows(self, sl): r"""ScaleRows(SparseMatrix self, Vector sl)""" return _sparsemat.SparseMatrix_ScaleRows(self, sl) + ScaleRows = _swig_new_instance_method(_sparsemat.SparseMatrix_ScaleRows) def ScaleColumns(self, sr): r"""ScaleColumns(SparseMatrix self, Vector sr)""" return _sparsemat.SparseMatrix_ScaleColumns(self, sr) + ScaleColumns = _swig_new_instance_method(_sparsemat.SparseMatrix_ScaleColumns) def __iadd__(self, B): r"""__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix""" @@ -493,6 +689,7 @@ def Add(self, *args): Add(SparseMatrix self, double const a, SparseMatrix B) """ return _sparsemat.SparseMatrix_Add(self, *args) + Add = _swig_new_instance_method(_sparsemat.SparseMatrix_Add) def __imul__(self, a): r"""__imul__(SparseMatrix self, double a) -> SparseMatrix""" @@ -508,67 +705,83 @@ def __imul__(self, a): def IsSymmetric(self): r"""IsSymmetric(SparseMatrix self) -> double""" return _sparsemat.SparseMatrix_IsSymmetric(self) + IsSymmetric = _swig_new_instance_method(_sparsemat.SparseMatrix_IsSymmetric) def Symmetrize(self): r"""Symmetrize(SparseMatrix self)""" return _sparsemat.SparseMatrix_Symmetrize(self) + Symmetrize = _swig_new_instance_method(_sparsemat.SparseMatrix_Symmetrize) def NumNonZeroElems(self): r"""NumNonZeroElems(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_NumNonZeroElems(self) + NumNonZeroElems = _swig_new_instance_method(_sparsemat.SparseMatrix_NumNonZeroElems) def MaxNorm(self): r"""MaxNorm(SparseMatrix self) -> double""" return _sparsemat.SparseMatrix_MaxNorm(self) + MaxNorm = _swig_new_instance_method(_sparsemat.SparseMatrix_MaxNorm) def CountSmallElems(self, tol): r"""CountSmallElems(SparseMatrix self, double tol) -> int""" return _sparsemat.SparseMatrix_CountSmallElems(self, tol) + CountSmallElems = _swig_new_instance_method(_sparsemat.SparseMatrix_CountSmallElems) def CheckFinite(self): r"""CheckFinite(SparseMatrix self) -> int""" return _sparsemat.SparseMatrix_CheckFinite(self) + CheckFinite = _swig_new_instance_method(_sparsemat.SparseMatrix_CheckFinite) def SetGraphOwner(self, ownij): r"""SetGraphOwner(SparseMatrix self, bool ownij)""" return _sparsemat.SparseMatrix_SetGraphOwner(self, ownij) + SetGraphOwner = _swig_new_instance_method(_sparsemat.SparseMatrix_SetGraphOwner) def SetDataOwner(self, owna): r"""SetDataOwner(SparseMatrix self, bool owna)""" return _sparsemat.SparseMatrix_SetDataOwner(self, owna) + SetDataOwner = _swig_new_instance_method(_sparsemat.SparseMatrix_SetDataOwner) def OwnsGraph(self): r"""OwnsGraph(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_OwnsGraph(self) + OwnsGraph = _swig_new_instance_method(_sparsemat.SparseMatrix_OwnsGraph) def OwnsData(self): r"""OwnsData(SparseMatrix self) -> bool""" return _sparsemat.SparseMatrix_OwnsData(self) + OwnsData = _swig_new_instance_method(_sparsemat.SparseMatrix_OwnsData) def LoseData(self): r"""LoseData(SparseMatrix self)""" return _sparsemat.SparseMatrix_LoseData(self) + LoseData = _swig_new_instance_method(_sparsemat.SparseMatrix_LoseData) def Swap(self, other): r"""Swap(SparseMatrix self, SparseMatrix other)""" return _sparsemat.SparseMatrix_Swap(self, other) + Swap = _swig_new_instance_method(_sparsemat.SparseMatrix_Swap) __swig_destroy__ = _sparsemat.delete_SparseMatrix def GetType(self): r"""GetType(SparseMatrix self) -> mfem::Operator::Type""" return _sparsemat.SparseMatrix_GetType(self) + GetType = _swig_new_instance_method(_sparsemat.SparseMatrix_GetType) def GetIArray(self): r"""GetIArray(SparseMatrix self) -> PyObject *""" return _sparsemat.SparseMatrix_GetIArray(self) + GetIArray = _swig_new_instance_method(_sparsemat.SparseMatrix_GetIArray) def GetJArray(self): r"""GetJArray(SparseMatrix self) -> PyObject *""" return _sparsemat.SparseMatrix_GetJArray(self) + GetJArray = _swig_new_instance_method(_sparsemat.SparseMatrix_GetJArray) def GetDataArray(self): r"""GetDataArray(SparseMatrix self) -> PyObject *""" return _sparsemat.SparseMatrix_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_sparsemat.SparseMatrix_GetDataArray) def Print(self, *args): r""" @@ -576,6 +789,7 @@ def Print(self, *args): Print(SparseMatrix self, char const * file, int precision=8) """ return _sparsemat.SparseMatrix_Print(self, *args) + Print = _swig_new_instance_method(_sparsemat.SparseMatrix_Print) def PrintMatlab(self, *args): r""" @@ -583,6 +797,7 @@ def PrintMatlab(self, *args): PrintMatlab(SparseMatrix self, char const * file, int precision=8) """ return _sparsemat.SparseMatrix_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintMatlab) def PrintMM(self, *args): r""" @@ -590,6 +805,7 @@ def PrintMM(self, *args): PrintMM(SparseMatrix self, char const * file, int precision=8) """ return _sparsemat.SparseMatrix_PrintMM(self, *args) + PrintMM = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintMM) def PrintCSR(self, *args): r""" @@ -598,6 +814,7 @@ def PrintCSR(self, *args): PrintCSR(SparseMatrix self) """ return _sparsemat.SparseMatrix_PrintCSR(self, *args) + PrintCSR = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintCSR) def PrintCSR2(self, *args): r""" @@ -606,6 +823,7 @@ def PrintCSR2(self, *args): PrintCSR2(SparseMatrix self) """ return _sparsemat.SparseMatrix_PrintCSR2(self, *args) + PrintCSR2 = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintCSR2) def PrintInfo(self, *args): r""" @@ -614,6 +832,7 @@ def PrintInfo(self, *args): PrintInfo(SparseMatrix self) """ return _sparsemat.SparseMatrix_PrintInfo(self, *args) + PrintInfo = _swig_new_instance_method(_sparsemat.SparseMatrix_PrintInfo) # Register SparseMatrix in _sparsemat: _sparsemat.SparseMatrix_swigregister(SparseMatrix) @@ -622,22 +841,27 @@ def PrintInfo(self, *args): def SparseMatrixFunction(S, f): r"""SparseMatrixFunction(SparseMatrix S, double (*)(double) f)""" return _sparsemat.SparseMatrixFunction(S, f) +SparseMatrixFunction = _sparsemat.SparseMatrixFunction def TransposeAbstractSparseMatrix(A, useActualWidth): r"""TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix""" return _sparsemat.TransposeAbstractSparseMatrix(A, useActualWidth) +TransposeAbstractSparseMatrix = _sparsemat.TransposeAbstractSparseMatrix def TransposeMult(A, B): r"""TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix""" return _sparsemat.TransposeMult(A, B) +TransposeMult = _sparsemat.TransposeMult def MultAbstractSparseMatrix(A, B): r"""MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix""" return _sparsemat.MultAbstractSparseMatrix(A, B) +MultAbstractSparseMatrix = _sparsemat.MultAbstractSparseMatrix def Mult_AtDA(A, D, OAtDA=None): r"""Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix""" return _sparsemat.Mult_AtDA(A, D, OAtDA) +Mult_AtDA = _sparsemat.Mult_AtDA def OuterProduct(*args): r""" @@ -647,5 +871,6 @@ def OuterProduct(*args): OuterProduct(SparseMatrix A, SparseMatrix B) -> SparseMatrix """ return _sparsemat.OuterProduct(*args) +OuterProduct = _sparsemat.OuterProduct diff --git a/mfem/_ser/sparsemat_wrap.cxx b/mfem/_ser/sparsemat_wrap.cxx index 76f66941..74a828bf 100644 --- a/mfem/_ser/sparsemat_wrap.cxx +++ b/mfem/_ser/sparsemat_wrap.cxx @@ -3079,23 +3079,28 @@ namespace Swig { #define SWIGTYPE_p_mfem__IdentityOperator swig_types[11] #define SWIGTYPE_p_mfem__Matrix swig_types[12] #define SWIGTYPE_p_mfem__MatrixInverse swig_types[13] -#define SWIGTYPE_p_mfem__Operator swig_types[14] -#define SWIGTYPE_p_mfem__OperatorHandle swig_types[15] -#define SWIGTYPE_p_mfem__OperatorPtr swig_types[16] -#define SWIGTYPE_p_mfem__ProductOperator swig_types[17] -#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[18] -#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[19] -#define SWIGTYPE_p_mfem__RAPOperator swig_types[20] -#define SWIGTYPE_p_mfem__RowNode swig_types[21] -#define SWIGTYPE_p_mfem__Solver swig_types[22] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[23] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[24] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[25] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[26] -#define SWIGTYPE_p_mfem__Vector swig_types[27] -#define SWIGTYPE_p_void swig_types[28] -static swig_type_info *swig_types[30]; -static swig_module_info swig_module = {swig_types, 29, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__MemoryT_double_t swig_types[14] +#define SWIGTYPE_p_mfem__MemoryT_int_t swig_types[15] +#define SWIGTYPE_p_mfem__Operator swig_types[16] +#define SWIGTYPE_p_mfem__OperatorHandle swig_types[17] +#define SWIGTYPE_p_mfem__OperatorPtr swig_types[18] +#define SWIGTYPE_p_mfem__ProductOperator swig_types[19] +#define SWIGTYPE_p_mfem__PyOperatorBase swig_types[20] +#define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[21] +#define SWIGTYPE_p_mfem__RAPOperator swig_types[22] +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[23] +#define SWIGTYPE_p_mfem__RowNode swig_types[24] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[25] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[26] +#define SWIGTYPE_p_mfem__Solver swig_types[27] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[28] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[29] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[30] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[31] +#define SWIGTYPE_p_mfem__Vector swig_types[32] +#define SWIGTYPE_p_void swig_types[33] +static swig_type_info *swig_types[35]; +static swig_module_info swig_module = {swig_types, 34, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -5279,6 +5284,1869 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetData(PyObject *self, PyObject *args) } +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &(arg1)->GetMemoryI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryI", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryI__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryI__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::GetMemoryI()\n" + " mfem::SparseMatrix::GetMemoryI() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadI", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadI__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadI__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadI(bool) const\n" + " mfem::SparseMatrix::ReadI() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->WriteI(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->WriteI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteI", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_WriteI__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_WriteI__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::WriteI(bool)\n" + " mfem::SparseMatrix::WriteI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->ReadWriteI(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->ReadWriteI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteI", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadWriteI__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadWriteI__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadWriteI(bool)\n" + " mfem::SparseMatrix::ReadWriteI()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostWriteI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostReadWriteI(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &(arg1)->GetMemoryJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryJ", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryJ__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryJ__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::GetMemoryJ()\n" + " mfem::SparseMatrix::GetMemoryJ() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadJ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadJ__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadJ__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadJ(bool) const\n" + " mfem::SparseMatrix::ReadJ() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->WriteJ(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->WriteJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteJ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_WriteJ__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_WriteJ__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::WriteJ(bool)\n" + " mfem::SparseMatrix::WriteJ()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + int *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (int *)(arg1)->ReadWriteJ(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->ReadWriteJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteJ", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadWriteJ__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadWriteJ__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteJ'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadWriteJ(bool)\n" + " mfem::SparseMatrix::ReadWriteJ()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostWriteJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostReadWriteJ(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &(arg1)->GetMemoryData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryData", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryData__SWIG_0(self, argc, argv); + } + } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_GetMemoryData__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::GetMemoryData()\n" + " mfem::SparseMatrix::GetMemoryData() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadData", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadData__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadData__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadData(bool) const\n" + " mfem::SparseMatrix::ReadData() const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)(arg1)->WriteData(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->WriteData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteData", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_WriteData__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_WriteData__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::WriteData(bool)\n" + " mfem::SparseMatrix::WriteData()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + double *result = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + { + try { + result = (double *)(arg1)->ReadWriteData(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->ReadWriteData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteData", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_ReadWriteData__SWIG_1(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_ReadWriteData__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteData'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::ReadWriteData(bool)\n" + " mfem::SparseMatrix::ReadWriteData()\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)((mfem::SparseMatrix const *)arg1)->HostReadData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->HostWriteData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double *)(arg1)->HostReadWriteData(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_SparseMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; @@ -8273,6 +10141,66 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_2(PyObject *SWIGUNUS } +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::SparseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + { + try { + (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { @@ -8312,6 +10240,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * } } } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_EliminateCols__SWIG_3(self, argc, argv); + } + } + } + } if (argc == 4) { int _v; void *vptr = 0; @@ -8341,7 +10287,8 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *,mfem::Vector *)\n" " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *)\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &)\n"); + " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &)\n" + " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::SparseMatrix &)\n"); return 0; } @@ -10444,7 +12391,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalized(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SparseMatrix_areColumnsSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ColumnsAreSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -10456,12 +12403,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_areColumnsSorted(PyObject *SWIGUNUSEDPAR swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_areColumnsSorted" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ColumnsAreSorted" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (bool)((mfem::SparseMatrix const *)arg1)->areColumnsSorted(); + result = (bool)((mfem::SparseMatrix const *)arg1)->ColumnsAreSorted(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16104,6 +18051,7 @@ SWIGINTERN PyObject *_wrap_OuterProduct(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, @@ -16143,6 +18091,36 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetData(SparseMatrix self) -> double\n" "SparseMatrix_GetData(SparseMatrix self) -> double const *\n" ""}, + { "SparseMatrix_GetMemoryI", _wrap_SparseMatrix_GetMemoryI, METH_VARARGS, "\n" + "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" + "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "SparseMatrix_ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "SparseMatrix_WriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "SparseMatrix_ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "SparseMatrix_HostReadI(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "SparseMatrix_HostWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "SparseMatrix_HostReadWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryJ", _wrap_SparseMatrix_GetMemoryJ, METH_VARARGS, "\n" + "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" + "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "SparseMatrix_ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "SparseMatrix_WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "SparseMatrix_ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "SparseMatrix_HostReadJ(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "SparseMatrix_HostWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "SparseMatrix_HostReadWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryData", _wrap_SparseMatrix_GetMemoryData, METH_VARARGS, "\n" + "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" + "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" + ""}, + { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "SparseMatrix_ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, + { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "SparseMatrix_WriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "SparseMatrix_ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "SparseMatrix_HostReadData(SparseMatrix self) -> double const *"}, + { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "SparseMatrix_HostWriteData(SparseMatrix self) -> double *"}, + { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "SparseMatrix_HostReadWriteData(SparseMatrix self) -> double *"}, { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "SparseMatrix_RowSize(SparseMatrix self, int const i) -> int"}, { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "SparseMatrix_MaxRowSize(SparseMatrix self) -> int"}, { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" @@ -16190,7 +18168,10 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" ""}, { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "SparseMatrix_EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, - { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "SparseMatrix_EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)"}, + { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" + "SparseMatrix_EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" + "SparseMatrix_EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" + ""}, { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "SparseMatrix_EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "SparseMatrix_EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" @@ -16212,7 +18193,7 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" ""}, { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "SparseMatrix_Finalized(SparseMatrix self) -> bool"}, - { "SparseMatrix_areColumnsSorted", _wrap_SparseMatrix_areColumnsSorted, METH_O, "SparseMatrix_areColumnsSorted(SparseMatrix self) -> bool"}, + { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "SparseMatrix_ColumnsAreSorted(SparseMatrix self) -> bool"}, { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "SparseMatrix_Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "SparseMatrix_GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "SparseMatrix_GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, @@ -16309,6 +18290,242 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, + { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, + { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, + { "OperatorHandle2SparseMatrix", _wrap_OperatorHandle2SparseMatrix, METH_O, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, + { "RowNode_Value_set", _wrap_RowNode_Value_set, METH_VARARGS, "RowNode_Value_set(RowNode self, double Value)"}, + { "RowNode_Value_get", _wrap_RowNode_Value_get, METH_O, "RowNode_Value_get(RowNode self) -> double"}, + { "RowNode_Prev_set", _wrap_RowNode_Prev_set, METH_VARARGS, "RowNode_Prev_set(RowNode self, RowNode Prev)"}, + { "RowNode_Prev_get", _wrap_RowNode_Prev_get, METH_O, "RowNode_Prev_get(RowNode self) -> RowNode"}, + { "RowNode_Column_set", _wrap_RowNode_Column_set, METH_VARARGS, "RowNode_Column_set(RowNode self, int Column)"}, + { "RowNode_Column_get", _wrap_RowNode_Column_get, METH_O, "RowNode_Column_get(RowNode self) -> int"}, + { "new_RowNode", _wrap_new_RowNode, METH_NOARGS, "new_RowNode() -> RowNode"}, + { "delete_RowNode", _wrap_delete_RowNode, METH_O, "delete_RowNode(RowNode self)"}, + { "RowNode_swigregister", RowNode_swigregister, METH_O, NULL}, + { "RowNode_swiginit", RowNode_swiginit, METH_VARARGS, NULL}, + { "new_SparseMatrix", _wrap_new_SparseMatrix, METH_VARARGS, "\n" + "SparseMatrix()\n" + "SparseMatrix(int nrows, int ncols=-1)\n" + "SparseMatrix(int * i)\n" + "SparseMatrix(int * i, bool ownij, bool owna, bool issorted)\n" + "SparseMatrix(int nrows, int ncols, int rowsize)\n" + "SparseMatrix(SparseMatrix mat, bool copy_graph=True)\n" + "new_SparseMatrix(Vector v) -> SparseMatrix\n" + ""}, + { "SparseMatrix_MakeRef", _wrap_SparseMatrix_MakeRef, METH_VARARGS, "MakeRef(SparseMatrix self, SparseMatrix master)"}, + { "SparseMatrix_Size", _wrap_SparseMatrix_Size, METH_O, "Size(SparseMatrix self) -> int"}, + { "SparseMatrix_Clear", _wrap_SparseMatrix_Clear, METH_O, "Clear(SparseMatrix self)"}, + { "SparseMatrix_Empty", _wrap_SparseMatrix_Empty, METH_O, "Empty(SparseMatrix self) -> bool"}, + { "SparseMatrix_GetI", _wrap_SparseMatrix_GetI, METH_VARARGS, "\n" + "GetI(SparseMatrix self) -> int\n" + "GetI(SparseMatrix self) -> int const *\n" + ""}, + { "SparseMatrix_GetJ", _wrap_SparseMatrix_GetJ, METH_VARARGS, "\n" + "GetJ(SparseMatrix self) -> int\n" + "GetJ(SparseMatrix self) -> int const *\n" + ""}, + { "SparseMatrix_GetData", _wrap_SparseMatrix_GetData, METH_VARARGS, "\n" + "GetData(SparseMatrix self) -> double\n" + "GetData(SparseMatrix self) -> double const *\n" + ""}, + { "SparseMatrix_GetMemoryI", _wrap_SparseMatrix_GetMemoryI, METH_VARARGS, "\n" + "GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" + "GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "WriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "HostReadI(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "HostWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "HostReadWriteI(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryJ", _wrap_SparseMatrix_GetMemoryJ, METH_VARARGS, "\n" + "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" + "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" + ""}, + { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, + { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "HostReadJ(SparseMatrix self) -> int const *"}, + { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "HostWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "HostReadWriteJ(SparseMatrix self) -> int *"}, + { "SparseMatrix_GetMemoryData", _wrap_SparseMatrix_GetMemoryData, METH_VARARGS, "\n" + "GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" + "GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" + ""}, + { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, + { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "WriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "HostReadData(SparseMatrix self) -> double const *"}, + { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "HostWriteData(SparseMatrix self) -> double *"}, + { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "HostReadWriteData(SparseMatrix self) -> double *"}, + { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "RowSize(SparseMatrix self, int const i) -> int"}, + { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "MaxRowSize(SparseMatrix self) -> int"}, + { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" + "GetRowColumns(SparseMatrix self, int const row) -> int\n" + "GetRowColumns(SparseMatrix self, int const row) -> int const *\n" + ""}, + { "SparseMatrix_GetRowEntries", _wrap_SparseMatrix_GetRowEntries, METH_VARARGS, "\n" + "GetRowEntries(SparseMatrix self, int const row) -> double\n" + "GetRowEntries(SparseMatrix self, int const row) -> double const *\n" + ""}, + { "SparseMatrix_SetWidth", _wrap_SparseMatrix_SetWidth, METH_VARARGS, "SetWidth(SparseMatrix self, int width_=-1)"}, + { "SparseMatrix_ActualWidth", _wrap_SparseMatrix_ActualWidth, METH_O, "ActualWidth(SparseMatrix self) -> int"}, + { "SparseMatrix_SortColumnIndices", _wrap_SparseMatrix_SortColumnIndices, METH_O, "SortColumnIndices(SparseMatrix self)"}, + { "SparseMatrix_MoveDiagonalFirst", _wrap_SparseMatrix_MoveDiagonalFirst, METH_O, "MoveDiagonalFirst(SparseMatrix self)"}, + { "SparseMatrix_Elem", _wrap_SparseMatrix_Elem, METH_VARARGS, "\n" + "Elem(SparseMatrix self, int i, int j) -> double\n" + "Elem(SparseMatrix self, int i, int j) -> double const &\n" + ""}, + { "SparseMatrix___call__", _wrap_SparseMatrix___call__, METH_VARARGS, "\n" + "__call__(SparseMatrix self, int i, int j) -> double\n" + "__call__(SparseMatrix self, int i, int j) -> double const &\n" + ""}, + { "SparseMatrix_GetDiag", _wrap_SparseMatrix_GetDiag, METH_VARARGS, "GetDiag(SparseMatrix self, Vector d)"}, + { "SparseMatrix_ToDenseMatrix", _wrap_SparseMatrix_ToDenseMatrix, METH_VARARGS, "\n" + "ToDenseMatrix(SparseMatrix self) -> DenseMatrix\n" + "ToDenseMatrix(SparseMatrix self, DenseMatrix B)\n" + ""}, + { "SparseMatrix_GetMemoryClass", _wrap_SparseMatrix_GetMemoryClass, METH_O, "GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass"}, + { "SparseMatrix_Mult", _wrap_SparseMatrix_Mult, METH_VARARGS, "Mult(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMult", _wrap_SparseMatrix_AddMult, METH_VARARGS, "AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_MultTranspose", _wrap_SparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMultTranspose", _wrap_SparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BuildTranspose", _wrap_SparseMatrix_BuildTranspose, METH_O, "BuildTranspose(SparseMatrix self)"}, + { "SparseMatrix_ResetTranspose", _wrap_SparseMatrix_ResetTranspose, METH_O, "ResetTranspose(SparseMatrix self)"}, + { "SparseMatrix_PartMult", _wrap_SparseMatrix_PartMult, METH_VARARGS, "PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, + { "SparseMatrix_PartAddMult", _wrap_SparseMatrix_PartAddMult, METH_VARARGS, "PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BooleanMult", _wrap_SparseMatrix_BooleanMult, METH_VARARGS, "BooleanMult(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_BooleanMultTranspose", _wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS, "BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_InnerProduct", _wrap_SparseMatrix_InnerProduct, METH_VARARGS, "InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, + { "SparseMatrix_GetRowSums", _wrap_SparseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(SparseMatrix self, Vector x)"}, + { "SparseMatrix_GetRowNorml1", _wrap_SparseMatrix_GetRowNorml1, METH_VARARGS, "GetRowNorml1(SparseMatrix self, int irow) -> double"}, + { "SparseMatrix_Inverse", _wrap_SparseMatrix_Inverse, METH_O, "Inverse(SparseMatrix self) -> MatrixInverse"}, + { "SparseMatrix_EliminateRow", _wrap_SparseMatrix_EliminateRow, METH_VARARGS, "\n" + "EliminateRow(SparseMatrix self, int row, double const sol, Vector rhs)\n" + "EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" + ""}, + { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, + { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" + "EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" + "EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" + ""}, + { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, + { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, + { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" + "EliminateRowCol(SparseMatrix self, int rc, double const sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateRowCol(SparseMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + "EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" + ""}, + { "SparseMatrix_SetDiagIdentity", _wrap_SparseMatrix_SetDiagIdentity, METH_O, "SetDiagIdentity(SparseMatrix self)"}, + { "SparseMatrix_EliminateZeroRows", _wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, + { "SparseMatrix_Gauss_Seidel_forw", _wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS, "Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_Gauss_Seidel_back", _wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS, "Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_GetJacobiScaling", _wrap_SparseMatrix_GetJacobiScaling, METH_O, "GetJacobiScaling(SparseMatrix self) -> double"}, + { "SparseMatrix_Jacobi", _wrap_SparseMatrix_Jacobi, METH_VARARGS, "Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, + { "SparseMatrix_DiagScale", _wrap_SparseMatrix_DiagScale, METH_VARARGS, "DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, + { "SparseMatrix_Jacobi2", _wrap_SparseMatrix_Jacobi2, METH_VARARGS, "Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi3", _wrap_SparseMatrix_Jacobi3, METH_VARARGS, "Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Finalize", _wrap_SparseMatrix_Finalize, METH_VARARGS, "\n" + "Finalize(SparseMatrix self, int skip_zeros=1)\n" + "Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" + ""}, + { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "Finalized(SparseMatrix self) -> bool"}, + { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "ColumnsAreSorted(SparseMatrix self) -> bool"}, + { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, + { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, + { "SparseMatrix_SetColPtr", _wrap_SparseMatrix_SetColPtr, METH_VARARGS, "SetColPtr(SparseMatrix self, int const row)"}, + { "SparseMatrix_ClearColPtr", _wrap_SparseMatrix_ClearColPtr, METH_O, "ClearColPtr(SparseMatrix self)"}, + { "SparseMatrix__Get_", _wrap_SparseMatrix__Get_, METH_VARARGS, "_Get_(SparseMatrix self, int const col) -> double"}, + { "SparseMatrix_SearchRow", _wrap_SparseMatrix_SearchRow, METH_VARARGS, "\n" + "SearchRow(SparseMatrix self, int const col) -> double\n" + "SearchRow(SparseMatrix self, int const row, int const col) -> double &\n" + ""}, + { "SparseMatrix__Add_", _wrap_SparseMatrix__Add_, METH_VARARGS, "\n" + "_Add_(SparseMatrix self, int const col, double const a)\n" + "_Add_(SparseMatrix self, int const row, int const col, double const a)\n" + ""}, + { "SparseMatrix__Set_", _wrap_SparseMatrix__Set_, METH_VARARGS, "\n" + "_Set_(SparseMatrix self, int const col, double const a)\n" + "_Set_(SparseMatrix self, int const row, int const col, double const a)\n" + ""}, + { "SparseMatrix_Set", _wrap_SparseMatrix_Set, METH_VARARGS, "Set(SparseMatrix self, int const i, int const j, double const a)"}, + { "SparseMatrix_SetSubMatrix", _wrap_SparseMatrix_SetSubMatrix, METH_VARARGS, "SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_SetSubMatrixTranspose", _wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS, "SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_AddSubMatrix", _wrap_SparseMatrix_AddSubMatrix, METH_VARARGS, "AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_RowIsEmpty", _wrap_SparseMatrix_RowIsEmpty, METH_VARARGS, "RowIsEmpty(SparseMatrix self, int const row) -> bool"}, + { "SparseMatrix_GetRow", _wrap_SparseMatrix_GetRow, METH_VARARGS, "GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "SparseMatrix_SetRow", _wrap_SparseMatrix_SetRow, METH_VARARGS, "SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_AddRow", _wrap_SparseMatrix_AddRow, METH_VARARGS, "AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_ScaleRow", _wrap_SparseMatrix_ScaleRow, METH_VARARGS, "ScaleRow(SparseMatrix self, int const row, double const scale)"}, + { "SparseMatrix_ScaleRows", _wrap_SparseMatrix_ScaleRows, METH_VARARGS, "ScaleRows(SparseMatrix self, Vector sl)"}, + { "SparseMatrix_ScaleColumns", _wrap_SparseMatrix_ScaleColumns, METH_VARARGS, "ScaleColumns(SparseMatrix self, Vector sr)"}, + { "SparseMatrix___iadd__", _wrap_SparseMatrix___iadd__, METH_VARARGS, "__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, + { "SparseMatrix_Add", _wrap_SparseMatrix_Add, METH_VARARGS, "\n" + "Add(SparseMatrix self, int const i, int const j, double const a)\n" + "Add(SparseMatrix self, double const a, SparseMatrix B)\n" + ""}, + { "SparseMatrix___imul__", _wrap_SparseMatrix___imul__, METH_VARARGS, "__imul__(SparseMatrix self, double a) -> SparseMatrix"}, + { "SparseMatrix_IsSymmetric", _wrap_SparseMatrix_IsSymmetric, METH_O, "IsSymmetric(SparseMatrix self) -> double"}, + { "SparseMatrix_Symmetrize", _wrap_SparseMatrix_Symmetrize, METH_O, "Symmetrize(SparseMatrix self)"}, + { "SparseMatrix_NumNonZeroElems", _wrap_SparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(SparseMatrix self) -> int"}, + { "SparseMatrix_MaxNorm", _wrap_SparseMatrix_MaxNorm, METH_O, "MaxNorm(SparseMatrix self) -> double"}, + { "SparseMatrix_CountSmallElems", _wrap_SparseMatrix_CountSmallElems, METH_VARARGS, "CountSmallElems(SparseMatrix self, double tol) -> int"}, + { "SparseMatrix_CheckFinite", _wrap_SparseMatrix_CheckFinite, METH_O, "CheckFinite(SparseMatrix self) -> int"}, + { "SparseMatrix_SetGraphOwner", _wrap_SparseMatrix_SetGraphOwner, METH_VARARGS, "SetGraphOwner(SparseMatrix self, bool ownij)"}, + { "SparseMatrix_SetDataOwner", _wrap_SparseMatrix_SetDataOwner, METH_VARARGS, "SetDataOwner(SparseMatrix self, bool owna)"}, + { "SparseMatrix_OwnsGraph", _wrap_SparseMatrix_OwnsGraph, METH_O, "OwnsGraph(SparseMatrix self) -> bool"}, + { "SparseMatrix_OwnsData", _wrap_SparseMatrix_OwnsData, METH_O, "OwnsData(SparseMatrix self) -> bool"}, + { "SparseMatrix_LoseData", _wrap_SparseMatrix_LoseData, METH_O, "LoseData(SparseMatrix self)"}, + { "SparseMatrix_Swap", _wrap_SparseMatrix_Swap, METH_VARARGS, "Swap(SparseMatrix self, SparseMatrix other)"}, + { "delete_SparseMatrix", _wrap_delete_SparseMatrix, METH_O, "delete_SparseMatrix(SparseMatrix self)"}, + { "SparseMatrix_GetType", _wrap_SparseMatrix_GetType, METH_O, "GetType(SparseMatrix self) -> mfem::Operator::Type"}, + { "SparseMatrix_GetIArray", _wrap_SparseMatrix_GetIArray, METH_O, "GetIArray(SparseMatrix self) -> PyObject *"}, + { "SparseMatrix_GetJArray", _wrap_SparseMatrix_GetJArray, METH_O, "GetJArray(SparseMatrix self) -> PyObject *"}, + { "SparseMatrix_GetDataArray", _wrap_SparseMatrix_GetDataArray, METH_O, "GetDataArray(SparseMatrix self) -> PyObject *"}, + { "SparseMatrix_Print", _wrap_SparseMatrix_Print, METH_VARARGS, "\n" + "Print(SparseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" + "Print(SparseMatrix self, char const * file, int precision=8)\n" + ""}, + { "SparseMatrix_PrintMatlab", _wrap_SparseMatrix_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(SparseMatrix self, std::ostream & out=mfem::out)\n" + "PrintMatlab(SparseMatrix self, char const * file, int precision=8)\n" + ""}, + { "SparseMatrix_PrintMM", _wrap_SparseMatrix_PrintMM, METH_VARARGS, "\n" + "PrintMM(SparseMatrix self, std::ostream & out=mfem::out)\n" + "PrintMM(SparseMatrix self, char const * file, int precision=8)\n" + ""}, + { "SparseMatrix_PrintCSR", _wrap_SparseMatrix_PrintCSR, METH_VARARGS, "\n" + "PrintCSR(SparseMatrix self, std::ostream & out)\n" + "PrintCSR(SparseMatrix self, char const * file, int precision=8)\n" + "PrintCSR(SparseMatrix self)\n" + ""}, + { "SparseMatrix_PrintCSR2", _wrap_SparseMatrix_PrintCSR2, METH_VARARGS, "\n" + "PrintCSR2(SparseMatrix self, std::ostream & out)\n" + "PrintCSR2(SparseMatrix self, char const * file, int precision=8)\n" + "PrintCSR2(SparseMatrix self)\n" + ""}, + { "SparseMatrix_PrintInfo", _wrap_SparseMatrix_PrintInfo, METH_VARARGS, "\n" + "PrintInfo(SparseMatrix self, std::ostream & out)\n" + "PrintInfo(SparseMatrix self, char const * file, int precision=8)\n" + "PrintInfo(SparseMatrix self)\n" + ""}, + { "SparseMatrix_swigregister", SparseMatrix_swigregister, METH_O, NULL}, + { "SparseMatrix_swiginit", SparseMatrix_swiginit, METH_VARARGS, NULL}, + { "SparseMatrixFunction", _wrap_SparseMatrixFunction, METH_VARARGS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, + { "TransposeAbstractSparseMatrix", _wrap_TransposeAbstractSparseMatrix, METH_VARARGS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, + { "TransposeMult", _wrap_TransposeMult, METH_VARARGS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, + { "MultAbstractSparseMatrix", _wrap_MultAbstractSparseMatrix, METH_VARARGS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, + { "Mult_AtDA", _wrap_Mult_AtDA, METH_VARARGS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, + { "OuterProduct", _wrap_OuterProduct, METH_VARARGS, "\n" + "OuterProduct(DenseMatrix A, DenseMatrix B) -> DenseMatrix\n" + "OuterProduct(DenseMatrix A, SparseMatrix B) -> SparseMatrix\n" + "OuterProduct(SparseMatrix A, DenseMatrix B) -> SparseMatrix\n" + "OuterProduct(SparseMatrix A, SparseMatrix B) -> SparseMatrix\n" + ""}, { NULL, NULL, 0, NULL } }; @@ -16345,18 +18562,21 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -16372,9 +18592,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -16390,16 +18616,21 @@ static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", "mf static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", "mfem::Matrix *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__MatrixInverse = {"_p_mfem__MatrixInverse", "mfem::MatrixInverse *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatrixInverse", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__MemoryT_double_t = {"_p_mfem__MemoryT_double_t", "mfem::Memory< double > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__MemoryT_int_t = {"_p_mfem__MemoryT_int_t", "mfem::Memory< int > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__OperatorHandle = {"_p_mfem__OperatorHandle", "mfem::OperatorHandle *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__OperatorPtr = {"_p_mfem__OperatorPtr", "mfem::OperatorPtr *", 0, 0, (void*)0, 0}; @@ -16423,6 +18654,8 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__IdentityOperator, &_swigt__p_mfem__Matrix, &_swigt__p_mfem__MatrixInverse, + &_swigt__p_mfem__MemoryT_double_t, + &_swigt__p_mfem__MemoryT_int_t, &_swigt__p_mfem__Operator, &_swigt__p_mfem__OperatorHandle, &_swigt__p_mfem__OperatorPtr, @@ -16430,7 +18663,10 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, &_swigt__p_mfem__RowNode, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__TimeDependentOperator, @@ -16452,17 +18688,22 @@ static swig_cast_info _swigc__p_mfem__DenseMatrix[] = { {&_swigt__p_mfem__Dense static swig_cast_info _swigc__p_mfem__Matrix[] = { {&_swigt__p_mfem__Matrix, 0, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Matrix, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Matrix, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Matrix, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__DenseMatrixInverse, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__MatrixInverse, 0, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__MatrixInverse, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MemoryT_double_t[] = { {&_swigt__p_mfem__MemoryT_double_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__MemoryT_int_t[] = { {&_swigt__p_mfem__MemoryT_int_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = {{&_swigt__p_mfem__Solver, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorHandle[] = { {&_swigt__p_mfem__OperatorHandle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__OperatorPtr[] = { {&_swigt__p_mfem__OperatorPtr, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RowNode[] = { {&_swigt__p_mfem__RowNode, 0, 0, 0},{0, 0, 0, 0}}; @@ -16485,6 +18726,8 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__IdentityOperator, _swigc__p_mfem__Matrix, _swigc__p_mfem__MatrixInverse, + _swigc__p_mfem__MemoryT_double_t, + _swigc__p_mfem__MemoryT_int_t, _swigc__p_mfem__Operator, _swigc__p_mfem__OperatorHandle, _swigc__p_mfem__OperatorPtr, @@ -16492,7 +18735,10 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, _swigc__p_mfem__RowNode, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__TimeDependentOperator, diff --git a/mfem/_ser/sparsesmoothers.py b/mfem/_ser/sparsesmoothers.py index e5b6b1a9..32363dde 100644 --- a/mfem/_ser/sparsesmoothers.py +++ b/mfem/_ser/sparsesmoothers.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _sparsesmoothers.SWIG_PyInstanceMethod_New +_swig_new_static_method = _sparsesmoothers.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -82,6 +85,7 @@ def __init__(self, *args, **kwargs): def SetOperator(self, a): r"""SetOperator(SparseSmoother self, Operator a)""" return _sparsesmoothers.SparseSmoother_SetOperator(self, a) + SetOperator = _swig_new_instance_method(_sparsesmoothers.SparseSmoother_SetOperator) __swig_destroy__ = _sparsesmoothers.delete_SparseSmoother # Register SparseSmoother in _sparsesmoothers: @@ -103,6 +107,7 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(GSSmoother self, Vector x, Vector y)""" return _sparsesmoothers.GSSmoother_Mult(self, x, y) + Mult = _swig_new_instance_method(_sparsesmoothers.GSSmoother_Mult) __swig_destroy__ = _sparsesmoothers.delete_GSSmoother # Register GSSmoother in _sparsesmoothers: @@ -124,6 +129,7 @@ def __init__(self, *args): def Mult(self, x, y): r"""Mult(DSmoother self, Vector x, Vector y)""" return _sparsesmoothers.DSmoother_Mult(self, x, y) + Mult = _swig_new_instance_method(_sparsesmoothers.DSmoother_Mult) __swig_destroy__ = _sparsesmoothers.delete_DSmoother # Register DSmoother in _sparsesmoothers: diff --git a/mfem/_ser/sparsesmoothers_wrap.cxx b/mfem/_ser/sparsesmoothers_wrap.cxx index f3b8642e..0e3de2b3 100644 --- a/mfem/_ser/sparsesmoothers_wrap.cxx +++ b/mfem/_ser/sparsesmoothers_wrap.cxx @@ -3081,15 +3081,18 @@ namespace Swig { #define SWIGTYPE_p_mfem__PyOperatorBase swig_types[13] #define SWIGTYPE_p_mfem__PyTimeDependentOperatorBase swig_types[14] #define SWIGTYPE_p_mfem__RAPOperator swig_types[15] -#define SWIGTYPE_p_mfem__Solver swig_types[16] -#define SWIGTYPE_p_mfem__SparseMatrix swig_types[17] -#define SWIGTYPE_p_mfem__SparseSmoother swig_types[18] -#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[19] -#define SWIGTYPE_p_mfem__TransposeOperator swig_types[20] -#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[21] -#define SWIGTYPE_p_mfem__Vector swig_types[22] -static swig_type_info *swig_types[24]; -static swig_module_info swig_module = {swig_types, 23, 0, 0, 0, 0}; +#define SWIGTYPE_p_mfem__RectangularConstrainedOperator swig_types[16] +#define SWIGTYPE_p_mfem__ScaledOperator swig_types[17] +#define SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator swig_types[18] +#define SWIGTYPE_p_mfem__Solver swig_types[19] +#define SWIGTYPE_p_mfem__SparseMatrix swig_types[20] +#define SWIGTYPE_p_mfem__SparseSmoother swig_types[21] +#define SWIGTYPE_p_mfem__TimeDependentOperator swig_types[22] +#define SWIGTYPE_p_mfem__TransposeOperator swig_types[23] +#define SWIGTYPE_p_mfem__TripleProductOperator swig_types[24] +#define SWIGTYPE_p_mfem__Vector swig_types[25] +static swig_type_info *swig_types[27]; +static swig_module_info swig_module = {swig_types, 26, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -4510,6 +4513,7 @@ SWIGINTERN PyObject *DSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SparseSmoother_SetOperator(SparseSmoother self, Operator a)"}, { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, @@ -4533,6 +4537,27 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SetOperator(SparseSmoother self, Operator a)"}, + { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, + { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, + { "new_GSSmoother", _wrap_new_GSSmoother, METH_VARARGS, "\n" + "GSSmoother(int t=0, int it=1)\n" + "GSSmoother(SparseMatrix a, int t=0, int it=1)\n" + ""}, + { "GSSmoother_Mult", _wrap_GSSmoother_Mult, METH_VARARGS, "Mult(GSSmoother self, Vector x, Vector y)"}, + { "delete_GSSmoother", _wrap_delete_GSSmoother, METH_O, "delete_GSSmoother(GSSmoother self)"}, + { "GSSmoother_swigregister", GSSmoother_swigregister, METH_O, NULL}, + { "GSSmoother_swiginit", GSSmoother_swiginit, METH_VARARGS, NULL}, + { "new_DSmoother", _wrap_new_DSmoother, METH_VARARGS, "\n" + "DSmoother(int t=0, double s=1., int it=1)\n" + "DSmoother(SparseMatrix a, int t=0, double s=1., int it=1)\n" + ""}, + { "DSmoother_Mult", _wrap_DSmoother_Mult, METH_VARARGS, "Mult(DSmoother self, Vector x, Vector y)"}, + { "delete_DSmoother", _wrap_delete_DSmoother, METH_O, "delete_DSmoother(DSmoother self)"}, + { "DSmoother_swigregister", DSmoother_swigregister, METH_O, NULL}, + { "DSmoother_swiginit", DSmoother_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; @@ -4575,18 +4600,21 @@ static void *_p_mfem__DenseMatrixInverseTo_p_mfem__Operator(void *x, int *SWIGUN static void *_p_mfem__SolverTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Solver *) x)); } -static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); -} static void *_p_mfem__AbstractSparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::AbstractSparseMatrix *) x)); } +static void *_p_mfem__DenseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::Matrix *) ((mfem::DenseMatrix *) x)); +} static void *_p_mfem__SparseMatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) (mfem::Matrix *)(mfem::AbstractSparseMatrix *) ((mfem::SparseMatrix *) x)); } static void *_p_mfem__MatrixTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::Matrix *) x)); } +static void *_p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::RectangularConstrainedOperator *) x)); +} static void *_p_mfem__ConstrainedOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::ConstrainedOperator *) x)); } @@ -4602,9 +4630,15 @@ static void *_p_mfem__ProductOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSE static void *_p_mfem__TransposeOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TransposeOperator *) x)); } +static void *_p_mfem__ScaledOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) ((mfem::ScaledOperator *) x)); +} static void *_p_mfem__IdentityOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::IdentityOperator *) x)); } +static void *_p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((mfem::Operator *) (mfem::TimeDependentOperator *) ((mfem::SecondOrderTimeDependentOperator *) x)); +} static void *_p_mfem__TimeDependentOperatorTo_p_mfem__Operator(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((mfem::Operator *) ((mfem::TimeDependentOperator *) x)); } @@ -4638,15 +4672,18 @@ static swig_type_info _swigt__p_mfem__DenseMatrixInverse = {"_p_mfem__DenseMatri static swig_type_info _swigt__p_mfem__Operator = {"_p_mfem__Operator", "mfem::Operator *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__PyTimeDependentOperatorBase = {"_p_mfem__PyTimeDependentOperatorBase", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__PyOperatorBase = {"_p_mfem__PyOperatorBase", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__AbstractSparseMatrix = {"_p_mfem__AbstractSparseMatrix", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__DenseMatrix = {"_p_mfem__DenseMatrix", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Matrix = {"_p_mfem__Matrix", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__RAPOperator = {"_p_mfem__RAPOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TripleProductOperator = {"_p_mfem__TripleProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__ConstrainedOperator = {"_p_mfem__ConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__RectangularConstrainedOperator = {"_p_mfem__RectangularConstrainedOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ProductOperator = {"_p_mfem__ProductOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TransposeOperator = {"_p_mfem__TransposeOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__ScaledOperator = {"_p_mfem__ScaledOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__IdentityOperator = {"_p_mfem__IdentityOperator", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_mfem__SecondOrderTimeDependentOperator = {"_p_mfem__SecondOrderTimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__TimeDependentOperator = {"_p_mfem__TimeDependentOperator", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_mfem__Solver = {"_p_mfem__Solver", "mfem::Solver *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_mfem__SparseMatrix = {"_p_mfem__SparseMatrix", "mfem::SparseMatrix *", 0, 0, (void*)0, 0}; @@ -4670,6 +4707,9 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_mfem__PyOperatorBase, &_swigt__p_mfem__PyTimeDependentOperatorBase, &_swigt__p_mfem__RAPOperator, + &_swigt__p_mfem__RectangularConstrainedOperator, + &_swigt__p_mfem__ScaledOperator, + &_swigt__p_mfem__SecondOrderTimeDependentOperator, &_swigt__p_mfem__Solver, &_swigt__p_mfem__SparseMatrix, &_swigt__p_mfem__SparseSmoother, @@ -4687,17 +4727,20 @@ static swig_cast_info _swigc__p_mfem__DenseMatrixInverse[] = {{&_swigt__p_mfem__ static swig_cast_info _swigc__p_mfem__MatrixInverse[] = { {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__MatrixInverse, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__MatrixInverse, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__MatrixInverse, 0, 0}, {&_swigt__p_mfem__MatrixInverse, 0, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__MatrixInverse, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyTimeDependentOperatorBase[] = {{&_swigt__p_mfem__PyTimeDependentOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__PyOperatorBase[] = {{&_swigt__p_mfem__PyOperatorBase, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__AbstractSparseMatrix[] = {{&_swigt__p_mfem__AbstractSparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__DenseMatrix[] = {{&_swigt__p_mfem__DenseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Matrix[] = {{&_swigt__p_mfem__Matrix, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__RAPOperator[] = {{&_swigt__p_mfem__RAPOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TripleProductOperator[] = {{&_swigt__p_mfem__TripleProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__ConstrainedOperator[] = {{&_swigt__p_mfem__ConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__RectangularConstrainedOperator[] = {{&_swigt__p_mfem__RectangularConstrainedOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ProductOperator[] = {{&_swigt__p_mfem__ProductOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TransposeOperator[] = {{&_swigt__p_mfem__TransposeOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ScaledOperator[] = {{&_swigt__p_mfem__ScaledOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__IdentityOperator[] = {{&_swigt__p_mfem__IdentityOperator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__SecondOrderTimeDependentOperator[] = {{&_swigt__p_mfem__SecondOrderTimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__TimeDependentOperator[] = {{&_swigt__p_mfem__TimeDependentOperator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__Operator[] = { {&_swigt__p_mfem__PyTimeDependentOperatorBase, _p_mfem__PyTimeDependentOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__PyOperatorBase, _p_mfem__PyOperatorBaseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Solver, _p_mfem__SolverTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__AbstractSparseMatrix, _p_mfem__AbstractSparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__DenseMatrix, _p_mfem__DenseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseMatrix, _p_mfem__SparseMatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Matrix, _p_mfem__MatrixTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RAPOperator, _p_mfem__RAPOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__Operator, 0, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TripleProductOperator, _p_mfem__TripleProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ConstrainedOperator, _p_mfem__ConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__RectangularConstrainedOperator, _p_mfem__RectangularConstrainedOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ProductOperator, _p_mfem__ProductOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TransposeOperator, _p_mfem__TransposeOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__ScaledOperator, _p_mfem__ScaledOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__IdentityOperator, _p_mfem__IdentityOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__SecondOrderTimeDependentOperator, _p_mfem__SecondOrderTimeDependentOperatorTo_p_mfem__Operator, 0, 0}, {&_swigt__p_mfem__TimeDependentOperator, _p_mfem__TimeDependentOperatorTo_p_mfem__Operator, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__Solver[] = { {&_swigt__p_mfem__SparseSmoother, _p_mfem__SparseSmootherTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__Solver, 0, 0, 0}, {&_swigt__p_mfem__MatrixInverse, _p_mfem__MatrixInverseTo_p_mfem__Solver, 0, 0}, {&_swigt__p_mfem__DenseMatrixInverse, _p_mfem__DenseMatrixInverseTo_p_mfem__Solver, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseMatrix[] = { {&_swigt__p_mfem__SparseMatrix, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_mfem__SparseSmoother[] = { {&_swigt__p_mfem__SparseSmoother, 0, 0, 0}, {&_swigt__p_mfem__GSSmoother, _p_mfem__GSSmootherTo_p_mfem__SparseSmoother, 0, 0}, {&_swigt__p_mfem__DSmoother, _p_mfem__DSmootherTo_p_mfem__SparseSmoother, 0, 0},{0, 0, 0, 0}}; @@ -4720,6 +4763,9 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_mfem__PyOperatorBase, _swigc__p_mfem__PyTimeDependentOperatorBase, _swigc__p_mfem__RAPOperator, + _swigc__p_mfem__RectangularConstrainedOperator, + _swigc__p_mfem__ScaledOperator, + _swigc__p_mfem__SecondOrderTimeDependentOperator, _swigc__p_mfem__Solver, _swigc__p_mfem__SparseMatrix, _swigc__p_mfem__SparseSmoother, diff --git a/mfem/_ser/stable3d.py b/mfem/_ser/stable3d.py index c6612836..30679ae6 100644 --- a/mfem/_ser/stable3d.py +++ b/mfem/_ser/stable3d.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _stable3d.SWIG_PyInstanceMethod_New +_swig_new_static_method = _stable3d.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -105,14 +108,17 @@ def __init__(self, nr): def Push(self, r, c, f): r"""Push(STable3D self, int r, int c, int f) -> int""" return _stable3d.STable3D_Push(self, r, c, f) + Push = _swig_new_instance_method(_stable3d.STable3D_Push) def Index(self, r, c, f): r"""Index(STable3D self, int r, int c, int f) -> int""" return _stable3d.STable3D_Index(self, r, c, f) + Index = _swig_new_instance_method(_stable3d.STable3D_Index) def Push4(self, r, c, f, t): r"""Push4(STable3D self, int r, int c, int f, int t) -> int""" return _stable3d.STable3D_Push4(self, r, c, f, t) + Push4 = _swig_new_instance_method(_stable3d.STable3D_Push4) def __call__(self, *args): r""" @@ -120,10 +126,12 @@ def __call__(self, *args): __call__(STable3D self, int r, int c, int f, int t) -> int """ return _stable3d.STable3D___call__(self, *args) + __call__ = _swig_new_instance_method(_stable3d.STable3D___call__) def NumberOfElements(self): r"""NumberOfElements(STable3D self) -> int""" return _stable3d.STable3D_NumberOfElements(self) + NumberOfElements = _swig_new_instance_method(_stable3d.STable3D_NumberOfElements) __swig_destroy__ = _stable3d.delete_STable3D def Print(self, *args): @@ -132,6 +140,7 @@ def Print(self, *args): Print(STable3D self, char const * file, int precision=8) """ return _stable3d.STable3D_Print(self, *args) + Print = _swig_new_instance_method(_stable3d.STable3D_Print) # Register STable3D in _stable3d: _stable3d.STable3D_swigregister(STable3D) diff --git a/mfem/_ser/stable3d_wrap.cxx b/mfem/_ser/stable3d_wrap.cxx index e3f31aa2..39c84fa4 100644 --- a/mfem/_ser/stable3d_wrap.cxx +++ b/mfem/_ser/stable3d_wrap.cxx @@ -4470,6 +4470,7 @@ SWIGINTERN PyObject *STable3D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "STable3DNode_Prev_set", _wrap_STable3DNode_Prev_set, METH_VARARGS, "STable3DNode_Prev_set(STable3DNode self, STable3DNode Prev)"}, { "STable3DNode_Prev_get", _wrap_STable3DNode_Prev_get, METH_O, "STable3DNode_Prev_get(STable3DNode self) -> STable3DNode"}, { "STable3DNode_Column_set", _wrap_STable3DNode_Column_set, METH_VARARGS, "STable3DNode_Column_set(STable3DNode self, int Column)"}, @@ -4502,6 +4503,36 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "STable3DNode_Prev_set", _wrap_STable3DNode_Prev_set, METH_VARARGS, "STable3DNode_Prev_set(STable3DNode self, STable3DNode Prev)"}, + { "STable3DNode_Prev_get", _wrap_STable3DNode_Prev_get, METH_O, "STable3DNode_Prev_get(STable3DNode self) -> STable3DNode"}, + { "STable3DNode_Column_set", _wrap_STable3DNode_Column_set, METH_VARARGS, "STable3DNode_Column_set(STable3DNode self, int Column)"}, + { "STable3DNode_Column_get", _wrap_STable3DNode_Column_get, METH_O, "STable3DNode_Column_get(STable3DNode self) -> int"}, + { "STable3DNode_Floor_set", _wrap_STable3DNode_Floor_set, METH_VARARGS, "STable3DNode_Floor_set(STable3DNode self, int Floor)"}, + { "STable3DNode_Floor_get", _wrap_STable3DNode_Floor_get, METH_O, "STable3DNode_Floor_get(STable3DNode self) -> int"}, + { "STable3DNode_Number_set", _wrap_STable3DNode_Number_set, METH_VARARGS, "STable3DNode_Number_set(STable3DNode self, int Number)"}, + { "STable3DNode_Number_get", _wrap_STable3DNode_Number_get, METH_O, "STable3DNode_Number_get(STable3DNode self) -> int"}, + { "new_STable3DNode", _wrap_new_STable3DNode, METH_NOARGS, "new_STable3DNode() -> STable3DNode"}, + { "delete_STable3DNode", _wrap_delete_STable3DNode, METH_O, "delete_STable3DNode(STable3DNode self)"}, + { "STable3DNode_swigregister", STable3DNode_swigregister, METH_O, NULL}, + { "STable3DNode_swiginit", STable3DNode_swiginit, METH_VARARGS, NULL}, + { "new_STable3D", _wrap_new_STable3D, METH_O, "new_STable3D(int nr) -> STable3D"}, + { "STable3D_Push", _wrap_STable3D_Push, METH_VARARGS, "Push(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Index", _wrap_STable3D_Index, METH_VARARGS, "Index(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Push4", _wrap_STable3D_Push4, METH_VARARGS, "Push4(STable3D self, int r, int c, int f, int t) -> int"}, + { "STable3D___call__", _wrap_STable3D___call__, METH_VARARGS, "\n" + "__call__(STable3D self, int r, int c, int f) -> int\n" + "__call__(STable3D self, int r, int c, int f, int t) -> int\n" + ""}, + { "STable3D_NumberOfElements", _wrap_STable3D_NumberOfElements, METH_O, "NumberOfElements(STable3D self) -> int"}, + { "delete_STable3D", _wrap_delete_STable3D, METH_O, "delete_STable3D(STable3D self)"}, + { "STable3D_Print", _wrap_STable3D_Print, METH_VARARGS, "\n" + "Print(STable3D self, std::ostream & out=mfem::out)\n" + "Print(STable3D self, char const * file, int precision=8)\n" + ""}, + { "STable3D_swigregister", STable3D_swigregister, METH_O, NULL}, + { "STable3D_swiginit", STable3D_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/table.py b/mfem/_ser/table.py index 057580c6..7bfdbeda 100644 --- a/mfem/_ser/table.py +++ b/mfem/_ser/table.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _table.SWIG_PyInstanceMethod_New +_swig_new_static_method = _table.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -81,10 +84,12 @@ def __init__(self, *args): def __eq__(self, rhs): r"""__eq__(Connection self, Connection rhs) -> bool""" return _table.Connection___eq__(self, rhs) + __eq__ = _swig_new_instance_method(_table.Connection___eq__) def __lt__(self, rhs): r"""__lt__(Connection self, Connection rhs) -> bool""" return _table.Connection___lt__(self, rhs) + __lt__ = _swig_new_instance_method(_table.Connection___lt__) __swig_destroy__ = _table.delete_Connection # Register Connection in _table: @@ -109,54 +114,67 @@ def __init__(self, *args): def MakeI(self, nrows): r"""MakeI(Table self, int nrows)""" return _table.Table_MakeI(self, nrows) + MakeI = _swig_new_instance_method(_table.Table_MakeI) def AddAColumnInRow(self, r): r"""AddAColumnInRow(Table self, int r)""" return _table.Table_AddAColumnInRow(self, r) + AddAColumnInRow = _swig_new_instance_method(_table.Table_AddAColumnInRow) def AddColumnsInRow(self, r, ncol): r"""AddColumnsInRow(Table self, int r, int ncol)""" return _table.Table_AddColumnsInRow(self, r, ncol) + AddColumnsInRow = _swig_new_instance_method(_table.Table_AddColumnsInRow) def MakeJ(self): r"""MakeJ(Table self)""" return _table.Table_MakeJ(self) + MakeJ = _swig_new_instance_method(_table.Table_MakeJ) def AddConnection(self, r, c): r"""AddConnection(Table self, int r, int c)""" return _table.Table_AddConnection(self, r, c) + AddConnection = _swig_new_instance_method(_table.Table_AddConnection) def AddConnections(self, r, c, nc): r"""AddConnections(Table self, int r, int const * c, int nc)""" return _table.Table_AddConnections(self, r, c, nc) + AddConnections = _swig_new_instance_method(_table.Table_AddConnections) def ShiftUpI(self): r"""ShiftUpI(Table self)""" return _table.Table_ShiftUpI(self) + ShiftUpI = _swig_new_instance_method(_table.Table_ShiftUpI) def SetSize(self, dim, connections_per_row): r"""SetSize(Table self, int dim, int connections_per_row)""" return _table.Table_SetSize(self, dim, connections_per_row) + SetSize = _swig_new_instance_method(_table.Table_SetSize) def SetDims(self, rows, nnz): r"""SetDims(Table self, int rows, int nnz)""" return _table.Table_SetDims(self, rows, nnz) + SetDims = _swig_new_instance_method(_table.Table_SetDims) def Size(self): r"""Size(Table self) -> int""" return _table.Table_Size(self) + Size = _swig_new_instance_method(_table.Table_Size) def Size_of_connections(self): r"""Size_of_connections(Table self) -> int""" return _table.Table_Size_of_connections(self) + Size_of_connections = _swig_new_instance_method(_table.Table_Size_of_connections) def __call__(self, i, j): r"""__call__(Table self, int i, int j) -> int""" return _table.Table___call__(self, i, j) + __call__ = _swig_new_instance_method(_table.Table___call__) def RowSize(self, i): r"""RowSize(Table self, int i) -> int""" return _table.Table_RowSize(self, i) + RowSize = _swig_new_instance_method(_table.Table_RowSize) def GetRow(self, *args): r""" @@ -165,6 +183,7 @@ def GetRow(self, *args): GetRow(Table self, int i) -> int * """ return _table.Table_GetRow(self, *args) + GetRow = _swig_new_instance_method(_table.Table_GetRow) def GetI(self, *args): r""" @@ -172,6 +191,7 @@ def GetI(self, *args): GetI(Table self) -> int const * """ return _table.Table_GetI(self, *args) + GetI = _swig_new_instance_method(_table.Table_GetI) def GetJ(self, *args): r""" @@ -179,6 +199,7 @@ def GetJ(self, *args): GetJ(Table self) -> int const * """ return _table.Table_GetJ(self, *args) + GetJ = _swig_new_instance_method(_table.Table_GetJ) def GetIMemory(self, *args): r""" @@ -186,6 +207,7 @@ def GetIMemory(self, *args): GetIMemory(Table self) -> mfem::Memory< int > const & """ return _table.Table_GetIMemory(self, *args) + GetIMemory = _swig_new_instance_method(_table.Table_GetIMemory) def GetJMemory(self, *args): r""" @@ -193,59 +215,73 @@ def GetJMemory(self, *args): GetJMemory(Table self) -> mfem::Memory< int > const & """ return _table.Table_GetJMemory(self, *args) + GetJMemory = _swig_new_instance_method(_table.Table_GetJMemory) def SortRows(self): r"""SortRows(Table self)""" return _table.Table_SortRows(self) + SortRows = _swig_new_instance_method(_table.Table_SortRows) def SetIJ(self, newI, newJ, newsize=-1): r"""SetIJ(Table self, int * newI, int * newJ, int newsize=-1)""" return _table.Table_SetIJ(self, newI, newJ, newsize) + SetIJ = _swig_new_instance_method(_table.Table_SetIJ) def Push(self, i, j): r"""Push(Table self, int i, int j) -> int""" return _table.Table_Push(self, i, j) + Push = _swig_new_instance_method(_table.Table_Push) def Finalize(self): r"""Finalize(Table self)""" return _table.Table_Finalize(self) + Finalize = _swig_new_instance_method(_table.Table_Finalize) def MakeFromList(self, nrows, list): r"""MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)""" return _table.Table_MakeFromList(self, nrows, list) + MakeFromList = _swig_new_instance_method(_table.Table_MakeFromList) def Width(self): r"""Width(Table self) -> int""" return _table.Table_Width(self) + Width = _swig_new_instance_method(_table.Table_Width) def LoseData(self): r"""LoseData(Table self)""" return _table.Table_LoseData(self) + LoseData = _swig_new_instance_method(_table.Table_LoseData) def Load(self, _in): r"""Load(Table self, std::istream & _in)""" return _table.Table_Load(self, _in) + Load = _swig_new_instance_method(_table.Table_Load) def Copy(self, copy): r"""Copy(Table self, Table copy)""" return _table.Table_Copy(self, copy) + Copy = _swig_new_instance_method(_table.Table_Copy) def Swap(self, other): r"""Swap(Table self, Table other)""" return _table.Table_Swap(self, other) + Swap = _swig_new_instance_method(_table.Table_Swap) def Clear(self): r"""Clear(Table self)""" return _table.Table_Clear(self) + Clear = _swig_new_instance_method(_table.Table_Clear) def MemoryUsage(self): r"""MemoryUsage(Table self) -> long""" return _table.Table_MemoryUsage(self) + MemoryUsage = _swig_new_instance_method(_table.Table_MemoryUsage) __swig_destroy__ = _table.delete_Table def GetRowList(self, i): r"""GetRowList(Table self, int i) -> PyObject *""" return _table.Table_GetRowList(self, i) + GetRowList = _swig_new_instance_method(_table.Table_GetRowList) def Print(self, *args): r""" @@ -253,6 +289,7 @@ def Print(self, *args): Print(Table self, char const * file, int precision=8) """ return _table.Table_Print(self, *args) + Print = _swig_new_instance_method(_table.Table_Print) def PrintMatlab(self, *args): r""" @@ -260,6 +297,7 @@ def PrintMatlab(self, *args): PrintMatlab(Table self, char const * file, int precision=8) """ return _table.Table_PrintMatlab(self, *args) + PrintMatlab = _swig_new_instance_method(_table.Table_PrintMatlab) def Save(self, *args): r""" @@ -268,6 +306,7 @@ def Save(self, *args): Save(Table self) """ return _table.Table_Save(self, *args) + Save = _swig_new_instance_method(_table.Table_Save) # Register Table in _table: _table.Table_swigregister(Table) @@ -285,10 +324,12 @@ def __init__(self, dim, connections_per_row=3): def __call__(self, i, j): r"""__call__(STable self, int i, int j) -> int""" return _table.STable___call__(self, i, j) + __call__ = _swig_new_instance_method(_table.STable___call__) def Push(self, i, j): r"""Push(STable self, int i, int j) -> int""" return _table.STable_Push(self, i, j) + Push = _swig_new_instance_method(_table.STable_Push) __swig_destroy__ = _table.delete_STable # Register STable in _table: @@ -307,18 +348,22 @@ def __init__(self, nrows): def NumberOfRows(self): r"""NumberOfRows(DSTable self) -> int""" return _table.DSTable_NumberOfRows(self) + NumberOfRows = _swig_new_instance_method(_table.DSTable_NumberOfRows) def NumberOfEntries(self): r"""NumberOfEntries(DSTable self) -> int""" return _table.DSTable_NumberOfEntries(self) + NumberOfEntries = _swig_new_instance_method(_table.DSTable_NumberOfEntries) def Push(self, a, b): r"""Push(DSTable self, int a, int b) -> int""" return _table.DSTable_Push(self, a, b) + Push = _swig_new_instance_method(_table.DSTable_Push) def __call__(self, a, b): r"""__call__(DSTable self, int a, int b) -> int""" return _table.DSTable___call__(self, a, b) + __call__ = _swig_new_instance_method(_table.DSTable___call__) __swig_destroy__ = _table.delete_DSTable # Register DSTable in _table: diff --git a/mfem/_ser/table_wrap.cxx b/mfem/_ser/table_wrap.cxx index 85c1a27c..55ac4697 100644 --- a/mfem/_ser/table_wrap.cxx +++ b/mfem/_ser/table_wrap.cxx @@ -7108,6 +7108,7 @@ SWIGINTERN PyObject *DSTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "Connection__from_set", _wrap_Connection__from_set, METH_VARARGS, "Connection__from_set(Connection self, int _from)"}, { "Connection__from_get", _wrap_Connection__from_get, METH_O, "Connection__from_get(Connection self) -> int"}, { "Connection_to_set", _wrap_Connection_to_set, METH_VARARGS, "Connection_to_set(Connection self, int to)"}, @@ -7209,6 +7210,105 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "Connection__from_set", _wrap_Connection__from_set, METH_VARARGS, "Connection__from_set(Connection self, int _from)"}, + { "Connection__from_get", _wrap_Connection__from_get, METH_O, "Connection__from_get(Connection self) -> int"}, + { "Connection_to_set", _wrap_Connection_to_set, METH_VARARGS, "Connection_to_set(Connection self, int to)"}, + { "Connection_to_get", _wrap_Connection_to_get, METH_O, "Connection_to_get(Connection self) -> int"}, + { "new_Connection", _wrap_new_Connection, METH_VARARGS, "\n" + "Connection()\n" + "new_Connection(int _from, int to) -> Connection\n" + ""}, + { "Connection___eq__", _wrap_Connection___eq__, METH_VARARGS, "__eq__(Connection self, Connection rhs) -> bool"}, + { "Connection___lt__", _wrap_Connection___lt__, METH_VARARGS, "__lt__(Connection self, Connection rhs) -> bool"}, + { "delete_Connection", _wrap_delete_Connection, METH_O, "delete_Connection(Connection self)"}, + { "Connection_swigregister", Connection_swigregister, METH_O, NULL}, + { "Connection_swiginit", Connection_swiginit, METH_VARARGS, NULL}, + { "new_Table", _wrap_new_Table, METH_VARARGS, "\n" + "Table()\n" + "Table(Table arg1)\n" + "Table(int dim, int connections_per_row=3)\n" + "Table(int nrows, mfem::Array< mfem::Connection > & list)\n" + "new_Table(int nrows, int * partitioning) -> Table\n" + ""}, + { "Table_MakeI", _wrap_Table_MakeI, METH_VARARGS, "MakeI(Table self, int nrows)"}, + { "Table_AddAColumnInRow", _wrap_Table_AddAColumnInRow, METH_VARARGS, "AddAColumnInRow(Table self, int r)"}, + { "Table_AddColumnsInRow", _wrap_Table_AddColumnsInRow, METH_VARARGS, "AddColumnsInRow(Table self, int r, int ncol)"}, + { "Table_MakeJ", _wrap_Table_MakeJ, METH_O, "MakeJ(Table self)"}, + { "Table_AddConnection", _wrap_Table_AddConnection, METH_VARARGS, "AddConnection(Table self, int r, int c)"}, + { "Table_AddConnections", _wrap_Table_AddConnections, METH_VARARGS, "AddConnections(Table self, int r, int const * c, int nc)"}, + { "Table_ShiftUpI", _wrap_Table_ShiftUpI, METH_O, "ShiftUpI(Table self)"}, + { "Table_SetSize", _wrap_Table_SetSize, METH_VARARGS, "SetSize(Table self, int dim, int connections_per_row)"}, + { "Table_SetDims", _wrap_Table_SetDims, METH_VARARGS, "SetDims(Table self, int rows, int nnz)"}, + { "Table_Size", _wrap_Table_Size, METH_O, "Size(Table self) -> int"}, + { "Table_Size_of_connections", _wrap_Table_Size_of_connections, METH_O, "Size_of_connections(Table self) -> int"}, + { "Table___call__", _wrap_Table___call__, METH_VARARGS, "__call__(Table self, int i, int j) -> int"}, + { "Table_RowSize", _wrap_Table_RowSize, METH_VARARGS, "RowSize(Table self, int i) -> int"}, + { "Table_GetRow", _wrap_Table_GetRow, METH_VARARGS, "\n" + "GetRow(Table self, int i, intArray row)\n" + "GetRow(Table self, int i) -> int const\n" + "GetRow(Table self, int i) -> int *\n" + ""}, + { "Table_GetI", _wrap_Table_GetI, METH_VARARGS, "\n" + "GetI(Table self) -> int\n" + "GetI(Table self) -> int const *\n" + ""}, + { "Table_GetJ", _wrap_Table_GetJ, METH_VARARGS, "\n" + "GetJ(Table self) -> int\n" + "GetJ(Table self) -> int const *\n" + ""}, + { "Table_GetIMemory", _wrap_Table_GetIMemory, METH_VARARGS, "\n" + "GetIMemory(Table self) -> mfem::Memory< int >\n" + "GetIMemory(Table self) -> mfem::Memory< int > const &\n" + ""}, + { "Table_GetJMemory", _wrap_Table_GetJMemory, METH_VARARGS, "\n" + "GetJMemory(Table self) -> mfem::Memory< int >\n" + "GetJMemory(Table self) -> mfem::Memory< int > const &\n" + ""}, + { "Table_SortRows", _wrap_Table_SortRows, METH_O, "SortRows(Table self)"}, + { "Table_SetIJ", _wrap_Table_SetIJ, METH_VARARGS, "SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, + { "Table_Push", _wrap_Table_Push, METH_VARARGS, "Push(Table self, int i, int j) -> int"}, + { "Table_Finalize", _wrap_Table_Finalize, METH_O, "Finalize(Table self)"}, + { "Table_MakeFromList", _wrap_Table_MakeFromList, METH_VARARGS, "MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, + { "Table_Width", _wrap_Table_Width, METH_O, "Width(Table self) -> int"}, + { "Table_LoseData", _wrap_Table_LoseData, METH_O, "LoseData(Table self)"}, + { "Table_Load", _wrap_Table_Load, METH_VARARGS, "Load(Table self, std::istream & _in)"}, + { "Table_Copy", _wrap_Table_Copy, METH_VARARGS, "Copy(Table self, Table copy)"}, + { "Table_Swap", _wrap_Table_Swap, METH_VARARGS, "Swap(Table self, Table other)"}, + { "Table_Clear", _wrap_Table_Clear, METH_O, "Clear(Table self)"}, + { "Table_MemoryUsage", _wrap_Table_MemoryUsage, METH_O, "MemoryUsage(Table self) -> long"}, + { "delete_Table", _wrap_delete_Table, METH_O, "delete_Table(Table self)"}, + { "Table_GetRowList", _wrap_Table_GetRowList, METH_VARARGS, "GetRowList(Table self, int i) -> PyObject *"}, + { "Table_Print", _wrap_Table_Print, METH_VARARGS, "\n" + "Print(Table self, std::ostream & out=mfem::out, int width=4)\n" + "Print(Table self, char const * file, int precision=8)\n" + ""}, + { "Table_PrintMatlab", _wrap_Table_PrintMatlab, METH_VARARGS, "\n" + "PrintMatlab(Table self, std::ostream & out)\n" + "PrintMatlab(Table self, char const * file, int precision=8)\n" + ""}, + { "Table_Save", _wrap_Table_Save, METH_VARARGS, "\n" + "Save(Table self, std::ostream & out)\n" + "Save(Table self, char const * file, int precision=8)\n" + "Save(Table self)\n" + ""}, + { "Table_swigregister", Table_swigregister, METH_O, NULL}, + { "Table_swiginit", Table_swiginit, METH_VARARGS, NULL}, + { "new_STable", _wrap_new_STable, METH_VARARGS, "STable(int dim, int connections_per_row=3)"}, + { "STable___call__", _wrap_STable___call__, METH_VARARGS, "__call__(STable self, int i, int j) -> int"}, + { "STable_Push", _wrap_STable_Push, METH_VARARGS, "Push(STable self, int i, int j) -> int"}, + { "delete_STable", _wrap_delete_STable, METH_O, "delete_STable(STable self)"}, + { "STable_swigregister", STable_swigregister, METH_O, NULL}, + { "STable_swiginit", STable_swiginit, METH_VARARGS, NULL}, + { "new_DSTable", _wrap_new_DSTable, METH_O, "new_DSTable(int nrows) -> DSTable"}, + { "DSTable_NumberOfRows", _wrap_DSTable_NumberOfRows, METH_O, "NumberOfRows(DSTable self) -> int"}, + { "DSTable_NumberOfEntries", _wrap_DSTable_NumberOfEntries, METH_O, "NumberOfEntries(DSTable self) -> int"}, + { "DSTable_Push", _wrap_DSTable_Push, METH_VARARGS, "Push(DSTable self, int a, int b) -> int"}, + { "DSTable___call__", _wrap_DSTable___call__, METH_VARARGS, "__call__(DSTable self, int a, int b) -> int"}, + { "delete_DSTable", _wrap_delete_DSTable, METH_O, "delete_DSTable(DSTable self)"}, + { "DSTable_swigregister", DSTable_swigregister, METH_O, NULL}, + { "DSTable_swiginit", DSTable_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/vector.py b/mfem/_ser/vector.py index 12cd3f33..dccfbfa4 100644 --- a/mfem/_ser/vector.py +++ b/mfem/_ser/vector.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _vector.SWIG_PyInstanceMethod_New +_swig_new_static_method = _vector.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -72,6 +75,7 @@ def add_vector(*args): add_vector(double const a, Vector x, double const b, Vector y, Vector z) """ return _vector.add_vector(*args) +add_vector = _vector.add_vector def subtract_vector(*args): r""" @@ -79,14 +83,17 @@ def subtract_vector(*args): subtract_vector(double const a, Vector x, Vector y, Vector z) """ return _vector.subtract_vector(*args) +subtract_vector = _vector.subtract_vector def CheckFinite(v, n): r"""CheckFinite(double const * v, int const n) -> int""" return _vector.CheckFinite(v, n) +CheckFinite = _vector.CheckFinite def infinity(): r"""infinity() -> double""" return _vector.infinity() +infinity = _vector.infinity class Vector(object): r"""Proxy of C++ mfem::Vector class.""" @@ -99,6 +106,7 @@ def UseDevice(self, *args): UseDevice(Vector self) -> bool """ return _vector.Vector_UseDevice(self, *args) + UseDevice = _swig_new_instance_method(_vector.Vector_UseDevice) def Load(self, *args): r""" @@ -107,6 +115,7 @@ def Load(self, *args): Load(Vector self, std::istream & _in) """ return _vector.Vector_Load(self, *args) + Load = _swig_new_instance_method(_vector.Vector_Load) def SetSize(self, *args): r""" @@ -115,42 +124,60 @@ def SetSize(self, *args): SetSize(Vector self, int s, Vector v) """ return _vector.Vector_SetSize(self, *args) + SetSize = _swig_new_instance_method(_vector.Vector_SetSize) def SetData(self, d): r"""SetData(Vector self, double * d)""" return _vector.Vector_SetData(self, d) + SetData = _swig_new_instance_method(_vector.Vector_SetData) def SetDataAndSize(self, d, s): r"""SetDataAndSize(Vector self, double * d, int s)""" return _vector.Vector_SetDataAndSize(self, d, s) + SetDataAndSize = _swig_new_instance_method(_vector.Vector_SetDataAndSize) def NewDataAndSize(self, d, s): r"""NewDataAndSize(Vector self, double * d, int s)""" return _vector.Vector_NewDataAndSize(self, d, s) + NewDataAndSize = _swig_new_instance_method(_vector.Vector_NewDataAndSize) def NewMemoryAndSize(self, mem, s, own_mem): r"""NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)""" return _vector.Vector_NewMemoryAndSize(self, mem, s, own_mem) + NewMemoryAndSize = _swig_new_instance_method(_vector.Vector_NewMemoryAndSize) + + def MakeRef(self, *args): + r""" + MakeRef(Vector self, Vector base, int offset, int size) + MakeRef(Vector self, Vector base, int offset) + """ + return _vector.Vector_MakeRef(self, *args) + MakeRef = _swig_new_instance_method(_vector.Vector_MakeRef) def MakeDataOwner(self): r"""MakeDataOwner(Vector self)""" return _vector.Vector_MakeDataOwner(self) + MakeDataOwner = _swig_new_instance_method(_vector.Vector_MakeDataOwner) def Destroy(self): r"""Destroy(Vector self)""" return _vector.Vector_Destroy(self) + Destroy = _swig_new_instance_method(_vector.Vector_Destroy) def Size(self): r"""Size(Vector self) -> int""" return _vector.Vector_Size(self) + Size = _swig_new_instance_method(_vector.Vector_Size) def Capacity(self): r"""Capacity(Vector self) -> int""" return _vector.Vector_Capacity(self) + Capacity = _swig_new_instance_method(_vector.Vector_Capacity) def GetData(self): r"""GetData(Vector self) -> double *""" return _vector.Vector_GetData(self) + GetData = _swig_new_instance_method(_vector.Vector_GetData) def GetMemory(self, *args): r""" @@ -158,18 +185,22 @@ def GetMemory(self, *args): GetMemory(Vector self) -> mfem::Memory< double > const & """ return _vector.Vector_GetMemory(self, *args) + GetMemory = _swig_new_instance_method(_vector.Vector_GetMemory) def SyncMemory(self, v): r"""SyncMemory(Vector self, Vector v)""" return _vector.Vector_SyncMemory(self, v) + SyncMemory = _swig_new_instance_method(_vector.Vector_SyncMemory) def SyncAliasMemory(self, v): r"""SyncAliasMemory(Vector self, Vector v)""" return _vector.Vector_SyncAliasMemory(self, v) + SyncAliasMemory = _swig_new_instance_method(_vector.Vector_SyncAliasMemory) def OwnsData(self): r"""OwnsData(Vector self) -> bool""" return _vector.Vector_OwnsData(self) + OwnsData = _swig_new_instance_method(_vector.Vector_OwnsData) def StealData(self, *args): r""" @@ -177,6 +208,7 @@ def StealData(self, *args): StealData(Vector self) -> double * """ return _vector.Vector_StealData(self, *args) + StealData = _swig_new_instance_method(_vector.Vector_StealData) def Elem(self, *args): r""" @@ -184,6 +216,7 @@ def Elem(self, *args): Elem(Vector self, int i) -> double const & """ return _vector.Vector_Elem(self, *args) + Elem = _swig_new_instance_method(_vector.Vector_Elem) def __call__(self, *args): r""" @@ -191,6 +224,7 @@ def __call__(self, *args): __call__(Vector self, int i) -> double const & """ return _vector.Vector___call__(self, *args) + __call__ = _swig_new_instance_method(_vector.Vector___call__) def __mul__(self, *args): r""" @@ -198,6 +232,7 @@ def __mul__(self, *args): __mul__(Vector self, Vector v) -> double """ return _vector.Vector___mul__(self, *args) + __mul__ = _swig_new_instance_method(_vector.Vector___mul__) def __imul__(self, v): ret = _vector.Vector___imul__(self, v) @@ -234,26 +269,32 @@ def __iadd__(self, v): def Add(self, a, Va): r"""Add(Vector self, double const a, Vector Va) -> Vector""" return _vector.Vector_Add(self, a, Va) + Add = _swig_new_instance_method(_vector.Vector_Add) def Set(self, a, x): r"""Set(Vector self, double const a, Vector x) -> Vector""" return _vector.Vector_Set(self, a, x) + Set = _swig_new_instance_method(_vector.Vector_Set) def SetVector(self, v, offset): r"""SetVector(Vector self, Vector v, int offset)""" return _vector.Vector_SetVector(self, v, offset) + SetVector = _swig_new_instance_method(_vector.Vector_SetVector) def Neg(self): r"""Neg(Vector self)""" return _vector.Vector_Neg(self) + Neg = _swig_new_instance_method(_vector.Vector_Neg) def Swap(self, other): r"""Swap(Vector self, Vector other)""" return _vector.Vector_Swap(self, other) + Swap = _swig_new_instance_method(_vector.Vector_Swap) def median(self, lo, hi): r"""median(Vector self, Vector lo, Vector hi)""" return _vector.Vector_median(self, lo, hi) + median = _swig_new_instance_method(_vector.Vector_median) def GetSubVector(self, *args): r""" @@ -261,6 +302,7 @@ def GetSubVector(self, *args): GetSubVector(Vector self, intArray dofs, double * elem_data) """ return _vector.Vector_GetSubVector(self, *args) + GetSubVector = _swig_new_instance_method(_vector.Vector_GetSubVector) def SetSubVector(self, *args): r""" @@ -269,6 +311,7 @@ def SetSubVector(self, *args): SetSubVector(Vector self, intArray dofs, double * elem_data) """ return _vector.Vector_SetSubVector(self, *args) + SetSubVector = _swig_new_instance_method(_vector.Vector_SetSubVector) def AddElementVector(self, *args): r""" @@ -277,79 +320,98 @@ def AddElementVector(self, *args): AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect) """ return _vector.Vector_AddElementVector(self, *args) + AddElementVector = _swig_new_instance_method(_vector.Vector_AddElementVector) def SetSubVectorComplement(self, dofs, val): r"""SetSubVectorComplement(Vector self, intArray dofs, double const val)""" return _vector.Vector_SetSubVectorComplement(self, dofs, val) + SetSubVectorComplement = _swig_new_instance_method(_vector.Vector_SetSubVectorComplement) def Randomize(self, seed=0): r"""Randomize(Vector self, int seed=0)""" return _vector.Vector_Randomize(self, seed) + Randomize = _swig_new_instance_method(_vector.Vector_Randomize) def Norml2(self): r"""Norml2(Vector self) -> double""" return _vector.Vector_Norml2(self) + Norml2 = _swig_new_instance_method(_vector.Vector_Norml2) def Normlinf(self): r"""Normlinf(Vector self) -> double""" return _vector.Vector_Normlinf(self) + Normlinf = _swig_new_instance_method(_vector.Vector_Normlinf) def Norml1(self): r"""Norml1(Vector self) -> double""" return _vector.Vector_Norml1(self) + Norml1 = _swig_new_instance_method(_vector.Vector_Norml1) def Normlp(self, p): r"""Normlp(Vector self, double p) -> double""" return _vector.Vector_Normlp(self, p) + Normlp = _swig_new_instance_method(_vector.Vector_Normlp) def Max(self): r"""Max(Vector self) -> double""" return _vector.Vector_Max(self) + Max = _swig_new_instance_method(_vector.Vector_Max) def Min(self): r"""Min(Vector self) -> double""" return _vector.Vector_Min(self) + Min = _swig_new_instance_method(_vector.Vector_Min) def Sum(self): r"""Sum(Vector self) -> double""" return _vector.Vector_Sum(self) + Sum = _swig_new_instance_method(_vector.Vector_Sum) def DistanceSquaredTo(self, p): r"""DistanceSquaredTo(Vector self, double const * p) -> double""" return _vector.Vector_DistanceSquaredTo(self, p) + DistanceSquaredTo = _swig_new_instance_method(_vector.Vector_DistanceSquaredTo) def DistanceTo(self, p): r"""DistanceTo(Vector self, double const * p) -> double""" return _vector.Vector_DistanceTo(self, p) + DistanceTo = _swig_new_instance_method(_vector.Vector_DistanceTo) def CheckFinite(self): r"""CheckFinite(Vector self) -> int""" return _vector.Vector_CheckFinite(self) + CheckFinite = _swig_new_instance_method(_vector.Vector_CheckFinite) __swig_destroy__ = _vector.delete_Vector def Read(self, on_dev=True): r"""Read(Vector self, bool on_dev=True) -> double const""" return _vector.Vector_Read(self, on_dev) + Read = _swig_new_instance_method(_vector.Vector_Read) def HostRead(self): r"""HostRead(Vector self) -> double const *""" return _vector.Vector_HostRead(self) + HostRead = _swig_new_instance_method(_vector.Vector_HostRead) def Write(self, on_dev=True): r"""Write(Vector self, bool on_dev=True) -> double""" return _vector.Vector_Write(self, on_dev) + Write = _swig_new_instance_method(_vector.Vector_Write) def HostWrite(self): r"""HostWrite(Vector self) -> double *""" return _vector.Vector_HostWrite(self) + HostWrite = _swig_new_instance_method(_vector.Vector_HostWrite) def ReadWrite(self, on_dev=True): r"""ReadWrite(Vector self, bool on_dev=True) -> double""" return _vector.Vector_ReadWrite(self, on_dev) + ReadWrite = _swig_new_instance_method(_vector.Vector_ReadWrite) def HostReadWrite(self): r"""HostReadWrite(Vector self) -> double *""" return _vector.Vector_HostReadWrite(self) + HostReadWrite = _swig_new_instance_method(_vector.Vector_HostReadWrite) def __init__(self, *args): r""" @@ -428,14 +490,17 @@ def Assign(self, *args): def __setitem__(self, i, v): r"""__setitem__(Vector self, int i, double const v)""" return _vector.Vector___setitem__(self, i, v) + __setitem__ = _swig_new_instance_method(_vector.Vector___setitem__) def __getitem__(self, param): r"""__getitem__(Vector self, PyObject * param) -> PyObject *""" return _vector.Vector___getitem__(self, param) + __getitem__ = _swig_new_instance_method(_vector.Vector___getitem__) def GetDataArray(self): r"""GetDataArray(Vector self) -> PyObject *""" return _vector.Vector_GetDataArray(self) + GetDataArray = _swig_new_instance_method(_vector.Vector_GetDataArray) def Print(self, *args): r""" @@ -443,6 +508,7 @@ def Print(self, *args): Print(Vector self, char const * file, int precision=8) """ return _vector.Vector_Print(self, *args) + Print = _swig_new_instance_method(_vector.Vector_Print) def Print_HYPRE(self, *args): r""" @@ -451,6 +517,7 @@ def Print_HYPRE(self, *args): Print_HYPRE(Vector self) """ return _vector.Vector_Print_HYPRE(self, *args) + Print_HYPRE = _swig_new_instance_method(_vector.Vector_Print_HYPRE) # Register Vector in _vector: _vector.Vector_swigregister(Vector) @@ -459,14 +526,17 @@ def Print_HYPRE(self, *args): def IsFinite(val): r"""IsFinite(double const & val) -> bool""" return _vector.IsFinite(val) +IsFinite = _vector.IsFinite def DistanceSquared(x, y, n): r"""DistanceSquared(double const * x, double const * y, int const n) -> double""" return _vector.DistanceSquared(x, y, n) +DistanceSquared = _vector.DistanceSquared def Distance(x, y, n): r"""Distance(double const * x, double const * y, int const n) -> double""" return _vector.Distance(x, y, n) +Distance = _vector.Distance Vector.__idiv__ = Vector.__itruediv__ diff --git a/mfem/_ser/vector_wrap.cxx b/mfem/_ser/vector_wrap.cxx index 48951dda..5c971562 100644 --- a/mfem/_ser/vector_wrap.cxx +++ b/mfem/_ser/vector_wrap.cxx @@ -4902,6 +4902,195 @@ SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self } +SWIGINTERN PyObject *_wrap_Vector_MakeRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Vector *arg1 = (mfem::Vector *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + int arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_MakeRef" "', argument " "1"" of type '" "mfem::Vector *""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Vector_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Vector *arg1 = (mfem::Vector *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_MakeRef" "', argument " "1"" of type '" "mfem::Vector *""'"); + } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + (arg1)->MakeRef(*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Vector_MakeRef(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_MakeRef", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Vector_MakeRef__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Vector_MakeRef__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_MakeRef'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Vector::MakeRef(mfem::Vector &,int,int)\n" + " mfem::Vector::MakeRef(mfem::Vector &,int)\n"); + return 0; +} + + SWIGINTERN PyObject *_wrap_Vector_MakeDataOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -9519,6 +9708,7 @@ SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *ar static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "add_vector", _wrap_add_vector, METH_VARARGS, "\n" "add_vector(Vector v1, Vector v2, Vector v)\n" "add_vector(Vector v1, double alpha, Vector v2, Vector v)\n" @@ -9549,6 +9739,10 @@ static PyMethodDef SwigMethods[] = { { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "Vector_SetDataAndSize(Vector self, double * d, int s)"}, { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "Vector_NewDataAndSize(Vector self, double * d, int s)"}, { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "Vector_NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" + "Vector_MakeRef(Vector self, Vector base, int offset, int size)\n" + "Vector_MakeRef(Vector self, Vector base, int offset)\n" + ""}, { "Vector_MakeDataOwner", _wrap_Vector_MakeDataOwner, METH_O, "Vector_MakeDataOwner(Vector self)"}, { "Vector_Destroy", _wrap_Vector_Destroy, METH_O, "Vector_Destroy(Vector self)"}, { "Vector_Size", _wrap_Vector_Size, METH_O, "Vector_Size(Vector self) -> int"}, @@ -9657,6 +9851,146 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "add_vector", _wrap_add_vector, METH_VARARGS, "\n" + "add_vector(Vector v1, Vector v2, Vector v)\n" + "add_vector(Vector v1, double alpha, Vector v2, Vector v)\n" + "add_vector(double const a, Vector x, Vector y, Vector z)\n" + "add_vector(double const a, Vector x, double const b, Vector y, Vector z)\n" + ""}, + { "subtract_vector", _wrap_subtract_vector, METH_VARARGS, "\n" + "subtract_vector(Vector v1, Vector v2, Vector v)\n" + "subtract_vector(double const a, Vector x, Vector y, Vector z)\n" + ""}, + { "CheckFinite", _wrap_CheckFinite, METH_VARARGS, "CheckFinite(double const * v, int const n) -> int"}, + { "infinity", _wrap_infinity, METH_NOARGS, "infinity() -> double"}, + { "Vector_UseDevice", _wrap_Vector_UseDevice, METH_VARARGS, "\n" + "UseDevice(Vector self, bool use_dev)\n" + "UseDevice(Vector self) -> bool\n" + ""}, + { "Vector_Load", _wrap_Vector_Load, METH_VARARGS, "\n" + "Load(Vector self, std::istream ** _in, int np, int * dim)\n" + "Load(Vector self, std::istream & _in, int Size)\n" + "Load(Vector self, std::istream & _in)\n" + ""}, + { "Vector_SetSize", _wrap_Vector_SetSize, METH_VARARGS, "\n" + "SetSize(Vector self, int s)\n" + "SetSize(Vector self, int s, mfem::MemoryType mt)\n" + "SetSize(Vector self, int s, Vector v)\n" + ""}, + { "Vector_SetData", _wrap_Vector_SetData, METH_VARARGS, "SetData(Vector self, double * d)"}, + { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "SetDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "NewDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" + "MakeRef(Vector self, Vector base, int offset, int size)\n" + "MakeRef(Vector self, Vector base, int offset)\n" + ""}, + { "Vector_MakeDataOwner", _wrap_Vector_MakeDataOwner, METH_O, "MakeDataOwner(Vector self)"}, + { "Vector_Destroy", _wrap_Vector_Destroy, METH_O, "Destroy(Vector self)"}, + { "Vector_Size", _wrap_Vector_Size, METH_O, "Size(Vector self) -> int"}, + { "Vector_Capacity", _wrap_Vector_Capacity, METH_O, "Capacity(Vector self) -> int"}, + { "Vector_GetData", _wrap_Vector_GetData, METH_O, "GetData(Vector self) -> double *"}, + { "Vector_GetMemory", _wrap_Vector_GetMemory, METH_VARARGS, "\n" + "GetMemory(Vector self) -> mfem::Memory< double >\n" + "GetMemory(Vector self) -> mfem::Memory< double > const &\n" + ""}, + { "Vector_SyncMemory", _wrap_Vector_SyncMemory, METH_VARARGS, "SyncMemory(Vector self, Vector v)"}, + { "Vector_SyncAliasMemory", _wrap_Vector_SyncAliasMemory, METH_VARARGS, "SyncAliasMemory(Vector self, Vector v)"}, + { "Vector_OwnsData", _wrap_Vector_OwnsData, METH_O, "OwnsData(Vector self) -> bool"}, + { "Vector_StealData", _wrap_Vector_StealData, METH_VARARGS, "\n" + "StealData(Vector self, double ** p)\n" + "StealData(Vector self) -> double *\n" + ""}, + { "Vector_Elem", _wrap_Vector_Elem, METH_VARARGS, "\n" + "Elem(Vector self, int i) -> double\n" + "Elem(Vector self, int i) -> double const &\n" + ""}, + { "Vector___call__", _wrap_Vector___call__, METH_VARARGS, "\n" + "__call__(Vector self, int i) -> double\n" + "__call__(Vector self, int i) -> double const &\n" + ""}, + { "Vector___mul__", _wrap_Vector___mul__, METH_VARARGS, "\n" + "__mul__(Vector self, double const * arg2) -> double\n" + "__mul__(Vector self, Vector v) -> double\n" + ""}, + { "Vector___imul__", _wrap_Vector___imul__, METH_VARARGS, "__imul__(Vector self, double c) -> Vector"}, + { "Vector___itruediv__", _wrap_Vector___itruediv__, METH_VARARGS, "__itruediv__(Vector self, double c) -> Vector"}, + { "Vector___isub__", _wrap_Vector___isub__, METH_VARARGS, "\n" + "__isub__(Vector self, double c) -> Vector\n" + "__isub__(Vector self, Vector v) -> Vector\n" + ""}, + { "Vector___iadd__", _wrap_Vector___iadd__, METH_VARARGS, "__iadd__(Vector self, Vector v) -> Vector"}, + { "Vector_Add", _wrap_Vector_Add, METH_VARARGS, "Add(Vector self, double const a, Vector Va) -> Vector"}, + { "Vector_Set", _wrap_Vector_Set, METH_VARARGS, "Set(Vector self, double const a, Vector x) -> Vector"}, + { "Vector_SetVector", _wrap_Vector_SetVector, METH_VARARGS, "SetVector(Vector self, Vector v, int offset)"}, + { "Vector_Neg", _wrap_Vector_Neg, METH_O, "Neg(Vector self)"}, + { "Vector_Swap", _wrap_Vector_Swap, METH_VARARGS, "Swap(Vector self, Vector other)"}, + { "Vector_median", _wrap_Vector_median, METH_VARARGS, "median(Vector self, Vector lo, Vector hi)"}, + { "Vector_GetSubVector", _wrap_Vector_GetSubVector, METH_VARARGS, "\n" + "GetSubVector(Vector self, intArray dofs, Vector elemvect)\n" + "GetSubVector(Vector self, intArray dofs, double * elem_data)\n" + ""}, + { "Vector_SetSubVector", _wrap_Vector_SetSubVector, METH_VARARGS, "\n" + "SetSubVector(Vector self, intArray dofs, double const value)\n" + "SetSubVector(Vector self, intArray dofs, Vector elemvect)\n" + "SetSubVector(Vector self, intArray dofs, double * elem_data)\n" + ""}, + { "Vector_AddElementVector", _wrap_Vector_AddElementVector, METH_VARARGS, "\n" + "AddElementVector(Vector self, intArray dofs, Vector elemvect)\n" + "AddElementVector(Vector self, intArray dofs, double * elem_data)\n" + "AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect)\n" + ""}, + { "Vector_SetSubVectorComplement", _wrap_Vector_SetSubVectorComplement, METH_VARARGS, "SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, + { "Vector_Randomize", _wrap_Vector_Randomize, METH_VARARGS, "Randomize(Vector self, int seed=0)"}, + { "Vector_Norml2", _wrap_Vector_Norml2, METH_O, "Norml2(Vector self) -> double"}, + { "Vector_Normlinf", _wrap_Vector_Normlinf, METH_O, "Normlinf(Vector self) -> double"}, + { "Vector_Norml1", _wrap_Vector_Norml1, METH_O, "Norml1(Vector self) -> double"}, + { "Vector_Normlp", _wrap_Vector_Normlp, METH_VARARGS, "Normlp(Vector self, double p) -> double"}, + { "Vector_Max", _wrap_Vector_Max, METH_O, "Max(Vector self) -> double"}, + { "Vector_Min", _wrap_Vector_Min, METH_O, "Min(Vector self) -> double"}, + { "Vector_Sum", _wrap_Vector_Sum, METH_O, "Sum(Vector self) -> double"}, + { "Vector_DistanceSquaredTo", _wrap_Vector_DistanceSquaredTo, METH_VARARGS, "DistanceSquaredTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceTo", _wrap_Vector_DistanceTo, METH_VARARGS, "DistanceTo(Vector self, double const * p) -> double"}, + { "Vector_CheckFinite", _wrap_Vector_CheckFinite, METH_O, "CheckFinite(Vector self) -> int"}, + { "delete_Vector", _wrap_delete_Vector, METH_O, "delete_Vector(Vector self)"}, + { "Vector_Read", _wrap_Vector_Read, METH_VARARGS, "Read(Vector self, bool on_dev=True) -> double const"}, + { "Vector_HostRead", _wrap_Vector_HostRead, METH_O, "HostRead(Vector self) -> double const *"}, + { "Vector_Write", _wrap_Vector_Write, METH_VARARGS, "Write(Vector self, bool on_dev=True) -> double"}, + { "Vector_HostWrite", _wrap_Vector_HostWrite, METH_O, "HostWrite(Vector self) -> double *"}, + { "Vector_ReadWrite", _wrap_Vector_ReadWrite, METH_VARARGS, "ReadWrite(Vector self, bool on_dev=True) -> double"}, + { "Vector_HostReadWrite", _wrap_Vector_HostReadWrite, METH_O, "HostReadWrite(Vector self) -> double *"}, + { "new_Vector", _wrap_new_Vector, METH_VARARGS, "\n" + "Vector()\n" + "Vector(Vector arg1)\n" + "Vector(int s)\n" + "Vector(double * _data, int _size)\n" + "Vector(int size_, mfem::MemoryType mt)\n" + "new_Vector(Vector v, int offset, int size) -> Vector\n" + ""}, + { "Vector_Assign", _wrap_Vector_Assign, METH_VARARGS, "\n" + "Assign(Vector self, double const v)\n" + "Assign(Vector self, Vector v)\n" + "Assign(Vector self, PyObject * param)\n" + ""}, + { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, "__setitem__(Vector self, int i, double const v)"}, + { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, "__getitem__(Vector self, PyObject * param) -> PyObject *"}, + { "Vector_GetDataArray", _wrap_Vector_GetDataArray, METH_O, "GetDataArray(Vector self) -> PyObject *"}, + { "Vector_Print", _wrap_Vector_Print, METH_VARARGS, "\n" + "Print(Vector self, std::ostream & out=mfem::out, int width=8)\n" + "Print(Vector self, char const * file, int precision=8)\n" + ""}, + { "Vector_Print_HYPRE", _wrap_Vector_Print_HYPRE, METH_VARARGS, "\n" + "Print_HYPRE(Vector self, std::ostream & out)\n" + "Print_HYPRE(Vector self, char const * file, int precision=8)\n" + "Print_HYPRE(Vector self)\n" + ""}, + { "Vector_swigregister", Vector_swigregister, METH_O, NULL}, + { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL}, + { "IsFinite", _wrap_IsFinite, METH_O, "IsFinite(double const & val) -> bool"}, + { "DistanceSquared", _wrap_DistanceSquared, METH_VARARGS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, + { "Distance", _wrap_Distance, METH_VARARGS, "Distance(double const * x, double const * y, int const n) -> double"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/vertex.py b/mfem/_ser/vertex.py index 3f368d30..04843b07 100644 --- a/mfem/_ser/vertex.py +++ b/mfem/_ser/vertex.py @@ -19,6 +19,9 @@ except ImportError: import __builtin__ +_swig_new_instance_method = _vertex.SWIG_PyInstanceMethod_New +_swig_new_static_method = _vertex.SWIG_PyStaticMethod_New + def _swig_repr(self): try: strthis = "proxy of " + self.this.__repr__() @@ -96,6 +99,7 @@ def __call__(self, *args): __call__(Vertex self, int i) -> double const & """ return _vertex.Vertex___call__(self, *args) + __call__ = _swig_new_instance_method(_vertex.Vertex___call__) def SetCoords(self, *args): r""" @@ -103,6 +107,7 @@ def SetCoords(self, *args): SetCoords(Vertex self, int dim, double const * p) """ return _vertex.Vertex_SetCoords(self, *args) + SetCoords = _swig_new_instance_method(_vertex.Vertex_SetCoords) __swig_destroy__ = _vertex.delete_Vertex # Register Vertex in _vertex: diff --git a/mfem/_ser/vertex_wrap.cxx b/mfem/_ser/vertex_wrap.cxx index f2c1a4c6..12ff914d 100644 --- a/mfem/_ser/vertex_wrap.cxx +++ b/mfem/_ser/vertex_wrap.cxx @@ -3902,6 +3902,7 @@ SWIGINTERN PyObject *Vertex_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Vertex", _wrap_new_Vertex, METH_VARARGS, "\n" "Vertex()\n" "Vertex(double * xx, int dim)\n" @@ -3924,6 +3925,26 @@ static PyMethodDef SwigMethods[] = { }; static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "new_Vertex", _wrap_new_Vertex, METH_VARARGS, "\n" + "Vertex()\n" + "Vertex(double * xx, int dim)\n" + "Vertex(double x, double y)\n" + "new_Vertex(double x, double y, double z) -> Vertex\n" + ""}, + { "Vertex___call__", _wrap_Vertex___call__, METH_VARARGS, "\n" + "__call__(Vertex self) -> double\n" + "__call__(Vertex self, int i) -> double\n" + "__call__(Vertex self, int i) -> double const &\n" + ""}, + { "Vertex_SetCoords", _wrap_Vertex_SetCoords, METH_VARARGS, "\n" + "SetCoords(Vertex self, double const * p)\n" + "SetCoords(Vertex self, int dim, double const * p)\n" + ""}, + { "delete_Vertex", _wrap_delete_Vertex, METH_O, "delete_Vertex(Vertex self)"}, + { "Vertex_swigregister", Vertex_swigregister, METH_O, NULL}, + { "Vertex_swiginit", Vertex_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/vtk.i b/mfem/_ser/vtk.i new file mode 100644 index 00000000..ee6e79d6 --- /dev/null +++ b/mfem/_ser/vtk.i @@ -0,0 +1,21 @@ +%module(package="mfem._ser") vtk +%{ +#include "mfem.hpp" +#include "mesh/vtk.hpp" +#include "numpy/arrayobject.h" +#include "io_stream.hpp" +%} + +%init %{ +import_array(); +%} +%include "exception.i" +%import "element.i" +%include "../common/exception.i" + +%import "../common/numpy_int_typemap.i" +%import "../common/io_stream_typemap.i" +OSTREAM_TYPEMAP(std::ostream&) + +%include "mesh/vtk.hpp" + diff --git a/mfem/_ser/vtk.py b/mfem/_ser/vtk.py new file mode 100644 index 00000000..b3b6a9bb --- /dev/null +++ b/mfem/_ser/vtk.py @@ -0,0 +1,102 @@ +# This file was automatically generated by SWIG (http://www.swig.org). +# Version 4.0.1 +# +# Do not make changes to this file unless you know what you are doing--modify +# the SWIG interface file instead. + +from sys import version_info as _swig_python_version_info +if _swig_python_version_info < (2, 7, 0): + raise RuntimeError("Python 2.7 or later required") + +# Import the low-level C/C++ module +if __package__ or "." in __name__: + from . import _vtk +else: + import _vtk + +try: + import builtins as __builtin__ +except ImportError: + import __builtin__ + +_swig_new_instance_method = _vtk.SWIG_PyInstanceMethod_New +_swig_new_static_method = _vtk.SWIG_PyStaticMethod_New + +def _swig_repr(self): + try: + strthis = "proxy of " + self.this.__repr__() + except __builtin__.Exception: + strthis = "" + return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) + + +def _swig_setattr_nondynamic_instance_variable(set): + def set_instance_attr(self, name, value): + if name == "thisown": + self.this.own(value) + elif name == "this": + set(self, name, value) + elif hasattr(self, name) and isinstance(getattr(type(self), name), property): + set(self, name, value) + else: + raise AttributeError("You cannot add instance attributes to %s" % self) + return set_instance_attr + + +def _swig_setattr_nondynamic_class_variable(set): + def set_class_attr(cls, name, value): + if hasattr(cls, name) and not isinstance(getattr(cls, name), property): + set(cls, name, value) + else: + raise AttributeError("You cannot add class attributes to %s" % cls) + return set_class_attr + + +def _swig_add_metaclass(metaclass): + """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" + def wrapper(cls): + return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) + return wrapper + + +class _SwigNonDynamicMeta(type): + """Meta class to enforce nondynamic attributes (no new attributes) for a class""" + __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) + + +import weakref + +import mfem._ser.element +import mfem._ser.array +import mfem._ser.mem_manager +import mfem._ser.densemat +import mfem._ser.vector +import mfem._ser.operators +import mfem._ser.matrix +import mfem._ser.geom +import mfem._ser.intrules +import mfem._ser.table +import mfem._ser.hash +VTKFormat_ASCII = _vtk.VTKFormat_ASCII + +VTKFormat_BINARY = _vtk.VTKFormat_BINARY + +VTKFormat_BINARY32 = _vtk.VTKFormat_BINARY32 + + +def CreateVTKElementConnectivity(con, geom, ref): + r"""CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)""" + return _vtk.CreateVTKElementConnectivity(con, geom, ref) +CreateVTKElementConnectivity = _vtk.CreateVTKElementConnectivity + +def WriteVTKEncodedCompressed(out, bytes, nbytes, compression_level): + r"""WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)""" + return _vtk.WriteVTKEncodedCompressed(out, bytes, nbytes, compression_level) +WriteVTKEncodedCompressed = _vtk.WriteVTKEncodedCompressed + +def VTKByteOrder(): + r"""VTKByteOrder() -> char const *""" + return _vtk.VTKByteOrder() +VTKByteOrder = _vtk.VTKByteOrder + + diff --git a/mfem/_ser/vtk_wrap.cxx b/mfem/_ser/vtk_wrap.cxx new file mode 100644 index 00000000..73528c3a --- /dev/null +++ b/mfem/_ser/vtk_wrap.cxx @@ -0,0 +1,4356 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGPYTHON +#define SWIGPYTHON +#endif + +#define SWIG_DIRECTORS +#define SWIG_PYTHON_DIRECTOR_NO_VTABLE + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + + +#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND) +/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */ +# include +#endif + +#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG) +/* Use debug wrappers with the Python release dll */ +# undef _DEBUG +# include +# define _DEBUG 1 +#else +# include +#endif + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = (unsigned char)((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = (unsigned char)((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (unsigned char)(d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (unsigned char)(d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* Compatibility macros for Python 3 */ +#if PY_VERSION_HEX >= 0x03000000 + +#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type) +#define PyInt_Check(x) PyLong_Check(x) +#define PyInt_AsLong(x) PyLong_AsLong(x) +#define PyInt_FromLong(x) PyLong_FromLong(x) +#define PyInt_FromSize_t(x) PyLong_FromSize_t(x) +#define PyString_Check(name) PyBytes_Check(name) +#define PyString_FromString(x) PyUnicode_FromString(x) +#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args) +#define PyString_AsString(str) PyBytes_AsString(str) +#define PyString_Size(str) PyBytes_Size(str) +#define PyString_InternFromString(key) PyUnicode_InternFromString(key) +#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE +#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x) +#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x) + +#endif + +#ifndef Py_TYPE +# define Py_TYPE(op) ((op)->ob_type) +#endif + +/* SWIG APIs for compatibility of both Python 2 & 3 */ + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_FromFormat PyUnicode_FromFormat +#else +# define SWIG_Python_str_FromFormat PyString_FromFormat +#endif + + +/* Warning: This function will allocate a new string in Python 3, + * so please call SWIG_Python_str_DelForPy3(x) to free the space. + */ +SWIGINTERN char* +SWIG_Python_str_AsChar(PyObject *str) +{ +#if PY_VERSION_HEX >= 0x03000000 + char *newstr = 0; + str = PyUnicode_AsUTF8String(str); + if (str) { + char *cstr; + Py_ssize_t len; + PyBytes_AsStringAndSize(str, &cstr, &len); + newstr = (char *) malloc(len+1); + memcpy(newstr, cstr, len+1); + Py_XDECREF(str); + } + return newstr; +#else + return PyString_AsString(str); +#endif +} + +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) ) +#else +# define SWIG_Python_str_DelForPy3(x) +#endif + + +SWIGINTERN PyObject* +SWIG_Python_str_FromChar(const char *c) +{ +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_FromString(c); +#else + return PyString_FromString(c); +#endif +} + +#ifndef PyObject_DEL +# define PyObject_DEL PyObject_Del +#endif + +// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user +// interface files check for it. +# define SWIGPY_USE_CAPSULE +# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME) + +#if PY_VERSION_HEX < 0x03020000 +#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type) +#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name) +#define Py_hash_t long +#endif + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGRUNTIME PyObject* +SWIG_Python_ErrorType(int code) { + PyObject* type = 0; + switch(code) { + case SWIG_MemoryError: + type = PyExc_MemoryError; + break; + case SWIG_IOError: + type = PyExc_IOError; + break; + case SWIG_RuntimeError: + type = PyExc_RuntimeError; + break; + case SWIG_IndexError: + type = PyExc_IndexError; + break; + case SWIG_TypeError: + type = PyExc_TypeError; + break; + case SWIG_DivisionByZero: + type = PyExc_ZeroDivisionError; + break; + case SWIG_OverflowError: + type = PyExc_OverflowError; + break; + case SWIG_SyntaxError: + type = PyExc_SyntaxError; + break; + case SWIG_ValueError: + type = PyExc_ValueError; + break; + case SWIG_SystemError: + type = PyExc_SystemError; + break; + case SWIG_AttributeError: + type = PyExc_AttributeError; + break; + default: + type = PyExc_RuntimeError; + } + return type; +} + + +SWIGRUNTIME void +SWIG_Python_AddErrorMsg(const char* mesg) +{ + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + + if (PyErr_Occurred()) + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + PyErr_Clear(); + Py_XINCREF(type); + if (tmp) + PyErr_Format(type, "%s %s", tmp, mesg); + else + PyErr_Format(type, "%s", mesg); + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + Py_DECREF(value); + } else { + PyErr_SetString(PyExc_RuntimeError, mesg); + } +} + +SWIGRUNTIME int +SWIG_Python_TypeErrorOccurred(PyObject *obj) +{ + PyObject *error; + if (obj) + return 0; + error = PyErr_Occurred(); + return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError); +} + +SWIGRUNTIME void +SWIG_Python_RaiseOrModifyTypeError(const char *message) +{ + if (SWIG_Python_TypeErrorOccurred(NULL)) { + /* Use existing TypeError to preserve stacktrace and enhance with given message */ + PyObject *newvalue; + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); +#if PY_VERSION_HEX >= 0x03000000 + newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message); +#else + newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); +#endif + Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + /* Raise TypeError using given message */ + PyErr_SetString(PyExc_TypeError, message); + } +} + +#if defined(SWIG_PYTHON_NO_THREADS) +# if defined(SWIG_PYTHON_THREADS) +# undef SWIG_PYTHON_THREADS +# endif +#endif +#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */ +# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL) +# define SWIG_PYTHON_USE_GIL +# endif +# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */ +# ifndef SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads() +# endif +# ifdef __cplusplus /* C++ code */ + class SWIG_Python_Thread_Block { + bool status; + PyGILState_STATE state; + public: + void end() { if (status) { PyGILState_Release(state); status = false;} } + SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {} + ~SWIG_Python_Thread_Block() { end(); } + }; + class SWIG_Python_Thread_Allow { + bool status; + PyThreadState *save; + public: + void end() { if (status) { PyEval_RestoreThread(save); status = false; }} + SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {} + ~SWIG_Python_Thread_Allow() { end(); } + }; +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block +# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end() +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow +# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end() +# else /* C code */ +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure() +# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread() +# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow) +# endif +# else /* Old thread way, not implemented, user must provide it */ +# if !defined(SWIG_PYTHON_INITIALIZE_THREADS) +# define SWIG_PYTHON_INITIALIZE_THREADS +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK) +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_END_BLOCK) +# define SWIG_PYTHON_THREAD_END_BLOCK +# endif +# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW) +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# endif +# if !defined(SWIG_PYTHON_THREAD_END_ALLOW) +# define SWIG_PYTHON_THREAD_END_ALLOW +# endif +# endif +#else /* No thread support */ +# define SWIG_PYTHON_INITIALIZE_THREADS +# define SWIG_PYTHON_THREAD_BEGIN_BLOCK +# define SWIG_PYTHON_THREAD_END_BLOCK +# define SWIG_PYTHON_THREAD_BEGIN_ALLOW +# define SWIG_PYTHON_THREAD_END_ALLOW +#endif + +/* ----------------------------------------------------------------------------- + * Python API portion that goes into the runtime + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_PY_POINTER 4 +#define SWIG_PY_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + const char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +#ifdef __cplusplus +} +#endif + + +/* ----------------------------------------------------------------------------- + * pyrun.swg + * + * This file contains the runtime support for Python modules + * and includes code for managing global variables and pointer + * type checking. + * + * ----------------------------------------------------------------------------- */ + +#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */ +# error "This version of SWIG only supports Python >= 2.7" +#endif + +#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000 +# error "This version of SWIG only supports Python 3 >= 3.2" +#endif + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0) +#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags) +#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own) + +#ifdef SWIGPYTHON_BUILTIN +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags) +#else +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) +#endif + +#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags) + +#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty) +#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src) +#define swig_owntype int + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags) +#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata) +#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer) +#define SWIG_NewClientData(obj) SwigPyClientData_New(obj) + +#define SWIG_SetErrorObj SWIG_Python_SetErrorObj +#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg +#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Runtime API implementation */ + +/* Error manipulation */ + +SWIGINTERN void +SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetObject(errtype, obj); + Py_DECREF(obj); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +SWIGINTERN void +SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + PyErr_SetString(errtype, msg); + SWIG_PYTHON_THREAD_END_BLOCK; +} + +#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj) + +/* Set a constant value */ + +#if defined(SWIGPYTHON_BUILTIN) + +SWIGINTERN void +SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) { + PyObject *s = PyString_InternFromString(key); + PyList_Append(seq, s); + Py_DECREF(s); +} + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); + if (public_interface) + SwigPyBuiltin_AddPublicSymbol(public_interface, name); +} + +#else + +SWIGINTERN void +SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) { + PyDict_SetItemString(d, name, obj); + Py_DECREF(obj); +} + +#endif + +/* Append a value to the result obj */ + +SWIGINTERN PyObject* +SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { + if (!result) { + result = obj; + } else if (result == Py_None) { + Py_DECREF(result); + result = obj; + } else { + if (!PyList_Check(result)) { + PyObject *o2 = result; + result = PyList_New(1); + PyList_SetItem(result, 0, o2); + } + PyList_Append(result,obj); + Py_DECREF(obj); + } + return result; +} + +/* Unpack the argument tuple */ + +SWIGINTERN Py_ssize_t +SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs) +{ + if (!args) { + if (!min && !max) { + return 1; + } else { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", + name, (min == max ? "" : "at least "), (int)min); + return 0; + } + } + if (!PyTuple_Check(args)) { + if (min <= 1 && max >= 1) { + Py_ssize_t i; + objs[0] = args; + for (i = 1; i < max; ++i) { + objs[i] = 0; + } + return 2; + } + PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple"); + return 0; + } else { + Py_ssize_t l = PyTuple_GET_SIZE(args); + if (l < min) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at least "), (int)min, (int)l); + return 0; + } else if (l > max) { + PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", + name, (min == max ? "" : "at most "), (int)max, (int)l); + return 0; + } else { + Py_ssize_t i; + for (i = 0; i < l; ++i) { + objs[i] = PyTuple_GET_ITEM(args, i); + } + for (; l < max; ++l) { + objs[l] = 0; + } + return i + 1; + } + } +} + +/* A functor is a function object with one single object argument */ +#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL); + +/* + Helper for static pointer initialization for both C and C++ code, for example + static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...); +*/ +#ifdef __cplusplus +#define SWIG_STATIC_POINTER(var) var +#else +#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var +#endif + +/* ----------------------------------------------------------------------------- + * Pointer declarations + * ----------------------------------------------------------------------------- */ + +/* Flags for new pointer objects */ +#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1) +#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN) + +#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1) + +#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2) +#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN) + +#ifdef __cplusplus +extern "C" { +#endif + +/* The python void return value */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Py_Void(void) +{ + PyObject *none = Py_None; + Py_INCREF(none); + return none; +} + +/* SwigPyClientData */ + +typedef struct { + PyObject *klass; + PyObject *newraw; + PyObject *newargs; + PyObject *destroy; + int delargs; + int implicitconv; + PyTypeObject *pytype; +} SwigPyClientData; + +SWIGRUNTIMEINLINE int +SWIG_Python_CheckImplicit(swig_type_info *ty) +{ + SwigPyClientData *data = (SwigPyClientData *)ty->clientdata; + int fail = data ? data->implicitconv : 0; + if (fail) + PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors."); + return fail; +} + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_ExceptionType(swig_type_info *desc) { + SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0; + PyObject *klass = data ? data->klass : 0; + return (klass ? klass : PyExc_RuntimeError); +} + + +SWIGRUNTIME SwigPyClientData * +SwigPyClientData_New(PyObject* obj) +{ + if (!obj) { + return 0; + } else { + SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData)); + /* the klass element */ + data->klass = obj; + Py_INCREF(data->klass); + /* the newraw method and newargs arguments used to create a new raw instance */ + if (PyClass_Check(obj)) { + data->newraw = 0; + data->newargs = obj; + Py_INCREF(obj); + } else { + data->newraw = PyObject_GetAttrString(data->klass, "__new__"); + if (data->newraw) { + Py_INCREF(data->newraw); + data->newargs = PyTuple_New(1); + PyTuple_SetItem(data->newargs, 0, obj); + } else { + data->newargs = obj; + } + Py_INCREF(data->newargs); + } + /* the destroy method, aka as the C++ delete method */ + data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); + if (PyErr_Occurred()) { + PyErr_Clear(); + data->destroy = 0; + } + if (data->destroy) { + int flags; + Py_INCREF(data->destroy); + flags = PyCFunction_GET_FLAGS(data->destroy); + data->delargs = !(flags & (METH_O)); + } else { + data->delargs = 0; + } + data->implicitconv = 0; + data->pytype = 0; + return data; + } +} + +SWIGRUNTIME void +SwigPyClientData_Del(SwigPyClientData *data) { + Py_XDECREF(data->newraw); + Py_XDECREF(data->newargs); + Py_XDECREF(data->destroy); +} + +/* =============== SwigPyObject =====================*/ + +typedef struct { + PyObject_HEAD + void *ptr; + swig_type_info *ty; + int own; + PyObject *next; +#ifdef SWIGPYTHON_BUILTIN + PyObject *dict; +#endif +} SwigPyObject; + + +#ifdef SWIGPYTHON_BUILTIN + +SWIGRUNTIME PyObject * +SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + + if (!sobj->dict) + sobj->dict = PyDict_New(); + + Py_INCREF(sobj->dict); + return sobj->dict; +} + +#endif + +SWIGRUNTIME PyObject * +SwigPyObject_long(SwigPyObject *v) +{ + return PyLong_FromVoidPtr(v->ptr); +} + +SWIGRUNTIME PyObject * +SwigPyObject_format(const char* fmt, SwigPyObject *v) +{ + PyObject *res = NULL; + PyObject *args = PyTuple_New(1); + if (args) { + if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { + PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + if (ofmt) { +#if PY_VERSION_HEX >= 0x03000000 + res = PyUnicode_Format(ofmt,args); +#else + res = PyString_Format(ofmt,args); +#endif + Py_DECREF(ofmt); + } + Py_DECREF(args); + } + } + return res; +} + +SWIGRUNTIME PyObject * +SwigPyObject_oct(SwigPyObject *v) +{ + return SwigPyObject_format("%o",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_hex(SwigPyObject *v) +{ + return SwigPyObject_format("%x",v); +} + +SWIGRUNTIME PyObject * +SwigPyObject_repr(SwigPyObject *v) +{ + const char *name = SWIG_TypePrettyName(v->ty); + PyObject *repr = SWIG_Python_str_FromFormat("", (name ? name : "unknown"), (void *)v); + if (v->next) { + PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); +# if PY_VERSION_HEX >= 0x03000000 + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; +# else + PyString_ConcatAndDel(&repr,nrep); +# endif + } + return repr; +} + +/* We need a version taking two PyObject* parameters so it's a valid + * PyCFunction to use in swigobject_methods[]. */ +SWIGRUNTIME PyObject * +SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) +{ + return SwigPyObject_repr((SwigPyObject*)v); +} + +SWIGRUNTIME int +SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w) +{ + void *i = v->ptr; + void *j = w->ptr; + return (i < j) ? -1 : ((i > j) ? 1 : 0); +} + +/* Added for Python 3.x, would it also be useful for Python 2.x? */ +SWIGRUNTIME PyObject* +SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op) +{ + PyObject* res; + if( op != Py_EQ && op != Py_NE ) { + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; + } + res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0); + return res; +} + + +SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void); + +#ifdef SWIGPYTHON_BUILTIN +static swig_type_info *SwigPyObject_stype = 0; +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + SwigPyClientData *cd; + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + assert(cd); + assert(cd->pytype); + return cd->pytype; +} +#else +SWIGRUNTIME PyTypeObject* +SwigPyObject_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce(); + return type; +} +#endif + +SWIGRUNTIMEINLINE int +SwigPyObject_Check(PyObject *op) { +#ifdef SWIGPYTHON_BUILTIN + PyTypeObject *target_tp = SwigPyObject_type(); + if (PyType_IsSubtype(op->ob_type, target_tp)) + return 1; + return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0); +#else + return (Py_TYPE(op) == SwigPyObject_type()) + || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0); +#endif +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own); + +SWIGRUNTIME void +SwigPyObject_dealloc(PyObject *v) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + PyObject *next = sobj->next; + if (sobj->own == SWIG_POINTER_OWN) { + swig_type_info *ty = sobj->ty; + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + PyObject *destroy = data ? data->destroy : 0; + if (destroy) { + /* destroy is always a VARARGS method */ + PyObject *res; + + /* PyObject_CallFunction() has the potential to silently drop + the active exception. In cases of unnamed temporary + variable or where we just finished iterating over a generator + StopIteration will be active right now, and this needs to + remain true upon return from SwigPyObject_dealloc. So save + and restore. */ + + PyObject *type = NULL, *value = NULL, *traceback = NULL; + PyErr_Fetch(&type, &value, &traceback); + + if (data->delargs) { + /* we need to create a temporary object to carry the destroy operation */ + PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); + res = SWIG_Python_CallFunctor(destroy, tmp); + Py_DECREF(tmp); + } else { + PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); + PyObject *mself = PyCFunction_GET_SELF(destroy); + res = ((*meth)(mself, v)); + } + if (!res) + PyErr_WriteUnraisable(destroy); + + PyErr_Restore(type, value, traceback); + + Py_XDECREF(res); + } +#if !defined(SWIG_PYTHON_SILENT_MEMLEAK) + else { + const char *name = SWIG_TypePrettyName(ty); + printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown")); + } +#endif + } + Py_XDECREF(next); + PyObject_DEL(v); +} + +SWIGRUNTIME PyObject* +SwigPyObject_append(PyObject* v, PyObject* next) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (!SwigPyObject_Check(next)) { + PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject"); + return NULL; + } + sobj->next = next; + Py_INCREF(next); + return SWIG_Py_Void(); +} + +SWIGRUNTIME PyObject* +SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *) v; + if (sobj->next) { + Py_INCREF(sobj->next); + return sobj->next; + } else { + return SWIG_Py_Void(); + } +} + +SWIGINTERN PyObject* +SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = 0; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args)) +{ + SwigPyObject *sobj = (SwigPyObject *)v; + sobj->own = SWIG_POINTER_OWN; + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject* +SwigPyObject_own(PyObject *v, PyObject *args) +{ + PyObject *val = 0; + if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) { + return NULL; + } else { + SwigPyObject *sobj = (SwigPyObject *)v; + PyObject *obj = PyBool_FromLong(sobj->own); + if (val) { + if (PyObject_IsTrue(val)) { + SwigPyObject_acquire(v,args); + } else { + SwigPyObject_disown(v,args); + } + } + return obj; + } +} + +static PyMethodDef +swigobject_methods[] = { + {"disown", SwigPyObject_disown, METH_NOARGS, "releases ownership of the pointer"}, + {"acquire", SwigPyObject_acquire, METH_NOARGS, "acquires ownership of the pointer"}, + {"own", SwigPyObject_own, METH_VARARGS, "returns/sets ownership of the pointer"}, + {"append", SwigPyObject_append, METH_O, "appends another 'this' object"}, + {"next", SwigPyObject_next, METH_NOARGS, "returns the next 'this' object"}, + {"__repr__",SwigPyObject_repr2, METH_NOARGS, "returns object representation"}, + {0, 0, 0, 0} +}; + +SWIGRUNTIME PyTypeObject* +SwigPyObject_TypeOnce(void) { + static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer"; + + static PyNumberMethods SwigPyObject_as_number = { + (binaryfunc)0, /*nb_add*/ + (binaryfunc)0, /*nb_subtract*/ + (binaryfunc)0, /*nb_multiply*/ + /* nb_divide removed in Python 3 */ +#if PY_VERSION_HEX < 0x03000000 + (binaryfunc)0, /*nb_divide*/ +#endif + (binaryfunc)0, /*nb_remainder*/ + (binaryfunc)0, /*nb_divmod*/ + (ternaryfunc)0,/*nb_power*/ + (unaryfunc)0, /*nb_negative*/ + (unaryfunc)0, /*nb_positive*/ + (unaryfunc)0, /*nb_absolute*/ + (inquiry)0, /*nb_nonzero*/ + 0, /*nb_invert*/ + 0, /*nb_lshift*/ + 0, /*nb_rshift*/ + 0, /*nb_and*/ + 0, /*nb_xor*/ + 0, /*nb_or*/ +#if PY_VERSION_HEX < 0x03000000 + 0, /*nb_coerce*/ +#endif + (unaryfunc)SwigPyObject_long, /*nb_int*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_long, /*nb_long*/ +#else + 0, /*nb_reserved*/ +#endif + (unaryfunc)0, /*nb_float*/ +#if PY_VERSION_HEX < 0x03000000 + (unaryfunc)SwigPyObject_oct, /*nb_oct*/ + (unaryfunc)SwigPyObject_hex, /*nb_hex*/ +#endif +#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */ +#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */ +#else + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */ +#endif + }; + + static PyTypeObject swigpyobject_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyObject", /* tp_name */ + sizeof(SwigPyObject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyObject_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX >= 0x03000000 + 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */ +#else + (cmpfunc)SwigPyObject_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyObject_repr, /* tp_repr */ + &SwigPyObject_as_number, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigobject_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + swigobject_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpyobject_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpyobject_type) < 0) + return NULL; + } + return &swigpyobject_type; +} + +SWIGRUNTIME PyObject * +SwigPyObject_New(void *ptr, swig_type_info *ty, int own) +{ + SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type()); + if (sobj) { + sobj->ptr = ptr; + sobj->ty = ty; + sobj->own = own; + sobj->next = 0; + } + return (PyObject *)sobj; +} + +/* ----------------------------------------------------------------------------- + * Implements a simple Swig Packed type, and use it instead of string + * ----------------------------------------------------------------------------- */ + +typedef struct { + PyObject_HEAD + void *pack; + swig_type_info *ty; + size_t size; +} SwigPyPacked; + +SWIGRUNTIME PyObject * +SwigPyPacked_repr(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) { + return SWIG_Python_str_FromFormat("", result, v->ty->name); + } else { + return SWIG_Python_str_FromFormat("", v->ty->name); + } +} + +SWIGRUNTIME PyObject * +SwigPyPacked_str(SwigPyPacked *v) +{ + char result[SWIG_BUFFER_SIZE]; + if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){ + return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name); + } else { + return SWIG_Python_str_FromChar(v->ty->name); + } +} + +SWIGRUNTIME int +SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w) +{ + size_t i = v->size; + size_t j = w->size; + int s = (i < j) ? -1 : ((i > j) ? 1 : 0); + return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size); +} + +SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void); + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_type(void) { + static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce(); + return type; +} + +SWIGRUNTIMEINLINE int +SwigPyPacked_Check(PyObject *op) { + return ((op)->ob_type == SwigPyPacked_TypeOnce()) + || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0); +} + +SWIGRUNTIME void +SwigPyPacked_dealloc(PyObject *v) +{ + if (SwigPyPacked_Check(v)) { + SwigPyPacked *sobj = (SwigPyPacked *) v; + free(sobj->pack); + } + PyObject_DEL(v); +} + +SWIGRUNTIME PyTypeObject* +SwigPyPacked_TypeOnce(void) { + static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer"; + static PyTypeObject swigpypacked_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX>=0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "SwigPyPacked", /* tp_name */ + sizeof(SwigPyPacked), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)SwigPyPacked_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)0, /* tp_getattr */ + (setattrfunc)0, /* tp_setattr */ +#if PY_VERSION_HEX>=0x03000000 + 0, /* tp_reserved in 3.0.1 */ +#else + (cmpfunc)SwigPyPacked_compare, /* tp_compare */ +#endif + (reprfunc)SwigPyPacked_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + (hashfunc)0, /* tp_hash */ + (ternaryfunc)0, /* tp_call */ + (reprfunc)SwigPyPacked_str, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + swigpacked_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ + 0, /* tp_free */ + 0, /* tp_is_gc */ + 0, /* tp_bases */ + 0, /* tp_mro */ + 0, /* tp_cache */ + 0, /* tp_subclasses */ + 0, /* tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + swigpypacked_type = tmp; + type_init = 1; + if (PyType_Ready(&swigpypacked_type) < 0) + return NULL; + } + return &swigpypacked_type; +} + +SWIGRUNTIME PyObject * +SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty) +{ + SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type()); + if (sobj) { + void *pack = malloc(size); + if (pack) { + memcpy(pack, ptr, size); + sobj->pack = pack; + sobj->ty = ty; + sobj->size = size; + } else { + PyObject_DEL((PyObject *) sobj); + sobj = 0; + } + } + return (PyObject *) sobj; +} + +SWIGRUNTIME swig_type_info * +SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size) +{ + if (SwigPyPacked_Check(obj)) { + SwigPyPacked *sobj = (SwigPyPacked *)obj; + if (sobj->size != size) return 0; + memcpy(ptr, sobj->pack, size); + return sobj->ty; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +static PyObject *Swig_This_global = NULL; + +SWIGRUNTIME PyObject * +SWIG_This(void) +{ + if (Swig_This_global == NULL) + Swig_This_global = SWIG_Python_str_FromChar("this"); + return Swig_This_global; +} + +/* #define SWIG_PYTHON_SLOW_GETSET_THIS */ + +/* TODO: I don't know how to implement the fast getset in Python 3 right now */ +#if PY_VERSION_HEX>=0x03000000 +#define SWIG_PYTHON_SLOW_GETSET_THIS +#endif + +SWIGRUNTIME SwigPyObject * +SWIG_Python_GetSwigThis(PyObject *pyobj) +{ + PyObject *obj; + + if (SwigPyObject_Check(pyobj)) + return (SwigPyObject *) pyobj; + +#ifdef SWIGPYTHON_BUILTIN + (void)obj; +# ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + pyobj = PyWeakref_GET_OBJECT(pyobj); + if (pyobj && SwigPyObject_Check(pyobj)) + return (SwigPyObject*) pyobj; + } +# endif + return NULL; +#else + + obj = 0; + +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + if (PyInstance_Check(pyobj)) { + obj = _PyInstance_Lookup(pyobj, SWIG_This()); + } else { + PyObject **dictptr = _PyObject_GetDictPtr(pyobj); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0; + } else { +#ifdef PyWeakref_CheckProxy + if (PyWeakref_CheckProxy(pyobj)) { + PyObject *wobj = PyWeakref_GET_OBJECT(pyobj); + return wobj ? SWIG_Python_GetSwigThis(wobj) : 0; + } +#endif + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } + } + } +#else + obj = PyObject_GetAttr(pyobj,SWIG_This()); + if (obj) { + Py_DECREF(obj); + } else { + if (PyErr_Occurred()) PyErr_Clear(); + return 0; + } +#endif + if (obj && !SwigPyObject_Check(obj)) { + /* a PyObject is called 'this', try to get the 'real this' + SwigPyObject from it */ + return SWIG_Python_GetSwigThis(obj); + } + return (SwigPyObject *)obj; +#endif +} + +/* Acquire a pointer value */ + +SWIGRUNTIME int +SWIG_Python_AcquirePtr(PyObject *obj, int own) { + if (own == SWIG_POINTER_OWN) { + SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj); + if (sobj) { + int oldown = sobj->own; + sobj->own = own; + return oldown; + } + } + return 0; +} + +/* Convert a pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) { + int res; + SwigPyObject *sobj; + int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0; + + if (!obj) + return SWIG_ERROR; + if (obj == Py_None && !implicit_conv) { + if (ptr) + *ptr = 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + + res = SWIG_ERROR; + + sobj = SWIG_Python_GetSwigThis(obj); + if (own) + *own = 0; + while (sobj) { + void *vptr = sobj->ptr; + if (ty) { + swig_type_info *to = sobj->ty; + if (to == ty) { + /* no type cast needed */ + if (ptr) *ptr = vptr; + break; + } else { + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) { + sobj = (SwigPyObject *)sobj->next; + } else { + if (ptr) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own = *own | SWIG_CAST_NEW_MEMORY; + } + } + break; + } + } + } else { + if (ptr) *ptr = vptr; + break; + } + } + if (sobj) { + if (own) + *own = *own | sobj->own; + if (flags & SWIG_POINTER_DISOWN) { + sobj->own = 0; + } + res = SWIG_OK; + } else { + if (implicit_conv) { + SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0; + if (data && !data->implicitconv) { + PyObject *klass = data->klass; + if (klass) { + PyObject *impconv; + data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/ + impconv = SWIG_Python_CallFunctor(klass, obj); + data->implicitconv = 0; + if (PyErr_Occurred()) { + PyErr_Clear(); + impconv = 0; + } + if (impconv) { + SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv); + if (iobj) { + void *vptr; + res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0); + if (SWIG_IsOK(res)) { + if (ptr) { + *ptr = vptr; + /* transfer the ownership to 'ptr' */ + iobj->own = 0; + res = SWIG_AddCast(res); + res = SWIG_AddNewMask(res); + } else { + res = SWIG_AddCast(res); + } + } + } + Py_DECREF(impconv); + } + } + } + if (!SWIG_IsOK(res) && obj == Py_None) { + if (ptr) + *ptr = 0; + if (PyErr_Occurred()) + PyErr_Clear(); + res = SWIG_OK; + } + } + } + return res; +} + +/* Convert a function ptr value */ + +SWIGRUNTIME int +SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) { + if (!PyCFunction_Check(obj)) { + return SWIG_ConvertPtr(obj, ptr, ty, 0); + } else { + void *vptr = 0; + swig_cast_info *tc; + + /* here we get the method pointer for callbacks */ + const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc); + const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0; + if (desc) + desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0; + if (!desc) + return SWIG_ERROR; + tc = SWIG_TypeCheck(desc,ty); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc,vptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; + } + return SWIG_OK; + } +} + +/* Convert a packed pointer value */ + +SWIGRUNTIME int +SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) { + swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz); + if (!to) return SWIG_ERROR; + if (ty) { + if (to != ty) { + /* check type cast? */ + swig_cast_info *tc = SWIG_TypeCheck(to->name,ty); + if (!tc) return SWIG_ERROR; + } + } + return SWIG_OK; +} + +/* ----------------------------------------------------------------------------- + * Create a new pointer object + * ----------------------------------------------------------------------------- */ + +/* + Create a new instance object, without calling __init__, and set the + 'this' attribute. +*/ + +SWIGRUNTIME PyObject* +SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) +{ + PyObject *inst = 0; + PyObject *newraw = data->newraw; + if (newraw) { + inst = PyObject_Call(newraw, data->newargs, NULL); + if (inst) { +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + PyDict_SetItem(dict, SWIG_This(), swig_this); + } + } +#else + PyObject *key = SWIG_This(); + PyObject_SetAttr(inst, key, swig_this); +#endif + } + } else { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *empty_args = PyTuple_New(0); + if (empty_args) { + PyObject *empty_kwargs = PyDict_New(); + if (empty_kwargs) { + inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs); + Py_DECREF(empty_kwargs); + if (inst) { + PyObject_SetAttr(inst, SWIG_This(), swig_this); + Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG; + } + } + Py_DECREF(empty_args); + } +#else + PyObject *dict = PyDict_New(); + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + inst = PyInstance_NewRaw(data->newargs, dict); + Py_DECREF(dict); + } +#endif + } + return inst; +} + +SWIGRUNTIME void +SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) +{ + PyObject *dict; +#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) + PyObject **dictptr = _PyObject_GetDictPtr(inst); + if (dictptr != NULL) { + dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + PyDict_SetItem(dict, SWIG_This(), swig_this); + return; + } +#endif + dict = PyObject_GetAttrString(inst, "__dict__"); + PyDict_SetItem(dict, SWIG_This(), swig_this); + Py_DECREF(dict); +} + + +SWIGINTERN PyObject * +SWIG_Python_InitShadowInstance(PyObject *args) { + PyObject *obj[2]; + if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) { + return NULL; + } else { + SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); + if (sthis) { + SwigPyObject_append((PyObject*) sthis, obj[1]); + } else { + SWIG_Python_SetSwigThis(obj[0], obj[1]); + } + return SWIG_Py_Void(); + } +} + +/* Create a new pointer object */ + +SWIGRUNTIME PyObject * +SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) { + SwigPyClientData *clientdata; + PyObject * robj; + int own; + + if (!ptr) + return SWIG_Py_Void(); + + clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0; + own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0; + if (clientdata && clientdata->pytype) { + SwigPyObject *newobj; + if (flags & SWIG_BUILTIN_TP_INIT) { + newobj = (SwigPyObject*) self; + if (newobj->ptr) { + PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0); + while (newobj->next) + newobj = (SwigPyObject *) newobj->next; + newobj->next = next_self; + newobj = (SwigPyObject *)next_self; +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + } else { + newobj = PyObject_New(SwigPyObject, clientdata->pytype); +#ifdef SWIGPYTHON_BUILTIN + newobj->dict = 0; +#endif + } + if (newobj) { + newobj->ptr = ptr; + newobj->ty = type; + newobj->own = own; + newobj->next = 0; + return (PyObject*) newobj; + } + return SWIG_Py_Void(); + } + + assert(!(flags & SWIG_BUILTIN_TP_INIT)); + + robj = SwigPyObject_New(ptr, type, own); + if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) { + PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj); + Py_DECREF(robj); + robj = inst; + } + return robj; +} + +/* Create a new packed object */ + +SWIGRUNTIMEINLINE PyObject * +SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { + return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void(); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +#ifdef SWIG_LINK_RUNTIME +void *SWIG_ReturnGlobalTypeList(void *); +#endif + +SWIGRUNTIME swig_module_info * +SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { + static void *type_pointer = (void *)0; + /* first check if module already created */ + if (!type_pointer) { +#ifdef SWIG_LINK_RUNTIME + type_pointer = SWIG_ReturnGlobalTypeList((void *)0); +#else + type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0); + if (PyErr_Occurred()) { + PyErr_Clear(); + type_pointer = (void *)0; + } +#endif + } + return (swig_module_info *) type_pointer; +} + +SWIGRUNTIME void +SWIG_Python_DestroyModule(PyObject *obj) +{ + swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME); + swig_type_info **types = swig_module->types; + size_t i; + for (i =0; i < swig_module->size; ++i) { + swig_type_info *ty = types[i]; + if (ty->owndata) { + SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + if (data) SwigPyClientData_Del(data); + } + } + Py_DECREF(SWIG_This()); + Swig_This_global = NULL; +} + +SWIGRUNTIME void +SWIG_Python_SetModule(swig_module_info *swig_module) { +#if PY_VERSION_HEX >= 0x03000000 + /* Add a dummy module object into sys.modules */ + PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION); +#else + static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */ + PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table); +#endif + PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); + if (pointer && module) { + PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + } else { + Py_XDECREF(pointer); + } +} + +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + +SWIGRUNTIME swig_type_info * +SWIG_Python_TypeQuery(const char *type) +{ + PyObject *cache = SWIG_Python_TypeCache(); + PyObject *key = SWIG_Python_str_FromChar(type); + PyObject *obj = PyDict_GetItem(cache, key); + swig_type_info *descriptor; + if (obj) { + descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL); + } else { + swig_module_info *swig_module = SWIG_GetModule(0); + descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); + if (descriptor) { + obj = PyCapsule_New((void*) descriptor, NULL, NULL); + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } + } + Py_DECREF(key); + return descriptor; +} + +/* + For backward compatibility only +*/ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg) +#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags) + +SWIGRUNTIME int +SWIG_Python_AddErrMesg(const char* mesg, int infront) +{ + if (PyErr_Occurred()) { + PyObject *type = 0; + PyObject *value = 0; + PyObject *traceback = 0; + PyErr_Fetch(&type, &value, &traceback); + if (value) { + PyObject *old_str = PyObject_Str(value); + const char *tmp = SWIG_Python_str_AsChar(old_str); + const char *errmesg = tmp ? tmp : "Invalid error message"; + Py_XINCREF(type); + PyErr_Clear(); + if (infront) { + PyErr_Format(type, "%s %s", mesg, errmesg); + } else { + PyErr_Format(type, "%s %s", errmesg, mesg); + } + SWIG_Python_str_DelForPy3(tmp); + Py_DECREF(old_str); + } + return 1; + } else { + return 0; + } +} + +SWIGRUNTIME int +SWIG_Python_ArgFail(int argnum) +{ + if (PyErr_Occurred()) { + /* add information about failing argument */ + char mesg[256]; + PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum); + return SWIG_Python_AddErrMesg(mesg, 1); + } else { + return 0; + } +} + +SWIGRUNTIMEINLINE const char * +SwigPyObject_GetDesc(PyObject *self) +{ + SwigPyObject *v = (SwigPyObject *)self; + swig_type_info *ty = v ? v->ty : 0; + return ty ? ty->str : ""; +} + +SWIGRUNTIME void +SWIG_Python_TypeError(const char *type, PyObject *obj) +{ + if (type) { +#if defined(SWIG_COBJECT_TYPES) + if (obj && SwigPyObject_Check(obj)) { + const char *otype = (const char *) SwigPyObject_GetDesc(obj); + if (otype) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received", + type, otype); + return; + } + } else +#endif + { + const char *otype = (obj ? obj->ob_type->tp_name : 0); + if (otype) { + PyObject *str = PyObject_Str(obj); + const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0; + if (cstr) { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received", + type, otype, cstr); + SWIG_Python_str_DelForPy3(cstr); + } else { + PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received", + type, otype); + } + Py_XDECREF(str); + return; + } + } + PyErr_Format(PyExc_TypeError, "a '%s' is expected", type); + } else { + PyErr_Format(PyExc_TypeError, "unexpected type is received"); + } +} + + +/* Convert a pointer value, signal an exception on a type mismatch */ +SWIGRUNTIME void * +SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) { + void *result; + if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) { + PyErr_Clear(); +#if SWIG_POINTER_EXCEPTION + if (flags) { + SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj); + SWIG_Python_ArgFail(argnum); + } +#endif + } + return result; +} + +#ifdef SWIGPYTHON_BUILTIN +SWIGRUNTIME int +SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { + PyTypeObject *tp = obj->ob_type; + PyObject *descr; + PyObject *encoded_name; + descrsetfunc f; + int res = -1; + +# ifdef Py_USING_UNICODE + if (PyString_Check(name)) { + name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL); + if (!name) + return -1; + } else if (!PyUnicode_Check(name)) +# else + if (!PyString_Check(name)) +# endif + { + PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name); + return -1; + } else { + Py_INCREF(name); + } + + if (!tp->tp_dict) { + if (PyType_Ready(tp) < 0) + goto done; + } + + descr = _PyType_Lookup(tp, name); + f = NULL; + if (descr != NULL) + f = descr->ob_type->tp_descr_set; + if (!f) { + if (PyString_Check(name)) { + encoded_name = name; + Py_INCREF(name); + } else { + encoded_name = PyUnicode_AsUTF8String(name); + if (!encoded_name) + return -1; + } + PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); + Py_DECREF(encoded_name); + } else { + res = f(descr, obj, value); + } + + done: + Py_DECREF(name); + return res; +} +#endif + + +#ifdef __cplusplus +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Method creation and docstring support functions */ + +SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name); +SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); +SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func); + +#ifdef __cplusplus +} +#endif + + + #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) + +/* ----------------------------------------------------------------------------- + * director_common.swg + * + * This file contains support for director classes which is common between + * languages. + * ----------------------------------------------------------------------------- */ + +/* + Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the + 'Swig' namespace. This could be useful for multi-modules projects. +*/ +#ifdef SWIG_DIRECTOR_STATIC +/* Force anonymous (static) namespace */ +#define Swig +#endif +/* ----------------------------------------------------------------------------- + * director.swg + * + * This file contains support for director classes so that Python proxy + * methods can be called from C++. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DIRECTOR_PYTHON_HEADER_ +#define SWIG_DIRECTOR_PYTHON_HEADER_ + +#include +#include +#include +#include +#include + + +/* + Use -DSWIG_PYTHON_DIRECTOR_NO_VTABLE if you don't want to generate a 'virtual + table', and avoid multiple GetAttr calls to retrieve the python + methods. +*/ + +#ifndef SWIG_PYTHON_DIRECTOR_NO_VTABLE +#ifndef SWIG_PYTHON_DIRECTOR_VTABLE +#define SWIG_PYTHON_DIRECTOR_VTABLE +#endif +#endif + + + +/* + Use -DSWIG_DIRECTOR_NO_UEH if you prefer to avoid the use of the + Undefined Exception Handler provided by swig. +*/ +#ifndef SWIG_DIRECTOR_NO_UEH +#ifndef SWIG_DIRECTOR_UEH +#define SWIG_DIRECTOR_UEH +#endif +#endif + + +/* + Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the + native C++ RTTI and dynamic_cast<>. But be aware that directors + could stop working when using this option. +*/ +#ifdef SWIG_DIRECTOR_NORTTI +/* + When we don't use the native C++ RTTI, we implement a minimal one + only for Directors. +*/ +# ifndef SWIG_DIRECTOR_RTDIR +# define SWIG_DIRECTOR_RTDIR + +namespace Swig { + class Director; + SWIGINTERN std::map& get_rtdir_map() { + static std::map rtdir_map; + return rtdir_map; + } + + SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) { + get_rtdir_map()[vptr] = rtdir; + } + + SWIGINTERNINLINE Director *get_rtdir(void *vptr) { + std::map::const_iterator pos = get_rtdir_map().find(vptr); + Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0; + return rtdir; + } +} +# endif /* SWIG_DIRECTOR_RTDIR */ + +# define SWIG_DIRECTOR_CAST(ARG) Swig::get_rtdir(static_cast(ARG)) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) Swig::set_rtdir(static_cast(ARG1), ARG2) + +#else + +# define SWIG_DIRECTOR_CAST(ARG) dynamic_cast(ARG) +# define SWIG_DIRECTOR_RGTR(ARG1, ARG2) + +#endif /* SWIG_DIRECTOR_NORTTI */ + +extern "C" { + struct swig_type_info; +} + +namespace Swig { + + /* memory handler */ + struct GCItem { + virtual ~GCItem() {} + + virtual int get_own() const { + return 0; + } + }; + + struct GCItem_var { + GCItem_var(GCItem *item = 0) : _item(item) { + } + + GCItem_var& operator=(GCItem *item) { + GCItem *tmp = _item; + _item = item; + delete tmp; + return *this; + } + + ~GCItem_var() { + delete _item; + } + + GCItem * operator->() const { + return _item; + } + + private: + GCItem *_item; + }; + + struct GCItem_Object : GCItem { + GCItem_Object(int own) : _own(own) { + } + + virtual ~GCItem_Object() { + } + + int get_own() const { + return _own; + } + + private: + int _own; + }; + + template + struct GCItem_T : GCItem { + GCItem_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCItem_T() { + delete _ptr; + } + + private: + Type *_ptr; + }; + + template + struct GCArray_T : GCItem { + GCArray_T(Type *ptr) : _ptr(ptr) { + } + + virtual ~GCArray_T() { + delete[] _ptr; + } + + private: + Type *_ptr; + }; + + /* base class for director exceptions */ + class DirectorException : public std::exception { + protected: + std::string swig_msg; + public: + DirectorException(PyObject *error, const char *hdr ="", const char *msg ="") : swig_msg(hdr) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + if (msg[0]) { + swig_msg += " "; + swig_msg += msg; + } + if (!PyErr_Occurred()) { + PyErr_SetString(error, what()); + } + SWIG_PYTHON_THREAD_END_BLOCK; + } + + virtual ~DirectorException() throw() { + } + + /* Deprecated, use what() instead */ + const char *getMessage() const { + return what(); + } + + const char *what() const throw() { + return swig_msg.c_str(); + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorException(error, msg); + } + + static void raise(const char *msg) { + raise(PyExc_RuntimeError, msg); + } + }; + + /* type mismatch in the return value from a python method call */ + class DirectorTypeMismatchException : public DirectorException { + public: + DirectorTypeMismatchException(PyObject *error, const char *msg="") + : DirectorException(error, "SWIG director type mismatch", msg) { + } + + DirectorTypeMismatchException(const char *msg="") + : DirectorException(PyExc_TypeError, "SWIG director type mismatch", msg) { + } + + static void raise(PyObject *error, const char *msg) { + throw DirectorTypeMismatchException(error, msg); + } + + static void raise(const char *msg) { + throw DirectorTypeMismatchException(msg); + } + }; + + /* any python exception that occurs during a director method call */ + class DirectorMethodException : public DirectorException { + public: + DirectorMethodException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director method error.", msg) { + } + + static void raise(const char *msg) { + throw DirectorMethodException(msg); + } + }; + + /* attempt to call a pure virtual method via a director method */ + class DirectorPureVirtualException : public DirectorException { + public: + DirectorPureVirtualException(const char *msg = "") + : DirectorException(PyExc_RuntimeError, "SWIG director pure virtual method called", msg) { + } + + static void raise(const char *msg) { + throw DirectorPureVirtualException(msg); + } + }; + + +#if defined(SWIG_PYTHON_THREADS) +/* __THREAD__ is the old macro to activate some thread support */ +# if !defined(__THREAD__) +# define __THREAD__ 1 +# endif +#endif + +#ifdef __THREAD__ +# include "pythread.h" + class Guard { + PyThread_type_lock &mutex_; + + public: + Guard(PyThread_type_lock & mutex) : mutex_(mutex) { + PyThread_acquire_lock(mutex_, WAIT_LOCK); + } + + ~Guard() { + PyThread_release_lock(mutex_); + } + }; +# define SWIG_GUARD(mutex) Guard _guard(mutex) +#else +# define SWIG_GUARD(mutex) +#endif + + /* director base class */ + class Director { + private: + /* pointer to the wrapped python object */ + PyObject *swig_self; + /* flag indicating whether the object is owned by python or c++ */ + mutable bool swig_disown_flag; + + /* decrement the reference count of the wrapped python object */ + void swig_decref() const { + if (swig_disown_flag) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_DECREF(swig_self); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + public: + /* wrap a python object. */ + Director(PyObject *self) : swig_self(self), swig_disown_flag(false) { + } + + /* discard our reference at destruction */ + virtual ~Director() { + swig_decref(); + } + + /* return a pointer to the wrapped python object */ + PyObject *swig_get_self() const { + return swig_self; + } + + /* acquire ownership of the wrapped python object (the sense of "disown" is from python) */ + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag=true; + swig_incref(); + } + } + + /* increase the reference count of the wrapped python object */ + void swig_incref() const { + if (swig_disown_flag) { + Py_INCREF(swig_self); + } + } + + /* methods to implement pseudo protected director members */ + virtual bool swig_get_inner(const char * /* swig_protected_method_name */) const { + return true; + } + + virtual void swig_set_inner(const char * /* swig_protected_method_name */, bool /* swig_val */) const { + } + + /* ownership management */ + private: + typedef std::map swig_ownership_map; + mutable swig_ownership_map swig_owner; +#ifdef __THREAD__ + static PyThread_type_lock swig_mutex_own; +#endif + + public: + template + void swig_acquire_ownership_array(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCArray_T(vptr); + } + } + + template + void swig_acquire_ownership(Type *vptr) const { + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_T(vptr); + } + } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + SWIG_GUARD(swig_mutex_own); + swig_owner[vptr] = new GCItem_Object(own); + } + } + + int swig_release_ownership(void *vptr) const { + int own = 0; + if (vptr) { + SWIG_GUARD(swig_mutex_own); + swig_ownership_map::iterator iter = swig_owner.find(vptr); + if (iter != swig_owner.end()) { + own = iter->second->get_own(); + swig_owner.erase(iter); + } + } + return own; + } + + template + static PyObject *swig_pyobj_disown(PyObject *pyobj, PyObject *SWIGUNUSEDPARM(args)) { + SwigPyObject *sobj = (SwigPyObject *)pyobj; + sobj->own = 0; + Director *d = SWIG_DIRECTOR_CAST(reinterpret_cast(sobj->ptr)); + if (d) + d->swig_disown(); + return PyWeakref_NewProxy(pyobj, NULL); + } + }; + +#ifdef __THREAD__ + PyThread_type_lock Director::swig_mutex_own = PyThread_allocate_lock(); +#endif +} + +#endif + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_PyMFEM__wFILE swig_types[0] +#define SWIGTYPE_p_char swig_types[1] +#define SWIGTYPE_p_mfem__ArrayT_int_t swig_types[2] +#define SWIGTYPE_p_uint32_t swig_types[3] +static swig_type_info *swig_types[5]; +static swig_module_info swig_module = {swig_types, 4, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#ifdef SWIG_TypeQuery +# undef SWIG_TypeQuery +#endif +#define SWIG_TypeQuery SWIG_Python_TypeQuery + +/*----------------------------------------------- + @(target):= _vtk.so + ------------------------------------------------*/ +#if PY_VERSION_HEX >= 0x03000000 +# define SWIG_init PyInit__vtk + +#else +# define SWIG_init init_vtk + +#endif +#define SWIG_name "_vtk" + +#define SWIGVERSION 0x040001 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) + + +#include + + +namespace swig { + class SwigPtr_PyObject { + protected: + PyObject *_obj; + + public: + SwigPtr_PyObject() :_obj(0) + { + } + + SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj) + { + if (initial_ref) { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + } + + SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XINCREF(item._obj); + Py_XDECREF(_obj); + _obj = item._obj; + SWIG_PYTHON_THREAD_END_BLOCK; + return *this; + } + + ~SwigPtr_PyObject() + { + SWIG_PYTHON_THREAD_BEGIN_BLOCK; + Py_XDECREF(_obj); + SWIG_PYTHON_THREAD_END_BLOCK; + } + + operator PyObject *() const + { + return _obj; + } + + PyObject *operator->() const + { + return _obj; + } + }; +} + + +namespace swig { + struct SwigVar_PyObject : SwigPtr_PyObject { + SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { } + + SwigVar_PyObject & operator = (PyObject* obj) + { + Py_XDECREF(_obj); + _obj = obj; + return *this; + } + }; +} + + +#include "mfem.hpp" +#include "mesh/vtk.hpp" +#include "numpy/arrayobject.h" +#include "io_stream.hpp" + + +SWIGINTERNINLINE PyObject* + SWIG_From_int (int value) +{ + return PyInt_FromLong((long) value); +} + + +#include +#if !defined(SWIG_NO_LLONG_MAX) +# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__) +# define LLONG_MAX __LONG_LONG_MAX__ +# define LLONG_MIN (-LLONG_MAX - 1LL) +# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL) +# endif +#endif + + +SWIGINTERN int +SWIG_AsVal_double (PyObject *obj, double *val) +{ + int res = SWIG_TypeError; + if (PyFloat_Check(obj)) { + if (val) *val = PyFloat_AsDouble(obj); + return SWIG_OK; +#if PY_VERSION_HEX < 0x03000000 + } else if (PyInt_Check(obj)) { + if (val) *val = (double) PyInt_AsLong(obj); + return SWIG_OK; +#endif + } else if (PyLong_Check(obj)) { + double v = PyLong_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + double d = PyFloat_AsDouble(obj); + if (!PyErr_Occurred()) { + if (val) *val = d; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_AddCast(SWIG_OK)); + } else { + PyErr_Clear(); + } + } + } +#endif + return res; +} + + +#include + + +#include + + +SWIGINTERNINLINE int +SWIG_CanCastAsInteger(double *d, double min, double max) { + double x = *d; + if ((min <= x && x <= max)) { + double fx = floor(x); + double cx = ceil(x); + double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */ + if ((errno == EDOM) || (errno == ERANGE)) { + errno = 0; + } else { + double summ, reps, diff; + if (rd < x) { + diff = x - rd; + } else if (rd > x) { + diff = rd - x; + } else { + return 1; + } + summ = rd + x; + reps = diff/summ; + if (reps < 8*DBL_EPSILON) { + *d = rd; + return 1; + } + } + } + return 0; +} + + +SWIGINTERN int +SWIG_AsVal_long (PyObject *obj, long* val) +{ +#if PY_VERSION_HEX < 0x03000000 + if (PyInt_Check(obj)) { + if (val) *val = PyInt_AsLong(obj); + return SWIG_OK; + } else +#endif + if (PyLong_Check(obj)) { + long v = PyLong_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_OK; + } else { + PyErr_Clear(); + return SWIG_OverflowError; + } + } +#ifdef SWIG_PYTHON_CAST_MODE + { + int dispatch = 0; + long v = PyInt_AsLong(obj); + if (!PyErr_Occurred()) { + if (val) *val = v; + return SWIG_AddCast(SWIG_OK); + } else { + PyErr_Clear(); + } + if (!dispatch) { + double d; + int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d)); + if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) { + if (val) *val = (long)(d); + return res; + } + } + } +#endif + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int (PyObject * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long (obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = static_cast< int >(v); + } + } + return res; +} + + +SWIGINTERN swig_type_info* +SWIG_pchar_descriptor(void) +{ + static int init = 0; + static swig_type_info* info = 0; + if (!init) { + info = SWIG_TypeQuery("_p_char"); + init = 1; + } + return info; +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + if (carray) { + if (size > INT_MAX) { + swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); + return pchar_descriptor ? + SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void(); + } else { +#if PY_VERSION_HEX >= 0x03000000 +#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR) + return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#else + return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape"); +#endif +#else + return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size)); +#endif + } + } else { + return SWIG_Py_Void(); + } +} + + +SWIGINTERNINLINE PyObject * +SWIG_FromCharPtr(const char *cptr) +{ + return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); +} + + + +/* --------------------------------------------------- + * C++ director class methods + * --------------------------------------------------- */ + +#include "vtk_wrap.h" + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Array< int > *arg1 = 0 ; + mfem::Geometry::Type arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject *swig_obj[3] ; + + if (!SWIG_Python_UnpackTuple(args, "CreateVTKElementConnectivity", 3, 3, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); + } + arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateVTKElementConnectivity" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + try { + mfem::CreateVTKElementConnectivity(*arg1,arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + std::ostream *arg1 = 0 ; + void *arg2 = (void *) 0 ; + uint32_t arg3 ; + int arg4 ; + PyMFEM::wFILE *temp1 = 0 ; + std::ofstream out1 ; + int res2 ; + void *argp3 ; + int res3 = 0 ; + PyObject *swig_obj[4] ; + + if (!SWIG_Python_UnpackTuple(args, "WriteVTKEncodedCompressed", 4, 4, swig_obj)) SWIG_fail; + { + if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp1->isSTDOUT() == 1) { + arg1 = &std::cout; + } + else { + out1.open(temp1->getFilename()); + out1.precision(temp1->getPrecision()); + arg1 = &out1; + } + } + res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteVTKEncodedCompressed" "', argument " "2"" of type '" "void const *""'"); + } + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_uint32_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WriteVTKEncodedCompressed" "', argument " "3"" of type '" "uint32_t""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "WriteVTKEncodedCompressed" "', argument " "3"" of type '" "uint32_t""'"); + } else { + uint32_t * temp = reinterpret_cast< uint32_t * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + { + try { + mfem::WriteVTKEncodedCompressed(*arg1,(void const *)arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + return resultobj; +fail: + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_VTKByteOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + char *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "VTKByteOrder", 0, 0, 0)) SWIG_fail; + { + try { + result = (char *)mfem::VTKByteOrder(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_FromCharPtr((const char *)result); + return resultobj; +fail: + return NULL; +} + + +static PyMethodDef SwigMethods[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, + { NULL, NULL, 0, NULL } +}; + +static PyMethodDef SwigMethods_proxydocs[] = { + { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, + { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, + { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, + { NULL, NULL, 0, NULL } +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_PyMFEM__wFILE = {"_p_PyMFEM__wFILE", "PyMFEM::wFILE *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_mfem__ArrayT_int_t = {"_p_mfem__ArrayT_int_t", "mfem::Array< int > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_PyMFEM__wFILE, + &_swigt__p_char, + &_swigt__p_mfem__ArrayT_int_t, + &_swigt__p_uint32_t, +}; + +static swig_cast_info _swigc__p_PyMFEM__wFILE[] = { {&_swigt__p_PyMFEM__wFILE, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_mfem__ArrayT_int_t[] = { {&_swigt__p_mfem__ArrayT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_PyMFEM__wFILE, + _swigc__p_char, + _swigc__p_mfem__ArrayT_int_t, + _swigc__p_uint32_t, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +static swig_const_info swig_const_table[] = { +{0, 0, 0, 0.0, 0, 0}}; + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Python-specific SWIG API */ +#define SWIG_newvarlink() SWIG_Python_newvarlink() +#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr) +#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants) + + /* ----------------------------------------------------------------------------- + * global variable support code. + * ----------------------------------------------------------------------------- */ + + typedef struct swig_globalvar { + char *name; /* Name of global variable */ + PyObject *(*get_attr)(void); /* Return the current value */ + int (*set_attr)(PyObject *); /* Set the value */ + struct swig_globalvar *next; + } swig_globalvar; + + typedef struct swig_varlinkobject { + PyObject_HEAD + swig_globalvar *vars; + } swig_varlinkobject; + + SWIGINTERN PyObject * + swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) { +#if PY_VERSION_HEX >= 0x03000000 + return PyUnicode_InternFromString(""); +#else + return PyString_FromString(""); +#endif + } + + SWIGINTERN PyObject * + swig_varlink_str(swig_varlinkobject *v) { +#if PY_VERSION_HEX >= 0x03000000 + PyObject *str = PyUnicode_InternFromString("("); + PyObject *tail; + PyObject *joined; + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + tail = PyUnicode_FromString(var->name); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + if (var->next) { + tail = PyUnicode_InternFromString(", "); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; + } + } + tail = PyUnicode_InternFromString(")"); + joined = PyUnicode_Concat(str, tail); + Py_DecRef(str); + Py_DecRef(tail); + str = joined; +#else + PyObject *str = PyString_FromString("("); + swig_globalvar *var; + for (var = v->vars; var; var=var->next) { + PyString_ConcatAndDel(&str,PyString_FromString(var->name)); + if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", ")); + } + PyString_ConcatAndDel(&str,PyString_FromString(")")); +#endif + return str; + } + + SWIGINTERN void + swig_varlink_dealloc(swig_varlinkobject *v) { + swig_globalvar *var = v->vars; + while (var) { + swig_globalvar *n = var->next; + free(var->name); + free(var); + var = n; + } + } + + SWIGINTERN PyObject * + swig_varlink_getattr(swig_varlinkobject *v, char *n) { + PyObject *res = NULL; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->get_attr)(); + break; + } + var = var->next; + } + if (res == NULL && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN int + swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) { + int res = 1; + swig_globalvar *var = v->vars; + while (var) { + if (strcmp(var->name,n) == 0) { + res = (*var->set_attr)(p); + break; + } + var = var->next; + } + if (res == 1 && !PyErr_Occurred()) { + PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n); + } + return res; + } + + SWIGINTERN PyTypeObject* + swig_varlink_type(void) { + static char varlink__doc__[] = "Swig var link object"; + static PyTypeObject varlink_type; + static int type_init = 0; + if (!type_init) { + const PyTypeObject tmp = { +#if PY_VERSION_HEX >= 0x03000000 + PyVarObject_HEAD_INIT(NULL, 0) +#else + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ +#endif + "swigvarlink", /* tp_name */ + sizeof(swig_varlinkobject), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor) swig_varlink_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc) swig_varlink_getattr, /* tp_getattr */ + (setattrfunc) swig_varlink_setattr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc) swig_varlink_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + (reprfunc) swig_varlink_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + 0, /* tp_flags */ + varlink__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */ + 0, /* tp_del */ + 0, /* tp_version_tag */ +#if PY_VERSION_HEX >= 0x03040000 + 0, /* tp_finalize */ +#endif +#ifdef COUNT_ALLOCS + 0, /* tp_allocs */ + 0, /* tp_frees */ + 0, /* tp_maxalloc */ + 0, /* tp_prev */ + 0 /* tp_next */ +#endif + }; + varlink_type = tmp; + type_init = 1; + if (PyType_Ready(&varlink_type) < 0) + return NULL; + } + return &varlink_type; + } + + /* Create a variable linking object for use later */ + SWIGINTERN PyObject * + SWIG_Python_newvarlink(void) { + swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type()); + if (result) { + result->vars = 0; + } + return ((PyObject*) result); + } + + SWIGINTERN void + SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) { + swig_varlinkobject *v = (swig_varlinkobject *) p; + swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar)); + if (gv) { + size_t size = strlen(name)+1; + gv->name = (char *)malloc(size); + if (gv->name) { + memcpy(gv->name, name, size); + gv->get_attr = get_attr; + gv->set_attr = set_attr; + gv->next = v->vars; + } + } + v->vars = gv; + } + + SWIGINTERN PyObject * + SWIG_globals(void) { + static PyObject *globals = 0; + if (!globals) { + globals = SWIG_newvarlink(); + } + return globals; + } + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + SWIGINTERN void + SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) { + PyObject *obj = 0; + size_t i; + for (i = 0; constants[i].type; ++i) { + switch(constants[i].type) { + case SWIG_PY_POINTER: + obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_PY_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + PyDict_SetItemString(d, constants[i].name, obj); + Py_DECREF(obj); + } + } + } + + /* -----------------------------------------------------------------------------*/ + /* Fix SwigMethods to carry the callback ptrs when needed */ + /* -----------------------------------------------------------------------------*/ + + SWIGINTERN void + SWIG_Python_FixMethods(PyMethodDef *methods, + swig_const_info *const_table, + swig_type_info **types, + swig_type_info **types_initial) { + size_t i; + for (i = 0; methods[i].ml_name; ++i) { + const char *c = methods[i].ml_doc; + if (!c) continue; + c = strstr(c, "swig_ptr: "); + if (c) { + int j; + swig_const_info *ci = 0; + const char *name = c + 10; + for (j = 0; const_table[j].type; ++j) { + if (strncmp(const_table[j].name, name, + strlen(const_table[j].name)) == 0) { + ci = &(const_table[j]); + break; + } + } + if (ci) { + void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0; + if (ptr) { + size_t shift = (ci->ptype) - types; + swig_type_info *ty = types_initial[shift]; + size_t ldoc = (c - methods[i].ml_doc); + size_t lptr = strlen(ty->name)+2*sizeof(void*)+2; + char *ndoc = (char*)malloc(ldoc + lptr + 10); + if (ndoc) { + char *buff = ndoc; + memcpy(buff, methods[i].ml_doc, ldoc); + buff += ldoc; + memcpy(buff, "swig_ptr: ", 10); + buff += 10; + SWIG_PackVoidPtr(buff, ptr, ty->name, lptr); + methods[i].ml_doc = ndoc; + } + } + } + } + } + } + + /* ----------------------------------------------------------------------------- + * Method creation and docstring support functions + * ----------------------------------------------------------------------------- */ + + /* ----------------------------------------------------------------------------- + * Function to find the method definition with the correct docstring for the + * proxy module as opposed to the low-level API + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) { + /* Find the function in the modified method table */ + size_t offset = 0; + int found = 0; + while (SwigMethods_proxydocs[offset].ml_meth != NULL) { + if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) { + found = 1; + break; + } + offset++; + } + /* Use the copy with the modified docstring if available */ + return found ? &SwigMethods_proxydocs[offset] : NULL; + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyInstanceMethod_New() used in Python 3 + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } +#if PY_VERSION_HEX >= 0x03000000 + return PyInstanceMethod_New(func); +#else + return PyMethod_New(func, NULL, NULL); +#endif + } + + /* ----------------------------------------------------------------------------- + * Wrapper of PyStaticMethod_New() + * It is exported to the generated module, used for -fastproxy + * ----------------------------------------------------------------------------- */ + + SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) { + if (PyCFunction_Check(func)) { + PyCFunctionObject *funcobj = (PyCFunctionObject *)func; + PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name); + if (ml) + func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module); + } + return PyStaticMethod_New(func); + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +#ifdef __cplusplus +extern "C" +#endif + +SWIGEXPORT +#if PY_VERSION_HEX >= 0x03000000 +PyObject* +#else +void +#endif +SWIG_init(void) { + PyObject *m, *d, *md, *globals; + +#if PY_VERSION_HEX >= 0x03000000 + static struct PyModuleDef SWIG_module = { + PyModuleDef_HEAD_INIT, + SWIG_name, + NULL, + -1, + SwigMethods, + NULL, + NULL, + NULL, + NULL + }; +#endif + +#if defined(SWIGPYTHON_BUILTIN) + static SwigPyClientData SwigPyObject_clientdata = { + 0, 0, 0, 0, 0, 0, 0 + }; + static PyGetSetDef this_getset_def = { + (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL + }; + static SwigPyGetSet thisown_getset_closure = { + SwigPyObject_own, + SwigPyObject_own + }; + static PyGetSetDef thisown_getset_def = { + (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure + }; + PyTypeObject *builtin_pytype; + int builtin_base_count; + swig_type_info *builtin_basetype; + PyObject *tuple; + PyGetSetDescrObject *static_getset; + PyTypeObject *metatype; + PyTypeObject *swigpyobject; + SwigPyClientData *cd; + PyObject *public_interface, *public_symbol; + PyObject *this_descr; + PyObject *thisown_descr; + PyObject *self = 0; + int i; + + (void)builtin_pytype; + (void)builtin_base_count; + (void)builtin_basetype; + (void)tuple; + (void)static_getset; + (void)self; + + /* Metaclass is used to implement static member variables */ + metatype = SwigPyObjectType(); + assert(metatype); +#endif + + (void)globals; + + /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */ + SWIG_This(); + SWIG_Python_TypeCache(); + SwigPyPacked_type(); +#ifndef SWIGPYTHON_BUILTIN + SwigPyObject_type(); +#endif + + /* Fix SwigMethods to carry the callback ptrs when needed */ + SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial); + +#if PY_VERSION_HEX >= 0x03000000 + m = PyModule_Create(&SWIG_module); +#else + m = Py_InitModule(SWIG_name, SwigMethods); +#endif + + md = d = PyModule_GetDict(m); + (void)md; + + SWIG_InitializeModule(0); + +#ifdef SWIGPYTHON_BUILTIN + swigpyobject = SwigPyObject_TypeOnce(); + + SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject"); + assert(SwigPyObject_stype); + cd = (SwigPyClientData*) SwigPyObject_stype->clientdata; + if (!cd) { + SwigPyObject_stype->clientdata = &SwigPyObject_clientdata; + SwigPyObject_clientdata.pytype = swigpyobject; + } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) { + PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules."); +# if PY_VERSION_HEX >= 0x03000000 + return NULL; +# else + return; +# endif + } + + /* All objects have a 'this' attribute */ + this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def); + (void)this_descr; + + /* All objects have a 'thisown' attribute */ + thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def); + (void)thisown_descr; + + public_interface = PyList_New(0); + public_symbol = 0; + (void)public_symbol; + + PyDict_SetItemString(md, "__all__", public_interface); + Py_DECREF(public_interface); + for (i = 0; SwigMethods[i].ml_name != NULL; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name); + for (i = 0; swig_const_table[i].name != 0; ++i) + SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name); +#endif + + SWIG_InstallConstants(d,swig_const_table); + + + import_array(); + + SWIG_Python_SetConstant(d, "VTKFormat_ASCII",SWIG_From_int(static_cast< int >(mfem::VTKFormat::ASCII))); + SWIG_Python_SetConstant(d, "VTKFormat_BINARY",SWIG_From_int(static_cast< int >(mfem::VTKFormat::BINARY))); + SWIG_Python_SetConstant(d, "VTKFormat_BINARY32",SWIG_From_int(static_cast< int >(mfem::VTKFormat::BINARY32))); +#if PY_VERSION_HEX >= 0x03000000 + return m; +#else + return; +#endif +} + diff --git a/mfem/_ser/vtk_wrap.h b/mfem/_ser/vtk_wrap.h new file mode 100644 index 00000000..6ac318d3 --- /dev/null +++ b/mfem/_ser/vtk_wrap.h @@ -0,0 +1,18 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_vtk_WRAP_H_ +#define SWIG_vtk_WRAP_H_ + +#include +#include + + +#endif From 9e5fd4800fab48dc31b2919dc2367a45d8bcbfef Mon Sep 17 00:00:00 2001 From: Syun'ichi Shiraiwa Date: Thu, 9 Apr 2020 09:24:11 -0400 Subject: [PATCH 6/9] Improved FindPoints argument interface --- README | 9 +++++++++ mfem/_par/mesh.i | 15 +++++++++++++++ mfem/_par/mesh.py | 19 +++++++++++++++---- mfem/_ser/mesh.i | 16 ++++++++++++++++ mfem/_ser/mesh.py | 19 +++++++++++++++---- 5 files changed, 70 insertions(+), 8 deletions(-) diff --git a/README b/README index 256421a0..273d6c7a 100644 --- a/README +++ b/README @@ -194,6 +194,15 @@ to find more detail of the MFEM libirary. virtual void PrintInfo(std::ostream &out = mfem::out) + FindPoints receive only one argument (points to look for) and returns + count, element_id, integration_points. Note points are row order. For example, + + >>> count, elem_ids, int_pts = mesh.FindPoint([1,2,3], [3,4,5], [4,5,6], [7,8,9]]) + + will look for 4 points. + + + 4-5) sparsemat RAP has two different implementations. One accept three references. The other accept a pointer as a third argument, instead. diff --git a/mfem/_par/mesh.i b/mfem/_par/mesh.i index 66947023..bf70e966 100644 --- a/mfem/_par/mesh.i +++ b/mfem/_par/mesh.i @@ -268,6 +268,21 @@ def GetEdgeTransformation(self, i): _mesh.Mesh_GetEdgeTransformation(self, i, Tr) return Tr %} +%feature("shadow") mfem::Mesh::FindPoints %{ +def FindPoints(self, pp): + r"""count, element_id, integration_points = FindPoints(points)""" + import numpy as np + import mfem.par as mfem + + pp = np.array(pp, copy=False, dtype=float).transpose() + M = mfem.DenseMatrix(pp.shape[0], pp.shape[1]) + M.Assign(pp) + elem_ids = mfem.intArray() + int_points = mfem.IntegrationPointArray() + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + elem_ids = elem_ids.ToList() + return count, elem_ids, int_points +%} %immutable attributes; %immutable bdr_attributes; diff --git a/mfem/_par/mesh.py b/mfem/_par/mesh.py index 46d5d738..e4fc1ffc 100644 --- a/mfem/_par/mesh.py +++ b/mfem/_par/mesh.py @@ -977,10 +977,21 @@ def PrintCharacteristics(self, *args): return _mesh.Mesh_PrintCharacteristics(self, *args) PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) - def FindPoints(self, point_mat, elem_ids, ips, warn=True, inv_trans=None): - r"""FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int""" - return _mesh.Mesh_FindPoints(self, point_mat, elem_ids, ips, warn, inv_trans) - FindPoints = _swig_new_instance_method(_mesh.Mesh_FindPoints) + def FindPoints(self, pp): + r"""count, element_id, integration_points = FindPoints(points)""" + import numpy as np + import mfem.par as mfem + + pp = np.array(pp, copy=False, dtype=float).transpose() + M = mfem.DenseMatrix(pp.shape[0], pp.shape[1]) + M.Assign(pp) + elem_ids = mfem.intArray() + int_points = mfem.IntegrationPointArray() + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + elem_ids = elem_ids.ToList() + return count, elem_ids, int_points + + __swig_destroy__ = _mesh.delete_Mesh def __init__(self, *args): diff --git a/mfem/_ser/mesh.i b/mfem/_ser/mesh.i index 270fdd0d..2c77c1be 100644 --- a/mfem/_ser/mesh.i +++ b/mfem/_ser/mesh.i @@ -275,6 +275,22 @@ def GetEdgeTransformation(self, i): _mesh.Mesh_GetEdgeTransformation(self, i, Tr) return Tr %} +%feature("shadow") mfem::Mesh::FindPoints %{ +def FindPoints(self, pp): + r"""count, element_id, integration_points = FindPoints(points)""" + import numpy as np + import mfem.ser as mfem + + pp = np.array(pp, copy=False, dtype=float).transpose() + M = mfem.DenseMatrix(pp.shape[0], pp.shape[1]) + M.Assign(pp) + elem_ids = mfem.intArray() + int_points = mfem.IntegrationPointArray() + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + elem_ids = elem_ids.ToList() + return count, elem_ids, int_points +%} + %immutable attributes; %immutable bdr_attributes; diff --git a/mfem/_ser/mesh.py b/mfem/_ser/mesh.py index be734770..7c850ff9 100644 --- a/mfem/_ser/mesh.py +++ b/mfem/_ser/mesh.py @@ -1040,10 +1040,21 @@ def PrintCharacteristics(self, *args): return _mesh.Mesh_PrintCharacteristics(self, *args) PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) - def FindPoints(self, point_mat, elem_ids, ips, warn=True, inv_trans=None): - r"""FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int""" - return _mesh.Mesh_FindPoints(self, point_mat, elem_ids, ips, warn, inv_trans) - FindPoints = _swig_new_instance_method(_mesh.Mesh_FindPoints) + def FindPoints(self, pp): + r"""count, element_id, integration_points = FindPoints(points)""" + import numpy as np + import mfem.ser as mfem + + pp = np.array(pp, copy=False, dtype=float).transpose() + M = mfem.DenseMatrix(pp.shape[0], pp.shape[1]) + M.Assign(pp) + elem_ids = mfem.intArray() + int_points = mfem.IntegrationPointArray() + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + elem_ids = elem_ids.ToList() + return count, elem_ids, int_points + + __swig_destroy__ = _mesh.delete_Mesh def __init__(self, *args): From b030dbb087f4b30f9861a0fecc70fcb115bac964 Mon Sep 17 00:00:00 2001 From: Syun'ichi Shiraiwa Date: Sun, 12 Apr 2020 19:29:20 -0400 Subject: [PATCH 7/9] regenerated wrapper with -keyword option --- Makefile | 2 +- mfem/_par/array.py | 12 +- mfem/_par/array_wrap.cxx | 2422 +-- mfem/_par/bilinearform_wrap.cxx | 4713 ++--- mfem/_par/bilinearform_wrap.h | 2 +- mfem/_par/bilininteg_wrap.cxx | 6761 ++++---- mfem/_par/bilininteg_wrap.h | 2 +- mfem/_par/blockmatrix_wrap.cxx | 851 +- mfem/_par/blockoperator_wrap.cxx | 808 +- mfem/_par/blockvector_wrap.cxx | 43 +- mfem/_par/coefficient_wrap.cxx | 3625 ++-- mfem/_par/common_functions_wrap.cxx | 394 +- mfem/_par/communication.py | 4 +- mfem/_par/communication_wrap.cxx | 698 +- mfem/_par/complex_operator.py | 4 +- mfem/_par/complex_operator_wrap.cxx | 532 +- mfem/_par/config_wrap.cxx | 8 +- mfem/_par/cpointers_wrap.cxx | 68 +- mfem/_par/densemat.py | 12 +- mfem/_par/densemat_wrap.cxx | 3623 ++-- mfem/_par/device.py | 4 +- mfem/_par/device_wrap.cxx | 405 +- mfem/_par/element_wrap.cxx | 195 +- mfem/_par/eltrans_wrap.cxx | 480 +- mfem/_par/error_wrap.cxx | 325 +- mfem/_par/estimators_wrap.cxx | 563 +- mfem/_par/fe.py | 84 +- mfem/_par/fe_coll.py | 32 +- mfem/_par/fe_coll_wrap.cxx | 4427 ++--- mfem/_par/fe_wrap.cxx | 10239 ++++++----- mfem/_par/fespace.py | 4 +- mfem/_par/fespace_wrap.cxx | 3642 ++-- mfem/_par/geom_wrap.cxx | 556 +- mfem/_par/globals.py | 4 +- mfem/_par/globals_wrap.cxx | 278 +- mfem/_par/gridfunc_wrap.cxx | 12886 +++++--------- mfem/_par/handle_wrap.cxx | 1263 +- mfem/_par/hash_wrap.cxx | 69 +- mfem/_par/hybridization_wrap.cxx | 163 +- mfem/_par/hypre.py | 2 +- mfem/_par/hypre_wrap.cxx | 5875 +++---- mfem/_par/intrules.py | 4 +- mfem/_par/intrules_wrap.cxx | 906 +- mfem/_par/io_stream_wrap.cxx | 78 +- mfem/_par/linearform_wrap.cxx | 36 +- mfem/_par/lininteg_wrap.cxx | 1388 +- mfem/_par/matrix_wrap.cxx | 755 +- mfem/_par/mem_manager.py | 8 +- mfem/_par/mem_manager_wrap.cxx | 375 +- mfem/_par/mesh.py | 6 +- mfem/_par/mesh_operators.py | 4 +- mfem/_par/mesh_operators_wrap.cxx | 316 +- mfem/_par/mesh_wrap.cxx | 21615 +++++++---------------- mfem/_par/ncmesh_wrap.cxx | 1173 +- mfem/_par/nonlinearform_wrap.cxx | 481 +- mfem/_par/nonlininteg_wrap.cxx | 1108 +- mfem/_par/ode.py | 12 +- mfem/_par/ode_wrap.cxx | 1914 +-- mfem/_par/operators_wrap.cxx | 3579 ++-- mfem/_par/pbilinearform_wrap.cxx | 1267 +- mfem/_par/pfespace.py | 4 +- mfem/_par/pfespace_wrap.cxx | 1722 +- mfem/_par/pgridfunc.py | 1 - mfem/_par/pgridfunc_wrap.cxx | 2925 +--- mfem/_par/plinearform_wrap.cxx | 84 +- mfem/_par/pmesh.py | 19 +- mfem/_par/pmesh_wrap.cxx | 2986 +--- mfem/_par/pncmesh_wrap.cxx | 762 +- mfem/_par/pnonlinearform_wrap.cxx | 261 +- mfem/_par/point_wrap.cxx | 163 +- mfem/_par/prestriction.py | 4 +- mfem/_par/prestriction_wrap.cxx | 188 +- mfem/_par/pumi.py | 3 - mfem/_par/pumi_wrap.cxx | 1074 +- mfem/_par/restriction.py | 4 +- mfem/_par/restriction_wrap.cxx | 494 +- mfem/_par/segment_wrap.cxx | 284 +- mfem/_par/sets_wrap.cxx | 135 +- mfem/_par/socketstream_wrap.cxx | 425 +- mfem/_par/solvers_wrap.cxx | 7980 +++------ mfem/_par/sparsemat.py | 26 +- mfem/_par/sparsemat_wrap.cxx | 8555 +++------ mfem/_par/sparsesmoothers_wrap.cxx | 747 +- mfem/_par/stable3d_wrap.cxx | 277 +- mfem/_par/table_wrap.cxx | 1369 +- mfem/_par/vector.py | 6 +- mfem/_par/vector_wrap.cxx | 1449 +- mfem/_par/vtk_wrap.cxx | 49 +- mfem/_ser/array.py | 12 +- mfem/_ser/array_wrap.cxx | 2422 +-- mfem/_ser/bilinearform_wrap.cxx | 5031 ++---- mfem/_ser/bilinearform_wrap.h | 2 +- mfem/_ser/bilininteg_wrap.cxx | 7031 ++++---- mfem/_ser/bilininteg_wrap.h | 2 +- mfem/_ser/blockmatrix_wrap.cxx | 961 +- mfem/_ser/blockoperator_wrap.cxx | 804 +- mfem/_ser/blockvector_wrap.cxx | 43 +- mfem/_ser/coefficient_wrap.cxx | 3722 ++-- mfem/_ser/common_functions_wrap.cxx | 396 +- mfem/_ser/complex_operator.py | 4 +- mfem/_ser/complex_operator_wrap.cxx | 556 +- mfem/_ser/densemat.py | 12 +- mfem/_ser/densemat_wrap.cxx | 3663 ++-- mfem/_ser/device.py | 4 +- mfem/_ser/device_wrap.cxx | 405 +- mfem/_ser/element_wrap.cxx | 195 +- mfem/_ser/eltrans_wrap.cxx | 486 +- mfem/_ser/error_wrap.cxx | 325 +- mfem/_ser/estimators_wrap.cxx | 398 +- mfem/_ser/fe.py | 84 +- mfem/_ser/fe_coll.py | 32 +- mfem/_ser/fe_coll_wrap.cxx | 5531 +++--- mfem/_ser/fe_wrap.cxx | 10473 ++++++----- mfem/_ser/fespace.py | 4 +- mfem/_ser/fespace_wrap.cxx | 3455 ++-- mfem/_ser/geom_wrap.cxx | 568 +- mfem/_ser/globals.py | 4 +- mfem/_ser/globals_wrap.cxx | 278 +- mfem/_ser/gridfunc_wrap.cxx | 11901 ++++--------- mfem/_ser/handle_wrap.cxx | 1201 +- mfem/_ser/hash_wrap.cxx | 69 +- mfem/_ser/hybridization_wrap.cxx | 145 +- mfem/_ser/intrules.py | 4 +- mfem/_ser/intrules_wrap.cxx | 906 +- mfem/_ser/io_stream_wrap.cxx | 78 +- mfem/_ser/linearform_wrap.cxx | 104 +- mfem/_ser/lininteg_wrap.cxx | 1376 +- mfem/_ser/matrix_wrap.cxx | 791 +- mfem/_ser/mem_manager.py | 8 +- mfem/_ser/mem_manager_wrap.cxx | 375 +- mfem/_ser/mesh.py | 6 +- mfem/_ser/mesh_operators.py | 4 +- mfem/_ser/mesh_operators_wrap.cxx | 330 +- mfem/_ser/mesh_wrap.cxx | 23898 +++++++------------------- mfem/_ser/ncmesh_wrap.cxx | 1311 +- mfem/_ser/nonlinearform_wrap.cxx | 487 +- mfem/_ser/nonlininteg_wrap.cxx | 1146 +- mfem/_ser/ode.py | 12 +- mfem/_ser/ode_wrap.cxx | 2060 +-- mfem/_ser/operators_wrap.cxx | 3750 ++-- mfem/_ser/point_wrap.cxx | 169 +- mfem/_ser/restriction.py | 4 +- mfem/_ser/restriction_wrap.cxx | 505 +- mfem/_ser/segment_wrap.cxx | 296 +- mfem/_ser/sets_wrap.cxx | 135 +- mfem/_ser/socketstream_wrap.cxx | 469 +- mfem/_ser/solvers_wrap.cxx | 8716 +++------- mfem/_ser/sparsemat.py | 26 +- mfem/_ser/sparsemat_wrap.cxx | 7879 +++------ mfem/_ser/sparsesmoothers_wrap.cxx | 807 +- mfem/_ser/stable3d_wrap.cxx | 289 +- mfem/_ser/table_wrap.cxx | 1369 +- mfem/_ser/vector.py | 6 +- mfem/_ser/vector_wrap.cxx | 1449 +- mfem/_ser/vtk_wrap.cxx | 49 +- 155 files changed, 84837 insertions(+), 167297 deletions(-) diff --git a/Makefile b/Makefile index 1783bd43..d03f7dd3 100644 --- a/Makefile +++ b/Makefile @@ -17,7 +17,7 @@ WHOLE_ARCHIVE = --whole_archive NO_WHOLE_ARCHIVE = --no-whole-archive SWIG=$(shell which swig) -SWIGFLAG = -Wall -c++ -python -fastproxy -olddefs +SWIGFLAG = -Wall -c++ -python -fastproxy -olddefs -keyword # # MFEM path: diff --git a/mfem/_par/array.py b/mfem/_par/array.py index ce9d3d34..9d60e6cf 100644 --- a/mfem/_par/array.py +++ b/mfem/_par/array.py @@ -288,7 +288,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_array.intArray_MemoryUsage) def Read(self, on_dev=True): - r"""Read(intArray self, bool on_dev=True) -> int const""" + r"""Read(intArray self, bool on_dev=True) -> int const *""" return _array.intArray_Read(self, on_dev) Read = _swig_new_instance_method(_array.intArray_Read) @@ -298,7 +298,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_array.intArray_HostRead) def Write(self, on_dev=True): - r"""Write(intArray self, bool on_dev=True) -> int""" + r"""Write(intArray self, bool on_dev=True) -> int *""" return _array.intArray_Write(self, on_dev) Write = _swig_new_instance_method(_array.intArray_Write) @@ -308,7 +308,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_array.intArray_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(intArray self, bool on_dev=True) -> int""" + r"""ReadWrite(intArray self, bool on_dev=True) -> int *""" return _array.intArray_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_array.intArray_ReadWrite) @@ -583,7 +583,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_array.doubleArray_MemoryUsage) def Read(self, on_dev=True): - r"""Read(doubleArray self, bool on_dev=True) -> double const""" + r"""Read(doubleArray self, bool on_dev=True) -> double const *""" return _array.doubleArray_Read(self, on_dev) Read = _swig_new_instance_method(_array.doubleArray_Read) @@ -593,7 +593,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_array.doubleArray_HostRead) def Write(self, on_dev=True): - r"""Write(doubleArray self, bool on_dev=True) -> double""" + r"""Write(doubleArray self, bool on_dev=True) -> double *""" return _array.doubleArray_Write(self, on_dev) Write = _swig_new_instance_method(_array.doubleArray_Write) @@ -603,7 +603,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_array.doubleArray_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(doubleArray self, bool on_dev=True) -> double""" + r"""ReadWrite(doubleArray self, bool on_dev=True) -> double *""" return _array.doubleArray_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_array.doubleArray_ReadWrite) diff --git a/mfem/_par/array_wrap.cxx b/mfem/_par/array_wrap.cxx index 7075632c..d31bc33f 100644 --- a/mfem/_par/array_wrap.cxx +++ b/mfem/_par/array_wrap.cxx @@ -3100,7 +3100,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Array_Sl_int_Sg__Print__SWIG_3(mfem::Array< int > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_int_Sg__Print__SWIG_1(mfem::Array< int > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3111,7 +3111,7 @@ SWIGINTERN void mfem_Array_Sl_int_Sg__Print__SWIG_3(mfem::Array< int > *self,cha self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_2(mfem::Array< int > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_1(mfem::Array< int > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3122,7 +3122,7 @@ SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_2(mfem::Array< int > *self,char self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_4(mfem::Array< int > *self){ +SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_2(mfem::Array< int > *self){ self -> Save(std::cout); } @@ -3138,7 +3138,7 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Assign__SWIG_1(mfem::Array< double > *s *self = a; } SWIGINTERN void mfem_Array_Sl_double_Sg__FakeToList(mfem::Array< double > *self){} -SWIGINTERN void mfem_Array_Sl_double_Sg__Print__SWIG_3(mfem::Array< double > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_double_Sg__Print__SWIG_1(mfem::Array< double > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3149,7 +3149,7 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Print__SWIG_3(mfem::Array< double > *se self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_2(mfem::Array< double > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_1(mfem::Array< double > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3160,7 +3160,7 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_2(mfem::Array< double > *sel self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_4(mfem::Array< double > *self){ +SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_2(mfem::Array< double > *self){ self -> Save(std::cout); } #ifdef __cplusplus @@ -3749,7 +3749,7 @@ SWIGINTERN PyObject *_wrap_intArray_OwnsData(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_intArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int **arg2 = (int **) 0 ; @@ -3757,15 +3757,19 @@ SWIGINTERN PyObject *_wrap_intArray_StealData(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_StealData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_StealData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_StealData" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_StealData" "', argument " "2"" of type '" "int **""'"); } @@ -4166,7 +4170,7 @@ SWIGINTERN PyObject *_wrap_intArray_Capacity(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_intArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -4174,15 +4178,19 @@ SWIGINTERN PyObject *_wrap_intArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"capacity", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_Reserve", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Reserve", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Reserve" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Reserve" "', argument " "2"" of type '" "int""'"); } @@ -4422,7 +4430,7 @@ SWIGINTERN PyObject *_wrap_intArray_Append(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_intArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4431,16 +4439,20 @@ SWIGINTERN PyObject *_wrap_intArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyOb int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_Prepend", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Prepend", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Prepend" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Prepend" "', argument " "2"" of type '" "int""'"); } @@ -4577,7 +4589,7 @@ SWIGINTERN PyObject *_wrap_intArray_Last(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4586,16 +4598,20 @@ SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObje int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_Union", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Union", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Union" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Union" "', argument " "2"" of type '" "int""'"); } @@ -4624,7 +4640,7 @@ SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4633,16 +4649,20 @@ SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObjec int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_Find", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Find", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Find" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Find" "', argument " "2"" of type '" "int""'"); } @@ -4671,7 +4691,7 @@ SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_intArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4680,16 +4700,20 @@ SWIGINTERN PyObject *_wrap_intArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), P int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_FindSorted", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_FindSorted", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_FindSorted" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_FindSorted" "', argument " "2"" of type '" "int""'"); } @@ -4755,7 +4779,7 @@ SWIGINTERN PyObject *_wrap_intArray_DeleteLast(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_intArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4764,15 +4788,19 @@ SWIGINTERN PyObject *_wrap_intArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_DeleteFirst", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_DeleteFirst", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_DeleteFirst" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_DeleteFirst" "', argument " "2"" of type '" "int""'"); } @@ -4838,7 +4866,7 @@ SWIGINTERN PyObject *_wrap_intArray_DeleteAll(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_intArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4846,15 +4874,19 @@ SWIGINTERN PyObject *_wrap_intArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Copy" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Copy" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -5033,7 +5065,7 @@ SWIGINTERN PyObject *_wrap_intArray_MakeRef(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -5047,25 +5079,31 @@ SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"sa_size", (char *)"sa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_GetSubArray", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:intArray_GetSubArray", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_GetSubArray" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_GetSubArray" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_GetSubArray" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "intArray_GetSubArray" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -5099,8 +5137,9 @@ SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; @@ -5108,32 +5147,36 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self) int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { ((mfem::Array< int > const *)arg1)->Print(*arg2,arg3); @@ -5167,19 +5210,22 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; std::ostream *arg2 = 0 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + int val3 ; + int ecode3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { @@ -5197,9 +5243,16 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self) arg2 = &out2; } } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - ((mfem::Array< int > const *)arg1)->Print(*arg2); + ((mfem::Array< int > const *)arg1)->Save(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5230,21 +5283,42 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; + std::istream *arg2 = 0 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Load" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - ((mfem::Array< int > const *)arg1)->Print(); + (arg1)->Load(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5265,47 +5339,40 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + int arg2 ; + std::istream *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val3 ; - int ecode3 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Load" "', argument " "2"" of type '" "int""'"); } - arg3 = static_cast< int >(val3); + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); + } + arg3 = reinterpret_cast< std::istream * >(argp3); { try { - ((mfem::Array< int > const *)arg1)->Save(*arg2,arg3); + (arg1)->Load(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5320,55 +5387,91 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intArray_Load(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Load", 0, 3, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_intArray_Load__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_intArray_Load__SWIG_0(self, argc, argv); + } + } } } - return NULL; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_Load__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Load'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< int >::Load(std::istream &,int)\n" + " mfem::Array< int >::Load(int,std::istream &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Max" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } { try { - ((mfem::Array< int > const *)arg1)->Save(*arg2); + result = (int)((mfem::Array< int > const *)arg1)->Max(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5382,301 +5485,26 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Load" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - (arg1)->Load(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - try { - (arg1)->Load(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - int arg2 ; - std::istream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Load" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); - } - arg3 = reinterpret_cast< std::istream * >(argp3); - { - try { - (arg1)->Load(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Load(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Load", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Load__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_Load__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Load__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Load'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Load(std::istream &,int)\n" - " mfem::Array< int >::Load(std::istream &)\n" - " mfem::Array< int >::Load(int,std::istream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_intArray_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Max" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - try { - result = (int)((mfem::Array< int > const *)arg1)->Max(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Min" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Min" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { @@ -6186,66 +6014,37 @@ SWIGINTERN PyObject *_wrap_intArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:intArray_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Read" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)((mfem::Array< int > const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Read" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - result = (int *)((mfem::Array< int > const *)arg1)->Read(); + result = (int *)((mfem::Array< int > const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6266,48 +6065,6 @@ SWIGINTERN PyObject *_wrap_intArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Read(bool) const\n" - " mfem::Array< int >::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_intArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -6346,66 +6103,37 @@ SWIGINTERN PyObject *_wrap_intArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_intArray_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:intArray_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Write" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Write" "', argument " "1"" of type '" "mfem::Array< int > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - result = (int *)(arg1)->Write(); + result = (int *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6426,48 +6154,6 @@ SWIGINTERN PyObject *_wrap_intArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Write(bool)\n" - " mfem::Array< int >::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_intArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -6506,66 +6192,37 @@ SWIGINTERN PyObject *_wrap_intArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_intArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:intArray_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)(arg1)->ReadWrite(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< int > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - result = (int *)(arg1)->ReadWrite(); + result = (int *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6586,48 +6243,6 @@ SWIGINTERN PyObject *_wrap_intArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_intArray_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::ReadWrite(bool)\n" - " mfem::Array< int >::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_intArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -6666,7 +6281,7 @@ SWIGINTERN PyObject *_wrap_intArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -6677,20 +6292,25 @@ SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:intArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___setitem__" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___setitem__" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray___setitem__" "', argument " "3"" of type '" "int""'"); } @@ -6718,7 +6338,7 @@ SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -6726,16 +6346,20 @@ SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "intArray___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___getitem__" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___getitem__" "', argument " "2"" of type '" "int""'"); } @@ -6892,11 +6516,11 @@ SWIGINTERN PyObject *_wrap_intArray_FakeToList(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -6905,7 +6529,7 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self) int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -6916,60 +6540,16 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_int_Sg__Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Print" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Array_Sl_int_Sg__Print__SWIG_3(arg1,(char const *)arg2); + mfem_Array_Sl_int_Sg__Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7000,34 +6580,15 @@ SWIGINTERN PyObject *_wrap_intArray_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_intArray_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_intArray_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -7038,51 +6599,37 @@ SWIGINTERN PyObject *_wrap_intArray_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_intArray_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_intArray_Print__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_intArray_Print__SWIG_3(self, argc, argv); + return _wrap_intArray_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_intArray_Print__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_intArray_Print__SWIG_0(self, argc, argv); + return _wrap_intArray_Print__SWIG_1(self, argc, argv); } } } @@ -7092,79 +6639,25 @@ SWIGINTERN PyObject *_wrap_intArray_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< int >::Print(std::ostream &,int) const\n" - " mfem::Array< int >::Print(std::ostream &) const\n" - " mfem::Array< int >::Print() const\n" - " mfem::Array< int >::Print(char const *,int)\n" - " mfem::Array< int >::Print(char const *)\n"); + " mfem::Array< int >::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_int_Sg__Save__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + int ecode3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -7175,9 +6668,16 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - mfem_Array_Sl_int_Sg__Save__SWIG_2(arg1,(char const *)arg2); + mfem_Array_Sl_int_Sg__Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7200,7 +6700,7 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; void *argp1 = 0 ; @@ -7214,7 +6714,7 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(self), arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - mfem_Array_Sl_int_Sg__Save__SWIG_4(arg1); + mfem_Array_Sl_int_Sg__Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7249,10 +6749,10 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_intArray_Save__SWIG_4(self, argc, argv); + return _wrap_intArray_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); @@ -7261,50 +6761,20 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_intArray_Save__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_intArray_Save__SWIG_1(self, argc, argv); } - } - if (_v) { - return _wrap_intArray_Save__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_intArray_Save__SWIG_2(self, argc, argv); + return _wrap_intArray_Save__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); @@ -7320,6 +6790,9 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_intArray_Save__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -7335,9 +6808,7 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< int >::Save(std::ostream &,int) const\n" - " mfem::Array< int >::Save(std::ostream &) const\n" " mfem::Array< int >::Save(char const *,int)\n" - " mfem::Array< int >::Save(char const *)\n" " mfem::Array< int >::Save()\n"); return 0; } @@ -7937,7 +7408,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_OwnsData(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double **arg2 = (double **) 0 ; @@ -7945,15 +7416,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_StealData(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_StealData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_StealData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_StealData" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_StealData" "', argument " "2"" of type '" "double **""'"); } @@ -8354,7 +7829,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Capacity(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -8362,15 +7837,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_Reserve(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"capacity", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Reserve", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Reserve", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Reserve" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Reserve" "', argument " "2"" of type '" "int""'"); } @@ -8610,7 +8089,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Append(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_doubleArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8619,16 +8098,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Prepend(PyObject *SWIGUNUSEDPARM(self), P double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Prepend", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Prepend", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Prepend" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Prepend" "', argument " "2"" of type '" "double""'"); } @@ -8765,7 +8248,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Last(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8774,16 +8257,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyO double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Union", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Union", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Union" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Union" "', argument " "2"" of type '" "double""'"); } @@ -8812,7 +8299,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8821,16 +8308,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyOb double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Find", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Find", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Find" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Find" "', argument " "2"" of type '" "double""'"); } @@ -8859,7 +8350,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_doubleArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8868,16 +8359,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_FindSorted(PyObject *SWIGUNUSEDPARM(self) double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_FindSorted", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_FindSorted", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_FindSorted" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_FindSorted" "', argument " "2"" of type '" "double""'"); } @@ -8943,7 +8438,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_DeleteLast(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_doubleArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8952,15 +8447,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_DeleteFirst", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_DeleteFirst", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_DeleteFirst" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_DeleteFirst" "', argument " "2"" of type '" "double""'"); } @@ -9026,7 +8525,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_DeleteAll(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; mfem::Array< double > *arg2 = 0 ; @@ -9034,15 +8533,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Copy" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Copy" "', argument " "2"" of type '" "mfem::Array< double > &""'"); } @@ -9221,7 +8724,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_MakeRef(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -9235,25 +8738,31 @@ SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"sa_size", (char *)"sa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_GetSubArray", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:doubleArray_GetSubArray", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_GetSubArray" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_GetSubArray" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_GetSubArray" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "doubleArray_GetSubArray" "', argument " "4"" of type '" "mfem::Array< double > &""'"); } @@ -9287,8 +8796,9 @@ SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; @@ -9296,98 +8806,39 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(se int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - ((mfem::Array< double > const *)arg1)->Print(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } { try { - ((mfem::Array< double > const *)arg1)->Print(*arg2); + ((mfem::Array< double > const *)arg1)->Print(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9418,46 +8869,11 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - try { - ((mfem::Array< double > const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; std::ostream *arg2 = 0 ; - int arg3 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; @@ -9465,75 +8881,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(sel int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - ((mfem::Array< double > const *)arg1)->Save(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); @@ -9554,9 +8902,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(sel arg2 = &out2; } } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - ((mfem::Array< double > const *)arg1)->Save(*arg2); + ((mfem::Array< double > const *)arg1)->Save(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9591,7 +8946,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; std::istream *arg2 = 0 ; - int arg3 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9599,7 +8954,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Load" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -9613,11 +8968,13 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "doubleArray_Load" "', argument " "2"" of type '" "std::istream &""'"); } arg2 = reinterpret_cast< std::istream * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Load" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Load" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { (arg1)->Load(*arg2,arg3); @@ -9642,52 +8999,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Load" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "doubleArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - try { - (arg1)->Load(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -9749,21 +9060,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Load", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Load__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); @@ -9773,6 +9070,9 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Load__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -9798,7 +9098,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_doubleArray_Load__SWIG_2(self, argc, argv); + return _wrap_doubleArray_Load__SWIG_1(self, argc, argv); } } } @@ -9808,7 +9108,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Load'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< double >::Load(std::istream &,int)\n" - " mfem::Array< double >::Load(std::istream &)\n" " mfem::Array< double >::Load(int,std::istream &)\n"); return 0; } @@ -10374,66 +9673,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_doubleArray_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:doubleArray_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Read" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::Array< double > const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Read" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); { try { - result = (double *)((mfem::Array< double > const *)arg1)->Read(); + result = (double *)((mfem::Array< double > const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10454,48 +9724,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_doubleArray_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_doubleArray_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::Read(bool) const\n" - " mfem::Array< double >::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_doubleArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; @@ -10534,146 +9762,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_HostRead(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Write" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Write" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - try { - result = (double *)(arg1)->Write(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_doubleArray_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::Write(bool)\n" - " mfem::Array< double >::Write()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:doubleArray_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_HostWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Write" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->HostWrite(); + result = (double *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10694,30 +9813,24 @@ SWIGINTERN PyObject *_wrap_doubleArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + PyObject *swig_obj[1] ; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_HostWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { try { - result = (double *)(arg1)->ReadWrite(arg2); + result = (double *)(arg1)->HostWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10738,22 +9851,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:doubleArray_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10774,48 +9902,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_doubleArray_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::ReadWrite(bool)\n" - " mfem::Array< double >::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_doubleArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; @@ -10854,7 +9940,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -10865,20 +9951,25 @@ SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:doubleArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___setitem__" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___setitem__" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray___setitem__" "', argument " "3"" of type '" "double""'"); } @@ -10906,7 +9997,7 @@ SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -10914,16 +10005,20 @@ SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "doubleArray___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___getitem__" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___getitem__" "', argument " "2"" of type '" "int""'"); } @@ -11080,11 +10175,11 @@ SWIGINTERN PyObject *_wrap_doubleArray_FakeToList(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11093,7 +10188,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(se int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -11104,60 +10199,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_double_Sg__Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Print" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Array_Sl_double_Sg__Print__SWIG_3(arg1,(char const *)arg2); + mfem_Array_Sl_double_Sg__Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11188,34 +10239,15 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -11226,51 +10258,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_doubleArray_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_doubleArray_Print__SWIG_3(self, argc, argv); + return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Print__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); + return _wrap_doubleArray_Print__SWIG_1(self, argc, argv); } } } @@ -11280,19 +10298,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< double >::Print(std::ostream &,int) const\n" - " mfem::Array< double >::Print(std::ostream &) const\n" - " mfem::Array< double >::Print() const\n" - " mfem::Array< double >::Print(char const *,int)\n" - " mfem::Array< double >::Print(char const *)\n"); + " mfem::Array< double >::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11301,7 +10316,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(sel int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -11312,60 +10327,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_double_Sg__Save__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Save" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Array_Sl_double_Sg__Save__SWIG_2(arg1,(char const *)arg2); + mfem_Array_Sl_double_Sg__Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11388,7 +10359,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; void *argp1 = 0 ; @@ -11402,7 +10373,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(sel arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); { try { - mfem_Array_Sl_double_Sg__Save__SWIG_4(arg1); + mfem_Array_Sl_double_Sg__Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11437,10 +10408,10 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_doubleArray_Save__SWIG_4(self, argc, argv); + return _wrap_doubleArray_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); @@ -11449,50 +10420,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_doubleArray_Save__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_doubleArray_Save__SWIG_1(self, argc, argv); } - } - if (_v) { - return _wrap_doubleArray_Save__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_doubleArray_Save__SWIG_2(self, argc, argv); + return _wrap_doubleArray_Save__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); @@ -11508,6 +10449,9 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Save__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -11523,9 +10467,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< double >::Save(std::ostream &,int) const\n" - " mfem::Array< double >::Save(std::ostream &) const\n" " mfem::Array< double >::Save(char const *,int)\n" - " mfem::Array< double >::Save(char const *)\n" " mfem::Array< double >::Save()\n"); return 0; } @@ -11979,7 +10921,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "intArray_UseDevice", _wrap_intArray_UseDevice, METH_O, "intArray_UseDevice(intArray self) -> bool"}, { "intArray_OwnsData", _wrap_intArray_OwnsData, METH_O, "intArray_OwnsData(intArray self) -> bool"}, - { "intArray_StealData", _wrap_intArray_StealData, METH_VARARGS, "intArray_StealData(intArray self, int ** p)"}, + { "intArray_StealData", (PyCFunction)(void(*)(void))_wrap_intArray_StealData, METH_VARARGS|METH_KEYWORDS, "intArray_StealData(intArray self, int ** p)"}, { "intArray_LoseData", _wrap_intArray_LoseData, METH_O, "intArray_LoseData(intArray self)"}, { "intArray_MakeDataOwner", _wrap_intArray_MakeDataOwner, METH_O, "intArray_MakeDataOwner(intArray self)"}, { "intArray_Size", _wrap_intArray_Size, METH_O, "intArray_Size(intArray self) -> int"}, @@ -11989,29 +10931,29 @@ static PyMethodDef SwigMethods[] = { "intArray_SetSize(intArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "intArray_Capacity", _wrap_intArray_Capacity, METH_O, "intArray_Capacity(intArray self) -> int"}, - { "intArray_Reserve", _wrap_intArray_Reserve, METH_VARARGS, "intArray_Reserve(intArray self, int capacity)"}, + { "intArray_Reserve", (PyCFunction)(void(*)(void))_wrap_intArray_Reserve, METH_VARARGS|METH_KEYWORDS, "intArray_Reserve(intArray self, int capacity)"}, { "intArray_Append", _wrap_intArray_Append, METH_VARARGS, "\n" "intArray_Append(intArray self, int const & el) -> int\n" "intArray_Append(intArray self, int const * els, int nels) -> int\n" "intArray_Append(intArray self, intArray els) -> int\n" ""}, - { "intArray_Prepend", _wrap_intArray_Prepend, METH_VARARGS, "intArray_Prepend(intArray self, int const & el) -> int"}, + { "intArray_Prepend", (PyCFunction)(void(*)(void))_wrap_intArray_Prepend, METH_VARARGS|METH_KEYWORDS, "intArray_Prepend(intArray self, int const & el) -> int"}, { "intArray_Last", _wrap_intArray_Last, METH_VARARGS, "\n" "intArray_Last(intArray self) -> int\n" "intArray_Last(intArray self) -> int const &\n" ""}, - { "intArray_Union", _wrap_intArray_Union, METH_VARARGS, "intArray_Union(intArray self, int const & el) -> int"}, - { "intArray_Find", _wrap_intArray_Find, METH_VARARGS, "intArray_Find(intArray self, int const & el) -> int"}, - { "intArray_FindSorted", _wrap_intArray_FindSorted, METH_VARARGS, "intArray_FindSorted(intArray self, int const & el) -> int"}, + { "intArray_Union", (PyCFunction)(void(*)(void))_wrap_intArray_Union, METH_VARARGS|METH_KEYWORDS, "intArray_Union(intArray self, int const & el) -> int"}, + { "intArray_Find", (PyCFunction)(void(*)(void))_wrap_intArray_Find, METH_VARARGS|METH_KEYWORDS, "intArray_Find(intArray self, int const & el) -> int"}, + { "intArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_intArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "intArray_FindSorted(intArray self, int const & el) -> int"}, { "intArray_DeleteLast", _wrap_intArray_DeleteLast, METH_O, "intArray_DeleteLast(intArray self)"}, - { "intArray_DeleteFirst", _wrap_intArray_DeleteFirst, METH_VARARGS, "intArray_DeleteFirst(intArray self, int const & el)"}, + { "intArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_intArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "intArray_DeleteFirst(intArray self, int const & el)"}, { "intArray_DeleteAll", _wrap_intArray_DeleteAll, METH_O, "intArray_DeleteAll(intArray self)"}, - { "intArray_Copy", _wrap_intArray_Copy, METH_VARARGS, "intArray_Copy(intArray self, intArray copy)"}, + { "intArray_Copy", (PyCFunction)(void(*)(void))_wrap_intArray_Copy, METH_VARARGS|METH_KEYWORDS, "intArray_Copy(intArray self, intArray copy)"}, { "intArray_MakeRef", _wrap_intArray_MakeRef, METH_VARARGS, "\n" "intArray_MakeRef(intArray self, int * arg2, int arg3)\n" "intArray_MakeRef(intArray self, intArray master)\n" ""}, - { "intArray_GetSubArray", _wrap_intArray_GetSubArray, METH_VARARGS, "intArray_GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, + { "intArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_intArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "intArray_GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, { "intArray_Load", _wrap_intArray_Load, METH_VARARGS, "\n" "intArray_Load(intArray self, std::istream & _in, int fmt=0)\n" "intArray_Load(intArray self, int new_size, std::istream & _in)\n" @@ -12032,14 +10974,14 @@ static PyMethodDef SwigMethods[] = { "intArray_end(intArray self) -> int const *\n" ""}, { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "intArray_MemoryUsage(intArray self) -> long"}, - { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "intArray_Read(intArray self, bool on_dev=True) -> int const"}, + { "intArray_Read", (PyCFunction)(void(*)(void))_wrap_intArray_Read, METH_VARARGS|METH_KEYWORDS, "intArray_Read(intArray self, bool on_dev=True) -> int const *"}, { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "intArray_HostRead(intArray self) -> int const *"}, - { "intArray_Write", _wrap_intArray_Write, METH_VARARGS, "intArray_Write(intArray self, bool on_dev=True) -> int"}, + { "intArray_Write", (PyCFunction)(void(*)(void))_wrap_intArray_Write, METH_VARARGS|METH_KEYWORDS, "intArray_Write(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostWrite", _wrap_intArray_HostWrite, METH_O, "intArray_HostWrite(intArray self) -> int *"}, - { "intArray_ReadWrite", _wrap_intArray_ReadWrite, METH_VARARGS, "intArray_ReadWrite(intArray self, bool on_dev=True) -> int"}, + { "intArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_intArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "intArray_ReadWrite(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostReadWrite", _wrap_intArray_HostReadWrite, METH_O, "intArray_HostReadWrite(intArray self) -> int *"}, - { "intArray___setitem__", _wrap_intArray___setitem__, METH_VARARGS, "intArray___setitem__(intArray self, int i, int const v)"}, - { "intArray___getitem__", _wrap_intArray___getitem__, METH_VARARGS, "intArray___getitem__(intArray self, int const i) -> int const &"}, + { "intArray___setitem__", (PyCFunction)(void(*)(void))_wrap_intArray___setitem__, METH_VARARGS|METH_KEYWORDS, "intArray___setitem__(intArray self, int i, int const v)"}, + { "intArray___getitem__", (PyCFunction)(void(*)(void))_wrap_intArray___getitem__, METH_VARARGS|METH_KEYWORDS, "intArray___getitem__(intArray self, int const i) -> int const &"}, { "intArray_Assign", _wrap_intArray_Assign, METH_VARARGS, "\n" "intArray_Assign(intArray self, int const * arg2)\n" "intArray_Assign(intArray self, int const & a)\n" @@ -12074,7 +11016,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "doubleArray_UseDevice", _wrap_doubleArray_UseDevice, METH_O, "doubleArray_UseDevice(doubleArray self) -> bool"}, { "doubleArray_OwnsData", _wrap_doubleArray_OwnsData, METH_O, "doubleArray_OwnsData(doubleArray self) -> bool"}, - { "doubleArray_StealData", _wrap_doubleArray_StealData, METH_VARARGS, "doubleArray_StealData(doubleArray self, double ** p)"}, + { "doubleArray_StealData", (PyCFunction)(void(*)(void))_wrap_doubleArray_StealData, METH_VARARGS|METH_KEYWORDS, "doubleArray_StealData(doubleArray self, double ** p)"}, { "doubleArray_LoseData", _wrap_doubleArray_LoseData, METH_O, "doubleArray_LoseData(doubleArray self)"}, { "doubleArray_MakeDataOwner", _wrap_doubleArray_MakeDataOwner, METH_O, "doubleArray_MakeDataOwner(doubleArray self)"}, { "doubleArray_Size", _wrap_doubleArray_Size, METH_O, "doubleArray_Size(doubleArray self) -> int"}, @@ -12084,29 +11026,29 @@ static PyMethodDef SwigMethods[] = { "doubleArray_SetSize(doubleArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "doubleArray_Capacity", _wrap_doubleArray_Capacity, METH_O, "doubleArray_Capacity(doubleArray self) -> int"}, - { "doubleArray_Reserve", _wrap_doubleArray_Reserve, METH_VARARGS, "doubleArray_Reserve(doubleArray self, int capacity)"}, + { "doubleArray_Reserve", (PyCFunction)(void(*)(void))_wrap_doubleArray_Reserve, METH_VARARGS|METH_KEYWORDS, "doubleArray_Reserve(doubleArray self, int capacity)"}, { "doubleArray_Append", _wrap_doubleArray_Append, METH_VARARGS, "\n" "doubleArray_Append(doubleArray self, double const & el) -> int\n" "doubleArray_Append(doubleArray self, double const * els, int nels) -> int\n" "doubleArray_Append(doubleArray self, doubleArray els) -> int\n" ""}, - { "doubleArray_Prepend", _wrap_doubleArray_Prepend, METH_VARARGS, "doubleArray_Prepend(doubleArray self, double const & el) -> int"}, + { "doubleArray_Prepend", (PyCFunction)(void(*)(void))_wrap_doubleArray_Prepend, METH_VARARGS|METH_KEYWORDS, "doubleArray_Prepend(doubleArray self, double const & el) -> int"}, { "doubleArray_Last", _wrap_doubleArray_Last, METH_VARARGS, "\n" "doubleArray_Last(doubleArray self) -> double\n" "doubleArray_Last(doubleArray self) -> double const &\n" ""}, - { "doubleArray_Union", _wrap_doubleArray_Union, METH_VARARGS, "doubleArray_Union(doubleArray self, double const & el) -> int"}, - { "doubleArray_Find", _wrap_doubleArray_Find, METH_VARARGS, "doubleArray_Find(doubleArray self, double const & el) -> int"}, - { "doubleArray_FindSorted", _wrap_doubleArray_FindSorted, METH_VARARGS, "doubleArray_FindSorted(doubleArray self, double const & el) -> int"}, + { "doubleArray_Union", (PyCFunction)(void(*)(void))_wrap_doubleArray_Union, METH_VARARGS|METH_KEYWORDS, "doubleArray_Union(doubleArray self, double const & el) -> int"}, + { "doubleArray_Find", (PyCFunction)(void(*)(void))_wrap_doubleArray_Find, METH_VARARGS|METH_KEYWORDS, "doubleArray_Find(doubleArray self, double const & el) -> int"}, + { "doubleArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_doubleArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "doubleArray_FindSorted(doubleArray self, double const & el) -> int"}, { "doubleArray_DeleteLast", _wrap_doubleArray_DeleteLast, METH_O, "doubleArray_DeleteLast(doubleArray self)"}, - { "doubleArray_DeleteFirst", _wrap_doubleArray_DeleteFirst, METH_VARARGS, "doubleArray_DeleteFirst(doubleArray self, double const & el)"}, + { "doubleArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_doubleArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "doubleArray_DeleteFirst(doubleArray self, double const & el)"}, { "doubleArray_DeleteAll", _wrap_doubleArray_DeleteAll, METH_O, "doubleArray_DeleteAll(doubleArray self)"}, - { "doubleArray_Copy", _wrap_doubleArray_Copy, METH_VARARGS, "doubleArray_Copy(doubleArray self, doubleArray copy)"}, + { "doubleArray_Copy", (PyCFunction)(void(*)(void))_wrap_doubleArray_Copy, METH_VARARGS|METH_KEYWORDS, "doubleArray_Copy(doubleArray self, doubleArray copy)"}, { "doubleArray_MakeRef", _wrap_doubleArray_MakeRef, METH_VARARGS, "\n" "doubleArray_MakeRef(doubleArray self, double * arg2, int arg3)\n" "doubleArray_MakeRef(doubleArray self, doubleArray master)\n" ""}, - { "doubleArray_GetSubArray", _wrap_doubleArray_GetSubArray, METH_VARARGS, "doubleArray_GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, + { "doubleArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_doubleArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "doubleArray_GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, { "doubleArray_Load", _wrap_doubleArray_Load, METH_VARARGS, "\n" "doubleArray_Load(doubleArray self, std::istream & _in, int fmt=0)\n" "doubleArray_Load(doubleArray self, int new_size, std::istream & _in)\n" @@ -12127,14 +11069,14 @@ static PyMethodDef SwigMethods[] = { "doubleArray_end(doubleArray self) -> double const *\n" ""}, { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "doubleArray_MemoryUsage(doubleArray self) -> long"}, - { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "doubleArray_Read(doubleArray self, bool on_dev=True) -> double const"}, + { "doubleArray_Read", (PyCFunction)(void(*)(void))_wrap_doubleArray_Read, METH_VARARGS|METH_KEYWORDS, "doubleArray_Read(doubleArray self, bool on_dev=True) -> double const *"}, { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "doubleArray_HostRead(doubleArray self) -> double const *"}, - { "doubleArray_Write", _wrap_doubleArray_Write, METH_VARARGS, "doubleArray_Write(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_Write", (PyCFunction)(void(*)(void))_wrap_doubleArray_Write, METH_VARARGS|METH_KEYWORDS, "doubleArray_Write(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostWrite", _wrap_doubleArray_HostWrite, METH_O, "doubleArray_HostWrite(doubleArray self) -> double *"}, - { "doubleArray_ReadWrite", _wrap_doubleArray_ReadWrite, METH_VARARGS, "doubleArray_ReadWrite(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_doubleArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "doubleArray_ReadWrite(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostReadWrite", _wrap_doubleArray_HostReadWrite, METH_O, "doubleArray_HostReadWrite(doubleArray self) -> double *"}, - { "doubleArray___setitem__", _wrap_doubleArray___setitem__, METH_VARARGS, "doubleArray___setitem__(doubleArray self, int i, double const v)"}, - { "doubleArray___getitem__", _wrap_doubleArray___getitem__, METH_VARARGS, "doubleArray___getitem__(doubleArray self, int const i) -> double const &"}, + { "doubleArray___setitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___setitem__, METH_VARARGS|METH_KEYWORDS, "doubleArray___setitem__(doubleArray self, int i, double const v)"}, + { "doubleArray___getitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___getitem__, METH_VARARGS|METH_KEYWORDS, "doubleArray___getitem__(doubleArray self, int const i) -> double const &"}, { "doubleArray_Assign", _wrap_doubleArray_Assign, METH_VARARGS, "\n" "doubleArray_Assign(doubleArray self, double const * arg2)\n" "doubleArray_Assign(doubleArray self, double const & a)\n" @@ -12185,7 +11127,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "intArray_UseDevice", _wrap_intArray_UseDevice, METH_O, "UseDevice(intArray self) -> bool"}, { "intArray_OwnsData", _wrap_intArray_OwnsData, METH_O, "OwnsData(intArray self) -> bool"}, - { "intArray_StealData", _wrap_intArray_StealData, METH_VARARGS, "StealData(intArray self, int ** p)"}, + { "intArray_StealData", (PyCFunction)(void(*)(void))_wrap_intArray_StealData, METH_VARARGS|METH_KEYWORDS, "StealData(intArray self, int ** p)"}, { "intArray_LoseData", _wrap_intArray_LoseData, METH_O, "LoseData(intArray self)"}, { "intArray_MakeDataOwner", _wrap_intArray_MakeDataOwner, METH_O, "MakeDataOwner(intArray self)"}, { "intArray_Size", _wrap_intArray_Size, METH_O, "Size(intArray self) -> int"}, @@ -12195,29 +11137,29 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(intArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "intArray_Capacity", _wrap_intArray_Capacity, METH_O, "Capacity(intArray self) -> int"}, - { "intArray_Reserve", _wrap_intArray_Reserve, METH_VARARGS, "Reserve(intArray self, int capacity)"}, + { "intArray_Reserve", (PyCFunction)(void(*)(void))_wrap_intArray_Reserve, METH_VARARGS|METH_KEYWORDS, "Reserve(intArray self, int capacity)"}, { "intArray_Append", _wrap_intArray_Append, METH_VARARGS, "\n" "Append(intArray self, int const & el) -> int\n" "Append(intArray self, int const * els, int nels) -> int\n" "Append(intArray self, intArray els) -> int\n" ""}, - { "intArray_Prepend", _wrap_intArray_Prepend, METH_VARARGS, "Prepend(intArray self, int const & el) -> int"}, + { "intArray_Prepend", (PyCFunction)(void(*)(void))_wrap_intArray_Prepend, METH_VARARGS|METH_KEYWORDS, "Prepend(intArray self, int const & el) -> int"}, { "intArray_Last", _wrap_intArray_Last, METH_VARARGS, "\n" "Last(intArray self) -> int\n" "Last(intArray self) -> int const &\n" ""}, - { "intArray_Union", _wrap_intArray_Union, METH_VARARGS, "Union(intArray self, int const & el) -> int"}, - { "intArray_Find", _wrap_intArray_Find, METH_VARARGS, "Find(intArray self, int const & el) -> int"}, - { "intArray_FindSorted", _wrap_intArray_FindSorted, METH_VARARGS, "FindSorted(intArray self, int const & el) -> int"}, + { "intArray_Union", (PyCFunction)(void(*)(void))_wrap_intArray_Union, METH_VARARGS|METH_KEYWORDS, "Union(intArray self, int const & el) -> int"}, + { "intArray_Find", (PyCFunction)(void(*)(void))_wrap_intArray_Find, METH_VARARGS|METH_KEYWORDS, "Find(intArray self, int const & el) -> int"}, + { "intArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_intArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "FindSorted(intArray self, int const & el) -> int"}, { "intArray_DeleteLast", _wrap_intArray_DeleteLast, METH_O, "DeleteLast(intArray self)"}, - { "intArray_DeleteFirst", _wrap_intArray_DeleteFirst, METH_VARARGS, "DeleteFirst(intArray self, int const & el)"}, + { "intArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_intArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "DeleteFirst(intArray self, int const & el)"}, { "intArray_DeleteAll", _wrap_intArray_DeleteAll, METH_O, "DeleteAll(intArray self)"}, - { "intArray_Copy", _wrap_intArray_Copy, METH_VARARGS, "Copy(intArray self, intArray copy)"}, + { "intArray_Copy", (PyCFunction)(void(*)(void))_wrap_intArray_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(intArray self, intArray copy)"}, { "intArray_MakeRef", _wrap_intArray_MakeRef, METH_VARARGS, "\n" "MakeRef(intArray self, int * arg2, int arg3)\n" "MakeRef(intArray self, intArray master)\n" ""}, - { "intArray_GetSubArray", _wrap_intArray_GetSubArray, METH_VARARGS, "GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, + { "intArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_intArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, { "intArray_Load", _wrap_intArray_Load, METH_VARARGS, "\n" "Load(intArray self, std::istream & _in, int fmt=0)\n" "Load(intArray self, int new_size, std::istream & _in)\n" @@ -12238,14 +11180,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "end(intArray self) -> int const *\n" ""}, { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "MemoryUsage(intArray self) -> long"}, - { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "Read(intArray self, bool on_dev=True) -> int const"}, + { "intArray_Read", (PyCFunction)(void(*)(void))_wrap_intArray_Read, METH_VARARGS|METH_KEYWORDS, "Read(intArray self, bool on_dev=True) -> int const *"}, { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "HostRead(intArray self) -> int const *"}, - { "intArray_Write", _wrap_intArray_Write, METH_VARARGS, "Write(intArray self, bool on_dev=True) -> int"}, + { "intArray_Write", (PyCFunction)(void(*)(void))_wrap_intArray_Write, METH_VARARGS|METH_KEYWORDS, "Write(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostWrite", _wrap_intArray_HostWrite, METH_O, "HostWrite(intArray self) -> int *"}, - { "intArray_ReadWrite", _wrap_intArray_ReadWrite, METH_VARARGS, "ReadWrite(intArray self, bool on_dev=True) -> int"}, + { "intArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_intArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostReadWrite", _wrap_intArray_HostReadWrite, METH_O, "HostReadWrite(intArray self) -> int *"}, - { "intArray___setitem__", _wrap_intArray___setitem__, METH_VARARGS, "__setitem__(intArray self, int i, int const v)"}, - { "intArray___getitem__", _wrap_intArray___getitem__, METH_VARARGS, "__getitem__(intArray self, int const i) -> int const &"}, + { "intArray___setitem__", (PyCFunction)(void(*)(void))_wrap_intArray___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(intArray self, int i, int const v)"}, + { "intArray___getitem__", (PyCFunction)(void(*)(void))_wrap_intArray___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(intArray self, int const i) -> int const &"}, { "intArray_Assign", _wrap_intArray_Assign, METH_VARARGS, "\n" "Assign(intArray self, int const * arg2)\n" "Assign(intArray self, int const & a)\n" @@ -12280,7 +11222,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "doubleArray_UseDevice", _wrap_doubleArray_UseDevice, METH_O, "UseDevice(doubleArray self) -> bool"}, { "doubleArray_OwnsData", _wrap_doubleArray_OwnsData, METH_O, "OwnsData(doubleArray self) -> bool"}, - { "doubleArray_StealData", _wrap_doubleArray_StealData, METH_VARARGS, "StealData(doubleArray self, double ** p)"}, + { "doubleArray_StealData", (PyCFunction)(void(*)(void))_wrap_doubleArray_StealData, METH_VARARGS|METH_KEYWORDS, "StealData(doubleArray self, double ** p)"}, { "doubleArray_LoseData", _wrap_doubleArray_LoseData, METH_O, "LoseData(doubleArray self)"}, { "doubleArray_MakeDataOwner", _wrap_doubleArray_MakeDataOwner, METH_O, "MakeDataOwner(doubleArray self)"}, { "doubleArray_Size", _wrap_doubleArray_Size, METH_O, "Size(doubleArray self) -> int"}, @@ -12290,29 +11232,29 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(doubleArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "doubleArray_Capacity", _wrap_doubleArray_Capacity, METH_O, "Capacity(doubleArray self) -> int"}, - { "doubleArray_Reserve", _wrap_doubleArray_Reserve, METH_VARARGS, "Reserve(doubleArray self, int capacity)"}, + { "doubleArray_Reserve", (PyCFunction)(void(*)(void))_wrap_doubleArray_Reserve, METH_VARARGS|METH_KEYWORDS, "Reserve(doubleArray self, int capacity)"}, { "doubleArray_Append", _wrap_doubleArray_Append, METH_VARARGS, "\n" "Append(doubleArray self, double const & el) -> int\n" "Append(doubleArray self, double const * els, int nels) -> int\n" "Append(doubleArray self, doubleArray els) -> int\n" ""}, - { "doubleArray_Prepend", _wrap_doubleArray_Prepend, METH_VARARGS, "Prepend(doubleArray self, double const & el) -> int"}, + { "doubleArray_Prepend", (PyCFunction)(void(*)(void))_wrap_doubleArray_Prepend, METH_VARARGS|METH_KEYWORDS, "Prepend(doubleArray self, double const & el) -> int"}, { "doubleArray_Last", _wrap_doubleArray_Last, METH_VARARGS, "\n" "Last(doubleArray self) -> double\n" "Last(doubleArray self) -> double const &\n" ""}, - { "doubleArray_Union", _wrap_doubleArray_Union, METH_VARARGS, "Union(doubleArray self, double const & el) -> int"}, - { "doubleArray_Find", _wrap_doubleArray_Find, METH_VARARGS, "Find(doubleArray self, double const & el) -> int"}, - { "doubleArray_FindSorted", _wrap_doubleArray_FindSorted, METH_VARARGS, "FindSorted(doubleArray self, double const & el) -> int"}, + { "doubleArray_Union", (PyCFunction)(void(*)(void))_wrap_doubleArray_Union, METH_VARARGS|METH_KEYWORDS, "Union(doubleArray self, double const & el) -> int"}, + { "doubleArray_Find", (PyCFunction)(void(*)(void))_wrap_doubleArray_Find, METH_VARARGS|METH_KEYWORDS, "Find(doubleArray self, double const & el) -> int"}, + { "doubleArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_doubleArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "FindSorted(doubleArray self, double const & el) -> int"}, { "doubleArray_DeleteLast", _wrap_doubleArray_DeleteLast, METH_O, "DeleteLast(doubleArray self)"}, - { "doubleArray_DeleteFirst", _wrap_doubleArray_DeleteFirst, METH_VARARGS, "DeleteFirst(doubleArray self, double const & el)"}, + { "doubleArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_doubleArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "DeleteFirst(doubleArray self, double const & el)"}, { "doubleArray_DeleteAll", _wrap_doubleArray_DeleteAll, METH_O, "DeleteAll(doubleArray self)"}, - { "doubleArray_Copy", _wrap_doubleArray_Copy, METH_VARARGS, "Copy(doubleArray self, doubleArray copy)"}, + { "doubleArray_Copy", (PyCFunction)(void(*)(void))_wrap_doubleArray_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(doubleArray self, doubleArray copy)"}, { "doubleArray_MakeRef", _wrap_doubleArray_MakeRef, METH_VARARGS, "\n" "MakeRef(doubleArray self, double * arg2, int arg3)\n" "MakeRef(doubleArray self, doubleArray master)\n" ""}, - { "doubleArray_GetSubArray", _wrap_doubleArray_GetSubArray, METH_VARARGS, "GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, + { "doubleArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_doubleArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, { "doubleArray_Load", _wrap_doubleArray_Load, METH_VARARGS, "\n" "Load(doubleArray self, std::istream & _in, int fmt=0)\n" "Load(doubleArray self, int new_size, std::istream & _in)\n" @@ -12333,14 +11275,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "end(doubleArray self) -> double const *\n" ""}, { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "MemoryUsage(doubleArray self) -> long"}, - { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "Read(doubleArray self, bool on_dev=True) -> double const"}, + { "doubleArray_Read", (PyCFunction)(void(*)(void))_wrap_doubleArray_Read, METH_VARARGS|METH_KEYWORDS, "Read(doubleArray self, bool on_dev=True) -> double const *"}, { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "HostRead(doubleArray self) -> double const *"}, - { "doubleArray_Write", _wrap_doubleArray_Write, METH_VARARGS, "Write(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_Write", (PyCFunction)(void(*)(void))_wrap_doubleArray_Write, METH_VARARGS|METH_KEYWORDS, "Write(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostWrite", _wrap_doubleArray_HostWrite, METH_O, "HostWrite(doubleArray self) -> double *"}, - { "doubleArray_ReadWrite", _wrap_doubleArray_ReadWrite, METH_VARARGS, "ReadWrite(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_doubleArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostReadWrite", _wrap_doubleArray_HostReadWrite, METH_O, "HostReadWrite(doubleArray self) -> double *"}, - { "doubleArray___setitem__", _wrap_doubleArray___setitem__, METH_VARARGS, "__setitem__(doubleArray self, int i, double const v)"}, - { "doubleArray___getitem__", _wrap_doubleArray___getitem__, METH_VARARGS, "__getitem__(doubleArray self, int const i) -> double const &"}, + { "doubleArray___setitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(doubleArray self, int i, double const v)"}, + { "doubleArray___getitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(doubleArray self, int const i) -> double const &"}, { "doubleArray_Assign", _wrap_doubleArray_Assign, METH_VARARGS, "\n" "Assign(doubleArray self, double const * arg2)\n" "Assign(doubleArray self, double const & a)\n" diff --git a/mfem/_par/bilinearform_wrap.cxx b/mfem/_par/bilinearform_wrap.cxx index f16ff660..3188510a 100644 --- a/mfem/_par/bilinearform_wrap.cxx +++ b/mfem/_par/bilinearform_wrap.cxx @@ -4024,7 +4024,7 @@ void SwigDirector_BilinearForm::AddMult(mfem::Vector const &x, mfem::Vector &y, Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 16; + const size_t swig_method_index = 14; const char *const swig_method_name = "AddMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4054,7 +4054,7 @@ void SwigDirector_BilinearForm::AddMultTranspose(mfem::Vector const &x, mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 18; + const size_t swig_method_index = 15; const char *const swig_method_name = "AddMultTranspose"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4092,7 +4092,7 @@ void SwigDirector_BilinearForm::FormLinearSystem(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 21; + const size_t swig_method_index = 16; const char *const swig_method_name = "FormLinearSystem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL); @@ -4120,7 +4120,7 @@ void SwigDirector_BilinearForm::FormSystemMatrix(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 23; + const size_t swig_method_index = 17; const char *const swig_method_name = "FormSystemMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -4146,7 +4146,7 @@ void SwigDirector_BilinearForm::Update(mfem::FiniteElementSpace *nfes) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 24; + const size_t swig_method_index = 18; const char *const swig_method_name = "Update"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4236,14 +4236,14 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(sel PyObject *arg1 = (PyObject *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; mfem::BilinearForm *arg3 = (mfem::BilinearForm *) 0 ; - int arg4 ; + int arg4 = (int) 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; mfem::BilinearForm *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { @@ -4255,11 +4255,13 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BilinearForm" "', argument " "3"" of type '" "mfem::BilinearForm *""'"); } arg3 = reinterpret_cast< mfem::BilinearForm * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { @@ -4281,49 +4283,6 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - mfem::BilinearForm *arg3 = (mfem::BilinearForm *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::BilinearForm *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BilinearForm" "', argument " "3"" of type '" "mfem::BilinearForm *""'"); - } - arg3 = reinterpret_cast< mfem::BilinearForm * >(argp3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::BilinearForm *)new SwigDirector_BilinearForm(arg1,arg2,arg3); - } else { - result = (mfem::BilinearForm *)new mfem::BilinearForm(arg2,arg3); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { @@ -4351,24 +4310,7 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BilinearForm__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -4380,6 +4322,9 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_new_BilinearForm__SWIG_2(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4401,8 +4346,7 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::BilinearForm()\n" " mfem::BilinearForm::BilinearForm(mfem::FiniteElementSpace *)\n" - " mfem::BilinearForm::BilinearForm(mfem::FiniteElementSpace *,mfem::BilinearForm *,int)\n" - " mfem::BilinearForm::BilinearForm(PyObject *,mfem::FiniteElementSpace *,mfem::BilinearForm *)\n"); + " mfem::BilinearForm::BilinearForm(PyObject *,mfem::FiniteElementSpace *,mfem::BilinearForm *,int)\n"); return 0; } @@ -4437,7 +4381,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Size(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::AssemblyLevel arg2 ; @@ -4445,15 +4389,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPAR int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"assembly_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_SetAssemblyLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); } @@ -4592,7 +4540,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SCFESpace(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -4606,25 +4554,31 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"constr_space", (char *)"constr_integ", (char *)"ess_tdof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EnableHybridization", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearForm_EnableHybridization", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EnableHybridization" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EnableHybridization" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EnableHybridization" "', argument " "3"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg3 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EnableHybridization" "', argument " "4"" of type '" "mfem::Array< int > const &""'"); } @@ -4647,55 +4601,35 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ps", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_UsePrecomputedSparsity", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_UsePrecomputedSparsity" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->UsePrecomputedSparsity(arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_UsePrecomputedSparsity" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - (arg1)->UsePrecomputedSparsity(); + (arg1)->UsePrecomputedSparsity(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4708,52 +4642,6 @@ SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_UsePrecomputedSparsity", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_UsePrecomputedSparsity__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_UsePrecomputedSparsity__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_UsePrecomputedSparsity'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::UsePrecomputedSparsity(int)\n" - " mfem::BilinearForm::UsePrecomputedSparsity()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BilinearForm_UseSparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -5109,33 +4997,38 @@ SWIGINTERN PyObject *_wrap_BilinearForm_GetBFBFI_Marker(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BilinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm___call__" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5342,7 +5235,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Elem(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5353,17 +5246,22 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Mult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5371,7 +5269,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5380,7 +5278,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5404,7 +5302,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5415,15 +5313,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5431,7 +5334,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5454,12 +5357,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5468,16 +5371,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BilinearForm_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5485,7 +5395,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5493,13 +5403,15 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5523,51 +5435,123 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullAddMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullAddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::BilinearForm const *)arg1)->FullAddMult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BilinearForm_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { if (upcall) { - ((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::AddMult((mfem::Vector const &)*arg2,*arg3); + ((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } else { - ((mfem::BilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); + ((mfem::BilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } } catch (Swig::DirectorException &e) { @@ -5584,326 +5568,31 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BilinearForm_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 +SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BilinearForm_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullAddMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullAddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::BilinearForm const *)arg1)->FullAddMult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - ((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } else { - ((mfem::BilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - ((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::AddMultTranspose((mfem::Vector const &)*arg2,*arg3); - } else { - ((mfem::BilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullAddMultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullAddMultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5911,7 +5600,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5934,7 +5623,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5945,17 +5634,22 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5963,7 +5657,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5972,7 +5666,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5996,7 +5690,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6007,16 +5701,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_InnerProduct", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_InnerProduct", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_InnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6024,7 +5723,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_InnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -6092,75 +5791,43 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_Finalize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Finalize" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { + if (obj1) { { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Finalize(arg2); - } else { - (arg1)->Finalize(arg2); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - } catch (Swig::DirectorException&) { - SWIG_fail; } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Finalize" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { if (upcall) { - (arg1)->mfem::BilinearForm::Finalize(); + (arg1)->mfem::BilinearForm::Finalize(arg2); } else { - (arg1)->Finalize(); + (arg1)->Finalize(arg2); } } catch (Swig::DirectorException &e) { @@ -6177,52 +5844,6 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_BilinearForm_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Finalize", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_Finalize__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_Finalize__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Finalize(int)\n" - " mfem::BilinearForm::Finalize()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BilinearForm_SpMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -6437,7 +6058,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SpMatElim(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_BilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -6445,15 +6066,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSED int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -6605,7 +6230,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddBoundaryIntegrator(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_BilinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -6613,15 +6238,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddInteriorFaceIntegrator(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AddInteriorFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_AddInteriorFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddInteriorFaceIntegrator" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddInteriorFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -6698,130 +6327,18 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddBdrFaceIntegrator__SWIG_1(PyObject *S if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddBdrFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddBdrFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddBdrFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - (arg1)->AddBdrFaceIntegrator(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AddBdrFaceIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AddBdrFaceIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AddBdrFaceIntegrator__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AddBdrFaceIntegrator__SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AddBdrFaceIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AddBdrFaceIntegrator(mfem::BilinearFormIntegrator *)\n" - " mfem::BilinearForm::AddBdrFaceIntegrator(mfem::BilinearFormIntegrator *,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Assemble" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Assemble(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Assemble" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddBdrFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddBdrFaceIntegrator" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->Assemble(); + (arg1)->AddBdrFaceIntegrator(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6834,53 +6351,99 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_BilinearForm_Assemble(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddBdrFaceIntegrator(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Assemble", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AddBdrFaceIntegrator", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_Assemble__SWIG_1(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AddBdrFaceIntegrator__SWIG_0(self, argc, argv); + } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_Assemble__SWIG_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_BilinearForm_AddBdrFaceIntegrator__SWIG_1(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Assemble'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AddBdrFaceIntegrator'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Assemble(int)\n" - " mfem::BilinearForm::Assemble()\n"); + " mfem::BilinearForm::AddBdrFaceIntegrator(mfem::BilinearFormIntegrator *)\n" + " mfem::BilinearForm::AddBdrFaceIntegrator(mfem::BilinearFormIntegrator *,mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_Assemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + int arg2 = (int) 1 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_Assemble", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Assemble" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } + { + try { + (arg1)->Assemble(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6888,15 +6451,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleDiagonal", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_AssembleDiagonal", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7108,7 +6675,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU mfem::OperatorHandle *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7126,7 +6693,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -7180,126 +6747,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { + if (swig_obj[7]) { { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); - } else { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::OperatorHandle *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__OperatorHandle, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - arg5 = reinterpret_cast< mfem::OperatorHandle * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearForm::FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->mfem::BilinearForm::FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } else { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } } catch (Swig::DirectorException &e) { @@ -7377,7 +6841,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_0(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7391,17 +6855,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDP int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"X", (char *)"b", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_RecoverFEMSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearForm_RecoverFEMSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7409,7 +6879,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -7417,7 +6887,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7426,7 +6896,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDP } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -7461,87 +6931,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrices(PyObject *SWIGUNU swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeElementMatrices" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - try { - (arg1)->ComputeElementMatrices(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FreeElementMatrices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FreeElementMatrices" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - try { - (arg1)->FreeElementMatrices(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_ComputeElementMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeElementMatrices" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - (arg1)->ComputeElementMatrix(arg2,*arg3); + (arg1)->ComputeElementMatrices(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7554,40 +6949,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_FreeElementMatrices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FreeElementMatrices" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->ComputeBdrElementMatrix(arg2,*arg3); + (arg1)->FreeElementMatrices(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7600,46 +6978,45 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_ComputeElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); + (arg1)->ComputeElementMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7652,7 +7029,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; @@ -7661,30 +7038,36 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_ComputeBdrElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); + (arg1)->ComputeBdrElementMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7697,21 +7080,18 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - int arg5 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -7731,23 +7111,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7760,12 +7134,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; mfem::Array< int > *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -7773,7 +7148,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject * void *argp4 = 0 ; int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -7801,9 +7176,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7824,30 +7207,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, Py if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleElementMatrix", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -7865,34 +7225,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, Py int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); + if (argc <= 3) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -7908,7 +7243,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, Py } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -7917,159 +7252,60 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, Py { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - int arg5 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8089,23 +7325,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8118,12 +7348,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; mfem::Array< int > *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -8131,7 +7362,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObjec void *argp4 = 0 ; int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8159,9 +7390,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8182,7 +7421,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleBdrElementMatrix", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -8200,57 +7439,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); + if (argc <= 3) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8266,7 +7457,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -8288,6 +7479,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8297,7 +7491,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, } } if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); } } } @@ -8309,9 +7503,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleBdrElementMatrix'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n"); return 0; } @@ -8322,7 +7514,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *S mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8334,7 +7526,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *S int val5 ; int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8364,11 +7556,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); @@ -8388,67 +7582,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *S PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8456,7 +7590,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *S int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8470,52 +7604,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8536,61 +7634,29 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBC", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); - } + } + if (_v) { + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -8606,6 +7672,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); @@ -8623,14 +7692,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBC'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8641,15 +7708,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGU int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCDiag", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_EliminateEssentialBCDiag", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -8657,7 +7729,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "3"" of type '" "double""'"); } @@ -8683,7 +7755,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8695,7 +7767,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU int val5 ; int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8725,11 +7797,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); @@ -8749,67 +7823,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNU PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8817,7 +7831,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8831,52 +7845,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8897,20 +7875,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofs", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -8919,39 +7884,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); - } + return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -8967,6 +7913,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_EliminateVDofs__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); @@ -8984,9 +7933,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateVDofs'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n"); return 0; } @@ -8997,7 +7944,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9009,72 +7956,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO int val5 ; int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); - { - try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -9104,55 +7986,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9165,16 +8008,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -9188,9 +8034,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); + } { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9211,20 +8064,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofs", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -9233,39 +8073,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); - } + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -9281,6 +8102,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); @@ -9298,14 +8122,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBCFromDofs'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9316,15 +8138,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_dofs", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofsDiag", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_EliminateEssentialBCFromDofsDiag", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9332,7 +8159,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "3"" of type '" "double""'"); } @@ -9352,7 +8179,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9366,15 +8193,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdofs", (char *)"x", (char *)"b", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofsInRHS", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearForm_EliminateVDofsInRHS", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9382,7 +8215,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9390,7 +8223,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9413,7 +8246,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9424,16 +8257,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullInnerProduct", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullInnerProduct", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullInnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9441,7 +8279,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9464,30 +8302,37 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nfes", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_Update", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9511,86 +8356,6 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Update(); - } else { - (arg1)->Update(); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Update", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_Update__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_Update__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Update'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Update(mfem::FiniteElementSpace *)\n" - " mfem::BilinearForm::Update()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BilinearForm_GetFES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -9713,7 +8478,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FESpace(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Matrix::DiagonalPolicy arg2 ; @@ -9721,15 +8486,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"policy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetDiagonalPolicy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_SetDiagonalPolicy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "2"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } @@ -9769,132 +8538,32 @@ SWIGINTERN PyObject *_wrap_BilinearForm_UseExternalIntegrators(PyObject *SWIGUNU } catch (Swig::DirectorException &e) { SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::SparseMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } + arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9907,7 +8576,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9916,6 +8585,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGU mfem::SparseMatrix *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9931,7 +8601,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGU void *argp7 = 0 ; int res7 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -9985,9 +8655,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); + if (swig_obj[7]) { + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + } { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10049,107 +8727,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_2(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::HypreParMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::HypreParMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -10158,6 +8736,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_7(PyObject *SWIGU mfem::HypreParMatrix *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10173,7 +8752,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_7(PyObject *SWIGU void *argp7 = 0 ; int res7 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -10222,149 +8801,43 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_7(PyObject *SWIGU res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_7(self, argc, argv); - } - } - } - } - } - } + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + if (swig_obj[7]) { + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + } + { + try { + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::HypreParMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (argc == 8) { + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; + --argc; + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -10393,6 +8866,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 7) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10412,7 +8888,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec } } } - if (argc == 8) { + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -10430,7 +8906,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; @@ -10441,6 +8917,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 7) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_2(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10450,7 +8929,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec } } if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_6(self, argc, argv); + return _wrap_BilinearForm_FormLinearSystem__SWIG_2(self, argc, argv); } } } @@ -10460,7 +8939,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec } } } - if (argc == 8) { + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -10478,7 +8957,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; @@ -10489,6 +8968,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 7) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10498,7 +8980,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec } } if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); + return _wrap_BilinearForm_FormLinearSystem__SWIG_3(self, argc, argv); } } } @@ -10513,11 +8995,8 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormLinearSystem'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &)\n" " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &)\n"); + " mfem::BilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &,int)\n"); return 0; } @@ -10644,16 +9123,18 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_BilinearForm", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } @@ -10972,7 +9453,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10983,15 +9464,20 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Mult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -10999,7 +9485,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11022,12 +9508,12 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -11036,14 +9522,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSE int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:MixedBilinearForm_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11051,7 +9544,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11059,11 +9552,13 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); @@ -11079,7 +9574,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11090,124 +9585,20 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11215,7 +9606,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11238,12 +9629,12 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -11252,14 +9643,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject * int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:MixedBilinearForm_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11267,7 +9665,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11275,132 +9673,25 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } + ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; + return NULL; } @@ -11434,55 +9725,35 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MixedBilinearForm_Finalize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Finalize(arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->Finalize(); + (arg1)->Finalize(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11495,53 +9766,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Finalize", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Finalize(int)\n" - " mfem::MixedBilinearForm::Finalize()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; @@ -11549,15 +9774,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blocks", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_GetBlocks", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_GetBlocks", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); } @@ -11702,7 +9931,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_LoseMat(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -11710,15 +9939,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -11870,7 +10103,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *sel } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -11878,15 +10111,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SW int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddTraceFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_AddTraceFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -12218,7 +10455,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBTFBFI_Marker(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::AssemblyLevel arg2 ; @@ -12226,15 +10463,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUS int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"assembly_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_SetAssemblyLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); } @@ -12254,55 +10495,35 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MixedBilinearForm_Assemble", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Assemble(arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->Assemble(); + (arg1)->Assemble(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12315,52 +10536,6 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Assemble(int)\n" - " mfem::MixedBilinearForm::Assemble()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; @@ -12510,7 +10685,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; @@ -12519,129 +10694,36 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIG int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeElementMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_ComputeElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - (arg1)->ComputeElementMatrix(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - (arg1)->ComputeBdrElementMatrix(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); + (arg1)->ComputeElementMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12654,7 +10736,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; @@ -12663,30 +10745,36 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObj int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_ComputeBdrElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); + (arg1)->ComputeBdrElementMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12699,24 +10787,18 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - mfem::Array< int > *arg5 = 0 ; - int arg6 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -12736,31 +10818,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12773,13 +10841,14 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObj } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; mfem::Array< int > *arg4 = 0 ; mfem::Array< int > *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -12789,7 +10858,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObj void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -12825,9 +10894,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); } arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12848,30 +10925,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix(PyObject *sel if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleElementMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -12889,224 +10943,92 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix(PyObject *sel int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleElementMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); + } + } + } + } } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); + if ((argc >= 5) && (argc <= 6)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleElementMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - mfem::Array< int > *arg5 = 0 ; - int arg6 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -13126,31 +11048,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13163,13 +11071,14 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(Py } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; mfem::Array< int > *arg4 = 0 ; mfem::Array< int > *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -13179,7 +11088,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(Py void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -13215,9 +11124,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); } arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13238,30 +11155,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleBdrElementMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -13279,6 +11173,9 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -13294,40 +11191,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * } } } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { + if ((argc >= 5) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -13353,6 +11217,9 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 5) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -13362,7 +11229,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * } } if (_v) { - return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); } } } @@ -13375,14 +11242,12 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleBdrElementMatrix'.\n" " Possible C/C++ prototypes are:\n" " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" - " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -13396,15 +11261,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"sol", (char *)"rhs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTrialDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedBilinearForm_EliminateTrialDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13412,7 +11283,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -13420,7 +11291,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -13443,7 +11314,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -13457,15 +11328,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"marked_vdofs", (char *)"sol", (char *)"rhs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedBilinearForm_EliminateEssentialBCFromTrialDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13473,7 +11350,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -13481,7 +11358,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -13504,7 +11381,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -13512,15 +11389,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTestDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_EliminateTestDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13543,7 +11424,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -13557,15 +11438,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularSystemMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedBilinearForm_FormRectangularSystemMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13573,7 +11460,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -13581,7 +11468,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); } @@ -13604,7 +11491,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -13630,15 +11517,25 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:MixedBilinearForm_FormRectangularLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13646,7 +11543,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -13654,7 +11551,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -13662,7 +11559,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -13670,7 +11567,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); } @@ -13678,7 +11575,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); } arg6 = reinterpret_cast< mfem::OperatorHandle * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -13686,7 +11583,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -13962,7 +11859,7 @@ SWIGINTERN PyObject *MixedBilinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -13970,16 +11867,20 @@ SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"domain_fes", (char *)"range_fes", NULL + }; mfem::DiscreteLinearOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DiscreteLinearOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_DiscreteLinearOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscreteLinearOperator" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscreteLinearOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -13999,7 +11900,7 @@ SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; mfem::DiscreteInterpolator *arg2 = (mfem::DiscreteInterpolator *) 0 ; @@ -14007,15 +11908,19 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"di", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiscreteLinearOperator_AddDomainInterpolator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiscreteLinearOperator_AddDomainInterpolator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_AddDomainInterpolator" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteLinearOperator_AddDomainInterpolator" "', argument " "2"" of type '" "mfem::DiscreteInterpolator *""'"); } @@ -14035,7 +11940,7 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; mfem::DiscreteInterpolator *arg2 = (mfem::DiscreteInterpolator *) 0 ; @@ -14043,15 +11948,19 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator(PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"di", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiscreteLinearOperator_AddTraceFaceInterpolator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiscreteLinearOperator_AddTraceFaceInterpolator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_AddTraceFaceInterpolator" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteLinearOperator_AddTraceFaceInterpolator" "', argument " "2"" of type '" "mfem::DiscreteInterpolator *""'"); } @@ -14101,55 +12010,35 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_GetDI(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DiscreteLinearOperator_Assemble", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_Assemble" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Assemble(arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_Assemble" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } - arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); { try { - (arg1)->Assemble(); + (arg1)->Assemble(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14162,52 +12051,6 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiscreteLinearOperator_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiscreteLinearOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiscreteLinearOperator_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiscreteLinearOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DiscreteLinearOperator_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiscreteLinearOperator_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiscreteLinearOperator::Assemble(int)\n" - " mfem::DiscreteLinearOperator::Assemble()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; @@ -14254,16 +12097,16 @@ static PyMethodDef SwigMethods[] = { { "new_BilinearForm", _wrap_new_BilinearForm, METH_VARARGS, "\n" "BilinearForm()\n" "BilinearForm(FiniteElementSpace f)\n" - "BilinearForm(FiniteElementSpace f, BilinearForm bf, int ps=0)\n" + "new_BilinearForm(PyObject * _self, FiniteElementSpace f, BilinearForm bf, int ps=0) -> BilinearForm\n" ""}, { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "BilinearForm_Size(BilinearForm self) -> int"}, - { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "BilinearForm_SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "BilinearForm_SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "BilinearForm_GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "BilinearForm_EnableStaticCondensation(BilinearForm self)"}, { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "BilinearForm_StaticCondensationIsEnabled(BilinearForm self) -> bool"}, { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "BilinearForm_SCFESpace(BilinearForm self) -> FiniteElementSpace"}, - { "BilinearForm_EnableHybridization", _wrap_BilinearForm_EnableHybridization, METH_VARARGS, "BilinearForm_EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, - { "BilinearForm_UsePrecomputedSparsity", _wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS, "BilinearForm_UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, + { "BilinearForm_EnableHybridization", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EnableHybridization, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, + { "BilinearForm_UsePrecomputedSparsity", (PyCFunction)(void(*)(void))_wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS|METH_KEYWORDS, "BilinearForm_UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, { "BilinearForm_UseSparsity", _wrap_BilinearForm_UseSparsity, METH_VARARGS, "\n" "BilinearForm_UseSparsity(BilinearForm self, int * I, int * J, bool isSorted)\n" "BilinearForm_UseSparsity(BilinearForm self, SparseMatrix A)\n" @@ -14275,21 +12118,21 @@ static PyMethodDef SwigMethods[] = { { "BilinearForm_GetFBFI", _wrap_BilinearForm_GetFBFI, METH_O, "BilinearForm_GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI", _wrap_BilinearForm_GetBFBFI, METH_O, "BilinearForm_GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI_Marker", _wrap_BilinearForm_GetBFBFI_Marker, METH_O, "BilinearForm_GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "BilinearForm___call__", _wrap_BilinearForm___call__, METH_VARARGS, "BilinearForm___call__(BilinearForm self, int i, int j) -> double const &"}, + { "BilinearForm___call__", (PyCFunction)(void(*)(void))_wrap_BilinearForm___call__, METH_VARARGS|METH_KEYWORDS, "BilinearForm___call__(BilinearForm self, int i, int j) -> double const &"}, { "BilinearForm_Elem", _wrap_BilinearForm_Elem, METH_VARARGS, "\n" "BilinearForm_Elem(BilinearForm self, int i, int j) -> double\n" "BilinearForm_Elem(BilinearForm self, int i, int j) -> double const &\n" ""}, - { "BilinearForm_Mult", _wrap_BilinearForm_Mult, METH_VARARGS, "BilinearForm_Mult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_FullMult", _wrap_BilinearForm_FullMult, METH_VARARGS, "BilinearForm_FullMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMult", _wrap_BilinearForm_AddMult, METH_VARARGS, "BilinearForm_AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMult", _wrap_BilinearForm_FullAddMult, METH_VARARGS, "BilinearForm_FullAddMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMultTranspose", _wrap_BilinearForm_AddMultTranspose, METH_VARARGS, "BilinearForm_AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMultTranspose", _wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS, "BilinearForm_FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_MultTranspose", _wrap_BilinearForm_MultTranspose, METH_VARARGS, "BilinearForm_MultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_InnerProduct", _wrap_BilinearForm_InnerProduct, METH_VARARGS, "BilinearForm_InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Mult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_FullMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullMult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullAddMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BilinearForm_MultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_InnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_InnerProduct, METH_VARARGS|METH_KEYWORDS, "BilinearForm_InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, { "BilinearForm_Inverse", _wrap_BilinearForm_Inverse, METH_O, "BilinearForm_Inverse(BilinearForm self) -> MatrixInverse"}, - { "BilinearForm_Finalize", _wrap_BilinearForm_Finalize, METH_VARARGS, "BilinearForm_Finalize(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Finalize(BilinearForm self, int skip_zeros=1)"}, { "BilinearForm_SpMat", _wrap_BilinearForm_SpMat, METH_VARARGS, "\n" "BilinearForm_SpMat(BilinearForm self) -> SparseMatrix\n" "BilinearForm_SpMat(BilinearForm self) -> SparseMatrix\n" @@ -14299,27 +12142,27 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_SpMatElim(BilinearForm self) -> SparseMatrix\n" "BilinearForm_SpMatElim(BilinearForm self) -> SparseMatrix\n" ""}, - { "BilinearForm_AddDomainIntegrator", _wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS, "BilinearForm_AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBoundaryIntegrator", _wrap_BilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "BilinearForm_AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "BilinearForm_AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_AddInteriorFaceIntegrator", _wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "BilinearForm_AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBdrFaceIntegrator", _wrap_BilinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "BilinearForm_AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "BilinearForm_AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "BilinearForm_Assemble(BilinearForm self, int skip_zeros=1)"}, - { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "BilinearForm_AssembleDiagonal(BilinearForm self, Vector diag)"}, + { "BilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AssembleDiagonal, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AssembleDiagonal(BilinearForm self, Vector diag)"}, { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "BilinearForm_GetProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "BilinearForm_GetRestriction(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "BilinearForm_GetOutputProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "BilinearForm_GetOutputRestriction(BilinearForm self) -> Operator"}, - { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "BilinearForm_RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, + { "BilinearForm_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "BilinearForm_RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "BilinearForm_ComputeElementMatrices(BilinearForm self)"}, { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "BilinearForm_FreeElementMatrices(BilinearForm self)"}, - { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "BilinearForm_ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, - { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "BilinearForm_ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "BilinearForm_ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "BilinearForm_ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" @@ -14332,7 +12175,7 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCDiag", _wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS, "BilinearForm_EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, + { "BilinearForm_EliminateEssentialBCDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, { "BilinearForm_EliminateVDofs", _wrap_BilinearForm_EliminateVDofs, METH_VARARGS, "\n" "BilinearForm_EliminateVDofs(BilinearForm self, intArray vdofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" @@ -14341,16 +12184,16 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCFromDofsDiag", _wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS, "BilinearForm_EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, - { "BilinearForm_EliminateVDofsInRHS", _wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS, "BilinearForm_EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, - { "BilinearForm_FullInnerProduct", _wrap_BilinearForm_FullInnerProduct, METH_VARARGS, "BilinearForm_FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, - { "BilinearForm_Update", _wrap_BilinearForm_Update, METH_VARARGS, "BilinearForm_Update(BilinearForm self, FiniteElementSpace nfes=None)"}, + { "BilinearForm_EliminateEssentialBCFromDofsDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, + { "BilinearForm_EliminateVDofsInRHS", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, + { "BilinearForm_FullInnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullInnerProduct, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Update", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Update, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Update(BilinearForm self, FiniteElementSpace nfes=None)"}, { "BilinearForm_GetFES", _wrap_BilinearForm_GetFES, METH_O, "BilinearForm_GetFES(BilinearForm self) -> FiniteElementSpace"}, { "BilinearForm_FESpace", _wrap_BilinearForm_FESpace, METH_VARARGS, "\n" "BilinearForm_FESpace(BilinearForm self) -> FiniteElementSpace\n" "BilinearForm_FESpace(BilinearForm self) -> FiniteElementSpace\n" ""}, - { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "BilinearForm_SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_SetDiagonalPolicy", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS|METH_KEYWORDS, "BilinearForm_SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "BilinearForm_UseExternalIntegrators(BilinearForm self)"}, { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" @@ -14363,7 +12206,7 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, HypreParMatrix A)\n" ""}, - { "disown_BilinearForm", _wrap_disown_BilinearForm, METH_O, NULL}, + { "disown_BilinearForm", (PyCFunction)(void(*)(void))_wrap_disown_BilinearForm, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearForm_swigregister", BilinearForm_swigregister, METH_O, NULL}, { "BilinearForm_swiginit", BilinearForm_swiginit, METH_VARARGS, NULL}, { "new_MixedBilinearForm", _wrap_new_MixedBilinearForm, METH_VARARGS, "\n" @@ -14374,24 +12217,24 @@ static PyMethodDef SwigMethods[] = { "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double\n" "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double const &\n" ""}, - { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "MixedBilinearForm_Mult(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "MixedBilinearForm_AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MixedBilinearForm_MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_Mult(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "MixedBilinearForm_Inverse(MixedBilinearForm self) -> MatrixInverse"}, - { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "MixedBilinearForm_Finalize(MixedBilinearForm self, int skip_zeros=1)"}, - { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "MixedBilinearForm_GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "MixedBilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_Finalize(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetBlocks", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_GetBlocks, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, { "MixedBilinearForm_SpMat", _wrap_MixedBilinearForm_SpMat, METH_VARARGS, "\n" "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" ""}, { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "MixedBilinearForm_LoseMat(MixedBilinearForm self) -> SparseMatrix"}, - { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "MixedBilinearForm_AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "MixedBilinearForm_AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddTraceFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" @@ -14402,15 +12245,15 @@ static PyMethodDef SwigMethods[] = { { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "MixedBilinearForm_GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "MixedBilinearForm_GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "MixedBilinearForm_GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "MixedBilinearForm_SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, - { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "MixedBilinearForm_Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "MixedBilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_Assemble(MixedBilinearForm self, int skip_zeros=1)"}, { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "MixedBilinearForm_GetProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "MixedBilinearForm_GetRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "MixedBilinearForm_GetOutputProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "MixedBilinearForm_GetOutputRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "MixedBilinearForm_ConformingAssemble(MixedBilinearForm self)"}, - { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, - { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" @@ -14419,11 +12262,11 @@ static PyMethodDef SwigMethods[] = { "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" ""}, - { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "MixedBilinearForm_EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, - { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "MixedBilinearForm_FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, - { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "MixedBilinearForm_FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "MixedBilinearForm_EliminateTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateTestDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "MixedBilinearForm_Update(MixedBilinearForm self)"}, { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" "MixedBilinearForm_TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" @@ -14436,11 +12279,11 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, - { "new_DiscreteLinearOperator", _wrap_new_DiscreteLinearOperator, METH_VARARGS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, - { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, - { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "new_DiscreteLinearOperator", (PyCFunction)(void(*)(void))_wrap_new_DiscreteLinearOperator, METH_VARARGS|METH_KEYWORDS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, + { "DiscreteLinearOperator_AddDomainInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS|METH_KEYWORDS, "DiscreteLinearOperator_AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_AddTraceFaceInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS|METH_KEYWORDS, "DiscreteLinearOperator_AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "DiscreteLinearOperator_GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "DiscreteLinearOperator_Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, + { "DiscreteLinearOperator_Assemble", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_Assemble, METH_VARARGS|METH_KEYWORDS, "DiscreteLinearOperator_Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, { "delete_DiscreteLinearOperator", _wrap_delete_DiscreteLinearOperator, METH_O, "delete_DiscreteLinearOperator(DiscreteLinearOperator self)"}, { "DiscreteLinearOperator_swigregister", DiscreteLinearOperator_swigregister, METH_O, NULL}, { "DiscreteLinearOperator_swiginit", DiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, @@ -14453,16 +12296,16 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "new_BilinearForm", _wrap_new_BilinearForm, METH_VARARGS, "\n" "BilinearForm()\n" "BilinearForm(FiniteElementSpace f)\n" - "BilinearForm(FiniteElementSpace f, BilinearForm bf, int ps=0)\n" + "new_BilinearForm(PyObject * _self, FiniteElementSpace f, BilinearForm bf, int ps=0) -> BilinearForm\n" ""}, { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "Size(BilinearForm self) -> int"}, - { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "EnableStaticCondensation(BilinearForm self)"}, { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "StaticCondensationIsEnabled(BilinearForm self) -> bool"}, { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "SCFESpace(BilinearForm self) -> FiniteElementSpace"}, - { "BilinearForm_EnableHybridization", _wrap_BilinearForm_EnableHybridization, METH_VARARGS, "EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, - { "BilinearForm_UsePrecomputedSparsity", _wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS, "UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, + { "BilinearForm_EnableHybridization", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EnableHybridization, METH_VARARGS|METH_KEYWORDS, "EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, + { "BilinearForm_UsePrecomputedSparsity", (PyCFunction)(void(*)(void))_wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS|METH_KEYWORDS, "UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, { "BilinearForm_UseSparsity", _wrap_BilinearForm_UseSparsity, METH_VARARGS, "\n" "UseSparsity(BilinearForm self, int * I, int * J, bool isSorted)\n" "UseSparsity(BilinearForm self, SparseMatrix A)\n" @@ -14474,21 +12317,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "BilinearForm_GetFBFI", _wrap_BilinearForm_GetFBFI, METH_O, "GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI", _wrap_BilinearForm_GetBFBFI, METH_O, "GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI_Marker", _wrap_BilinearForm_GetBFBFI_Marker, METH_O, "GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "BilinearForm___call__", _wrap_BilinearForm___call__, METH_VARARGS, "__call__(BilinearForm self, int i, int j) -> double const &"}, + { "BilinearForm___call__", (PyCFunction)(void(*)(void))_wrap_BilinearForm___call__, METH_VARARGS|METH_KEYWORDS, "__call__(BilinearForm self, int i, int j) -> double const &"}, { "BilinearForm_Elem", _wrap_BilinearForm_Elem, METH_VARARGS, "\n" "Elem(BilinearForm self, int i, int j) -> double\n" "Elem(BilinearForm self, int i, int j) -> double const &\n" ""}, - { "BilinearForm_Mult", _wrap_BilinearForm_Mult, METH_VARARGS, "Mult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_FullMult", _wrap_BilinearForm_FullMult, METH_VARARGS, "FullMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMult", _wrap_BilinearForm_AddMult, METH_VARARGS, "AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMult", _wrap_BilinearForm_FullAddMult, METH_VARARGS, "FullAddMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMultTranspose", _wrap_BilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMultTranspose", _wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS, "FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_MultTranspose", _wrap_BilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_InnerProduct", _wrap_BilinearForm_InnerProduct, METH_VARARGS, "InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_FullMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullMult, METH_VARARGS|METH_KEYWORDS, "FullMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMult, METH_VARARGS|METH_KEYWORDS, "FullAddMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS|METH_KEYWORDS, "FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_InnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_InnerProduct, METH_VARARGS|METH_KEYWORDS, "InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, { "BilinearForm_Inverse", _wrap_BilinearForm_Inverse, METH_O, "Inverse(BilinearForm self) -> MatrixInverse"}, - { "BilinearForm_Finalize", _wrap_BilinearForm_Finalize, METH_VARARGS, "Finalize(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(BilinearForm self, int skip_zeros=1)"}, { "BilinearForm_SpMat", _wrap_BilinearForm_SpMat, METH_VARARGS, "\n" "SpMat(BilinearForm self) -> SparseMatrix\n" "SpMat(BilinearForm self) -> SparseMatrix\n" @@ -14498,27 +12341,27 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SpMatElim(BilinearForm self) -> SparseMatrix\n" "SpMatElim(BilinearForm self) -> SparseMatrix\n" ""}, - { "BilinearForm_AddDomainIntegrator", _wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBoundaryIntegrator", _wrap_BilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_AddInteriorFaceIntegrator", _wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBdrFaceIntegrator", _wrap_BilinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "Assemble(BilinearForm self, int skip_zeros=1)"}, - { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "AssembleDiagonal(BilinearForm self, Vector diag)"}, + { "BilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AssembleDiagonal, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonal(BilinearForm self, Vector diag)"}, { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "GetProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "GetRestriction(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(BilinearForm self) -> Operator"}, - { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, + { "BilinearForm_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "ComputeElementMatrices(BilinearForm self)"}, { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "FreeElementMatrices(BilinearForm self)"}, - { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, - { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" @@ -14531,7 +12374,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCDiag", _wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS, "EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, + { "BilinearForm_EliminateEssentialBCDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS|METH_KEYWORDS, "EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, { "BilinearForm_EliminateVDofs", _wrap_BilinearForm_EliminateVDofs, METH_VARARGS, "\n" "EliminateVDofs(BilinearForm self, intArray vdofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" @@ -14540,16 +12383,16 @@ static PyMethodDef SwigMethods_proxydocs[] = { "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCFromDofsDiag", _wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS, "EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, - { "BilinearForm_EliminateVDofsInRHS", _wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS, "EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, - { "BilinearForm_FullInnerProduct", _wrap_BilinearForm_FullInnerProduct, METH_VARARGS, "FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, - { "BilinearForm_Update", _wrap_BilinearForm_Update, METH_VARARGS, "Update(BilinearForm self, FiniteElementSpace nfes=None)"}, + { "BilinearForm_EliminateEssentialBCFromDofsDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS|METH_KEYWORDS, "EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, + { "BilinearForm_EliminateVDofsInRHS", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS|METH_KEYWORDS, "EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, + { "BilinearForm_FullInnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullInnerProduct, METH_VARARGS|METH_KEYWORDS, "FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Update", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Update, METH_VARARGS|METH_KEYWORDS, "Update(BilinearForm self, FiniteElementSpace nfes=None)"}, { "BilinearForm_GetFES", _wrap_BilinearForm_GetFES, METH_O, "GetFES(BilinearForm self) -> FiniteElementSpace"}, { "BilinearForm_FESpace", _wrap_BilinearForm_FESpace, METH_VARARGS, "\n" "FESpace(BilinearForm self) -> FiniteElementSpace\n" "FESpace(BilinearForm self) -> FiniteElementSpace\n" ""}, - { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_SetDiagonalPolicy", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS|METH_KEYWORDS, "SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "UseExternalIntegrators(BilinearForm self)"}, { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" @@ -14562,7 +12405,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, HypreParMatrix A)\n" ""}, - { "disown_BilinearForm", _wrap_disown_BilinearForm, METH_O, NULL}, + { "disown_BilinearForm", (PyCFunction)(void(*)(void))_wrap_disown_BilinearForm, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearForm_swigregister", BilinearForm_swigregister, METH_O, NULL}, { "BilinearForm_swiginit", BilinearForm_swiginit, METH_VARARGS, NULL}, { "new_MixedBilinearForm", _wrap_new_MixedBilinearForm, METH_VARARGS, "\n" @@ -14573,24 +12416,24 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Elem(MixedBilinearForm self, int i, int j) -> double\n" "Elem(MixedBilinearForm self, int i, int j) -> double const &\n" ""}, - { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "Mult(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "Inverse(MixedBilinearForm self) -> MatrixInverse"}, - { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "Finalize(MixedBilinearForm self, int skip_zeros=1)"}, - { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "MixedBilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetBlocks", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_GetBlocks, METH_VARARGS|METH_KEYWORDS, "GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, { "MixedBilinearForm_SpMat", _wrap_MixedBilinearForm_SpMat, METH_VARARGS, "\n" "SpMat(MixedBilinearForm self) -> SparseMatrix\n" "SpMat(MixedBilinearForm self) -> SparseMatrix\n" ""}, { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "LoseMat(MixedBilinearForm self) -> SparseMatrix"}, - { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddTraceFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" @@ -14601,15 +12444,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, - { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "MixedBilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "Assemble(MixedBilinearForm self, int skip_zeros=1)"}, { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "GetProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "GetRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "ConformingAssemble(MixedBilinearForm self)"}, - { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, - { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" @@ -14618,11 +12461,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" ""}, - { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, - { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, - { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "MixedBilinearForm_EliminateTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS|METH_KEYWORDS, "EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS|METH_KEYWORDS, "EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateTestDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS|METH_KEYWORDS, "EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS|METH_KEYWORDS, "FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "Update(MixedBilinearForm self)"}, { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" "TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" @@ -14635,11 +12478,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, - { "new_DiscreteLinearOperator", _wrap_new_DiscreteLinearOperator, METH_VARARGS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, - { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, - { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "new_DiscreteLinearOperator", (PyCFunction)(void(*)(void))_wrap_new_DiscreteLinearOperator, METH_VARARGS|METH_KEYWORDS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, + { "DiscreteLinearOperator_AddDomainInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS|METH_KEYWORDS, "AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_AddTraceFaceInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS|METH_KEYWORDS, "AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, + { "DiscreteLinearOperator_Assemble", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_Assemble, METH_VARARGS|METH_KEYWORDS, "Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, { "delete_DiscreteLinearOperator", _wrap_delete_DiscreteLinearOperator, METH_O, "delete_DiscreteLinearOperator(DiscreteLinearOperator self)"}, { "DiscreteLinearOperator_swigregister", DiscreteLinearOperator_swigregister, METH_O, NULL}, { "DiscreteLinearOperator_swiginit", DiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/bilinearform_wrap.h b/mfem/_par/bilinearform_wrap.h index 84555a81..5336778a 100644 --- a/mfem/_par/bilinearform_wrap.h +++ b/mfem/_par/bilinearform_wrap.h @@ -71,7 +71,7 @@ class SwigDirector_BilinearForm : public mfem::BilinearForm, public Swig::Direct return method; } private: - mutable swig::SwigVar_PyObject vtable[26]; + mutable swig::SwigVar_PyObject vtable[19]; #endif }; diff --git a/mfem/_par/bilininteg_wrap.cxx b/mfem/_par/bilininteg_wrap.cxx index 77b9181f..513fd8ad 100644 --- a/mfem/_par/bilininteg_wrap.cxx +++ b/mfem/_par/bilininteg_wrap.cxx @@ -4129,7 +4129,7 @@ double SwigDirector_BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElemen Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 16; + const size_t swig_method_index = 15; const char *const swig_method_name = "ComputeFluxEnergy"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -4161,54 +4161,33 @@ SwigDirector_BilinearFormIntegrator::~SwigDirector_BilinearFormIntegrator() { #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) NULL ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"ir", NULL + }; mfem::BilinearFormIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BilinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::BilinearFormIntegrator *)new SwigDirector_BilinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_BilinearFormIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + arg1 = obj0; + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BilinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::BilinearFormIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::BilinearFormIntegrator *)new SwigDirector_BilinearFormIntegrator(arg1); + result = (mfem::BilinearFormIntegrator *)new SwigDirector_BilinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -4225,43 +4204,6 @@ SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BilinearFormIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_BilinearFormIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - _v = (argv[0] != 0); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BilinearFormIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BilinearFormIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::BilinearFormIntegrator(mfem::IntegrationRule const *)\n" - " mfem::BilinearFormIntegrator::BilinearFormIntegrator(PyObject *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; @@ -4422,7 +4364,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -4430,17 +4372,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearFormIntegrator_AssemblePAInteriorFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -4449,7 +4395,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObje } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4473,7 +4419,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObje } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -4481,17 +4427,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearFormIntegrator_AssemblePABoundaryFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -4500,7 +4450,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObje } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4524,7 +4474,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObje } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4532,17 +4482,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearFormIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4551,7 +4505,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *S } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4575,7 +4529,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4586,17 +4540,22 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearFormIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4604,7 +4563,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4613,7 +4572,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4637,7 +4596,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4648,17 +4607,22 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearFormIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4666,7 +4630,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4675,7 +4639,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4699,7 +4663,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4713,17 +4677,23 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearFormIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4731,7 +4701,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4739,7 +4709,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -4748,7 +4718,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4772,7 +4742,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4789,17 +4759,24 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BilinearFormIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4807,7 +4784,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -4815,7 +4792,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -4823,7 +4800,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -4832,7 +4809,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5109,7 +5086,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix(PyObject *s } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5126,17 +5103,24 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BilinearFormIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5144,7 +5128,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5152,7 +5136,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -5160,7 +5144,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -5169,7 +5153,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject } arg5 = reinterpret_cast< mfem::Vector * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5193,7 +5177,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5210,17 +5194,24 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BilinearFormIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5228,7 +5219,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5236,7 +5227,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -5244,7 +5235,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -5253,7 +5244,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5277,7 +5268,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5297,17 +5288,25 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:BilinearFormIntegrator_AssembleFaceGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5315,7 +5314,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -5323,7 +5322,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -5331,7 +5330,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } @@ -5339,7 +5338,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } @@ -5348,7 +5347,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI } arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5372,7 +5371,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5380,7 +5379,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO mfem::Vector *arg4 = 0 ; mfem::FiniteElement *arg5 = 0 ; mfem::Vector *arg6 = 0 ; - bool arg7 ; + bool arg7 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5395,16 +5394,26 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO int res6 = 0 ; bool val7 ; int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:BilinearFormIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5412,7 +5421,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5420,7 +5429,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5428,7 +5437,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } @@ -5436,7 +5445,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -5444,13 +5453,15 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5474,14 +5485,13 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5492,66 +5502,64 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; Swig::Director *director = 0; bool upcall = false; + double result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:BilinearFormIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } else { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } } catch (Swig::DirectorException &e) { @@ -5561,363 +5569,54 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyO } catch (Swig::DirectorException&) { SWIG_fail; } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; +SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } + arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + { + try { + delete arg1; } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeElementFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" - " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_disown_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); - } else { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } else { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_disown_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_BilinearFormIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -5945,25 +5644,32 @@ SWIGINTERN PyObject *BilinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_bfi", (char *)"_own_bfi", NULL + }; mfem::TransposeIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_TransposeIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -5980,81 +5686,7 @@ SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::TransposeIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - try { - result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_TransposeIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_TransposeIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_TransposeIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TransposeIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6068,15 +5700,21 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TransposeIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6084,7 +5722,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6092,7 +5730,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6115,7 +5753,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6132,15 +5770,22 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:TransposeIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6148,7 +5793,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -6156,7 +5801,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -6164,7 +5809,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -6584,7 +6229,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePA(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -6592,15 +6237,19 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeIntegrator_AssemblePAInteriorFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -6623,7 +6272,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -6631,15 +6280,19 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeIntegrator_AssemblePABoundaryFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -6662,7 +6315,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6673,15 +6326,20 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6689,7 +6347,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6712,7 +6370,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6723,15 +6381,20 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6739,7 +6402,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6775,84 +6438,63 @@ SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(s if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeIntegrator" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *TransposeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TransposeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::LumpedIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); { try { - result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1,arg2); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *TransposeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TransposeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_LumpedIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_bfi", (char *)"_own_bfi", NULL + }; mfem::LumpedIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_LumpedIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } { try { - result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1); + result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6865,53 +6507,7 @@ SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_LumpedIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_LumpedIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_LumpedIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LumpedIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LumpedIntegrator *arg1 = (mfem::LumpedIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6925,15 +6521,21 @@ SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LumpedIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LumpedIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::LumpedIntegrator *""'"); } arg1 = reinterpret_cast< mfem::LumpedIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6941,7 +6543,7 @@ SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6949,7 +6551,7 @@ SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7012,57 +6614,36 @@ SWIGINTERN PyObject *LumpedIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_InverseIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"integ", (char *)"own_integ", NULL + }; mfem::InverseIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_InverseIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::InverseIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { try { - result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1); + result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7075,53 +6656,7 @@ SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_InverseIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_InverseIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_InverseIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseIntegrator *arg1 = (mfem::InverseIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7135,15 +6670,21 @@ SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:InverseIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::InverseIntegrator *""'"); } arg1 = reinterpret_cast< mfem::InverseIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7151,7 +6692,7 @@ SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7159,7 +6700,7 @@ SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7222,41 +6763,27 @@ SWIGINTERN PyObject *InverseIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SumIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 1 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"own_integs", NULL + }; mfem::SumIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SumIntegrator *)new mfem::SumIntegrator(arg1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_SumIntegrator", kwnames, &obj0)) SWIG_fail; + if (obj0) { + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::SumIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::SumIntegrator *)new mfem::SumIntegrator(); + result = (mfem::SumIntegrator *)new mfem::SumIntegrator(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7269,42 +6796,7 @@ SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_new_SumIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SumIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SumIntegrator__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SumIntegrator__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SumIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SumIntegrator::SumIntegrator(int)\n" - " mfem::SumIntegrator::SumIntegrator()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -7312,15 +6804,19 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"integ", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AddIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SumIntegrator_AddIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AddIntegrator" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); } arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AddIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -7340,7 +6836,7 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7354,15 +6850,21 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SumIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); } arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7370,7 +6872,7 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7378,7 +6880,7 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7441,7 +6943,7 @@ SWIGINTERN PyObject *SumIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7458,15 +6960,22 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MixedScalarIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7474,7 +6983,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -7482,7 +6991,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -7490,7 +6999,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -7513,7 +7022,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7527,15 +7036,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7543,7 +7058,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7551,7 +7066,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7610,7 +7125,7 @@ SWIGINTERN PyObject *MixedScalarIntegrator_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7627,15 +7142,22 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MixedVectorIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7643,7 +7165,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -7651,7 +7173,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -7659,7 +7181,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -7682,7 +7204,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7696,15 +7218,21 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedVectorIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7712,7 +7240,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7720,7 +7248,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7779,7 +7307,7 @@ SWIGINTERN PyObject *MixedVectorIntegrator_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarVectorIntegrator *arg1 = (mfem::MixedScalarVectorIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7796,15 +7324,22 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MixedScalarVectorIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarVectorIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarVectorIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7812,7 +7347,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -7820,7 +7355,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -7828,7 +7363,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -8008,17 +7543,19 @@ SWIGINTERN PyObject *MixedScalarMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedVectorProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedVectorProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -8444,17 +7981,19 @@ SWIGINTERN PyObject *MixedScalarDivergenceIntegrator_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedVectorDivergenceIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedVectorDivergenceIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -9083,17 +8622,19 @@ SWIGINTERN PyObject *MixedVectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -9156,17 +8697,19 @@ SWIGINTERN PyObject *MixedCrossProductIntegrator_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedDotProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedDotProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -9189,7 +8732,7 @@ SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -9200,16 +8743,21 @@ SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedDotProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedDotProductIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -9217,7 +8765,7 @@ SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -9310,17 +8858,19 @@ SWIGINTERN PyObject *MixedDotProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedWeakGradDotIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedWeakGradDotIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -9343,7 +8893,7 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -9354,16 +8904,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -9371,7 +8926,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -9424,7 +8979,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMe } -SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -9438,15 +8993,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedWeakGradDotIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -9454,7 +9015,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -9462,7 +9023,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9525,17 +9086,19 @@ SWIGINTERN PyObject *MixedWeakGradDotIntegrator_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedWeakDivCrossIntegrator *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedWeakDivCrossIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -9558,7 +9121,7 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -9569,16 +9132,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -9586,7 +9154,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -9639,7 +9207,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureM } -SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -9653,15 +9221,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedWeakDivCrossIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -9669,7 +9243,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -9677,7 +9251,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -9903,7 +9477,7 @@ SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -9914,16 +9488,21 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedGradGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -9931,7 +9510,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -9984,7 +9563,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessa } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -9998,16 +9577,22 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_GetIntegrationOrder", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradGradIntegrator_GetIntegrationOrder", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10015,7 +9600,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -10023,7 +9608,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -10046,7 +9631,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10060,15 +9645,21 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10076,7 +9667,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10084,7 +9675,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -10107,7 +9698,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10121,15 +9712,21 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10137,7 +9734,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10145,7 +9742,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -10208,17 +9805,19 @@ SWIGINTERN PyObject *MixedGradGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossGradGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossGradGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -10241,7 +9840,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10252,16 +9851,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10269,7 +9873,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -10322,7 +9926,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10336,15 +9940,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10352,7 +9962,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10360,7 +9970,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -10383,7 +9993,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10397,15 +10007,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10413,7 +10029,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10421,7 +10037,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -10647,7 +10263,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10658,16 +10274,21 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCurlCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10675,7 +10296,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -10728,7 +10349,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessa } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10742,15 +10363,21 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCurlCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10758,7 +10385,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10766,7 +10393,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -10789,7 +10416,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10803,15 +10430,21 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCurlCurlIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10819,7 +10452,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10827,7 +10460,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -10890,17 +10523,19 @@ SWIGINTERN PyObject *MixedCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossCurlCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossCurlCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -10923,7 +10558,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10934,16 +10569,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10951,7 +10591,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -11004,7 +10644,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11018,15 +10658,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11034,7 +10680,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11042,7 +10688,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11065,7 +10711,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11079,15 +10725,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlCurlIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11095,7 +10747,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11103,7 +10755,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11166,17 +10818,19 @@ SWIGINTERN PyObject *MixedCrossCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossCurlGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossCurlGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -11199,7 +10853,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11210,16 +10864,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11227,7 +10886,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -11280,7 +10939,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11294,15 +10953,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11310,7 +10975,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11318,7 +10983,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11341,7 +11006,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11355,15 +11020,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11371,7 +11042,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11379,7 +11050,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11442,17 +11113,19 @@ SWIGINTERN PyObject *MixedCrossCurlGradIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossGradCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossGradCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -11475,7 +11148,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11486,16 +11159,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11503,7 +11181,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -11556,7 +11234,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11570,15 +11248,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11586,7 +11270,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11594,7 +11278,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11617,7 +11301,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11631,15 +11315,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradCurlIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11647,7 +11337,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11655,7 +11345,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11718,17 +11408,19 @@ SWIGINTERN PyObject *MixedCrossGradCurlIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedWeakCurlCrossIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedWeakCurlCrossIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -11751,7 +11443,7 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11762,16 +11454,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11779,7 +11476,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -11832,7 +11529,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11846,15 +11543,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedWeakCurlCrossIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11862,7 +11565,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11870,7 +11573,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11933,17 +11636,19 @@ SWIGINTERN PyObject *MixedWeakCurlCrossIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarWeakCurlCrossIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarWeakCurlCrossIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -11966,7 +11671,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11977,16 +11682,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElemen int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11994,7 +11704,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElemen SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12047,7 +11757,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeF } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12061,15 +11771,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarWeakCurlCrossIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12077,7 +11793,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12085,7 +11801,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -12148,17 +11864,19 @@ SWIGINTERN PyObject *MixedScalarWeakCurlCrossIntegrator_swiginit(PyObject *SWIGU return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -12181,7 +11899,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12192,16 +11910,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12209,7 +11932,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12262,7 +11985,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMess } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12276,15 +11999,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12292,7 +12021,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12300,7 +12029,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12323,7 +12052,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12337,15 +12066,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12353,7 +12088,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12361,7 +12096,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12424,17 +12159,19 @@ SWIGINTERN PyObject *MixedCrossGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -12457,7 +12194,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12468,16 +12205,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12485,7 +12227,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12538,7 +12280,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMess } -SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12552,15 +12294,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12568,7 +12316,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12576,7 +12324,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12639,17 +12387,19 @@ SWIGINTERN PyObject *MixedCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarCrossCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarCrossCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -12672,7 +12422,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12683,16 +12433,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTyp int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12700,7 +12455,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTyp SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12753,7 +12508,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailu } -SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12767,15 +12522,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarCrossCurlIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12783,7 +12544,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12791,7 +12552,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -12854,17 +12615,19 @@ SWIGINTERN PyObject *MixedScalarCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarCrossGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarCrossGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -12887,7 +12650,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12898,16 +12661,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTyp int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12915,7 +12683,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTyp SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12968,7 +12736,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailu } -SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12982,15 +12750,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarCrossGradIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12998,7 +12772,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13006,7 +12780,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13069,17 +12843,19 @@ SWIGINTERN PyObject *MixedScalarCrossGradIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarCrossProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarCrossProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13102,7 +12878,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13113,16 +12889,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElement int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13130,7 +12911,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElement SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13223,17 +13004,19 @@ SWIGINTERN PyObject *MixedScalarCrossProductIntegrator_swiginit(PyObject *SWIGUN return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarWeakCrossProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarWeakCrossProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13256,7 +13039,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *S } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCrossProductIntegrator *arg1 = (mfem::MixedScalarWeakCrossProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13267,16 +13050,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteEle int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakCrossProductIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCrossProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13284,7 +13072,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteEle SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13337,7 +13125,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTy } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCrossProductIntegrator *arg1 = (mfem::MixedScalarWeakCrossProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13351,15 +13139,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCrossProductIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarWeakCrossProductIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakCrossProductIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCrossProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13367,7 +13161,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13375,7 +13169,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -13438,17 +13232,19 @@ SWIGINTERN PyObject *MixedScalarWeakCrossProductIntegrator_swiginit(PyObject *SW return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedDirectionalDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedDirectionalDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedDirectionalDerivativeIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedDirectionalDerivativeIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDirectionalDerivativeIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13471,7 +13267,7 @@ SWIGINTERN PyObject *_wrap_new_MixedDirectionalDerivativeIntegrator(PyObject *SW } -SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDirectionalDerivativeIntegrator *arg1 = (mfem::MixedDirectionalDerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13482,16 +13278,21 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElem int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDirectionalDerivativeIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedDirectionalDerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13499,7 +13300,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElem SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13552,7 +13353,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTyp } -SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDirectionalDerivativeIntegrator *arg1 = (mfem::MixedDirectionalDerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13566,15 +13367,21 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedDirectionalDerivativeIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedDirectionalDerivativeIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedDirectionalDerivativeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedDirectionalDerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13582,7 +13389,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13590,7 +13397,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13653,17 +13460,19 @@ SWIGINTERN PyObject *MixedDirectionalDerivativeIntegrator_swiginit(PyObject *SWI return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedGradDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedGradDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedGradDivIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedGradDivIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradDivIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13686,7 +13495,7 @@ SWIGINTERN PyObject *_wrap_new_MixedGradDivIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradDivIntegrator *arg1 = (mfem::MixedGradDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13697,16 +13506,21 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedGradDivIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedGradDivIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedGradDivIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedGradDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13714,7 +13528,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13767,7 +13581,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessag } -SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradDivIntegrator *arg1 = (mfem::MixedGradDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13781,15 +13595,21 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradDivIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradDivIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedGradDivIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13797,7 +13617,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13805,7 +13625,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13828,7 +13648,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradDivIntegrator *arg1 = (mfem::MixedGradDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13842,15 +13662,21 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradDivIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradDivIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedGradDivIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13858,7 +13684,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13866,7 +13692,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -13929,17 +13755,19 @@ SWIGINTERN PyObject *MixedGradDivIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedDivGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedDivGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedDivGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedDivGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDivGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13962,7 +13790,7 @@ SWIGINTERN PyObject *_wrap_new_MixedDivGradIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDivGradIntegrator *arg1 = (mfem::MixedDivGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13973,16 +13801,21 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedDivGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedDivGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDivGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedDivGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13990,7 +13823,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -14043,7 +13876,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessag } -SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDivGradIntegrator *arg1 = (mfem::MixedDivGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14057,15 +13890,21 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedDivGradIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedDivGradIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedDivGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedDivGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14073,7 +13912,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14081,7 +13920,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -14104,7 +13943,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDivGradIntegrator *arg1 = (mfem::MixedDivGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14118,15 +13957,21 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedDivGradIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedDivGradIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedDivGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedDivGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14134,7 +13979,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14142,7 +13987,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -14205,17 +14050,19 @@ SWIGINTERN PyObject *MixedDivGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarWeakDivergenceIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarWeakDivergenceIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14238,7 +14085,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDivergenceIntegrator(PyObject *SWI } -SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakDivergenceIntegrator *arg1 = (mfem::MixedScalarWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14249,16 +14096,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteEleme int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakDivergenceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14266,7 +14118,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteEleme SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -14319,7 +14171,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementType } -SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakDivergenceIntegrator *arg1 = (mfem::MixedScalarWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14333,15 +14185,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakDivergenceIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarWeakDivergenceIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14349,7 +14207,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14357,7 +14215,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -15351,7 +15209,7 @@ SWIGINTERN PyObject *_wrap_new_GradientIntegrator(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15368,15 +15226,22 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:GradientIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15384,7 +15249,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -15392,7 +15257,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -15400,7 +15265,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -15507,7 +15372,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssemblePA(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -15518,15 +15383,20 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GradientIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -15534,7 +15404,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15557,7 +15427,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -15568,15 +15438,20 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GradientIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -15584,7 +15459,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15607,7 +15482,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15618,11 +15493,16 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GradientIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } @@ -15630,7 +15510,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15638,7 +15518,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15852,7 +15732,7 @@ SWIGINTERN PyObject *_wrap_delete_DiffusionIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15866,15 +15746,21 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DiffusionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15882,7 +15768,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15890,7 +15776,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -15913,7 +15799,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15930,15 +15816,22 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DiffusionIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15946,7 +15839,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -15954,7 +15847,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -15962,7 +15855,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -15985,7 +15878,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -16002,15 +15895,22 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DiffusionIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16018,7 +15918,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16026,7 +15926,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -16034,7 +15934,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -16057,7 +15957,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -16065,7 +15965,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObje mfem::Vector *arg4 = 0 ; mfem::FiniteElement *arg5 = 0 ; mfem::Vector *arg6 = 0 ; - bool arg7 ; + bool arg7 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -16080,101 +15980,24 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObje int res6 = 0 ; bool val7 ; int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); - { - try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:DiffusionIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16182,7 +16005,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16190,7 +16013,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -16198,7 +16021,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } @@ -16206,192 +16029,43 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeElementFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -16400,15 +16074,25 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:DiffusionIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16416,7 +16100,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16424,7 +16108,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -16432,9 +16116,16 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + } { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16447,75 +16138,6 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; @@ -16585,7 +16207,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -16593,15 +16215,19 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiffusionIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -16624,7 +16250,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -16635,15 +16261,20 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DiffusionIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -16651,7 +16282,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -16674,269 +16305,136 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - mfem::IntegrationRule *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - { - try { - result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - { - try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_SetupPA__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DiffusionIntegrator_SetupPA__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_SetupPA'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" - " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *DiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::MassIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", NULL + }; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiffusionIntegrator_GetRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); + result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::MassIntegrator *result = 0 ; + mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; + mfem::FiniteElementSpace *arg2 = 0 ; + bool arg3 = (bool) (bool)false ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", (char *)"force", NULL + }; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:DiffusionIntegrator_SetupPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + } + arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *DiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DiffusionIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; mfem::MassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); + if ((nobjs < 0) || (nobjs > 1)) SWIG_fail; + if (swig_obj[0]) { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); + } + arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16949,14 +16447,17 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) NULL ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; mfem::MassIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -16965,9 +16466,16 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); + } { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16988,38 +16496,32 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_MassIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 1)) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 0) { return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MassIntegrator__SWIG_3(self, argc, argv); + return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MassIntegrator__SWIG_2(self, argc, argv); + return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); } } } @@ -17028,9 +16530,7 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MassIntegrator'.\n" " Possible C/C++ prototypes are:\n" " mfem::MassIntegrator::MassIntegrator(mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator()\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &)\n"); + " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n"); return 0; } @@ -17064,7 +16564,7 @@ SWIGINTERN PyObject *_wrap_delete_MassIntegrator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -17078,15 +16578,21 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MassIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -17094,7 +16600,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -17102,7 +16608,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -17125,7 +16631,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -17142,15 +16648,22 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MassIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -17158,7 +16671,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -17166,7 +16679,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -17174,7 +16687,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -17266,7 +16779,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -17274,15 +16787,19 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MassIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -17305,7 +16822,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -17316,15 +16833,20 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MassIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::MassIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -17332,7 +16854,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -17355,7 +16877,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -17366,11 +16888,16 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MassIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } @@ -17378,7 +16905,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -17386,7 +16913,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -17409,25 +16936,31 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; - bool arg3 ; + bool arg3 = (bool) (bool)false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", (char *)"force", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:MassIntegrator_SetupPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -17435,52 +16968,16 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MassIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MassIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17493,56 +16990,6 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MassIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MassIntegrator_SetupPA__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MassIntegrator_SetupPA__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MassIntegrator_SetupPA'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" - " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); - return 0; -} - - SWIGINTERN PyObject *MassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -17554,17 +17001,19 @@ SWIGINTERN PyObject *MassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"q", NULL + }; mfem::BoundaryMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_BoundaryMassIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -17924,85 +17373,54 @@ SWIGINTERN PyObject *_wrap_delete_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPAR if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *BoundaryMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BoundaryMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::ConvectionIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::BoundaryMassIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + arg1 = reinterpret_cast< mfem::BoundaryMassIntegrator * >(argp1); { try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *BoundaryMassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryMassIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BoundaryMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; + double arg2 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"q", (char *)"a", NULL + }; mfem::ConvectionIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_ConvectionIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -18010,9 +17428,16 @@ SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + } { try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1); + result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18025,49 +17450,7 @@ SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvectionIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvectionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -18081,15 +17464,21 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", (char *)"arg4", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ConvectionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -18097,7 +17486,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -18105,7 +17494,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -18197,7 +17586,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssemblePA(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18208,15 +17597,20 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConvectionIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::ConvectionIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -18224,7 +17618,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -18430,18 +17824,23 @@ SWIGINTERN PyObject *ConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; + double arg2 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"q", (char *)"a", NULL + }; mfem::GroupConvectionIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_GroupConvectionIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -18449,45 +17848,16 @@ SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GroupConvectionIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1); + result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18500,49 +17870,7 @@ SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GroupConvectionIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GroupConvectionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -18556,15 +17884,21 @@ SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", (char *)"arg4", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GroupConvectionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -18572,7 +17906,7 @@ SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -18580,7 +17914,7 @@ SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -18666,12 +18000,12 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - int arg2 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -18680,11 +18014,13 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -18702,37 +18038,6 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -18751,83 +18056,14 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorMassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18840,28 +18076,30 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - int arg2 ; + mfem::VectorCoefficient *arg1 = 0 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -18878,14 +18116,15 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); @@ -18894,9 +18133,17 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -18920,39 +18167,15 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar if (argc == 0) { return _wrap_new_VectorMassIntegrator__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_5(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_7(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 1) { + return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -18962,30 +18185,41 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar } } if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); } } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); + if (argc <= 1) { + return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); } } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -18995,7 +18229,7 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar } } if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_6(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); } } } @@ -19005,16 +18239,11 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); } } } @@ -19024,12 +18253,9 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar " Possible C/C++ prototypes are:\n" " mfem::VectorMassIntegrator::VectorMassIntegrator()\n" " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &)\n" " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n"); return 0; } @@ -19064,25 +18290,29 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_GetVDim(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_SetVDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorMassIntegrator_SetVDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_SetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -19099,7 +18329,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19113,15 +18343,21 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorMassIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19129,7 +18365,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -19137,7 +18373,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -19160,7 +18396,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19177,15 +18413,22 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorMassIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19193,7 +18436,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -19201,7 +18444,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -19209,7 +18452,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -19301,7 +18544,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssemblePA(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -19309,15 +18552,19 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorMassIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -19340,7 +18587,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWI } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -19351,15 +18598,20 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorMassIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -19367,7 +18619,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19511,7 +18763,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19525,15 +18777,21 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEDivergenceIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19541,7 +18799,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -19549,7 +18807,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -19572,7 +18830,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py } -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19589,15 +18847,22 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFEDivergenceIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19605,7 +18870,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -19613,7 +18878,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -19621,7 +18886,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -19765,7 +19030,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator(PyObject *self, } -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19779,15 +19044,21 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19795,7 +19066,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -19803,7 +19074,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -19826,7 +19097,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri } -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19843,15 +19114,22 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19859,7 +19137,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -19867,7 +19145,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -19875,7 +19153,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -20019,7 +19297,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -20033,15 +19311,21 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFECurlIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -20049,7 +19333,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -20057,7 +19341,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -20080,7 +19364,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -20097,15 +19381,22 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFECurlIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -20113,7 +19404,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -20121,7 +19412,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -20129,7 +19420,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -20192,17 +19483,21 @@ SWIGINTERN PyObject *VectorFECurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"q", (char *)"i", NULL + }; mfem::DerivativeIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DerivativeIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_DerivativeIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -20211,10 +19506,10 @@ SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(sel } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -20231,7 +19526,7 @@ SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -20245,15 +19540,21 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DerivativeIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -20261,7 +19562,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -20269,7 +19570,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -20292,7 +19593,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -20309,15 +19610,22 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DerivativeIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -20325,7 +19633,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -20333,7 +19641,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -20341,7 +19649,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -20526,7 +19834,7 @@ SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -20540,15 +19848,21 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:CurlCurlIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -20556,7 +19870,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -20564,7 +19878,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -20587,7 +19901,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -20610,15 +19924,24 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU int res6 = 0 ; bool val7 ; int ecode7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeElementFlux", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:CurlCurlIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -20626,7 +19949,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -20634,7 +19957,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -20642,7 +19965,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } @@ -20650,7 +19973,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -20658,7 +19981,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + ecode7 = SWIG_AsVal_bool(obj6, &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); } @@ -20678,13 +20001,13 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -20695,81 +20018,23 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:CurlCurlIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -20777,7 +20042,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -20785,95 +20050,33 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } + { + try { + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; + return NULL; } @@ -20946,7 +20149,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssemblePA(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -20957,15 +20160,20 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CurlCurlIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -20973,7 +20181,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20996,7 +20204,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -21004,15 +20212,19 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CurlCurlIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -21156,7 +20368,7 @@ SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -21170,15 +20382,21 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorCurlCurlIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -21186,7 +20404,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -21194,7 +20412,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -21217,7 +20435,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -21231,16 +20449,22 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorCurlCurlIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -21248,7 +20472,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -21256,7 +20480,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -21596,7 +20820,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -21610,15 +20834,21 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEMassIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -21626,7 +20856,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -21634,7 +20864,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -21657,7 +20887,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -21674,15 +20904,22 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFEMassIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -21690,7 +20927,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -21698,7 +20935,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -21706,7 +20943,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -21798,7 +21035,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssemblePA(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -21809,15 +21046,20 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorFEMassIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -21825,7 +21067,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21848,7 +21090,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -21856,15 +21098,19 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorFEMassIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -22046,7 +21292,7 @@ SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22063,15 +21309,22 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorDivergenceIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22079,7 +21332,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -22087,7 +21340,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -22095,7 +21348,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -22202,7 +21455,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssemblePA(PyObject *self, } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -22213,15 +21466,20 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDivergenceIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -22229,7 +21487,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22252,7 +21510,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -22263,15 +21521,20 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDivergenceIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -22279,7 +21542,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22302,7 +21565,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObjec } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22313,11 +21576,16 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDivergenceIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } @@ -22325,7 +21593,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22333,7 +21601,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -22477,7 +21745,7 @@ SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22491,15 +21759,21 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DivDivIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DivDivIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22507,7 +21781,7 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -22515,7 +21789,7 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -22659,7 +21933,7 @@ SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22673,15 +21947,21 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorDiffusionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22689,7 +21969,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -22697,7 +21977,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -22720,7 +22000,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22737,15 +22017,22 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorDiffusionIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22753,7 +22040,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -22761,7 +22048,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -22769,7 +22056,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -22861,7 +22148,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssemblePA(PyObject *self, } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -22869,15 +22156,19 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDiffusionIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -22900,7 +22191,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -22911,15 +22202,20 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDiffusionIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -22927,7 +22223,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -23132,7 +22428,7 @@ SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator(PyObject *self, PyObject *ar } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -23146,15 +22442,21 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", (char *)"arg4", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ElasticityIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23162,7 +22464,7 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -23170,189 +22472,17 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - bool arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); - { - try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23365,101 +22495,15 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeElementFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -23470,64 +22514,96 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObje int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - double result; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:ElasticityIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -23536,15 +22612,25 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:ElasticityIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23552,7 +22638,7 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -23560,7 +22646,7 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -23568,9 +22654,16 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + } { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -23583,75 +22676,6 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; @@ -24190,7 +23214,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix(PyObject *self, } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -24198,15 +23222,19 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DGTraceIntegrator_AssemblePAInteriorFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -24229,7 +23257,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *S } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -24237,15 +23265,19 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DGTraceIntegrator_AssemblePABoundaryFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -24268,7 +23300,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *S } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -24279,15 +23311,20 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DGTraceIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -24295,7 +23332,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -24318,7 +23355,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -24329,15 +23366,20 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DGTraceIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -24345,7 +23387,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -24368,7 +23410,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry::Type arg1 ; int arg2 ; @@ -24377,22 +23419,27 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(se int ecode1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"geom", (char *)"order", (char *)"T", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DGTraceIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DGTraceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::Geometry::Type""'"); } arg1 = static_cast< mfem::Geometry::Type >(val1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -26418,7 +25465,7 @@ SWIGINTERN PyObject *DiscreteInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26435,15 +25482,22 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h1_fe", (char *)"nd_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:GradientInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); } arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26451,7 +25505,7 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -26459,7 +25513,7 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -26467,7 +25521,7 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -26550,7 +25604,7 @@ SWIGINTERN PyObject *GradientInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26567,15 +25621,22 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:IdentityInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); } arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26583,7 +25644,7 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -26591,7 +25652,7 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -26599,7 +25660,7 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -26682,7 +25743,7 @@ SWIGINTERN PyObject *IdentityInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26699,15 +25760,22 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:CurlInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); } arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26715,7 +25783,7 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -26723,7 +25791,7 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -26731,7 +25799,7 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -26814,7 +25882,7 @@ SWIGINTERN PyObject *CurlInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26831,15 +25899,22 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DivergenceInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DivergenceInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); } arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26847,7 +25922,7 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -26855,7 +25930,7 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -26863,7 +25938,7 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -26946,7 +26021,7 @@ SWIGINTERN PyObject *DivergenceInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26963,15 +26038,22 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NormalInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NormalInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); } arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26979,7 +26061,7 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -26987,7 +26069,7 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -26995,7 +26077,7 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -27078,17 +26160,19 @@ SWIGINTERN PyObject *NormalInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"sc", NULL + }; mfem::ScalarProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ScalarProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -27111,7 +26195,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -27128,15 +26212,22 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ScalarProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -27144,7 +26235,7 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -27152,7 +26243,7 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -27160,7 +26251,7 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -27223,17 +26314,19 @@ SWIGINTERN PyObject *ScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"sc", NULL + }; mfem::ScalarVectorProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ScalarVectorProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -27256,7 +26349,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -27273,15 +26366,22 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarVectorProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ScalarVectorProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -27289,7 +26389,7 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -27297,7 +26397,7 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -27305,7 +26405,7 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -27368,17 +26468,19 @@ SWIGINTERN PyObject *ScalarVectorProductInterpolator_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vc", NULL + }; mfem::VectorScalarProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorScalarProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -27401,7 +26503,7 @@ SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -27418,15 +26520,22 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorScalarProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -27434,7 +26543,7 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -27442,7 +26551,7 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -27450,7 +26559,7 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -27513,17 +26622,19 @@ SWIGINTERN PyObject *VectorScalarProductInterpolator_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vc", NULL + }; mfem::VectorCrossProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorCrossProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -27546,7 +26657,7 @@ SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -27563,15 +26674,22 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nd_fe", (char *)"rt_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorCrossProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorCrossProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -27579,7 +26697,7 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -27587,7 +26705,7 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -27595,7 +26713,7 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -27658,17 +26776,19 @@ SWIGINTERN PyObject *VectorCrossProductInterpolator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vc", NULL + }; mfem::VectorInnerProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorInnerProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -27691,7 +26811,7 @@ SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -27708,15 +26828,22 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rt_fe", (char *)"l2_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorInnerProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorInnerProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -27724,7 +26851,7 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -27732,7 +26859,7 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -27740,7 +26867,7 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -27806,35 +26933,35 @@ SWIGINTERN PyObject *VectorInnerProductInterpolator_swiginit(PyObject *SWIGUNUSE static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, + { "new_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BilinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> BilinearFormIntegrator"}, { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(BilinearFormIntegrator self)\n" "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "BilinearFormIntegrator_AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, - { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "BilinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, - { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, + { "disown_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_TransposeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_TransposeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> TransposeIntegrator"}, + { "TransposeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -27844,38 +26971,38 @@ static PyMethodDef SwigMethods[] = { "AssemblePA()\n" "TransposeIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "TransposeIntegrator_AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "TransposeIntegrator_AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "TransposeIntegrator_AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, - { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "TransposeIntegrator_AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_LumpedIntegrator", (PyCFunction)(void(*)(void))_wrap_new_LumpedIntegrator, METH_VARARGS|METH_KEYWORDS, "new_LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> LumpedIntegrator"}, + { "LumpedIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, - { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_InverseIntegrator", (PyCFunction)(void(*)(void))_wrap_new_InverseIntegrator, METH_VARARGS|METH_KEYWORDS, "new_InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1) -> InverseIntegrator"}, + { "InverseIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, - { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, - { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_SumIntegrator", (PyCFunction)(void(*)(void))_wrap_new_SumIntegrator, METH_VARARGS|METH_KEYWORDS, "new_SumIntegrator(int own_integs=1) -> SumIntegrator"}, + { "SumIntegrator_AddIntegrator", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AddIntegrator, METH_VARARGS|METH_KEYWORDS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, - { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, - { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, - { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" @@ -27885,7 +27012,7 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedScalarMassIntegrator", _wrap_delete_MixedScalarMassIntegrator, METH_O, "delete_MixedScalarMassIntegrator(MixedScalarMassIntegrator self)"}, { "MixedScalarMassIntegrator_swigregister", MixedScalarMassIntegrator_swigregister, METH_O, NULL}, { "MixedScalarMassIntegrator_swiginit", MixedScalarMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorProductIntegrator", _wrap_new_MixedVectorProductIntegrator, METH_O, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, + { "new_MixedVectorProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, { "delete_MixedVectorProductIntegrator", _wrap_delete_MixedVectorProductIntegrator, METH_O, "delete_MixedVectorProductIntegrator(MixedVectorProductIntegrator self)"}, { "MixedVectorProductIntegrator_swigregister", MixedVectorProductIntegrator_swigregister, METH_O, NULL}, { "MixedVectorProductIntegrator_swiginit", MixedVectorProductIntegrator_swiginit, METH_VARARGS, NULL}, @@ -27910,7 +27037,7 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedScalarDivergenceIntegrator", _wrap_delete_MixedScalarDivergenceIntegrator, METH_O, "delete_MixedScalarDivergenceIntegrator(MixedScalarDivergenceIntegrator self)"}, { "MixedScalarDivergenceIntegrator_swigregister", MixedScalarDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarDivergenceIntegrator_swiginit", MixedScalarDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorDivergenceIntegrator", _wrap_new_MixedVectorDivergenceIntegrator, METH_O, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, + { "new_MixedVectorDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, { "delete_MixedVectorDivergenceIntegrator", _wrap_delete_MixedVectorDivergenceIntegrator, METH_O, "delete_MixedVectorDivergenceIntegrator(MixedVectorDivergenceIntegrator self)"}, { "MixedVectorDivergenceIntegrator_swigregister", MixedVectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedVectorDivergenceIntegrator_swiginit", MixedVectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -27944,27 +27071,27 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedVectorMassIntegrator", _wrap_delete_MixedVectorMassIntegrator, METH_O, "delete_MixedVectorMassIntegrator(MixedVectorMassIntegrator self)"}, { "MixedVectorMassIntegrator_swigregister", MixedVectorMassIntegrator_swigregister, METH_O, NULL}, { "MixedVectorMassIntegrator_swiginit", MixedVectorMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossProductIntegrator", _wrap_new_MixedCrossProductIntegrator, METH_O, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, + { "new_MixedCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, { "delete_MixedCrossProductIntegrator", _wrap_delete_MixedCrossProductIntegrator, METH_O, "delete_MixedCrossProductIntegrator(MixedCrossProductIntegrator self)"}, { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, - { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDotProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDotProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDotProductIntegrator_FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, - { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakGradDotIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakGradDotIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, - { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedWeakGradDotIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, - { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakDivCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakDivCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, - { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, @@ -27974,19 +27101,19 @@ static PyMethodDef SwigMethods[] = { "MixedGradGradIntegrator(VectorCoefficient dq)\n" "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" ""}, - { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradGradIntegrator_FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, - { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, - { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, - { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, - { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, @@ -27996,120 +27123,120 @@ static PyMethodDef SwigMethods[] = { "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" ""}, - { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, - { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, - { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, - { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, - { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, - { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, - { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, - { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, - { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, - { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, - { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, - { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, - { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, - { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, - { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, - { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, - { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, - { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, - { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, - { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDirectionalDerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDirectionalDerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, - { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, - { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedGradDivIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedGradDivIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradDivIntegrator_FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, - { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedGradDivIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, - { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDivGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDivGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDivGradIntegrator_FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, - { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedDivGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, - { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, - { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28154,14 +27281,14 @@ static PyMethodDef SwigMethods[] = { "GradientIntegrator(Coefficient _q)\n" "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" ""}, - { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "GradientIntegrator_AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "GradientIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "GradientIntegrator_AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "GradientIntegrator_AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "GradientIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28171,39 +27298,39 @@ static PyMethodDef SwigMethods[] = { "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" ""}, { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, - { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "DiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "DiffusionIntegrator_AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, - { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, - { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, - { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "DiffusionIntegrator_SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "DiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" "MassIntegrator(IntegrationRule ir=None)\n" - "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" + "new_MassIntegrator(Coefficient q, IntegrationRule ir=None) -> MassIntegrator\n" ""}, { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, - { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "MassIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "MassIntegrator_AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, - { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, - { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, - { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "MassIntegrator_SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "MassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, + { "new_BoundaryMassIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryMassIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -28212,13 +27339,13 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_ConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_ConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_ConvectionIntegrator(VectorCoefficient q, double a=1.0) -> ConvectionIntegrator"}, + { "ConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "ConvectionIntegrator_AssemblePA(FiniteElementSpace arg1)\n" ""}, - { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "ConvectionIntegrator_AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "ConvectionIntegrator_AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" "ConvectionIntegrator_GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" "ConvectionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" @@ -28226,8 +27353,8 @@ static PyMethodDef SwigMethods[] = { { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_GroupConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_GroupConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_GroupConvectionIntegrator(VectorCoefficient q, double a=1.0) -> GroupConvectionIntegrator"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28236,18 +27363,18 @@ static PyMethodDef SwigMethods[] = { "VectorMassIntegrator(Coefficient q, int qo=0)\n" "VectorMassIntegrator(Coefficient q, IntegrationRule ir)\n" "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" - "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" + "new_VectorMassIntegrator(MatrixCoefficient q, int qo=0) -> VectorMassIntegrator\n" ""}, { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "VectorMassIntegrator_GetVDim(VectorMassIntegrator self) -> int"}, - { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, - { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_SetVDim", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_SetVDim, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorMassIntegrator_AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, - { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "VectorMassIntegrator_AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, + { "VectorMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28255,8 +27382,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEDivergenceIntegrator()\n" "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" ""}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28264,8 +27391,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEWeakDivergenceIntegrator()\n" "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" ""}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28273,14 +27400,14 @@ static PyMethodDef SwigMethods[] = { "VectorFECurlIntegrator()\n" "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" ""}, - { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, - { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_DerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, + { "DerivativeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28289,15 +27416,15 @@ static PyMethodDef SwigMethods[] = { "CurlCurlIntegrator(Coefficient q)\n" "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" ""}, - { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, - { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "CurlCurlIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "CurlCurlIntegrator_AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, - { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "CurlCurlIntegrator_AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, + { "CurlCurlIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28305,8 +27432,8 @@ static PyMethodDef SwigMethods[] = { "VectorCurlCurlIntegrator()\n" "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" ""}, - { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28319,14 +27446,14 @@ static PyMethodDef SwigMethods[] = { "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" ""}, - { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorFEMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "VectorFEMassIntegrator_AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, - { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorFEMassIntegrator_AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, + { "VectorFEMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28335,14 +27462,14 @@ static PyMethodDef SwigMethods[] = { "VectorDivergenceIntegrator(Coefficient _q)\n" "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" ""}, - { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorDivergenceIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "VectorDivergenceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28350,7 +27477,7 @@ static PyMethodDef SwigMethods[] = { "DivDivIntegrator()\n" "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" ""}, - { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivDivIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28358,14 +27485,14 @@ static PyMethodDef SwigMethods[] = { "VectorDiffusionIntegrator()\n" "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" ""}, - { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorDiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorDiffusionIntegrator_AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, - { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "VectorDiffusionIntegrator_AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28373,9 +27500,9 @@ static PyMethodDef SwigMethods[] = { "ElasticityIntegrator(Coefficient l, Coefficient m)\n" "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" ""}, - { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, - { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "ElasticityIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28388,11 +27515,11 @@ static PyMethodDef SwigMethods[] = { "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "DGTraceIntegrator_AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, - { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "DGTraceIntegrator_AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, - { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28443,53 +27570,53 @@ static PyMethodDef SwigMethods[] = { { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, - { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, - { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "IdentityInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, - { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, - { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivergenceInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, - { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "NormalInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, - { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, - { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarVectorProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, - { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, - { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorCrossProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, - { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorInnerProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorInnerProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, @@ -28499,35 +27626,35 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, + { "new_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BilinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> BilinearFormIntegrator"}, { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(BilinearFormIntegrator self)\n" "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, - { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "BilinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, - { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, + { "disown_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_TransposeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_TransposeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> TransposeIntegrator"}, + { "TransposeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -28537,38 +27664,38 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, - { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_LumpedIntegrator", (PyCFunction)(void(*)(void))_wrap_new_LumpedIntegrator, METH_VARARGS|METH_KEYWORDS, "new_LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> LumpedIntegrator"}, + { "LumpedIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, - { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_InverseIntegrator", (PyCFunction)(void(*)(void))_wrap_new_InverseIntegrator, METH_VARARGS|METH_KEYWORDS, "new_InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1) -> InverseIntegrator"}, + { "InverseIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, - { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, - { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_SumIntegrator", (PyCFunction)(void(*)(void))_wrap_new_SumIntegrator, METH_VARARGS|METH_KEYWORDS, "new_SumIntegrator(int own_integs=1) -> SumIntegrator"}, + { "SumIntegrator_AddIntegrator", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AddIntegrator, METH_VARARGS|METH_KEYWORDS, "AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, - { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, - { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, - { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" @@ -28578,7 +27705,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedScalarMassIntegrator", _wrap_delete_MixedScalarMassIntegrator, METH_O, "delete_MixedScalarMassIntegrator(MixedScalarMassIntegrator self)"}, { "MixedScalarMassIntegrator_swigregister", MixedScalarMassIntegrator_swigregister, METH_O, NULL}, { "MixedScalarMassIntegrator_swiginit", MixedScalarMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorProductIntegrator", _wrap_new_MixedVectorProductIntegrator, METH_O, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, + { "new_MixedVectorProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, { "delete_MixedVectorProductIntegrator", _wrap_delete_MixedVectorProductIntegrator, METH_O, "delete_MixedVectorProductIntegrator(MixedVectorProductIntegrator self)"}, { "MixedVectorProductIntegrator_swigregister", MixedVectorProductIntegrator_swigregister, METH_O, NULL}, { "MixedVectorProductIntegrator_swiginit", MixedVectorProductIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28603,7 +27730,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedScalarDivergenceIntegrator", _wrap_delete_MixedScalarDivergenceIntegrator, METH_O, "delete_MixedScalarDivergenceIntegrator(MixedScalarDivergenceIntegrator self)"}, { "MixedScalarDivergenceIntegrator_swigregister", MixedScalarDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarDivergenceIntegrator_swiginit", MixedScalarDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorDivergenceIntegrator", _wrap_new_MixedVectorDivergenceIntegrator, METH_O, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, + { "new_MixedVectorDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, { "delete_MixedVectorDivergenceIntegrator", _wrap_delete_MixedVectorDivergenceIntegrator, METH_O, "delete_MixedVectorDivergenceIntegrator(MixedVectorDivergenceIntegrator self)"}, { "MixedVectorDivergenceIntegrator_swigregister", MixedVectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedVectorDivergenceIntegrator_swiginit", MixedVectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28637,27 +27764,27 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedVectorMassIntegrator", _wrap_delete_MixedVectorMassIntegrator, METH_O, "delete_MixedVectorMassIntegrator(MixedVectorMassIntegrator self)"}, { "MixedVectorMassIntegrator_swigregister", MixedVectorMassIntegrator_swigregister, METH_O, NULL}, { "MixedVectorMassIntegrator_swiginit", MixedVectorMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossProductIntegrator", _wrap_new_MixedCrossProductIntegrator, METH_O, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, + { "new_MixedCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, { "delete_MixedCrossProductIntegrator", _wrap_delete_MixedCrossProductIntegrator, METH_O, "delete_MixedCrossProductIntegrator(MixedCrossProductIntegrator self)"}, { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, - { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDotProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDotProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, - { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakGradDotIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakGradDotIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, - { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedWeakGradDotIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, - { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakDivCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakDivCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, - { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28667,19 +27794,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MixedGradGradIntegrator(VectorCoefficient dq)\n" "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" ""}, - { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, - { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, - { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS|METH_KEYWORDS, "GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, - { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, - { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28689,120 +27816,120 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" ""}, - { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, - { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, - { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, - { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, - { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, - { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, - { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, - { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, - { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, - { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, - { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, - { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, - { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, - { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, - { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, - { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, - { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, - { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, - { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, - { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDirectionalDerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDirectionalDerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, - { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, - { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedGradDivIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedGradDivIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, - { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedGradDivIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, - { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDivGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDivGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, - { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedDivGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, - { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, - { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28847,14 +27974,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GradientIntegrator(Coefficient _q)\n" "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" ""}, - { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "GradientIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28864,39 +27991,39 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" ""}, { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, - { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, - { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, - { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, - { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "DiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" "MassIntegrator(IntegrationRule ir=None)\n" - "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" + "new_MassIntegrator(Coefficient q, IntegrationRule ir=None) -> MassIntegrator\n" ""}, { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, - { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, - { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, - { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, - { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "MassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, + { "new_BoundaryMassIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryMassIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -28905,13 +28032,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_ConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_ConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_ConvectionIntegrator(VectorCoefficient q, double a=1.0) -> ConvectionIntegrator"}, + { "ConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace arg1)\n" ""}, - { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" "GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" @@ -28919,8 +28046,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_GroupConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_GroupConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_GroupConvectionIntegrator(VectorCoefficient q, double a=1.0) -> GroupConvectionIntegrator"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28929,18 +28056,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorMassIntegrator(Coefficient q, int qo=0)\n" "VectorMassIntegrator(Coefficient q, IntegrationRule ir)\n" "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" - "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" + "new_VectorMassIntegrator(MatrixCoefficient q, int qo=0) -> VectorMassIntegrator\n" ""}, { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "GetVDim(VectorMassIntegrator self) -> int"}, - { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "SetVDim(VectorMassIntegrator self, int vdim)"}, - { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_SetVDim", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_SetVDim, METH_VARARGS|METH_KEYWORDS, "SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, - { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, + { "VectorMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28948,8 +28075,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFEDivergenceIntegrator()\n" "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" ""}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28957,8 +28084,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFEWeakDivergenceIntegrator()\n" "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" ""}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28966,14 +28093,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFECurlIntegrator()\n" "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" ""}, - { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, - { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_DerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, + { "DerivativeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28982,15 +28109,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CurlCurlIntegrator(Coefficient q)\n" "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" ""}, - { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, - { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, - { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, + { "CurlCurlIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -28998,8 +28125,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorCurlCurlIntegrator()\n" "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" ""}, - { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29012,14 +28139,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" ""}, - { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, - { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, + { "VectorFEMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29028,14 +28155,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorDivergenceIntegrator(Coefficient _q)\n" "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" ""}, - { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "VectorDivergenceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29043,7 +28170,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DivDivIntegrator()\n" "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" ""}, - { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivDivIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29051,14 +28178,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorDiffusionIntegrator()\n" "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" ""}, - { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, - { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29066,9 +28193,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ElasticityIntegrator(Coefficient l, Coefficient m)\n" "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" ""}, - { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, - { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "ElasticityIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29081,11 +28208,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, - { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, - { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -29136,53 +28263,53 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, - { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, - { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "IdentityInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, - { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, - { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivergenceInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, - { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "NormalInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, - { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, - { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarVectorProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, - { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, - { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorCrossProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, - { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorInnerProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorInnerProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/bilininteg_wrap.h b/mfem/_par/bilininteg_wrap.h index 3361ff37..63cc9638 100644 --- a/mfem/_par/bilininteg_wrap.h +++ b/mfem/_par/bilininteg_wrap.h @@ -66,7 +66,7 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, return method; } private: - mutable swig::SwigVar_PyObject vtable[18]; + mutable swig::SwigVar_PyObject vtable[16]; #endif }; diff --git a/mfem/_par/blockmatrix_wrap.cxx b/mfem/_par/blockmatrix_wrap.cxx index cc6158b6..e4ab3960 100644 --- a/mfem/_par/blockmatrix_wrap.cxx +++ b/mfem/_par/blockmatrix_wrap.cxx @@ -3501,7 +3501,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_BlockMatrix_PrintMatlab__SWIG_2(mfem::BlockMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_BlockMatrix_PrintMatlab__SWIG_1(mfem::BlockMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3644,7 +3644,7 @@ SWIGINTERN PyObject *_wrap_new_BlockMatrix(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_BlockMatrix_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; @@ -3654,27 +3654,33 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_SetBlock(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"mat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_SetBlock", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockMatrix_SetBlock", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_SetBlock" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockMatrix_SetBlock" "', argument " "4"" of type '" "mfem::SparseMatrix *""'"); } @@ -3939,33 +3945,38 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetBlock(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_BlockMatrix_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_IsZeroBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockMatrix_IsZeroBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_IsZeroBlock" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4191,26 +4202,30 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_ColOffsets(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_BlockMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_RowSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockMatrix_RowSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_RowSize" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4236,13 +4251,13 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNU PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); @@ -4254,11 +4269,13 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNU }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); + } { try { (arg1)->EliminateRowCol(arg2,arg3); @@ -4280,45 +4297,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNU SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->EliminateRowCol(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4391,7 +4369,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_EliminateRowCol", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); @@ -4406,25 +4384,9 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject } } if (_v) { - return _wrap_BlockMatrix_EliminateRowCol__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_BlockMatrix_EliminateRowCol__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -4453,7 +4415,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BlockMatrix_EliminateRowCol__SWIG_2(self, argc, argv); + return _wrap_BlockMatrix_EliminateRowCol__SWIG_1(self, argc, argv); } } } @@ -4464,7 +4426,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_EliminateRowCol'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockMatrix::EliminateRowCol(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BlockMatrix::EliminateRowCol(int)\n" " mfem::BlockMatrix::EliminateRowCol(mfem::Array< int > &,mfem::Vector &,mfem::Vector &)\n"); return 0; } @@ -4473,21 +4434,23 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_Finalize" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -4510,38 +4473,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_Finalize" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - try { - (arg1)->Finalize(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; @@ -4596,21 +4527,15 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_Finalize", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_Finalize__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_BlockMatrix_Finalize__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4644,7 +4569,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BlockMatrix_Finalize__SWIG_2(self, argc, argv); + return _wrap_BlockMatrix_Finalize__SWIG_1(self, argc, argv); } } } @@ -4654,7 +4579,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_Finalize'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockMatrix::Finalize(int)\n" - " mfem::BlockMatrix::Finalize()\n" " mfem::BlockMatrix::Finalize(int,bool)\n"); return 0; } @@ -4698,31 +4622,34 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_CreateMonolithic(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -4755,38 +4682,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - try { - ((mfem::BlockMatrix const *)arg1)->PrintMatlab(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_BlockMatrix_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; @@ -5027,7 +4922,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_NumNonZeroElems(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; @@ -5039,22 +4934,28 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_GetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockMatrix_GetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_GetRow" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5062,7 +4963,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockMatrix_GetRow" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5090,61 +4991,36 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - double arg2 ; + double arg2 = (double) (double)1e-12 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"threshold", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BlockMatrix_EliminateZeroRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->EliminateZeroRows(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { try { - (arg1)->EliminateZeroRows(); + (arg1)->EliminateZeroRows(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5162,49 +5038,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_EliminateZeroRows", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_EliminateZeroRows__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockMatrix_EliminateZeroRows__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_EliminateZeroRows'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockMatrix::EliminateZeroRows(double const)\n" - " mfem::BlockMatrix::EliminateZeroRows()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5215,15 +5049,20 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockMatrix_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_Mult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5231,7 +5070,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5259,12 +5098,12 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1. ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5273,14 +5112,21 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BlockMatrix_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5288,7 +5134,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5296,11 +5142,13 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { ((mfem::BlockMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); @@ -5321,7 +5169,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5332,129 +5180,20 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::BlockMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockMatrix_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockMatrix::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BlockMatrix::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockMatrix_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5462,7 +5201,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5490,12 +5229,12 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1. ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5504,14 +5243,21 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUN int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BlockMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5519,7 +5265,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5527,68 +5273,16 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::BlockMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::BlockMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::BlockMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5606,66 +5300,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockMatrix_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BlockMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_BlockMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; @@ -5751,18 +5385,18 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_owns_blocks_get(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); @@ -5773,58 +5407,17 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_BlockMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_BlockMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2); + mfem_BlockMatrix_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5852,34 +5445,15 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_PrintMatlab__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_PrintMatlab__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_BlockMatrix_PrintMatlab__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -5894,7 +5468,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); @@ -5903,6 +5477,9 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_BlockMatrix_PrintMatlab__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5912,7 +5489,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_BlockMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_BlockMatrix_PrintMatlab__SWIG_1(self, argc, argv); } } } @@ -5922,9 +5499,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::BlockMatrix::PrintMatlab() const\n" - " mfem::BlockMatrix::PrintMatlab(char const *,int)\n" - " mfem::BlockMatrix::PrintMatlab(char const *)\n"); + " mfem::BlockMatrix::PrintMatlab(char const *,int)\n"); return 0; } @@ -5947,14 +5522,14 @@ static PyMethodDef SwigMethods[] = { "BlockMatrix(intArray offsets)\n" "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" ""}, - { "BlockMatrix_SetBlock", _wrap_BlockMatrix_SetBlock, METH_VARARGS, "BlockMatrix_SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, + { "BlockMatrix_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_SetBlock, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, { "BlockMatrix_NumRowBlocks", _wrap_BlockMatrix_NumRowBlocks, METH_O, "BlockMatrix_NumRowBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_NumColBlocks", _wrap_BlockMatrix_NumColBlocks, METH_O, "BlockMatrix_NumColBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_GetBlock", _wrap_BlockMatrix_GetBlock, METH_VARARGS, "\n" "BlockMatrix_GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" "BlockMatrix_GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" ""}, - { "BlockMatrix_IsZeroBlock", _wrap_BlockMatrix_IsZeroBlock, METH_VARARGS, "BlockMatrix_IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, + { "BlockMatrix_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, { "BlockMatrix_RowOffsets", _wrap_BlockMatrix_RowOffsets, METH_VARARGS, "\n" "BlockMatrix_RowOffsets(BlockMatrix self) -> intArray\n" "BlockMatrix_RowOffsets(BlockMatrix self) -> intArray\n" @@ -5963,7 +5538,7 @@ static PyMethodDef SwigMethods[] = { "BlockMatrix_ColOffsets(BlockMatrix self) -> intArray\n" "BlockMatrix_ColOffsets(BlockMatrix self) -> intArray\n" ""}, - { "BlockMatrix_RowSize", _wrap_BlockMatrix_RowSize, METH_VARARGS, "BlockMatrix_RowSize(BlockMatrix self, int const i) -> int"}, + { "BlockMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_RowSize(BlockMatrix self, int const i) -> int"}, { "BlockMatrix_EliminateRowCol", _wrap_BlockMatrix_EliminateRowCol, METH_VARARGS, "\n" "BlockMatrix_EliminateRowCol(BlockMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BlockMatrix_EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs)\n" @@ -5979,12 +5554,12 @@ static PyMethodDef SwigMethods[] = { ""}, { "BlockMatrix_Inverse", _wrap_BlockMatrix_Inverse, METH_O, "BlockMatrix_Inverse(BlockMatrix self) -> MatrixInverse"}, { "BlockMatrix_NumNonZeroElems", _wrap_BlockMatrix_NumNonZeroElems, METH_O, "BlockMatrix_NumNonZeroElems(BlockMatrix self) -> int"}, - { "BlockMatrix_GetRow", _wrap_BlockMatrix_GetRow, METH_VARARGS, "BlockMatrix_GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "BlockMatrix_EliminateZeroRows", _wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS, "BlockMatrix_EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, - { "BlockMatrix_Mult", _wrap_BlockMatrix_Mult, METH_VARARGS, "BlockMatrix_Mult(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMult", _wrap_BlockMatrix_AddMult, METH_VARARGS, "BlockMatrix_AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, - { "BlockMatrix_MultTranspose", _wrap_BlockMatrix_MultTranspose, METH_VARARGS, "BlockMatrix_MultTranspose(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMultTranspose", _wrap_BlockMatrix_AddMultTranspose, METH_VARARGS, "BlockMatrix_AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "BlockMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, + { "BlockMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_Mult(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_MultTranspose(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_BlockMatrix", _wrap_delete_BlockMatrix, METH_O, "delete_BlockMatrix(BlockMatrix self)"}, { "BlockMatrix_owns_blocks_set", _wrap_BlockMatrix_owns_blocks_set, METH_VARARGS, "BlockMatrix_owns_blocks_set(BlockMatrix self, int owns_blocks)"}, { "BlockMatrix_owns_blocks_get", _wrap_BlockMatrix_owns_blocks_get, METH_O, "BlockMatrix_owns_blocks_get(BlockMatrix self) -> int"}, @@ -6004,14 +5579,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "BlockMatrix(intArray offsets)\n" "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" ""}, - { "BlockMatrix_SetBlock", _wrap_BlockMatrix_SetBlock, METH_VARARGS, "SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, + { "BlockMatrix_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_SetBlock, METH_VARARGS|METH_KEYWORDS, "SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, { "BlockMatrix_NumRowBlocks", _wrap_BlockMatrix_NumRowBlocks, METH_O, "NumRowBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_NumColBlocks", _wrap_BlockMatrix_NumColBlocks, METH_O, "NumColBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_GetBlock", _wrap_BlockMatrix_GetBlock, METH_VARARGS, "\n" "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" ""}, - { "BlockMatrix_IsZeroBlock", _wrap_BlockMatrix_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, + { "BlockMatrix_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, { "BlockMatrix_RowOffsets", _wrap_BlockMatrix_RowOffsets, METH_VARARGS, "\n" "RowOffsets(BlockMatrix self) -> intArray\n" "RowOffsets(BlockMatrix self) -> intArray\n" @@ -6020,7 +5595,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ColOffsets(BlockMatrix self) -> intArray\n" "ColOffsets(BlockMatrix self) -> intArray\n" ""}, - { "BlockMatrix_RowSize", _wrap_BlockMatrix_RowSize, METH_VARARGS, "RowSize(BlockMatrix self, int const i) -> int"}, + { "BlockMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "RowSize(BlockMatrix self, int const i) -> int"}, { "BlockMatrix_EliminateRowCol", _wrap_BlockMatrix_EliminateRowCol, METH_VARARGS, "\n" "EliminateRowCol(BlockMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs)\n" @@ -6036,12 +5611,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "BlockMatrix_Inverse", _wrap_BlockMatrix_Inverse, METH_O, "Inverse(BlockMatrix self) -> MatrixInverse"}, { "BlockMatrix_NumNonZeroElems", _wrap_BlockMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(BlockMatrix self) -> int"}, - { "BlockMatrix_GetRow", _wrap_BlockMatrix_GetRow, METH_VARARGS, "GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "BlockMatrix_EliminateZeroRows", _wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, - { "BlockMatrix_Mult", _wrap_BlockMatrix_Mult, METH_VARARGS, "Mult(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMult", _wrap_BlockMatrix_AddMult, METH_VARARGS, "AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, - { "BlockMatrix_MultTranspose", _wrap_BlockMatrix_MultTranspose, METH_VARARGS, "MultTranspose(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMultTranspose", _wrap_BlockMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "BlockMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, + { "BlockMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_BlockMatrix", _wrap_delete_BlockMatrix, METH_O, "delete_BlockMatrix(BlockMatrix self)"}, { "BlockMatrix_owns_blocks_set", _wrap_BlockMatrix_owns_blocks_set, METH_VARARGS, "BlockMatrix_owns_blocks_set(BlockMatrix self, int owns_blocks)"}, { "BlockMatrix_owns_blocks_get", _wrap_BlockMatrix_owns_blocks_get, METH_O, "BlockMatrix_owns_blocks_get(BlockMatrix self) -> int"}, diff --git a/mfem/_par/blockoperator_wrap.cxx b/mfem/_par/blockoperator_wrap.cxx index 3e9c7101..461d2d32 100644 --- a/mfem/_par/blockoperator_wrap.cxx +++ b/mfem/_par/blockoperator_wrap.cxx @@ -3276,17 +3276,19 @@ SWIGINTERNINLINE PyObject* #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_Opr2BlockOpr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Opr2BlockOpr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::BlockOperator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Opr2BlockOpr", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opr2BlockOpr" "', argument " "1"" of type '" "mfem::Operator *""'"); } @@ -3311,17 +3313,19 @@ SWIGINTERN PyObject *_wrap_Opr2BlockOpr(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Opr2SparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Opr2SparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Opr2SparseMat", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opr2SparseMat" "', argument " "1"" of type '" "mfem::Operator *""'"); } @@ -3346,17 +3350,19 @@ SWIGINTERN PyObject *_wrap_Opr2SparseMat(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Opr2HypreParMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Opr2HypreParMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::HypreParMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Opr2HypreParMat", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opr2HypreParMat" "', argument " "1"" of type '" "mfem::Operator *""'"); } @@ -3502,41 +3508,50 @@ SWIGINTERN PyObject *_wrap_new_BlockOperator(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; mfem::Operator *arg3 = (mfem::Operator *) 0 ; - double arg4 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"op", (char *)"c", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BlockOperator_SetDiagonalBlock", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { (arg1)->SetDiagonalBlock(arg2,arg3,arg4); @@ -3557,224 +3572,61 @@ SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock__SWIG_0(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; - int arg2 ; - mfem::Operator *arg3 = (mfem::Operator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); - } - arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); - } - arg3 = reinterpret_cast< mfem::Operator * >(argp3); - { - try { - (arg1)->SetDiagonalBlock(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockOperator_SetDiagonalBlock", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockOperator_SetDiagonalBlock__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockOperator_SetDiagonalBlock__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockOperator_SetDiagonalBlock'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockOperator::SetDiagonalBlock(int,mfem::Operator *,double)\n" - " mfem::BlockOperator::SetDiagonalBlock(int,mfem::Operator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; mfem::Operator *arg4 = (mfem::Operator *) 0 ; - double arg5 ; + double arg5 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; double val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iRow", (char *)"iCol", (char *)"op", (char *)"c", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:BlockOperator_SetBlock", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockOperator_SetBlock" "', argument " "4"" of type '" "mfem::Operator *""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlockOperator_SetBlock" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - (arg1)->SetBlock(arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; - int arg2 ; - int arg3 ; - mfem::Operator *arg4 = (mfem::Operator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); - } - arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockOperator_SetBlock" "', argument " "4"" of type '" "mfem::Operator *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlockOperator_SetBlock" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } - arg4 = reinterpret_cast< mfem::Operator * >(argp4); { try { - (arg1)->SetBlock(arg2,arg3,arg4); + (arg1)->SetBlock(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3792,98 +3644,6 @@ SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockOperator_SetBlock", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockOperator_SetBlock__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockOperator_SetBlock__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockOperator_SetBlock'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockOperator::SetBlock(int,int,mfem::Operator *,double)\n" - " mfem::BlockOperator::SetBlock(int,int,mfem::Operator *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BlockOperator_NumRowBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; @@ -3954,33 +3714,38 @@ SWIGINTERN PyObject *_wrap_BlockOperator_NumColBlocks(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BlockOperator_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_IsZeroBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_IsZeroBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_IsZeroBlock" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4002,33 +3767,38 @@ SWIGINTERN PyObject *_wrap_BlockOperator_IsZeroBlock(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BlockOperator_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_GetBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_GetBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_GetBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4050,33 +3820,38 @@ SWIGINTERN PyObject *_wrap_BlockOperator_GetBlock(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_BlockOperator_GetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_GetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_GetBlockCoef", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_GetBlockCoef", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_GetBlockCoef" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4098,7 +3873,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_GetBlockCoef(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_SetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; @@ -4108,27 +3883,33 @@ SWIGINTERN PyObject *_wrap_BlockOperator_SetBlockCoef(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_SetBlockCoef", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockOperator_SetBlockCoef", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetBlockCoef" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockOperator_SetBlockCoef" "', argument " "4"" of type '" "double""'"); } @@ -4223,7 +4004,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_ColOffsets(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4234,15 +4015,20 @@ SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_Mult" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4250,7 +4036,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4278,7 +4064,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4289,15 +4075,20 @@ SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_MultTranspose" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4305,7 +4096,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4429,17 +4220,19 @@ SWIGINTERN PyObject *BlockOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BlockDiagonalPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockDiagonalPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"offsets", NULL + }; mfem::BlockDiagonalPreconditioner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_BlockDiagonalPreconditioner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockDiagonalPreconditioner" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } @@ -4467,7 +4260,7 @@ SWIGINTERN PyObject *_wrap_new_BlockDiagonalPreconditioner(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; int arg2 ; @@ -4476,21 +4269,26 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_SetDiagonalBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockDiagonalPreconditioner_SetDiagonalBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockDiagonalPreconditioner_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); } @@ -4515,7 +4313,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; mfem::Operator *arg2 = 0 ; @@ -4523,15 +4321,19 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetOperator(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockDiagonalPreconditioner_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_SetOperator" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockDiagonalPreconditioner_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -4594,26 +4396,30 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_NumBlocks(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_GetDiagonalBlock", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockDiagonalPreconditioner_GetDiagonalBlock", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_GetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4670,7 +4476,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Offsets(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4681,15 +4487,20 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockDiagonalPreconditioner_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4697,7 +4508,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4725,7 +4536,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4736,15 +4547,20 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockDiagonalPreconditioner_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4752,7 +4568,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4876,17 +4692,19 @@ SWIGINTERN PyObject *BlockDiagonalPreconditioner_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BlockLowerTriangularPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockLowerTriangularPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"offsets", NULL + }; mfem::BlockLowerTriangularPreconditioner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_BlockLowerTriangularPreconditioner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockLowerTriangularPreconditioner" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } @@ -4914,7 +4732,7 @@ SWIGINTERN PyObject *_wrap_new_BlockLowerTriangularPreconditioner(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; int arg2 ; @@ -4923,21 +4741,26 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(P int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_SetDiagonalBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_SetDiagonalBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockLowerTriangularPreconditioner_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); } @@ -4962,7 +4785,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(P } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; int arg2 ; @@ -4972,27 +4795,33 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iRow", (char *)"iCol", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_SetBlock", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockLowerTriangularPreconditioner_SetBlock", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_SetBlock" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockLowerTriangularPreconditioner_SetBlock" "', argument " "4"" of type '" "mfem::Operator *""'"); } @@ -5017,7 +4846,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; mfem::Operator *arg2 = 0 ; @@ -5025,15 +4854,19 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetOperator(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockLowerTriangularPreconditioner_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_SetOperator" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockLowerTriangularPreconditioner_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -5096,33 +4929,38 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_NumBlocks(PyObject } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"jblock", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_GetBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_GetBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_GetBlock" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5179,7 +5017,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Offsets(PyObject * } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5190,15 +5028,20 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5206,7 +5049,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5234,7 +5077,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWI } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5245,15 +5088,20 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5261,7 +5109,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5388,52 +5236,52 @@ SWIGINTERN PyObject *BlockLowerTriangularPreconditioner_swiginit(PyObject *SWIGU static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, - { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, - { "Opr2HypreParMat", _wrap_Opr2HypreParMat, METH_O, "Opr2HypreParMat(Operator op) -> mfem::HypreParMatrix *"}, + { "Opr2BlockOpr", (PyCFunction)(void(*)(void))_wrap_Opr2BlockOpr, METH_VARARGS|METH_KEYWORDS, "Opr2BlockOpr(Operator op) -> BlockOperator"}, + { "Opr2SparseMat", (PyCFunction)(void(*)(void))_wrap_Opr2SparseMat, METH_VARARGS|METH_KEYWORDS, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, + { "Opr2HypreParMat", (PyCFunction)(void(*)(void))_wrap_Opr2HypreParMat, METH_VARARGS|METH_KEYWORDS, "Opr2HypreParMat(Operator op) -> mfem::HypreParMatrix *"}, { "new_BlockOperator", _wrap_new_BlockOperator, METH_VARARGS, "\n" "BlockOperator(intArray offsets)\n" "new_BlockOperator(intArray row_offsets, intArray col_offsets) -> BlockOperator\n" ""}, - { "BlockOperator_SetDiagonalBlock", _wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS, "BlockOperator_SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, - { "BlockOperator_SetBlock", _wrap_BlockOperator_SetBlock, METH_VARARGS, "BlockOperator_SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, + { "BlockOperator_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, + { "BlockOperator_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, { "BlockOperator_NumRowBlocks", _wrap_BlockOperator_NumRowBlocks, METH_O, "BlockOperator_NumRowBlocks(BlockOperator self) -> int"}, { "BlockOperator_NumColBlocks", _wrap_BlockOperator_NumColBlocks, METH_O, "BlockOperator_NumColBlocks(BlockOperator self) -> int"}, - { "BlockOperator_IsZeroBlock", _wrap_BlockOperator_IsZeroBlock, METH_VARARGS, "BlockOperator_IsZeroBlock(BlockOperator self, int i, int j) -> int"}, - { "BlockOperator_GetBlock", _wrap_BlockOperator_GetBlock, METH_VARARGS, "BlockOperator_GetBlock(BlockOperator self, int i, int j) -> Operator"}, - { "BlockOperator_GetBlockCoef", _wrap_BlockOperator_GetBlockCoef, METH_VARARGS, "BlockOperator_GetBlockCoef(BlockOperator self, int i, int j) -> double"}, - { "BlockOperator_SetBlockCoef", _wrap_BlockOperator_SetBlockCoef, METH_VARARGS, "BlockOperator_SetBlockCoef(BlockOperator self, int i, int j, double c)"}, + { "BlockOperator_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_IsZeroBlock(BlockOperator self, int i, int j) -> int"}, + { "BlockOperator_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_GetBlock(BlockOperator self, int i, int j) -> Operator"}, + { "BlockOperator_GetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlockCoef, METH_VARARGS|METH_KEYWORDS, "BlockOperator_GetBlockCoef(BlockOperator self, int i, int j) -> double"}, + { "BlockOperator_SetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlockCoef, METH_VARARGS|METH_KEYWORDS, "BlockOperator_SetBlockCoef(BlockOperator self, int i, int j, double c)"}, { "BlockOperator_RowOffsets", _wrap_BlockOperator_RowOffsets, METH_O, "BlockOperator_RowOffsets(BlockOperator self) -> intArray"}, { "BlockOperator_ColOffsets", _wrap_BlockOperator_ColOffsets, METH_O, "BlockOperator_ColOffsets(BlockOperator self) -> intArray"}, - { "BlockOperator_Mult", _wrap_BlockOperator_Mult, METH_VARARGS, "BlockOperator_Mult(BlockOperator self, Vector x, Vector y)"}, - { "BlockOperator_MultTranspose", _wrap_BlockOperator_MultTranspose, METH_VARARGS, "BlockOperator_MultTranspose(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_Mult", (PyCFunction)(void(*)(void))_wrap_BlockOperator_Mult, METH_VARARGS|METH_KEYWORDS, "BlockOperator_Mult(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockOperator_MultTranspose(BlockOperator self, Vector x, Vector y)"}, { "delete_BlockOperator", _wrap_delete_BlockOperator, METH_O, "delete_BlockOperator(BlockOperator self)"}, { "BlockOperator_owns_blocks_set", _wrap_BlockOperator_owns_blocks_set, METH_VARARGS, "BlockOperator_owns_blocks_set(BlockOperator self, int owns_blocks)"}, { "BlockOperator_owns_blocks_get", _wrap_BlockOperator_owns_blocks_get, METH_O, "BlockOperator_owns_blocks_get(BlockOperator self) -> int"}, { "BlockOperator_swigregister", BlockOperator_swigregister, METH_O, NULL}, { "BlockOperator_swiginit", BlockOperator_swiginit, METH_VARARGS, NULL}, - { "new_BlockDiagonalPreconditioner", _wrap_new_BlockDiagonalPreconditioner, METH_O, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, - { "BlockDiagonalPreconditioner_SetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS, "BlockDiagonalPreconditioner_SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, - { "BlockDiagonalPreconditioner_SetOperator", _wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS, "BlockDiagonalPreconditioner_SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, + { "new_BlockDiagonalPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockDiagonalPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, + { "BlockDiagonalPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, + { "BlockDiagonalPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, { "BlockDiagonalPreconditioner_NumBlocks", _wrap_BlockDiagonalPreconditioner_NumBlocks, METH_O, "BlockDiagonalPreconditioner_NumBlocks(BlockDiagonalPreconditioner self) -> int"}, - { "BlockDiagonalPreconditioner_GetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS, "BlockDiagonalPreconditioner_GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, + { "BlockDiagonalPreconditioner_GetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, { "BlockDiagonalPreconditioner_Offsets", _wrap_BlockDiagonalPreconditioner_Offsets, METH_O, "BlockDiagonalPreconditioner_Offsets(BlockDiagonalPreconditioner self) -> intArray"}, - { "BlockDiagonalPreconditioner_Mult", _wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS, "BlockDiagonalPreconditioner_Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, - { "BlockDiagonalPreconditioner_MultTranspose", _wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS, "BlockDiagonalPreconditioner_MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, { "delete_BlockDiagonalPreconditioner", _wrap_delete_BlockDiagonalPreconditioner, METH_O, "delete_BlockDiagonalPreconditioner(BlockDiagonalPreconditioner self)"}, { "BlockDiagonalPreconditioner_owns_blocks_set", _wrap_BlockDiagonalPreconditioner_owns_blocks_set, METH_VARARGS, "BlockDiagonalPreconditioner_owns_blocks_set(BlockDiagonalPreconditioner self, int owns_blocks)"}, { "BlockDiagonalPreconditioner_owns_blocks_get", _wrap_BlockDiagonalPreconditioner_owns_blocks_get, METH_O, "BlockDiagonalPreconditioner_owns_blocks_get(BlockDiagonalPreconditioner self) -> int"}, { "BlockDiagonalPreconditioner_swigregister", BlockDiagonalPreconditioner_swigregister, METH_O, NULL}, { "BlockDiagonalPreconditioner_swiginit", BlockDiagonalPreconditioner_swiginit, METH_VARARGS, NULL}, - { "new_BlockLowerTriangularPreconditioner", _wrap_new_BlockLowerTriangularPreconditioner, METH_O, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, - { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", _wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS, "BlockLowerTriangularPreconditioner_SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetBlock", _wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS, "BlockLowerTriangularPreconditioner_SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetOperator", _wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS, "BlockLowerTriangularPreconditioner_SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, + { "new_BlockLowerTriangularPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockLowerTriangularPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, + { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, { "BlockLowerTriangularPreconditioner_NumBlocks", _wrap_BlockLowerTriangularPreconditioner_NumBlocks, METH_O, "BlockLowerTriangularPreconditioner_NumBlocks(BlockLowerTriangularPreconditioner self) -> int"}, - { "BlockLowerTriangularPreconditioner_GetBlock", _wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS, "BlockLowerTriangularPreconditioner_GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, + { "BlockLowerTriangularPreconditioner_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, { "BlockLowerTriangularPreconditioner_Offsets", _wrap_BlockLowerTriangularPreconditioner_Offsets, METH_O, "BlockLowerTriangularPreconditioner_Offsets(BlockLowerTriangularPreconditioner self) -> intArray"}, - { "BlockLowerTriangularPreconditioner_Mult", _wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS, "BlockLowerTriangularPreconditioner_Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, - { "BlockLowerTriangularPreconditioner_MultTranspose", _wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS, "BlockLowerTriangularPreconditioner_MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, { "delete_BlockLowerTriangularPreconditioner", _wrap_delete_BlockLowerTriangularPreconditioner, METH_O, "delete_BlockLowerTriangularPreconditioner(BlockLowerTriangularPreconditioner self)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_set", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_set, METH_VARARGS, "BlockLowerTriangularPreconditioner_owns_blocks_set(BlockLowerTriangularPreconditioner self, int owns_blocks)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_get", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_get, METH_O, "BlockLowerTriangularPreconditioner_owns_blocks_get(BlockLowerTriangularPreconditioner self) -> int"}, @@ -5445,52 +5293,52 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, - { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, - { "Opr2HypreParMat", _wrap_Opr2HypreParMat, METH_O, "Opr2HypreParMat(Operator op) -> mfem::HypreParMatrix *"}, + { "Opr2BlockOpr", (PyCFunction)(void(*)(void))_wrap_Opr2BlockOpr, METH_VARARGS|METH_KEYWORDS, "Opr2BlockOpr(Operator op) -> BlockOperator"}, + { "Opr2SparseMat", (PyCFunction)(void(*)(void))_wrap_Opr2SparseMat, METH_VARARGS|METH_KEYWORDS, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, + { "Opr2HypreParMat", (PyCFunction)(void(*)(void))_wrap_Opr2HypreParMat, METH_VARARGS|METH_KEYWORDS, "Opr2HypreParMat(Operator op) -> mfem::HypreParMatrix *"}, { "new_BlockOperator", _wrap_new_BlockOperator, METH_VARARGS, "\n" "BlockOperator(intArray offsets)\n" "new_BlockOperator(intArray row_offsets, intArray col_offsets) -> BlockOperator\n" ""}, - { "BlockOperator_SetDiagonalBlock", _wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, - { "BlockOperator_SetBlock", _wrap_BlockOperator_SetBlock, METH_VARARGS, "SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, + { "BlockOperator_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, + { "BlockOperator_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlock, METH_VARARGS|METH_KEYWORDS, "SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, { "BlockOperator_NumRowBlocks", _wrap_BlockOperator_NumRowBlocks, METH_O, "NumRowBlocks(BlockOperator self) -> int"}, { "BlockOperator_NumColBlocks", _wrap_BlockOperator_NumColBlocks, METH_O, "NumColBlocks(BlockOperator self) -> int"}, - { "BlockOperator_IsZeroBlock", _wrap_BlockOperator_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockOperator self, int i, int j) -> int"}, - { "BlockOperator_GetBlock", _wrap_BlockOperator_GetBlock, METH_VARARGS, "GetBlock(BlockOperator self, int i, int j) -> Operator"}, - { "BlockOperator_GetBlockCoef", _wrap_BlockOperator_GetBlockCoef, METH_VARARGS, "GetBlockCoef(BlockOperator self, int i, int j) -> double"}, - { "BlockOperator_SetBlockCoef", _wrap_BlockOperator_SetBlockCoef, METH_VARARGS, "SetBlockCoef(BlockOperator self, int i, int j, double c)"}, + { "BlockOperator_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "IsZeroBlock(BlockOperator self, int i, int j) -> int"}, + { "BlockOperator_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlock, METH_VARARGS|METH_KEYWORDS, "GetBlock(BlockOperator self, int i, int j) -> Operator"}, + { "BlockOperator_GetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlockCoef, METH_VARARGS|METH_KEYWORDS, "GetBlockCoef(BlockOperator self, int i, int j) -> double"}, + { "BlockOperator_SetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlockCoef, METH_VARARGS|METH_KEYWORDS, "SetBlockCoef(BlockOperator self, int i, int j, double c)"}, { "BlockOperator_RowOffsets", _wrap_BlockOperator_RowOffsets, METH_O, "RowOffsets(BlockOperator self) -> intArray"}, { "BlockOperator_ColOffsets", _wrap_BlockOperator_ColOffsets, METH_O, "ColOffsets(BlockOperator self) -> intArray"}, - { "BlockOperator_Mult", _wrap_BlockOperator_Mult, METH_VARARGS, "Mult(BlockOperator self, Vector x, Vector y)"}, - { "BlockOperator_MultTranspose", _wrap_BlockOperator_MultTranspose, METH_VARARGS, "MultTranspose(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_Mult", (PyCFunction)(void(*)(void))_wrap_BlockOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockOperator self, Vector x, Vector y)"}, { "delete_BlockOperator", _wrap_delete_BlockOperator, METH_O, "delete_BlockOperator(BlockOperator self)"}, { "BlockOperator_owns_blocks_set", _wrap_BlockOperator_owns_blocks_set, METH_VARARGS, "BlockOperator_owns_blocks_set(BlockOperator self, int owns_blocks)"}, { "BlockOperator_owns_blocks_get", _wrap_BlockOperator_owns_blocks_get, METH_O, "BlockOperator_owns_blocks_get(BlockOperator self) -> int"}, { "BlockOperator_swigregister", BlockOperator_swigregister, METH_O, NULL}, { "BlockOperator_swiginit", BlockOperator_swiginit, METH_VARARGS, NULL}, - { "new_BlockDiagonalPreconditioner", _wrap_new_BlockDiagonalPreconditioner, METH_O, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, - { "BlockDiagonalPreconditioner_SetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, - { "BlockDiagonalPreconditioner_SetOperator", _wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, + { "new_BlockDiagonalPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockDiagonalPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, + { "BlockDiagonalPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, + { "BlockDiagonalPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, { "BlockDiagonalPreconditioner_NumBlocks", _wrap_BlockDiagonalPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockDiagonalPreconditioner self) -> int"}, - { "BlockDiagonalPreconditioner_GetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS, "GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, + { "BlockDiagonalPreconditioner_GetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, { "BlockDiagonalPreconditioner_Offsets", _wrap_BlockDiagonalPreconditioner_Offsets, METH_O, "Offsets(BlockDiagonalPreconditioner self) -> intArray"}, - { "BlockDiagonalPreconditioner_Mult", _wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS, "Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, - { "BlockDiagonalPreconditioner_MultTranspose", _wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, { "delete_BlockDiagonalPreconditioner", _wrap_delete_BlockDiagonalPreconditioner, METH_O, "delete_BlockDiagonalPreconditioner(BlockDiagonalPreconditioner self)"}, { "BlockDiagonalPreconditioner_owns_blocks_set", _wrap_BlockDiagonalPreconditioner_owns_blocks_set, METH_VARARGS, "BlockDiagonalPreconditioner_owns_blocks_set(BlockDiagonalPreconditioner self, int owns_blocks)"}, { "BlockDiagonalPreconditioner_owns_blocks_get", _wrap_BlockDiagonalPreconditioner_owns_blocks_get, METH_O, "BlockDiagonalPreconditioner_owns_blocks_get(BlockDiagonalPreconditioner self) -> int"}, { "BlockDiagonalPreconditioner_swigregister", BlockDiagonalPreconditioner_swigregister, METH_O, NULL}, { "BlockDiagonalPreconditioner_swiginit", BlockDiagonalPreconditioner_swiginit, METH_VARARGS, NULL}, - { "new_BlockLowerTriangularPreconditioner", _wrap_new_BlockLowerTriangularPreconditioner, METH_O, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, - { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", _wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetBlock", _wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS, "SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetOperator", _wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, + { "new_BlockLowerTriangularPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockLowerTriangularPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, + { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS|METH_KEYWORDS, "SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, { "BlockLowerTriangularPreconditioner_NumBlocks", _wrap_BlockLowerTriangularPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockLowerTriangularPreconditioner self) -> int"}, - { "BlockLowerTriangularPreconditioner_GetBlock", _wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS, "GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, + { "BlockLowerTriangularPreconditioner_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS|METH_KEYWORDS, "GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, { "BlockLowerTriangularPreconditioner_Offsets", _wrap_BlockLowerTriangularPreconditioner_Offsets, METH_O, "Offsets(BlockLowerTriangularPreconditioner self) -> intArray"}, - { "BlockLowerTriangularPreconditioner_Mult", _wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS, "Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, - { "BlockLowerTriangularPreconditioner_MultTranspose", _wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, { "delete_BlockLowerTriangularPreconditioner", _wrap_delete_BlockLowerTriangularPreconditioner, METH_O, "delete_BlockLowerTriangularPreconditioner(BlockLowerTriangularPreconditioner self)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_set", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_set, METH_VARARGS, "BlockLowerTriangularPreconditioner_owns_blocks_set(BlockLowerTriangularPreconditioner self, int owns_blocks)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_get", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_get, METH_O, "BlockLowerTriangularPreconditioner_owns_blocks_get(BlockLowerTriangularPreconditioner self) -> int"}, diff --git a/mfem/_par/blockvector_wrap.cxx b/mfem/_par/blockvector_wrap.cxx index 93b93065..1c04eed4 100644 --- a/mfem/_par/blockvector_wrap.cxx +++ b/mfem/_par/blockvector_wrap.cxx @@ -3381,7 +3381,7 @@ SWIGINTERN PyObject *_wrap_BlockVector_GetBlock(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockVector *arg1 = (mfem::BlockVector *) 0 ; int arg2 ; @@ -3390,21 +3390,26 @@ SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"blockView", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockVector_GetBlockView", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockVector_GetBlockView", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockVector_GetBlockView" "', argument " "1"" of type '" "mfem::BlockVector *""'"); } arg1 = reinterpret_cast< mfem::BlockVector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockVector_GetBlockView" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3435,26 +3440,30 @@ SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BlockVector_BlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockVector_BlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockVector *arg1 = (mfem::BlockVector *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockVector_BlockSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockVector_BlockSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockVector_BlockSize" "', argument " "1"" of type '" "mfem::BlockVector *""'"); } arg1 = reinterpret_cast< mfem::BlockVector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3728,8 +3737,8 @@ static PyMethodDef SwigMethods[] = { "BlockVector_GetBlock(BlockVector self, int i) -> Vector\n" "BlockVector_GetBlock(BlockVector self, int i) -> Vector\n" ""}, - { "BlockVector_GetBlockView", _wrap_BlockVector_GetBlockView, METH_VARARGS, "BlockVector_GetBlockView(BlockVector self, int i, Vector blockView)"}, - { "BlockVector_BlockSize", _wrap_BlockVector_BlockSize, METH_VARARGS, "BlockVector_BlockSize(BlockVector self, int i) -> int"}, + { "BlockVector_GetBlockView", (PyCFunction)(void(*)(void))_wrap_BlockVector_GetBlockView, METH_VARARGS|METH_KEYWORDS, "BlockVector_GetBlockView(BlockVector self, int i, Vector blockView)"}, + { "BlockVector_BlockSize", (PyCFunction)(void(*)(void))_wrap_BlockVector_BlockSize, METH_VARARGS|METH_KEYWORDS, "BlockVector_BlockSize(BlockVector self, int i) -> int"}, { "BlockVector_Update", _wrap_BlockVector_Update, METH_VARARGS, "\n" "BlockVector_Update(BlockVector self, double * data, intArray bOffsets)\n" "BlockVector_Update(BlockVector self, intArray bOffsets)\n" @@ -3755,8 +3764,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetBlock(BlockVector self, int i) -> Vector\n" "GetBlock(BlockVector self, int i) -> Vector\n" ""}, - { "BlockVector_GetBlockView", _wrap_BlockVector_GetBlockView, METH_VARARGS, "GetBlockView(BlockVector self, int i, Vector blockView)"}, - { "BlockVector_BlockSize", _wrap_BlockVector_BlockSize, METH_VARARGS, "BlockSize(BlockVector self, int i) -> int"}, + { "BlockVector_GetBlockView", (PyCFunction)(void(*)(void))_wrap_BlockVector_GetBlockView, METH_VARARGS|METH_KEYWORDS, "GetBlockView(BlockVector self, int i, Vector blockView)"}, + { "BlockVector_BlockSize", (PyCFunction)(void(*)(void))_wrap_BlockVector_BlockSize, METH_VARARGS|METH_KEYWORDS, "BlockSize(BlockVector self, int i) -> int"}, { "BlockVector_Update", _wrap_BlockVector_Update, METH_VARARGS, "\n" "Update(BlockVector self, double * data, intArray bOffsets)\n" "Update(BlockVector self, intArray bOffsets)\n" diff --git a/mfem/_par/coefficient_wrap.cxx b/mfem/_par/coefficient_wrap.cxx index 90433d8a..7d98da31 100644 --- a/mfem/_par/coefficient_wrap.cxx +++ b/mfem/_par/coefficient_wrap.cxx @@ -3916,7 +3916,7 @@ void SwigDirector_MatrixPyCoefficientBase::_EvalPyT(mfem::Vector &arg0, double a #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_Coefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Coefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; double arg2 ; @@ -3924,15 +3924,19 @@ SWIGINTERN PyObject *_wrap_Coefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Coefficient_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Coefficient_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coefficient_SetTime" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Coefficient_SetTime" "', argument " "2"" of type '" "double""'"); } @@ -4263,47 +4267,28 @@ SWIGINTERN PyObject *_wrap_ConstantCoefficient_constant_get(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_ConstantCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"c", NULL + }; mfem::ConstantCoefficient *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantCoefficient" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::ConstantCoefficient *)new mfem::ConstantCoefficient(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_ConstantCoefficient", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantCoefficient" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstantCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ConstantCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::ConstantCoefficient *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::ConstantCoefficient *)new mfem::ConstantCoefficient(); + result = (mfem::ConstantCoefficient *)new mfem::ConstantCoefficient(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4321,38 +4306,7 @@ SWIGINTERN PyObject *_wrap_new_ConstantCoefficient__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_ConstantCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstantCoefficient", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_ConstantCoefficient__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ConstantCoefficient__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstantCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ConstantCoefficient::ConstantCoefficient(double)\n" - " mfem::ConstantCoefficient::ConstantCoefficient()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConstantCoefficient *arg1 = (mfem::ConstantCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -4363,16 +4317,21 @@ SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ConstantCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstantCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstantCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConstantCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantCoefficient_Eval" "', argument " "1"" of type '" "mfem::ConstantCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ConstantCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -4380,7 +4339,7 @@ SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4455,44 +4414,21 @@ SWIGINTERN PyObject *ConstantCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self) SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 0 ; mfem::PWConstCoefficient *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::PWConstCoefficient *)new mfem::PWConstCoefficient(arg1); + if ((nobjs < 0) || (nobjs > 1)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PWConstCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::PWConstCoefficient *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::PWConstCoefficient *)new mfem::PWConstCoefficient(); + result = (mfem::PWConstCoefficient *)new mfem::PWConstCoefficient(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4510,7 +4446,7 @@ SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; @@ -4554,20 +4490,11 @@ SWIGINTERN PyObject *_wrap_new_PWConstCoefficient(PyObject *self, PyObject *args if (!(argc = SWIG_Python_UnpackTuple(args, "new_PWConstCoefficient", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_PWConstCoefficient__SWIG_1(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 1)) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_PWConstCoefficient__SWIG_2(self, argc, argv); + if (argc <= 0) { + return _wrap_new_PWConstCoefficient__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4580,18 +4507,26 @@ SWIGINTERN PyObject *_wrap_new_PWConstCoefficient(PyObject *self, PyObject *args return _wrap_new_PWConstCoefficient__SWIG_0(self, argc, argv); } } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_PWConstCoefficient__SWIG_1(self, argc, argv); + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PWConstCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::PWConstCoefficient::PWConstCoefficient(int)\n" - " mfem::PWConstCoefficient::PWConstCoefficient()\n" " mfem::PWConstCoefficient::PWConstCoefficient(mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PWConstCoefficient *arg1 = (mfem::PWConstCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4599,15 +4534,19 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PWConstCoefficient_UpdateConstants", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PWConstCoefficient_UpdateConstants", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PWConstCoefficient_UpdateConstants" "', argument " "1"" of type '" "mfem::PWConstCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PWConstCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PWConstCoefficient_UpdateConstants" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4635,26 +4574,30 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_PWConstCoefficient___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PWConstCoefficient___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PWConstCoefficient *arg1 = (mfem::PWConstCoefficient *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PWConstCoefficient___call__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PWConstCoefficient___call__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PWConstCoefficient___call__" "', argument " "1"" of type '" "mfem::PWConstCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PWConstCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4711,7 +4654,7 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_GetNConst(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PWConstCoefficient *arg1 = (mfem::PWConstCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -4722,16 +4665,21 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "PWConstCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PWConstCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PWConstCoefficient_Eval" "', argument " "1"" of type '" "mfem::PWConstCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PWConstCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PWConstCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -4739,7 +4687,7 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PWConstCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PWConstCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4996,7 +4944,7 @@ SWIGINTERN PyObject *_wrap_new_FunctionCoefficient(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FunctionCoefficient *arg1 = (mfem::FunctionCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5007,16 +4955,21 @@ SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "FunctionCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::FunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::FunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5024,7 +4977,7 @@ SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5125,59 +5078,28 @@ SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient__SWIG_0(PyObject *SWIGUNU SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; mfem::GridFunctionCoefficient *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::GridFunctionCoefficient *)new mfem::GridFunctionCoefficient(arg1,arg2); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunctionCoefficient *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { try { - result = (mfem::GridFunctionCoefficient *)new mfem::GridFunctionCoefficient(arg1); + result = (mfem::GridFunctionCoefficient *)new mfem::GridFunctionCoefficient(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5206,21 +5128,15 @@ SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient(PyObject *self, PyObject if (argc == 0) { return _wrap_new_GridFunctionCoefficient__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GridFunctionCoefficient__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_GridFunctionCoefficient__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5239,13 +5155,12 @@ SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GridFunctionCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::GridFunctionCoefficient::GridFunctionCoefficient()\n" - " mfem::GridFunctionCoefficient::GridFunctionCoefficient(mfem::GridFunction *,int)\n" - " mfem::GridFunctionCoefficient::GridFunctionCoefficient(mfem::GridFunction *)\n"); + " mfem::GridFunctionCoefficient::GridFunctionCoefficient(mfem::GridFunction *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunctionCoefficient *arg1 = (mfem::GridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -5253,15 +5168,19 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_SetGridFunction(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::GridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::GridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -5321,7 +5240,7 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_GetGridFunction(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunctionCoefficient *arg1 = (mfem::GridFunctionCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5332,16 +5251,21 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "GridFunctionCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::GridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::GridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5349,7 +5273,7 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5561,7 +5485,7 @@ SWIGINTERN PyObject *_wrap_new_TransformedCoefficient(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransformedCoefficient *arg1 = (mfem::TransformedCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5572,16 +5496,21 @@ SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "TransformedCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransformedCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransformedCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransformedCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformedCoefficient_Eval" "', argument " "1"" of type '" "mfem::TransformedCoefficient *""'"); } arg1 = reinterpret_cast< mfem::TransformedCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5589,7 +5518,7 @@ SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransformedCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5923,7 +5852,7 @@ SWIGINTERN PyObject *_wrap_new_DeltaCoefficient(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5931,15 +5860,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetDeltaCenter" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_SetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5967,7 +5900,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; double arg2 ; @@ -5975,15 +5908,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetScale", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetScale", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetScale" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeltaCoefficient_SetScale" "', argument " "2"" of type '" "double""'"); } @@ -6008,22 +5945,26 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; double (*arg2)(double) = (double (*)(double)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetFunction" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_double__double); + int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double__double); if (!SWIG_IsOK(res)) { SWIG_exception_fail(SWIG_ArgError(res), "in method '" "DeltaCoefficient_SetFunction" "', argument " "2"" of type '" "double (*)(double)""'"); } @@ -6048,7 +5989,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetFunction(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; double arg2 ; @@ -6056,15 +5997,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetTol" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeltaCoefficient_SetTol" "', argument " "2"" of type '" "double""'"); } @@ -6089,7 +6034,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; @@ -6097,15 +6042,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetWeight(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"w", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetWeight", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetWeight", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetWeight" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_SetWeight" "', argument " "2"" of type '" "mfem::Coefficient *""'"); } @@ -6270,7 +6219,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_Weight(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6278,15 +6227,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_GetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_GetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_GetDeltaCenter" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_GetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6314,7 +6267,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6325,16 +6278,21 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_EvalDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeltaCoefficient_EvalDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_EvalDelta" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6342,7 +6300,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeltaCoefficient_EvalDelta" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -6370,7 +6328,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6381,16 +6339,21 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeltaCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_Eval" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6398,7 +6361,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeltaCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -6471,7 +6434,7 @@ SWIGINTERN PyObject *DeltaCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; @@ -6479,11 +6442,15 @@ SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_c", (char *)"attr", NULL + }; mfem::RestrictedCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_RestrictedCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_RestrictedCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RestrictedCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -6491,7 +6458,7 @@ SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RestrictedCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RestrictedCoefficient" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -6519,7 +6486,7 @@ SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RestrictedCoefficient *arg1 = (mfem::RestrictedCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6530,16 +6497,21 @@ SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "RestrictedCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RestrictedCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RestrictedCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RestrictedCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RestrictedCoefficient_Eval" "', argument " "1"" of type '" "mfem::RestrictedCoefficient *""'"); } arg1 = reinterpret_cast< mfem::RestrictedCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6547,7 +6519,7 @@ SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RestrictedCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -6620,7 +6592,7 @@ SWIGINTERN PyObject *RestrictedCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_VectorCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = (mfem::VectorCoefficient *) 0 ; double arg2 ; @@ -6628,15 +6600,19 @@ SWIGINTERN PyObject *_wrap_VectorCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorCoefficient_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorCoefficient_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCoefficient_SetTime" "', argument " "1"" of type '" "mfem::VectorCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorCoefficient_SetTime" "', argument " "2"" of type '" "double""'"); } @@ -6966,17 +6942,19 @@ SWIGINTERN PyObject *VectorCoefficient_swigregister(PyObject *SWIGUNUSEDPARM(sel return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_VectorConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"v", NULL + }; mfem::VectorConstantCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorConstantCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorConstantCoefficient" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -7371,12 +7349,12 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_0(PyObject *SWIGU PyObject *resultobj = 0; int arg1 ; void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp3 = 0 ; int res3 = 0 ; mfem::VectorFunctionCoefficient *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -7389,11 +7367,13 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); { try { result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2,arg3); @@ -7417,10 +7397,13 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; + void (*arg2)(mfem::Vector const &,double,mfem::Vector &) = (void (*)(mfem::Vector const &,double,mfem::Vector &)) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; + void *argp3 = 0 ; + int res3 = 0 ; mfem::VectorFunctionCoefficient *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -7428,100 +7411,21 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_1(PyObject *SWIGU arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::Vector &)""'"); + } + } + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } { try { - result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,double,mfem::Vector &) = (void (*)(mfem::Vector const &,double,mfem::Vector &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::VectorFunctionCoefficient *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::Vector &)""'"); - } - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,double,mfem::Vector &) = (void (*)(mfem::Vector const &,double,mfem::Vector &)) 0 ; - mfem::VectorFunctionCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::Vector &)""'"); - } - } - { - try { - result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2); + result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7547,7 +7451,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFunctionCoefficient", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -7562,54 +7466,19 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_new_VectorFunctionCoefficient__SWIG_0(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_2(self, argc, argv); + return _wrap_new_VectorFunctionCoefficient__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -7621,14 +7490,17 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec } if (_v) { void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_VectorFunctionCoefficient__SWIG_1(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_0(self, argc, argv); + return _wrap_new_VectorFunctionCoefficient__SWIG_1(self, argc, argv); } } } @@ -7638,9 +7510,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFunctionCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::Vector &),mfem::Coefficient *)\n" - " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::Vector &))\n" - " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::Vector &),mfem::Coefficient *)\n" - " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::Vector &))\n"); + " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::Vector &),mfem::Coefficient *)\n"); return 0; } @@ -7973,19 +7843,21 @@ SWIGINTERN PyObject *VectorFunctionCoefficient_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"dim", NULL + }; mfem::VectorArrayCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorArrayCoefficient", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -8007,26 +7879,30 @@ SWIGINTERN PyObject *_wrap_new_VectorArrayCoefficient(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::Coefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorArrayCoefficient_GetCoeff", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorArrayCoefficient_GetCoeff", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_GetCoeff" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -8083,91 +7959,53 @@ SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_GetCoeffs(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; int arg2 ; mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; - bool arg4 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"c", (char *)"own", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:VectorArrayCoefficient_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorArrayCoefficient_Set" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorArrayCoefficient_Set" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - (arg1)->Set(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; - int arg2 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); - } - arg1 = reinterpret_cast< mfem::VectorArrayCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorArrayCoefficient_Set" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorArrayCoefficient_Set" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); { try { - (arg1)->Set(arg2,arg3); + (arg1)->Set(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8185,78 +8023,6 @@ SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "VectorArrayCoefficient_Set", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorArrayCoefficient_Set__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorArrayCoefficient_Set__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorArrayCoefficient_Set'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorArrayCoefficient::Set(int,mfem::Coefficient *,bool)\n" - " mfem::VectorArrayCoefficient::Set(int,mfem::Coefficient *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; @@ -8764,7 +8530,7 @@ SWIGINTERN PyObject *_wrap_new_VectorGridFunctionCoefficient(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_VectorGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorGridFunctionCoefficient *arg1 = (mfem::VectorGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -8772,15 +8538,19 @@ SWIGINTERN PyObject *_wrap_VectorGridFunctionCoefficient_SetGridFunction(PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::VectorGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -9079,17 +8849,19 @@ SWIGINTERN PyObject *VectorGridFunctionCoefficient_swiginit(PyObject *SWIGUNUSED return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GradientGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GradientGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"gf", NULL + }; mfem::GradientGridFunctionCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_GradientGridFunctionCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GradientGridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } @@ -9114,7 +8886,7 @@ SWIGINTERN PyObject *_wrap_new_GradientGridFunctionCoefficient(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GradientGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientGridFunctionCoefficient *arg1 = (mfem::GradientGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -9122,15 +8894,19 @@ SWIGINTERN PyObject *_wrap_GradientGridFunctionCoefficient_SetGridFunction(PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GradientGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::GradientGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::GradientGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -9429,7 +9205,7 @@ SWIGINTERN PyObject *GradientGridFunctionCoefficient_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_CurlGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlGridFunctionCoefficient *arg1 = (mfem::CurlGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -9437,15 +9213,19 @@ SWIGINTERN PyObject *_wrap_CurlGridFunctionCoefficient_SetGridFunction(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CurlGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::CurlGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::CurlGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -9829,17 +9609,19 @@ SWIGINTERN PyObject *CurlGridFunctionCoefficient_swigregister(PyObject *SWIGUNUS return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_DivergenceGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DivergenceGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"gf", NULL + }; mfem::DivergenceGridFunctionCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_DivergenceGridFunctionCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DivergenceGridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } @@ -9864,7 +9646,7 @@ SWIGINTERN PyObject *_wrap_new_DivergenceGridFunctionCoefficient(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivergenceGridFunctionCoefficient *arg1 = (mfem::DivergenceGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -9872,15 +9654,19 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_SetGridFunction(PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DivergenceGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DivergenceGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::DivergenceGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DivergenceGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -9940,7 +9726,7 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_GetGridFunction(PyO } -SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivergenceGridFunctionCoefficient *arg1 = (mfem::DivergenceGridFunctionCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -9951,16 +9737,21 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DivergenceGridFunctionCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DivergenceGridFunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::DivergenceGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DivergenceGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -9968,7 +9759,7 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10410,7 +10201,7 @@ SWIGINTERN PyObject *_wrap_new_VectorDeltaCoefficient(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::DeltaCoefficient *arg2 = 0 ; @@ -10418,15 +10209,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCoefficient(PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetDeltaCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetDeltaCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetDeltaCoefficient" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_SetDeltaCoefficient" "', argument " "2"" of type '" "mfem::DeltaCoefficient const &""'"); } @@ -10489,7 +10284,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCoefficient(PyObject * } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; double arg2 ; @@ -10497,15 +10292,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDP int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetScale", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetScale", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetScale" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDeltaCoefficient_SetScale" "', argument " "2"" of type '" "double""'"); } @@ -10530,7 +10329,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10538,15 +10337,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetDirection", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetDirection", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetDirection" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_SetDirection" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -10574,7 +10377,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10582,15 +10385,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetDeltaCenter" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_SetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -10618,7 +10425,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10626,15 +10433,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_GetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_GetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_GetDeltaCenter" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_GetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -10662,7 +10473,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10676,15 +10487,21 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"V", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_EvalDelta", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorDeltaCoefficient_EvalDelta", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -10692,7 +10509,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10700,7 +10517,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11056,7 +10873,7 @@ SWIGINTERN PyObject *VectorDeltaCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; @@ -11064,11 +10881,15 @@ SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"vc", (char *)"attr", NULL + }; mfem::VectorRestrictedCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorRestrictedCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_VectorRestrictedCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorRestrictedCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -11076,7 +10897,7 @@ SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorRestrictedCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorRestrictedCoefficient" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -11343,7 +11164,7 @@ SWIGINTERN PyObject *VectorRestrictedCoefficient_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MatrixCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; double arg2 ; @@ -11351,15 +11172,19 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixCoefficient_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MatrixCoefficient_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixCoefficient_SetTime" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixCoefficient_SetTime" "', argument " "2"" of type '" "double""'"); } @@ -11524,7 +11349,7 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_GetVDim(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -11538,15 +11363,21 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self) int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -11554,7 +11385,7 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11562,7 +11393,7 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11631,17 +11462,19 @@ SWIGINTERN PyObject *MatrixCoefficient_swigregister(PyObject *SWIGUNUSEDPARM(sel return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_MatrixConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"m", NULL + }; mfem::MatrixConstantCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MatrixConstantCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixConstantCoefficient" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -11912,12 +11745,12 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_0(PyObject *SWIGU PyObject *resultobj = 0; int arg1 ; void (*arg2)(mfem::Vector const &,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,mfem::DenseMatrix &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp3 = 0 ; int res3 = 0 ; mfem::MatrixFunctionCoefficient *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -11930,11 +11763,13 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::DenseMatrix &)""'"); } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); { try { result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2,arg3); @@ -11956,45 +11791,6 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,mfem::DenseMatrix &)) 0 ; - mfem::MatrixFunctionCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__DenseMatrix__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::DenseMatrix &)""'"); - } - } - { - try { - result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; @@ -12041,16 +11837,16 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_2(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; void (*arg2)(mfem::Vector const &,double,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp3 = 0 ; int res3 = 0 ; mfem::MatrixFunctionCoefficient *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -12063,53 +11859,16 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_3(PyObject *SWIGU SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)""'"); } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,double,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)) 0 ; - mfem::MatrixFunctionCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__DenseMatrix__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } { try { - result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2); + result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12143,50 +11902,12 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__DenseMatrix__void); - _v = SWIG_CheckState(res); if (_v) { return _wrap_new_MatrixFunctionCoefficient__SWIG_1(self, argc, argv); } } } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__DenseMatrix__void); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -12198,19 +11919,22 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec } if (_v) { void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__DenseMatrix__void); + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__DenseMatrix__void); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_MatrixFunctionCoefficient__SWIG_0(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_3(self, argc, argv); + return _wrap_new_MatrixFunctionCoefficient__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -12222,14 +11946,17 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec } if (_v) { void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__DenseMatrix__void); + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__DenseMatrix__void); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_MatrixFunctionCoefficient__SWIG_2(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_0(self, argc, argv); + return _wrap_new_MatrixFunctionCoefficient__SWIG_2(self, argc, argv); } } } @@ -12239,15 +11966,13 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MatrixFunctionCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::DenseMatrix &),mfem::Coefficient *)\n" - " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::DenseMatrix &))\n" " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(mfem::DenseMatrix const &,mfem::Coefficient &)\n" - " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::DenseMatrix &),mfem::Coefficient *)\n" - " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::DenseMatrix &))\n"); + " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::DenseMatrix &),mfem::Coefficient *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixFunctionCoefficient *arg1 = (mfem::MatrixFunctionCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12261,15 +11986,21 @@ SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixFunctionCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixFunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12277,7 +12008,7 @@ SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12285,7 +12016,7 @@ SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12358,19 +12089,21 @@ SWIGINTERN PyObject *MatrixFunctionCoefficient_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"dim", NULL + }; mfem::MatrixArrayCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MatrixArrayCoefficient", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -12392,33 +12125,38 @@ SWIGINTERN PyObject *_wrap_new_MatrixArrayCoefficient(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; mfem::Coefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MatrixArrayCoefficient_GetCoeff", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MatrixArrayCoefficient_GetCoeff", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_GetCoeff" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12440,48 +12178,58 @@ SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; int arg2 ; int arg3 ; mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - bool arg5 ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; bool val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"c", (char *)"own", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:MatrixArrayCoefficient_Set", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixArrayCoefficient_Set" "', argument " "4"" of type '" "mfem::Coefficient *""'"); } arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MatrixArrayCoefficient_Set" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MatrixArrayCoefficient_Set" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } { try { (arg1)->Set(arg2,arg3,arg4,arg5); @@ -12502,21 +12250,25 @@ SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; int arg2 ; int arg3 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; + mfem::ElementTransformation *arg4 = 0 ; + mfem::IntegrationPoint *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixArrayCoefficient * >(argp1); { @@ -12531,14 +12283,25 @@ SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUS }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixArrayCoefficient_Set" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MatrixArrayCoefficient_Eval" "', argument " "5"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixArrayCoefficient_Eval" "', argument " "5"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg5 = reinterpret_cast< mfem::IntegrationPoint * >(argp5); { try { - (arg1)->Set(arg2,arg3,arg4); + result = (double)(arg1)->Eval(arg2,arg3,*arg4,(mfem::IntegrationPoint const &)*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12549,168 +12312,7 @@ SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MatrixArrayCoefficient_Set", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MatrixArrayCoefficient_Set__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MatrixArrayCoefficient_Set__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MatrixArrayCoefficient_Set'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MatrixArrayCoefficient::Set(int,int,mfem::Coefficient *,bool)\n" - " mfem::MatrixArrayCoefficient::Set(int,int,mfem::Coefficient *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; - int arg2 ; - int arg3 ; - mfem::ElementTransformation *arg4 = 0 ; - mfem::IntegrationPoint *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); - } - arg1 = reinterpret_cast< mfem::MatrixArrayCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); - } - arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MatrixArrayCoefficient_Eval" "', argument " "5"" of type '" "mfem::IntegrationPoint const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixArrayCoefficient_Eval" "', argument " "5"" of type '" "mfem::IntegrationPoint const &""'"); - } - arg5 = reinterpret_cast< mfem::IntegrationPoint * >(argp5); - { - try { - result = (double)(arg1)->Eval(arg2,arg3,*arg4,(mfem::IntegrationPoint const &)*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; @@ -12906,7 +12508,7 @@ SWIGINTERN PyObject *MatrixArrayCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; @@ -12914,11 +12516,15 @@ SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"mc", (char *)"attr", NULL + }; mfem::MatrixRestrictedCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_MatrixRestrictedCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_MatrixRestrictedCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixRestrictedCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -12926,7 +12532,7 @@ SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixRestrictedCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixRestrictedCoefficient" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -12954,7 +12560,7 @@ SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixRestrictedCoefficient *arg1 = (mfem::MatrixRestrictedCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12968,15 +12574,21 @@ SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixRestrictedCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixRestrictedCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixRestrictedCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixRestrictedCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixRestrictedCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixRestrictedCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12984,7 +12596,7 @@ SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12992,7 +12604,7 @@ SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13065,12 +12677,12 @@ SWIGINTERN PyObject *MatrixRestrictedCoefficient_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SumCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + double arg3 = (double) 1.0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13079,122 +12691,17 @@ SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(s int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"_alpha", (char *)"_beta", NULL + }; mfem::SumCoefficient *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SumCoefficient" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::SumCoefficient *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SumCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_SumCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -13202,114 +12709,49 @@ SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - try { - result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SumCoefficient", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_SumCoefficient__SWIG_2(self, argc, argv); - } - } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SumCoefficient" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SumCoefficient__SWIG_1(self, argc, argv); - } - } - } + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SumCoefficient" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SumCoefficient__SWIG_0(self, argc, argv); - } - } - } + { + try { + result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2,arg3,arg4); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SumCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SumCoefficient::SumCoefficient(mfem::Coefficient &,mfem::Coefficient &,double,double)\n" - " mfem::SumCoefficient::SumCoefficient(mfem::Coefficient &,mfem::Coefficient &,double)\n" - " mfem::SumCoefficient::SumCoefficient(mfem::Coefficient &,mfem::Coefficient &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SumCoefficient *arg1 = (mfem::SumCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -13320,16 +12762,21 @@ SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "SumCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SumCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SumCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumCoefficient_Eval" "', argument " "1"" of type '" "mfem::SumCoefficient *""'"); } arg1 = reinterpret_cast< mfem::SumCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -13337,7 +12784,7 @@ SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SumCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13410,7 +12857,7 @@ SWIGINTERN PyObject *SumCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; @@ -13418,11 +12865,15 @@ SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::ProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -13430,7 +12881,7 @@ SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ProductCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } @@ -13458,7 +12909,7 @@ SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ProductCoefficient *arg1 = (mfem::ProductCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -13469,16 +12920,21 @@ SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ProductCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::ProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -13486,7 +12942,7 @@ SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13559,7 +13015,7 @@ SWIGINTERN PyObject *ProductCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; double arg2 ; @@ -13567,11 +13023,15 @@ SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"_p", NULL + }; mfem::PowerCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_PowerCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_PowerCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PowerCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -13579,7 +13039,7 @@ SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PowerCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PowerCoefficient" "', argument " "2"" of type '" "double""'"); } @@ -13604,7 +13064,7 @@ SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PowerCoefficient *arg1 = (mfem::PowerCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -13615,16 +13075,21 @@ SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "PowerCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PowerCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PowerCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PowerCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerCoefficient_Eval" "', argument " "1"" of type '" "mfem::PowerCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PowerCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PowerCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -13632,7 +13097,7 @@ SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowerCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PowerCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13705,7 +13170,7 @@ SWIGINTERN PyObject *PowerCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -13713,11 +13178,15 @@ SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::InnerProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_InnerProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_InnerProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InnerProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13725,7 +13194,7 @@ SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InnerProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InnerProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13753,7 +13222,7 @@ SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InnerProductCoefficient *arg1 = (mfem::InnerProductCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -13764,16 +13233,21 @@ SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "InnerProductCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InnerProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InnerProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InnerProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InnerProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::InnerProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::InnerProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InnerProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -13781,7 +13255,7 @@ SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InnerProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InnerProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13854,7 +13328,7 @@ SWIGINTERN PyObject *InnerProductCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -13862,11 +13336,15 @@ SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::VectorRotProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorRotProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_VectorRotProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorRotProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13874,7 +13352,7 @@ SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorRotProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorRotProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13902,7 +13380,7 @@ SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorRotProductCoefficient *arg1 = (mfem::VectorRotProductCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -13913,16 +13391,21 @@ SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "VectorRotProductCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorRotProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorRotProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorRotProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorRotProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::VectorRotProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorRotProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorRotProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -13930,7 +13413,7 @@ SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorRotProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorRotProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14003,17 +13486,19 @@ SWIGINTERN PyObject *VectorRotProductCoefficient_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DeterminantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DeterminantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"A", NULL + }; mfem::DeterminantCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_DeterminantCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeterminantCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -14041,7 +13526,7 @@ SWIGINTERN PyObject *_wrap_new_DeterminantCoefficient(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeterminantCoefficient *arg1 = (mfem::DeterminantCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -14052,16 +13537,21 @@ SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DeterminantCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeterminantCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeterminantCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeterminantCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeterminantCoefficient_Eval" "', argument " "1"" of type '" "mfem::DeterminantCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeterminantCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeterminantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -14069,7 +13559,7 @@ SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeterminantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeterminantCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14142,12 +13632,12 @@ SWIGINTERN PyObject *DeterminantCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + double arg3 = (double) 1.0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -14156,122 +13646,17 @@ SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_0(PyObject *SWIGUNUSED int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"_alpha", (char *)"_beta", NULL + }; mfem::VectorSumCoefficient *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VectorSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VectorSumCoefficient" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::VectorSumCoefficient *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VectorSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::VectorSumCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_VectorSumCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14279,7 +13664,7 @@ SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_2(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14287,102 +13672,37 @@ SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_2(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorSumCoefficient", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorSumCoefficient__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorSumCoefficient__SWIG_1(self, argc, argv); - } - } - } + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VectorSumCoefficient" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorSumCoefficient__SWIG_0(self, argc, argv); - } - } - } + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VectorSumCoefficient" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + { + try { + result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2,arg3,arg4); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorSumCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorSumCoefficient::VectorSumCoefficient(mfem::VectorCoefficient &,mfem::VectorCoefficient &,double,double)\n" - " mfem::VectorSumCoefficient::VectorSumCoefficient(mfem::VectorCoefficient &,mfem::VectorCoefficient &,double)\n" - " mfem::VectorSumCoefficient::VectorSumCoefficient(mfem::VectorCoefficient &,mfem::VectorCoefficient &)\n"); - return 0; + return NULL; } @@ -14625,7 +13945,7 @@ SWIGINTERN PyObject *VectorSumCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -14633,11 +13953,15 @@ SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::ScalarVectorProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ScalarVectorProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ScalarVectorProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -14645,7 +13969,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarVectorProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScalarVectorProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14912,7 +14236,7 @@ SWIGINTERN PyObject *ScalarVectorProductCoefficient_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -14920,11 +14244,15 @@ SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::VectorCrossProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorCrossProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_VectorCrossProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14932,7 +14260,7 @@ SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCrossProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorCrossProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -15199,7 +14527,7 @@ SWIGINTERN PyObject *VectorCrossProductCoefficient_swiginit(PyObject *SWIGUNUSED return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -15207,11 +14535,15 @@ SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::MatVecCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_MatVecCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_MatVecCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatVecCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -15219,7 +14551,7 @@ SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatVecCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatVecCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -15486,19 +14818,21 @@ SWIGINTERN PyObject *MatVecCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IdentityMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_IdentityMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"d", NULL + }; mfem::IdentityMatrixCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_IdentityMatrixCoefficient", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -15520,7 +14854,7 @@ SWIGINTERN PyObject *_wrap_new_IdentityMatrixCoefficient(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityMatrixCoefficient *arg1 = (mfem::IdentityMatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -15534,15 +14868,21 @@ SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityMatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityMatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IdentityMatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityMatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::IdentityMatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::IdentityMatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -15550,7 +14890,7 @@ SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15558,7 +14898,7 @@ SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15631,12 +14971,12 @@ SWIGINTERN PyObject *IdentityMatrixCoefficient_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; mfem::MatrixCoefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + double arg3 = (double) 1.0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -15645,237 +14985,67 @@ SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_0(PyObject *SWIGUNUSED int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; - mfem::MatrixSumCoefficient *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MatrixSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MatrixSumCoefficient" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - mfem::MatrixCoefficient *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::MatrixSumCoefficient *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MatrixSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - mfem::MatrixCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::MatrixSumCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - { - try { - result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"_alpha", (char *)"_beta", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MatrixSumCoefficient", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MatrixSumCoefficient__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MatrixSumCoefficient__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MatrixSumCoefficient__SWIG_0(self, argc, argv); - } - } - } + mfem::MatrixSumCoefficient *result = 0 ; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_MatrixSumCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MatrixSumCoefficient" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MatrixSumCoefficient" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + { + try { + result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2,arg3,arg4); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MatrixSumCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MatrixSumCoefficient::MatrixSumCoefficient(mfem::MatrixCoefficient &,mfem::MatrixCoefficient &,double,double)\n" - " mfem::MatrixSumCoefficient::MatrixSumCoefficient(mfem::MatrixCoefficient &,mfem::MatrixCoefficient &,double)\n" - " mfem::MatrixSumCoefficient::MatrixSumCoefficient(mfem::MatrixCoefficient &,mfem::MatrixCoefficient &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixSumCoefficient *arg1 = (mfem::MatrixSumCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -15889,15 +15059,21 @@ SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixSumCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixSumCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixSumCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixSumCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixSumCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixSumCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixSumCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixSumCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -15905,7 +15081,7 @@ SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixSumCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixSumCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15913,7 +15089,7 @@ SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixSumCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixSumCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15986,7 +15162,7 @@ SWIGINTERN PyObject *MatrixSumCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -15994,11 +15170,15 @@ SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::ScalarMatrixProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ScalarMatrixProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ScalarMatrixProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarMatrixProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -16006,7 +15186,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarMatrixProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScalarMatrixProductCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -16034,7 +15214,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarMatrixProductCoefficient *arg1 = (mfem::ScalarMatrixProductCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -16048,15 +15228,21 @@ SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarMatrixProductCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ScalarMatrixProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::ScalarMatrixProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ScalarMatrixProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -16064,7 +15250,7 @@ SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16072,7 +15258,7 @@ SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16145,17 +15331,19 @@ SWIGINTERN PyObject *ScalarMatrixProductCoefficient_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TransposeMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TransposeMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"A", NULL + }; mfem::TransposeMatrixCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_TransposeMatrixCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeMatrixCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -16183,7 +15371,7 @@ SWIGINTERN PyObject *_wrap_new_TransposeMatrixCoefficient(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeMatrixCoefficient *arg1 = (mfem::TransposeMatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -16197,15 +15385,21 @@ SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDP int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeMatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeMatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TransposeMatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeMatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::TransposeMatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::TransposeMatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -16213,7 +15407,7 @@ SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16221,7 +15415,7 @@ SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16294,17 +15488,19 @@ SWIGINTERN PyObject *TransposeMatrixCoefficient_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_InverseMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InverseMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"A", NULL + }; mfem::InverseMatrixCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_InverseMatrixCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseMatrixCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -16332,7 +15528,7 @@ SWIGINTERN PyObject *_wrap_new_InverseMatrixCoefficient(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseMatrixCoefficient *arg1 = (mfem::InverseMatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -16346,15 +15542,21 @@ SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseMatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseMatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:InverseMatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseMatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::InverseMatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::InverseMatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -16362,7 +15564,7 @@ SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16370,7 +15572,7 @@ SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16443,7 +15645,7 @@ SWIGINTERN PyObject *InverseMatrixCoefficient_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -16451,11 +15653,15 @@ SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::OuterProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_OuterProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_OuterProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OuterProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -16463,7 +15669,7 @@ SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OuterProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OuterProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -16491,7 +15697,7 @@ SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OuterProductCoefficient *arg1 = (mfem::OuterProductCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -16505,15 +15711,21 @@ SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OuterProductCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OuterProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OuterProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OuterProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OuterProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::OuterProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::OuterProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OuterProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -16521,7 +15733,7 @@ SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OuterProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OuterProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16529,7 +15741,7 @@ SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OuterProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OuterProductCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17050,17 +16262,19 @@ SWIGINTERN PyObject *_wrap_ComputeGlobalLpNorm(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_fake_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fake_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"x", NULL + }; double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:fake_func", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fake_func" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -17088,7 +16302,7 @@ SWIGINTERN PyObject *_wrap_fake_func(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -17096,10 +16310,14 @@ SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"Ht", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "fake_func_vec", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fake_func_vec", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fake_func_vec" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -17107,7 +16325,7 @@ SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fake_func_vec" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fake_func_vec" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -17135,7 +16353,7 @@ SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -17143,10 +16361,14 @@ SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"Kt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "fake_func_mat", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fake_func_mat", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fake_func_mat" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -17154,7 +16376,7 @@ SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fake_func_mat" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fake_func_mat" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -17182,20 +16404,24 @@ SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_new_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"tdep", NULL + }; mfem::PyCoefficientBase *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_PyCoefficientBase", 2, 2, swig_obj)) SWIG_fail; - arg1 = swig_obj[0]; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_PyCoefficientBase", kwnames, &obj0, &obj1)) SWIG_fail; + arg1 = obj0; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -17223,7 +16449,7 @@ SWIGINTERN PyObject *_wrap_new_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -17234,18 +16460,23 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "PyCoefficientBase_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyCoefficientBase_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCoefficientBase_Eval" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::PyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -17253,7 +16484,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyCoefficientBase_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17262,7 +16493,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) } arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -17291,7 +16522,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -17299,18 +16530,22 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "PyCoefficientBase__EvalPy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PyCoefficientBase__EvalPy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCoefficientBase__EvalPy" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::PyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -17319,7 +16554,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(se } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -17348,7 +16583,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -17359,18 +16594,23 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "PyCoefficientBase__EvalPyT", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyCoefficientBase__EvalPyT", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCoefficientBase__EvalPyT" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::PyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -17378,13 +16618,13 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyCoefficientBase__EvalPyT" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -17447,16 +16687,18 @@ SWIGINTERN PyObject *_wrap_delete_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_disown_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_PyCoefficientBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PyCoefficientBase" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } @@ -17484,35 +16726,44 @@ SWIGINTERN PyObject *PyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"dim", (char *)"tdep", (char *)"q", NULL + }; mfem::VectorPyCoefficientBase *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - arg1 = swig_obj[0]; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_VectorPyCoefficientBase", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + arg1 = obj0; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VectorPyCoefficientBase" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + if (obj3) { + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VectorPyCoefficientBase" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); { try { if ( arg1 != Py_None ) { @@ -17538,129 +16789,6 @@ SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - mfem::VectorPyCoefficientBase *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::VectorPyCoefficientBase *)new SwigDirector_VectorPyCoefficientBase(arg1,arg2,arg3); - } else { - result = (mfem::VectorPyCoefficientBase *)new mfem::VectorPyCoefficientBase(arg2,arg3); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorPyCoefficientBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorPyCoefficientBase", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorPyCoefficientBase__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorPyCoefficientBase__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorPyCoefficientBase'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorPyCoefficientBase::VectorPyCoefficientBase(int,int,mfem::Coefficient *)\n" - " mfem::VectorPyCoefficientBase::VectorPyCoefficientBase(PyObject *,int,int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; @@ -17879,7 +17007,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase_Eval(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -17890,17 +17018,22 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "VectorPyCoefficientBase__EvalPy", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorPyCoefficientBase__EvalPy", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "1"" of type '" "mfem::VectorPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::VectorPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -17908,7 +17041,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -17917,7 +17050,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -17946,7 +17079,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -17960,17 +17093,23 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", (char *)"arg2", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "VectorPyCoefficientBase__EvalPyT", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorPyCoefficientBase__EvalPyT", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "1"" of type '" "mfem::VectorPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::VectorPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -17978,12 +17117,12 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -17992,7 +17131,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -18055,16 +17194,18 @@ SWIGINTERN PyObject *_wrap_delete_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_disown_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_VectorPyCoefficientBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_VectorPyCoefficientBase" "', argument " "1"" of type '" "mfem::VectorPyCoefficientBase *""'"); } @@ -18092,27 +17233,32 @@ SWIGINTERN PyObject *VectorPyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"dim", (char *)"tdep", NULL + }; mfem::MatrixPyCoefficientBase *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_MatrixPyCoefficientBase", 3, 3, swig_obj)) SWIG_fail; - arg1 = swig_obj[0]; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_MatrixPyCoefficientBase", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + arg1 = obj0; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -18139,7 +17285,7 @@ SWIGINTERN PyObject *_wrap_new_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -18153,17 +17299,23 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "MatrixPyCoefficientBase_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixPyCoefficientBase_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::MatrixPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -18171,7 +17323,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -18179,7 +17331,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -18188,7 +17340,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM } arg4 = reinterpret_cast< mfem::IntegrationPoint * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -18217,7 +17369,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18228,17 +17380,22 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "MatrixPyCoefficientBase__EvalPy", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MatrixPyCoefficientBase__EvalPy", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::MatrixPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -18246,7 +17403,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -18255,7 +17412,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -18284,7 +17441,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18298,17 +17455,23 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", (char *)"arg2", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "MatrixPyCoefficientBase__EvalPyT", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixPyCoefficientBase__EvalPyT", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::MatrixPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -18316,12 +17479,12 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -18330,7 +17493,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -18393,16 +17556,18 @@ SWIGINTERN PyObject *_wrap_delete_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_disown_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_MatrixPyCoefficientBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MatrixPyCoefficientBase" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } @@ -18433,7 +17598,7 @@ SWIGINTERN PyObject *MatrixPyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(s static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "Coefficient_SetTime(Coefficient self, double t)"}, + { "Coefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_Coefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "Coefficient_SetTime(Coefficient self, double t)"}, { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "Coefficient_GetTime(Coefficient self) -> double"}, { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" "Coefficient_Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip) -> double\n" @@ -18443,8 +17608,8 @@ static PyMethodDef SwigMethods[] = { { "Coefficient_swigregister", Coefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_constant_set", _wrap_ConstantCoefficient_constant_set, METH_VARARGS, "ConstantCoefficient_constant_set(ConstantCoefficient self, double constant)"}, { "ConstantCoefficient_constant_get", _wrap_ConstantCoefficient_constant_get, METH_O, "ConstantCoefficient_constant_get(ConstantCoefficient self) -> double"}, - { "new_ConstantCoefficient", _wrap_new_ConstantCoefficient, METH_VARARGS, "ConstantCoefficient(double c=1.0)"}, - { "ConstantCoefficient_Eval", _wrap_ConstantCoefficient_Eval, METH_VARARGS, "ConstantCoefficient_Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ConstantCoefficient(double c=1.0) -> ConstantCoefficient"}, + { "ConstantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ConstantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ConstantCoefficient_Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ConstantCoefficient", _wrap_delete_ConstantCoefficient, METH_O, "delete_ConstantCoefficient(ConstantCoefficient self)"}, { "ConstantCoefficient_swigregister", ConstantCoefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_swiginit", ConstantCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18452,10 +17617,10 @@ static PyMethodDef SwigMethods[] = { "PWConstCoefficient(int NumOfSubD=0)\n" "new_PWConstCoefficient(Vector c) -> PWConstCoefficient\n" ""}, - { "PWConstCoefficient_UpdateConstants", _wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS, "PWConstCoefficient_UpdateConstants(PWConstCoefficient self, Vector c)"}, - { "PWConstCoefficient___call__", _wrap_PWConstCoefficient___call__, METH_VARARGS, "PWConstCoefficient___call__(PWConstCoefficient self, int i) -> double &"}, + { "PWConstCoefficient_UpdateConstants", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS|METH_KEYWORDS, "PWConstCoefficient_UpdateConstants(PWConstCoefficient self, Vector c)"}, + { "PWConstCoefficient___call__", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient___call__, METH_VARARGS|METH_KEYWORDS, "PWConstCoefficient___call__(PWConstCoefficient self, int i) -> double &"}, { "PWConstCoefficient_GetNConst", _wrap_PWConstCoefficient_GetNConst, METH_O, "PWConstCoefficient_GetNConst(PWConstCoefficient self) -> int"}, - { "PWConstCoefficient_Eval", _wrap_PWConstCoefficient_Eval, METH_VARARGS, "PWConstCoefficient_Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PWConstCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "PWConstCoefficient_Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PWConstCoefficient", _wrap_delete_PWConstCoefficient, METH_O, "delete_PWConstCoefficient(PWConstCoefficient self)"}, { "PWConstCoefficient_swigregister", PWConstCoefficient_swigregister, METH_O, NULL}, { "PWConstCoefficient_swiginit", PWConstCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18465,17 +17630,17 @@ static PyMethodDef SwigMethods[] = { "FunctionCoefficient(double (*)(mfem::Vector &) f)\n" "new_FunctionCoefficient(double (*)(mfem::Vector &,double) tdf) -> FunctionCoefficient\n" ""}, - { "FunctionCoefficient_Eval", _wrap_FunctionCoefficient_Eval, METH_VARARGS, "FunctionCoefficient_Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "FunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_FunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "FunctionCoefficient_Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_FunctionCoefficient", _wrap_delete_FunctionCoefficient, METH_O, "delete_FunctionCoefficient(FunctionCoefficient self)"}, { "FunctionCoefficient_swigregister", FunctionCoefficient_swigregister, METH_O, NULL}, { "FunctionCoefficient_swiginit", FunctionCoefficient_swiginit, METH_VARARGS, NULL}, { "new_GridFunctionCoefficient", _wrap_new_GridFunctionCoefficient, METH_VARARGS, "\n" "GridFunctionCoefficient()\n" - "GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1)\n" + "new_GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1) -> GridFunctionCoefficient\n" ""}, - { "GridFunctionCoefficient_SetGridFunction", _wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS, "GridFunctionCoefficient_SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "GridFunctionCoefficient_SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GridFunctionCoefficient_GetGridFunction", _wrap_GridFunctionCoefficient_GetGridFunction, METH_O, "GridFunctionCoefficient_GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "GridFunctionCoefficient_Eval", _wrap_GridFunctionCoefficient_Eval, METH_VARARGS, "GridFunctionCoefficient_Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "GridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "GridFunctionCoefficient_Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_GridFunctionCoefficient", _wrap_delete_GridFunctionCoefficient, METH_O, "delete_GridFunctionCoefficient(GridFunctionCoefficient self)"}, { "GridFunctionCoefficient_swigregister", GridFunctionCoefficient_swigregister, METH_O, NULL}, { "GridFunctionCoefficient_swiginit", GridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18483,7 +17648,7 @@ static PyMethodDef SwigMethods[] = { "TransformedCoefficient(Coefficient q, double (*)(double) F)\n" "new_TransformedCoefficient(Coefficient q1, Coefficient q2, double (*)(double,double) F) -> TransformedCoefficient\n" ""}, - { "TransformedCoefficient_Eval", _wrap_TransformedCoefficient_Eval, METH_VARARGS, "TransformedCoefficient_Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "TransformedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransformedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "TransformedCoefficient_Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_TransformedCoefficient", _wrap_delete_TransformedCoefficient, METH_O, "delete_TransformedCoefficient(TransformedCoefficient self)"}, { "TransformedCoefficient_swigregister", TransformedCoefficient_swigregister, METH_O, NULL}, { "TransformedCoefficient_swiginit", TransformedCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18493,27 +17658,27 @@ static PyMethodDef SwigMethods[] = { "DeltaCoefficient(double x, double y, double s)\n" "new_DeltaCoefficient(double x, double y, double z, double s) -> DeltaCoefficient\n" ""}, - { "DeltaCoefficient_SetDeltaCenter", _wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS, "DeltaCoefficient_SetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_SetScale", _wrap_DeltaCoefficient_SetScale, METH_VARARGS, "DeltaCoefficient_SetScale(DeltaCoefficient self, double _s)"}, - { "DeltaCoefficient_SetFunction", _wrap_DeltaCoefficient_SetFunction, METH_VARARGS, "DeltaCoefficient_SetFunction(DeltaCoefficient self, double (*)(double) f)"}, - { "DeltaCoefficient_SetTol", _wrap_DeltaCoefficient_SetTol, METH_VARARGS, "DeltaCoefficient_SetTol(DeltaCoefficient self, double _tol)"}, - { "DeltaCoefficient_SetWeight", _wrap_DeltaCoefficient_SetWeight, METH_VARARGS, "DeltaCoefficient_SetWeight(DeltaCoefficient self, Coefficient w)"}, + { "DeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetScale(DeltaCoefficient self, double _s)"}, + { "DeltaCoefficient_SetFunction", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetFunction, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetFunction(DeltaCoefficient self, double (*)(double) f)"}, + { "DeltaCoefficient_SetTol", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetTol, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetTol(DeltaCoefficient self, double _tol)"}, + { "DeltaCoefficient_SetWeight", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetWeight, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetWeight(DeltaCoefficient self, Coefficient w)"}, { "DeltaCoefficient_Center", _wrap_DeltaCoefficient_Center, METH_O, "DeltaCoefficient_Center(DeltaCoefficient self) -> double const *"}, { "DeltaCoefficient_Scale", _wrap_DeltaCoefficient_Scale, METH_O, "DeltaCoefficient_Scale(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Tol", _wrap_DeltaCoefficient_Tol, METH_O, "DeltaCoefficient_Tol(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Weight", _wrap_DeltaCoefficient_Weight, METH_O, "DeltaCoefficient_Weight(DeltaCoefficient self) -> Coefficient"}, - { "DeltaCoefficient_GetDeltaCenter", _wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS, "DeltaCoefficient_GetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_EvalDelta", _wrap_DeltaCoefficient_EvalDelta, METH_VARARGS, "DeltaCoefficient_EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "DeltaCoefficient_Eval", _wrap_DeltaCoefficient_Eval, METH_VARARGS, "DeltaCoefficient_Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_GetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeltaCoefficient", _wrap_delete_DeltaCoefficient, METH_O, "delete_DeltaCoefficient(DeltaCoefficient self)"}, { "DeltaCoefficient_swigregister", DeltaCoefficient_swigregister, METH_O, NULL}, { "DeltaCoefficient_swiginit", DeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_RestrictedCoefficient", _wrap_new_RestrictedCoefficient, METH_VARARGS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, - { "RestrictedCoefficient_Eval", _wrap_RestrictedCoefficient_Eval, METH_VARARGS, "RestrictedCoefficient_Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_RestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_RestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, + { "RestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_RestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "RestrictedCoefficient_Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_RestrictedCoefficient", _wrap_delete_RestrictedCoefficient, METH_O, "delete_RestrictedCoefficient(RestrictedCoefficient self)"}, { "RestrictedCoefficient_swigregister", RestrictedCoefficient_swigregister, METH_O, NULL}, { "RestrictedCoefficient_swiginit", RestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "VectorCoefficient_SetTime", _wrap_VectorCoefficient_SetTime, METH_VARARGS, "VectorCoefficient_SetTime(VectorCoefficient self, double t)"}, + { "VectorCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_VectorCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "VectorCoefficient_SetTime(VectorCoefficient self, double t)"}, { "VectorCoefficient_GetTime", _wrap_VectorCoefficient_GetTime, METH_O, "VectorCoefficient_GetTime(VectorCoefficient self) -> double"}, { "VectorCoefficient_GetVDim", _wrap_VectorCoefficient_GetVDim, METH_O, "VectorCoefficient_GetVDim(VectorCoefficient self) -> int"}, { "VectorCoefficient_Eval", _wrap_VectorCoefficient_Eval, METH_VARARGS, "\n" @@ -18522,7 +17687,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_VectorCoefficient", _wrap_delete_VectorCoefficient, METH_O, "delete_VectorCoefficient(VectorCoefficient self)"}, { "VectorCoefficient_swigregister", VectorCoefficient_swigregister, METH_O, NULL}, - { "new_VectorConstantCoefficient", _wrap_new_VectorConstantCoefficient, METH_O, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, + { "new_VectorConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, { "VectorConstantCoefficient_Eval", _wrap_VectorConstantCoefficient_Eval, METH_VARARGS, "\n" "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18534,7 +17699,7 @@ static PyMethodDef SwigMethods[] = { { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, { "new_VectorFunctionCoefficient", _wrap_new_VectorFunctionCoefficient, METH_VARARGS, "\n" "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::Vector &) F, Coefficient q=None)\n" - "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None)\n" + "new_VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None) -> VectorFunctionCoefficient\n" ""}, { "VectorFunctionCoefficient_Eval", _wrap_VectorFunctionCoefficient_Eval, METH_VARARGS, "\n" "VectorFunctionCoefficient_Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18544,10 +17709,10 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFunctionCoefficient", _wrap_delete_VectorFunctionCoefficient, METH_O, "delete_VectorFunctionCoefficient(VectorFunctionCoefficient self)"}, { "VectorFunctionCoefficient_swigregister", VectorFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorFunctionCoefficient_swiginit", VectorFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorArrayCoefficient", _wrap_new_VectorArrayCoefficient, METH_O, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, - { "VectorArrayCoefficient_GetCoeff", _wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS, "VectorArrayCoefficient_GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, + { "new_VectorArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, + { "VectorArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "VectorArrayCoefficient_GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, { "VectorArrayCoefficient_GetCoeffs", _wrap_VectorArrayCoefficient_GetCoeffs, METH_O, "VectorArrayCoefficient_GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **"}, - { "VectorArrayCoefficient_Set", _wrap_VectorArrayCoefficient_Set, METH_VARARGS, "VectorArrayCoefficient_Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, + { "VectorArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "VectorArrayCoefficient_Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, { "VectorArrayCoefficient_Eval", _wrap_VectorArrayCoefficient_Eval, METH_VARARGS, "\n" "VectorArrayCoefficient_Eval(VectorArrayCoefficient self, int i, ElementTransformation T, IntegrationPoint ip) -> double\n" "VectorArrayCoefficient_Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18561,7 +17726,7 @@ static PyMethodDef SwigMethods[] = { "VectorGridFunctionCoefficient()\n" "new_VectorGridFunctionCoefficient(mfem::GridFunction * gf) -> VectorGridFunctionCoefficient\n" ""}, - { "VectorGridFunctionCoefficient_SetGridFunction", _wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "VectorGridFunctionCoefficient_SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "VectorGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "VectorGridFunctionCoefficient_SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "VectorGridFunctionCoefficient_GetGridFunction", _wrap_VectorGridFunctionCoefficient_GetGridFunction, METH_O, "VectorGridFunctionCoefficient_GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "VectorGridFunctionCoefficient_Eval", _wrap_VectorGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "VectorGridFunctionCoefficient_Eval(VectorGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18570,8 +17735,8 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorGridFunctionCoefficient", _wrap_delete_VectorGridFunctionCoefficient, METH_O, "delete_VectorGridFunctionCoefficient(VectorGridFunctionCoefficient self)"}, { "VectorGridFunctionCoefficient_swigregister", VectorGridFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorGridFunctionCoefficient_swiginit", VectorGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_GradientGridFunctionCoefficient", _wrap_new_GradientGridFunctionCoefficient, METH_O, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, - { "GradientGridFunctionCoefficient_SetGridFunction", _wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "GradientGridFunctionCoefficient_SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_GradientGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_GradientGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, + { "GradientGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "GradientGridFunctionCoefficient_SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GradientGridFunctionCoefficient_GetGridFunction", _wrap_GradientGridFunctionCoefficient_GetGridFunction, METH_O, "GradientGridFunctionCoefficient_GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "GradientGridFunctionCoefficient_Eval", _wrap_GradientGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "GradientGridFunctionCoefficient_Eval(GradientGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18580,7 +17745,7 @@ static PyMethodDef SwigMethods[] = { { "delete_GradientGridFunctionCoefficient", _wrap_delete_GradientGridFunctionCoefficient, METH_O, "delete_GradientGridFunctionCoefficient(GradientGridFunctionCoefficient self)"}, { "GradientGridFunctionCoefficient_swigregister", GradientGridFunctionCoefficient_swigregister, METH_O, NULL}, { "GradientGridFunctionCoefficient_swiginit", GradientGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "CurlGridFunctionCoefficient_SetGridFunction", _wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "CurlGridFunctionCoefficient_SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "CurlGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "CurlGridFunctionCoefficient_SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "CurlGridFunctionCoefficient_GetGridFunction", _wrap_CurlGridFunctionCoefficient_GetGridFunction, METH_O, "CurlGridFunctionCoefficient_GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "CurlGridFunctionCoefficient_Eval", _wrap_CurlGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "CurlGridFunctionCoefficient_Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18589,10 +17754,10 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_CurlGridFunctionCoefficient", _wrap_delete_CurlGridFunctionCoefficient, METH_O, "delete_CurlGridFunctionCoefficient(CurlGridFunctionCoefficient self)"}, { "CurlGridFunctionCoefficient_swigregister", CurlGridFunctionCoefficient_swigregister, METH_O, NULL}, - { "new_DivergenceGridFunctionCoefficient", _wrap_new_DivergenceGridFunctionCoefficient, METH_O, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, - { "DivergenceGridFunctionCoefficient_SetGridFunction", _wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "DivergenceGridFunctionCoefficient_SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_DivergenceGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DivergenceGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, + { "DivergenceGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "DivergenceGridFunctionCoefficient_SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "DivergenceGridFunctionCoefficient_GetGridFunction", _wrap_DivergenceGridFunctionCoefficient_GetGridFunction, METH_O, "DivergenceGridFunctionCoefficient_GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "DivergenceGridFunctionCoefficient_Eval", _wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS, "DivergenceGridFunctionCoefficient_Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DivergenceGridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "DivergenceGridFunctionCoefficient_Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DivergenceGridFunctionCoefficient", _wrap_delete_DivergenceGridFunctionCoefficient, METH_O, "delete_DivergenceGridFunctionCoefficient(DivergenceGridFunctionCoefficient self)"}, { "DivergenceGridFunctionCoefficient_swigregister", DivergenceGridFunctionCoefficient_swigregister, METH_O, NULL}, { "DivergenceGridFunctionCoefficient_swiginit", DivergenceGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18603,13 +17768,13 @@ static PyMethodDef SwigMethods[] = { "VectorDeltaCoefficient(Vector _dir, double x, double y, double s)\n" "new_VectorDeltaCoefficient(Vector _dir, double x, double y, double z, double s) -> VectorDeltaCoefficient\n" ""}, - { "VectorDeltaCoefficient_SetDeltaCoefficient", _wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS, "VectorDeltaCoefficient_SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, + { "VectorDeltaCoefficient_SetDeltaCoefficient", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, { "VectorDeltaCoefficient_GetDeltaCoefficient", _wrap_VectorDeltaCoefficient_GetDeltaCoefficient, METH_O, "VectorDeltaCoefficient_GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient"}, - { "VectorDeltaCoefficient_SetScale", _wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS, "VectorDeltaCoefficient_SetScale(VectorDeltaCoefficient self, double s)"}, - { "VectorDeltaCoefficient_SetDirection", _wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS, "VectorDeltaCoefficient_SetDirection(VectorDeltaCoefficient self, Vector _d)"}, - { "VectorDeltaCoefficient_SetDeltaCenter", _wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS, "VectorDeltaCoefficient_SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_GetDeltaCenter", _wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS, "VectorDeltaCoefficient_GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_EvalDelta", _wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS, "VectorDeltaCoefficient_EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, + { "VectorDeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetScale(VectorDeltaCoefficient self, double s)"}, + { "VectorDeltaCoefficient_SetDirection", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetDirection(VectorDeltaCoefficient self, Vector _d)"}, + { "VectorDeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, { "VectorDeltaCoefficient_Eval", _wrap_VectorDeltaCoefficient_Eval, METH_VARARGS, "\n" "VectorDeltaCoefficient_Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorDeltaCoefficient_Eval(VectorDeltaCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18618,7 +17783,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorDeltaCoefficient", _wrap_delete_VectorDeltaCoefficient, METH_O, "delete_VectorDeltaCoefficient(VectorDeltaCoefficient self)"}, { "VectorDeltaCoefficient_swigregister", VectorDeltaCoefficient_swigregister, METH_O, NULL}, { "VectorDeltaCoefficient_swiginit", VectorDeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRestrictedCoefficient", _wrap_new_VectorRestrictedCoefficient, METH_VARARGS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, + { "new_VectorRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, { "VectorRestrictedCoefficient_Eval", _wrap_VectorRestrictedCoefficient_Eval, METH_VARARGS, "\n" "VectorRestrictedCoefficient_Eval(VectorRestrictedCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorRestrictedCoefficient_Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18626,15 +17791,15 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorRestrictedCoefficient", _wrap_delete_VectorRestrictedCoefficient, METH_O, "delete_VectorRestrictedCoefficient(VectorRestrictedCoefficient self)"}, { "VectorRestrictedCoefficient_swigregister", VectorRestrictedCoefficient_swigregister, METH_O, NULL}, { "VectorRestrictedCoefficient_swiginit", VectorRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "MatrixCoefficient_SetTime", _wrap_MatrixCoefficient_SetTime, METH_VARARGS, "MatrixCoefficient_SetTime(MatrixCoefficient self, double t)"}, + { "MatrixCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "MatrixCoefficient_SetTime(MatrixCoefficient self, double t)"}, { "MatrixCoefficient_GetTime", _wrap_MatrixCoefficient_GetTime, METH_O, "MatrixCoefficient_GetTime(MatrixCoefficient self) -> double"}, { "MatrixCoefficient_GetHeight", _wrap_MatrixCoefficient_GetHeight, METH_O, "MatrixCoefficient_GetHeight(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetWidth", _wrap_MatrixCoefficient_GetWidth, METH_O, "MatrixCoefficient_GetWidth(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetVDim", _wrap_MatrixCoefficient_GetVDim, METH_O, "MatrixCoefficient_GetVDim(MatrixCoefficient self) -> int"}, - { "MatrixCoefficient_Eval", _wrap_MatrixCoefficient_Eval, METH_VARARGS, "MatrixCoefficient_Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixCoefficient_Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixCoefficient", _wrap_delete_MatrixCoefficient, METH_O, "delete_MatrixCoefficient(MatrixCoefficient self)"}, { "MatrixCoefficient_swigregister", MatrixCoefficient_swigregister, METH_O, NULL}, - { "new_MatrixConstantCoefficient", _wrap_new_MatrixConstantCoefficient, METH_O, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, + { "new_MatrixConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, { "MatrixConstantCoefficient_Eval", _wrap_MatrixConstantCoefficient_Eval, METH_VARARGS, "\n" "MatrixConstantCoefficient_Eval(MatrixConstantCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" "MatrixConstantCoefficient_Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)\n" @@ -18645,15 +17810,15 @@ static PyMethodDef SwigMethods[] = { { "new_MatrixFunctionCoefficient", _wrap_new_MatrixFunctionCoefficient, METH_VARARGS, "\n" "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::DenseMatrix &) F, Coefficient q=None)\n" "MatrixFunctionCoefficient(DenseMatrix m, Coefficient q)\n" - "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None)\n" + "new_MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None) -> MatrixFunctionCoefficient\n" ""}, - { "MatrixFunctionCoefficient_Eval", _wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS, "MatrixFunctionCoefficient_Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixFunctionCoefficient_Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixFunctionCoefficient", _wrap_delete_MatrixFunctionCoefficient, METH_O, "delete_MatrixFunctionCoefficient(MatrixFunctionCoefficient self)"}, { "MatrixFunctionCoefficient_swigregister", MatrixFunctionCoefficient_swigregister, METH_O, NULL}, { "MatrixFunctionCoefficient_swiginit", MatrixFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixArrayCoefficient", _wrap_new_MatrixArrayCoefficient, METH_O, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, - { "MatrixArrayCoefficient_GetCoeff", _wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS, "MatrixArrayCoefficient_GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, - { "MatrixArrayCoefficient_Set", _wrap_MatrixArrayCoefficient_Set, METH_VARARGS, "MatrixArrayCoefficient_Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, + { "new_MatrixArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, + { "MatrixArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "MatrixArrayCoefficient_GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, + { "MatrixArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "MatrixArrayCoefficient_Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, { "MatrixArrayCoefficient_Eval", _wrap_MatrixArrayCoefficient_Eval, METH_VARARGS, "\n" "MatrixArrayCoefficient_Eval(MatrixArrayCoefficient self, int i, int j, ElementTransformation T, IntegrationPoint ip) -> double\n" "MatrixArrayCoefficient_Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" @@ -18661,42 +17826,42 @@ static PyMethodDef SwigMethods[] = { { "delete_MatrixArrayCoefficient", _wrap_delete_MatrixArrayCoefficient, METH_O, "delete_MatrixArrayCoefficient(MatrixArrayCoefficient self)"}, { "MatrixArrayCoefficient_swigregister", MatrixArrayCoefficient_swigregister, METH_O, NULL}, { "MatrixArrayCoefficient_swiginit", MatrixArrayCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixRestrictedCoefficient", _wrap_new_MatrixRestrictedCoefficient, METH_VARARGS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, - { "MatrixRestrictedCoefficient_Eval", _wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS, "MatrixRestrictedCoefficient_Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, + { "MatrixRestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixRestrictedCoefficient_Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixRestrictedCoefficient", _wrap_delete_MatrixRestrictedCoefficient, METH_O, "delete_MatrixRestrictedCoefficient(MatrixRestrictedCoefficient self)"}, { "MatrixRestrictedCoefficient_swigregister", MatrixRestrictedCoefficient_swigregister, METH_O, NULL}, { "MatrixRestrictedCoefficient_swiginit", MatrixRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_SumCoefficient", _wrap_new_SumCoefficient, METH_VARARGS, "SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "SumCoefficient_Eval", _wrap_SumCoefficient_Eval, METH_VARARGS, "SumCoefficient_Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_SumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_SumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0) -> SumCoefficient"}, + { "SumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_SumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "SumCoefficient_Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_SumCoefficient", _wrap_delete_SumCoefficient, METH_O, "delete_SumCoefficient(SumCoefficient self)"}, { "SumCoefficient_swigregister", SumCoefficient_swigregister, METH_O, NULL}, { "SumCoefficient_swiginit", SumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ProductCoefficient", _wrap_new_ProductCoefficient, METH_VARARGS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, - { "ProductCoefficient_Eval", _wrap_ProductCoefficient_Eval, METH_VARARGS, "ProductCoefficient_Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, + { "ProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ProductCoefficient_Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ProductCoefficient", _wrap_delete_ProductCoefficient, METH_O, "delete_ProductCoefficient(ProductCoefficient self)"}, { "ProductCoefficient_swigregister", ProductCoefficient_swigregister, METH_O, NULL}, { "ProductCoefficient_swiginit", ProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_PowerCoefficient", _wrap_new_PowerCoefficient, METH_VARARGS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, - { "PowerCoefficient_Eval", _wrap_PowerCoefficient_Eval, METH_VARARGS, "PowerCoefficient_Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_PowerCoefficient", (PyCFunction)(void(*)(void))_wrap_new_PowerCoefficient, METH_VARARGS|METH_KEYWORDS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, + { "PowerCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PowerCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "PowerCoefficient_Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PowerCoefficient", _wrap_delete_PowerCoefficient, METH_O, "delete_PowerCoefficient(PowerCoefficient self)"}, { "PowerCoefficient_swigregister", PowerCoefficient_swigregister, METH_O, NULL}, { "PowerCoefficient_swiginit", PowerCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InnerProductCoefficient", _wrap_new_InnerProductCoefficient, METH_VARARGS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, - { "InnerProductCoefficient_Eval", _wrap_InnerProductCoefficient_Eval, METH_VARARGS, "InnerProductCoefficient_Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_InnerProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InnerProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, + { "InnerProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InnerProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "InnerProductCoefficient_Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_InnerProductCoefficient", _wrap_delete_InnerProductCoefficient, METH_O, "delete_InnerProductCoefficient(InnerProductCoefficient self)"}, { "InnerProductCoefficient_swigregister", InnerProductCoefficient_swigregister, METH_O, NULL}, { "InnerProductCoefficient_swiginit", InnerProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRotProductCoefficient", _wrap_new_VectorRotProductCoefficient, METH_VARARGS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, - { "VectorRotProductCoefficient_Eval", _wrap_VectorRotProductCoefficient_Eval, METH_VARARGS, "VectorRotProductCoefficient_Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_VectorRotProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRotProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, + { "VectorRotProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_VectorRotProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "VectorRotProductCoefficient_Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_VectorRotProductCoefficient", _wrap_delete_VectorRotProductCoefficient, METH_O, "delete_VectorRotProductCoefficient(VectorRotProductCoefficient self)"}, { "VectorRotProductCoefficient_swigregister", VectorRotProductCoefficient_swigregister, METH_O, NULL}, { "VectorRotProductCoefficient_swiginit", VectorRotProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_DeterminantCoefficient", _wrap_new_DeterminantCoefficient, METH_O, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, - { "DeterminantCoefficient_Eval", _wrap_DeterminantCoefficient_Eval, METH_VARARGS, "DeterminantCoefficient_Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_DeterminantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DeterminantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, + { "DeterminantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeterminantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "DeterminantCoefficient_Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeterminantCoefficient", _wrap_delete_DeterminantCoefficient, METH_O, "delete_DeterminantCoefficient(DeterminantCoefficient self)"}, { "DeterminantCoefficient_swigregister", DeterminantCoefficient_swigregister, METH_O, NULL}, { "DeterminantCoefficient_swiginit", DeterminantCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorSumCoefficient", _wrap_new_VectorSumCoefficient, METH_VARARGS, "VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "new_VectorSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0) -> VectorSumCoefficient"}, { "VectorSumCoefficient_Eval", _wrap_VectorSumCoefficient_Eval, METH_VARARGS, "\n" "VectorSumCoefficient_Eval(VectorSumCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorSumCoefficient_Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18704,7 +17869,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorSumCoefficient", _wrap_delete_VectorSumCoefficient, METH_O, "delete_VectorSumCoefficient(VectorSumCoefficient self)"}, { "VectorSumCoefficient_swigregister", VectorSumCoefficient_swigregister, METH_O, NULL}, { "VectorSumCoefficient_swiginit", VectorSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductCoefficient", _wrap_new_ScalarVectorProductCoefficient, METH_VARARGS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, + { "new_ScalarVectorProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, { "ScalarVectorProductCoefficient_Eval", _wrap_ScalarVectorProductCoefficient_Eval, METH_VARARGS, "\n" "ScalarVectorProductCoefficient_Eval(ScalarVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "ScalarVectorProductCoefficient_Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18712,7 +17877,7 @@ static PyMethodDef SwigMethods[] = { { "delete_ScalarVectorProductCoefficient", _wrap_delete_ScalarVectorProductCoefficient, METH_O, "delete_ScalarVectorProductCoefficient(ScalarVectorProductCoefficient self)"}, { "ScalarVectorProductCoefficient_swigregister", ScalarVectorProductCoefficient_swigregister, METH_O, NULL}, { "ScalarVectorProductCoefficient_swiginit", ScalarVectorProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductCoefficient", _wrap_new_VectorCrossProductCoefficient, METH_VARARGS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, + { "new_VectorCrossProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, { "VectorCrossProductCoefficient_Eval", _wrap_VectorCrossProductCoefficient_Eval, METH_VARARGS, "\n" "VectorCrossProductCoefficient_Eval(VectorCrossProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorCrossProductCoefficient_Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18720,7 +17885,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorCrossProductCoefficient", _wrap_delete_VectorCrossProductCoefficient, METH_O, "delete_VectorCrossProductCoefficient(VectorCrossProductCoefficient self)"}, { "VectorCrossProductCoefficient_swigregister", VectorCrossProductCoefficient_swigregister, METH_O, NULL}, { "VectorCrossProductCoefficient_swiginit", VectorCrossProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatVecCoefficient", _wrap_new_MatVecCoefficient, METH_VARARGS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, + { "new_MatVecCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatVecCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, { "MatVecCoefficient_Eval", _wrap_MatVecCoefficient_Eval, METH_VARARGS, "\n" "MatVecCoefficient_Eval(MatVecCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "MatVecCoefficient_Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18728,33 +17893,33 @@ static PyMethodDef SwigMethods[] = { { "delete_MatVecCoefficient", _wrap_delete_MatVecCoefficient, METH_O, "delete_MatVecCoefficient(MatVecCoefficient self)"}, { "MatVecCoefficient_swigregister", MatVecCoefficient_swigregister, METH_O, NULL}, { "MatVecCoefficient_swiginit", MatVecCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_IdentityMatrixCoefficient", _wrap_new_IdentityMatrixCoefficient, METH_O, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, - { "IdentityMatrixCoefficient_Eval", _wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS, "IdentityMatrixCoefficient_Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_IdentityMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_IdentityMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, + { "IdentityMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "IdentityMatrixCoefficient_Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_IdentityMatrixCoefficient", _wrap_delete_IdentityMatrixCoefficient, METH_O, "delete_IdentityMatrixCoefficient(IdentityMatrixCoefficient self)"}, { "IdentityMatrixCoefficient_swigregister", IdentityMatrixCoefficient_swigregister, METH_O, NULL}, { "IdentityMatrixCoefficient_swiginit", IdentityMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixSumCoefficient", _wrap_new_MatrixSumCoefficient, METH_VARARGS, "MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "MatrixSumCoefficient_Eval", _wrap_MatrixSumCoefficient_Eval, METH_VARARGS, "MatrixSumCoefficient_Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0) -> MatrixSumCoefficient"}, + { "MatrixSumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixSumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixSumCoefficient_Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixSumCoefficient", _wrap_delete_MatrixSumCoefficient, METH_O, "delete_MatrixSumCoefficient(MatrixSumCoefficient self)"}, { "MatrixSumCoefficient_swigregister", MatrixSumCoefficient_swigregister, METH_O, NULL}, { "MatrixSumCoefficient_swiginit", MatrixSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarMatrixProductCoefficient", _wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, - { "ScalarMatrixProductCoefficient_Eval", _wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS, "ScalarMatrixProductCoefficient_Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_ScalarMatrixProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, + { "ScalarMatrixProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ScalarMatrixProductCoefficient_Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_ScalarMatrixProductCoefficient", _wrap_delete_ScalarMatrixProductCoefficient, METH_O, "delete_ScalarMatrixProductCoefficient(ScalarMatrixProductCoefficient self)"}, { "ScalarMatrixProductCoefficient_swigregister", ScalarMatrixProductCoefficient_swigregister, METH_O, NULL}, { "ScalarMatrixProductCoefficient_swiginit", ScalarMatrixProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_TransposeMatrixCoefficient", _wrap_new_TransposeMatrixCoefficient, METH_O, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, - { "TransposeMatrixCoefficient_Eval", _wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS, "TransposeMatrixCoefficient_Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_TransposeMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_TransposeMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, + { "TransposeMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "TransposeMatrixCoefficient_Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_TransposeMatrixCoefficient", _wrap_delete_TransposeMatrixCoefficient, METH_O, "delete_TransposeMatrixCoefficient(TransposeMatrixCoefficient self)"}, { "TransposeMatrixCoefficient_swigregister", TransposeMatrixCoefficient_swigregister, METH_O, NULL}, { "TransposeMatrixCoefficient_swiginit", TransposeMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InverseMatrixCoefficient", _wrap_new_InverseMatrixCoefficient, METH_O, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, - { "InverseMatrixCoefficient_Eval", _wrap_InverseMatrixCoefficient_Eval, METH_VARARGS, "InverseMatrixCoefficient_Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_InverseMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InverseMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, + { "InverseMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InverseMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "InverseMatrixCoefficient_Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_InverseMatrixCoefficient", _wrap_delete_InverseMatrixCoefficient, METH_O, "delete_InverseMatrixCoefficient(InverseMatrixCoefficient self)"}, { "InverseMatrixCoefficient_swigregister", InverseMatrixCoefficient_swigregister, METH_O, NULL}, { "InverseMatrixCoefficient_swiginit", InverseMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_OuterProductCoefficient", _wrap_new_OuterProductCoefficient, METH_VARARGS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, - { "OuterProductCoefficient_Eval", _wrap_OuterProductCoefficient_Eval, METH_VARARGS, "OuterProductCoefficient_Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_OuterProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_OuterProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, + { "OuterProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_OuterProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "OuterProductCoefficient_Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_OuterProductCoefficient", _wrap_delete_OuterProductCoefficient, METH_O, "delete_OuterProductCoefficient(OuterProductCoefficient self)"}, { "OuterProductCoefficient_swigregister", OuterProductCoefficient_swigregister, METH_O, NULL}, { "OuterProductCoefficient_swiginit", OuterProductCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18766,34 +17931,34 @@ static PyMethodDef SwigMethods[] = { "ComputeGlobalLpNorm(double p, Coefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double\n" "ComputeGlobalLpNorm(double p, VectorCoefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double\n" ""}, - { "fake_func", _wrap_fake_func, METH_O, "fake_func(Vector x) -> double"}, - { "fake_func_vec", _wrap_fake_func_vec, METH_VARARGS, "fake_func_vec(Vector x, Vector Ht)"}, - { "fake_func_mat", _wrap_fake_func_mat, METH_VARARGS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, - { "new_PyCoefficientBase", _wrap_new_PyCoefficientBase, METH_VARARGS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, - { "PyCoefficientBase_Eval", _wrap_PyCoefficientBase_Eval, METH_VARARGS, "PyCoefficientBase_Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "PyCoefficientBase__EvalPy", _wrap_PyCoefficientBase__EvalPy, METH_VARARGS, "PyCoefficientBase__EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, - { "PyCoefficientBase__EvalPyT", _wrap_PyCoefficientBase__EvalPyT, METH_VARARGS, "PyCoefficientBase__EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, + { "fake_func", (PyCFunction)(void(*)(void))_wrap_fake_func, METH_VARARGS|METH_KEYWORDS, "fake_func(Vector x) -> double"}, + { "fake_func_vec", (PyCFunction)(void(*)(void))_wrap_fake_func_vec, METH_VARARGS|METH_KEYWORDS, "fake_func_vec(Vector x, Vector Ht)"}, + { "fake_func_mat", (PyCFunction)(void(*)(void))_wrap_fake_func_mat, METH_VARARGS|METH_KEYWORDS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, + { "new_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, + { "PyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "PyCoefficientBase_Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "PyCoefficientBase__EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, + { "PyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "PyCoefficientBase__EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, { "delete_PyCoefficientBase", _wrap_delete_PyCoefficientBase, METH_O, "delete_PyCoefficientBase(PyCoefficientBase self)"}, - { "disown_PyCoefficientBase", _wrap_disown_PyCoefficientBase, METH_O, NULL}, + { "disown_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyCoefficientBase_swigregister", PyCoefficientBase_swigregister, METH_O, NULL}, { "PyCoefficientBase_swiginit", PyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_VectorPyCoefficientBase", _wrap_new_VectorPyCoefficientBase, METH_VARARGS, "VectorPyCoefficientBase(int dim, int tdep, Coefficient q=None)"}, + { "new_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_VectorPyCoefficientBase(PyObject * _self, int dim, int tdep, Coefficient q=None) -> VectorPyCoefficientBase"}, { "VectorPyCoefficientBase_Eval", _wrap_VectorPyCoefficientBase_Eval, METH_VARARGS, "\n" "VectorPyCoefficientBase_Eval(VectorPyCoefficientBase self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" "VectorPyCoefficientBase_Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" ""}, - { "VectorPyCoefficientBase__EvalPy", _wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS, "VectorPyCoefficientBase__EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, - { "VectorPyCoefficientBase__EvalPyT", _wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS, "VectorPyCoefficientBase__EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, + { "VectorPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "VectorPyCoefficientBase__EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, + { "VectorPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "VectorPyCoefficientBase__EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, { "delete_VectorPyCoefficientBase", _wrap_delete_VectorPyCoefficientBase, METH_O, "delete_VectorPyCoefficientBase(VectorPyCoefficientBase self)"}, - { "disown_VectorPyCoefficientBase", _wrap_disown_VectorPyCoefficientBase, METH_O, NULL}, + { "disown_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "VectorPyCoefficientBase_swigregister", VectorPyCoefficientBase_swigregister, METH_O, NULL}, { "VectorPyCoefficientBase_swiginit", VectorPyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_MatrixPyCoefficientBase", _wrap_new_MatrixPyCoefficientBase, METH_VARARGS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, - { "MatrixPyCoefficientBase_Eval", _wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS, "MatrixPyCoefficientBase_Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, - { "MatrixPyCoefficientBase__EvalPy", _wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS, "MatrixPyCoefficientBase__EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, - { "MatrixPyCoefficientBase__EvalPyT", _wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS, "MatrixPyCoefficientBase__EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, + { "new_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, + { "MatrixPyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixPyCoefficientBase_Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "MatrixPyCoefficientBase__EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, + { "MatrixPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "MatrixPyCoefficientBase__EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, { "delete_MatrixPyCoefficientBase", _wrap_delete_MatrixPyCoefficientBase, METH_O, "delete_MatrixPyCoefficientBase(MatrixPyCoefficientBase self)"}, - { "disown_MatrixPyCoefficientBase", _wrap_disown_MatrixPyCoefficientBase, METH_O, NULL}, + { "disown_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "MatrixPyCoefficientBase_swigregister", MatrixPyCoefficientBase_swigregister, METH_O, NULL}, { "MatrixPyCoefficientBase_swiginit", MatrixPyCoefficientBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -18802,7 +17967,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "SetTime(Coefficient self, double t)"}, + { "Coefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_Coefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(Coefficient self, double t)"}, { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "GetTime(Coefficient self) -> double"}, { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" "Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip) -> double\n" @@ -18812,8 +17977,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Coefficient_swigregister", Coefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_constant_set", _wrap_ConstantCoefficient_constant_set, METH_VARARGS, "ConstantCoefficient_constant_set(ConstantCoefficient self, double constant)"}, { "ConstantCoefficient_constant_get", _wrap_ConstantCoefficient_constant_get, METH_O, "ConstantCoefficient_constant_get(ConstantCoefficient self) -> double"}, - { "new_ConstantCoefficient", _wrap_new_ConstantCoefficient, METH_VARARGS, "ConstantCoefficient(double c=1.0)"}, - { "ConstantCoefficient_Eval", _wrap_ConstantCoefficient_Eval, METH_VARARGS, "Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ConstantCoefficient(double c=1.0) -> ConstantCoefficient"}, + { "ConstantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ConstantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ConstantCoefficient", _wrap_delete_ConstantCoefficient, METH_O, "delete_ConstantCoefficient(ConstantCoefficient self)"}, { "ConstantCoefficient_swigregister", ConstantCoefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_swiginit", ConstantCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18821,10 +17986,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "PWConstCoefficient(int NumOfSubD=0)\n" "new_PWConstCoefficient(Vector c) -> PWConstCoefficient\n" ""}, - { "PWConstCoefficient_UpdateConstants", _wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS, "UpdateConstants(PWConstCoefficient self, Vector c)"}, - { "PWConstCoefficient___call__", _wrap_PWConstCoefficient___call__, METH_VARARGS, "__call__(PWConstCoefficient self, int i) -> double &"}, + { "PWConstCoefficient_UpdateConstants", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS|METH_KEYWORDS, "UpdateConstants(PWConstCoefficient self, Vector c)"}, + { "PWConstCoefficient___call__", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient___call__, METH_VARARGS|METH_KEYWORDS, "__call__(PWConstCoefficient self, int i) -> double &"}, { "PWConstCoefficient_GetNConst", _wrap_PWConstCoefficient_GetNConst, METH_O, "GetNConst(PWConstCoefficient self) -> int"}, - { "PWConstCoefficient_Eval", _wrap_PWConstCoefficient_Eval, METH_VARARGS, "Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PWConstCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PWConstCoefficient", _wrap_delete_PWConstCoefficient, METH_O, "delete_PWConstCoefficient(PWConstCoefficient self)"}, { "PWConstCoefficient_swigregister", PWConstCoefficient_swigregister, METH_O, NULL}, { "PWConstCoefficient_swiginit", PWConstCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18834,17 +17999,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FunctionCoefficient(double (*)(mfem::Vector &) f)\n" "new_FunctionCoefficient(double (*)(mfem::Vector &,double) tdf) -> FunctionCoefficient\n" ""}, - { "FunctionCoefficient_Eval", _wrap_FunctionCoefficient_Eval, METH_VARARGS, "Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "FunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_FunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_FunctionCoefficient", _wrap_delete_FunctionCoefficient, METH_O, "delete_FunctionCoefficient(FunctionCoefficient self)"}, { "FunctionCoefficient_swigregister", FunctionCoefficient_swigregister, METH_O, NULL}, { "FunctionCoefficient_swiginit", FunctionCoefficient_swiginit, METH_VARARGS, NULL}, { "new_GridFunctionCoefficient", _wrap_new_GridFunctionCoefficient, METH_VARARGS, "\n" "GridFunctionCoefficient()\n" - "GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1)\n" + "new_GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1) -> GridFunctionCoefficient\n" ""}, - { "GridFunctionCoefficient_SetGridFunction", _wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GridFunctionCoefficient_GetGridFunction", _wrap_GridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "GridFunctionCoefficient_Eval", _wrap_GridFunctionCoefficient_Eval, METH_VARARGS, "Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "GridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_GridFunctionCoefficient", _wrap_delete_GridFunctionCoefficient, METH_O, "delete_GridFunctionCoefficient(GridFunctionCoefficient self)"}, { "GridFunctionCoefficient_swigregister", GridFunctionCoefficient_swigregister, METH_O, NULL}, { "GridFunctionCoefficient_swiginit", GridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18852,7 +18017,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "TransformedCoefficient(Coefficient q, double (*)(double) F)\n" "new_TransformedCoefficient(Coefficient q1, Coefficient q2, double (*)(double,double) F) -> TransformedCoefficient\n" ""}, - { "TransformedCoefficient_Eval", _wrap_TransformedCoefficient_Eval, METH_VARARGS, "Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "TransformedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransformedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_TransformedCoefficient", _wrap_delete_TransformedCoefficient, METH_O, "delete_TransformedCoefficient(TransformedCoefficient self)"}, { "TransformedCoefficient_swigregister", TransformedCoefficient_swigregister, METH_O, NULL}, { "TransformedCoefficient_swiginit", TransformedCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18862,27 +18027,27 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DeltaCoefficient(double x, double y, double s)\n" "new_DeltaCoefficient(double x, double y, double z, double s) -> DeltaCoefficient\n" ""}, - { "DeltaCoefficient_SetDeltaCenter", _wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_SetScale", _wrap_DeltaCoefficient_SetScale, METH_VARARGS, "SetScale(DeltaCoefficient self, double _s)"}, - { "DeltaCoefficient_SetFunction", _wrap_DeltaCoefficient_SetFunction, METH_VARARGS, "SetFunction(DeltaCoefficient self, double (*)(double) f)"}, - { "DeltaCoefficient_SetTol", _wrap_DeltaCoefficient_SetTol, METH_VARARGS, "SetTol(DeltaCoefficient self, double _tol)"}, - { "DeltaCoefficient_SetWeight", _wrap_DeltaCoefficient_SetWeight, METH_VARARGS, "SetWeight(DeltaCoefficient self, Coefficient w)"}, + { "DeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "SetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "SetScale(DeltaCoefficient self, double _s)"}, + { "DeltaCoefficient_SetFunction", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetFunction, METH_VARARGS|METH_KEYWORDS, "SetFunction(DeltaCoefficient self, double (*)(double) f)"}, + { "DeltaCoefficient_SetTol", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetTol, METH_VARARGS|METH_KEYWORDS, "SetTol(DeltaCoefficient self, double _tol)"}, + { "DeltaCoefficient_SetWeight", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetWeight, METH_VARARGS|METH_KEYWORDS, "SetWeight(DeltaCoefficient self, Coefficient w)"}, { "DeltaCoefficient_Center", _wrap_DeltaCoefficient_Center, METH_O, "Center(DeltaCoefficient self) -> double const *"}, { "DeltaCoefficient_Scale", _wrap_DeltaCoefficient_Scale, METH_O, "Scale(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Tol", _wrap_DeltaCoefficient_Tol, METH_O, "Tol(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Weight", _wrap_DeltaCoefficient_Weight, METH_O, "Weight(DeltaCoefficient self) -> Coefficient"}, - { "DeltaCoefficient_GetDeltaCenter", _wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_EvalDelta", _wrap_DeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "DeltaCoefficient_Eval", _wrap_DeltaCoefficient_Eval, METH_VARARGS, "Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "GetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeltaCoefficient", _wrap_delete_DeltaCoefficient, METH_O, "delete_DeltaCoefficient(DeltaCoefficient self)"}, { "DeltaCoefficient_swigregister", DeltaCoefficient_swigregister, METH_O, NULL}, { "DeltaCoefficient_swiginit", DeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_RestrictedCoefficient", _wrap_new_RestrictedCoefficient, METH_VARARGS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, - { "RestrictedCoefficient_Eval", _wrap_RestrictedCoefficient_Eval, METH_VARARGS, "Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_RestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_RestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, + { "RestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_RestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_RestrictedCoefficient", _wrap_delete_RestrictedCoefficient, METH_O, "delete_RestrictedCoefficient(RestrictedCoefficient self)"}, { "RestrictedCoefficient_swigregister", RestrictedCoefficient_swigregister, METH_O, NULL}, { "RestrictedCoefficient_swiginit", RestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "VectorCoefficient_SetTime", _wrap_VectorCoefficient_SetTime, METH_VARARGS, "SetTime(VectorCoefficient self, double t)"}, + { "VectorCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_VectorCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(VectorCoefficient self, double t)"}, { "VectorCoefficient_GetTime", _wrap_VectorCoefficient_GetTime, METH_O, "GetTime(VectorCoefficient self) -> double"}, { "VectorCoefficient_GetVDim", _wrap_VectorCoefficient_GetVDim, METH_O, "GetVDim(VectorCoefficient self) -> int"}, { "VectorCoefficient_Eval", _wrap_VectorCoefficient_Eval, METH_VARARGS, "\n" @@ -18891,7 +18056,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_VectorCoefficient", _wrap_delete_VectorCoefficient, METH_O, "delete_VectorCoefficient(VectorCoefficient self)"}, { "VectorCoefficient_swigregister", VectorCoefficient_swigregister, METH_O, NULL}, - { "new_VectorConstantCoefficient", _wrap_new_VectorConstantCoefficient, METH_O, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, + { "new_VectorConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, { "VectorConstantCoefficient_Eval", _wrap_VectorConstantCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18903,7 +18068,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, { "new_VectorFunctionCoefficient", _wrap_new_VectorFunctionCoefficient, METH_VARARGS, "\n" "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::Vector &) F, Coefficient q=None)\n" - "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None)\n" + "new_VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None) -> VectorFunctionCoefficient\n" ""}, { "VectorFunctionCoefficient_Eval", _wrap_VectorFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18913,10 +18078,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFunctionCoefficient", _wrap_delete_VectorFunctionCoefficient, METH_O, "delete_VectorFunctionCoefficient(VectorFunctionCoefficient self)"}, { "VectorFunctionCoefficient_swigregister", VectorFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorFunctionCoefficient_swiginit", VectorFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorArrayCoefficient", _wrap_new_VectorArrayCoefficient, METH_O, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, - { "VectorArrayCoefficient_GetCoeff", _wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, + { "new_VectorArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, + { "VectorArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, { "VectorArrayCoefficient_GetCoeffs", _wrap_VectorArrayCoefficient_GetCoeffs, METH_O, "GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **"}, - { "VectorArrayCoefficient_Set", _wrap_VectorArrayCoefficient_Set, METH_VARARGS, "Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, + { "VectorArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, { "VectorArrayCoefficient_Eval", _wrap_VectorArrayCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorArrayCoefficient self, int i, ElementTransformation T, IntegrationPoint ip) -> double\n" "Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18930,7 +18095,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorGridFunctionCoefficient()\n" "new_VectorGridFunctionCoefficient(mfem::GridFunction * gf) -> VectorGridFunctionCoefficient\n" ""}, - { "VectorGridFunctionCoefficient_SetGridFunction", _wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "VectorGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "VectorGridFunctionCoefficient_GetGridFunction", _wrap_VectorGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "VectorGridFunctionCoefficient_Eval", _wrap_VectorGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18939,8 +18104,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorGridFunctionCoefficient", _wrap_delete_VectorGridFunctionCoefficient, METH_O, "delete_VectorGridFunctionCoefficient(VectorGridFunctionCoefficient self)"}, { "VectorGridFunctionCoefficient_swigregister", VectorGridFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorGridFunctionCoefficient_swiginit", VectorGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_GradientGridFunctionCoefficient", _wrap_new_GradientGridFunctionCoefficient, METH_O, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, - { "GradientGridFunctionCoefficient_SetGridFunction", _wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_GradientGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_GradientGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, + { "GradientGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GradientGridFunctionCoefficient_GetGridFunction", _wrap_GradientGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "GradientGridFunctionCoefficient_Eval", _wrap_GradientGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(GradientGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18949,7 +18114,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_GradientGridFunctionCoefficient", _wrap_delete_GradientGridFunctionCoefficient, METH_O, "delete_GradientGridFunctionCoefficient(GradientGridFunctionCoefficient self)"}, { "GradientGridFunctionCoefficient_swigregister", GradientGridFunctionCoefficient_swigregister, METH_O, NULL}, { "GradientGridFunctionCoefficient_swiginit", GradientGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "CurlGridFunctionCoefficient_SetGridFunction", _wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "CurlGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "CurlGridFunctionCoefficient_GetGridFunction", _wrap_CurlGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "CurlGridFunctionCoefficient_Eval", _wrap_CurlGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -18958,10 +18123,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_CurlGridFunctionCoefficient", _wrap_delete_CurlGridFunctionCoefficient, METH_O, "delete_CurlGridFunctionCoefficient(CurlGridFunctionCoefficient self)"}, { "CurlGridFunctionCoefficient_swigregister", CurlGridFunctionCoefficient_swigregister, METH_O, NULL}, - { "new_DivergenceGridFunctionCoefficient", _wrap_new_DivergenceGridFunctionCoefficient, METH_O, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, - { "DivergenceGridFunctionCoefficient_SetGridFunction", _wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_DivergenceGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DivergenceGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, + { "DivergenceGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "DivergenceGridFunctionCoefficient_GetGridFunction", _wrap_DivergenceGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "DivergenceGridFunctionCoefficient_Eval", _wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS, "Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DivergenceGridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DivergenceGridFunctionCoefficient", _wrap_delete_DivergenceGridFunctionCoefficient, METH_O, "delete_DivergenceGridFunctionCoefficient(DivergenceGridFunctionCoefficient self)"}, { "DivergenceGridFunctionCoefficient_swigregister", DivergenceGridFunctionCoefficient_swigregister, METH_O, NULL}, { "DivergenceGridFunctionCoefficient_swiginit", DivergenceGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -18972,13 +18137,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorDeltaCoefficient(Vector _dir, double x, double y, double s)\n" "new_VectorDeltaCoefficient(Vector _dir, double x, double y, double z, double s) -> VectorDeltaCoefficient\n" ""}, - { "VectorDeltaCoefficient_SetDeltaCoefficient", _wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS, "SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, + { "VectorDeltaCoefficient_SetDeltaCoefficient", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS|METH_KEYWORDS, "SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, { "VectorDeltaCoefficient_GetDeltaCoefficient", _wrap_VectorDeltaCoefficient_GetDeltaCoefficient, METH_O, "GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient"}, - { "VectorDeltaCoefficient_SetScale", _wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS, "SetScale(VectorDeltaCoefficient self, double s)"}, - { "VectorDeltaCoefficient_SetDirection", _wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS, "SetDirection(VectorDeltaCoefficient self, Vector _d)"}, - { "VectorDeltaCoefficient_SetDeltaCenter", _wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_GetDeltaCenter", _wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_EvalDelta", _wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, + { "VectorDeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "SetScale(VectorDeltaCoefficient self, double s)"}, + { "VectorDeltaCoefficient_SetDirection", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS|METH_KEYWORDS, "SetDirection(VectorDeltaCoefficient self, Vector _d)"}, + { "VectorDeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, { "VectorDeltaCoefficient_Eval", _wrap_VectorDeltaCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorDeltaCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18987,7 +18152,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorDeltaCoefficient", _wrap_delete_VectorDeltaCoefficient, METH_O, "delete_VectorDeltaCoefficient(VectorDeltaCoefficient self)"}, { "VectorDeltaCoefficient_swigregister", VectorDeltaCoefficient_swigregister, METH_O, NULL}, { "VectorDeltaCoefficient_swiginit", VectorDeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRestrictedCoefficient", _wrap_new_VectorRestrictedCoefficient, METH_VARARGS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, + { "new_VectorRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, { "VectorRestrictedCoefficient_Eval", _wrap_VectorRestrictedCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorRestrictedCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -18995,15 +18160,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorRestrictedCoefficient", _wrap_delete_VectorRestrictedCoefficient, METH_O, "delete_VectorRestrictedCoefficient(VectorRestrictedCoefficient self)"}, { "VectorRestrictedCoefficient_swigregister", VectorRestrictedCoefficient_swigregister, METH_O, NULL}, { "VectorRestrictedCoefficient_swiginit", VectorRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "MatrixCoefficient_SetTime", _wrap_MatrixCoefficient_SetTime, METH_VARARGS, "SetTime(MatrixCoefficient self, double t)"}, + { "MatrixCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(MatrixCoefficient self, double t)"}, { "MatrixCoefficient_GetTime", _wrap_MatrixCoefficient_GetTime, METH_O, "GetTime(MatrixCoefficient self) -> double"}, { "MatrixCoefficient_GetHeight", _wrap_MatrixCoefficient_GetHeight, METH_O, "GetHeight(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetWidth", _wrap_MatrixCoefficient_GetWidth, METH_O, "GetWidth(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetVDim", _wrap_MatrixCoefficient_GetVDim, METH_O, "GetVDim(MatrixCoefficient self) -> int"}, - { "MatrixCoefficient_Eval", _wrap_MatrixCoefficient_Eval, METH_VARARGS, "Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixCoefficient", _wrap_delete_MatrixCoefficient, METH_O, "delete_MatrixCoefficient(MatrixCoefficient self)"}, { "MatrixCoefficient_swigregister", MatrixCoefficient_swigregister, METH_O, NULL}, - { "new_MatrixConstantCoefficient", _wrap_new_MatrixConstantCoefficient, METH_O, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, + { "new_MatrixConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, { "MatrixConstantCoefficient_Eval", _wrap_MatrixConstantCoefficient_Eval, METH_VARARGS, "\n" "Eval(MatrixConstantCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" "Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)\n" @@ -19014,15 +18179,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "new_MatrixFunctionCoefficient", _wrap_new_MatrixFunctionCoefficient, METH_VARARGS, "\n" "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::DenseMatrix &) F, Coefficient q=None)\n" "MatrixFunctionCoefficient(DenseMatrix m, Coefficient q)\n" - "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None)\n" + "new_MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None) -> MatrixFunctionCoefficient\n" ""}, - { "MatrixFunctionCoefficient_Eval", _wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS, "Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixFunctionCoefficient", _wrap_delete_MatrixFunctionCoefficient, METH_O, "delete_MatrixFunctionCoefficient(MatrixFunctionCoefficient self)"}, { "MatrixFunctionCoefficient_swigregister", MatrixFunctionCoefficient_swigregister, METH_O, NULL}, { "MatrixFunctionCoefficient_swiginit", MatrixFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixArrayCoefficient", _wrap_new_MatrixArrayCoefficient, METH_O, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, - { "MatrixArrayCoefficient_GetCoeff", _wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, - { "MatrixArrayCoefficient_Set", _wrap_MatrixArrayCoefficient_Set, METH_VARARGS, "Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, + { "new_MatrixArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, + { "MatrixArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, + { "MatrixArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, { "MatrixArrayCoefficient_Eval", _wrap_MatrixArrayCoefficient_Eval, METH_VARARGS, "\n" "Eval(MatrixArrayCoefficient self, int i, int j, ElementTransformation T, IntegrationPoint ip) -> double\n" "Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" @@ -19030,42 +18195,42 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MatrixArrayCoefficient", _wrap_delete_MatrixArrayCoefficient, METH_O, "delete_MatrixArrayCoefficient(MatrixArrayCoefficient self)"}, { "MatrixArrayCoefficient_swigregister", MatrixArrayCoefficient_swigregister, METH_O, NULL}, { "MatrixArrayCoefficient_swiginit", MatrixArrayCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixRestrictedCoefficient", _wrap_new_MatrixRestrictedCoefficient, METH_VARARGS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, - { "MatrixRestrictedCoefficient_Eval", _wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS, "Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, + { "MatrixRestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixRestrictedCoefficient", _wrap_delete_MatrixRestrictedCoefficient, METH_O, "delete_MatrixRestrictedCoefficient(MatrixRestrictedCoefficient self)"}, { "MatrixRestrictedCoefficient_swigregister", MatrixRestrictedCoefficient_swigregister, METH_O, NULL}, { "MatrixRestrictedCoefficient_swiginit", MatrixRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_SumCoefficient", _wrap_new_SumCoefficient, METH_VARARGS, "SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "SumCoefficient_Eval", _wrap_SumCoefficient_Eval, METH_VARARGS, "Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_SumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_SumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0) -> SumCoefficient"}, + { "SumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_SumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_SumCoefficient", _wrap_delete_SumCoefficient, METH_O, "delete_SumCoefficient(SumCoefficient self)"}, { "SumCoefficient_swigregister", SumCoefficient_swigregister, METH_O, NULL}, { "SumCoefficient_swiginit", SumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ProductCoefficient", _wrap_new_ProductCoefficient, METH_VARARGS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, - { "ProductCoefficient_Eval", _wrap_ProductCoefficient_Eval, METH_VARARGS, "Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, + { "ProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ProductCoefficient", _wrap_delete_ProductCoefficient, METH_O, "delete_ProductCoefficient(ProductCoefficient self)"}, { "ProductCoefficient_swigregister", ProductCoefficient_swigregister, METH_O, NULL}, { "ProductCoefficient_swiginit", ProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_PowerCoefficient", _wrap_new_PowerCoefficient, METH_VARARGS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, - { "PowerCoefficient_Eval", _wrap_PowerCoefficient_Eval, METH_VARARGS, "Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_PowerCoefficient", (PyCFunction)(void(*)(void))_wrap_new_PowerCoefficient, METH_VARARGS|METH_KEYWORDS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, + { "PowerCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PowerCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PowerCoefficient", _wrap_delete_PowerCoefficient, METH_O, "delete_PowerCoefficient(PowerCoefficient self)"}, { "PowerCoefficient_swigregister", PowerCoefficient_swigregister, METH_O, NULL}, { "PowerCoefficient_swiginit", PowerCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InnerProductCoefficient", _wrap_new_InnerProductCoefficient, METH_VARARGS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, - { "InnerProductCoefficient_Eval", _wrap_InnerProductCoefficient_Eval, METH_VARARGS, "Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_InnerProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InnerProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, + { "InnerProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InnerProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_InnerProductCoefficient", _wrap_delete_InnerProductCoefficient, METH_O, "delete_InnerProductCoefficient(InnerProductCoefficient self)"}, { "InnerProductCoefficient_swigregister", InnerProductCoefficient_swigregister, METH_O, NULL}, { "InnerProductCoefficient_swiginit", InnerProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRotProductCoefficient", _wrap_new_VectorRotProductCoefficient, METH_VARARGS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, - { "VectorRotProductCoefficient_Eval", _wrap_VectorRotProductCoefficient_Eval, METH_VARARGS, "Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_VectorRotProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRotProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, + { "VectorRotProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_VectorRotProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_VectorRotProductCoefficient", _wrap_delete_VectorRotProductCoefficient, METH_O, "delete_VectorRotProductCoefficient(VectorRotProductCoefficient self)"}, { "VectorRotProductCoefficient_swigregister", VectorRotProductCoefficient_swigregister, METH_O, NULL}, { "VectorRotProductCoefficient_swiginit", VectorRotProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_DeterminantCoefficient", _wrap_new_DeterminantCoefficient, METH_O, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, - { "DeterminantCoefficient_Eval", _wrap_DeterminantCoefficient_Eval, METH_VARARGS, "Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_DeterminantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DeterminantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, + { "DeterminantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeterminantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeterminantCoefficient", _wrap_delete_DeterminantCoefficient, METH_O, "delete_DeterminantCoefficient(DeterminantCoefficient self)"}, { "DeterminantCoefficient_swigregister", DeterminantCoefficient_swigregister, METH_O, NULL}, { "DeterminantCoefficient_swiginit", DeterminantCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorSumCoefficient", _wrap_new_VectorSumCoefficient, METH_VARARGS, "VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "new_VectorSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0) -> VectorSumCoefficient"}, { "VectorSumCoefficient_Eval", _wrap_VectorSumCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorSumCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19073,7 +18238,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorSumCoefficient", _wrap_delete_VectorSumCoefficient, METH_O, "delete_VectorSumCoefficient(VectorSumCoefficient self)"}, { "VectorSumCoefficient_swigregister", VectorSumCoefficient_swigregister, METH_O, NULL}, { "VectorSumCoefficient_swiginit", VectorSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductCoefficient", _wrap_new_ScalarVectorProductCoefficient, METH_VARARGS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, + { "new_ScalarVectorProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, { "ScalarVectorProductCoefficient_Eval", _wrap_ScalarVectorProductCoefficient_Eval, METH_VARARGS, "\n" "Eval(ScalarVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19081,7 +18246,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_ScalarVectorProductCoefficient", _wrap_delete_ScalarVectorProductCoefficient, METH_O, "delete_ScalarVectorProductCoefficient(ScalarVectorProductCoefficient self)"}, { "ScalarVectorProductCoefficient_swigregister", ScalarVectorProductCoefficient_swigregister, METH_O, NULL}, { "ScalarVectorProductCoefficient_swiginit", ScalarVectorProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductCoefficient", _wrap_new_VectorCrossProductCoefficient, METH_VARARGS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, + { "new_VectorCrossProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, { "VectorCrossProductCoefficient_Eval", _wrap_VectorCrossProductCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorCrossProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19089,7 +18254,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorCrossProductCoefficient", _wrap_delete_VectorCrossProductCoefficient, METH_O, "delete_VectorCrossProductCoefficient(VectorCrossProductCoefficient self)"}, { "VectorCrossProductCoefficient_swigregister", VectorCrossProductCoefficient_swigregister, METH_O, NULL}, { "VectorCrossProductCoefficient_swiginit", VectorCrossProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatVecCoefficient", _wrap_new_MatVecCoefficient, METH_VARARGS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, + { "new_MatVecCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatVecCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, { "MatVecCoefficient_Eval", _wrap_MatVecCoefficient_Eval, METH_VARARGS, "\n" "Eval(MatVecCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19097,33 +18262,33 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MatVecCoefficient", _wrap_delete_MatVecCoefficient, METH_O, "delete_MatVecCoefficient(MatVecCoefficient self)"}, { "MatVecCoefficient_swigregister", MatVecCoefficient_swigregister, METH_O, NULL}, { "MatVecCoefficient_swiginit", MatVecCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_IdentityMatrixCoefficient", _wrap_new_IdentityMatrixCoefficient, METH_O, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, - { "IdentityMatrixCoefficient_Eval", _wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS, "Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_IdentityMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_IdentityMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, + { "IdentityMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_IdentityMatrixCoefficient", _wrap_delete_IdentityMatrixCoefficient, METH_O, "delete_IdentityMatrixCoefficient(IdentityMatrixCoefficient self)"}, { "IdentityMatrixCoefficient_swigregister", IdentityMatrixCoefficient_swigregister, METH_O, NULL}, { "IdentityMatrixCoefficient_swiginit", IdentityMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixSumCoefficient", _wrap_new_MatrixSumCoefficient, METH_VARARGS, "MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "MatrixSumCoefficient_Eval", _wrap_MatrixSumCoefficient_Eval, METH_VARARGS, "Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0) -> MatrixSumCoefficient"}, + { "MatrixSumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixSumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixSumCoefficient", _wrap_delete_MatrixSumCoefficient, METH_O, "delete_MatrixSumCoefficient(MatrixSumCoefficient self)"}, { "MatrixSumCoefficient_swigregister", MatrixSumCoefficient_swigregister, METH_O, NULL}, { "MatrixSumCoefficient_swiginit", MatrixSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarMatrixProductCoefficient", _wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, - { "ScalarMatrixProductCoefficient_Eval", _wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS, "Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_ScalarMatrixProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, + { "ScalarMatrixProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_ScalarMatrixProductCoefficient", _wrap_delete_ScalarMatrixProductCoefficient, METH_O, "delete_ScalarMatrixProductCoefficient(ScalarMatrixProductCoefficient self)"}, { "ScalarMatrixProductCoefficient_swigregister", ScalarMatrixProductCoefficient_swigregister, METH_O, NULL}, { "ScalarMatrixProductCoefficient_swiginit", ScalarMatrixProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_TransposeMatrixCoefficient", _wrap_new_TransposeMatrixCoefficient, METH_O, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, - { "TransposeMatrixCoefficient_Eval", _wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS, "Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_TransposeMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_TransposeMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, + { "TransposeMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_TransposeMatrixCoefficient", _wrap_delete_TransposeMatrixCoefficient, METH_O, "delete_TransposeMatrixCoefficient(TransposeMatrixCoefficient self)"}, { "TransposeMatrixCoefficient_swigregister", TransposeMatrixCoefficient_swigregister, METH_O, NULL}, { "TransposeMatrixCoefficient_swiginit", TransposeMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InverseMatrixCoefficient", _wrap_new_InverseMatrixCoefficient, METH_O, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, - { "InverseMatrixCoefficient_Eval", _wrap_InverseMatrixCoefficient_Eval, METH_VARARGS, "Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_InverseMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InverseMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, + { "InverseMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InverseMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_InverseMatrixCoefficient", _wrap_delete_InverseMatrixCoefficient, METH_O, "delete_InverseMatrixCoefficient(InverseMatrixCoefficient self)"}, { "InverseMatrixCoefficient_swigregister", InverseMatrixCoefficient_swigregister, METH_O, NULL}, { "InverseMatrixCoefficient_swiginit", InverseMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_OuterProductCoefficient", _wrap_new_OuterProductCoefficient, METH_VARARGS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, - { "OuterProductCoefficient_Eval", _wrap_OuterProductCoefficient_Eval, METH_VARARGS, "Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_OuterProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_OuterProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, + { "OuterProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_OuterProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_OuterProductCoefficient", _wrap_delete_OuterProductCoefficient, METH_O, "delete_OuterProductCoefficient(OuterProductCoefficient self)"}, { "OuterProductCoefficient_swigregister", OuterProductCoefficient_swigregister, METH_O, NULL}, { "OuterProductCoefficient_swiginit", OuterProductCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19135,34 +18300,34 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ComputeGlobalLpNorm(double p, Coefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double\n" "ComputeGlobalLpNorm(double p, VectorCoefficient coeff, mfem::ParMesh & pmesh, mfem::IntegrationRule const *[] irs) -> double\n" ""}, - { "fake_func", _wrap_fake_func, METH_O, "fake_func(Vector x) -> double"}, - { "fake_func_vec", _wrap_fake_func_vec, METH_VARARGS, "fake_func_vec(Vector x, Vector Ht)"}, - { "fake_func_mat", _wrap_fake_func_mat, METH_VARARGS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, - { "new_PyCoefficientBase", _wrap_new_PyCoefficientBase, METH_VARARGS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, - { "PyCoefficientBase_Eval", _wrap_PyCoefficientBase_Eval, METH_VARARGS, "Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "PyCoefficientBase__EvalPy", _wrap_PyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, - { "PyCoefficientBase__EvalPyT", _wrap_PyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, + { "fake_func", (PyCFunction)(void(*)(void))_wrap_fake_func, METH_VARARGS|METH_KEYWORDS, "fake_func(Vector x) -> double"}, + { "fake_func_vec", (PyCFunction)(void(*)(void))_wrap_fake_func_vec, METH_VARARGS|METH_KEYWORDS, "fake_func_vec(Vector x, Vector Ht)"}, + { "fake_func_mat", (PyCFunction)(void(*)(void))_wrap_fake_func_mat, METH_VARARGS|METH_KEYWORDS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, + { "new_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, + { "PyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "_EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, + { "PyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, { "delete_PyCoefficientBase", _wrap_delete_PyCoefficientBase, METH_O, "delete_PyCoefficientBase(PyCoefficientBase self)"}, - { "disown_PyCoefficientBase", _wrap_disown_PyCoefficientBase, METH_O, NULL}, + { "disown_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyCoefficientBase_swigregister", PyCoefficientBase_swigregister, METH_O, NULL}, { "PyCoefficientBase_swiginit", PyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_VectorPyCoefficientBase", _wrap_new_VectorPyCoefficientBase, METH_VARARGS, "VectorPyCoefficientBase(int dim, int tdep, Coefficient q=None)"}, + { "new_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_VectorPyCoefficientBase(PyObject * _self, int dim, int tdep, Coefficient q=None) -> VectorPyCoefficientBase"}, { "VectorPyCoefficientBase_Eval", _wrap_VectorPyCoefficientBase_Eval, METH_VARARGS, "\n" "Eval(VectorPyCoefficientBase self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" "Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" ""}, - { "VectorPyCoefficientBase__EvalPy", _wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, - { "VectorPyCoefficientBase__EvalPyT", _wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, + { "VectorPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, + { "VectorPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, { "delete_VectorPyCoefficientBase", _wrap_delete_VectorPyCoefficientBase, METH_O, "delete_VectorPyCoefficientBase(VectorPyCoefficientBase self)"}, - { "disown_VectorPyCoefficientBase", _wrap_disown_VectorPyCoefficientBase, METH_O, NULL}, + { "disown_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "VectorPyCoefficientBase_swigregister", VectorPyCoefficientBase_swigregister, METH_O, NULL}, { "VectorPyCoefficientBase_swiginit", VectorPyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_MatrixPyCoefficientBase", _wrap_new_MatrixPyCoefficientBase, METH_VARARGS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, - { "MatrixPyCoefficientBase_Eval", _wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS, "Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, - { "MatrixPyCoefficientBase__EvalPy", _wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, - { "MatrixPyCoefficientBase__EvalPyT", _wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, + { "new_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, + { "MatrixPyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, + { "MatrixPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, { "delete_MatrixPyCoefficientBase", _wrap_delete_MatrixPyCoefficientBase, METH_O, "delete_MatrixPyCoefficientBase(MatrixPyCoefficientBase self)"}, - { "disown_MatrixPyCoefficientBase", _wrap_disown_MatrixPyCoefficientBase, METH_O, NULL}, + { "disown_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "MatrixPyCoefficientBase_swigregister", MatrixPyCoefficientBase_swigregister, METH_O, NULL}, { "MatrixPyCoefficientBase_swiginit", MatrixPyCoefficientBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -20412,10 +19577,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); import_array(); diff --git a/mfem/_par/common_functions_wrap.cxx b/mfem/_par/common_functions_wrap.cxx index 695e596c..8c16d0ca 100644 --- a/mfem/_par/common_functions_wrap.cxx +++ b/mfem/_par/common_functions_wrap.cxx @@ -3031,7 +3031,7 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ PyObject *resultobj = 0; mfem::Table *arg1 = 0 ; mfem::Table *arg2 = 0 ; - int arg3 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3039,7 +3039,7 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Table const &""'"); @@ -3056,11 +3056,13 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { mfem::Transpose((mfem::Table const &)*arg1,*arg2,arg3); @@ -3085,55 +3087,6 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_Transpose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = 0 ; - mfem::Table *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Table const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Table const &""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); - { - try { - mfem::Transpose((mfem::Table const &)*arg1,*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Transpose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = 0 ; void *argp1 = 0 ; @@ -3172,11 +3125,11 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Transpose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; mfem::Table *arg2 = 0 ; - int arg3 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3184,7 +3137,7 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); @@ -3201,63 +3154,16 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem::Transpose((mfem::Array< int > const &)*arg1,*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Transpose__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = 0 ; - mfem::Table *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< mfem::Table * >(argp2); { try { - mfem::Transpose((mfem::Array< int > const &)*arg1,*arg2); + mfem::Transpose((mfem::Array< int > const &)*arg1,*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3498,7 +3404,7 @@ SWIGINTERN PyObject *_wrap_InnerProduct__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Transpose__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = 0 ; void *argp1 = 0 ; @@ -3861,7 +3767,7 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize } -SWIGINTERN PyObject *_wrap_Transpose__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Transpose__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; void *argp1 = 0 ; @@ -3913,7 +3819,7 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_2(self, argc, argv); + return _wrap_Transpose__SWIG_1(self, argc, argv); } } if (argc == 1) { @@ -3921,7 +3827,7 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BlockMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_5(self, argc, argv); + return _wrap_Transpose__SWIG_3(self, argc, argv); } } if (argc == 1) { @@ -3929,10 +3835,10 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_6(self, argc, argv); + return _wrap_Transpose__SWIG_4(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -3941,57 +3847,37 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Transpose__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Transpose__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Transpose__SWIG_3(self, argc, argv); + return _wrap_Transpose__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Transpose__SWIG_2(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Transpose__SWIG_0(self, argc, argv); + return _wrap_Transpose__SWIG_2(self, argc, argv); } } } @@ -4001,10 +3887,8 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Transpose'.\n" " Possible C/C++ prototypes are:\n" " mfem::Transpose(mfem::Table const &,mfem::Table &,int)\n" - " mfem::Transpose(mfem::Table const &,mfem::Table &)\n" " mfem::Transpose(mfem::Table const &)\n" " mfem::Transpose(mfem::Array< int > const &,mfem::Table &,int)\n" - " mfem::Transpose(mfem::Array< int > const &,mfem::Table &)\n" " mfem::Transpose(mfem::BlockMatrix const &)\n" " mfem::Transpose(mfem::SparseMatrix const &)\n"); return 0; @@ -4015,7 +3899,7 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; - mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) 0 ; + mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4024,7 +3908,7 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize int res3 = 0 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -4041,11 +3925,13 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { result = (mfem::SparseMatrix *)mfem::Mult((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2,arg3); @@ -4070,56 +3956,6 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize SWIGINTERN PyObject *_wrap_Mult__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - mfem::SparseMatrix *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - { - try { - result = (mfem::SparseMatrix *)mfem::Mult((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mult__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -4201,7 +4037,7 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -4209,7 +4045,15 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mult__SWIG_5(self, argc, argv); + if (argc <= 2) { + return _wrap_Mult__SWIG_4(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mult__SWIG_4(self, argc, argv); + } } } } @@ -4222,24 +4066,7 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mult__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mult__SWIG_4(self, argc, argv); - } + return _wrap_Mult__SWIG_5(self, argc, argv); } } } @@ -4286,7 +4113,6 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { " mfem::Mult(mfem::BlockMatrix const &,mfem::BlockMatrix const &)\n" " mfem::Mult(mfem::DenseMatrix const &,mfem::DenseMatrix const &,mfem::DenseMatrix &)\n" " mfem::Mult(mfem::SparseMatrix const &,mfem::SparseMatrix const &,mfem::SparseMatrix *)\n" - " mfem::Mult(mfem::SparseMatrix const &,mfem::SparseMatrix const &)\n" " mfem::Mult(mfem::SparseMatrix const &,mfem::DenseMatrix &)\n"); return 0; } @@ -4396,7 +4222,7 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; - mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) 0 ; + mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4405,7 +4231,7 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res3 = 0 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -4422,11 +4248,13 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { result = (mfem::SparseMatrix *)mfem::RAP((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2,arg3); @@ -4451,56 +4279,6 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIGINTERN PyObject *_wrap_RAP__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - mfem::SparseMatrix *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAP" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - { - try { - result = (mfem::SparseMatrix *)mfem::RAP((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_RAP__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -5204,7 +4982,7 @@ SWIGINTERN PyObject *_wrap_Add(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_RAP__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_RAP__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; @@ -5248,7 +5026,7 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_RAP__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_RAP__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; @@ -5334,7 +5112,7 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -5342,7 +5120,15 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RAP__SWIG_3(self, argc, argv); + if (argc <= 2) { + return _wrap_RAP__SWIG_2(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_RAP__SWIG_2(self, argc, argv); + } } } } @@ -5356,7 +5142,7 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RAP__SWIG_5(self, argc, argv); + return _wrap_RAP__SWIG_4(self, argc, argv); } } } @@ -5371,24 +5157,7 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RAP__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_RAP__SWIG_2(self, argc, argv); + return _wrap_RAP__SWIG_3(self, argc, argv); } } } @@ -5407,7 +5176,7 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RAP__SWIG_6(self, argc, argv); + return _wrap_RAP__SWIG_5(self, argc, argv); } } } @@ -5419,7 +5188,6 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { " mfem::RAP(mfem::SparseMatrix const &,mfem::DenseMatrix &)\n" " mfem::RAP(mfem::DenseMatrix &,mfem::SparseMatrix const &)\n" " mfem::RAP(mfem::SparseMatrix const &,mfem::SparseMatrix const &,mfem::SparseMatrix *)\n" - " mfem::RAP(mfem::SparseMatrix const &,mfem::SparseMatrix const &)\n" " mfem::RAP(mfem::SparseMatrix const &,mfem::SparseMatrix const &,mfem::SparseMatrix const &)\n" " mfem::RAP(mfem::HypreParMatrix const *,mfem::HypreParMatrix const *)\n" " mfem::RAP(mfem::HypreParMatrix const *,mfem::HypreParMatrix const *,mfem::HypreParMatrix const *)\n"); @@ -6392,11 +6160,11 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); SWIG_Python_SetConstant(d, "MFEM_GIT_STRING",SWIG_FromCharPtr("tags/v4.1-0-g8dbbcfc25629ac7612fe31afd5b511752ff0e69b")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/communication.py b/mfem/_par/communication.py index b3d863e5..cb5efe7f 100644 --- a/mfem/_par/communication.py +++ b/mfem/_par/communication.py @@ -240,9 +240,9 @@ class GroupCommunicator(object): byNeighbor = _communication.GroupCommunicator_byNeighbor - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(GroupCommunicator self, GroupTopology gt, mfem::GroupCommunicator::Mode m=byNeighbor) -> GroupCommunicator""" - _communication.GroupCommunicator_swiginit(self, _communication.new_GroupCommunicator(*args)) + _communication.GroupCommunicator_swiginit(self, _communication.new_GroupCommunicator(*args, **kwargs)) def Create(self, ldof_group): r"""Create(GroupCommunicator self, intArray ldof_group)""" diff --git a/mfem/_par/communication_wrap.cxx b/mfem/_par/communication_wrap.cxx index 510d1eea..5cdf52cf 100644 --- a/mfem/_par/communication_wrap.cxx +++ b/mfem/_par/communication_wrap.cxx @@ -3146,7 +3146,7 @@ SWIG_AsVal_int (PyObject * obj, int *val) return res; } -SWIGINTERN void mfem_GroupCommunicator_PrintInfo__SWIG_2(mfem::GroupCommunicator *self,char const *file,int precision=8){ +SWIGINTERN void mfem_GroupCommunicator_PrintInfo__SWIG_1(mfem::GroupCommunicator *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3578,23 +3578,27 @@ SWIGINTERN PyObject *_wrap_new_GroupTopology(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_GroupTopology_SetComm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_SetComm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; MPI_Comm arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"comm", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_SetComm", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_SetComm", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_SetComm" "', argument " "1"" of type '" "mfem::GroupTopology *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[1], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj1, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "GroupTopology_SetComm" "', argument " "2"" of type '" "MPI_Comm""'"); } @@ -3738,7 +3742,7 @@ SWIGINTERN PyObject *_wrap_GroupTopology_NRanks(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_GroupTopology_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; mfem::ListOfIntegerSets *arg2 = 0 ; @@ -3747,15 +3751,20 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Create(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"groups", (char *)"mpitag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_Create", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GroupTopology_Create", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_Create" "', argument " "1"" of type '" "mfem::GroupTopology *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ListOfIntegerSets, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ListOfIntegerSets, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupTopology_Create" "', argument " "2"" of type '" "mfem::ListOfIntegerSets &""'"); } @@ -3764,10 +3773,10 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Create(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3868,26 +3877,30 @@ SWIGINTERN PyObject *_wrap_GroupTopology_GetNumNeighbors(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_GroupTopology_GetNeighborRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_GetNeighborRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_GetNeighborRank", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_GetNeighborRank", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_GetNeighborRank" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3912,26 +3925,30 @@ SWIGINTERN PyObject *_wrap_GroupTopology_GetNeighborRank(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_GroupTopology_IAmMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_IAmMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"g", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_IAmMaster", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_IAmMaster", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_IAmMaster" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3956,26 +3973,30 @@ SWIGINTERN PyObject *_wrap_GroupTopology_IAmMaster(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"g", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_GetGroupMaster", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_GetGroupMaster", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_GetGroupMaster" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4000,26 +4021,30 @@ SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMaster(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMasterRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMasterRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"g", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_GetGroupMasterRank", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_GetGroupMasterRank", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_GetGroupMasterRank" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4044,26 +4069,30 @@ SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMasterRank(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMasterGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMasterGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"g", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_GetGroupMasterGroup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_GetGroupMasterGroup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_GetGroupMasterGroup" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4088,26 +4117,30 @@ SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupMasterGroup(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"g", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_GetGroupSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_GetGroupSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_GetGroupSize" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4132,26 +4165,30 @@ SWIGINTERN PyObject *_wrap_GroupTopology_GetGroupSize(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GroupTopology_GetGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_GetGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"g", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_GetGroup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_GetGroup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_GetGroup" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4239,7 +4276,7 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GroupTopology_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; std::istream *arg2 = 0 ; @@ -4247,15 +4284,19 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Load(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_in", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_Load", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_Load", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_Load" "', argument " "1"" of type '" "mfem::GroupTopology *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupTopology_Load" "', argument " "2"" of type '" "std::istream &""'"); } @@ -4286,7 +4327,7 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Load(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_GroupTopology_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupTopology_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; mfem::GroupTopology *arg2 = 0 ; @@ -4294,15 +4335,19 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Copy(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupTopology_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupTopology_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_Copy" "', argument " "1"" of type '" "mfem::GroupTopology const *""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GroupTopology, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GroupTopology, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupTopology_Copy" "', argument " "2"" of type '" "mfem::GroupTopology &""'"); } @@ -4374,14 +4419,14 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(s PyObject *resultobj = 0; mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_Save" "', argument " "1"" of type '" "mfem::GroupTopology *""'"); @@ -4392,61 +4437,17 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupTopology_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_GroupTopology_Save__SWIG_1(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GroupTopology_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GroupTopology *arg1 = (mfem::GroupTopology *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupTopology, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupTopology_Save" "', argument " "1"" of type '" "mfem::GroupTopology *""'"); - } - arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupTopology_Save" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_GroupTopology_Save__SWIG_1(arg1,(char const *)arg2); + mfem_GroupTopology_Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4477,7 +4478,7 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Save(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "GroupTopology_Save", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupTopology, 0); @@ -4486,7 +4487,20 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GroupTopology_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_GroupTopology_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GroupTopology_Save__SWIG_1(self, argc, argv); + } } } } @@ -4510,36 +4524,12 @@ SWIGINTERN PyObject *_wrap_GroupTopology_Save(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupTopology, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GroupTopology_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GroupTopology_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::GroupTopology::Save(std::ostream &) const\n" - " mfem::GroupTopology::Save(char const *,int)\n" - " mfem::GroupTopology::Save(char const *)\n"); + " mfem::GroupTopology::Save(char const *,int)\n"); return 0; } @@ -4555,18 +4545,23 @@ SWIGINTERN PyObject *GroupTopology_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GroupCommunicator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GroupCommunicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupTopology *arg1 = 0 ; - mfem::GroupCommunicator::Mode arg2 ; + mfem::GroupCommunicator::Mode arg2 = (mfem::GroupCommunicator::Mode) mfem::GroupCommunicator::byNeighbor ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"gt", (char *)"m", NULL + }; mfem::GroupCommunicator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__GroupTopology, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_GroupCommunicator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__GroupTopology, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupCommunicator" "', argument " "1"" of type '" "mfem::GroupTopology &""'"); } @@ -4574,11 +4569,13 @@ SWIGINTERN PyObject *_wrap_new_GroupCommunicator__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupCommunicator" "', argument " "1"" of type '" "mfem::GroupTopology &""'"); } arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupCommunicator" "', argument " "2"" of type '" "mfem::GroupCommunicator::Mode""'"); - } - arg2 = static_cast< mfem::GroupCommunicator::Mode >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupCommunicator" "', argument " "2"" of type '" "mfem::GroupCommunicator::Mode""'"); + } + arg2 = static_cast< mfem::GroupCommunicator::Mode >(val2); + } { try { result = (mfem::GroupCommunicator *)new mfem::GroupCommunicator(*arg1,arg2); @@ -4602,88 +4599,7 @@ SWIGINTERN PyObject *_wrap_new_GroupCommunicator__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_GroupCommunicator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GroupTopology *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GroupCommunicator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__GroupTopology, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupCommunicator" "', argument " "1"" of type '" "mfem::GroupTopology &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupCommunicator" "', argument " "1"" of type '" "mfem::GroupTopology &""'"); - } - arg1 = reinterpret_cast< mfem::GroupTopology * >(argp1); - { - try { - result = (mfem::GroupCommunicator *)new mfem::GroupCommunicator(*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupCommunicator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GroupCommunicator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GroupCommunicator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupTopology, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GroupCommunicator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupTopology, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GroupCommunicator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GroupCommunicator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GroupCommunicator::GroupCommunicator(mfem::GroupTopology &,mfem::GroupCommunicator::Mode)\n" - " mfem::GroupCommunicator::GroupCommunicator(mfem::GroupTopology &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GroupCommunicator_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupCommunicator_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4691,15 +4607,19 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_Create(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ldof_group", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupCommunicator_Create", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupCommunicator_Create", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_Create" "', argument " "1"" of type '" "mfem::GroupCommunicator *""'"); } arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_Create" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -4875,7 +4795,7 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_Finalize(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GroupCommunicator_SetLTDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupCommunicator_SetLTDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4883,15 +4803,19 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_SetLTDofTable(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ldof_ltdof", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupCommunicator_SetLTDofTable", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupCommunicator_SetLTDofTable", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_SetLTDofTable" "', argument " "1"" of type '" "mfem::GroupCommunicator *""'"); } arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_SetLTDofTable" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5030,7 +4954,7 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_GetGroupTopology(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLTDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLTDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; mfem::Table *arg2 = 0 ; @@ -5038,15 +4962,19 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLTDofTable(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nbr_ltdof", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupCommunicator_GetNeighborLTDofTable", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupCommunicator_GetNeighborLTDofTable", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_GetNeighborLTDofTable" "', argument " "1"" of type '" "mfem::GroupCommunicator const *""'"); } arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_GetNeighborLTDofTable" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -5077,7 +5005,7 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLTDofTable(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLDofTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; mfem::Table *arg2 = 0 ; @@ -5085,15 +5013,19 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLDofTable(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nbr_ldof", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupCommunicator_GetNeighborLDofTable", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GroupCommunicator_GetNeighborLDofTable", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_GetNeighborLDofTable" "', argument " "1"" of type '" "mfem::GroupCommunicator const *""'"); } arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_GetNeighborLDofTable" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -5127,31 +5059,34 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_GetNeighborLDofTable(PyObject *SWIG SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_PrintInfo" "', argument " "1"" of type '" "mfem::GroupCommunicator const *""'"); } arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -5187,41 +5122,6 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_PrintInfo" "', argument " "1"" of type '" "mfem::GroupCommunicator const *""'"); - } - arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); - { - try { - ((mfem::GroupCommunicator const *)arg1)->PrintInfo(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_delete_GroupCommunicator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; @@ -5259,18 +5159,18 @@ SWIGINTERN PyObject *_wrap_delete_GroupCommunicator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_PrintInfo" "', argument " "1"" of type '" "mfem::GroupCommunicator *""'"); @@ -5281,61 +5181,17 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_2(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_GroupCommunicator_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GroupCommunicator *arg1 = (mfem::GroupCommunicator *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupCommunicator_PrintInfo" "', argument " "1"" of type '" "mfem::GroupCommunicator *""'"); - } - arg1 = reinterpret_cast< mfem::GroupCommunicator * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupCommunicator_PrintInfo" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_GroupCommunicator_PrintInfo__SWIG_2(arg1,(char const *)arg2); + mfem_GroupCommunicator_PrintInfo__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5366,34 +5222,15 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "GroupCommunicator_PrintInfo", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupCommunicator, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GroupCommunicator_PrintInfo__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupCommunicator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GroupCommunicator_PrintInfo__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_GroupCommunicator_PrintInfo__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupCommunicator, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -5408,7 +5245,7 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo(PyObject *self, PyObject } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GroupCommunicator, 0); @@ -5417,6 +5254,9 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo(PyObject *self, PyObject int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_GroupCommunicator_PrintInfo__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5426,7 +5266,7 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo(PyObject *self, PyObject } } if (_v) { - return _wrap_GroupCommunicator_PrintInfo__SWIG_2(self, argc, argv); + return _wrap_GroupCommunicator_PrintInfo__SWIG_1(self, argc, argv); } } } @@ -5436,9 +5276,7 @@ SWIGINTERN PyObject *_wrap_GroupCommunicator_PrintInfo(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GroupCommunicator_PrintInfo'.\n" " Possible C/C++ prototypes are:\n" " mfem::GroupCommunicator::PrintInfo(std::ostream &) const\n" - " mfem::GroupCommunicator::PrintInfo() const\n" - " mfem::GroupCommunicator::PrintInfo(char const *,int)\n" - " mfem::GroupCommunicator::PrintInfo(char const *)\n"); + " mfem::GroupCommunicator::PrintInfo(char const *,int)\n"); return 0; } @@ -5454,17 +5292,19 @@ SWIGINTERN PyObject *GroupCommunicator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ReorderRanksZCurve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ReorderRanksZCurve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; MPI_Comm arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"comm", NULL + }; MPI_Comm result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:ReorderRanksZCurve", kwnames, &obj0)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj0, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ReorderRanksZCurve" "', argument " "1"" of type '" "MPI_Comm""'"); } @@ -5512,22 +5352,22 @@ static PyMethodDef SwigMethods[] = { "GroupTopology(MPI_Comm comm)\n" "new_GroupTopology(GroupTopology gt) -> GroupTopology\n" ""}, - { "GroupTopology_SetComm", _wrap_GroupTopology_SetComm, METH_VARARGS, "GroupTopology_SetComm(GroupTopology self, MPI_Comm comm)"}, + { "GroupTopology_SetComm", (PyCFunction)(void(*)(void))_wrap_GroupTopology_SetComm, METH_VARARGS|METH_KEYWORDS, "GroupTopology_SetComm(GroupTopology self, MPI_Comm comm)"}, { "GroupTopology_GetComm", _wrap_GroupTopology_GetComm, METH_O, "GroupTopology_GetComm(GroupTopology self) -> MPI_Comm"}, { "GroupTopology_MyRank", _wrap_GroupTopology_MyRank, METH_O, "GroupTopology_MyRank(GroupTopology self) -> int"}, { "GroupTopology_NRanks", _wrap_GroupTopology_NRanks, METH_O, "GroupTopology_NRanks(GroupTopology self) -> int"}, - { "GroupTopology_Create", _wrap_GroupTopology_Create, METH_VARARGS, "GroupTopology_Create(GroupTopology self, ListOfIntegerSets groups, int mpitag)"}, + { "GroupTopology_Create", (PyCFunction)(void(*)(void))_wrap_GroupTopology_Create, METH_VARARGS|METH_KEYWORDS, "GroupTopology_Create(GroupTopology self, ListOfIntegerSets groups, int mpitag)"}, { "GroupTopology_NGroups", _wrap_GroupTopology_NGroups, METH_O, "GroupTopology_NGroups(GroupTopology self) -> int"}, { "GroupTopology_GetNumNeighbors", _wrap_GroupTopology_GetNumNeighbors, METH_O, "GroupTopology_GetNumNeighbors(GroupTopology self) -> int"}, - { "GroupTopology_GetNeighborRank", _wrap_GroupTopology_GetNeighborRank, METH_VARARGS, "GroupTopology_GetNeighborRank(GroupTopology self, int i) -> int"}, - { "GroupTopology_IAmMaster", _wrap_GroupTopology_IAmMaster, METH_VARARGS, "GroupTopology_IAmMaster(GroupTopology self, int g) -> bool"}, - { "GroupTopology_GetGroupMaster", _wrap_GroupTopology_GetGroupMaster, METH_VARARGS, "GroupTopology_GetGroupMaster(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroupMasterRank", _wrap_GroupTopology_GetGroupMasterRank, METH_VARARGS, "GroupTopology_GetGroupMasterRank(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroupMasterGroup", _wrap_GroupTopology_GetGroupMasterGroup, METH_VARARGS, "GroupTopology_GetGroupMasterGroup(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroupSize", _wrap_GroupTopology_GetGroupSize, METH_VARARGS, "GroupTopology_GetGroupSize(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroup", _wrap_GroupTopology_GetGroup, METH_VARARGS, "GroupTopology_GetGroup(GroupTopology self, int g) -> int const *"}, - { "GroupTopology_Load", _wrap_GroupTopology_Load, METH_VARARGS, "GroupTopology_Load(GroupTopology self, std::istream & _in)"}, - { "GroupTopology_Copy", _wrap_GroupTopology_Copy, METH_VARARGS, "GroupTopology_Copy(GroupTopology self, GroupTopology copy)"}, + { "GroupTopology_GetNeighborRank", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetNeighborRank, METH_VARARGS|METH_KEYWORDS, "GroupTopology_GetNeighborRank(GroupTopology self, int i) -> int"}, + { "GroupTopology_IAmMaster", (PyCFunction)(void(*)(void))_wrap_GroupTopology_IAmMaster, METH_VARARGS|METH_KEYWORDS, "GroupTopology_IAmMaster(GroupTopology self, int g) -> bool"}, + { "GroupTopology_GetGroupMaster", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupMaster, METH_VARARGS|METH_KEYWORDS, "GroupTopology_GetGroupMaster(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupMasterRank", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupMasterRank, METH_VARARGS|METH_KEYWORDS, "GroupTopology_GetGroupMasterRank(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupMasterGroup", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupMasterGroup, METH_VARARGS|METH_KEYWORDS, "GroupTopology_GetGroupMasterGroup(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupSize", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupSize, METH_VARARGS|METH_KEYWORDS, "GroupTopology_GetGroupSize(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroup", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroup, METH_VARARGS|METH_KEYWORDS, "GroupTopology_GetGroup(GroupTopology self, int g) -> int const *"}, + { "GroupTopology_Load", (PyCFunction)(void(*)(void))_wrap_GroupTopology_Load, METH_VARARGS|METH_KEYWORDS, "GroupTopology_Load(GroupTopology self, std::istream & _in)"}, + { "GroupTopology_Copy", (PyCFunction)(void(*)(void))_wrap_GroupTopology_Copy, METH_VARARGS|METH_KEYWORDS, "GroupTopology_Copy(GroupTopology self, GroupTopology copy)"}, { "delete_GroupTopology", _wrap_delete_GroupTopology, METH_O, "delete_GroupTopology(GroupTopology self)"}, { "GroupTopology_Save", _wrap_GroupTopology_Save, METH_VARARGS, "\n" "GroupTopology_Save(GroupTopology self, std::ostream & out)\n" @@ -5535,20 +5375,20 @@ static PyMethodDef SwigMethods[] = { ""}, { "GroupTopology_swigregister", GroupTopology_swigregister, METH_O, NULL}, { "GroupTopology_swiginit", GroupTopology_swiginit, METH_VARARGS, NULL}, - { "new_GroupCommunicator", _wrap_new_GroupCommunicator, METH_VARARGS, "GroupCommunicator(GroupTopology gt, mfem::GroupCommunicator::Mode m=byNeighbor)"}, - { "GroupCommunicator_Create", _wrap_GroupCommunicator_Create, METH_VARARGS, "GroupCommunicator_Create(GroupCommunicator self, intArray ldof_group)"}, + { "new_GroupCommunicator", (PyCFunction)(void(*)(void))_wrap_new_GroupCommunicator, METH_VARARGS|METH_KEYWORDS, "new_GroupCommunicator(GroupTopology gt, mfem::GroupCommunicator::Mode m=byNeighbor) -> GroupCommunicator"}, + { "GroupCommunicator_Create", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_Create, METH_VARARGS|METH_KEYWORDS, "GroupCommunicator_Create(GroupCommunicator self, intArray ldof_group)"}, { "GroupCommunicator_GroupLDofTable", _wrap_GroupCommunicator_GroupLDofTable, METH_VARARGS, "\n" "GroupCommunicator_GroupLDofTable(GroupCommunicator self) -> Table\n" "GroupCommunicator_GroupLDofTable(GroupCommunicator self) -> Table\n" ""}, { "GroupCommunicator_Finalize", _wrap_GroupCommunicator_Finalize, METH_O, "GroupCommunicator_Finalize(GroupCommunicator self)"}, - { "GroupCommunicator_SetLTDofTable", _wrap_GroupCommunicator_SetLTDofTable, METH_VARARGS, "GroupCommunicator_SetLTDofTable(GroupCommunicator self, intArray ldof_ltdof)"}, + { "GroupCommunicator_SetLTDofTable", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_SetLTDofTable, METH_VARARGS|METH_KEYWORDS, "GroupCommunicator_SetLTDofTable(GroupCommunicator self, intArray ldof_ltdof)"}, { "GroupCommunicator_GetGroupTopology", _wrap_GroupCommunicator_GetGroupTopology, METH_VARARGS, "\n" "GroupCommunicator_GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" "GroupCommunicator_GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" ""}, - { "GroupCommunicator_GetNeighborLTDofTable", _wrap_GroupCommunicator_GetNeighborLTDofTable, METH_VARARGS, "GroupCommunicator_GetNeighborLTDofTable(GroupCommunicator self, Table nbr_ltdof)"}, - { "GroupCommunicator_GetNeighborLDofTable", _wrap_GroupCommunicator_GetNeighborLDofTable, METH_VARARGS, "GroupCommunicator_GetNeighborLDofTable(GroupCommunicator self, Table nbr_ldof)"}, + { "GroupCommunicator_GetNeighborLTDofTable", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_GetNeighborLTDofTable, METH_VARARGS|METH_KEYWORDS, "GroupCommunicator_GetNeighborLTDofTable(GroupCommunicator self, Table nbr_ltdof)"}, + { "GroupCommunicator_GetNeighborLDofTable", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_GetNeighborLDofTable, METH_VARARGS|METH_KEYWORDS, "GroupCommunicator_GetNeighborLDofTable(GroupCommunicator self, Table nbr_ldof)"}, { "delete_GroupCommunicator", _wrap_delete_GroupCommunicator, METH_O, "delete_GroupCommunicator(GroupCommunicator self)"}, { "GroupCommunicator_PrintInfo", _wrap_GroupCommunicator_PrintInfo, METH_VARARGS, "\n" "GroupCommunicator_PrintInfo(GroupCommunicator self, std::ostream & out=mfem::out)\n" @@ -5556,7 +5396,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "GroupCommunicator_swigregister", GroupCommunicator_swigregister, METH_O, NULL}, { "GroupCommunicator_swiginit", GroupCommunicator_swiginit, METH_VARARGS, NULL}, - { "ReorderRanksZCurve", _wrap_ReorderRanksZCurve, METH_O, "ReorderRanksZCurve(MPI_Comm comm) -> MPI_Comm"}, + { "ReorderRanksZCurve", (PyCFunction)(void(*)(void))_wrap_ReorderRanksZCurve, METH_VARARGS|METH_KEYWORDS, "ReorderRanksZCurve(MPI_Comm comm) -> MPI_Comm"}, { NULL, NULL, 0, NULL } }; @@ -5578,22 +5418,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GroupTopology(MPI_Comm comm)\n" "new_GroupTopology(GroupTopology gt) -> GroupTopology\n" ""}, - { "GroupTopology_SetComm", _wrap_GroupTopology_SetComm, METH_VARARGS, "SetComm(GroupTopology self, MPI_Comm comm)"}, + { "GroupTopology_SetComm", (PyCFunction)(void(*)(void))_wrap_GroupTopology_SetComm, METH_VARARGS|METH_KEYWORDS, "SetComm(GroupTopology self, MPI_Comm comm)"}, { "GroupTopology_GetComm", _wrap_GroupTopology_GetComm, METH_O, "GetComm(GroupTopology self) -> MPI_Comm"}, { "GroupTopology_MyRank", _wrap_GroupTopology_MyRank, METH_O, "MyRank(GroupTopology self) -> int"}, { "GroupTopology_NRanks", _wrap_GroupTopology_NRanks, METH_O, "NRanks(GroupTopology self) -> int"}, - { "GroupTopology_Create", _wrap_GroupTopology_Create, METH_VARARGS, "Create(GroupTopology self, ListOfIntegerSets groups, int mpitag)"}, + { "GroupTopology_Create", (PyCFunction)(void(*)(void))_wrap_GroupTopology_Create, METH_VARARGS|METH_KEYWORDS, "Create(GroupTopology self, ListOfIntegerSets groups, int mpitag)"}, { "GroupTopology_NGroups", _wrap_GroupTopology_NGroups, METH_O, "NGroups(GroupTopology self) -> int"}, { "GroupTopology_GetNumNeighbors", _wrap_GroupTopology_GetNumNeighbors, METH_O, "GetNumNeighbors(GroupTopology self) -> int"}, - { "GroupTopology_GetNeighborRank", _wrap_GroupTopology_GetNeighborRank, METH_VARARGS, "GetNeighborRank(GroupTopology self, int i) -> int"}, - { "GroupTopology_IAmMaster", _wrap_GroupTopology_IAmMaster, METH_VARARGS, "IAmMaster(GroupTopology self, int g) -> bool"}, - { "GroupTopology_GetGroupMaster", _wrap_GroupTopology_GetGroupMaster, METH_VARARGS, "GetGroupMaster(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroupMasterRank", _wrap_GroupTopology_GetGroupMasterRank, METH_VARARGS, "GetGroupMasterRank(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroupMasterGroup", _wrap_GroupTopology_GetGroupMasterGroup, METH_VARARGS, "GetGroupMasterGroup(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroupSize", _wrap_GroupTopology_GetGroupSize, METH_VARARGS, "GetGroupSize(GroupTopology self, int g) -> int"}, - { "GroupTopology_GetGroup", _wrap_GroupTopology_GetGroup, METH_VARARGS, "GetGroup(GroupTopology self, int g) -> int const *"}, - { "GroupTopology_Load", _wrap_GroupTopology_Load, METH_VARARGS, "Load(GroupTopology self, std::istream & _in)"}, - { "GroupTopology_Copy", _wrap_GroupTopology_Copy, METH_VARARGS, "Copy(GroupTopology self, GroupTopology copy)"}, + { "GroupTopology_GetNeighborRank", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetNeighborRank, METH_VARARGS|METH_KEYWORDS, "GetNeighborRank(GroupTopology self, int i) -> int"}, + { "GroupTopology_IAmMaster", (PyCFunction)(void(*)(void))_wrap_GroupTopology_IAmMaster, METH_VARARGS|METH_KEYWORDS, "IAmMaster(GroupTopology self, int g) -> bool"}, + { "GroupTopology_GetGroupMaster", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupMaster, METH_VARARGS|METH_KEYWORDS, "GetGroupMaster(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupMasterRank", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupMasterRank, METH_VARARGS|METH_KEYWORDS, "GetGroupMasterRank(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupMasterGroup", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupMasterGroup, METH_VARARGS|METH_KEYWORDS, "GetGroupMasterGroup(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroupSize", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroupSize, METH_VARARGS|METH_KEYWORDS, "GetGroupSize(GroupTopology self, int g) -> int"}, + { "GroupTopology_GetGroup", (PyCFunction)(void(*)(void))_wrap_GroupTopology_GetGroup, METH_VARARGS|METH_KEYWORDS, "GetGroup(GroupTopology self, int g) -> int const *"}, + { "GroupTopology_Load", (PyCFunction)(void(*)(void))_wrap_GroupTopology_Load, METH_VARARGS|METH_KEYWORDS, "Load(GroupTopology self, std::istream & _in)"}, + { "GroupTopology_Copy", (PyCFunction)(void(*)(void))_wrap_GroupTopology_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(GroupTopology self, GroupTopology copy)"}, { "delete_GroupTopology", _wrap_delete_GroupTopology, METH_O, "delete_GroupTopology(GroupTopology self)"}, { "GroupTopology_Save", _wrap_GroupTopology_Save, METH_VARARGS, "\n" "Save(GroupTopology self, std::ostream & out)\n" @@ -5601,20 +5441,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "GroupTopology_swigregister", GroupTopology_swigregister, METH_O, NULL}, { "GroupTopology_swiginit", GroupTopology_swiginit, METH_VARARGS, NULL}, - { "new_GroupCommunicator", _wrap_new_GroupCommunicator, METH_VARARGS, "GroupCommunicator(GroupTopology gt, mfem::GroupCommunicator::Mode m=byNeighbor)"}, - { "GroupCommunicator_Create", _wrap_GroupCommunicator_Create, METH_VARARGS, "Create(GroupCommunicator self, intArray ldof_group)"}, + { "new_GroupCommunicator", (PyCFunction)(void(*)(void))_wrap_new_GroupCommunicator, METH_VARARGS|METH_KEYWORDS, "new_GroupCommunicator(GroupTopology gt, mfem::GroupCommunicator::Mode m=byNeighbor) -> GroupCommunicator"}, + { "GroupCommunicator_Create", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_Create, METH_VARARGS|METH_KEYWORDS, "Create(GroupCommunicator self, intArray ldof_group)"}, { "GroupCommunicator_GroupLDofTable", _wrap_GroupCommunicator_GroupLDofTable, METH_VARARGS, "\n" "GroupLDofTable(GroupCommunicator self) -> Table\n" "GroupLDofTable(GroupCommunicator self) -> Table\n" ""}, { "GroupCommunicator_Finalize", _wrap_GroupCommunicator_Finalize, METH_O, "Finalize(GroupCommunicator self)"}, - { "GroupCommunicator_SetLTDofTable", _wrap_GroupCommunicator_SetLTDofTable, METH_VARARGS, "SetLTDofTable(GroupCommunicator self, intArray ldof_ltdof)"}, + { "GroupCommunicator_SetLTDofTable", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_SetLTDofTable, METH_VARARGS|METH_KEYWORDS, "SetLTDofTable(GroupCommunicator self, intArray ldof_ltdof)"}, { "GroupCommunicator_GetGroupTopology", _wrap_GroupCommunicator_GetGroupTopology, METH_VARARGS, "\n" "GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" "GetGroupTopology(GroupCommunicator self) -> GroupTopology\n" ""}, - { "GroupCommunicator_GetNeighborLTDofTable", _wrap_GroupCommunicator_GetNeighborLTDofTable, METH_VARARGS, "GetNeighborLTDofTable(GroupCommunicator self, Table nbr_ltdof)"}, - { "GroupCommunicator_GetNeighborLDofTable", _wrap_GroupCommunicator_GetNeighborLDofTable, METH_VARARGS, "GetNeighborLDofTable(GroupCommunicator self, Table nbr_ldof)"}, + { "GroupCommunicator_GetNeighborLTDofTable", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_GetNeighborLTDofTable, METH_VARARGS|METH_KEYWORDS, "GetNeighborLTDofTable(GroupCommunicator self, Table nbr_ltdof)"}, + { "GroupCommunicator_GetNeighborLDofTable", (PyCFunction)(void(*)(void))_wrap_GroupCommunicator_GetNeighborLDofTable, METH_VARARGS|METH_KEYWORDS, "GetNeighborLDofTable(GroupCommunicator self, Table nbr_ldof)"}, { "delete_GroupCommunicator", _wrap_delete_GroupCommunicator, METH_O, "delete_GroupCommunicator(GroupCommunicator self)"}, { "GroupCommunicator_PrintInfo", _wrap_GroupCommunicator_PrintInfo, METH_VARARGS, "\n" "PrintInfo(GroupCommunicator self, std::ostream & out=mfem::out)\n" @@ -5622,7 +5462,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "GroupCommunicator_swigregister", GroupCommunicator_swigregister, METH_O, NULL}, { "GroupCommunicator_swiginit", GroupCommunicator_swiginit, METH_VARARGS, NULL}, - { "ReorderRanksZCurve", _wrap_ReorderRanksZCurve, METH_O, "ReorderRanksZCurve(MPI_Comm comm) -> MPI_Comm"}, + { "ReorderRanksZCurve", (PyCFunction)(void(*)(void))_wrap_ReorderRanksZCurve, METH_VARARGS|METH_KEYWORDS, "ReorderRanksZCurve(MPI_Comm comm) -> MPI_Comm"}, { NULL, NULL, 0, NULL } }; @@ -6427,10 +6267,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); import_array(); diff --git a/mfem/_par/complex_operator.py b/mfem/_par/complex_operator.py index 0ce08304..ecb014b0 100644 --- a/mfem/_par/complex_operator.py +++ b/mfem/_par/complex_operator.py @@ -148,9 +148,9 @@ class ComplexSparseMatrix(ComplexOperator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ComplexSparseMatrix self, SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix""" - _complex_operator.ComplexSparseMatrix_swiginit(self, _complex_operator.new_ComplexSparseMatrix(*args)) + _complex_operator.ComplexSparseMatrix_swiginit(self, _complex_operator.new_ComplexSparseMatrix(*args, **kwargs)) def real(self, *args): r""" diff --git a/mfem/_par/complex_operator_wrap.cxx b/mfem/_par/complex_operator_wrap.cxx index 41a6c784..63970091 100644 --- a/mfem/_par/complex_operator_wrap.cxx +++ b/mfem/_par/complex_operator_wrap.cxx @@ -3352,7 +3352,7 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) return SWIG_OK; } -SWIGINTERN mfem::ComplexOperator *new_mfem_ComplexOperator__SWIG_0(mfem::Operator *Op_Real,mfem::Operator *Op_Imag,bool ownReal=false,bool ownImag=false,bool hermitan=true){ +SWIGINTERN mfem::ComplexOperator *new_mfem_ComplexOperator(mfem::Operator *Op_Real,mfem::Operator *Op_Imag,bool ownReal=false,bool ownImag=false,bool hermitan=true){ if (hermitan){ return new mfem::ComplexOperator(Op_Real, Op_Imag, ownReal, ownImag, mfem::ComplexOperator::HERMITIAN); @@ -3706,7 +3706,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_imag(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3717,15 +3717,20 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ComplexOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ComplexOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_Mult" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); } arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComplexOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3733,7 +3738,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComplexOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComplexOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3761,7 +3766,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3772,15 +3777,20 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ComplexOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ComplexOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_MultTranspose" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); } arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComplexOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3788,7 +3798,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComplexOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComplexOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3851,13 +3861,13 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_GetType(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ComplexOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; - bool arg3 ; - bool arg4 ; - bool arg5 ; + bool arg3 = (bool) false ; + bool arg4 = (bool) false ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3868,184 +3878,51 @@ SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_0(PyObject *SWIGUNUSEDPARM( int ecode4 = 0 ; bool val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"Op_Real", (char *)"Op_Imag", (char *)"ownReal", (char *)"ownImag", (char *)"hermitan", NULL + }; mfem::ComplexOperator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexOperator" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - bool arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::ComplexOperator *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - mfem::ComplexOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:new_ComplexOperator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ComplexOperator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexOperator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexOperator" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2); + result = (mfem::ComplexOperator *)new_mfem_ComplexOperator(arg1,arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4063,118 +3940,6 @@ SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_3(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_ComplexOperator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComplexOperator", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ComplexOperator__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexOperator__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexOperator__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexOperator__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComplexOperator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *,bool,bool,bool)\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *,bool,bool)\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *,bool)\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *)\n"); - return 0; -} - - SWIGINTERN PyObject *ComplexOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -4186,13 +3951,13 @@ SWIGINTERN PyObject *ComplexOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = (mfem::SparseMatrix *) 0 ; bool arg3 ; bool arg4 ; - mfem::ComplexOperator::Convention arg5 ; + mfem::ComplexOperator::Convention arg5 = (mfem::ComplexOperator::Convention) mfem::ComplexOperator::HERMITIAN ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4203,94 +3968,47 @@ SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_0(PyObject *SWIGUNUSEDP int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"A_Real", (char *)"A_Imag", (char *)"ownReal", (char *)"ownImag", (char *)"convention", NULL + }; mfem::ComplexSparseMatrix *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:new_ComplexSparseMatrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexSparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexSparseMatrix" "', argument " "2"" of type '" "mfem::SparseMatrix *""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_bool(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexSparseMatrix" "', argument " "3"" of type '" "bool""'"); } arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexSparseMatrix" "', argument " "4"" of type '" "bool""'"); } arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexSparseMatrix" "', argument " "5"" of type '" "mfem::ComplexOperator::Convention""'"); - } - arg5 = static_cast< mfem::ComplexOperator::Convention >(val5); - { - try { - result = (mfem::ComplexSparseMatrix *)new mfem::ComplexSparseMatrix(arg1,arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexSparseMatrix, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::SparseMatrix *arg2 = (mfem::SparseMatrix *) 0 ; - bool arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::ComplexSparseMatrix *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexSparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexSparseMatrix" "', argument " "2"" of type '" "mfem::SparseMatrix *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexSparseMatrix" "', argument " "5"" of type '" "mfem::ComplexOperator::Convention""'"); + } + arg5 = static_cast< mfem::ComplexOperator::Convention >(val5); } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexSparseMatrix" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexSparseMatrix" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - result = (mfem::ComplexSparseMatrix *)new mfem::ComplexSparseMatrix(arg1,arg2,arg3,arg4); + result = (mfem::ComplexSparseMatrix *)new mfem::ComplexSparseMatrix(arg1,arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4308,82 +4026,6 @@ SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComplexSparseMatrix", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexSparseMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexSparseMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComplexSparseMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ComplexSparseMatrix::ComplexSparseMatrix(mfem::SparseMatrix *,mfem::SparseMatrix *,bool,bool,mfem::ComplexOperator::Convention)\n" - " mfem::ComplexSparseMatrix::ComplexSparseMatrix(mfem::SparseMatrix *,mfem::SparseMatrix *,bool,bool)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; @@ -4717,13 +4359,13 @@ static PyMethodDef SwigMethods[] = { "ComplexOperator_imag(ComplexOperator self) -> Operator\n" "ComplexOperator_imag(ComplexOperator self) -> Operator\n" ""}, - { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "ComplexOperator_Mult(ComplexOperator self, Vector x, Vector y)"}, - { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "ComplexOperator_MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ComplexOperator_Mult(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ComplexOperator_MultTranspose(ComplexOperator self, Vector x, Vector y)"}, { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "ComplexOperator_GetType(ComplexOperator self) -> mfem::Operator::Type"}, - { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, + { "new_ComplexOperator", (PyCFunction)(void(*)(void))_wrap_new_ComplexOperator, METH_VARARGS|METH_KEYWORDS, "new_ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True) -> ComplexOperator"}, { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, - { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "new_ComplexSparseMatrix", (PyCFunction)(void(*)(void))_wrap_new_ComplexSparseMatrix, METH_VARARGS|METH_KEYWORDS, "new_ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix"}, { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" @@ -4754,13 +4396,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "imag(ComplexOperator self) -> Operator\n" "imag(ComplexOperator self) -> Operator\n" ""}, - { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "Mult(ComplexOperator self, Vector x, Vector y)"}, - { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ComplexOperator self, Vector x, Vector y)"}, { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "GetType(ComplexOperator self) -> mfem::Operator::Type"}, - { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, + { "new_ComplexOperator", (PyCFunction)(void(*)(void))_wrap_new_ComplexOperator, METH_VARARGS|METH_KEYWORDS, "new_ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True) -> ComplexOperator"}, { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, - { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "new_ComplexSparseMatrix", (PyCFunction)(void(*)(void))_wrap_new_ComplexSparseMatrix, METH_VARARGS|METH_KEYWORDS, "new_ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix"}, { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" "real(ComplexSparseMatrix self) -> SparseMatrix\n" "real(ComplexSparseMatrix self) -> SparseMatrix\n" diff --git a/mfem/_par/config_wrap.cxx b/mfem/_par/config_wrap.cxx index 481b34ed..f44413fd 100644 --- a/mfem/_par/config_wrap.cxx +++ b/mfem/_par/config_wrap.cxx @@ -3582,11 +3582,11 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); SWIG_Python_SetConstant(d, "MFEM_GIT_STRING",SWIG_FromCharPtr("tags/v4.1-0-g8dbbcfc25629ac7612fe31afd5b511752ff0e69b")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); #if PY_VERSION_HEX >= 0x03000000 return m; #else diff --git a/mfem/_par/cpointers_wrap.cxx b/mfem/_par/cpointers_wrap.cxx index b6b48895..0d4a3623 100644 --- a/mfem/_par/cpointers_wrap.cxx +++ b/mfem/_par/cpointers_wrap.cxx @@ -3007,7 +3007,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -3015,15 +3015,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -3082,17 +3086,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -3151,7 +3157,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -3159,15 +3165,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -3226,17 +3236,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -3265,18 +3277,18 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -3287,18 +3299,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } diff --git a/mfem/_par/densemat.py b/mfem/_par/densemat.py index 6088db53..3aeecc7c 100644 --- a/mfem/_par/densemat.py +++ b/mfem/_par/densemat.py @@ -538,7 +538,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_densemat.DenseMatrix_MemoryUsage) def Read(self, on_dev=True): - r"""Read(DenseMatrix self, bool on_dev=True) -> double const""" + r"""Read(DenseMatrix self, bool on_dev=True) -> double const *""" return _densemat.DenseMatrix_Read(self, on_dev) Read = _swig_new_instance_method(_densemat.DenseMatrix_Read) @@ -548,7 +548,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_densemat.DenseMatrix_HostRead) def Write(self, on_dev=True): - r"""Write(DenseMatrix self, bool on_dev=True) -> double""" + r"""Write(DenseMatrix self, bool on_dev=True) -> double *""" return _densemat.DenseMatrix_Write(self, on_dev) Write = _swig_new_instance_method(_densemat.DenseMatrix_Write) @@ -558,7 +558,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(DenseMatrix self, bool on_dev=True) -> double""" + r"""ReadWrite(DenseMatrix self, bool on_dev=True) -> double *""" return _densemat.DenseMatrix_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_ReadWrite) @@ -1077,7 +1077,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_densemat.DenseTensor_MemoryUsage) def Read(self, on_dev=True): - r"""Read(DenseTensor self, bool on_dev=True) -> double const""" + r"""Read(DenseTensor self, bool on_dev=True) -> double const *""" return _densemat.DenseTensor_Read(self, on_dev) Read = _swig_new_instance_method(_densemat.DenseTensor_Read) @@ -1087,7 +1087,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_densemat.DenseTensor_HostRead) def Write(self, on_dev=True): - r"""Write(DenseTensor self, bool on_dev=True) -> double""" + r"""Write(DenseTensor self, bool on_dev=True) -> double *""" return _densemat.DenseTensor_Write(self, on_dev) Write = _swig_new_instance_method(_densemat.DenseTensor_Write) @@ -1097,7 +1097,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_densemat.DenseTensor_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(DenseTensor self, bool on_dev=True) -> double""" + r"""ReadWrite(DenseTensor self, bool on_dev=True) -> double *""" return _densemat.DenseTensor_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_densemat.DenseTensor_ReadWrite) diff --git a/mfem/_par/densemat_wrap.cxx b/mfem/_par/densemat_wrap.cxx index 9d85a596..ff0f9beb 100644 --- a/mfem/_par/densemat_wrap.cxx +++ b/mfem/_par/densemat_wrap.cxx @@ -3590,7 +3590,7 @@ SWIGINTERN PyObject *mfem_DenseMatrix_GetDataArray(mfem::DenseMatrix const *self -SWIGINTERN void mfem_DenseMatrix_Print__SWIG_3(mfem::DenseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_DenseMatrix_Print__SWIG_1(mfem::DenseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3601,7 +3601,7 @@ SWIGINTERN void mfem_DenseMatrix_Print__SWIG_3(mfem::DenseMatrix *self,char cons self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_DenseMatrix_PrintT__SWIG_3(mfem::DenseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_DenseMatrix_PrintT__SWIG_1(mfem::DenseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3612,7 +3612,7 @@ SWIGINTERN void mfem_DenseMatrix_PrintT__SWIG_3(mfem::DenseMatrix *self,char con self -> PrintT(ofile); ofile.close(); } -SWIGINTERN void mfem_DenseMatrix_PrintMatlab__SWIG_2(mfem::DenseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_DenseMatrix_PrintMatlab__SWIG_1(mfem::DenseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3992,7 +3992,7 @@ SWIGINTERN PyObject *_wrap_new_DenseMatrix(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -4002,30 +4002,36 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"h", (char *)"w", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_UseExternalData", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_UseExternalData", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_UseExternalData" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_UseExternalData" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -4047,7 +4053,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DenseMatrix_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -4057,30 +4063,36 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Reset(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"h", (char *)"w", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Reset", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_Reset", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Reset" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Reset" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -4733,7 +4745,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___call__(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -4741,16 +4753,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___mul__(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___mul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix___mul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___mul__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix___mul__" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5299,7 +5315,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_MultTranspose(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5310,15 +5326,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_AddMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMult" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5326,7 +5347,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5354,7 +5375,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5365,15 +5386,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5381,7 +5407,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5409,7 +5435,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -5423,20 +5449,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMult_a", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_AddMult_a", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMult_a" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_AddMult_a" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMult_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -5444,7 +5476,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMult_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseMatrix_AddMult_a" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5472,7 +5504,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -5486,20 +5518,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMultTranspose_a", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_AddMultTranspose_a", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -5507,7 +5545,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5584,7 +5622,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InnerProduct__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5592,15 +5630,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_LeftScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_LeftScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_LeftScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_LeftScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5628,7 +5670,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5636,15 +5678,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_InvLeftScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_InvLeftScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_InvLeftScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_InvLeftScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5672,7 +5718,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5680,15 +5726,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_RightScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_RightScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_RightScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_RightScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5716,7 +5766,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5724,15 +5774,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_InvRightScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_InvRightScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_InvRightScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_InvRightScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5760,7 +5814,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5768,15 +5822,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_SymmetricScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_SymmetricScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SymmetricScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_SymmetricScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5804,7 +5862,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DenseMatrix_InvSymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_InvSymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5812,15 +5870,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvSymmetricScaling(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_InvSymmetricScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_InvSymmetricScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_InvSymmetricScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_InvSymmetricScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6286,7 +6348,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Set(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -6297,20 +6359,25 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Add", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_Add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Add" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Add" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_Add" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6468,7 +6535,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___iadd__(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -6476,16 +6543,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___isub__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix___isub__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___isub__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix___isub__" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6513,7 +6584,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -6521,16 +6592,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___imul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix___imul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___imul__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix___imul__" "', argument " "2"" of type '" "double""'"); } @@ -6589,7 +6664,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Neg(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_DenseMatrix_Norm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Norm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -6597,15 +6672,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Norm2(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Norm2", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Norm2", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Norm2" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Norm2" "', argument " "2"" of type '" "double *""'"); } @@ -7227,7 +7306,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Eigensystem(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7235,15 +7314,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_SingularValues", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_SingularValues", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SingularValues" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_SingularValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7271,7 +7354,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -7279,16 +7362,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Rank", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Rank", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Rank" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Rank" "', argument " "2"" of type '" "double""'"); } @@ -7313,26 +7400,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_DenseMatrix_CalcSingularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CalcSingularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CalcSingularvalue", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_CalcSingularvalue", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CalcSingularvalue" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7354,7 +7445,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CalcSingularvalue(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -7365,20 +7456,25 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_lambda", (char *)"vec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CalcEigenvalues", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_CalcEigenvalues", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CalcEigenvalues" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CalcEigenvalues" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_CalcEigenvalues" "', argument " "3"" of type '" "double *""'"); } @@ -7403,7 +7499,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -7412,21 +7508,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"row", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetRow", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_GetRow", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetRow" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7665,7 +7766,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumn(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -7674,21 +7775,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", (char *)"col", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetColumnReference", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_GetColumnReference", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetColumnReference" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_GetColumnReference" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8186,7 +8292,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8194,15 +8300,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetDiag", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GetDiag", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetDiag" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GetDiag" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8230,7 +8340,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8238,15 +8348,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"l", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Getl1Diag", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Getl1Diag", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Getl1Diag" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Getl1Diag" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8274,7 +8388,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8282,15 +8396,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"l", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetRowSums", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GetRowSums", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetRowSums" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GetRowSums" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8662,7 +8780,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Lump(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -8670,15 +8788,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GradToCurl", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GradToCurl", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GradToCurl" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GradToCurl" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -8706,7 +8828,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8714,15 +8836,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"div", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GradToDiv", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GradToDiv", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GradToDiv" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GradToDiv" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8750,7 +8876,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -8760,15 +8886,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"row1", (char *)"row2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyRows", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyRows", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyRows" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyRows" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -8777,16 +8909,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -8808,7 +8940,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -8818,15 +8950,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"col1", (char *)"col2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyCols", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyCols", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyCols" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyCols" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -8835,16 +8973,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -8994,7 +9132,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMN__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -9004,15 +9142,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"row_offset", (char *)"col_offset", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyMNt", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyMNt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyMNt" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyMNt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -9021,16 +9165,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), P } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -9544,7 +9688,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNDiag(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -9554,15 +9698,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"m", (char *)"n", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyExceptMN", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyExceptMN", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyExceptMN" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyExceptMN" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -9571,16 +9721,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -9815,7 +9965,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMatrix(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -9824,21 +9974,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddToVector", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_AddToVector", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddToVector" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddToVector" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9866,7 +10021,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -9875,21 +10030,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetFromVector", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_GetFromVector", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetFromVector" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_GetFromVector" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9917,7 +10077,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9925,15 +10085,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AdjustDofDirection", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_AdjustDofDirection", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AdjustDofDirection" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_AdjustDofDirection" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -9961,7 +10125,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_DenseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -9969,15 +10133,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"eps", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Threshold", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Threshold", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Threshold" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Threshold" "', argument " "2"" of type '" "double""'"); } @@ -10040,39 +10208,44 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CheckFinite(PyObject *SWIGUNUSEDPARM(self SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -10104,39 +10277,42 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { try { - ((mfem::DenseMatrix const *)arg1)->Print(*arg2); + ((mfem::DenseMatrix const *)arg1)->PrintMatlab(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10164,71 +10340,51 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - ((mfem::DenseMatrix const *)arg1)->Print(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } { try { - ((mfem::DenseMatrix const *)arg1)->PrintMatlab(*arg2); + ((mfem::DenseMatrix const *)arg1)->PrintT(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10256,214 +10412,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_TestInversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_TestInversion" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { try { - ((mfem::DenseMatrix const *)arg1)->PrintMatlab(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::DenseMatrix const *)arg1)->PrintT(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::DenseMatrix const *)arg1)->PrintT(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - ((mfem::DenseMatrix const *)arg1)->PrintT(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_TestInversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_TestInversion" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - (arg1)->TestInversion(); + (arg1)->TestInversion(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10516,274 +10481,55 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::DenseMatrix const *)arg1)->Read(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - result = (double *)((mfem::DenseMatrix const *)arg1)->Read(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseMatrix_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::Read(bool) const\n" - " mfem::DenseMatrix::Read() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostRead" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - result = (double *)((mfem::DenseMatrix const *)arg1)->HostRead(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseMatrix_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - result = (double *)(arg1)->Write(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseMatrix_Write__SWIG_0(self, argc, argv); - } + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } + { + try { + result = (double *)((mfem::DenseMatrix const *)arg1)->Read(arg2); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::Write(bool)\n" - " mfem::DenseMatrix::Write()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; void *argp1 = 0 ; @@ -10795,12 +10541,12 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostRead" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { try { - result = (double *)(arg1)->HostWrite(); + result = (double *)((mfem::DenseMatrix const *)arg1)->HostRead(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10818,30 +10564,37 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseMatrix_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->ReadWrite(arg2); + result = (double *)(arg1)->Write(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10859,22 +10612,24 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->HostWrite(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10892,45 +10647,51 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + bool arg2 = (bool) true ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL }; + double *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_ReadWrite__SWIG_1(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseMatrix_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseMatrix_ReadWrite__SWIG_0(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } + { + try { + result = (double *)(arg1)->ReadWrite(arg2); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::ReadWrite(bool)\n" - " mfem::DenseMatrix::ReadWrite()\n"); - return 0; + return NULL; } @@ -11179,33 +10940,38 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___getitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix___getitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___getitem__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11227,7 +10993,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -11237,27 +11003,33 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___setitem__", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix___setitem__", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___setitem__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DenseMatrix___setitem__" "', argument " "4"" of type '" "double""'"); } @@ -11317,18 +11089,18 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); @@ -11339,58 +11111,17 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_DenseMatrix_Print__SWIG_3(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_DenseMatrix_Print__SWIG_3(arg1,(char const *)arg2); + mfem_DenseMatrix_Print__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11418,34 +11149,15 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -11456,19 +11168,9 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11478,27 +11180,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_Print__SWIG_3(self, argc, argv); + return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11508,85 +11206,33 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); + return _wrap_DenseMatrix_Print__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Print'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::Print(std::ostream &,int) const\n" - " mfem::DenseMatrix::Print(std::ostream &) const\n" - " mfem::DenseMatrix::Print() const\n" - " mfem::DenseMatrix::Print(char const *,int)\n" - " mfem::DenseMatrix::Print(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintT" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_DenseMatrix_PrintT__SWIG_3(arg1,(char const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Print'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::DenseMatrix::Print(std::ostream &,int) const\n" + " mfem::DenseMatrix::Print(char const *,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); @@ -11597,9 +11243,17 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_4(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintT" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_DenseMatrix_PrintT__SWIG_3(arg1,(char const *)arg2); + mfem_DenseMatrix_PrintT__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11627,34 +11281,15 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_PrintT", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -11665,19 +11300,9 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11687,27 +11312,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_3(self, argc, argv); + return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_PrintT__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11717,7 +11338,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); + return _wrap_DenseMatrix_PrintT__SWIG_1(self, argc, argv); } } } @@ -11727,26 +11348,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintT'.\n" " Possible C/C++ prototypes are:\n" " mfem::DenseMatrix::PrintT(std::ostream &,int) const\n" - " mfem::DenseMatrix::PrintT(std::ostream &) const\n" - " mfem::DenseMatrix::PrintT() const\n" - " mfem::DenseMatrix::PrintT(char const *,int)\n" - " mfem::DenseMatrix::PrintT(char const *)\n"); + " mfem::DenseMatrix::PrintT(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); @@ -11757,58 +11375,17 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_DenseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_DenseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2); + mfem_DenseMatrix_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11836,34 +11413,15 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_DenseMatrix_PrintMatlab__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -11878,7 +11436,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); @@ -11887,6 +11445,9 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_PrintMatlab__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11896,7 +11457,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_DenseMatrix_PrintMatlab__SWIG_1(self, argc, argv); } } } @@ -11906,9 +11467,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::DenseMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::DenseMatrix::PrintMatlab() const\n" - " mfem::DenseMatrix::PrintMatlab(char const *,int)\n" - " mfem::DenseMatrix::PrintMatlab(char const *)\n"); + " mfem::DenseMatrix::PrintMatlab(char const *,int)\n"); return 0; } @@ -11924,21 +11483,27 @@ SWIGINTERN PyObject *DenseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_LinearSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; double *arg2 = (double *) 0 ; - double arg3 ; + double arg3 = (double) 1.e-9 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"X", (char *)"TOL", NULL + }; bool result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:LinearSolve", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); } @@ -11946,63 +11511,21 @@ SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearSolve" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)mfem::LinearSolve(*arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = 0 ; - double *arg2 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearSolve" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - arg2 = reinterpret_cast< double * >(argp2); { try { - result = (bool)mfem::LinearSolve(*arg1,arg2); + result = (bool)mfem::LinearSolve(*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12020,59 +11543,7 @@ SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_LinearSolve(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "LinearSolve", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_LinearSolve__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_LinearSolve__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearSolve'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::LinearSolve(mfem::DenseMatrix &,double *,double)\n" - " mfem::LinearSolve(mfem::DenseMatrix &,double *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12083,10 +11554,15 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"b", (char *)"c", (char *)"a", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMult" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12094,7 +11570,7 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12102,7 +11578,7 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12130,7 +11606,7 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12144,15 +11620,21 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"alpha", (char *)"b", (char *)"c", (char *)"a", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMult_a", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12160,7 +11642,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12168,7 +11650,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12196,7 +11678,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12204,10 +11686,14 @@ SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"adja", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcAdjugate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcAdjugate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcAdjugate" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12215,7 +11701,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcAdjugate" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcAdjugate" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12243,7 +11729,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12251,10 +11737,14 @@ SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"adjat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcAdjugateTranspose", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcAdjugateTranspose", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcAdjugateTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12262,7 +11752,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcAdjugateTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcAdjugateTranspose" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12290,7 +11780,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12298,10 +11788,14 @@ SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"inva", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcInverse", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcInverse", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcInverse" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12309,7 +11803,7 @@ SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcInverse" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcInverse" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12337,7 +11831,7 @@ SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12345,10 +11839,14 @@ SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"inva", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcInverseTranspose", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcInverseTranspose", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcInverseTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12356,7 +11854,7 @@ SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcInverseTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcInverseTranspose" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12384,7 +11882,7 @@ SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -12392,10 +11890,14 @@ SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"J", (char *)"n", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcOrtho", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcOrtho", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcOrtho" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12403,7 +11905,7 @@ SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcOrtho" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcOrtho" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -12431,7 +11933,7 @@ SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12439,10 +11941,14 @@ SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"aat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultAAt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MultAAt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultAAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12450,7 +11956,7 @@ SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultAAt" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12478,7 +11984,7 @@ SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -12489,10 +11995,15 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"ADAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultADAt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultADAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12500,7 +12011,7 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12508,7 +12019,7 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultADAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12536,7 +12047,7 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -12547,10 +12058,15 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"ADAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultADAt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMultADAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12558,7 +12074,7 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12566,7 +12082,7 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultADAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12594,7 +12110,7 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12605,10 +12121,15 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"ABt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultABt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultABt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12616,7 +12137,7 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12624,7 +12145,7 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultABt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12652,7 +12173,7 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -12666,10 +12187,16 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"B", (char *)"ADBt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultADBt", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MultADBt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12677,7 +12204,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12685,7 +12212,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12693,7 +12220,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MultADBt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12721,7 +12248,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12732,10 +12259,15 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"ABt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultABt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMultABt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12743,7 +12275,7 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12751,7 +12283,7 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultABt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12779,7 +12311,7 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -12793,10 +12325,16 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"B", (char *)"ADBt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultADBt", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMultADBt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12804,7 +12342,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12812,7 +12350,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12820,7 +12358,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMultADBt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12848,7 +12386,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12862,15 +12400,21 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"A", (char *)"B", (char *)"ABt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_ABt", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMult_a_ABt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_ABt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_ABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12878,7 +12422,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_ABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_ABt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12886,7 +12430,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_ABt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a_ABt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12914,7 +12458,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12925,10 +12469,15 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"AtB", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultAtB", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultAtB", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultAtB" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12936,7 +12485,7 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAtB" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultAtB" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12944,7 +12493,7 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAtB" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultAtB" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12972,7 +12521,7 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12983,15 +12532,20 @@ SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"A", (char *)"AAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_AAt", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMult_a_AAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_AAt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12999,7 +12553,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_AAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13027,7 +12581,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13038,15 +12592,20 @@ SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"A", (char *)"AAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mult_a_AAt", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mult_a_AAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Mult_a_AAt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13054,7 +12613,7 @@ SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult_a_AAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13082,7 +12641,7 @@ SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13090,10 +12649,14 @@ SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"vvt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultVVt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MultVVt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -13101,7 +12664,7 @@ SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultVVt" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13129,7 +12692,7 @@ SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -13140,10 +12703,15 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"w", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultVWt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultVWt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -13151,7 +12719,7 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13159,7 +12727,7 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultVWt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13187,7 +12755,7 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -13198,10 +12766,15 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"w", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultVWt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMultVWt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -13209,7 +12782,7 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13217,7 +12790,7 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultVWt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13245,7 +12818,7 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13253,10 +12826,14 @@ SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultVVt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:AddMultVVt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -13264,7 +12841,7 @@ SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultVVt" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13292,7 +12869,7 @@ SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::Vector *arg2 = 0 ; @@ -13306,15 +12883,21 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"v", (char *)"w", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_VWt", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMult_a_VWt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_VWt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_VWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13322,7 +12905,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_VWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_VWt" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -13330,7 +12913,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_VWt" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a_VWt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13358,7 +12941,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::Vector *arg2 = 0 ; @@ -13369,15 +12952,20 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"v", (char *)"VVt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_VVt", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMult_a_VVt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_VVt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_VVt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13385,7 +12973,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_VVt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_VVt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13618,34 +13206,42 @@ SWIGINTERN PyObject *_wrap_new_LUFactors(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; - double arg3 ; + double arg3 = (double) 0.0 ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"TOL", NULL + }; bool result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:LUFactors_Factor", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LUFactors_Factor" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LUFactors_Factor" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { result = (bool)(arg1)->Factor(arg2,arg3); @@ -13666,128 +13262,30 @@ SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); - } - arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (bool)(arg1)->Factor(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "LUFactors_Factor", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_LUFactors_Factor__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_LUFactors_Factor__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LUFactors_Factor'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::LUFactors::Factor(int,double)\n" - " mfem::LUFactors::Factor(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; double result; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Det", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LUFactors_Det", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Det" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -13809,7 +13307,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -13819,27 +13317,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Mult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_Mult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Mult" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_Mult" "', argument " "4"" of type '" "double *""'"); } @@ -13864,7 +13368,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -13874,27 +13378,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_LSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_LSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_LSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_LSolve" "', argument " "4"" of type '" "double *""'"); } @@ -13919,7 +13429,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -13929,27 +13439,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_USolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_USolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_USolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_USolve" "', argument " "4"" of type '" "double *""'"); } @@ -13974,7 +13490,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -13984,27 +13500,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Solve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_Solve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Solve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_Solve" "', argument " "4"" of type '" "double *""'"); } @@ -14029,7 +13551,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14039,27 +13561,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_RightSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_RightSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_RightSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_RightSolve" "', argument " "4"" of type '" "double *""'"); } @@ -14084,7 +13612,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14093,21 +13621,26 @@ SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_GetInverseMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LUFactors_GetInverseMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_GetInverseMatrix" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LUFactors_GetInverseMatrix" "', argument " "3"" of type '" "double *""'"); } @@ -14132,7 +13665,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -14146,38 +13679,46 @@ SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyO int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"m", (char *)"n", (char *)"r", (char *)"A21", (char *)"X1", (char *)"X2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_SubMult", 6, 6, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:LUFactors_SubMult", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_SubMult" "', argument " "4"" of type '" "double const *""'"); } arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_SubMult" "', argument " "5"" of type '" "double const *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_SubMult" "', argument " "6"" of type '" "double *""'"); } @@ -14202,7 +13743,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14218,37 +13759,45 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"A12", (char *)"A21", (char *)"A22", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_BlockFactor", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:LUFactors_BlockFactor", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_BlockFactor" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_BlockFactor" "', argument " "4"" of type '" "double *""'"); } arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_BlockFactor" "', argument " "5"" of type '" "double *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_BlockFactor" "', argument " "6"" of type '" "double *""'"); } @@ -14273,7 +13822,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14290,43 +13839,52 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(sel int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"r", (char *)"L21", (char *)"B1", (char *)"B2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_BlockForwSolve", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:LUFactors_BlockForwSolve", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_BlockForwSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_BlockForwSolve" "', argument " "5"" of type '" "double const *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_BlockForwSolve" "', argument " "6"" of type '" "double *""'"); } arg6 = reinterpret_cast< double * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_double, 0 | 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "LUFactors_BlockForwSolve" "', argument " "7"" of type '" "double *""'"); } @@ -14351,7 +13909,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_LUFactors_BlockBackSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_BlockBackSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14368,43 +13926,52 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockBackSolve(PyObject *SWIGUNUSEDPARM(sel int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"r", (char *)"U12", (char *)"X2", (char *)"Y1", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_BlockBackSolve", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:LUFactors_BlockBackSolve", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_BlockBackSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_BlockBackSolve" "', argument " "5"" of type '" "double const *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_BlockBackSolve" "', argument " "6"" of type '" "double const *""'"); } arg6 = reinterpret_cast< double * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_double, 0 | 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "LUFactors_BlockBackSolve" "', argument " "7"" of type '" "double *""'"); } @@ -14757,7 +14324,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_Factor(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_DenseMatrixInverse_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixInverse_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixInverse *arg1 = (mfem::DenseMatrixInverse *) 0 ; mfem::Operator *arg2 = 0 ; @@ -14765,15 +14332,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_SetOperator(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixInverse_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixInverse_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixInverse_SetOperator" "', argument " "1"" of type '" "mfem::DenseMatrixInverse *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixInverse * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrixInverse_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -15021,7 +14592,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_Mult(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_DenseMatrixInverse_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixInverse_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixInverse *arg1 = (mfem::DenseMatrixInverse *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -15029,15 +14600,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_GetInverseMatrix(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Ainv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixInverse_GetInverseMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixInverse_GetInverseMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixInverse_GetInverseMatrix" "', argument " "1"" of type '" "mfem::DenseMatrixInverse const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixInverse * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrixInverse_GetInverseMatrix" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -15390,26 +14965,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvectors(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixEigensystem *arg1 = (mfem::DenseMatrixEigensystem *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixEigensystem_Eigenvalue", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixEigensystem_Eigenvalue", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixEigensystem_Eigenvalue" "', argument " "1"" of type '" "mfem::DenseMatrixEigensystem *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixEigensystem * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -15431,26 +15010,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvalue(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixEigensystem *arg1 = (mfem::DenseMatrixEigensystem *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixEigensystem_Eigenvector", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixEigensystem_Eigenvector", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixEigensystem_Eigenvector" "', argument " "1"" of type '" "mfem::DenseMatrixEigensystem *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixEigensystem * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -15643,7 +15226,7 @@ SWIGINTERN PyObject *_wrap_new_DenseMatrixSVD(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixSVD *arg1 = (mfem::DenseMatrixSVD *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -15651,15 +15234,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Eval(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixSVD_Eval", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixSVD_Eval", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixSVD_Eval" "', argument " "1"" of type '" "mfem::DenseMatrixSVD *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixSVD * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrixSVD_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -15722,26 +15309,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Singularvalues(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Singularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Singularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixSVD *arg1 = (mfem::DenseMatrixSVD *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixSVD_Singularvalue", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixSVD_Singularvalue", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixSVD_Singularvalue" "', argument " "1"" of type '" "mfem::DenseMatrixSVD *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixSVD * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16119,7 +15710,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_TotalSize(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; int arg2 ; @@ -16127,31 +15718,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), P int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"k", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_SetSize", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseTensor_SetSize", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_SetSize" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -16173,7 +15770,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; double *arg2 = (double *) 0 ; @@ -16184,36 +15781,43 @@ SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ext_data", (char *)"i", (char *)"j", (char *)"k", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_UseExternalData", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DenseTensor_UseExternalData", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_UseExternalData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_UseExternalData" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { try { @@ -16559,26 +16163,30 @@ SWIGINTERN PyObject *_wrap_DenseTensor___call__(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"k", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_GetData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseTensor_GetData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16804,7 +16412,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; mfem::Table *arg2 = 0 ; @@ -16818,15 +16426,21 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"elem_dof", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_AddMult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseTensor_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_AddMult" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); } @@ -16834,7 +16448,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -16842,7 +16456,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -16939,63 +16553,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseTensor_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::DenseTensor const *)arg1)->Read(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)((mfem::DenseTensor const *)arg1)->Read(); + result = (double *)((mfem::DenseTensor const *)arg1)->Read(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17013,48 +16601,6 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseTensor_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseTensor_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseTensor_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::Read(bool) const\n" - " mfem::DenseTensor::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseTensor_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; @@ -17090,63 +16636,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_HostRead(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseTensor_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)(arg1)->Write(); + result = (double *)(arg1)->Write(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17164,48 +16684,6 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseTensor_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseTensor_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseTensor_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::Write(bool)\n" - " mfem::DenseTensor::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseTensor_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; @@ -17241,63 +16719,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_HostWrite(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseTensor_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->ReadWrite(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->ReadWrite(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -17315,48 +16767,6 @@ SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseTensor_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseTensor_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::ReadWrite(bool)\n" - " mfem::DenseTensor::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseTensor_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; @@ -17426,7 +16836,7 @@ SWIGINTERN PyObject *_wrap_delete_DenseTensor(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_DenseTensor_Assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_Assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; double arg2 ; @@ -17434,15 +16844,19 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Assign(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_Assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseTensor_Assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Assign" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Assign" "', argument " "2"" of type '" "double""'"); } @@ -17637,7 +17051,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor___getitem__(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_DenseTensor___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; int arg2 ; @@ -17648,33 +17062,40 @@ SWIGINTERN PyObject *_wrap_DenseTensor___setitem__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; double val5 ; int ecode5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"k", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor___setitem__", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DenseTensor___setitem__", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___setitem__" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_double(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DenseTensor___setitem__" "', argument " "5"" of type '" "double""'"); } @@ -17756,8 +17177,8 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix(DenseMatrix mat, char ch)\n" "new_DenseMatrix(double * d, int h, int w) -> DenseMatrix\n" ""}, - { "DenseMatrix_UseExternalData", _wrap_DenseMatrix_UseExternalData, METH_VARARGS, "DenseMatrix_UseExternalData(DenseMatrix self, double * d, int h, int w)"}, - { "DenseMatrix_Reset", _wrap_DenseMatrix_Reset, METH_VARARGS, "DenseMatrix_Reset(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_UseExternalData, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_UseExternalData(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_Reset", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Reset, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Reset(DenseMatrix self, double * d, int h, int w)"}, { "DenseMatrix_ClearExternalData", _wrap_DenseMatrix_ClearExternalData, METH_O, "DenseMatrix_ClearExternalData(DenseMatrix self)"}, { "DenseMatrix_Clear", _wrap_DenseMatrix_Clear, METH_O, "DenseMatrix_Clear(DenseMatrix self)"}, { "DenseMatrix_Size", _wrap_DenseMatrix_Size, METH_O, "DenseMatrix_Size(DenseMatrix self) -> int"}, @@ -17776,7 +17197,7 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix___call__(DenseMatrix self, int i, int j) -> double\n" "DenseMatrix___call__(DenseMatrix self, int i, int j) -> double const &\n" ""}, - { "DenseMatrix___mul__", _wrap_DenseMatrix___mul__, METH_VARARGS, "DenseMatrix___mul__(DenseMatrix self, DenseMatrix m) -> double"}, + { "DenseMatrix___mul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___mul__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___mul__(DenseMatrix self, DenseMatrix m) -> double"}, { "DenseMatrix_Trace", _wrap_DenseMatrix_Trace, METH_O, "DenseMatrix_Trace(DenseMatrix self) -> double"}, { "DenseMatrix_Elem", _wrap_DenseMatrix_Elem, METH_VARARGS, "\n" "DenseMatrix_Elem(DenseMatrix self, int i, int j) -> double\n" @@ -17790,16 +17211,16 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_MultTranspose(DenseMatrix self, double const * x, double * y)\n" "DenseMatrix_MultTranspose(DenseMatrix self, Vector x, Vector y)\n" ""}, - { "DenseMatrix_AddMult", _wrap_DenseMatrix_AddMult, METH_VARARGS, "DenseMatrix_AddMult(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose", _wrap_DenseMatrix_AddMultTranspose, METH_VARARGS, "DenseMatrix_AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMult_a", _wrap_DenseMatrix_AddMult_a, METH_VARARGS, "DenseMatrix_AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose_a", _wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS, "DenseMatrix_AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_LeftScaling", _wrap_DenseMatrix_LeftScaling, METH_VARARGS, "DenseMatrix_LeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvLeftScaling", _wrap_DenseMatrix_InvLeftScaling, METH_VARARGS, "DenseMatrix_InvLeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_RightScaling", _wrap_DenseMatrix_RightScaling, METH_VARARGS, "DenseMatrix_RightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvRightScaling", _wrap_DenseMatrix_InvRightScaling, METH_VARARGS, "DenseMatrix_InvRightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_SymmetricScaling", _wrap_DenseMatrix_SymmetricScaling, METH_VARARGS, "DenseMatrix_SymmetricScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvSymmetricScaling", _wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS, "DenseMatrix_InvSymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMult(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMult_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult_a, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_LeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_LeftScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_LeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvLeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvLeftScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_InvLeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_RightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_RightScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_RightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvRightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvRightScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_InvRightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_SymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SymmetricScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_SymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvSymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_InvSymmetricScaling(DenseMatrix self, Vector s)"}, { "DenseMatrix_InnerProduct", _wrap_DenseMatrix_InnerProduct, METH_VARARGS, "\n" "DenseMatrix_InnerProduct(DenseMatrix self, double const * x, double const * y) -> double\n" "DenseMatrix_InnerProduct(DenseMatrix self, Vector x, Vector y) -> double\n" @@ -17813,15 +17234,15 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_Set(DenseMatrix self, double alpha, double const * A)\n" "DenseMatrix_Set(DenseMatrix self, double alpha, DenseMatrix A)\n" ""}, - { "DenseMatrix_Add", _wrap_DenseMatrix_Add, METH_VARARGS, "DenseMatrix_Add(DenseMatrix self, double const c, DenseMatrix A)"}, + { "DenseMatrix_Add", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Add, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Add(DenseMatrix self, double const c, DenseMatrix A)"}, { "DenseMatrix___iadd__", _wrap_DenseMatrix___iadd__, METH_VARARGS, "\n" "DenseMatrix___iadd__(DenseMatrix self, double const * m) -> DenseMatrix\n" "DenseMatrix___iadd__(DenseMatrix self, DenseMatrix m) -> DenseMatrix\n" ""}, - { "DenseMatrix___isub__", _wrap_DenseMatrix___isub__, METH_VARARGS, "DenseMatrix___isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, - { "DenseMatrix___imul__", _wrap_DenseMatrix___imul__, METH_VARARGS, "DenseMatrix___imul__(DenseMatrix self, double c) -> DenseMatrix"}, + { "DenseMatrix___isub__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___isub__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, + { "DenseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___imul__(DenseMatrix self, double c) -> DenseMatrix"}, { "DenseMatrix_Neg", _wrap_DenseMatrix_Neg, METH_O, "DenseMatrix_Neg(DenseMatrix self)"}, - { "DenseMatrix_Norm2", _wrap_DenseMatrix_Norm2, METH_VARARGS, "DenseMatrix_Norm2(DenseMatrix self, double * v)"}, + { "DenseMatrix_Norm2", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Norm2, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Norm2(DenseMatrix self, double * v)"}, { "DenseMatrix_MaxMaxNorm", _wrap_DenseMatrix_MaxMaxNorm, METH_O, "DenseMatrix_MaxMaxNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm", _wrap_DenseMatrix_FNorm, METH_O, "DenseMatrix_FNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm2", _wrap_DenseMatrix_FNorm2, METH_O, "DenseMatrix_FNorm2(DenseMatrix self) -> double"}, @@ -17835,17 +17256,17 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_Eigensystem(DenseMatrix self, Vector ev, DenseMatrix evect)\n" "DenseMatrix_Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" ""}, - { "DenseMatrix_SingularValues", _wrap_DenseMatrix_SingularValues, METH_VARARGS, "DenseMatrix_SingularValues(DenseMatrix self, Vector sv)"}, - { "DenseMatrix_Rank", _wrap_DenseMatrix_Rank, METH_VARARGS, "DenseMatrix_Rank(DenseMatrix self, double tol) -> int"}, - { "DenseMatrix_CalcSingularvalue", _wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS, "DenseMatrix_CalcSingularvalue(DenseMatrix self, int const i) -> double"}, - { "DenseMatrix_CalcEigenvalues", _wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS, "DenseMatrix_CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, - { "DenseMatrix_GetRow", _wrap_DenseMatrix_GetRow, METH_VARARGS, "DenseMatrix_GetRow(DenseMatrix self, int r, Vector row)"}, + { "DenseMatrix_SingularValues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SingularValues, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_SingularValues(DenseMatrix self, Vector sv)"}, + { "DenseMatrix_Rank", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Rank, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Rank(DenseMatrix self, double tol) -> int"}, + { "DenseMatrix_CalcSingularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CalcSingularvalue(DenseMatrix self, int const i) -> double"}, + { "DenseMatrix_CalcEigenvalues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, + { "DenseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetRow(DenseMatrix self, int r, Vector row)"}, { "DenseMatrix_GetColumn", _wrap_DenseMatrix_GetColumn, METH_VARARGS, "\n" "DenseMatrix_GetColumn(DenseMatrix self, int c, Vector col)\n" "DenseMatrix_GetColumn(DenseMatrix self, int col) -> double\n" "DenseMatrix_GetColumn(DenseMatrix self, int col) -> double const *\n" ""}, - { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "DenseMatrix_GetColumnReference(DenseMatrix self, int c, Vector col)"}, + { "DenseMatrix_GetColumnReference", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetColumnReference, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetColumnReference(DenseMatrix self, int c, Vector col)"}, { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" "DenseMatrix_SetRow(DenseMatrix self, int r, double const * row)\n" "DenseMatrix_SetRow(DenseMatrix self, int r, Vector row)\n" @@ -17856,9 +17277,9 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_SetCol(DenseMatrix self, int c, Vector col)\n" "DenseMatrix_SetCol(DenseMatrix self, int col, double value)\n" ""}, - { "DenseMatrix_GetDiag", _wrap_DenseMatrix_GetDiag, METH_VARARGS, "DenseMatrix_GetDiag(DenseMatrix self, Vector d)"}, - { "DenseMatrix_Getl1Diag", _wrap_DenseMatrix_Getl1Diag, METH_VARARGS, "DenseMatrix_Getl1Diag(DenseMatrix self, Vector l)"}, - { "DenseMatrix_GetRowSums", _wrap_DenseMatrix_GetRowSums, METH_VARARGS, "DenseMatrix_GetRowSums(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetDiag(DenseMatrix self, Vector d)"}, + { "DenseMatrix_Getl1Diag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Getl1Diag, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Getl1Diag(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetRowSums(DenseMatrix self, Vector l)"}, { "DenseMatrix_Diag", _wrap_DenseMatrix_Diag, METH_VARARGS, "\n" "DenseMatrix_Diag(DenseMatrix self, double c, int n)\n" "DenseMatrix_Diag(DenseMatrix self, double * diag, int n)\n" @@ -17869,11 +17290,11 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_Symmetrize", _wrap_DenseMatrix_Symmetrize, METH_O, "DenseMatrix_Symmetrize(DenseMatrix self)"}, { "DenseMatrix_Lump", _wrap_DenseMatrix_Lump, METH_O, "DenseMatrix_Lump(DenseMatrix self)"}, - { "DenseMatrix_GradToCurl", _wrap_DenseMatrix_GradToCurl, METH_VARARGS, "DenseMatrix_GradToCurl(DenseMatrix self, DenseMatrix curl)"}, - { "DenseMatrix_GradToDiv", _wrap_DenseMatrix_GradToDiv, METH_VARARGS, "DenseMatrix_GradToDiv(DenseMatrix self, Vector div)"}, - { "DenseMatrix_CopyRows", _wrap_DenseMatrix_CopyRows, METH_VARARGS, "DenseMatrix_CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, - { "DenseMatrix_CopyCols", _wrap_DenseMatrix_CopyCols, METH_VARARGS, "DenseMatrix_CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, - { "DenseMatrix_CopyMNt", _wrap_DenseMatrix_CopyMNt, METH_VARARGS, "DenseMatrix_CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, + { "DenseMatrix_GradToCurl", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToCurl, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GradToCurl(DenseMatrix self, DenseMatrix curl)"}, + { "DenseMatrix_GradToDiv", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToDiv, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GradToDiv(DenseMatrix self, Vector div)"}, + { "DenseMatrix_CopyRows", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyRows, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, + { "DenseMatrix_CopyCols", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyCols, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, + { "DenseMatrix_CopyMNt", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyMNt, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, { "DenseMatrix_CopyMN", _wrap_DenseMatrix_CopyMN, METH_VARARGS, "\n" "DenseMatrix_CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco)\n" "DenseMatrix_CopyMN(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)\n" @@ -17883,23 +17304,23 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_CopyMNDiag(DenseMatrix self, double c, int n, int row_offset, int col_offset)\n" "DenseMatrix_CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset)\n" ""}, - { "DenseMatrix_CopyExceptMN", _wrap_DenseMatrix_CopyExceptMN, METH_VARARGS, "DenseMatrix_CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, + { "DenseMatrix_CopyExceptMN", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyExceptMN, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, { "DenseMatrix_AddMatrix", _wrap_DenseMatrix_AddMatrix, METH_VARARGS, "\n" "DenseMatrix_AddMatrix(DenseMatrix self, DenseMatrix A, int ro, int co)\n" "DenseMatrix_AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co)\n" ""}, - { "DenseMatrix_AddToVector", _wrap_DenseMatrix_AddToVector, METH_VARARGS, "DenseMatrix_AddToVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_GetFromVector", _wrap_DenseMatrix_GetFromVector, METH_VARARGS, "DenseMatrix_GetFromVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_AdjustDofDirection", _wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS, "DenseMatrix_AdjustDofDirection(DenseMatrix self, intArray dofs)"}, - { "DenseMatrix_Threshold", _wrap_DenseMatrix_Threshold, METH_VARARGS, "DenseMatrix_Threshold(DenseMatrix self, double eps)"}, + { "DenseMatrix_AddToVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddToVector, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddToVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_GetFromVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetFromVector, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetFromVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_AdjustDofDirection", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AdjustDofDirection(DenseMatrix self, intArray dofs)"}, + { "DenseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Threshold(DenseMatrix self, double eps)"}, { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "DenseMatrix_CheckFinite(DenseMatrix self) -> int"}, { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "DenseMatrix_TestInversion(DenseMatrix self)"}, { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "DenseMatrix_MemoryUsage(DenseMatrix self) -> long"}, - { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "DenseMatrix_Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_Read", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Read, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Read(DenseMatrix self, bool on_dev=True) -> double const *"}, { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "DenseMatrix_HostRead(DenseMatrix self) -> double const *"}, - { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "DenseMatrix_Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_Write", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Write, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Write(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "DenseMatrix_HostWrite(DenseMatrix self) -> double *"}, - { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "DenseMatrix_ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_ReadWrite, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_ReadWrite(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "DenseMatrix_HostReadWrite(DenseMatrix self) -> double *"}, { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" @@ -17907,8 +17328,8 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_Assign(DenseMatrix self, DenseMatrix m)\n" "DenseMatrix_Assign(DenseMatrix self, PyObject * numpymat)\n" ""}, - { "DenseMatrix___getitem__", _wrap_DenseMatrix___getitem__, METH_VARARGS, "DenseMatrix___getitem__(DenseMatrix self, int const i, int const j) -> double const"}, - { "DenseMatrix___setitem__", _wrap_DenseMatrix___setitem__, METH_VARARGS, "DenseMatrix___setitem__(DenseMatrix self, int i, int j, double const v)"}, + { "DenseMatrix___getitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___getitem__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___getitem__(DenseMatrix self, int const i, int const j) -> double const"}, + { "DenseMatrix___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___setitem__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___setitem__(DenseMatrix self, int i, int j, double const v)"}, { "DenseMatrix_GetDataArray", _wrap_DenseMatrix_GetDataArray, METH_O, "DenseMatrix_GetDataArray(DenseMatrix self) -> PyObject *"}, { "DenseMatrix_Print", _wrap_DenseMatrix_Print, METH_VARARGS, "\n" "DenseMatrix_Print(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -17924,31 +17345,31 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, - { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, - { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, - { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, - { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, - { "CalcInverseTranspose", _wrap_CalcInverseTranspose, METH_VARARGS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, - { "CalcOrtho", _wrap_CalcOrtho, METH_VARARGS, "CalcOrtho(DenseMatrix J, Vector n)"}, - { "MultAAt", _wrap_MultAAt, METH_VARARGS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, - { "MultADAt", _wrap_MultADAt, METH_VARARGS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "AddMultADAt", _wrap_AddMultADAt, METH_VARARGS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "MultABt", _wrap_MultABt, METH_VARARGS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultADBt", _wrap_MultADBt, METH_VARARGS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMultABt", _wrap_AddMultABt, METH_VARARGS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "AddMultADBt", _wrap_AddMultADBt, METH_VARARGS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMult_a_ABt", _wrap_AddMult_a_ABt, METH_VARARGS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultAtB", _wrap_MultAtB, METH_VARARGS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, - { "AddMult_a_AAt", _wrap_AddMult_a_AAt, METH_VARARGS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "Mult_a_AAt", _wrap_Mult_a_AAt, METH_VARARGS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "MultVVt", _wrap_MultVVt, METH_VARARGS, "MultVVt(Vector v, DenseMatrix vvt)"}, - { "MultVWt", _wrap_MultVWt, METH_VARARGS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVWt", _wrap_AddMultVWt, METH_VARARGS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVVt", _wrap_AddMultVVt, METH_VARARGS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, - { "AddMult_a_VWt", _wrap_AddMult_a_VWt, METH_VARARGS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMult_a_VVt", _wrap_AddMult_a_VVt, METH_VARARGS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, + { "LinearSolve", (PyCFunction)(void(*)(void))_wrap_LinearSolve, METH_VARARGS|METH_KEYWORDS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, + { "AddMult", (PyCFunction)(void(*)(void))_wrap_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", (PyCFunction)(void(*)(void))_wrap_AddMult_a, METH_VARARGS|METH_KEYWORDS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "CalcAdjugate", (PyCFunction)(void(*)(void))_wrap_CalcAdjugate, METH_VARARGS|METH_KEYWORDS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, + { "CalcAdjugateTranspose", (PyCFunction)(void(*)(void))_wrap_CalcAdjugateTranspose, METH_VARARGS|METH_KEYWORDS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, + { "CalcInverse", (PyCFunction)(void(*)(void))_wrap_CalcInverse, METH_VARARGS|METH_KEYWORDS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, + { "CalcInverseTranspose", (PyCFunction)(void(*)(void))_wrap_CalcInverseTranspose, METH_VARARGS|METH_KEYWORDS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, + { "CalcOrtho", (PyCFunction)(void(*)(void))_wrap_CalcOrtho, METH_VARARGS|METH_KEYWORDS, "CalcOrtho(DenseMatrix J, Vector n)"}, + { "MultAAt", (PyCFunction)(void(*)(void))_wrap_MultAAt, METH_VARARGS|METH_KEYWORDS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, + { "MultADAt", (PyCFunction)(void(*)(void))_wrap_MultADAt, METH_VARARGS|METH_KEYWORDS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "AddMultADAt", (PyCFunction)(void(*)(void))_wrap_AddMultADAt, METH_VARARGS|METH_KEYWORDS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "MultABt", (PyCFunction)(void(*)(void))_wrap_MultABt, METH_VARARGS|METH_KEYWORDS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultADBt", (PyCFunction)(void(*)(void))_wrap_MultADBt, METH_VARARGS|METH_KEYWORDS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMultABt", (PyCFunction)(void(*)(void))_wrap_AddMultABt, METH_VARARGS|METH_KEYWORDS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "AddMultADBt", (PyCFunction)(void(*)(void))_wrap_AddMultADBt, METH_VARARGS|METH_KEYWORDS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMult_a_ABt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_ABt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultAtB", (PyCFunction)(void(*)(void))_wrap_MultAtB, METH_VARARGS|METH_KEYWORDS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, + { "AddMult_a_AAt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_AAt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "Mult_a_AAt", (PyCFunction)(void(*)(void))_wrap_Mult_a_AAt, METH_VARARGS|METH_KEYWORDS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "MultVVt", (PyCFunction)(void(*)(void))_wrap_MultVVt, METH_VARARGS|METH_KEYWORDS, "MultVVt(Vector v, DenseMatrix vvt)"}, + { "MultVWt", (PyCFunction)(void(*)(void))_wrap_MultVWt, METH_VARARGS|METH_KEYWORDS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVWt", (PyCFunction)(void(*)(void))_wrap_AddMultVWt, METH_VARARGS|METH_KEYWORDS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVVt", (PyCFunction)(void(*)(void))_wrap_AddMultVVt, METH_VARARGS|METH_KEYWORDS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, + { "AddMult_a_VWt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VWt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMult_a_VVt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VVt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, { "LUFactors_data_set", _wrap_LUFactors_data_set, METH_VARARGS, "LUFactors_data_set(LUFactors self, double * data)"}, { "LUFactors_data_get", _wrap_LUFactors_data_get, METH_O, "LUFactors_data_get(LUFactors self) -> double *"}, { "LUFactors_ipiv_set", _wrap_LUFactors_ipiv_set, METH_VARARGS, "LUFactors_ipiv_set(LUFactors self, int * ipiv)"}, @@ -17957,18 +17378,18 @@ static PyMethodDef SwigMethods[] = { "LUFactors()\n" "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" ""}, - { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "LUFactors_Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, - { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "LUFactors_Det(LUFactors self, int m) -> double"}, - { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "LUFactors_Mult(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LUFactors_LSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "LUFactors_USolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "LUFactors_Solve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "LUFactors_RightSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "LUFactors_GetInverseMatrix(LUFactors self, int m, double * X)"}, - { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, - { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "LUFactors_BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, - { "LUFactors_BlockForwSolve", _wrap_LUFactors_BlockForwSolve, METH_VARARGS, "LUFactors_BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, - { "LUFactors_BlockBackSolve", _wrap_LUFactors_BlockBackSolve, METH_VARARGS, "LUFactors_BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, + { "LUFactors_Factor", (PyCFunction)(void(*)(void))_wrap_LUFactors_Factor, METH_VARARGS|METH_KEYWORDS, "LUFactors_Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, + { "LUFactors_Det", (PyCFunction)(void(*)(void))_wrap_LUFactors_Det, METH_VARARGS|METH_KEYWORDS, "LUFactors_Det(LUFactors self, int m) -> double"}, + { "LUFactors_Mult", (PyCFunction)(void(*)(void))_wrap_LUFactors_Mult, METH_VARARGS|METH_KEYWORDS, "LUFactors_Mult(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_LSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_LSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_LSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_USolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_USolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_USolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_Solve", (PyCFunction)(void(*)(void))_wrap_LUFactors_Solve, METH_VARARGS|METH_KEYWORDS, "LUFactors_Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_RightSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_RightSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_LUFactors_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "LUFactors_GetInverseMatrix(LUFactors self, int m, double * X)"}, + { "LUFactors_SubMult", (PyCFunction)(void(*)(void))_wrap_LUFactors_SubMult, METH_VARARGS|METH_KEYWORDS, "LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, + { "LUFactors_BlockFactor", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockFactor, METH_VARARGS|METH_KEYWORDS, "LUFactors_BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, + { "LUFactors_BlockForwSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockForwSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, + { "LUFactors_BlockBackSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockBackSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, { "delete_LUFactors", _wrap_delete_LUFactors, METH_O, "delete_LUFactors(LUFactors self)"}, { "LUFactors_swigregister", LUFactors_swigregister, METH_O, NULL}, { "LUFactors_swiginit", LUFactors_swiginit, METH_VARARGS, NULL}, @@ -17982,13 +17403,13 @@ static PyMethodDef SwigMethods[] = { "DenseMatrixInverse_Factor(DenseMatrixInverse self)\n" "DenseMatrixInverse_Factor(DenseMatrixInverse self, DenseMatrix mat)\n" ""}, - { "DenseMatrixInverse_SetOperator", _wrap_DenseMatrixInverse_SetOperator, METH_VARARGS, "DenseMatrixInverse_SetOperator(DenseMatrixInverse self, Operator op)"}, + { "DenseMatrixInverse_SetOperator", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_SetOperator, METH_VARARGS|METH_KEYWORDS, "DenseMatrixInverse_SetOperator(DenseMatrixInverse self, Operator op)"}, { "DenseMatrixInverse_Mult", _wrap_DenseMatrixInverse_Mult, METH_VARARGS, "\n" "DenseMatrixInverse_Mult(DenseMatrixInverse self, Vector x, Vector y)\n" "DenseMatrixInverse_Mult(DenseMatrixInverse self, DenseMatrix B, DenseMatrix X)\n" "DenseMatrixInverse_Mult(DenseMatrixInverse self, DenseMatrix X)\n" ""}, - { "DenseMatrixInverse_GetInverseMatrix", _wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS, "DenseMatrixInverse_GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, + { "DenseMatrixInverse_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "DenseMatrixInverse_GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, { "DenseMatrixInverse_Det", _wrap_DenseMatrixInverse_Det, METH_O, "DenseMatrixInverse_Det(DenseMatrixInverse self) -> double"}, { "DenseMatrixInverse_TestInversion", _wrap_DenseMatrixInverse_TestInversion, METH_O, "DenseMatrixInverse_TestInversion(DenseMatrixInverse self)"}, { "delete_DenseMatrixInverse", _wrap_delete_DenseMatrixInverse, METH_O, "delete_DenseMatrixInverse(DenseMatrixInverse self)"}, @@ -18001,8 +17422,8 @@ static PyMethodDef SwigMethods[] = { { "DenseMatrixEigensystem_Eval", _wrap_DenseMatrixEigensystem_Eval, METH_O, "DenseMatrixEigensystem_Eval(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_Eigenvalues", _wrap_DenseMatrixEigensystem_Eigenvalues, METH_O, "DenseMatrixEigensystem_Eigenvalues(DenseMatrixEigensystem self) -> Vector"}, { "DenseMatrixEigensystem_Eigenvectors", _wrap_DenseMatrixEigensystem_Eigenvectors, METH_O, "DenseMatrixEigensystem_Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix"}, - { "DenseMatrixEigensystem_Eigenvalue", _wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS, "DenseMatrixEigensystem_Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, - { "DenseMatrixEigensystem_Eigenvector", _wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS, "DenseMatrixEigensystem_Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, + { "DenseMatrixEigensystem_Eigenvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS|METH_KEYWORDS, "DenseMatrixEigensystem_Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, + { "DenseMatrixEigensystem_Eigenvector", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS|METH_KEYWORDS, "DenseMatrixEigensystem_Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, { "delete_DenseMatrixEigensystem", _wrap_delete_DenseMatrixEigensystem, METH_O, "delete_DenseMatrixEigensystem(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_swigregister", DenseMatrixEigensystem_swigregister, METH_O, NULL}, { "DenseMatrixEigensystem_swiginit", DenseMatrixEigensystem_swiginit, METH_VARARGS, NULL}, @@ -18010,9 +17431,9 @@ static PyMethodDef SwigMethods[] = { "DenseMatrixSVD(DenseMatrix M)\n" "new_DenseMatrixSVD(int h, int w) -> DenseMatrixSVD\n" ""}, - { "DenseMatrixSVD_Eval", _wrap_DenseMatrixSVD_Eval, METH_VARARGS, "DenseMatrixSVD_Eval(DenseMatrixSVD self, DenseMatrix M)"}, + { "DenseMatrixSVD_Eval", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Eval, METH_VARARGS|METH_KEYWORDS, "DenseMatrixSVD_Eval(DenseMatrixSVD self, DenseMatrix M)"}, { "DenseMatrixSVD_Singularvalues", _wrap_DenseMatrixSVD_Singularvalues, METH_O, "DenseMatrixSVD_Singularvalues(DenseMatrixSVD self) -> Vector"}, - { "DenseMatrixSVD_Singularvalue", _wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS, "DenseMatrixSVD_Singularvalue(DenseMatrixSVD self, int i) -> double"}, + { "DenseMatrixSVD_Singularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS|METH_KEYWORDS, "DenseMatrixSVD_Singularvalue(DenseMatrixSVD self, int i) -> double"}, { "delete_DenseMatrixSVD", _wrap_delete_DenseMatrixSVD, METH_O, "delete_DenseMatrixSVD(DenseMatrixSVD self)"}, { "DenseMatrixSVD_swigregister", DenseMatrixSVD_swigregister, METH_O, NULL}, { "DenseMatrixSVD_swiginit", DenseMatrixSVD_swiginit, METH_VARARGS, NULL}, @@ -18025,15 +17446,15 @@ static PyMethodDef SwigMethods[] = { { "DenseTensor_SizeJ", _wrap_DenseTensor_SizeJ, METH_O, "DenseTensor_SizeJ(DenseTensor self) -> int"}, { "DenseTensor_SizeK", _wrap_DenseTensor_SizeK, METH_O, "DenseTensor_SizeK(DenseTensor self) -> int"}, { "DenseTensor_TotalSize", _wrap_DenseTensor_TotalSize, METH_O, "DenseTensor_TotalSize(DenseTensor self) -> int"}, - { "DenseTensor_SetSize", _wrap_DenseTensor_SetSize, METH_VARARGS, "DenseTensor_SetSize(DenseTensor self, int i, int j, int k)"}, - { "DenseTensor_UseExternalData", _wrap_DenseTensor_UseExternalData, METH_VARARGS, "DenseTensor_UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, + { "DenseTensor_SetSize", (PyCFunction)(void(*)(void))_wrap_DenseTensor_SetSize, METH_VARARGS|METH_KEYWORDS, "DenseTensor_SetSize(DenseTensor self, int i, int j, int k)"}, + { "DenseTensor_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_UseExternalData, METH_VARARGS|METH_KEYWORDS, "DenseTensor_UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, { "DenseTensor___call__", _wrap_DenseTensor___call__, METH_VARARGS, "\n" "DenseTensor___call__(DenseTensor self, int k) -> DenseMatrix\n" "DenseTensor___call__(DenseTensor self, int k) -> DenseMatrix\n" "DenseTensor___call__(DenseTensor self, int i, int j, int k) -> double\n" "DenseTensor___call__(DenseTensor self, int i, int j, int k) -> double const &\n" ""}, - { "DenseTensor_GetData", _wrap_DenseTensor_GetData, METH_VARARGS, "DenseTensor_GetData(DenseTensor self, int k) -> double *"}, + { "DenseTensor_GetData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_GetData, METH_VARARGS|METH_KEYWORDS, "DenseTensor_GetData(DenseTensor self, int k) -> double *"}, { "DenseTensor_Data", _wrap_DenseTensor_Data, METH_VARARGS, "\n" "DenseTensor_Data(DenseTensor self) -> double\n" "DenseTensor_Data(DenseTensor self) -> double const *\n" @@ -18042,22 +17463,22 @@ static PyMethodDef SwigMethods[] = { "DenseTensor_GetMemory(DenseTensor self) -> mfem::Memory< double >\n" "DenseTensor_GetMemory(DenseTensor self) -> mfem::Memory< double > const &\n" ""}, - { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "DenseTensor_AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, + { "DenseTensor_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseTensor_AddMult, METH_VARARGS|METH_KEYWORDS, "DenseTensor_AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "DenseTensor_Clear(DenseTensor self)"}, { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "DenseTensor_MemoryUsage(DenseTensor self) -> long"}, - { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "DenseTensor_Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_Read", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Read, METH_VARARGS|METH_KEYWORDS, "DenseTensor_Read(DenseTensor self, bool on_dev=True) -> double const *"}, { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "DenseTensor_HostRead(DenseTensor self) -> double const *"}, - { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "DenseTensor_Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_Write", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Write, METH_VARARGS|METH_KEYWORDS, "DenseTensor_Write(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "DenseTensor_HostWrite(DenseTensor self) -> double *"}, - { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "DenseTensor_ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseTensor_ReadWrite, METH_VARARGS|METH_KEYWORDS, "DenseTensor_ReadWrite(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "DenseTensor_HostReadWrite(DenseTensor self) -> double *"}, { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, - { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "DenseTensor_Assign(DenseTensor self, double const c)"}, + { "DenseTensor_Assign", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Assign, METH_VARARGS|METH_KEYWORDS, "DenseTensor_Assign(DenseTensor self, double const c)"}, { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" "DenseTensor___getitem__(DenseTensor self, int const i, int const j, int const k) -> double const\n" "DenseTensor___getitem__(DenseTensor self, int const k) -> DenseMatrix\n" ""}, - { "DenseTensor___setitem__", _wrap_DenseTensor___setitem__, METH_VARARGS, "DenseTensor___setitem__(DenseTensor self, int i, int j, int k, double const v)"}, + { "DenseTensor___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseTensor___setitem__, METH_VARARGS|METH_KEYWORDS, "DenseTensor___setitem__(DenseTensor self, int i, int j, int k, double const v)"}, { "DenseTensor_GetDataArray", _wrap_DenseTensor_GetDataArray, METH_O, "DenseTensor_GetDataArray(DenseTensor self) -> PyObject *"}, { "DenseTensor_swigregister", DenseTensor_swigregister, METH_O, NULL}, { "DenseTensor_swiginit", DenseTensor_swiginit, METH_VARARGS, NULL}, @@ -18075,8 +17496,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DenseMatrix(DenseMatrix mat, char ch)\n" "new_DenseMatrix(double * d, int h, int w) -> DenseMatrix\n" ""}, - { "DenseMatrix_UseExternalData", _wrap_DenseMatrix_UseExternalData, METH_VARARGS, "UseExternalData(DenseMatrix self, double * d, int h, int w)"}, - { "DenseMatrix_Reset", _wrap_DenseMatrix_Reset, METH_VARARGS, "Reset(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_UseExternalData, METH_VARARGS|METH_KEYWORDS, "UseExternalData(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_Reset", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Reset, METH_VARARGS|METH_KEYWORDS, "Reset(DenseMatrix self, double * d, int h, int w)"}, { "DenseMatrix_ClearExternalData", _wrap_DenseMatrix_ClearExternalData, METH_O, "ClearExternalData(DenseMatrix self)"}, { "DenseMatrix_Clear", _wrap_DenseMatrix_Clear, METH_O, "Clear(DenseMatrix self)"}, { "DenseMatrix_Size", _wrap_DenseMatrix_Size, METH_O, "Size(DenseMatrix self) -> int"}, @@ -18095,7 +17516,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__call__(DenseMatrix self, int i, int j) -> double\n" "__call__(DenseMatrix self, int i, int j) -> double const &\n" ""}, - { "DenseMatrix___mul__", _wrap_DenseMatrix___mul__, METH_VARARGS, "__mul__(DenseMatrix self, DenseMatrix m) -> double"}, + { "DenseMatrix___mul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___mul__, METH_VARARGS|METH_KEYWORDS, "__mul__(DenseMatrix self, DenseMatrix m) -> double"}, { "DenseMatrix_Trace", _wrap_DenseMatrix_Trace, METH_O, "Trace(DenseMatrix self) -> double"}, { "DenseMatrix_Elem", _wrap_DenseMatrix_Elem, METH_VARARGS, "\n" "Elem(DenseMatrix self, int i, int j) -> double\n" @@ -18109,16 +17530,16 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MultTranspose(DenseMatrix self, double const * x, double * y)\n" "MultTranspose(DenseMatrix self, Vector x, Vector y)\n" ""}, - { "DenseMatrix_AddMult", _wrap_DenseMatrix_AddMult, METH_VARARGS, "AddMult(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose", _wrap_DenseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMult_a", _wrap_DenseMatrix_AddMult_a, METH_VARARGS, "AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose_a", _wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS, "AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_LeftScaling", _wrap_DenseMatrix_LeftScaling, METH_VARARGS, "LeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvLeftScaling", _wrap_DenseMatrix_InvLeftScaling, METH_VARARGS, "InvLeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_RightScaling", _wrap_DenseMatrix_RightScaling, METH_VARARGS, "RightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvRightScaling", _wrap_DenseMatrix_InvRightScaling, METH_VARARGS, "InvRightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_SymmetricScaling", _wrap_DenseMatrix_SymmetricScaling, METH_VARARGS, "SymmetricScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvSymmetricScaling", _wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS, "InvSymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMult_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult_a, METH_VARARGS|METH_KEYWORDS, "AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_LeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_LeftScaling, METH_VARARGS|METH_KEYWORDS, "LeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvLeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvLeftScaling, METH_VARARGS|METH_KEYWORDS, "InvLeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_RightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_RightScaling, METH_VARARGS|METH_KEYWORDS, "RightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvRightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvRightScaling, METH_VARARGS|METH_KEYWORDS, "InvRightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_SymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SymmetricScaling, METH_VARARGS|METH_KEYWORDS, "SymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvSymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS|METH_KEYWORDS, "InvSymmetricScaling(DenseMatrix self, Vector s)"}, { "DenseMatrix_InnerProduct", _wrap_DenseMatrix_InnerProduct, METH_VARARGS, "\n" "InnerProduct(DenseMatrix self, double const * x, double const * y) -> double\n" "InnerProduct(DenseMatrix self, Vector x, Vector y) -> double\n" @@ -18132,15 +17553,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Set(DenseMatrix self, double alpha, double const * A)\n" "Set(DenseMatrix self, double alpha, DenseMatrix A)\n" ""}, - { "DenseMatrix_Add", _wrap_DenseMatrix_Add, METH_VARARGS, "Add(DenseMatrix self, double const c, DenseMatrix A)"}, + { "DenseMatrix_Add", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Add, METH_VARARGS|METH_KEYWORDS, "Add(DenseMatrix self, double const c, DenseMatrix A)"}, { "DenseMatrix___iadd__", _wrap_DenseMatrix___iadd__, METH_VARARGS, "\n" "__iadd__(DenseMatrix self, double const * m) -> DenseMatrix\n" "__iadd__(DenseMatrix self, DenseMatrix m) -> DenseMatrix\n" ""}, - { "DenseMatrix___isub__", _wrap_DenseMatrix___isub__, METH_VARARGS, "__isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, - { "DenseMatrix___imul__", _wrap_DenseMatrix___imul__, METH_VARARGS, "__imul__(DenseMatrix self, double c) -> DenseMatrix"}, + { "DenseMatrix___isub__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___isub__, METH_VARARGS|METH_KEYWORDS, "__isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, + { "DenseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "__imul__(DenseMatrix self, double c) -> DenseMatrix"}, { "DenseMatrix_Neg", _wrap_DenseMatrix_Neg, METH_O, "Neg(DenseMatrix self)"}, - { "DenseMatrix_Norm2", _wrap_DenseMatrix_Norm2, METH_VARARGS, "Norm2(DenseMatrix self, double * v)"}, + { "DenseMatrix_Norm2", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Norm2, METH_VARARGS|METH_KEYWORDS, "Norm2(DenseMatrix self, double * v)"}, { "DenseMatrix_MaxMaxNorm", _wrap_DenseMatrix_MaxMaxNorm, METH_O, "MaxMaxNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm", _wrap_DenseMatrix_FNorm, METH_O, "FNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm2", _wrap_DenseMatrix_FNorm2, METH_O, "FNorm2(DenseMatrix self) -> double"}, @@ -18154,17 +17575,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Eigensystem(DenseMatrix self, Vector ev, DenseMatrix evect)\n" "Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" ""}, - { "DenseMatrix_SingularValues", _wrap_DenseMatrix_SingularValues, METH_VARARGS, "SingularValues(DenseMatrix self, Vector sv)"}, - { "DenseMatrix_Rank", _wrap_DenseMatrix_Rank, METH_VARARGS, "Rank(DenseMatrix self, double tol) -> int"}, - { "DenseMatrix_CalcSingularvalue", _wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS, "CalcSingularvalue(DenseMatrix self, int const i) -> double"}, - { "DenseMatrix_CalcEigenvalues", _wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS, "CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, - { "DenseMatrix_GetRow", _wrap_DenseMatrix_GetRow, METH_VARARGS, "GetRow(DenseMatrix self, int r, Vector row)"}, + { "DenseMatrix_SingularValues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SingularValues, METH_VARARGS|METH_KEYWORDS, "SingularValues(DenseMatrix self, Vector sv)"}, + { "DenseMatrix_Rank", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Rank, METH_VARARGS|METH_KEYWORDS, "Rank(DenseMatrix self, double tol) -> int"}, + { "DenseMatrix_CalcSingularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS|METH_KEYWORDS, "CalcSingularvalue(DenseMatrix self, int const i) -> double"}, + { "DenseMatrix_CalcEigenvalues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS|METH_KEYWORDS, "CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, + { "DenseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(DenseMatrix self, int r, Vector row)"}, { "DenseMatrix_GetColumn", _wrap_DenseMatrix_GetColumn, METH_VARARGS, "\n" "GetColumn(DenseMatrix self, int c, Vector col)\n" "GetColumn(DenseMatrix self, int col) -> double\n" "GetColumn(DenseMatrix self, int col) -> double const *\n" ""}, - { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "GetColumnReference(DenseMatrix self, int c, Vector col)"}, + { "DenseMatrix_GetColumnReference", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetColumnReference, METH_VARARGS|METH_KEYWORDS, "GetColumnReference(DenseMatrix self, int c, Vector col)"}, { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" "SetRow(DenseMatrix self, int r, double const * row)\n" "SetRow(DenseMatrix self, int r, Vector row)\n" @@ -18175,9 +17596,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetCol(DenseMatrix self, int c, Vector col)\n" "SetCol(DenseMatrix self, int col, double value)\n" ""}, - { "DenseMatrix_GetDiag", _wrap_DenseMatrix_GetDiag, METH_VARARGS, "GetDiag(DenseMatrix self, Vector d)"}, - { "DenseMatrix_Getl1Diag", _wrap_DenseMatrix_Getl1Diag, METH_VARARGS, "Getl1Diag(DenseMatrix self, Vector l)"}, - { "DenseMatrix_GetRowSums", _wrap_DenseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "GetDiag(DenseMatrix self, Vector d)"}, + { "DenseMatrix_Getl1Diag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Getl1Diag, METH_VARARGS|METH_KEYWORDS, "Getl1Diag(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "GetRowSums(DenseMatrix self, Vector l)"}, { "DenseMatrix_Diag", _wrap_DenseMatrix_Diag, METH_VARARGS, "\n" "Diag(DenseMatrix self, double c, int n)\n" "Diag(DenseMatrix self, double * diag, int n)\n" @@ -18188,11 +17609,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "DenseMatrix_Symmetrize", _wrap_DenseMatrix_Symmetrize, METH_O, "Symmetrize(DenseMatrix self)"}, { "DenseMatrix_Lump", _wrap_DenseMatrix_Lump, METH_O, "Lump(DenseMatrix self)"}, - { "DenseMatrix_GradToCurl", _wrap_DenseMatrix_GradToCurl, METH_VARARGS, "GradToCurl(DenseMatrix self, DenseMatrix curl)"}, - { "DenseMatrix_GradToDiv", _wrap_DenseMatrix_GradToDiv, METH_VARARGS, "GradToDiv(DenseMatrix self, Vector div)"}, - { "DenseMatrix_CopyRows", _wrap_DenseMatrix_CopyRows, METH_VARARGS, "CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, - { "DenseMatrix_CopyCols", _wrap_DenseMatrix_CopyCols, METH_VARARGS, "CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, - { "DenseMatrix_CopyMNt", _wrap_DenseMatrix_CopyMNt, METH_VARARGS, "CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, + { "DenseMatrix_GradToCurl", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToCurl, METH_VARARGS|METH_KEYWORDS, "GradToCurl(DenseMatrix self, DenseMatrix curl)"}, + { "DenseMatrix_GradToDiv", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToDiv, METH_VARARGS|METH_KEYWORDS, "GradToDiv(DenseMatrix self, Vector div)"}, + { "DenseMatrix_CopyRows", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyRows, METH_VARARGS|METH_KEYWORDS, "CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, + { "DenseMatrix_CopyCols", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyCols, METH_VARARGS|METH_KEYWORDS, "CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, + { "DenseMatrix_CopyMNt", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyMNt, METH_VARARGS|METH_KEYWORDS, "CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, { "DenseMatrix_CopyMN", _wrap_DenseMatrix_CopyMN, METH_VARARGS, "\n" "CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco)\n" "CopyMN(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)\n" @@ -18202,23 +17623,23 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CopyMNDiag(DenseMatrix self, double c, int n, int row_offset, int col_offset)\n" "CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset)\n" ""}, - { "DenseMatrix_CopyExceptMN", _wrap_DenseMatrix_CopyExceptMN, METH_VARARGS, "CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, + { "DenseMatrix_CopyExceptMN", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyExceptMN, METH_VARARGS|METH_KEYWORDS, "CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, { "DenseMatrix_AddMatrix", _wrap_DenseMatrix_AddMatrix, METH_VARARGS, "\n" "AddMatrix(DenseMatrix self, DenseMatrix A, int ro, int co)\n" "AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co)\n" ""}, - { "DenseMatrix_AddToVector", _wrap_DenseMatrix_AddToVector, METH_VARARGS, "AddToVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_GetFromVector", _wrap_DenseMatrix_GetFromVector, METH_VARARGS, "GetFromVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_AdjustDofDirection", _wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS, "AdjustDofDirection(DenseMatrix self, intArray dofs)"}, - { "DenseMatrix_Threshold", _wrap_DenseMatrix_Threshold, METH_VARARGS, "Threshold(DenseMatrix self, double eps)"}, + { "DenseMatrix_AddToVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddToVector, METH_VARARGS|METH_KEYWORDS, "AddToVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_GetFromVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetFromVector, METH_VARARGS|METH_KEYWORDS, "GetFromVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_AdjustDofDirection", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS|METH_KEYWORDS, "AdjustDofDirection(DenseMatrix self, intArray dofs)"}, + { "DenseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "Threshold(DenseMatrix self, double eps)"}, { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "CheckFinite(DenseMatrix self) -> int"}, { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "TestInversion(DenseMatrix self)"}, { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "MemoryUsage(DenseMatrix self) -> long"}, - { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_Read", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Read, METH_VARARGS|METH_KEYWORDS, "Read(DenseMatrix self, bool on_dev=True) -> double const *"}, { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "HostRead(DenseMatrix self) -> double const *"}, - { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_Write", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Write, METH_VARARGS|METH_KEYWORDS, "Write(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "HostWrite(DenseMatrix self) -> double *"}, - { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "HostReadWrite(DenseMatrix self) -> double *"}, { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" @@ -18226,8 +17647,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Assign(DenseMatrix self, DenseMatrix m)\n" "Assign(DenseMatrix self, PyObject * numpymat)\n" ""}, - { "DenseMatrix___getitem__", _wrap_DenseMatrix___getitem__, METH_VARARGS, "__getitem__(DenseMatrix self, int const i, int const j) -> double const"}, - { "DenseMatrix___setitem__", _wrap_DenseMatrix___setitem__, METH_VARARGS, "__setitem__(DenseMatrix self, int i, int j, double const v)"}, + { "DenseMatrix___getitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(DenseMatrix self, int const i, int const j) -> double const"}, + { "DenseMatrix___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(DenseMatrix self, int i, int j, double const v)"}, { "DenseMatrix_GetDataArray", _wrap_DenseMatrix_GetDataArray, METH_O, "GetDataArray(DenseMatrix self) -> PyObject *"}, { "DenseMatrix_Print", _wrap_DenseMatrix_Print, METH_VARARGS, "\n" "Print(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -18243,31 +17664,31 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, - { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, - { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, - { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, - { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, - { "CalcInverseTranspose", _wrap_CalcInverseTranspose, METH_VARARGS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, - { "CalcOrtho", _wrap_CalcOrtho, METH_VARARGS, "CalcOrtho(DenseMatrix J, Vector n)"}, - { "MultAAt", _wrap_MultAAt, METH_VARARGS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, - { "MultADAt", _wrap_MultADAt, METH_VARARGS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "AddMultADAt", _wrap_AddMultADAt, METH_VARARGS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "MultABt", _wrap_MultABt, METH_VARARGS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultADBt", _wrap_MultADBt, METH_VARARGS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMultABt", _wrap_AddMultABt, METH_VARARGS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "AddMultADBt", _wrap_AddMultADBt, METH_VARARGS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMult_a_ABt", _wrap_AddMult_a_ABt, METH_VARARGS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultAtB", _wrap_MultAtB, METH_VARARGS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, - { "AddMult_a_AAt", _wrap_AddMult_a_AAt, METH_VARARGS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "Mult_a_AAt", _wrap_Mult_a_AAt, METH_VARARGS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "MultVVt", _wrap_MultVVt, METH_VARARGS, "MultVVt(Vector v, DenseMatrix vvt)"}, - { "MultVWt", _wrap_MultVWt, METH_VARARGS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVWt", _wrap_AddMultVWt, METH_VARARGS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVVt", _wrap_AddMultVVt, METH_VARARGS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, - { "AddMult_a_VWt", _wrap_AddMult_a_VWt, METH_VARARGS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMult_a_VVt", _wrap_AddMult_a_VVt, METH_VARARGS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, + { "LinearSolve", (PyCFunction)(void(*)(void))_wrap_LinearSolve, METH_VARARGS|METH_KEYWORDS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, + { "AddMult", (PyCFunction)(void(*)(void))_wrap_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", (PyCFunction)(void(*)(void))_wrap_AddMult_a, METH_VARARGS|METH_KEYWORDS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "CalcAdjugate", (PyCFunction)(void(*)(void))_wrap_CalcAdjugate, METH_VARARGS|METH_KEYWORDS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, + { "CalcAdjugateTranspose", (PyCFunction)(void(*)(void))_wrap_CalcAdjugateTranspose, METH_VARARGS|METH_KEYWORDS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, + { "CalcInverse", (PyCFunction)(void(*)(void))_wrap_CalcInverse, METH_VARARGS|METH_KEYWORDS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, + { "CalcInverseTranspose", (PyCFunction)(void(*)(void))_wrap_CalcInverseTranspose, METH_VARARGS|METH_KEYWORDS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, + { "CalcOrtho", (PyCFunction)(void(*)(void))_wrap_CalcOrtho, METH_VARARGS|METH_KEYWORDS, "CalcOrtho(DenseMatrix J, Vector n)"}, + { "MultAAt", (PyCFunction)(void(*)(void))_wrap_MultAAt, METH_VARARGS|METH_KEYWORDS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, + { "MultADAt", (PyCFunction)(void(*)(void))_wrap_MultADAt, METH_VARARGS|METH_KEYWORDS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "AddMultADAt", (PyCFunction)(void(*)(void))_wrap_AddMultADAt, METH_VARARGS|METH_KEYWORDS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "MultABt", (PyCFunction)(void(*)(void))_wrap_MultABt, METH_VARARGS|METH_KEYWORDS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultADBt", (PyCFunction)(void(*)(void))_wrap_MultADBt, METH_VARARGS|METH_KEYWORDS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMultABt", (PyCFunction)(void(*)(void))_wrap_AddMultABt, METH_VARARGS|METH_KEYWORDS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "AddMultADBt", (PyCFunction)(void(*)(void))_wrap_AddMultADBt, METH_VARARGS|METH_KEYWORDS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMult_a_ABt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_ABt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultAtB", (PyCFunction)(void(*)(void))_wrap_MultAtB, METH_VARARGS|METH_KEYWORDS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, + { "AddMult_a_AAt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_AAt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "Mult_a_AAt", (PyCFunction)(void(*)(void))_wrap_Mult_a_AAt, METH_VARARGS|METH_KEYWORDS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "MultVVt", (PyCFunction)(void(*)(void))_wrap_MultVVt, METH_VARARGS|METH_KEYWORDS, "MultVVt(Vector v, DenseMatrix vvt)"}, + { "MultVWt", (PyCFunction)(void(*)(void))_wrap_MultVWt, METH_VARARGS|METH_KEYWORDS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVWt", (PyCFunction)(void(*)(void))_wrap_AddMultVWt, METH_VARARGS|METH_KEYWORDS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVVt", (PyCFunction)(void(*)(void))_wrap_AddMultVVt, METH_VARARGS|METH_KEYWORDS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, + { "AddMult_a_VWt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VWt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMult_a_VVt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VVt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, { "LUFactors_data_set", _wrap_LUFactors_data_set, METH_VARARGS, "LUFactors_data_set(LUFactors self, double * data)"}, { "LUFactors_data_get", _wrap_LUFactors_data_get, METH_O, "LUFactors_data_get(LUFactors self) -> double *"}, { "LUFactors_ipiv_set", _wrap_LUFactors_ipiv_set, METH_VARARGS, "LUFactors_ipiv_set(LUFactors self, int * ipiv)"}, @@ -18276,18 +17697,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { "LUFactors()\n" "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" ""}, - { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, - { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "Det(LUFactors self, int m) -> double"}, - { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "Mult(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "USolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "Solve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "RightSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(LUFactors self, int m, double * X)"}, - { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, - { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, - { "LUFactors_BlockForwSolve", _wrap_LUFactors_BlockForwSolve, METH_VARARGS, "BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, - { "LUFactors_BlockBackSolve", _wrap_LUFactors_BlockBackSolve, METH_VARARGS, "BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, + { "LUFactors_Factor", (PyCFunction)(void(*)(void))_wrap_LUFactors_Factor, METH_VARARGS|METH_KEYWORDS, "Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, + { "LUFactors_Det", (PyCFunction)(void(*)(void))_wrap_LUFactors_Det, METH_VARARGS|METH_KEYWORDS, "Det(LUFactors self, int m) -> double"}, + { "LUFactors_Mult", (PyCFunction)(void(*)(void))_wrap_LUFactors_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_LSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_LSolve, METH_VARARGS|METH_KEYWORDS, "LSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_USolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_USolve, METH_VARARGS|METH_KEYWORDS, "USolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_Solve", (PyCFunction)(void(*)(void))_wrap_LUFactors_Solve, METH_VARARGS|METH_KEYWORDS, "Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_RightSolve, METH_VARARGS|METH_KEYWORDS, "RightSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_LUFactors_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "GetInverseMatrix(LUFactors self, int m, double * X)"}, + { "LUFactors_SubMult", (PyCFunction)(void(*)(void))_wrap_LUFactors_SubMult, METH_VARARGS|METH_KEYWORDS, "SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, + { "LUFactors_BlockFactor", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockFactor, METH_VARARGS|METH_KEYWORDS, "BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, + { "LUFactors_BlockForwSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockForwSolve, METH_VARARGS|METH_KEYWORDS, "BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, + { "LUFactors_BlockBackSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockBackSolve, METH_VARARGS|METH_KEYWORDS, "BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, { "delete_LUFactors", _wrap_delete_LUFactors, METH_O, "delete_LUFactors(LUFactors self)"}, { "LUFactors_swigregister", LUFactors_swigregister, METH_O, NULL}, { "LUFactors_swiginit", LUFactors_swiginit, METH_VARARGS, NULL}, @@ -18301,13 +17722,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Factor(DenseMatrixInverse self)\n" "Factor(DenseMatrixInverse self, DenseMatrix mat)\n" ""}, - { "DenseMatrixInverse_SetOperator", _wrap_DenseMatrixInverse_SetOperator, METH_VARARGS, "SetOperator(DenseMatrixInverse self, Operator op)"}, + { "DenseMatrixInverse_SetOperator", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(DenseMatrixInverse self, Operator op)"}, { "DenseMatrixInverse_Mult", _wrap_DenseMatrixInverse_Mult, METH_VARARGS, "\n" "Mult(DenseMatrixInverse self, Vector x, Vector y)\n" "Mult(DenseMatrixInverse self, DenseMatrix B, DenseMatrix X)\n" "Mult(DenseMatrixInverse self, DenseMatrix X)\n" ""}, - { "DenseMatrixInverse_GetInverseMatrix", _wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, + { "DenseMatrixInverse_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, { "DenseMatrixInverse_Det", _wrap_DenseMatrixInverse_Det, METH_O, "Det(DenseMatrixInverse self) -> double"}, { "DenseMatrixInverse_TestInversion", _wrap_DenseMatrixInverse_TestInversion, METH_O, "TestInversion(DenseMatrixInverse self)"}, { "delete_DenseMatrixInverse", _wrap_delete_DenseMatrixInverse, METH_O, "delete_DenseMatrixInverse(DenseMatrixInverse self)"}, @@ -18320,8 +17741,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "DenseMatrixEigensystem_Eval", _wrap_DenseMatrixEigensystem_Eval, METH_O, "Eval(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_Eigenvalues", _wrap_DenseMatrixEigensystem_Eigenvalues, METH_O, "Eigenvalues(DenseMatrixEigensystem self) -> Vector"}, { "DenseMatrixEigensystem_Eigenvectors", _wrap_DenseMatrixEigensystem_Eigenvectors, METH_O, "Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix"}, - { "DenseMatrixEigensystem_Eigenvalue", _wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS, "Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, - { "DenseMatrixEigensystem_Eigenvector", _wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS, "Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, + { "DenseMatrixEigensystem_Eigenvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS|METH_KEYWORDS, "Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, + { "DenseMatrixEigensystem_Eigenvector", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS|METH_KEYWORDS, "Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, { "delete_DenseMatrixEigensystem", _wrap_delete_DenseMatrixEigensystem, METH_O, "delete_DenseMatrixEigensystem(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_swigregister", DenseMatrixEigensystem_swigregister, METH_O, NULL}, { "DenseMatrixEigensystem_swiginit", DenseMatrixEigensystem_swiginit, METH_VARARGS, NULL}, @@ -18329,9 +17750,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DenseMatrixSVD(DenseMatrix M)\n" "new_DenseMatrixSVD(int h, int w) -> DenseMatrixSVD\n" ""}, - { "DenseMatrixSVD_Eval", _wrap_DenseMatrixSVD_Eval, METH_VARARGS, "Eval(DenseMatrixSVD self, DenseMatrix M)"}, + { "DenseMatrixSVD_Eval", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DenseMatrixSVD self, DenseMatrix M)"}, { "DenseMatrixSVD_Singularvalues", _wrap_DenseMatrixSVD_Singularvalues, METH_O, "Singularvalues(DenseMatrixSVD self) -> Vector"}, - { "DenseMatrixSVD_Singularvalue", _wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS, "Singularvalue(DenseMatrixSVD self, int i) -> double"}, + { "DenseMatrixSVD_Singularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS|METH_KEYWORDS, "Singularvalue(DenseMatrixSVD self, int i) -> double"}, { "delete_DenseMatrixSVD", _wrap_delete_DenseMatrixSVD, METH_O, "delete_DenseMatrixSVD(DenseMatrixSVD self)"}, { "DenseMatrixSVD_swigregister", DenseMatrixSVD_swigregister, METH_O, NULL}, { "DenseMatrixSVD_swiginit", DenseMatrixSVD_swiginit, METH_VARARGS, NULL}, @@ -18344,15 +17765,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "DenseTensor_SizeJ", _wrap_DenseTensor_SizeJ, METH_O, "SizeJ(DenseTensor self) -> int"}, { "DenseTensor_SizeK", _wrap_DenseTensor_SizeK, METH_O, "SizeK(DenseTensor self) -> int"}, { "DenseTensor_TotalSize", _wrap_DenseTensor_TotalSize, METH_O, "TotalSize(DenseTensor self) -> int"}, - { "DenseTensor_SetSize", _wrap_DenseTensor_SetSize, METH_VARARGS, "SetSize(DenseTensor self, int i, int j, int k)"}, - { "DenseTensor_UseExternalData", _wrap_DenseTensor_UseExternalData, METH_VARARGS, "UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, + { "DenseTensor_SetSize", (PyCFunction)(void(*)(void))_wrap_DenseTensor_SetSize, METH_VARARGS|METH_KEYWORDS, "SetSize(DenseTensor self, int i, int j, int k)"}, + { "DenseTensor_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_UseExternalData, METH_VARARGS|METH_KEYWORDS, "UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, { "DenseTensor___call__", _wrap_DenseTensor___call__, METH_VARARGS, "\n" "__call__(DenseTensor self, int k) -> DenseMatrix\n" "__call__(DenseTensor self, int k) -> DenseMatrix\n" "__call__(DenseTensor self, int i, int j, int k) -> double\n" "__call__(DenseTensor self, int i, int j, int k) -> double const &\n" ""}, - { "DenseTensor_GetData", _wrap_DenseTensor_GetData, METH_VARARGS, "GetData(DenseTensor self, int k) -> double *"}, + { "DenseTensor_GetData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_GetData, METH_VARARGS|METH_KEYWORDS, "GetData(DenseTensor self, int k) -> double *"}, { "DenseTensor_Data", _wrap_DenseTensor_Data, METH_VARARGS, "\n" "Data(DenseTensor self) -> double\n" "Data(DenseTensor self) -> double const *\n" @@ -18361,22 +17782,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemory(DenseTensor self) -> mfem::Memory< double >\n" "GetMemory(DenseTensor self) -> mfem::Memory< double > const &\n" ""}, - { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, + { "DenseTensor_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseTensor_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "Clear(DenseTensor self)"}, { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "MemoryUsage(DenseTensor self) -> long"}, - { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_Read", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Read, METH_VARARGS|METH_KEYWORDS, "Read(DenseTensor self, bool on_dev=True) -> double const *"}, { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "HostRead(DenseTensor self) -> double const *"}, - { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_Write", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Write, METH_VARARGS|METH_KEYWORDS, "Write(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "HostWrite(DenseTensor self) -> double *"}, - { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseTensor_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "HostReadWrite(DenseTensor self) -> double *"}, { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, - { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "Assign(DenseTensor self, double const c)"}, + { "DenseTensor_Assign", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Assign, METH_VARARGS|METH_KEYWORDS, "Assign(DenseTensor self, double const c)"}, { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" "__getitem__(DenseTensor self, int const i, int const j, int const k) -> double const\n" "__getitem__(DenseTensor self, int const k) -> DenseMatrix\n" ""}, - { "DenseTensor___setitem__", _wrap_DenseTensor___setitem__, METH_VARARGS, "__setitem__(DenseTensor self, int i, int j, int k, double const v)"}, + { "DenseTensor___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseTensor___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(DenseTensor self, int i, int j, int k, double const v)"}, { "DenseTensor_GetDataArray", _wrap_DenseTensor_GetDataArray, METH_O, "GetDataArray(DenseTensor self) -> PyObject *"}, { "DenseTensor_swigregister", DenseTensor_swigregister, METH_O, NULL}, { "DenseTensor_swiginit", DenseTensor_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/device.py b/mfem/_par/device.py index 4b9d2c0b..2cb2b66e 100644 --- a/mfem/_par/device.py +++ b/mfem/_par/device.py @@ -110,8 +110,8 @@ def Configure(self, device, dev=0): return _device.Device_Configure(self, device, dev) Configure = _swig_new_instance_method(_device.Device_Configure) - def Print(self, *args): - return _device.Device_Print(self, *args) + def Print(self, *args, **kwargs): + return _device.Device_Print(self, *args, **kwargs) Print = _swig_new_instance_method(_device.Device_Print) @staticmethod diff --git a/mfem/_par/device_wrap.cxx b/mfem/_par/device_wrap.cxx index 8b6f5deb..e85de6b5 100644 --- a/mfem/_par/device_wrap.cxx +++ b/mfem/_par/device_wrap.cxx @@ -3111,14 +3111,14 @@ SWIGINTERN PyObject *_wrap_new_Device__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py SWIGINTERN PyObject *_wrap_new_Device__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; - int arg2 ; + int arg2 = (int) (int)0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mfem::Device *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); @@ -3127,53 +3127,16 @@ SWIGINTERN PyObject *_wrap_new_Device__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); } arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Device" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - try { - result = (mfem::Device *)new mfem::Device((std::string const &)*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Device, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Device__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::Device *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Device" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - arg1 = reinterpret_cast< std::string * >(argp1); { try { - result = (mfem::Device *)new mfem::Device((std::string const &)*arg1); + result = (mfem::Device *)new mfem::Device((std::string const &)*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3205,19 +3168,14 @@ SWIGINTERN PyObject *_wrap_new_Device(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Device__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Device__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_Device__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); @@ -3232,8 +3190,7 @@ SWIGINTERN PyObject *_wrap_new_Device(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Device'.\n" " Possible C/C++ prototypes are:\n" " mfem::Device::Device()\n" - " mfem::Device::Device(std::string const &,int const)\n" - " mfem::Device::Device(std::string const &)\n"); + " mfem::Device::Device(std::string const &,int const)\n"); return 0; } @@ -3275,25 +3232,31 @@ SWIGINTERN PyObject *_wrap_delete_Device(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Device_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Device *arg1 = (mfem::Device *) 0 ; std::string *arg2 = 0 ; - int arg3 ; + int arg3 = (int) (int)0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"device", (char *)"dev", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Device_Configure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Configure" "', argument " "1"" of type '" "mfem::Device *""'"); } arg1 = reinterpret_cast< mfem::Device * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); } @@ -3301,11 +3264,13 @@ SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); } arg2 = reinterpret_cast< std::string * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Device_Configure" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (obj2) { + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Device_Configure" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { (arg1)->Configure((std::string const &)*arg2,arg3); @@ -3329,163 +3294,40 @@ SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Device_Print(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Device *arg1 = (mfem::Device *) 0 ; - std::string *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Configure" "', argument " "1"" of type '" "mfem::Device *""'"); - } - arg1 = reinterpret_cast< mfem::Device * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = reinterpret_cast< std::string * >(argp2); - { - try { - (arg1)->Configure((std::string const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Device_Configure(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Device_Configure", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Device_Configure__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Device_Configure__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_Configure'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Device::Configure(std::string const &,int const)\n" - " mfem::Device::Configure(std::string const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Device_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Device *arg1 = (mfem::Device *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Device_Print", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Print" "', argument " "1"" of type '" "mfem::Device *""'"); } arg1 = reinterpret_cast< mfem::Device * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - { - try { - (arg1)->Print(*arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg2 = reinterpret_cast< std::ostream * >(argp2); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Device_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Device *arg1 = (mfem::Device *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Print" "', argument " "1"" of type '" "mfem::Device *""'"); - } - arg1 = reinterpret_cast< mfem::Device * >(argp1); { try { - (arg1)->Print(); + (arg1)->Print(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3506,47 +3348,6 @@ SWIGINTERN PyObject *_wrap_Device_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Device_Print(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Device_Print", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Device_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Device_Print__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_Print'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Device::Print(std::ostream &)\n" - " mfem::Device::Print()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Device_IsConfigured(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; bool result; @@ -3659,17 +3460,19 @@ SWIGINTERN PyObject *_wrap_Device_IsDisabled(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Device_Allows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Device_Allows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; unsigned long arg1 ; unsigned long val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_mask", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Device_Allows", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_Allows" "', argument " "1"" of type '" "unsigned long""'"); } @@ -3865,48 +3668,27 @@ SWIGINTERN PyObject *_wrap_Device_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - bool arg1 ; + bool arg1 = (bool) (bool)true ; bool val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"force", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_SetGPUAwareMPI" "', argument " "1"" of type '" "bool""'"); - } - arg1 = static_cast< bool >(val1); - { - try { - mfem::Device::SetGPUAwareMPI(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:Device_SetGPUAwareMPI", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_bool(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_SetGPUAwareMPI" "', argument " "1"" of type '" "bool""'"); + } + arg1 = static_cast< bool >(val1); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - mfem::Device::SetGPUAwareMPI(); + mfem::Device::SetGPUAwareMPI(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3927,37 +3709,6 @@ SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Device_SetGPUAwareMPI", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_Device_SetGPUAwareMPI__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_bool(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Device_SetGPUAwareMPI__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_SetGPUAwareMPI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Device::SetGPUAwareMPI(bool const)\n" - " mfem::Device::SetGPUAwareMPI()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Device_GetGPUAwareMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; bool result; @@ -4006,20 +3757,20 @@ static PyMethodDef SwigMethods[] = { { "Backend_swiginit", Backend_swiginit, METH_VARARGS, NULL}, { "new_Device", _wrap_new_Device, METH_VARARGS, NULL}, { "delete_Device", _wrap_delete_Device, METH_O, NULL}, - { "Device_Configure", _wrap_Device_Configure, METH_VARARGS, NULL}, - { "Device_Print", _wrap_Device_Print, METH_VARARGS, NULL}, + { "Device_Configure", (PyCFunction)(void(*)(void))_wrap_Device_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, + { "Device_Print", (PyCFunction)(void(*)(void))_wrap_Device_Print, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_IsConfigured", _wrap_Device_IsConfigured, METH_NOARGS, NULL}, { "Device_IsAvailable", _wrap_Device_IsAvailable, METH_NOARGS, NULL}, { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, - { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_Allows", (PyCFunction)(void(*)(void))_wrap_Device_Allows, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, - { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_SetGPUAwareMPI", (PyCFunction)(void(*)(void))_wrap_Device_SetGPUAwareMPI, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, { "Device_swigregister", Device_swigregister, METH_O, NULL}, { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, @@ -4035,20 +3786,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Backend_swiginit", Backend_swiginit, METH_VARARGS, NULL}, { "new_Device", _wrap_new_Device, METH_VARARGS, NULL}, { "delete_Device", _wrap_delete_Device, METH_O, NULL}, - { "Device_Configure", _wrap_Device_Configure, METH_VARARGS, NULL}, - { "Device_Print", _wrap_Device_Print, METH_VARARGS, NULL}, + { "Device_Configure", (PyCFunction)(void(*)(void))_wrap_Device_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, + { "Device_Print", (PyCFunction)(void(*)(void))_wrap_Device_Print, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_IsConfigured", _wrap_Device_IsConfigured, METH_NOARGS, NULL}, { "Device_IsAvailable", _wrap_Device_IsAvailable, METH_NOARGS, NULL}, { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, - { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_Allows", (PyCFunction)(void(*)(void))_wrap_Device_Allows, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, - { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_SetGPUAwareMPI", (PyCFunction)(void(*)(void))_wrap_Device_SetGPUAwareMPI, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, { "Device_swigregister", Device_swigregister, METH_O, NULL}, { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/element_wrap.cxx b/mfem/_par/element_wrap.cxx index a1516a9d..1a11d77c 100644 --- a/mfem/_par/element_wrap.cxx +++ b/mfem/_par/element_wrap.cxx @@ -3327,25 +3327,29 @@ SWIGINTERN PyObject *_wrap_Element_GetAttribute(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Element_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_SetAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_SetAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_SetAttribute" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3367,7 +3371,7 @@ SWIGINTERN PyObject *_wrap_Element_SetAttribute(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Element_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int *arg2 = (int *) 0 ; @@ -3375,15 +3379,19 @@ SWIGINTERN PyObject *_wrap_Element_SetVertices(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ind", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_SetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_SetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_SetVertices" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_SetVertices" "', argument " "2"" of type '" "int const *""'"); } @@ -3638,26 +3646,30 @@ SWIGINTERN PyObject *_wrap_Element_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Element_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Element_GetEdgeVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_GetEdgeVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3797,26 +3809,30 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Element_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_GetNFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3838,26 +3854,30 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Element_GetFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_GetFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetFaceVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3879,7 +3899,7 @@ SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; mfem::DSTable *arg2 = 0 ; @@ -3890,15 +3910,20 @@ SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v_to_v", (char *)"length", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_MarkEdge", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Element_MarkEdge", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_MarkEdge" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DSTable, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DSTable, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_MarkEdge" "', argument " "2"" of type '" "mfem::DSTable const &""'"); } @@ -3906,7 +3931,7 @@ SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Element_MarkEdge" "', argument " "2"" of type '" "mfem::DSTable const &""'"); } arg2 = reinterpret_cast< mfem::DSTable * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Element_MarkEdge" "', argument " "3"" of type '" "int const *""'"); } @@ -3931,7 +3956,7 @@ SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; mfem::HashTable< mfem::Hashed2 > *arg2 = 0 ; @@ -3939,16 +3964,20 @@ SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v_to_v", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Element_NeedRefinement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_NeedRefinement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_NeedRefinement" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HashTableT_mfem__Hashed2_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HashTableT_mfem__Hashed2_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_NeedRefinement" "', argument " "2"" of type '" "mfem::HashTable< mfem::Hashed2 > &""'"); } @@ -3976,25 +4005,29 @@ SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Element_ResetTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_ResetTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_ResetTransform", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_ResetTransform", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_ResetTransform" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4016,25 +4049,29 @@ SWIGINTERN PyObject *_wrap_Element_ResetTransform(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Element_PushTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_PushTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_PushTransform", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_PushTransform", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_PushTransform" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4091,7 +4128,7 @@ SWIGINTERN PyObject *_wrap_Element_GetTransform(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Element_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -4099,16 +4136,20 @@ SWIGINTERN PyObject *_wrap_Element_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::Element *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Element_Duplicate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_Duplicate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_Duplicate" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_Duplicate" "', argument " "2"" of type '" "mfem::Mesh *""'"); } @@ -4215,8 +4256,8 @@ static PyMethodDef SwigMethods[] = { { "Element_GetType", _wrap_Element_GetType, METH_O, "Element_GetType(Element self) -> mfem::Element::Type"}, { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "Element_GetGeometryType(Element self) -> mfem::Geometry::Type"}, { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "Element_GetAttribute(Element self) -> int"}, - { "Element_SetAttribute", _wrap_Element_SetAttribute, METH_VARARGS, "Element_SetAttribute(Element self, int const attr)"}, - { "Element_SetVertices", _wrap_Element_SetVertices, METH_VARARGS, "Element_SetVertices(Element self, int const * ind)"}, + { "Element_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Element_SetAttribute, METH_VARARGS|METH_KEYWORDS, "Element_SetAttribute(Element self, int const attr)"}, + { "Element_SetVertices", (PyCFunction)(void(*)(void))_wrap_Element_SetVertices, METH_VARARGS|METH_KEYWORDS, "Element_SetVertices(Element self, int const * ind)"}, { "Element_GetVertices", _wrap_Element_GetVertices, METH_VARARGS, "\n" "Element_GetVertices(Element self, intArray v)\n" "Element_GetVertices(Element self) -> int\n" @@ -4224,19 +4265,19 @@ static PyMethodDef SwigMethods[] = { ""}, { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "Element_GetNVertices(Element self) -> int"}, { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "Element_GetNEdges(Element self) -> int"}, - { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "Element_GetEdgeVertices(Element self, int arg2) -> int const *"}, + { "Element_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Element_GetEdgeVertices(Element self, int arg2) -> int const *"}, { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" "Element_GetNFaces(Element self, int & nFaceVertices) -> int\n" "Element_GetNFaces(Element self) -> int\n" ""}, - { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "Element_GetNFaceVertices(Element self, int fi) -> int"}, - { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "Element_GetFaceVertices(Element self, int fi) -> int const *"}, - { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "Element_MarkEdge(Element self, DSTable v_to_v, int const * length)"}, - { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "Element_NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, - { "Element_ResetTransform", _wrap_Element_ResetTransform, METH_VARARGS, "Element_ResetTransform(Element self, int tr)"}, - { "Element_PushTransform", _wrap_Element_PushTransform, METH_VARARGS, "Element_PushTransform(Element self, int tr)"}, + { "Element_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "Element_GetNFaceVertices(Element self, int fi) -> int"}, + { "Element_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Element_GetFaceVertices(Element self, int fi) -> int const *"}, + { "Element_MarkEdge", (PyCFunction)(void(*)(void))_wrap_Element_MarkEdge, METH_VARARGS|METH_KEYWORDS, "Element_MarkEdge(Element self, DSTable v_to_v, int const * length)"}, + { "Element_NeedRefinement", (PyCFunction)(void(*)(void))_wrap_Element_NeedRefinement, METH_VARARGS|METH_KEYWORDS, "Element_NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, + { "Element_ResetTransform", (PyCFunction)(void(*)(void))_wrap_Element_ResetTransform, METH_VARARGS|METH_KEYWORDS, "Element_ResetTransform(Element self, int tr)"}, + { "Element_PushTransform", (PyCFunction)(void(*)(void))_wrap_Element_PushTransform, METH_VARARGS|METH_KEYWORDS, "Element_PushTransform(Element self, int tr)"}, { "Element_GetTransform", _wrap_Element_GetTransform, METH_O, "Element_GetTransform(Element self) -> unsigned int"}, - { "Element_Duplicate", _wrap_Element_Duplicate, METH_VARARGS, "Element_Duplicate(Element self, mfem::Mesh * m) -> Element"}, + { "Element_Duplicate", (PyCFunction)(void(*)(void))_wrap_Element_Duplicate, METH_VARARGS|METH_KEYWORDS, "Element_Duplicate(Element self, mfem::Mesh * m) -> Element"}, { "delete_Element", _wrap_delete_Element, METH_O, "delete_Element(Element self)"}, { "Element_GetVerticesArray", _wrap_Element_GetVerticesArray, METH_O, "Element_GetVerticesArray(Element self) -> PyObject *"}, { "Element_swigregister", Element_swigregister, METH_O, NULL}, @@ -4249,8 +4290,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Element_GetType", _wrap_Element_GetType, METH_O, "GetType(Element self) -> mfem::Element::Type"}, { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "GetGeometryType(Element self) -> mfem::Geometry::Type"}, { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "GetAttribute(Element self) -> int"}, - { "Element_SetAttribute", _wrap_Element_SetAttribute, METH_VARARGS, "SetAttribute(Element self, int const attr)"}, - { "Element_SetVertices", _wrap_Element_SetVertices, METH_VARARGS, "SetVertices(Element self, int const * ind)"}, + { "Element_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Element_SetAttribute, METH_VARARGS|METH_KEYWORDS, "SetAttribute(Element self, int const attr)"}, + { "Element_SetVertices", (PyCFunction)(void(*)(void))_wrap_Element_SetVertices, METH_VARARGS|METH_KEYWORDS, "SetVertices(Element self, int const * ind)"}, { "Element_GetVertices", _wrap_Element_GetVertices, METH_VARARGS, "\n" "GetVertices(Element self, intArray v)\n" "GetVertices(Element self) -> int\n" @@ -4258,19 +4299,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "GetNVertices(Element self) -> int"}, { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "GetNEdges(Element self) -> int"}, - { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Element self, int arg2) -> int const *"}, + { "Element_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Element self, int arg2) -> int const *"}, { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" "GetNFaces(Element self, int & nFaceVertices) -> int\n" "GetNFaces(Element self) -> int\n" ""}, - { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Element self, int fi) -> int"}, - { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Element self, int fi) -> int const *"}, - { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "MarkEdge(Element self, DSTable v_to_v, int const * length)"}, - { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, - { "Element_ResetTransform", _wrap_Element_ResetTransform, METH_VARARGS, "ResetTransform(Element self, int tr)"}, - { "Element_PushTransform", _wrap_Element_PushTransform, METH_VARARGS, "PushTransform(Element self, int tr)"}, + { "Element_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetNFaceVertices(Element self, int fi) -> int"}, + { "Element_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Element self, int fi) -> int const *"}, + { "Element_MarkEdge", (PyCFunction)(void(*)(void))_wrap_Element_MarkEdge, METH_VARARGS|METH_KEYWORDS, "MarkEdge(Element self, DSTable v_to_v, int const * length)"}, + { "Element_NeedRefinement", (PyCFunction)(void(*)(void))_wrap_Element_NeedRefinement, METH_VARARGS|METH_KEYWORDS, "NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, + { "Element_ResetTransform", (PyCFunction)(void(*)(void))_wrap_Element_ResetTransform, METH_VARARGS|METH_KEYWORDS, "ResetTransform(Element self, int tr)"}, + { "Element_PushTransform", (PyCFunction)(void(*)(void))_wrap_Element_PushTransform, METH_VARARGS|METH_KEYWORDS, "PushTransform(Element self, int tr)"}, { "Element_GetTransform", _wrap_Element_GetTransform, METH_O, "GetTransform(Element self) -> unsigned int"}, - { "Element_Duplicate", _wrap_Element_Duplicate, METH_VARARGS, "Duplicate(Element self, mfem::Mesh * m) -> Element"}, + { "Element_Duplicate", (PyCFunction)(void(*)(void))_wrap_Element_Duplicate, METH_VARARGS|METH_KEYWORDS, "Duplicate(Element self, mfem::Mesh * m) -> Element"}, { "delete_Element", _wrap_delete_Element, METH_O, "delete_Element(Element self)"}, { "Element_GetVerticesArray", _wrap_Element_GetVerticesArray, METH_O, "GetVerticesArray(Element self) -> PyObject *"}, { "Element_swigregister", Element_swigregister, METH_O, NULL}, diff --git a/mfem/_par/eltrans_wrap.cxx b/mfem/_par/eltrans_wrap.cxx index d30a1b34..121ce242 100644 --- a/mfem/_par/eltrans_wrap.cxx +++ b/mfem/_par/eltrans_wrap.cxx @@ -3557,7 +3557,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_ElementNo_get(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ElementTransformation_SetIntPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementTransformation_SetIntPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; mfem::IntegrationPoint *arg2 = (mfem::IntegrationPoint *) 0 ; @@ -3565,15 +3565,19 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_SetIntPoint(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementTransformation_SetIntPoint", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElementTransformation_SetIntPoint", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_SetIntPoint" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementTransformation_SetIntPoint" "', argument " "2"" of type '" "mfem::IntegrationPoint const *""'"); } @@ -4148,7 +4152,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_OrderW(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ElementTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; mfem::FiniteElement *arg2 = (mfem::FiniteElement *) 0 ; @@ -4156,16 +4160,20 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_OrderGrad(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ElementTransformation_OrderGrad", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElementTransformation_OrderGrad", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_OrderGrad" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementTransformation_OrderGrad" "', argument " "2"" of type '" "mfem::FiniteElement const *""'"); } @@ -4295,7 +4303,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_GetSpaceDim(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4306,16 +4314,21 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ip", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ElementTransformation_TransformBack", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementTransformation_TransformBack", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_TransformBack" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4323,7 +4336,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementTransformation_TransformBack" "', argument " "3"" of type '" "mfem::IntegrationPoint &""'"); } @@ -4392,47 +4405,28 @@ SWIGINTERN PyObject *ElementTransformation_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_InverseElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_InverseElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; + mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) NULL ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"Trans", NULL + }; mfem::InverseElementTransformation *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseElementTransformation" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); - } - arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - { - try { - result = (mfem::InverseElementTransformation *)new mfem::InverseElementTransformation(arg1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_InverseElementTransformation", kwnames, &obj0)) SWIG_fail; + if (obj0) { + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseElementTransformation" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseElementTransformation, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_InverseElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::InverseElementTransformation *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::InverseElementTransformation *)new mfem::InverseElementTransformation(); + result = (mfem::InverseElementTransformation *)new mfem::InverseElementTransformation(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4450,36 +4444,6 @@ SWIGINTERN PyObject *_wrap_new_InverseElementTransformation__SWIG_1(PyObject *SW } -SWIGINTERN PyObject *_wrap_new_InverseElementTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseElementTransformation", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_InverseElementTransformation__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElementTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_InverseElementTransformation__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseElementTransformation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::InverseElementTransformation::InverseElementTransformation(mfem::ElementTransformation *)\n" - " mfem::InverseElementTransformation::InverseElementTransformation()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_InverseElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; @@ -4514,7 +4478,7 @@ SWIGINTERN PyObject *_wrap_delete_InverseElementTransformation(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -4522,15 +4486,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetTransformation" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_SetTransformation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -4558,7 +4526,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObje } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::InverseElementTransformation::InitGuessType arg2 ; @@ -4566,15 +4534,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"itype", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitialGuessType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitialGuessType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitialGuessType" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetInitialGuessType" "', argument " "2"" of type '" "mfem::InverseElementTransformation::InitGuessType""'"); } @@ -4599,7 +4571,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyOb } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -4607,15 +4579,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"init_ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitialGuess", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitialGuess", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitialGuess" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_SetInitialGuess" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4643,25 +4619,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessPointsType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessPointsType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q_type", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitGuessPointsType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitGuessPointsType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitGuessPointsType" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4683,25 +4663,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessPointsType(P } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessRelOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessRelOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"order", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitGuessRelOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitGuessRelOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitGuessRelOrder" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4723,7 +4707,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessRelOrder(PyO } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::InverseElementTransformation::SolverType arg2 ; @@ -4731,15 +4715,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"stype", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetSolverType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetSolverType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetSolverType" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetSolverType" "', argument " "2"" of type '" "mfem::InverseElementTransformation::SolverType""'"); } @@ -4764,25 +4752,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject * } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_it", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetMaxIter" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4804,7 +4796,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetMaxIter(PyObject *SWI } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; double arg2 ; @@ -4812,15 +4804,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ref_sp_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetReferenceTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetReferenceTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetReferenceTol" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetReferenceTol" "', argument " "2"" of type '" "double""'"); } @@ -4845,7 +4841,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; double arg2 ; @@ -4853,15 +4849,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"phys_rel_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetPhysicalRelTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetPhysicalRelTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetPhysicalRelTol" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetPhysicalRelTol" "', argument " "2"" of type '" "double""'"); } @@ -4886,7 +4886,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObje } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; double arg2 ; @@ -4894,15 +4894,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject * int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetElementTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetElementTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetElementTol" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetElementTol" "', argument " "2"" of type '" "double""'"); } @@ -4927,25 +4931,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject * } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetPrintLevel" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4967,7 +4975,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPrintLevel(PyObject * } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4978,16 +4986,21 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ir", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_FindClosestPhysPoint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseElementTransformation_FindClosestPhysPoint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4995,7 +5008,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } @@ -5023,7 +5036,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyO } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5034,16 +5047,21 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ir", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_FindClosestRefPoint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseElementTransformation_FindClosestRefPoint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5051,7 +5069,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } @@ -5079,7 +5097,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyOb } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5090,16 +5108,21 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ip", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_Transform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseElementTransformation_Transform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_Transform" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_Transform" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5107,7 +5130,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseElementTransformation_Transform" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseElementTransformation_Transform" "', argument " "3"" of type '" "mfem::IntegrationPoint &""'"); } @@ -5146,7 +5169,7 @@ SWIGINTERN PyObject *InverseElementTransformation_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::FiniteElement *arg2 = (mfem::FiniteElement *) 0 ; @@ -5154,15 +5177,19 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetFE(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FE", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_SetFE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IsoparametricTransformation_SetFE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_SetFE" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsoparametricTransformation_SetFE" "', argument " "2"" of type '" "mfem::FiniteElement const *""'"); } @@ -5291,7 +5318,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_FinalizeTransformation(Py } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetIdentityTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetIdentityTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::Geometry::Type arg2 ; @@ -5299,15 +5326,19 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetIdentityTransformation int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_SetIdentityTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IsoparametricTransformation_SetIdentityTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_SetIdentityTransformation" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IsoparametricTransformation_SetIdentityTransformation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -5672,7 +5703,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderW(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::FiniteElement *arg2 = (mfem::FiniteElement *) 0 ; @@ -5680,16 +5711,20 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_OrderGrad", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IsoparametricTransformation_OrderGrad", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_OrderGrad" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsoparametricTransformation_OrderGrad" "', argument " "2"" of type '" "mfem::FiniteElement const *""'"); } @@ -5714,7 +5749,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5725,16 +5760,21 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", (char *)"ip", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_TransformBack", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IsoparametricTransformation_TransformBack", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_TransformBack" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsoparametricTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5742,7 +5782,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IsoparametricTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IsoparametricTransformation_TransformBack" "', argument " "3"" of type '" "mfem::IntegrationPoint &""'"); } @@ -6614,7 +6654,7 @@ static PyMethodDef SwigMethods[] = { { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, { "ElementTransformation_ElementNo_get", _wrap_ElementTransformation_ElementNo_get, METH_O, "ElementTransformation_ElementNo_get(ElementTransformation self) -> int"}, - { "ElementTransformation_SetIntPoint", _wrap_ElementTransformation_SetIntPoint, METH_VARARGS, "ElementTransformation_SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, + { "ElementTransformation_SetIntPoint", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_SetIntPoint, METH_VARARGS|METH_KEYWORDS, "ElementTransformation_SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, { "ElementTransformation_GetIntPoint", _wrap_ElementTransformation_GetIntPoint, METH_O, "ElementTransformation_GetIntPoint(ElementTransformation self) -> IntegrationPoint"}, { "ElementTransformation_Transform", _wrap_ElementTransformation_Transform, METH_VARARGS, "\n" "ElementTransformation_Transform(ElementTransformation self, IntegrationPoint arg2, Vector arg3)\n" @@ -6629,36 +6669,36 @@ static PyMethodDef SwigMethods[] = { { "ElementTransformation_Order", _wrap_ElementTransformation_Order, METH_O, "ElementTransformation_Order(ElementTransformation self) -> int"}, { "ElementTransformation_OrderJ", _wrap_ElementTransformation_OrderJ, METH_O, "ElementTransformation_OrderJ(ElementTransformation self) -> int"}, { "ElementTransformation_OrderW", _wrap_ElementTransformation_OrderW, METH_O, "ElementTransformation_OrderW(ElementTransformation self) -> int"}, - { "ElementTransformation_OrderGrad", _wrap_ElementTransformation_OrderGrad, METH_VARARGS, "ElementTransformation_OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, + { "ElementTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "ElementTransformation_OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, { "ElementTransformation_GetGeometryType", _wrap_ElementTransformation_GetGeometryType, METH_O, "ElementTransformation_GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type"}, { "ElementTransformation_GetDimension", _wrap_ElementTransformation_GetDimension, METH_O, "ElementTransformation_GetDimension(ElementTransformation self) -> int"}, { "ElementTransformation_GetSpaceDim", _wrap_ElementTransformation_GetSpaceDim, METH_O, "ElementTransformation_GetSpaceDim(ElementTransformation self) -> int"}, - { "ElementTransformation_TransformBack", _wrap_ElementTransformation_TransformBack, METH_VARARGS, "ElementTransformation_TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "ElementTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "ElementTransformation_TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "delete_ElementTransformation", _wrap_delete_ElementTransformation, METH_O, "delete_ElementTransformation(ElementTransformation self)"}, { "ElementTransformation_swigregister", ElementTransformation_swigregister, METH_O, NULL}, - { "new_InverseElementTransformation", _wrap_new_InverseElementTransformation, METH_VARARGS, "InverseElementTransformation(ElementTransformation Trans=None)"}, + { "new_InverseElementTransformation", (PyCFunction)(void(*)(void))_wrap_new_InverseElementTransformation, METH_VARARGS|METH_KEYWORDS, "new_InverseElementTransformation(ElementTransformation Trans=None) -> InverseElementTransformation"}, { "delete_InverseElementTransformation", _wrap_delete_InverseElementTransformation, METH_O, "delete_InverseElementTransformation(InverseElementTransformation self)"}, - { "InverseElementTransformation_SetTransformation", _wrap_InverseElementTransformation_SetTransformation, METH_VARARGS, "InverseElementTransformation_SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, - { "InverseElementTransformation_SetInitialGuessType", _wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS, "InverseElementTransformation_SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, - { "InverseElementTransformation_SetInitialGuess", _wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS, "InverseElementTransformation_SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, - { "InverseElementTransformation_SetInitGuessPointsType", _wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS, "InverseElementTransformation_SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, - { "InverseElementTransformation_SetInitGuessRelOrder", _wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS, "InverseElementTransformation_SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, - { "InverseElementTransformation_SetSolverType", _wrap_InverseElementTransformation_SetSolverType, METH_VARARGS, "InverseElementTransformation_SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, - { "InverseElementTransformation_SetMaxIter", _wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS, "InverseElementTransformation_SetMaxIter(InverseElementTransformation self, int max_it)"}, - { "InverseElementTransformation_SetReferenceTol", _wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS, "InverseElementTransformation_SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, - { "InverseElementTransformation_SetPhysicalRelTol", _wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS, "InverseElementTransformation_SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, - { "InverseElementTransformation_SetElementTol", _wrap_InverseElementTransformation_SetElementTol, METH_VARARGS, "InverseElementTransformation_SetElementTol(InverseElementTransformation self, double el_tol)"}, - { "InverseElementTransformation_SetPrintLevel", _wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS, "InverseElementTransformation_SetPrintLevel(InverseElementTransformation self, int pr_level)"}, - { "InverseElementTransformation_FindClosestPhysPoint", _wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS, "InverseElementTransformation_FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_FindClosestRefPoint", _wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS, "InverseElementTransformation_FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_Transform", _wrap_InverseElementTransformation_Transform, METH_VARARGS, "InverseElementTransformation_Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "InverseElementTransformation_SetTransformation", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetTransformation, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, + { "InverseElementTransformation_SetInitialGuessType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, + { "InverseElementTransformation_SetInitialGuess", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, + { "InverseElementTransformation_SetInitGuessPointsType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, + { "InverseElementTransformation_SetInitGuessRelOrder", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, + { "InverseElementTransformation_SetSolverType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetSolverType, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, + { "InverseElementTransformation_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetMaxIter(InverseElementTransformation self, int max_it)"}, + { "InverseElementTransformation_SetReferenceTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, + { "InverseElementTransformation_SetPhysicalRelTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, + { "InverseElementTransformation_SetElementTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetElementTol, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetElementTol(InverseElementTransformation self, double el_tol)"}, + { "InverseElementTransformation_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetPrintLevel(InverseElementTransformation self, int pr_level)"}, + { "InverseElementTransformation_FindClosestPhysPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_FindClosestRefPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_Transform", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_Transform, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "InverseElementTransformation_swigregister", InverseElementTransformation_swigregister, METH_O, NULL}, { "InverseElementTransformation_swiginit", InverseElementTransformation_swiginit, METH_VARARGS, NULL}, - { "IsoparametricTransformation_SetFE", _wrap_IsoparametricTransformation_SetFE, METH_VARARGS, "IsoparametricTransformation_SetFE(IsoparametricTransformation self, FiniteElement FE)"}, + { "IsoparametricTransformation_SetFE", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetFE, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_SetFE(IsoparametricTransformation self, FiniteElement FE)"}, { "IsoparametricTransformation_GetFE", _wrap_IsoparametricTransformation_GetFE, METH_O, "IsoparametricTransformation_GetFE(IsoparametricTransformation self) -> FiniteElement"}, { "IsoparametricTransformation_GetPointMat", _wrap_IsoparametricTransformation_GetPointMat, METH_O, "IsoparametricTransformation_GetPointMat(IsoparametricTransformation self) -> DenseMatrix"}, { "IsoparametricTransformation_FinalizeTransformation", _wrap_IsoparametricTransformation_FinalizeTransformation, METH_O, "IsoparametricTransformation_FinalizeTransformation(IsoparametricTransformation self)"}, - { "IsoparametricTransformation_SetIdentityTransformation", _wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS, "IsoparametricTransformation_SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, + { "IsoparametricTransformation_SetIdentityTransformation", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, { "IsoparametricTransformation_Transform", _wrap_IsoparametricTransformation_Transform, METH_VARARGS, "\n" "IsoparametricTransformation_Transform(IsoparametricTransformation self, IntegrationPoint arg2, Vector arg3)\n" "IsoparametricTransformation_Transform(IsoparametricTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" @@ -6667,8 +6707,8 @@ static PyMethodDef SwigMethods[] = { { "IsoparametricTransformation_Order", _wrap_IsoparametricTransformation_Order, METH_O, "IsoparametricTransformation_Order(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderJ", _wrap_IsoparametricTransformation_OrderJ, METH_O, "IsoparametricTransformation_OrderJ(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderW", _wrap_IsoparametricTransformation_OrderW, METH_O, "IsoparametricTransformation_OrderW(IsoparametricTransformation self) -> int"}, - { "IsoparametricTransformation_OrderGrad", _wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS, "IsoparametricTransformation_OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, - { "IsoparametricTransformation_TransformBack", _wrap_IsoparametricTransformation_TransformBack, METH_VARARGS, "IsoparametricTransformation_TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, + { "IsoparametricTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, + { "IsoparametricTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, { "delete_IsoparametricTransformation", _wrap_delete_IsoparametricTransformation, METH_O, "delete_IsoparametricTransformation(IsoparametricTransformation self)"}, { "new_IsoparametricTransformation", _wrap_new_IsoparametricTransformation, METH_NOARGS, "new_IsoparametricTransformation() -> IsoparametricTransformation"}, { "IsoparametricTransformation_swigregister", IsoparametricTransformation_swigregister, METH_O, NULL}, @@ -6713,7 +6753,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, { "ElementTransformation_ElementNo_get", _wrap_ElementTransformation_ElementNo_get, METH_O, "ElementTransformation_ElementNo_get(ElementTransformation self) -> int"}, - { "ElementTransformation_SetIntPoint", _wrap_ElementTransformation_SetIntPoint, METH_VARARGS, "SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, + { "ElementTransformation_SetIntPoint", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_SetIntPoint, METH_VARARGS|METH_KEYWORDS, "SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, { "ElementTransformation_GetIntPoint", _wrap_ElementTransformation_GetIntPoint, METH_O, "GetIntPoint(ElementTransformation self) -> IntegrationPoint"}, { "ElementTransformation_Transform", _wrap_ElementTransformation_Transform, METH_VARARGS, "\n" "Transform(ElementTransformation self, IntegrationPoint arg2, Vector arg3)\n" @@ -6728,36 +6768,36 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "ElementTransformation_Order", _wrap_ElementTransformation_Order, METH_O, "Order(ElementTransformation self) -> int"}, { "ElementTransformation_OrderJ", _wrap_ElementTransformation_OrderJ, METH_O, "OrderJ(ElementTransformation self) -> int"}, { "ElementTransformation_OrderW", _wrap_ElementTransformation_OrderW, METH_O, "OrderW(ElementTransformation self) -> int"}, - { "ElementTransformation_OrderGrad", _wrap_ElementTransformation_OrderGrad, METH_VARARGS, "OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, + { "ElementTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, { "ElementTransformation_GetGeometryType", _wrap_ElementTransformation_GetGeometryType, METH_O, "GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type"}, { "ElementTransformation_GetDimension", _wrap_ElementTransformation_GetDimension, METH_O, "GetDimension(ElementTransformation self) -> int"}, { "ElementTransformation_GetSpaceDim", _wrap_ElementTransformation_GetSpaceDim, METH_O, "GetSpaceDim(ElementTransformation self) -> int"}, - { "ElementTransformation_TransformBack", _wrap_ElementTransformation_TransformBack, METH_VARARGS, "TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "ElementTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "delete_ElementTransformation", _wrap_delete_ElementTransformation, METH_O, "delete_ElementTransformation(ElementTransformation self)"}, { "ElementTransformation_swigregister", ElementTransformation_swigregister, METH_O, NULL}, - { "new_InverseElementTransformation", _wrap_new_InverseElementTransformation, METH_VARARGS, "InverseElementTransformation(ElementTransformation Trans=None)"}, + { "new_InverseElementTransformation", (PyCFunction)(void(*)(void))_wrap_new_InverseElementTransformation, METH_VARARGS|METH_KEYWORDS, "new_InverseElementTransformation(ElementTransformation Trans=None) -> InverseElementTransformation"}, { "delete_InverseElementTransformation", _wrap_delete_InverseElementTransformation, METH_O, "delete_InverseElementTransformation(InverseElementTransformation self)"}, - { "InverseElementTransformation_SetTransformation", _wrap_InverseElementTransformation_SetTransformation, METH_VARARGS, "SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, - { "InverseElementTransformation_SetInitialGuessType", _wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS, "SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, - { "InverseElementTransformation_SetInitialGuess", _wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS, "SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, - { "InverseElementTransformation_SetInitGuessPointsType", _wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS, "SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, - { "InverseElementTransformation_SetInitGuessRelOrder", _wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS, "SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, - { "InverseElementTransformation_SetSolverType", _wrap_InverseElementTransformation_SetSolverType, METH_VARARGS, "SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, - { "InverseElementTransformation_SetMaxIter", _wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS, "SetMaxIter(InverseElementTransformation self, int max_it)"}, - { "InverseElementTransformation_SetReferenceTol", _wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS, "SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, - { "InverseElementTransformation_SetPhysicalRelTol", _wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS, "SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, - { "InverseElementTransformation_SetElementTol", _wrap_InverseElementTransformation_SetElementTol, METH_VARARGS, "SetElementTol(InverseElementTransformation self, double el_tol)"}, - { "InverseElementTransformation_SetPrintLevel", _wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS, "SetPrintLevel(InverseElementTransformation self, int pr_level)"}, - { "InverseElementTransformation_FindClosestPhysPoint", _wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS, "FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_FindClosestRefPoint", _wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS, "FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_Transform", _wrap_InverseElementTransformation_Transform, METH_VARARGS, "Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "InverseElementTransformation_SetTransformation", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetTransformation, METH_VARARGS|METH_KEYWORDS, "SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, + { "InverseElementTransformation_SetInitialGuessType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS|METH_KEYWORDS, "SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, + { "InverseElementTransformation_SetInitialGuess", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS|METH_KEYWORDS, "SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, + { "InverseElementTransformation_SetInitGuessPointsType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS|METH_KEYWORDS, "SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, + { "InverseElementTransformation_SetInitGuessRelOrder", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS|METH_KEYWORDS, "SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, + { "InverseElementTransformation_SetSolverType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetSolverType, METH_VARARGS|METH_KEYWORDS, "SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, + { "InverseElementTransformation_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(InverseElementTransformation self, int max_it)"}, + { "InverseElementTransformation_SetReferenceTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS|METH_KEYWORDS, "SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, + { "InverseElementTransformation_SetPhysicalRelTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS|METH_KEYWORDS, "SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, + { "InverseElementTransformation_SetElementTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetElementTol, METH_VARARGS|METH_KEYWORDS, "SetElementTol(InverseElementTransformation self, double el_tol)"}, + { "InverseElementTransformation_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(InverseElementTransformation self, int pr_level)"}, + { "InverseElementTransformation_FindClosestPhysPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS|METH_KEYWORDS, "FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_FindClosestRefPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS|METH_KEYWORDS, "FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_Transform", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_Transform, METH_VARARGS|METH_KEYWORDS, "Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "InverseElementTransformation_swigregister", InverseElementTransformation_swigregister, METH_O, NULL}, { "InverseElementTransformation_swiginit", InverseElementTransformation_swiginit, METH_VARARGS, NULL}, - { "IsoparametricTransformation_SetFE", _wrap_IsoparametricTransformation_SetFE, METH_VARARGS, "SetFE(IsoparametricTransformation self, FiniteElement FE)"}, + { "IsoparametricTransformation_SetFE", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetFE, METH_VARARGS|METH_KEYWORDS, "SetFE(IsoparametricTransformation self, FiniteElement FE)"}, { "IsoparametricTransformation_GetFE", _wrap_IsoparametricTransformation_GetFE, METH_O, "GetFE(IsoparametricTransformation self) -> FiniteElement"}, { "IsoparametricTransformation_GetPointMat", _wrap_IsoparametricTransformation_GetPointMat, METH_O, "GetPointMat(IsoparametricTransformation self) -> DenseMatrix"}, { "IsoparametricTransformation_FinalizeTransformation", _wrap_IsoparametricTransformation_FinalizeTransformation, METH_O, "FinalizeTransformation(IsoparametricTransformation self)"}, - { "IsoparametricTransformation_SetIdentityTransformation", _wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS, "SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, + { "IsoparametricTransformation_SetIdentityTransformation", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS|METH_KEYWORDS, "SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, { "IsoparametricTransformation_Transform", _wrap_IsoparametricTransformation_Transform, METH_VARARGS, "\n" "Transform(IsoparametricTransformation self, IntegrationPoint arg2, Vector arg3)\n" "Transform(IsoparametricTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" @@ -6766,8 +6806,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "IsoparametricTransformation_Order", _wrap_IsoparametricTransformation_Order, METH_O, "Order(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderJ", _wrap_IsoparametricTransformation_OrderJ, METH_O, "OrderJ(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderW", _wrap_IsoparametricTransformation_OrderW, METH_O, "OrderW(IsoparametricTransformation self) -> int"}, - { "IsoparametricTransformation_OrderGrad", _wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS, "OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, - { "IsoparametricTransformation_TransformBack", _wrap_IsoparametricTransformation_TransformBack, METH_VARARGS, "TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, + { "IsoparametricTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, + { "IsoparametricTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, { "delete_IsoparametricTransformation", _wrap_delete_IsoparametricTransformation, METH_O, "delete_IsoparametricTransformation(IsoparametricTransformation self)"}, { "new_IsoparametricTransformation", _wrap_new_IsoparametricTransformation, METH_NOARGS, "new_IsoparametricTransformation() -> IsoparametricTransformation"}, { "IsoparametricTransformation_swigregister", IsoparametricTransformation_swigregister, METH_O, NULL}, diff --git a/mfem/_par/error_wrap.cxx b/mfem/_par/error_wrap.cxx index 6245645f..9e70e4d3 100644 --- a/mfem/_par/error_wrap.cxx +++ b/mfem/_par/error_wrap.cxx @@ -3055,16 +3055,18 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_set_error_action(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_set_error_action(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ErrorAction arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"action", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_error_action", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_error_action" "', argument " "1"" of type '" "mfem::ErrorAction""'"); } @@ -3120,91 +3122,38 @@ SWIGINTERN PyObject *_wrap_get_error_action(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_mfem_backtrace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + int arg1 = (int) 0 ; + int arg2 = (int) -1 ; int val1 ; int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"mode", (char *)"depth", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mfem_backtrace" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mfem_backtrace" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - try { - mfem::mfem_backtrace(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:mfem_backtrace", kwnames, &obj0, &obj1)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mfem_backtrace" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mfem_backtrace" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - { - try { - mfem::mfem_backtrace(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (obj1) { + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mfem_backtrace" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - mfem::mfem_backtrace(); + mfem::mfem_backtrace(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3225,67 +3174,25 @@ SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_mfem_backtrace(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "mfem_backtrace", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_mfem_backtrace__SWIG_2(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_mfem_backtrace__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_mfem_backtrace__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mfem_backtrace'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::mfem_backtrace(int,int)\n" - " mfem::mfem_backtrace(int)\n" - " mfem::mfem_backtrace()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_mfem_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_mfem_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = (char *) NULL ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"msg", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_error" "', argument " "1"" of type '" "char const *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:mfem_error", kwnames, &obj0)) SWIG_fail; + if (obj0) { + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_error" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); } - arg1 = reinterpret_cast< char * >(buf1); { try { mfem::mfem_error((char const *)arg1); @@ -3311,75 +3218,25 @@ SWIGINTERN PyObject *_wrap_mfem_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_mfem_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - mfem::mfem_error(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_error(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "mfem_error", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_mfem_error__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_mfem_error__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mfem_error'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::mfem_error(char const *)\n" - " mfem::mfem_error()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_mfem_warning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_mfem_warning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = (char *) NULL ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"msg", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_warning" "', argument " "1"" of type '" "char const *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:mfem_warning", kwnames, &obj0)) SWIG_fail; + if (obj0) { + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_warning" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); } - arg1 = reinterpret_cast< char * >(buf1); { try { mfem::mfem_warning((char const *)arg1); @@ -3405,81 +3262,25 @@ SWIGINTERN PyObject *_wrap_mfem_warning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_mfem_warning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - mfem::mfem_warning(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_warning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "mfem_warning", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_mfem_warning__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_mfem_warning__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mfem_warning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::mfem_warning(char const *)\n" - " mfem::mfem_warning()\n"); - return 0; -} - - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "set_error_action", _wrap_set_error_action, METH_O, NULL}, + { "set_error_action", (PyCFunction)(void(*)(void))_wrap_set_error_action, METH_VARARGS|METH_KEYWORDS, NULL}, { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, - { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, - { "mfem_error", _wrap_mfem_error, METH_VARARGS, NULL}, - { "mfem_warning", _wrap_mfem_warning, METH_VARARGS, NULL}, + { "mfem_backtrace", (PyCFunction)(void(*)(void))_wrap_mfem_backtrace, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_error", (PyCFunction)(void(*)(void))_wrap_mfem_error, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_warning", (PyCFunction)(void(*)(void))_wrap_mfem_warning, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "set_error_action", _wrap_set_error_action, METH_O, NULL}, + { "set_error_action", (PyCFunction)(void(*)(void))_wrap_set_error_action, METH_VARARGS|METH_KEYWORDS, NULL}, { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, - { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, - { "mfem_error", _wrap_mfem_error, METH_VARARGS, NULL}, - { "mfem_warning", _wrap_mfem_warning, METH_VARARGS, NULL}, + { "mfem_backtrace", (PyCFunction)(void(*)(void))_wrap_mfem_backtrace, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_error", (PyCFunction)(void(*)(void))_wrap_mfem_error, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_warning", (PyCFunction)(void(*)(void))_wrap_mfem_warning, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/estimators_wrap.cxx b/mfem/_par/estimators_wrap.cxx index 22011871..0bc51a9a 100644 --- a/mfem/_par/estimators_wrap.cxx +++ b/mfem/_par/estimators_wrap.cxx @@ -3477,14 +3477,14 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) #define SWIG_From_double PyFloat_FromDouble -SWIGINTERN mfem::ZienkiewiczZhuEstimator *new_mfem_ZienkiewiczZhuEstimator__SWIG_0(mfem::BilinearFormIntegrator &integ,mfem::GridFunction &sol,mfem::FiniteElementSpace *flux_fes,bool own_flux_fes=false){ +SWIGINTERN mfem::ZienkiewiczZhuEstimator *new_mfem_ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &integ,mfem::GridFunction &sol,mfem::FiniteElementSpace *flux_fes,bool own_flux_fes=false){ if (own_flux_fes){ return new mfem::ZienkiewiczZhuEstimator(integ, sol, flux_fes); } else { return new mfem::ZienkiewiczZhuEstimator(integ, sol, *flux_fes); } } -SWIGINTERN mfem::L2ZienkiewiczZhuEstimator *new_mfem_L2ZienkiewiczZhuEstimator__SWIG_0(mfem::BilinearFormIntegrator &integ,mfem::ParGridFunction &sol,mfem::ParFiniteElementSpace *flux_fes,mfem::ParFiniteElementSpace *smooth_flux_fes,bool own_flux_fes=false){ +SWIGINTERN mfem::L2ZienkiewiczZhuEstimator *new_mfem_L2ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &integ,mfem::ParGridFunction &sol,mfem::ParFiniteElementSpace *flux_fes,mfem::ParFiniteElementSpace *smooth_flux_fes,bool own_flux_fes=false){ if (own_flux_fes){ return new mfem::L2ZienkiewiczZhuEstimator(integ, sol, flux_fes, smooth_flux_fes); @@ -3725,26 +3725,33 @@ SWIGINTERN PyObject *AnisotropicErrorEstimator_swigregister(PyObject *SWIGUNUSED return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"w_coeff", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ZienkiewiczZhuEstimator_SetWithCoeff", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); } arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { (arg1)->SetWithCoeff(arg2); @@ -3760,125 +3767,36 @@ SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(PyObject } -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); - } - arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); - { - try { - (arg1)->SetWithCoeff(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetWithCoeff", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZienkiewiczZhuEstimator_SetWithCoeff'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZienkiewiczZhuEstimator::SetWithCoeff(bool)\n" - " mfem::ZienkiewiczZhuEstimator::SetWithCoeff()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"aniso", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ZienkiewiczZhuEstimator_SetAnisotropic", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); } arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetAnisotropic(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); { try { - (arg1)->SetAnisotropic(); + (arg1)->SetAnisotropic(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3891,67 +3809,29 @@ SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetAnisotropic", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZienkiewiczZhuEstimator_SetAnisotropic'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZienkiewiczZhuEstimator::SetAnisotropic(bool)\n" - " mfem::ZienkiewiczZhuEstimator::SetAnisotropic()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetFluxAveraging", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ZienkiewiczZhuEstimator_SetFluxAveraging", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetFluxAveraging" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); } arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4116,12 +3996,12 @@ SWIGINTERN PyObject *_wrap_delete_ZienkiewiczZhuEstimator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; mfem::FiniteElementSpace *arg3 = (mfem::FiniteElementSpace *) 0 ; - bool arg4 ; + bool arg4 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4130,10 +4010,17 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNU int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"integ", (char *)"sol", (char *)"flux_fes", (char *)"own_flux_fes", NULL + }; mfem::ZienkiewiczZhuEstimator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_ZienkiewiczZhuEstimator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -4141,7 +4028,7 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } @@ -4149,69 +4036,21 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "3"" of type '" "mfem::FiniteElementSpace *""'"); } arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - result = (mfem::ZienkiewiczZhuEstimator *)new_mfem_ZienkiewiczZhuEstimator__SWIG_0(*arg1,*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::FiniteElementSpace *arg3 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::ZienkiewiczZhuEstimator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "3"" of type '" "mfem::FiniteElementSpace *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); { try { - result = (mfem::ZienkiewiczZhuEstimator *)new_mfem_ZienkiewiczZhuEstimator__SWIG_0(*arg1,*arg2,arg3); + result = (mfem::ZienkiewiczZhuEstimator *)new_mfem_ZienkiewiczZhuEstimator(*arg1,*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4224,68 +4063,6 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZienkiewiczZhuEstimator", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ZienkiewiczZhuEstimator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ZienkiewiczZhuEstimator__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZienkiewiczZhuEstimator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZienkiewiczZhuEstimator::ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::FiniteElementSpace *,bool)\n" - " mfem::ZienkiewiczZhuEstimator::ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::FiniteElementSpace *)\n"); - return 0; -} - - SWIGINTERN PyObject *ZienkiewiczZhuEstimator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -4297,25 +4074,29 @@ SWIGINTERN PyObject *ZienkiewiczZhuEstimator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_L2ZienkiewiczZhuEstimator_SetLocalErrorNormP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2ZienkiewiczZhuEstimator_SetLocalErrorNormP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2ZienkiewiczZhuEstimator *arg1 = (mfem::L2ZienkiewiczZhuEstimator *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ZienkiewiczZhuEstimator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:L2ZienkiewiczZhuEstimator_SetLocalErrorNormP", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2ZienkiewiczZhuEstimator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP" "', argument " "1"" of type '" "mfem::L2ZienkiewiczZhuEstimator *""'"); } arg1 = reinterpret_cast< mfem::L2ZienkiewiczZhuEstimator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4450,13 +4231,13 @@ SWIGINTERN PyObject *_wrap_delete_L2ZienkiewiczZhuEstimator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::ParGridFunction *arg2 = 0 ; mfem::ParFiniteElementSpace *arg3 = (mfem::ParFiniteElementSpace *) 0 ; mfem::ParFiniteElementSpace *arg4 = (mfem::ParFiniteElementSpace *) 0 ; - bool arg5 ; + bool arg5 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4467,10 +4248,18 @@ SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGU int res4 = 0 ; bool val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"integ", (char *)"sol", (char *)"flux_fes", (char *)"smooth_flux_fes", (char *)"own_flux_fes", NULL + }; mfem::L2ZienkiewiczZhuEstimator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:new_L2ZienkiewiczZhuEstimator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -4478,7 +4267,7 @@ SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction &""'"); } @@ -4486,82 +4275,26 @@ SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction &""'"); } arg2 = reinterpret_cast< mfem::ParGridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg3 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg4 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - result = (mfem::L2ZienkiewiczZhuEstimator *)new_mfem_L2ZienkiewiczZhuEstimator__SWIG_0(*arg1,*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2ZienkiewiczZhuEstimator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::ParGridFunction *arg2 = 0 ; - mfem::ParFiniteElementSpace *arg3 = (mfem::ParFiniteElementSpace *) 0 ; - mfem::ParFiniteElementSpace *arg4 = (mfem::ParFiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - mfem::L2ZienkiewiczZhuEstimator *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::ParGridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace *""'"); - } - arg3 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_L2ZienkiewiczZhuEstimator" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); } - arg4 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp4); { try { - result = (mfem::L2ZienkiewiczZhuEstimator *)new_mfem_L2ZienkiewiczZhuEstimator__SWIG_0(*arg1,*arg2,arg3,arg4); + result = (mfem::L2ZienkiewiczZhuEstimator *)new_mfem_L2ZienkiewiczZhuEstimator(*arg1,*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4574,78 +4307,6 @@ SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_L2ZienkiewiczZhuEstimator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2ZienkiewiczZhuEstimator", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParGridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_L2ZienkiewiczZhuEstimator__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParGridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_L2ZienkiewiczZhuEstimator__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2ZienkiewiczZhuEstimator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2ZienkiewiczZhuEstimator::L2ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &,mfem::ParGridFunction &,mfem::ParFiniteElementSpace *,mfem::ParFiniteElementSpace *,bool)\n" - " mfem::L2ZienkiewiczZhuEstimator::L2ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &,mfem::ParGridFunction &,mfem::ParFiniteElementSpace *,mfem::ParFiniteElementSpace *)\n"); - return 0; -} - - SWIGINTERN PyObject *L2ZienkiewiczZhuEstimator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -4671,23 +4332,23 @@ static PyMethodDef SwigMethods[] = { { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "AnisotropicErrorEstimator_GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, - { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "ZienkiewiczZhuEstimator_SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, - { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "ZienkiewiczZhuEstimator_SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, - { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "ZienkiewiczZhuEstimator_SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS|METH_KEYWORDS, "ZienkiewiczZhuEstimator_SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, + { "ZienkiewiczZhuEstimator_SetAnisotropic", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS|METH_KEYWORDS, "ZienkiewiczZhuEstimator_SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, + { "ZienkiewiczZhuEstimator_SetFluxAveraging", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS|METH_KEYWORDS, "ZienkiewiczZhuEstimator_SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "ZienkiewiczZhuEstimator_GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, { "ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "ZienkiewiczZhuEstimator_GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector"}, { "ZienkiewiczZhuEstimator_GetAnisotropicFlags", _wrap_ZienkiewiczZhuEstimator_GetAnisotropicFlags, METH_O, "ZienkiewiczZhuEstimator_GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray"}, { "ZienkiewiczZhuEstimator_Reset", _wrap_ZienkiewiczZhuEstimator_Reset, METH_O, "ZienkiewiczZhuEstimator_Reset(ZienkiewiczZhuEstimator self)"}, { "delete_ZienkiewiczZhuEstimator", _wrap_delete_ZienkiewiczZhuEstimator, METH_O, "delete_ZienkiewiczZhuEstimator(ZienkiewiczZhuEstimator self)"}, - { "new_ZienkiewiczZhuEstimator", _wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS, "ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False)"}, + { "new_ZienkiewiczZhuEstimator", (PyCFunction)(void(*)(void))_wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS|METH_KEYWORDS, "new_ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False) -> ZienkiewiczZhuEstimator"}, { "ZienkiewiczZhuEstimator_swigregister", ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, { "ZienkiewiczZhuEstimator_swiginit", ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, - { "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP", _wrap_L2ZienkiewiczZhuEstimator_SetLocalErrorNormP, METH_VARARGS, "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP(L2ZienkiewiczZhuEstimator self, int p)"}, + { "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP", (PyCFunction)(void(*)(void))_wrap_L2ZienkiewiczZhuEstimator_SetLocalErrorNormP, METH_VARARGS|METH_KEYWORDS, "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP(L2ZienkiewiczZhuEstimator self, int p)"}, { "L2ZienkiewiczZhuEstimator_GetTotalError", _wrap_L2ZienkiewiczZhuEstimator_GetTotalError, METH_O, "L2ZienkiewiczZhuEstimator_GetTotalError(L2ZienkiewiczZhuEstimator self) -> double"}, { "L2ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_L2ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "L2ZienkiewiczZhuEstimator_GetLocalErrors(L2ZienkiewiczZhuEstimator self) -> Vector"}, { "L2ZienkiewiczZhuEstimator_Reset", _wrap_L2ZienkiewiczZhuEstimator_Reset, METH_O, "L2ZienkiewiczZhuEstimator_Reset(L2ZienkiewiczZhuEstimator self)"}, { "delete_L2ZienkiewiczZhuEstimator", _wrap_delete_L2ZienkiewiczZhuEstimator, METH_O, "delete_L2ZienkiewiczZhuEstimator(L2ZienkiewiczZhuEstimator self)"}, - { "new_L2ZienkiewiczZhuEstimator", _wrap_new_L2ZienkiewiczZhuEstimator, METH_VARARGS, "L2ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, mfem::ParGridFunction & sol, mfem::ParFiniteElementSpace * flux_fes, mfem::ParFiniteElementSpace * smooth_flux_fes, bool own_flux_fes=False)"}, + { "new_L2ZienkiewiczZhuEstimator", (PyCFunction)(void(*)(void))_wrap_new_L2ZienkiewiczZhuEstimator, METH_VARARGS|METH_KEYWORDS, "new_L2ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, mfem::ParGridFunction & sol, mfem::ParFiniteElementSpace * flux_fes, mfem::ParFiniteElementSpace * smooth_flux_fes, bool own_flux_fes=False) -> L2ZienkiewiczZhuEstimator"}, { "L2ZienkiewiczZhuEstimator_swigregister", L2ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, { "L2ZienkiewiczZhuEstimator_swiginit", L2ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -4707,23 +4368,23 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, - { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, - { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, - { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS|METH_KEYWORDS, "SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, + { "ZienkiewiczZhuEstimator_SetAnisotropic", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS|METH_KEYWORDS, "SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, + { "ZienkiewiczZhuEstimator_SetFluxAveraging", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS|METH_KEYWORDS, "SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, { "ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector"}, { "ZienkiewiczZhuEstimator_GetAnisotropicFlags", _wrap_ZienkiewiczZhuEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray"}, { "ZienkiewiczZhuEstimator_Reset", _wrap_ZienkiewiczZhuEstimator_Reset, METH_O, "Reset(ZienkiewiczZhuEstimator self)"}, { "delete_ZienkiewiczZhuEstimator", _wrap_delete_ZienkiewiczZhuEstimator, METH_O, "delete_ZienkiewiczZhuEstimator(ZienkiewiczZhuEstimator self)"}, - { "new_ZienkiewiczZhuEstimator", _wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS, "ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False)"}, + { "new_ZienkiewiczZhuEstimator", (PyCFunction)(void(*)(void))_wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS|METH_KEYWORDS, "new_ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False) -> ZienkiewiczZhuEstimator"}, { "ZienkiewiczZhuEstimator_swigregister", ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, { "ZienkiewiczZhuEstimator_swiginit", ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, - { "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP", _wrap_L2ZienkiewiczZhuEstimator_SetLocalErrorNormP, METH_VARARGS, "SetLocalErrorNormP(L2ZienkiewiczZhuEstimator self, int p)"}, + { "L2ZienkiewiczZhuEstimator_SetLocalErrorNormP", (PyCFunction)(void(*)(void))_wrap_L2ZienkiewiczZhuEstimator_SetLocalErrorNormP, METH_VARARGS|METH_KEYWORDS, "SetLocalErrorNormP(L2ZienkiewiczZhuEstimator self, int p)"}, { "L2ZienkiewiczZhuEstimator_GetTotalError", _wrap_L2ZienkiewiczZhuEstimator_GetTotalError, METH_O, "GetTotalError(L2ZienkiewiczZhuEstimator self) -> double"}, { "L2ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_L2ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "GetLocalErrors(L2ZienkiewiczZhuEstimator self) -> Vector"}, { "L2ZienkiewiczZhuEstimator_Reset", _wrap_L2ZienkiewiczZhuEstimator_Reset, METH_O, "Reset(L2ZienkiewiczZhuEstimator self)"}, { "delete_L2ZienkiewiczZhuEstimator", _wrap_delete_L2ZienkiewiczZhuEstimator, METH_O, "delete_L2ZienkiewiczZhuEstimator(L2ZienkiewiczZhuEstimator self)"}, - { "new_L2ZienkiewiczZhuEstimator", _wrap_new_L2ZienkiewiczZhuEstimator, METH_VARARGS, "L2ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, mfem::ParGridFunction & sol, mfem::ParFiniteElementSpace * flux_fes, mfem::ParFiniteElementSpace * smooth_flux_fes, bool own_flux_fes=False)"}, + { "new_L2ZienkiewiczZhuEstimator", (PyCFunction)(void(*)(void))_wrap_new_L2ZienkiewiczZhuEstimator, METH_VARARGS|METH_KEYWORDS, "new_L2ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, mfem::ParGridFunction & sol, mfem::ParFiniteElementSpace * flux_fes, mfem::ParFiniteElementSpace * smooth_flux_fes, bool own_flux_fes=False) -> L2ZienkiewiczZhuEstimator"}, { "L2ZienkiewiczZhuEstimator_swigregister", L2ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, { "L2ZienkiewiczZhuEstimator_swiginit", L2ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -6166,10 +5827,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/fe.py b/mfem/_par/fe.py index f1aca2c4..30a4d255 100644 --- a/mfem/_par/fe.py +++ b/mfem/_par/fe.py @@ -641,9 +641,9 @@ class VectorFiniteElement(FiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(VectorFiniteElement self, int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk) -> VectorFiniteElement""" - _fe.VectorFiniteElement_swiginit(self, _fe.new_VectorFiniteElement(*args)) + _fe.VectorFiniteElement_swiginit(self, _fe.new_VectorFiniteElement(*args, **kwargs)) __swig_destroy__ = _fe.delete_VectorFiniteElement # Register VectorFiniteElement in _fe: @@ -2177,14 +2177,14 @@ def GetPoints(self, p, btype): return _fe.Poly_1D_GetPoints(self, p, btype) GetPoints = _swig_new_instance_method(_fe.Poly_1D_GetPoints) - def OpenPoints(self, *args): - r"""OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const""" - return _fe.Poly_1D_OpenPoints(self, *args) + def OpenPoints(self, *args, **kwargs): + r"""OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const *""" + return _fe.Poly_1D_OpenPoints(self, *args, **kwargs) OpenPoints = _swig_new_instance_method(_fe.Poly_1D_OpenPoints) - def ClosedPoints(self, *args): - r"""ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const""" - return _fe.Poly_1D_ClosedPoints(self, *args) + def ClosedPoints(self, *args, **kwargs): + r"""ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const *""" + return _fe.Poly_1D_ClosedPoints(self, *args, **kwargs) ClosedPoints = _swig_new_instance_method(_fe.Poly_1D_ClosedPoints) def GetBasis(self, p, btype): @@ -2432,9 +2432,9 @@ class H1_SegmentElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_SegmentElement self, int const p, int const btype=GaussLobatto) -> H1_SegmentElement""" - _fe.H1_SegmentElement_swiginit(self, _fe.new_H1_SegmentElement(*args)) + _fe.H1_SegmentElement_swiginit(self, _fe.new_H1_SegmentElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)""" @@ -2461,9 +2461,9 @@ class H1_QuadrilateralElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_QuadrilateralElement self, int const p, int const btype=GaussLobatto) -> H1_QuadrilateralElement""" - _fe.H1_QuadrilateralElement_swiginit(self, _fe.new_H1_QuadrilateralElement(*args)) + _fe.H1_QuadrilateralElement_swiginit(self, _fe.new_H1_QuadrilateralElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" @@ -2490,9 +2490,9 @@ class H1_HexahedronElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_HexahedronElement self, int const p, int const btype=GaussLobatto) -> H1_HexahedronElement""" - _fe.H1_HexahedronElement_swiginit(self, _fe.new_H1_HexahedronElement(*args)) + _fe.H1_HexahedronElement_swiginit(self, _fe.new_H1_HexahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -2644,9 +2644,9 @@ class H1_TriangleElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_TriangleElement self, int const p, int const btype=GaussLobatto) -> H1_TriangleElement""" - _fe.H1_TriangleElement_swiginit(self, _fe.new_H1_TriangleElement(*args)) + _fe.H1_TriangleElement_swiginit(self, _fe.new_H1_TriangleElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)""" @@ -2673,9 +2673,9 @@ class H1_TetrahedronElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_TetrahedronElement self, int const p, int const btype=GaussLobatto) -> H1_TetrahedronElement""" - _fe.H1_TetrahedronElement_swiginit(self, _fe.new_H1_TetrahedronElement(*args)) + _fe.H1_TetrahedronElement_swiginit(self, _fe.new_H1_TetrahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -2762,9 +2762,9 @@ class H1_WedgeElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_WedgeElement self, int const p, int const btype=GaussLobatto) -> H1_WedgeElement""" - _fe.H1_WedgeElement_swiginit(self, _fe.new_H1_WedgeElement(*args)) + _fe.H1_WedgeElement_swiginit(self, _fe.new_H1_WedgeElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)""" @@ -2852,9 +2852,9 @@ class L2_SegmentElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_SegmentElement self, int const p, int const btype=GaussLegendre) -> L2_SegmentElement""" - _fe.L2_SegmentElement_swiginit(self, _fe.new_L2_SegmentElement(*args)) + _fe.L2_SegmentElement_swiginit(self, _fe.new_L2_SegmentElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)""" @@ -2910,9 +2910,9 @@ class L2_QuadrilateralElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_QuadrilateralElement self, int const p, int const btype=GaussLegendre) -> L2_QuadrilateralElement""" - _fe.L2_QuadrilateralElement_swiginit(self, _fe.new_L2_QuadrilateralElement(*args)) + _fe.L2_QuadrilateralElement_swiginit(self, _fe.new_L2_QuadrilateralElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" @@ -2973,9 +2973,9 @@ class L2_HexahedronElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_HexahedronElement self, int const p, int const btype=GaussLegendre) -> L2_HexahedronElement""" - _fe.L2_HexahedronElement_swiginit(self, _fe.new_L2_HexahedronElement(*args)) + _fe.L2_HexahedronElement_swiginit(self, _fe.new_L2_HexahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -3031,9 +3031,9 @@ class L2_TriangleElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_TriangleElement self, int const p, int const btype=GaussLegendre) -> L2_TriangleElement""" - _fe.L2_TriangleElement_swiginit(self, _fe.new_L2_TriangleElement(*args)) + _fe.L2_TriangleElement_swiginit(self, _fe.new_L2_TriangleElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)""" @@ -3094,9 +3094,9 @@ class L2_TetrahedronElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_TetrahedronElement self, int const p, int const btype=GaussLegendre) -> L2_TetrahedronElement""" - _fe.L2_TetrahedronElement_swiginit(self, _fe.new_L2_TetrahedronElement(*args)) + _fe.L2_TetrahedronElement_swiginit(self, _fe.new_L2_TetrahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -3152,9 +3152,9 @@ class L2_WedgeElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_WedgeElement self, int const p, int const btype=GaussLegendre) -> L2_WedgeElement""" - _fe.L2_WedgeElement_swiginit(self, _fe.new_L2_WedgeElement(*args)) + _fe.L2_WedgeElement_swiginit(self, _fe.new_L2_WedgeElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)""" @@ -3214,9 +3214,9 @@ class RT_QuadrilateralElement(VectorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RT_QuadrilateralElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_QuadrilateralElement""" - _fe.RT_QuadrilateralElement_swiginit(self, _fe.new_RT_QuadrilateralElement(*args)) + _fe.RT_QuadrilateralElement_swiginit(self, _fe.new_RT_QuadrilateralElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3282,9 +3282,9 @@ class RT_HexahedronElement(VectorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RT_HexahedronElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_HexahedronElement""" - _fe.RT_HexahedronElement_swiginit(self, _fe.new_RT_HexahedronElement(*args)) + _fe.RT_HexahedronElement_swiginit(self, _fe.new_RT_HexahedronElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3476,9 +3476,9 @@ class ND_HexahedronElement(VectorTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_HexahedronElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_HexahedronElement""" - _fe.ND_HexahedronElement_swiginit(self, _fe.new_ND_HexahedronElement(*args)) + _fe.ND_HexahedronElement_swiginit(self, _fe.new_ND_HexahedronElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3544,9 +3544,9 @@ class ND_QuadrilateralElement(VectorTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_QuadrilateralElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_QuadrilateralElement""" - _fe.ND_QuadrilateralElement_swiginit(self, _fe.new_ND_QuadrilateralElement(*args)) + _fe.ND_QuadrilateralElement_swiginit(self, _fe.new_ND_QuadrilateralElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3738,9 +3738,9 @@ class ND_SegmentElement(VectorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_SegmentElement self, int const p, int const ob_type=GaussLegendre) -> ND_SegmentElement""" - _fe.ND_SegmentElement_swiginit(self, _fe.new_ND_SegmentElement(*args)) + _fe.ND_SegmentElement_swiginit(self, _fe.new_ND_SegmentElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)""" diff --git a/mfem/_par/fe_coll.py b/mfem/_par/fe_coll.py index e4f67e72..66099e5f 100644 --- a/mfem/_par/fe_coll.py +++ b/mfem/_par/fe_coll.py @@ -163,9 +163,9 @@ class H1_FECollection(FiniteElementCollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_FECollection self, int const p, int const dim=3, int const btype=GaussLobatto) -> H1_FECollection""" - _fe_coll.H1_FECollection_swiginit(self, _fe_coll.new_H1_FECollection(*args)) + _fe_coll.H1_FECollection_swiginit(self, _fe_coll.new_H1_FECollection(*args, **kwargs)) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" @@ -240,9 +240,9 @@ class H1_Trace_FECollection(H1_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_Trace_FECollection self, int const p, int const dim, int const btype=GaussLobatto) -> H1_Trace_FECollection""" - _fe_coll.H1_Trace_FECollection_swiginit(self, _fe_coll.new_H1_Trace_FECollection(*args)) + _fe_coll.H1_Trace_FECollection_swiginit(self, _fe_coll.new_H1_Trace_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_H1_Trace_FECollection # Register H1_Trace_FECollection in _fe_coll: @@ -254,9 +254,9 @@ class L2_FECollection(FiniteElementCollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_FECollection self, int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE) -> L2_FECollection""" - _fe_coll.L2_FECollection_swiginit(self, _fe_coll.new_L2_FECollection(*args)) + _fe_coll.L2_FECollection_swiginit(self, _fe_coll.new_L2_FECollection(*args, **kwargs)) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" @@ -337,9 +337,9 @@ class RT_Trace_FECollection(RT_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RT_Trace_FECollection self, int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre) -> RT_Trace_FECollection""" - _fe_coll.RT_Trace_FECollection_swiginit(self, _fe_coll.new_RT_Trace_FECollection(*args)) + _fe_coll.RT_Trace_FECollection_swiginit(self, _fe_coll.new_RT_Trace_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_RT_Trace_FECollection # Register RT_Trace_FECollection in _fe_coll: @@ -351,9 +351,9 @@ class DG_Interface_FECollection(RT_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(DG_Interface_FECollection self, int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre) -> DG_Interface_FECollection""" - _fe_coll.DG_Interface_FECollection_swiginit(self, _fe_coll.new_DG_Interface_FECollection(*args)) + _fe_coll.DG_Interface_FECollection_swiginit(self, _fe_coll.new_DG_Interface_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_DG_Interface_FECollection # Register DG_Interface_FECollection in _fe_coll: @@ -365,9 +365,9 @@ class ND_FECollection(FiniteElementCollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_FECollection self, int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_FECollection""" - _fe_coll.ND_FECollection_swiginit(self, _fe_coll.new_ND_FECollection(*args)) + _fe_coll.ND_FECollection_swiginit(self, _fe_coll.new_ND_FECollection(*args, **kwargs)) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" @@ -404,9 +404,9 @@ class ND_Trace_FECollection(ND_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_Trace_FECollection self, int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_Trace_FECollection""" - _fe_coll.ND_Trace_FECollection_swiginit(self, _fe_coll.new_ND_Trace_FECollection(*args)) + _fe_coll.ND_Trace_FECollection_swiginit(self, _fe_coll.new_ND_Trace_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_ND_Trace_FECollection # Register ND_Trace_FECollection in _fe_coll: @@ -420,9 +420,9 @@ class NURBSFECollection(FiniteElementCollection): VariableOrder = _fe_coll.NURBSFECollection_VariableOrder - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(NURBSFECollection self, int Order=VariableOrder) -> NURBSFECollection""" - _fe_coll.NURBSFECollection_swiginit(self, _fe_coll.new_NURBSFECollection(*args)) + _fe_coll.NURBSFECollection_swiginit(self, _fe_coll.new_NURBSFECollection(*args, **kwargs)) def Reset(self): r"""Reset(NURBSFECollection self)""" diff --git a/mfem/_par/fe_coll_wrap.cxx b/mfem/_par/fe_coll_wrap.cxx index ee34e984..96465f00 100644 --- a/mfem/_par/fe_coll_wrap.cxx +++ b/mfem/_par/fe_coll_wrap.cxx @@ -3658,7 +3658,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -3666,16 +3666,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -3695,7 +3699,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyOb } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -3703,16 +3707,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_DofForGeometry" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -3732,7 +3740,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -3741,25 +3749,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofOrderForOrientation(PyObje int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementCollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3806,7 +3819,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_Name(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -3814,16 +3827,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNU int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_HasFaceDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_HasFaceDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_HasFaceDofs" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_HasFaceDofs" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -3843,7 +3860,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -3851,16 +3868,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_TraceFiniteElementForGeometry int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_TraceFiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_TraceFiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_TraceFiniteElementForGeometry" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_TraceFiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -3939,18 +3960,20 @@ SWIGINTERN PyObject *_wrap_delete_FiniteElementCollection(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"name", NULL + }; mfem::FiniteElementCollection *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElementCollection_New", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_New" "', argument " "1"" of type '" "char const *""'"); } @@ -3972,7 +3995,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_New(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_SubDofOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_SubDofOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -3985,32 +4008,39 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_SubDofOrder(PyObject *SWIGUNU int ecode2 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Geom", (char *)"SDim", (char *)"Info", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_SubDofOrder", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:FiniteElementCollection_SubDofOrder", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_SubDofOrder" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_SubDofOrder" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FiniteElementCollection_SubDofOrder" "', argument " "5"" of type '" "mfem::Array< int > &""'"); } @@ -4040,96 +4070,45 @@ SWIGINTERN PyObject *FiniteElementCollection_swigregister(PyObject *SWIGUNUSEDPA return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)3 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"btype", NULL + }; mfem::H1_FECollection *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_H1_FECollection", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1,arg2,arg3); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::H1_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1,arg2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_FECollection *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1); + result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4142,98 +4121,7 @@ SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_H1_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_FECollection", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_FECollection__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_FECollection__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_FECollection::H1_FECollection(int const,int const,int const)\n" - " mfem::H1_FECollection::H1_FECollection(int const,int const)\n" - " mfem::H1_FECollection::H1_FECollection(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4241,16 +4129,20 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:H1_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4270,7 +4162,7 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SW } -SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4278,16 +4170,20 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:H1_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4307,7 +4203,7 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4316,25 +4212,30 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_DofOrderForOrientation(PyObject *SWIG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4441,7 +4342,7 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_GetBasisType(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1_FECollection_GetDofMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_GetDofMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4449,16 +4350,20 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_GetDofMap(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_GetDofMap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:H1_FECollection_GetDofMap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_GetDofMap" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_GetDofMap" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4518,55 +4423,35 @@ SWIGINTERN PyObject *H1_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", NULL + }; mfem::H1Pos_FECollection *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1Pos_FECollection", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1Pos_FECollection *)new mfem::H1Pos_FECollection(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Pos_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1Pos_FECollection *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1Pos_FECollection *)new mfem::H1Pos_FECollection(arg1); + result = (mfem::H1Pos_FECollection *)new mfem::H1Pos_FECollection(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4579,62 +4464,6 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1Pos_FECollection", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Pos_FECollection__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Pos_FECollection__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1Pos_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1Pos_FECollection::H1Pos_FECollection(int const,int const)\n" - " mfem::H1Pos_FECollection::H1Pos_FECollection(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_H1Pos_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::H1Pos_FECollection *arg1 = (mfem::H1Pos_FECollection *) 0 ; @@ -4675,55 +4504,35 @@ SWIGINTERN PyObject *H1Pos_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", NULL + }; mfem::H1Ser_FECollection *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1Ser_FECollection", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1Ser_FECollection *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1); + result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4736,62 +4545,6 @@ SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1Ser_FECollection", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Ser_FECollection__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Ser_FECollection__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1Ser_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1Ser_FECollection::H1Ser_FECollection(int const,int const)\n" - " mfem::H1Ser_FECollection::H1Ser_FECollection(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::H1Ser_FECollection *arg1 = (mfem::H1Ser_FECollection *) 0 ; @@ -4832,69 +4585,43 @@ SWIGINTERN PyObject *H1Ser_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"btype", NULL + }; mfem::H1_Trace_FECollection *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:new_H1_Trace_FECollection", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - try { - result = (mfem::H1_Trace_FECollection *)new mfem::H1_Trace_FECollection(arg1,arg2,arg3); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::H1_Trace_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - result = (mfem::H1_Trace_FECollection *)new mfem::H1_Trace_FECollection(arg1,arg2); + result = (mfem::H1_Trace_FECollection *)new mfem::H1_Trace_FECollection(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4907,82 +4634,6 @@ SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_Trace_FECollection", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_Trace_FECollection__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_Trace_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_Trace_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_Trace_FECollection::H1_Trace_FECollection(int const,int const,int const)\n" - " mfem::H1_Trace_FECollection::H1_Trace_FECollection(int const,int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_H1_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::H1_Trace_FECollection *arg1 = (mfem::H1_Trace_FECollection *) 0 ; @@ -5023,38 +4674,49 @@ SWIGINTERN PyObject *H1_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; - int arg4 ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + int arg4 = (int) (int)mfem::FiniteElement::VALUE ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"btype", (char *)"map_type", NULL + }; mfem::L2_FECollection *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_L2_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { @@ -5071,257 +4733,69 @@ SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_L2_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::L2_FECollection *result = 0 ; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:L2_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::L2_FECollection *)new mfem::L2_FECollection(arg1,arg2,arg3); + result = (mfem::FiniteElement *)((mfem::L2_FECollection const *)arg1)->FiniteElementForGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_L2_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::L2_FECollection *result = 0 ; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::L2_FECollection *)new mfem::L2_FECollection(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_FECollection::L2_FECollection(int const,int const,int const,int const)\n" - " mfem::L2_FECollection::L2_FECollection(int const,int const,int const)\n" - " mfem::L2_FECollection::L2_FECollection(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (mfem::FiniteElement *)((mfem::L2_FECollection const *)arg1)->FiniteElementForGeometry(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:L2_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -5341,7 +4815,7 @@ SWIGINTERN PyObject *_wrap_L2_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_L2_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -5350,25 +4824,30 @@ SWIGINTERN PyObject *_wrap_L2_FECollection_DofOrderForOrientation(PyObject *SWIG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5415,7 +4894,7 @@ SWIGINTERN PyObject *_wrap_L2_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_L2_FECollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_FECollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -5423,16 +4902,20 @@ SWIGINTERN PyObject *_wrap_L2_FECollection_TraceFiniteElementForGeometry(PyObjec int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_TraceFiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:L2_FECollection_TraceFiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_TraceFiniteElementForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_TraceFiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -5522,15 +5005,15 @@ SWIGINTERN PyObject *L2_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; - int arg4 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; mfem::RT_FECollection *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -5543,96 +5026,25 @@ SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM( }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2,arg3,arg4); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::RT_FECollection *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - { - try { - result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2,arg3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::RT_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2); + result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5653,7 +5065,7 @@ SWIGINTERN PyObject *_wrap_new_RT_FECollection(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_FECollection", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 4)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -5673,30 +5085,9 @@ SWIGINTERN PyObject *_wrap_new_RT_FECollection(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_RT_FECollection__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_RT_FECollection__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5706,40 +5097,9 @@ SWIGINTERN PyObject *_wrap_new_RT_FECollection(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_RT_FECollection__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 3) { + return _wrap_new_RT_FECollection__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5749,7 +5109,7 @@ SWIGINTERN PyObject *_wrap_new_RT_FECollection(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_RT_FECollection__SWIG_2(self, argc, argv); + return _wrap_new_RT_FECollection__SWIG_1(self, argc, argv); } } } @@ -5759,14 +5119,12 @@ SWIGINTERN PyObject *_wrap_new_RT_FECollection(PyObject *self, PyObject *args) { fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_FECollection'.\n" " Possible C/C++ prototypes are:\n" - " mfem::RT_FECollection::RT_FECollection(int const,int const,int const,int const)\n" - " mfem::RT_FECollection::RT_FECollection(int const,int const,int const)\n" - " mfem::RT_FECollection::RT_FECollection(int const,int const)\n"); + " mfem::RT_FECollection::RT_FECollection(int const,int const,int const,int const)\n"); return 0; } -SWIGINTERN PyObject *_wrap_RT_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -5774,16 +5132,20 @@ SWIGINTERN PyObject *_wrap_RT_FECollection_FiniteElementForGeometry(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -5803,7 +5165,7 @@ SWIGINTERN PyObject *_wrap_RT_FECollection_FiniteElementForGeometry(PyObject *SW } -SWIGINTERN PyObject *_wrap_RT_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -5811,16 +5173,20 @@ SWIGINTERN PyObject *_wrap_RT_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -5840,7 +5206,7 @@ SWIGINTERN PyObject *_wrap_RT_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_RT_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -5849,25 +5215,30 @@ SWIGINTERN PyObject *_wrap_RT_FECollection_DofOrderForOrientation(PyObject *SWIG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5984,38 +5355,49 @@ SWIGINTERN PyObject *RT_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; - int arg4 ; + int arg3 = (int) (int)mfem::FiniteElement::INTEGRAL ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"map_type", (char *)"ob_type", NULL + }; mfem::RT_Trace_FECollection *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_RT_Trace_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { @@ -6032,216 +5414,119 @@ SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::RT_Trace_FECollection *result = 0 ; + mfem::RT_Trace_FECollection *arg1 = (mfem::RT_Trace_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RT_Trace_FECollection" "', argument " "1"" of type '" "mfem::RT_Trace_FECollection *""'"); } + arg1 = reinterpret_cast< mfem::RT_Trace_FECollection * >(argp1); { try { - result = (mfem::RT_Trace_FECollection *)new mfem::RT_Trace_FECollection(arg1,arg2,arg3); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *RT_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *RT_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - mfem::RT_Trace_FECollection *result = 0 ; + int arg3 = (int) (int)mfem::FiniteElement::VALUE ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"map_type", (char *)"ob_type", NULL + }; + mfem::DG_Interface_FECollection *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_DG_Interface_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (mfem::RT_Trace_FECollection *)new mfem::RT_Trace_FECollection(arg1,arg2); + result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_Trace_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_Trace_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_Trace_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_Trace_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_Trace_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RT_Trace_FECollection::RT_Trace_FECollection(int const,int const,int const,int const)\n" - " mfem::RT_Trace_FECollection::RT_Trace_FECollection(int const,int const,int const)\n" - " mfem::RT_Trace_FECollection::RT_Trace_FECollection(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_DG_Interface_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RT_Trace_FECollection *arg1 = (mfem::RT_Trace_FECollection *) 0 ; + mfem::DG_Interface_FECollection *arg1 = (mfem::DG_Interface_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RT_Trace_FECollection" "', argument " "1"" of type '" "mfem::RT_Trace_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DG_Interface_FECollection" "', argument " "1"" of type '" "mfem::DG_Interface_FECollection *""'"); } - arg1 = reinterpret_cast< mfem::RT_Trace_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::DG_Interface_FECollection * >(argp1); { try { delete arg1; @@ -6257,1021 +5542,281 @@ SWIGINTERN PyObject *_wrap_delete_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *RT_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DG_Interface_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *RT_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DG_Interface_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; - int arg4 ; - mfem::DG_Interface_FECollection *result = 0 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"cb_type", (char *)"ob_type", NULL + }; + mfem::ND_FECollection *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_ND_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2,arg3,arg4); + result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ND_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::DG_Interface_FECollection *result = 0 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2,arg3); + result = (mfem::FiniteElement *)((mfem::ND_FECollection const *)arg1)->FiniteElementForGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ND_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::DG_Interface_FECollection *result = 0 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2); + result = (int)((mfem::ND_FECollection const *)arg1)->DofForGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 +SWIGINTERN PyObject *_wrap_ND_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL }; + int *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DG_Interface_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_DG_Interface_FECollection__SWIG_2(self, argc, argv); - } - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_DG_Interface_FECollection__SWIG_1(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_DG_Interface_FECollection__SWIG_0(self, argc, argv); - } - } - } + { + try { + result = (int *)((mfem::ND_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DG_Interface_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DG_Interface_FECollection::DG_Interface_FECollection(int const,int const,int const,int const)\n" - " mfem::DG_Interface_FECollection::DG_Interface_FECollection(int const,int const,int const)\n" - " mfem::DG_Interface_FECollection::DG_Interface_FECollection(int const,int const)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_delete_DG_Interface_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::DG_Interface_FECollection *arg1 = (mfem::DG_Interface_FECollection *) 0 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + char *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DG_Interface_FECollection" "', argument " "1"" of type '" "mfem::DG_Interface_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_Name" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } - arg1 = reinterpret_cast< mfem::DG_Interface_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); { try { - delete arg1; + result = (char *)((mfem::ND_FECollection const *)arg1)->Name(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *DG_Interface_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DG_Interface_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::ND_FECollection *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::ND_FECollection *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_FECollection::ND_FECollection(int const,int const,int const,int const)\n" - " mfem::ND_FECollection::ND_FECollection(int const,int const,int const)\n" - " mfem::ND_FECollection::ND_FECollection(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ND_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "ND_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (mfem::FiniteElement *)((mfem::ND_FECollection const *)arg1)->FiniteElementForGeometry(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ND_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "ND_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (int)((mfem::ND_FECollection const *)arg1)->DofForGeometry(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ND_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[3] ; - int *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "ND_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (int *)((mfem::ND_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ND_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - char *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_Name" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - { - try { - result = (char *)((mfem::ND_FECollection const *)arg1)->Name(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_FromCharPtr((const char *)result); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ND_FECollection_GetTraceCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElementCollection *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_GetTraceCollection" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - { - try { - result = (mfem::FiniteElementCollection *)((mfem::ND_FECollection const *)arg1)->GetTraceCollection(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_ND_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_FECollection_GetTraceCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + mfem::FiniteElementCollection *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_FECollection" "', argument " "1"" of type '" "mfem::ND_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_GetTraceCollection" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); { try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ND_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ND_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::ND_Trace_FECollection *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::ND_Trace_FECollection *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_Trace_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2); + result = (mfem::FiniteElementCollection *)((mfem::ND_FECollection const *)arg1)->GetTraceCollection(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_Trace_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_Trace_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_Trace_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_Trace_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_Trace_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_Trace_FECollection::ND_Trace_FECollection(int const,int const,int const,int const)\n" - " mfem::ND_Trace_FECollection::ND_Trace_FECollection(int const,int const,int const)\n" - " mfem::ND_Trace_FECollection::ND_Trace_FECollection(int const,int const)\n"); - return 0; +fail: + return NULL; } -SWIGINTERN PyObject *_wrap_delete_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ND_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ND_Trace_FECollection *arg1 = (mfem::ND_Trace_FECollection *) 0 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_Trace_FECollection" "', argument " "1"" of type '" "mfem::ND_Trace_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_FECollection" "', argument " "1"" of type '" "mfem::ND_FECollection *""'"); } - arg1 = reinterpret_cast< mfem::ND_Trace_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); { try { delete arg1; @@ -7287,96 +5832,146 @@ SWIGINTERN PyObject *_wrap_delete_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *ND_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ND_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_FECollection, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ND_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ND_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_NURBSFECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - mfem::NURBSFECollection *result = 0 ; + int arg2 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"cb_type", (char *)"ob_type", NULL + }; + mfem::ND_Trace_FECollection *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_ND_Trace_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); + } + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (mfem::NURBSFECollection *)new mfem::NURBSFECollection(arg1); + result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NURBSFECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_NURBSFECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_delete_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NURBSFECollection *result = 0 ; + mfem::ND_Trace_FECollection *arg1 = (mfem::ND_Trace_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_Trace_FECollection" "', argument " "1"" of type '" "mfem::ND_Trace_FECollection *""'"); + } + arg1 = reinterpret_cast< mfem::ND_Trace_FECollection * >(argp1); { try { - result = (mfem::NURBSFECollection *)new mfem::NURBSFECollection(); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NURBSFECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_NURBSFECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 +SWIGINTERN PyObject *ND_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ND_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_NURBSFECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + int arg1 = (int) mfem::NURBSFECollection::VariableOrder ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"Order", NULL }; + mfem::NURBSFECollection *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_NURBSFECollection", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_NURBSFECollection__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_NURBSFECollection", kwnames, &obj0)) SWIG_fail; + if (obj0) { { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } - if (_v) { - return _wrap_new_NURBSFECollection__SWIG_0(self, argc, argv); + } + { + try { + result = (mfem::NURBSFECollection *)new mfem::NURBSFECollection(arg1); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NURBSFECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NURBSFECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NURBSFECollection::NURBSFECollection(int)\n" - " mfem::NURBSFECollection::NURBSFECollection()\n"); - return 0; + return NULL; } @@ -7439,25 +6034,29 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_GetOrder(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_NURBSFECollection_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Order", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_SetOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFECollection_SetOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_SetOrder" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7474,7 +6073,7 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_SetOrder(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7482,16 +6081,20 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NURBSFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -7511,7 +6114,7 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7519,16 +6122,20 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSED int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NURBSFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -7548,7 +6155,7 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_NURBSFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7557,25 +6164,30 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_DofOrderForOrientation(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBSFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NURBSFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -7712,7 +6324,7 @@ SWIGINTERN PyObject *_wrap_new_LinearFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFECollection *arg1 = (mfem::LinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7720,16 +6332,20 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -7749,7 +6365,7 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFECollection *arg1 = (mfem::LinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7757,16 +6373,20 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -7786,7 +6406,7 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_LinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFECollection *arg1 = (mfem::LinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7795,25 +6415,30 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -7920,7 +6545,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticFECollection(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticFECollection *arg1 = (mfem::QuadraticFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7928,16 +6553,20 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObje int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -7957,7 +6586,7 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObje } -SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticFECollection *arg1 = (mfem::QuadraticFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -7965,16 +6594,20 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUN int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -7994,7 +6627,7 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticFECollection *arg1 = (mfem::QuadraticFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8003,25 +6636,30 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofOrderForOrientation(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -8128,7 +6766,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticPosFECollection(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosFECollection *arg1 = (mfem::QuadraticPosFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8136,16 +6774,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyO int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8165,7 +6807,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyO } -SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosFECollection *arg1 = (mfem::QuadraticPosFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8173,16 +6815,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWI int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8202,7 +6848,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWI } -SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosFECollection *arg1 = (mfem::QuadraticPosFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8211,25 +6857,30 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofOrderForOrientation(PyObj int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticPosFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticPosFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -8336,7 +6987,7 @@ SWIGINTERN PyObject *_wrap_new_CubicFECollection(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicFECollection *arg1 = (mfem::CubicFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8344,16 +6995,20 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::CubicFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8373,7 +7028,7 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicFECollection *arg1 = (mfem::CubicFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8381,16 +7036,20 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSED int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CubicFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::CubicFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8410,7 +7069,7 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_CubicFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicFECollection *arg1 = (mfem::CubicFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8419,25 +7078,30 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_DofOrderForOrientation(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CubicFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::CubicFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -8544,7 +7208,7 @@ SWIGINTERN PyObject *_wrap_new_CrouzeixRaviartFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFECollection *arg1 = (mfem::CrouzeixRaviartFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8552,16 +7216,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CrouzeixRaviartFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrouzeixRaviartFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8581,7 +7249,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFECollection *arg1 = (mfem::CrouzeixRaviartFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8589,16 +7257,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CrouzeixRaviartFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrouzeixRaviartFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8618,7 +7290,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFECollection *arg1 = (mfem::CrouzeixRaviartFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8627,25 +7299,30 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrouzeixRaviartFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -8752,7 +7429,7 @@ SWIGINTERN PyObject *_wrap_new_LinearNonConf3DFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearNonConf3DFECollection *arg1 = (mfem::LinearNonConf3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8760,16 +7437,20 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearNonConf3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearNonConf3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearNonConf3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearNonConf3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearNonConf3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearNonConf3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8789,7 +7470,7 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearNonConf3DFECollection *arg1 = (mfem::LinearNonConf3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8797,16 +7478,20 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearNonConf3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearNonConf3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearNonConf3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearNonConf3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearNonConf3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearNonConf3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8826,7 +7511,7 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearNonConf3DFECollection *arg1 = (mfem::LinearNonConf3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8835,25 +7520,30 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearNonConf3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearNonConf3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearNonConf3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearNonConf3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearNonConf3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearNonConf3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -8960,7 +7650,7 @@ SWIGINTERN PyObject *_wrap_new_RT0_2DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_2DFECollection *arg1 = (mfem::RT0_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8968,16 +7658,20 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT0_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8997,7 +7691,7 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_2DFECollection *arg1 = (mfem::RT0_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9005,16 +7699,20 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT0_2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT0_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9034,7 +7732,7 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_2DFECollection *arg1 = (mfem::RT0_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9043,25 +7741,30 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0_2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT0_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9168,7 +7871,7 @@ SWIGINTERN PyObject *_wrap_new_RT1_2DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_2DFECollection *arg1 = (mfem::RT1_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9176,16 +7879,20 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT1_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9205,7 +7912,7 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_2DFECollection *arg1 = (mfem::RT1_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9213,16 +7920,20 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT1_2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT1_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9242,7 +7953,7 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_2DFECollection *arg1 = (mfem::RT1_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9251,25 +7962,30 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1_2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT1_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9376,7 +8092,7 @@ SWIGINTERN PyObject *_wrap_new_RT2_2DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2_2DFECollection *arg1 = (mfem::RT2_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9384,16 +8100,20 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT2_2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT2_2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2_2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT2_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT2_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT2_2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9413,7 +8133,7 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2_2DFECollection *arg1 = (mfem::RT2_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9421,16 +8141,20 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT2_2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT2_2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2_2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT2_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT2_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT2_2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9450,7 +8174,7 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2_2DFECollection *arg1 = (mfem::RT2_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9459,25 +8183,30 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT2_2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2_2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2_2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT2_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT2_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT2_2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9584,7 +8313,7 @@ SWIGINTERN PyObject *_wrap_new_Const2DFECollection(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const2DFECollection *arg1 = (mfem::Const2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9592,16 +8321,20 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::Const2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9621,7 +8354,7 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const2DFECollection *arg1 = (mfem::Const2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9629,16 +8362,20 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUS int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Const2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::Const2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9658,7 +8395,7 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Const2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const2DFECollection *arg1 = (mfem::Const2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9667,25 +8404,30 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_DofOrderForOrientation(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Const2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::Const2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9792,7 +8534,7 @@ SWIGINTERN PyObject *_wrap_new_LinearDiscont2DFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont2DFECollection *arg1 = (mfem::LinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9800,16 +8542,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9829,7 +8575,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont2DFECollection *arg1 = (mfem::LinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9837,16 +8583,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9866,7 +8616,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont2DFECollection *arg1 = (mfem::LinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9875,25 +8625,30 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10000,7 +8755,7 @@ SWIGINTERN PyObject *_wrap_new_GaussLinearDiscont2DFECollection(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinearDiscont2DFECollection *arg1 = (mfem::GaussLinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10008,16 +8763,20 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeom int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussLinearDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::GaussLinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussLinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10037,7 +8796,7 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeom } -SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinearDiscont2DFECollection *arg1 = (mfem::GaussLinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10045,16 +8804,20 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObj int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GaussLinearDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussLinearDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinearDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::GaussLinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussLinearDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10074,7 +8837,7 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObj } -SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinearDiscont2DFECollection *arg1 = (mfem::GaussLinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10083,25 +8846,30 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientati int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussLinearDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinearDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::GaussLinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussLinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10208,7 +8976,7 @@ SWIGINTERN PyObject *_wrap_new_P1OnQuadFECollection(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFECollection *arg1 = (mfem::P1OnQuadFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10216,16 +8984,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObjec int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:P1OnQuadFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::P1OnQuadFECollection const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "P1OnQuadFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10245,7 +9017,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObjec } -SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFECollection *arg1 = (mfem::P1OnQuadFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10253,16 +9025,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNU int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:P1OnQuadFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::P1OnQuadFECollection const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "P1OnQuadFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10282,7 +9058,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFECollection *arg1 = (mfem::P1OnQuadFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10291,25 +9067,30 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofOrderForOrientation(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::P1OnQuadFECollection const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "P1OnQuadFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10416,7 +9197,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticDiscont2DFECollection(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont2DFECollection *arg1 = (mfem::QuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10424,16 +9205,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeomet int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10453,7 +9238,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeomet } -SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont2DFECollection *arg1 = (mfem::QuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10461,16 +9246,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObjec int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10490,7 +9279,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObjec } -SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont2DFECollection *arg1 = (mfem::QuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10499,25 +9288,30 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10624,7 +9418,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticPosDiscont2DFECollection(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosDiscont2DFECollection *arg1 = (mfem::QuadraticPosDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10632,16 +9426,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeo int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10661,7 +9459,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeo } -SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosDiscont2DFECollection *arg1 = (mfem::QuadraticPosDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10669,16 +9467,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10698,7 +9500,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyOb } -SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosDiscont2DFECollection *arg1 = (mfem::QuadraticPosDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10707,25 +9509,30 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientat int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticPosDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticPosDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10832,7 +9639,7 @@ SWIGINTERN PyObject *_wrap_new_GaussQuadraticDiscont2DFECollection(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuadraticDiscont2DFECollection *arg1 = (mfem::GaussQuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10840,16 +9647,20 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::GaussQuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10869,7 +9680,7 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForG } -SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuadraticDiscont2DFECollection *arg1 = (mfem::GaussQuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10877,16 +9688,20 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GaussQuadraticDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussQuadraticDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuadraticDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::GaussQuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussQuadraticDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10906,7 +9721,7 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(Py } -SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuadraticDiscont2DFECollection *arg1 = (mfem::GaussQuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10915,25 +9730,30 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrient int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::GaussQuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11040,7 +9860,7 @@ SWIGINTERN PyObject *_wrap_new_CubicDiscont2DFECollection(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicDiscont2DFECollection *arg1 = (mfem::CubicDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11048,16 +9868,20 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(P int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::CubicDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11077,7 +9901,7 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(P } -SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicDiscont2DFECollection *arg1 = (mfem::CubicDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11085,16 +9909,20 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CubicDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::CubicDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11114,7 +9942,7 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *S } -SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicDiscont2DFECollection *arg1 = (mfem::CubicDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11123,25 +9951,30 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofOrderForOrientation(PyO int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CubicDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::CubicDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11248,7 +10081,7 @@ SWIGINTERN PyObject *_wrap_new_Const3DFECollection(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const3DFECollection *arg1 = (mfem::Const3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11256,16 +10089,20 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::Const3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11285,7 +10122,7 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const3DFECollection *arg1 = (mfem::Const3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11293,16 +10130,20 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUS int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Const3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::Const3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11322,7 +10163,7 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Const3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const3DFECollection *arg1 = (mfem::Const3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11331,25 +10172,30 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_DofOrderForOrientation(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Const3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::Const3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11456,7 +10302,7 @@ SWIGINTERN PyObject *_wrap_new_LinearDiscont3DFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont3DFECollection *arg1 = (mfem::LinearDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11464,16 +10310,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11493,7 +10343,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont3DFECollection *arg1 = (mfem::LinearDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11501,16 +10351,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11530,7 +10384,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont3DFECollection *arg1 = (mfem::LinearDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11539,25 +10393,30 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearDiscont3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11664,7 +10523,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticDiscont3DFECollection(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont3DFECollection *arg1 = (mfem::QuadraticDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11672,16 +10531,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeomet int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11701,7 +10564,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeomet } -SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont3DFECollection *arg1 = (mfem::QuadraticDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11709,16 +10572,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObjec int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11738,7 +10605,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObjec } -SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont3DFECollection *arg1 = (mfem::QuadraticDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11747,25 +10614,30 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticDiscont3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11872,7 +10744,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinearFECollection(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinearFECollection *arg1 = (mfem::RefinedLinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11880,16 +10752,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinearFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RefinedLinearFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinearFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RefinedLinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RefinedLinearFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11909,7 +10785,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(Py } -SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinearFECollection *arg1 = (mfem::RefinedLinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11917,16 +10793,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinearFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RefinedLinearFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinearFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RefinedLinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RefinedLinearFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11946,7 +10826,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SW } -SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinearFECollection *arg1 = (mfem::RefinedLinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11955,25 +10835,30 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofOrderForOrientation(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinearFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinearFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinearFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RefinedLinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RefinedLinearFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12080,7 +10965,7 @@ SWIGINTERN PyObject *_wrap_new_ND1_3DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND1_3DFECollection *arg1 = (mfem::ND1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12088,16 +10973,20 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ND1_3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND1_3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND1_3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::ND1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND1_3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12117,7 +11006,7 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND1_3DFECollection *arg1 = (mfem::ND1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12125,16 +11014,20 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ND1_3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND1_3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND1_3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::ND1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND1_3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12154,7 +11047,7 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND1_3DFECollection *arg1 = (mfem::ND1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12163,25 +11056,30 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ND1_3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND1_3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND1_3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::ND1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND1_3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12288,7 +11186,7 @@ SWIGINTERN PyObject *_wrap_new_RT0_3DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_3DFECollection *arg1 = (mfem::RT0_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12296,16 +11194,20 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT0_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12325,7 +11227,7 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_3DFECollection *arg1 = (mfem::RT0_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12333,16 +11235,20 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT0_3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT0_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12362,7 +11268,7 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_3DFECollection *arg1 = (mfem::RT0_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12371,25 +11277,30 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0_3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT0_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12496,7 +11407,7 @@ SWIGINTERN PyObject *_wrap_new_RT1_3DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_3DFECollection *arg1 = (mfem::RT1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12504,16 +11415,20 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12533,7 +11448,7 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_3DFECollection *arg1 = (mfem::RT1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12541,16 +11456,20 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT1_3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12570,7 +11489,7 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_3DFECollection *arg1 = (mfem::RT1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12579,25 +11498,30 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1_3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12684,18 +11608,20 @@ SWIGINTERN PyObject *RT1_3DFECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_Local_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Local_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"fe_name", NULL + }; mfem::Local_FECollection *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_Local_FECollection", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Local_FECollection" "', argument " "1"" of type '" "char const *""'"); } @@ -12717,7 +11643,7 @@ SWIGINTERN PyObject *_wrap_new_Local_FECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Local_FECollection *arg1 = (mfem::Local_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12725,16 +11651,20 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Local_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Local_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Local_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::Local_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::Local_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Local_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12754,7 +11684,7 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Local_FECollection *arg1 = (mfem::Local_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12762,16 +11692,20 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Local_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Local_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Local_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::Local_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::Local_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Local_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12791,7 +11725,7 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Local_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Local_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Local_FECollection *arg1 = (mfem::Local_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12800,25 +11734,30 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Local_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Local_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Local_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::Local_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::Local_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Local_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12908,288 +11847,288 @@ SWIGINTERN PyObject *Local_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "FiniteElementCollection_FiniteElementForGeometry", _wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementCollection_FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "FiniteElementCollection_DofForGeometry", _wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS, "FiniteElementCollection_DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_DofOrderForOrientation", _wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS, "FiniteElementCollection_DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "FiniteElementCollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "FiniteElementCollection_Name", _wrap_FiniteElementCollection_Name, METH_O, "FiniteElementCollection_Name(FiniteElementCollection self) -> char const *"}, - { "FiniteElementCollection_HasFaceDofs", _wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS, "FiniteElementCollection_HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_TraceFiniteElementForGeometry", _wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS, "FiniteElementCollection_TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_HasFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "FiniteElementCollection_GetTraceCollection", _wrap_FiniteElementCollection_GetTraceCollection, METH_O, "FiniteElementCollection_GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection"}, { "delete_FiniteElementCollection", _wrap_delete_FiniteElementCollection, METH_O, "delete_FiniteElementCollection(FiniteElementCollection self)"}, - { "FiniteElementCollection_New", _wrap_FiniteElementCollection_New, METH_O, "FiniteElementCollection_New(char const * name) -> FiniteElementCollection"}, - { "FiniteElementCollection_SubDofOrder", _wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS, "FiniteElementCollection_SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, + { "FiniteElementCollection_New", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_New, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_New(char const * name) -> FiniteElementCollection"}, + { "FiniteElementCollection_SubDofOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, { "FiniteElementCollection_swigregister", FiniteElementCollection_swigregister, METH_O, NULL}, - { "new_H1_FECollection", _wrap_new_H1_FECollection, METH_VARARGS, "H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto)"}, - { "H1_FECollection_FiniteElementForGeometry", _wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS, "H1_FECollection_FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "H1_FECollection_DofForGeometry", _wrap_H1_FECollection_DofForGeometry, METH_VARARGS, "H1_FECollection_DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "H1_FECollection_DofOrderForOrientation", _wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS, "H1_FECollection_DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_H1_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto) -> H1_FECollection"}, + { "H1_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "H1_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "H1_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "H1_FECollection_Name", _wrap_H1_FECollection_Name, METH_O, "H1_FECollection_Name(H1_FECollection self) -> char const *"}, { "H1_FECollection_GetTraceCollection", _wrap_H1_FECollection_GetTraceCollection, METH_O, "H1_FECollection_GetTraceCollection(H1_FECollection self) -> FiniteElementCollection"}, { "H1_FECollection_GetBasisType", _wrap_H1_FECollection_GetBasisType, METH_O, "H1_FECollection_GetBasisType(H1_FECollection self) -> int"}, - { "H1_FECollection_GetDofMap", _wrap_H1_FECollection_GetDofMap, METH_VARARGS, "H1_FECollection_GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, + { "H1_FECollection_GetDofMap", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_GetDofMap, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, { "delete_H1_FECollection", _wrap_delete_H1_FECollection, METH_O, "delete_H1_FECollection(H1_FECollection self)"}, { "H1_FECollection_swigregister", H1_FECollection_swigregister, METH_O, NULL}, { "H1_FECollection_swiginit", H1_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_FECollection", _wrap_new_H1Pos_FECollection, METH_VARARGS, "H1Pos_FECollection(int const p, int const dim=3)"}, + { "new_H1Pos_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_FECollection(int const p, int const dim=3) -> H1Pos_FECollection"}, { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "new_H1Ser_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_FECollection(int const p, int const dim=2) -> H1Ser_FECollection"}, { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, + { "new_H1_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto) -> H1_Trace_FECollection"}, { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, { "H1_Trace_FECollection_swiginit", H1_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_L2_FECollection", _wrap_new_L2_FECollection, METH_VARARGS, "L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE)"}, - { "L2_FECollection_FiniteElementForGeometry", _wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS, "L2_FECollection_FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "L2_FECollection_DofForGeometry", _wrap_L2_FECollection_DofForGeometry, METH_VARARGS, "L2_FECollection_DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "L2_FECollection_DofOrderForOrientation", _wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS, "L2_FECollection_DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_L2_FECollection", (PyCFunction)(void(*)(void))_wrap_new_L2_FECollection, METH_VARARGS|METH_KEYWORDS, "new_L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE) -> L2_FECollection"}, + { "L2_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "L2_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "L2_FECollection_Name", _wrap_L2_FECollection_Name, METH_O, "L2_FECollection_Name(L2_FECollection self) -> char const *"}, - { "L2_FECollection_TraceFiniteElementForGeometry", _wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS, "L2_FECollection_TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "L2_FECollection_GetBasisType", _wrap_L2_FECollection_GetBasisType, METH_O, "L2_FECollection_GetBasisType(L2_FECollection self) -> int"}, { "delete_L2_FECollection", _wrap_delete_L2_FECollection, METH_O, "delete_L2_FECollection(L2_FECollection self)"}, { "L2_FECollection_swigregister", L2_FECollection_swigregister, METH_O, NULL}, { "L2_FECollection_swiginit", L2_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, "RT_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "RT_FECollection_FiniteElementForGeometry", _wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS, "RT_FECollection_FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT_FECollection_DofForGeometry", _wrap_RT_FECollection_DofForGeometry, METH_VARARGS, "RT_FECollection_DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT_FECollection_DofOrderForOrientation", _wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS, "RT_FECollection_DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, NULL}, + { "RT_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT_FECollection_FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT_FECollection_DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT_FECollection_DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT_FECollection_Name", _wrap_RT_FECollection_Name, METH_O, "RT_FECollection_Name(RT_FECollection self) -> char const *"}, { "RT_FECollection_GetTraceCollection", _wrap_RT_FECollection_GetTraceCollection, METH_O, "RT_FECollection_GetTraceCollection(RT_FECollection self) -> FiniteElementCollection"}, { "delete_RT_FECollection", _wrap_delete_RT_FECollection, METH_O, "delete_RT_FECollection(RT_FECollection self)"}, { "RT_FECollection_swigregister", RT_FECollection_swigregister, METH_O, NULL}, { "RT_FECollection_swiginit", RT_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_Trace_FECollection", _wrap_new_RT_Trace_FECollection, METH_VARARGS, "RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre)"}, + { "new_RT_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_RT_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre) -> RT_Trace_FECollection"}, { "delete_RT_Trace_FECollection", _wrap_delete_RT_Trace_FECollection, METH_O, "delete_RT_Trace_FECollection(RT_Trace_FECollection self)"}, { "RT_Trace_FECollection_swigregister", RT_Trace_FECollection_swigregister, METH_O, NULL}, { "RT_Trace_FECollection_swiginit", RT_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_DG_Interface_FECollection", _wrap_new_DG_Interface_FECollection, METH_VARARGS, "DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre)"}, + { "new_DG_Interface_FECollection", (PyCFunction)(void(*)(void))_wrap_new_DG_Interface_FECollection, METH_VARARGS|METH_KEYWORDS, "new_DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre) -> DG_Interface_FECollection"}, { "delete_DG_Interface_FECollection", _wrap_delete_DG_Interface_FECollection, METH_O, "delete_DG_Interface_FECollection(DG_Interface_FECollection self)"}, { "DG_Interface_FECollection_swigregister", DG_Interface_FECollection_swigregister, METH_O, NULL}, { "DG_Interface_FECollection_swiginit", DG_Interface_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_FECollection", _wrap_new_ND_FECollection, METH_VARARGS, "ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "ND_FECollection_FiniteElementForGeometry", _wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS, "ND_FECollection_FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND_FECollection_DofForGeometry", _wrap_ND_FECollection_DofForGeometry, METH_VARARGS, "ND_FECollection_DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND_FECollection_DofOrderForOrientation", _wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS, "ND_FECollection_DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_ND_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_FECollection"}, + { "ND_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "ND_FECollection_FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "ND_FECollection_DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "ND_FECollection_DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND_FECollection_Name", _wrap_ND_FECollection_Name, METH_O, "ND_FECollection_Name(ND_FECollection self) -> char const *"}, { "ND_FECollection_GetTraceCollection", _wrap_ND_FECollection_GetTraceCollection, METH_O, "ND_FECollection_GetTraceCollection(ND_FECollection self) -> FiniteElementCollection"}, { "delete_ND_FECollection", _wrap_delete_ND_FECollection, METH_O, "delete_ND_FECollection(ND_FECollection self)"}, { "ND_FECollection_swigregister", ND_FECollection_swigregister, METH_O, NULL}, { "ND_FECollection_swiginit", ND_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_Trace_FECollection", _wrap_new_ND_Trace_FECollection, METH_VARARGS, "ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_Trace_FECollection"}, { "delete_ND_Trace_FECollection", _wrap_delete_ND_Trace_FECollection, METH_O, "delete_ND_Trace_FECollection(ND_Trace_FECollection self)"}, { "ND_Trace_FECollection_swigregister", ND_Trace_FECollection_swigregister, METH_O, NULL}, { "ND_Trace_FECollection_swiginit", ND_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_NURBSFECollection", _wrap_new_NURBSFECollection, METH_VARARGS, "NURBSFECollection(int Order=VariableOrder)"}, + { "new_NURBSFECollection", (PyCFunction)(void(*)(void))_wrap_new_NURBSFECollection, METH_VARARGS|METH_KEYWORDS, "new_NURBSFECollection(int Order=VariableOrder) -> NURBSFECollection"}, { "NURBSFECollection_Reset", _wrap_NURBSFECollection_Reset, METH_O, "NURBSFECollection_Reset(NURBSFECollection self)"}, { "NURBSFECollection_GetOrder", _wrap_NURBSFECollection_GetOrder, METH_O, "NURBSFECollection_GetOrder(NURBSFECollection self) -> int"}, - { "NURBSFECollection_SetOrder", _wrap_NURBSFECollection_SetOrder, METH_VARARGS, "NURBSFECollection_SetOrder(NURBSFECollection self, int Order)"}, - { "NURBSFECollection_FiniteElementForGeometry", _wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS, "NURBSFECollection_FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "NURBSFECollection_DofForGeometry", _wrap_NURBSFECollection_DofForGeometry, METH_VARARGS, "NURBSFECollection_DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "NURBSFECollection_DofOrderForOrientation", _wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS, "NURBSFECollection_DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "NURBSFECollection_SetOrder", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_SetOrder, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_SetOrder(NURBSFECollection self, int Order)"}, + { "NURBSFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "NURBSFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "NURBSFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "NURBSFECollection_Name", _wrap_NURBSFECollection_Name, METH_O, "NURBSFECollection_Name(NURBSFECollection self) -> char const *"}, { "NURBSFECollection_GetTraceCollection", _wrap_NURBSFECollection_GetTraceCollection, METH_O, "NURBSFECollection_GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection"}, { "delete_NURBSFECollection", _wrap_delete_NURBSFECollection, METH_O, "delete_NURBSFECollection(NURBSFECollection self)"}, { "NURBSFECollection_swigregister", NURBSFECollection_swigregister, METH_O, NULL}, { "NURBSFECollection_swiginit", NURBSFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearFECollection", _wrap_new_LinearFECollection, METH_NOARGS, "new_LinearFECollection() -> LinearFECollection"}, - { "LinearFECollection_FiniteElementForGeometry", _wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearFECollection_FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearFECollection_DofForGeometry", _wrap_LinearFECollection_DofForGeometry, METH_VARARGS, "LinearFECollection_DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearFECollection_DofOrderForOrientation", _wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS, "LinearFECollection_DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearFECollection_FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearFECollection_DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearFECollection_DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearFECollection_Name", _wrap_LinearFECollection_Name, METH_O, "LinearFECollection_Name(LinearFECollection self) -> char const *"}, { "delete_LinearFECollection", _wrap_delete_LinearFECollection, METH_O, "delete_LinearFECollection(LinearFECollection self)"}, { "LinearFECollection_swigregister", LinearFECollection_swigregister, METH_O, NULL}, { "LinearFECollection_swiginit", LinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticFECollection", _wrap_new_QuadraticFECollection, METH_NOARGS, "new_QuadraticFECollection() -> QuadraticFECollection"}, - { "QuadraticFECollection_FiniteElementForGeometry", _wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticFECollection_FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticFECollection_DofForGeometry", _wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS, "QuadraticFECollection_DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticFECollection_DofOrderForOrientation", _wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticFECollection_DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticFECollection_FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticFECollection_DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticFECollection_DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticFECollection_Name", _wrap_QuadraticFECollection_Name, METH_O, "QuadraticFECollection_Name(QuadraticFECollection self) -> char const *"}, { "delete_QuadraticFECollection", _wrap_delete_QuadraticFECollection, METH_O, "delete_QuadraticFECollection(QuadraticFECollection self)"}, { "QuadraticFECollection_swigregister", QuadraticFECollection_swigregister, METH_O, NULL}, { "QuadraticFECollection_swiginit", QuadraticFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosFECollection", _wrap_new_QuadraticPosFECollection, METH_NOARGS, "new_QuadraticPosFECollection() -> QuadraticPosFECollection"}, - { "QuadraticPosFECollection_FiniteElementForGeometry", _wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticPosFECollection_FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosFECollection_DofForGeometry", _wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS, "QuadraticPosFECollection_DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosFECollection_DofOrderForOrientation", _wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticPosFECollection_DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosFECollection_FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosFECollection_DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticPosFECollection_DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosFECollection_Name", _wrap_QuadraticPosFECollection_Name, METH_O, "QuadraticPosFECollection_Name(QuadraticPosFECollection self) -> char const *"}, { "delete_QuadraticPosFECollection", _wrap_delete_QuadraticPosFECollection, METH_O, "delete_QuadraticPosFECollection(QuadraticPosFECollection self)"}, { "QuadraticPosFECollection_swigregister", QuadraticPosFECollection_swigregister, METH_O, NULL}, { "QuadraticPosFECollection_swiginit", QuadraticPosFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicFECollection", _wrap_new_CubicFECollection, METH_NOARGS, "new_CubicFECollection() -> CubicFECollection"}, - { "CubicFECollection_FiniteElementForGeometry", _wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS, "CubicFECollection_FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicFECollection_DofForGeometry", _wrap_CubicFECollection_DofForGeometry, METH_VARARGS, "CubicFECollection_DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicFECollection_DofOrderForOrientation", _wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS, "CubicFECollection_DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicFECollection_FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicFECollection_DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "CubicFECollection_DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicFECollection_Name", _wrap_CubicFECollection_Name, METH_O, "CubicFECollection_Name(CubicFECollection self) -> char const *"}, { "delete_CubicFECollection", _wrap_delete_CubicFECollection, METH_O, "delete_CubicFECollection(CubicFECollection self)"}, { "CubicFECollection_swigregister", CubicFECollection_swigregister, METH_O, NULL}, { "CubicFECollection_swiginit", CubicFECollection_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFECollection", _wrap_new_CrouzeixRaviartFECollection, METH_NOARGS, "new_CrouzeixRaviartFECollection() -> CrouzeixRaviartFECollection"}, - { "CrouzeixRaviartFECollection_FiniteElementForGeometry", _wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS, "CrouzeixRaviartFECollection_FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CrouzeixRaviartFECollection_DofForGeometry", _wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS, "CrouzeixRaviartFECollection_DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CrouzeixRaviartFECollection_DofOrderForOrientation", _wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS, "CrouzeixRaviartFECollection_DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CrouzeixRaviartFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFECollection_FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CrouzeixRaviartFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFECollection_DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CrouzeixRaviartFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFECollection_DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CrouzeixRaviartFECollection_Name", _wrap_CrouzeixRaviartFECollection_Name, METH_O, "CrouzeixRaviartFECollection_Name(CrouzeixRaviartFECollection self) -> char const *"}, { "delete_CrouzeixRaviartFECollection", _wrap_delete_CrouzeixRaviartFECollection, METH_O, "delete_CrouzeixRaviartFECollection(CrouzeixRaviartFECollection self)"}, { "CrouzeixRaviartFECollection_swigregister", CrouzeixRaviartFECollection_swigregister, METH_O, NULL}, { "CrouzeixRaviartFECollection_swiginit", CrouzeixRaviartFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearNonConf3DFECollection", _wrap_new_LinearNonConf3DFECollection, METH_NOARGS, "new_LinearNonConf3DFECollection() -> LinearNonConf3DFECollection"}, - { "LinearNonConf3DFECollection_FiniteElementForGeometry", _wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearNonConf3DFECollection_FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearNonConf3DFECollection_DofForGeometry", _wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS, "LinearNonConf3DFECollection_DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearNonConf3DFECollection_DofOrderForOrientation", _wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS, "LinearNonConf3DFECollection_DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearNonConf3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearNonConf3DFECollection_FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearNonConf3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearNonConf3DFECollection_DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearNonConf3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearNonConf3DFECollection_DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearNonConf3DFECollection_Name", _wrap_LinearNonConf3DFECollection_Name, METH_O, "LinearNonConf3DFECollection_Name(LinearNonConf3DFECollection self) -> char const *"}, { "delete_LinearNonConf3DFECollection", _wrap_delete_LinearNonConf3DFECollection, METH_O, "delete_LinearNonConf3DFECollection(LinearNonConf3DFECollection self)"}, { "LinearNonConf3DFECollection_swigregister", LinearNonConf3DFECollection_swigregister, METH_O, NULL}, { "LinearNonConf3DFECollection_swiginit", LinearNonConf3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_2DFECollection", _wrap_new_RT0_2DFECollection, METH_NOARGS, "new_RT0_2DFECollection() -> RT0_2DFECollection"}, - { "RT0_2DFECollection_FiniteElementForGeometry", _wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT0_2DFECollection_FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_2DFECollection_DofForGeometry", _wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS, "RT0_2DFECollection_DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_2DFECollection_DofOrderForOrientation", _wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS, "RT0_2DFECollection_DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_2DFECollection_FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_2DFECollection_DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT0_2DFECollection_DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_2DFECollection_Name", _wrap_RT0_2DFECollection_Name, METH_O, "RT0_2DFECollection_Name(RT0_2DFECollection self) -> char const *"}, { "delete_RT0_2DFECollection", _wrap_delete_RT0_2DFECollection, METH_O, "delete_RT0_2DFECollection(RT0_2DFECollection self)"}, { "RT0_2DFECollection_swigregister", RT0_2DFECollection_swigregister, METH_O, NULL}, { "RT0_2DFECollection_swiginit", RT0_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_2DFECollection", _wrap_new_RT1_2DFECollection, METH_NOARGS, "new_RT1_2DFECollection() -> RT1_2DFECollection"}, - { "RT1_2DFECollection_FiniteElementForGeometry", _wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT1_2DFECollection_FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_2DFECollection_DofForGeometry", _wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS, "RT1_2DFECollection_DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_2DFECollection_DofOrderForOrientation", _wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS, "RT1_2DFECollection_DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_2DFECollection_FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_2DFECollection_DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT1_2DFECollection_DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_2DFECollection_Name", _wrap_RT1_2DFECollection_Name, METH_O, "RT1_2DFECollection_Name(RT1_2DFECollection self) -> char const *"}, { "delete_RT1_2DFECollection", _wrap_delete_RT1_2DFECollection, METH_O, "delete_RT1_2DFECollection(RT1_2DFECollection self)"}, { "RT1_2DFECollection_swigregister", RT1_2DFECollection_swigregister, METH_O, NULL}, { "RT1_2DFECollection_swiginit", RT1_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT2_2DFECollection", _wrap_new_RT2_2DFECollection, METH_NOARGS, "new_RT2_2DFECollection() -> RT2_2DFECollection"}, - { "RT2_2DFECollection_FiniteElementForGeometry", _wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT2_2DFECollection_FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT2_2DFECollection_DofForGeometry", _wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS, "RT2_2DFECollection_DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT2_2DFECollection_DofOrderForOrientation", _wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS, "RT2_2DFECollection_DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT2_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT2_2DFECollection_FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT2_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT2_2DFECollection_DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT2_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT2_2DFECollection_DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT2_2DFECollection_Name", _wrap_RT2_2DFECollection_Name, METH_O, "RT2_2DFECollection_Name(RT2_2DFECollection self) -> char const *"}, { "delete_RT2_2DFECollection", _wrap_delete_RT2_2DFECollection, METH_O, "delete_RT2_2DFECollection(RT2_2DFECollection self)"}, { "RT2_2DFECollection_swigregister", RT2_2DFECollection_swigregister, METH_O, NULL}, { "RT2_2DFECollection_swiginit", RT2_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const2DFECollection", _wrap_new_Const2DFECollection, METH_NOARGS, "new_Const2DFECollection() -> Const2DFECollection"}, - { "Const2DFECollection_FiniteElementForGeometry", _wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS, "Const2DFECollection_FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const2DFECollection_DofForGeometry", _wrap_Const2DFECollection_DofForGeometry, METH_VARARGS, "Const2DFECollection_DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const2DFECollection_DofOrderForOrientation", _wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS, "Const2DFECollection_DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "Const2DFECollection_FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "Const2DFECollection_DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "Const2DFECollection_DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const2DFECollection_Name", _wrap_Const2DFECollection_Name, METH_O, "Const2DFECollection_Name(Const2DFECollection self) -> char const *"}, { "delete_Const2DFECollection", _wrap_delete_Const2DFECollection, METH_O, "delete_Const2DFECollection(Const2DFECollection self)"}, { "Const2DFECollection_swigregister", Const2DFECollection_swigregister, METH_O, NULL}, { "Const2DFECollection_swiginit", Const2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont2DFECollection", _wrap_new_LinearDiscont2DFECollection, METH_NOARGS, "new_LinearDiscont2DFECollection() -> LinearDiscont2DFECollection"}, - { "LinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearDiscont2DFECollection_FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont2DFECollection_DofForGeometry", _wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "LinearDiscont2DFECollection_DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont2DFECollection_DofOrderForOrientation", _wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "LinearDiscont2DFECollection_DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont2DFECollection_FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont2DFECollection_DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearDiscont2DFECollection_DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont2DFECollection_Name", _wrap_LinearDiscont2DFECollection_Name, METH_O, "LinearDiscont2DFECollection_Name(LinearDiscont2DFECollection self) -> char const *"}, { "delete_LinearDiscont2DFECollection", _wrap_delete_LinearDiscont2DFECollection, METH_O, "delete_LinearDiscont2DFECollection(LinearDiscont2DFECollection self)"}, { "LinearDiscont2DFECollection_swigregister", LinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont2DFECollection_swiginit", LinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussLinearDiscont2DFECollection", _wrap_new_GaussLinearDiscont2DFECollection, METH_NOARGS, "new_GaussLinearDiscont2DFECollection() -> GaussLinearDiscont2DFECollection"}, - { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "GaussLinearDiscont2DFECollection_FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussLinearDiscont2DFECollection_DofForGeometry", _wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "GaussLinearDiscont2DFECollection_DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "GaussLinearDiscont2DFECollection_DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussLinearDiscont2DFECollection_FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussLinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussLinearDiscont2DFECollection_DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "GaussLinearDiscont2DFECollection_DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussLinearDiscont2DFECollection_Name", _wrap_GaussLinearDiscont2DFECollection_Name, METH_O, "GaussLinearDiscont2DFECollection_Name(GaussLinearDiscont2DFECollection self) -> char const *"}, { "delete_GaussLinearDiscont2DFECollection", _wrap_delete_GaussLinearDiscont2DFECollection, METH_O, "delete_GaussLinearDiscont2DFECollection(GaussLinearDiscont2DFECollection self)"}, { "GaussLinearDiscont2DFECollection_swigregister", GaussLinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussLinearDiscont2DFECollection_swiginit", GaussLinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFECollection", _wrap_new_P1OnQuadFECollection, METH_NOARGS, "new_P1OnQuadFECollection() -> P1OnQuadFECollection"}, - { "P1OnQuadFECollection_FiniteElementForGeometry", _wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS, "P1OnQuadFECollection_FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "P1OnQuadFECollection_DofForGeometry", _wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS, "P1OnQuadFECollection_DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "P1OnQuadFECollection_DofOrderForOrientation", _wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS, "P1OnQuadFECollection_DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "P1OnQuadFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFECollection_FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "P1OnQuadFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFECollection_DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "P1OnQuadFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFECollection_DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "P1OnQuadFECollection_Name", _wrap_P1OnQuadFECollection_Name, METH_O, "P1OnQuadFECollection_Name(P1OnQuadFECollection self) -> char const *"}, { "delete_P1OnQuadFECollection", _wrap_delete_P1OnQuadFECollection, METH_O, "delete_P1OnQuadFECollection(P1OnQuadFECollection self)"}, { "P1OnQuadFECollection_swigregister", P1OnQuadFECollection_swigregister, METH_O, NULL}, { "P1OnQuadFECollection_swiginit", P1OnQuadFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont2DFECollection", _wrap_new_QuadraticDiscont2DFECollection, METH_NOARGS, "new_QuadraticDiscont2DFECollection() -> QuadraticDiscont2DFECollection"}, - { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticDiscont2DFECollection_FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont2DFECollection_DofForGeometry", _wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "QuadraticDiscont2DFECollection_DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticDiscont2DFECollection_DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont2DFECollection_FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont2DFECollection_DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont2DFECollection_DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont2DFECollection_Name", _wrap_QuadraticDiscont2DFECollection_Name, METH_O, "QuadraticDiscont2DFECollection_Name(QuadraticDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticDiscont2DFECollection", _wrap_delete_QuadraticDiscont2DFECollection, METH_O, "delete_QuadraticDiscont2DFECollection(QuadraticDiscont2DFECollection self)"}, { "QuadraticDiscont2DFECollection_swigregister", QuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont2DFECollection_swiginit", QuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosDiscont2DFECollection", _wrap_new_QuadraticPosDiscont2DFECollection, METH_NOARGS, "new_QuadraticPosDiscont2DFECollection() -> QuadraticPosDiscont2DFECollection"}, - { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosDiscont2DFECollection_DofForGeometry", _wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS, "QuadraticPosDiscont2DFECollection_DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticPosDiscont2DFECollection_DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosDiscont2DFECollection_DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticPosDiscont2DFECollection_DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosDiscont2DFECollection_Name", _wrap_QuadraticPosDiscont2DFECollection_Name, METH_O, "QuadraticPosDiscont2DFECollection_Name(QuadraticPosDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticPosDiscont2DFECollection", _wrap_delete_QuadraticPosDiscont2DFECollection, METH_O, "delete_QuadraticPosDiscont2DFECollection(QuadraticPosDiscont2DFECollection self)"}, { "QuadraticPosDiscont2DFECollection_swigregister", QuadraticPosDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticPosDiscont2DFECollection_swiginit", QuadraticPosDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussQuadraticDiscont2DFECollection", _wrap_new_GaussQuadraticDiscont2DFECollection, METH_NOARGS, "new_GaussQuadraticDiscont2DFECollection() -> GaussQuadraticDiscont2DFECollection"}, - { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussQuadraticDiscont2DFECollection_DofForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "GaussQuadraticDiscont2DFECollection_DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussQuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussQuadraticDiscont2DFECollection_DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussQuadraticDiscont2DFECollection_Name", _wrap_GaussQuadraticDiscont2DFECollection_Name, METH_O, "GaussQuadraticDiscont2DFECollection_Name(GaussQuadraticDiscont2DFECollection self) -> char const *"}, { "delete_GaussQuadraticDiscont2DFECollection", _wrap_delete_GaussQuadraticDiscont2DFECollection, METH_O, "delete_GaussQuadraticDiscont2DFECollection(GaussQuadraticDiscont2DFECollection self)"}, { "GaussQuadraticDiscont2DFECollection_swigregister", GaussQuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussQuadraticDiscont2DFECollection_swiginit", GaussQuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicDiscont2DFECollection", _wrap_new_CubicDiscont2DFECollection, METH_NOARGS, "new_CubicDiscont2DFECollection() -> CubicDiscont2DFECollection"}, - { "CubicDiscont2DFECollection_FiniteElementForGeometry", _wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "CubicDiscont2DFECollection_FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicDiscont2DFECollection_DofForGeometry", _wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS, "CubicDiscont2DFECollection_DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicDiscont2DFECollection_DofOrderForOrientation", _wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "CubicDiscont2DFECollection_DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicDiscont2DFECollection_FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicDiscont2DFECollection_DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "CubicDiscont2DFECollection_DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicDiscont2DFECollection_Name", _wrap_CubicDiscont2DFECollection_Name, METH_O, "CubicDiscont2DFECollection_Name(CubicDiscont2DFECollection self) -> char const *"}, { "delete_CubicDiscont2DFECollection", _wrap_delete_CubicDiscont2DFECollection, METH_O, "delete_CubicDiscont2DFECollection(CubicDiscont2DFECollection self)"}, { "CubicDiscont2DFECollection_swigregister", CubicDiscont2DFECollection_swigregister, METH_O, NULL}, { "CubicDiscont2DFECollection_swiginit", CubicDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const3DFECollection", _wrap_new_Const3DFECollection, METH_NOARGS, "new_Const3DFECollection() -> Const3DFECollection"}, - { "Const3DFECollection_FiniteElementForGeometry", _wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS, "Const3DFECollection_FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const3DFECollection_DofForGeometry", _wrap_Const3DFECollection_DofForGeometry, METH_VARARGS, "Const3DFECollection_DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const3DFECollection_DofOrderForOrientation", _wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS, "Const3DFECollection_DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "Const3DFECollection_FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "Const3DFECollection_DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "Const3DFECollection_DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const3DFECollection_Name", _wrap_Const3DFECollection_Name, METH_O, "Const3DFECollection_Name(Const3DFECollection self) -> char const *"}, { "delete_Const3DFECollection", _wrap_delete_Const3DFECollection, METH_O, "delete_Const3DFECollection(Const3DFECollection self)"}, { "Const3DFECollection_swigregister", Const3DFECollection_swigregister, METH_O, NULL}, { "Const3DFECollection_swiginit", Const3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont3DFECollection", _wrap_new_LinearDiscont3DFECollection, METH_NOARGS, "new_LinearDiscont3DFECollection() -> LinearDiscont3DFECollection"}, - { "LinearDiscont3DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearDiscont3DFECollection_FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont3DFECollection_DofForGeometry", _wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS, "LinearDiscont3DFECollection_DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont3DFECollection_DofOrderForOrientation", _wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "LinearDiscont3DFECollection_DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont3DFECollection_FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont3DFECollection_DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearDiscont3DFECollection_DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont3DFECollection_Name", _wrap_LinearDiscont3DFECollection_Name, METH_O, "LinearDiscont3DFECollection_Name(LinearDiscont3DFECollection self) -> char const *"}, { "delete_LinearDiscont3DFECollection", _wrap_delete_LinearDiscont3DFECollection, METH_O, "delete_LinearDiscont3DFECollection(LinearDiscont3DFECollection self)"}, { "LinearDiscont3DFECollection_swigregister", LinearDiscont3DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont3DFECollection_swiginit", LinearDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont3DFECollection", _wrap_new_QuadraticDiscont3DFECollection, METH_NOARGS, "new_QuadraticDiscont3DFECollection() -> QuadraticDiscont3DFECollection"}, - { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticDiscont3DFECollection_FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont3DFECollection_DofForGeometry", _wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS, "QuadraticDiscont3DFECollection_DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont3DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticDiscont3DFECollection_DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont3DFECollection_FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont3DFECollection_DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont3DFECollection_DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont3DFECollection_Name", _wrap_QuadraticDiscont3DFECollection_Name, METH_O, "QuadraticDiscont3DFECollection_Name(QuadraticDiscont3DFECollection self) -> char const *"}, { "delete_QuadraticDiscont3DFECollection", _wrap_delete_QuadraticDiscont3DFECollection, METH_O, "delete_QuadraticDiscont3DFECollection(QuadraticDiscont3DFECollection self)"}, { "QuadraticDiscont3DFECollection_swigregister", QuadraticDiscont3DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont3DFECollection_swiginit", QuadraticDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinearFECollection", _wrap_new_RefinedLinearFECollection, METH_NOARGS, "new_RefinedLinearFECollection() -> RefinedLinearFECollection"}, - { "RefinedLinearFECollection_FiniteElementForGeometry", _wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS, "RefinedLinearFECollection_FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RefinedLinearFECollection_DofForGeometry", _wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS, "RefinedLinearFECollection_DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RefinedLinearFECollection_DofOrderForOrientation", _wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS, "RefinedLinearFECollection_DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RefinedLinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RefinedLinearFECollection_FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RefinedLinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RefinedLinearFECollection_DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RefinedLinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RefinedLinearFECollection_DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RefinedLinearFECollection_Name", _wrap_RefinedLinearFECollection_Name, METH_O, "RefinedLinearFECollection_Name(RefinedLinearFECollection self) -> char const *"}, { "delete_RefinedLinearFECollection", _wrap_delete_RefinedLinearFECollection, METH_O, "delete_RefinedLinearFECollection(RefinedLinearFECollection self)"}, { "RefinedLinearFECollection_swigregister", RefinedLinearFECollection_swigregister, METH_O, NULL}, { "RefinedLinearFECollection_swiginit", RefinedLinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_ND1_3DFECollection", _wrap_new_ND1_3DFECollection, METH_NOARGS, "new_ND1_3DFECollection() -> ND1_3DFECollection"}, - { "ND1_3DFECollection_FiniteElementForGeometry", _wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "ND1_3DFECollection_FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND1_3DFECollection_DofForGeometry", _wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS, "ND1_3DFECollection_DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND1_3DFECollection_DofOrderForOrientation", _wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "ND1_3DFECollection_DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "ND1_3DFECollection_FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "ND1_3DFECollection_DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "ND1_3DFECollection_DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND1_3DFECollection_Name", _wrap_ND1_3DFECollection_Name, METH_O, "ND1_3DFECollection_Name(ND1_3DFECollection self) -> char const *"}, { "delete_ND1_3DFECollection", _wrap_delete_ND1_3DFECollection, METH_O, "delete_ND1_3DFECollection(ND1_3DFECollection self)"}, { "ND1_3DFECollection_swigregister", ND1_3DFECollection_swigregister, METH_O, NULL}, { "ND1_3DFECollection_swiginit", ND1_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_3DFECollection", _wrap_new_RT0_3DFECollection, METH_NOARGS, "new_RT0_3DFECollection() -> RT0_3DFECollection"}, - { "RT0_3DFECollection_FiniteElementForGeometry", _wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT0_3DFECollection_FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_3DFECollection_DofForGeometry", _wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS, "RT0_3DFECollection_DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_3DFECollection_DofOrderForOrientation", _wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS, "RT0_3DFECollection_DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_3DFECollection_FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_3DFECollection_DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT0_3DFECollection_DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_3DFECollection_Name", _wrap_RT0_3DFECollection_Name, METH_O, "RT0_3DFECollection_Name(RT0_3DFECollection self) -> char const *"}, { "delete_RT0_3DFECollection", _wrap_delete_RT0_3DFECollection, METH_O, "delete_RT0_3DFECollection(RT0_3DFECollection self)"}, { "RT0_3DFECollection_swigregister", RT0_3DFECollection_swigregister, METH_O, NULL}, { "RT0_3DFECollection_swiginit", RT0_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_3DFECollection", _wrap_new_RT1_3DFECollection, METH_NOARGS, "new_RT1_3DFECollection() -> RT1_3DFECollection"}, - { "RT1_3DFECollection_FiniteElementForGeometry", _wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT1_3DFECollection_FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_3DFECollection_DofForGeometry", _wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS, "RT1_3DFECollection_DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_3DFECollection_DofOrderForOrientation", _wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "RT1_3DFECollection_DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_3DFECollection_FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_3DFECollection_DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT1_3DFECollection_DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_3DFECollection_Name", _wrap_RT1_3DFECollection_Name, METH_O, "RT1_3DFECollection_Name(RT1_3DFECollection self) -> char const *"}, { "delete_RT1_3DFECollection", _wrap_delete_RT1_3DFECollection, METH_O, "delete_RT1_3DFECollection(RT1_3DFECollection self)"}, { "RT1_3DFECollection_swigregister", RT1_3DFECollection_swigregister, METH_O, NULL}, { "RT1_3DFECollection_swiginit", RT1_3DFECollection_swiginit, METH_VARARGS, NULL}, - { "new_Local_FECollection", _wrap_new_Local_FECollection, METH_O, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, - { "Local_FECollection_FiniteElementForGeometry", _wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS, "Local_FECollection_FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, - { "Local_FECollection_DofForGeometry", _wrap_Local_FECollection_DofForGeometry, METH_VARARGS, "Local_FECollection_DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, - { "Local_FECollection_DofOrderForOrientation", _wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS, "Local_FECollection_DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_Local_FECollection", (PyCFunction)(void(*)(void))_wrap_new_Local_FECollection, METH_VARARGS|METH_KEYWORDS, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, + { "Local_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "Local_FECollection_FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, + { "Local_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "Local_FECollection_DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, + { "Local_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "Local_FECollection_DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Local_FECollection_Name", _wrap_Local_FECollection_Name, METH_O, "Local_FECollection_Name(Local_FECollection self) -> char const *"}, { "delete_Local_FECollection", _wrap_delete_Local_FECollection, METH_O, "delete_Local_FECollection(Local_FECollection self)"}, { "Local_FECollection_swigregister", Local_FECollection_swigregister, METH_O, NULL}, @@ -13200,288 +12139,288 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "FiniteElementCollection_FiniteElementForGeometry", _wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "FiniteElementCollection_DofForGeometry", _wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS, "DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_DofOrderForOrientation", _wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "FiniteElementCollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "FiniteElementCollection_Name", _wrap_FiniteElementCollection_Name, METH_O, "Name(FiniteElementCollection self) -> char const *"}, - { "FiniteElementCollection_HasFaceDofs", _wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS, "HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_TraceFiniteElementForGeometry", _wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_HasFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS|METH_KEYWORDS, "HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "FiniteElementCollection_GetTraceCollection", _wrap_FiniteElementCollection_GetTraceCollection, METH_O, "GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection"}, { "delete_FiniteElementCollection", _wrap_delete_FiniteElementCollection, METH_O, "delete_FiniteElementCollection(FiniteElementCollection self)"}, - { "FiniteElementCollection_New", _wrap_FiniteElementCollection_New, METH_O, "New(char const * name) -> FiniteElementCollection"}, - { "FiniteElementCollection_SubDofOrder", _wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS, "SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, + { "FiniteElementCollection_New", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_New, METH_VARARGS|METH_KEYWORDS, "New(char const * name) -> FiniteElementCollection"}, + { "FiniteElementCollection_SubDofOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS|METH_KEYWORDS, "SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, { "FiniteElementCollection_swigregister", FiniteElementCollection_swigregister, METH_O, NULL}, - { "new_H1_FECollection", _wrap_new_H1_FECollection, METH_VARARGS, "H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto)"}, - { "H1_FECollection_FiniteElementForGeometry", _wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "H1_FECollection_DofForGeometry", _wrap_H1_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "H1_FECollection_DofOrderForOrientation", _wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_H1_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto) -> H1_FECollection"}, + { "H1_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "H1_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "H1_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "H1_FECollection_Name", _wrap_H1_FECollection_Name, METH_O, "Name(H1_FECollection self) -> char const *"}, { "H1_FECollection_GetTraceCollection", _wrap_H1_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(H1_FECollection self) -> FiniteElementCollection"}, { "H1_FECollection_GetBasisType", _wrap_H1_FECollection_GetBasisType, METH_O, "GetBasisType(H1_FECollection self) -> int"}, - { "H1_FECollection_GetDofMap", _wrap_H1_FECollection_GetDofMap, METH_VARARGS, "GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, + { "H1_FECollection_GetDofMap", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_GetDofMap, METH_VARARGS|METH_KEYWORDS, "GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, { "delete_H1_FECollection", _wrap_delete_H1_FECollection, METH_O, "delete_H1_FECollection(H1_FECollection self)"}, { "H1_FECollection_swigregister", H1_FECollection_swigregister, METH_O, NULL}, { "H1_FECollection_swiginit", H1_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_FECollection", _wrap_new_H1Pos_FECollection, METH_VARARGS, "H1Pos_FECollection(int const p, int const dim=3)"}, + { "new_H1Pos_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_FECollection(int const p, int const dim=3) -> H1Pos_FECollection"}, { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "new_H1Ser_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_FECollection(int const p, int const dim=2) -> H1Ser_FECollection"}, { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, + { "new_H1_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto) -> H1_Trace_FECollection"}, { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, { "H1_Trace_FECollection_swiginit", H1_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_L2_FECollection", _wrap_new_L2_FECollection, METH_VARARGS, "L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE)"}, - { "L2_FECollection_FiniteElementForGeometry", _wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "L2_FECollection_DofForGeometry", _wrap_L2_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "L2_FECollection_DofOrderForOrientation", _wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_L2_FECollection", (PyCFunction)(void(*)(void))_wrap_new_L2_FECollection, METH_VARARGS|METH_KEYWORDS, "new_L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE) -> L2_FECollection"}, + { "L2_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "L2_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "L2_FECollection_Name", _wrap_L2_FECollection_Name, METH_O, "Name(L2_FECollection self) -> char const *"}, - { "L2_FECollection_TraceFiniteElementForGeometry", _wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "L2_FECollection_GetBasisType", _wrap_L2_FECollection_GetBasisType, METH_O, "GetBasisType(L2_FECollection self) -> int"}, { "delete_L2_FECollection", _wrap_delete_L2_FECollection, METH_O, "delete_L2_FECollection(L2_FECollection self)"}, { "L2_FECollection_swigregister", L2_FECollection_swigregister, METH_O, NULL}, { "L2_FECollection_swiginit", L2_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, "RT_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "RT_FECollection_FiniteElementForGeometry", _wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT_FECollection_DofForGeometry", _wrap_RT_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT_FECollection_DofOrderForOrientation", _wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, NULL}, + { "RT_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT_FECollection_Name", _wrap_RT_FECollection_Name, METH_O, "Name(RT_FECollection self) -> char const *"}, { "RT_FECollection_GetTraceCollection", _wrap_RT_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(RT_FECollection self) -> FiniteElementCollection"}, { "delete_RT_FECollection", _wrap_delete_RT_FECollection, METH_O, "delete_RT_FECollection(RT_FECollection self)"}, { "RT_FECollection_swigregister", RT_FECollection_swigregister, METH_O, NULL}, { "RT_FECollection_swiginit", RT_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_Trace_FECollection", _wrap_new_RT_Trace_FECollection, METH_VARARGS, "RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre)"}, + { "new_RT_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_RT_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre) -> RT_Trace_FECollection"}, { "delete_RT_Trace_FECollection", _wrap_delete_RT_Trace_FECollection, METH_O, "delete_RT_Trace_FECollection(RT_Trace_FECollection self)"}, { "RT_Trace_FECollection_swigregister", RT_Trace_FECollection_swigregister, METH_O, NULL}, { "RT_Trace_FECollection_swiginit", RT_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_DG_Interface_FECollection", _wrap_new_DG_Interface_FECollection, METH_VARARGS, "DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre)"}, + { "new_DG_Interface_FECollection", (PyCFunction)(void(*)(void))_wrap_new_DG_Interface_FECollection, METH_VARARGS|METH_KEYWORDS, "new_DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre) -> DG_Interface_FECollection"}, { "delete_DG_Interface_FECollection", _wrap_delete_DG_Interface_FECollection, METH_O, "delete_DG_Interface_FECollection(DG_Interface_FECollection self)"}, { "DG_Interface_FECollection_swigregister", DG_Interface_FECollection_swigregister, METH_O, NULL}, { "DG_Interface_FECollection_swiginit", DG_Interface_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_FECollection", _wrap_new_ND_FECollection, METH_VARARGS, "ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "ND_FECollection_FiniteElementForGeometry", _wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND_FECollection_DofForGeometry", _wrap_ND_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND_FECollection_DofOrderForOrientation", _wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_ND_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_FECollection"}, + { "ND_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND_FECollection_Name", _wrap_ND_FECollection_Name, METH_O, "Name(ND_FECollection self) -> char const *"}, { "ND_FECollection_GetTraceCollection", _wrap_ND_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(ND_FECollection self) -> FiniteElementCollection"}, { "delete_ND_FECollection", _wrap_delete_ND_FECollection, METH_O, "delete_ND_FECollection(ND_FECollection self)"}, { "ND_FECollection_swigregister", ND_FECollection_swigregister, METH_O, NULL}, { "ND_FECollection_swiginit", ND_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_Trace_FECollection", _wrap_new_ND_Trace_FECollection, METH_VARARGS, "ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_Trace_FECollection"}, { "delete_ND_Trace_FECollection", _wrap_delete_ND_Trace_FECollection, METH_O, "delete_ND_Trace_FECollection(ND_Trace_FECollection self)"}, { "ND_Trace_FECollection_swigregister", ND_Trace_FECollection_swigregister, METH_O, NULL}, { "ND_Trace_FECollection_swiginit", ND_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_NURBSFECollection", _wrap_new_NURBSFECollection, METH_VARARGS, "NURBSFECollection(int Order=VariableOrder)"}, + { "new_NURBSFECollection", (PyCFunction)(void(*)(void))_wrap_new_NURBSFECollection, METH_VARARGS|METH_KEYWORDS, "new_NURBSFECollection(int Order=VariableOrder) -> NURBSFECollection"}, { "NURBSFECollection_Reset", _wrap_NURBSFECollection_Reset, METH_O, "Reset(NURBSFECollection self)"}, { "NURBSFECollection_GetOrder", _wrap_NURBSFECollection_GetOrder, METH_O, "GetOrder(NURBSFECollection self) -> int"}, - { "NURBSFECollection_SetOrder", _wrap_NURBSFECollection_SetOrder, METH_VARARGS, "SetOrder(NURBSFECollection self, int Order)"}, - { "NURBSFECollection_FiniteElementForGeometry", _wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "NURBSFECollection_DofForGeometry", _wrap_NURBSFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "NURBSFECollection_DofOrderForOrientation", _wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "NURBSFECollection_SetOrder", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_SetOrder, METH_VARARGS|METH_KEYWORDS, "SetOrder(NURBSFECollection self, int Order)"}, + { "NURBSFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "NURBSFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "NURBSFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "NURBSFECollection_Name", _wrap_NURBSFECollection_Name, METH_O, "Name(NURBSFECollection self) -> char const *"}, { "NURBSFECollection_GetTraceCollection", _wrap_NURBSFECollection_GetTraceCollection, METH_O, "GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection"}, { "delete_NURBSFECollection", _wrap_delete_NURBSFECollection, METH_O, "delete_NURBSFECollection(NURBSFECollection self)"}, { "NURBSFECollection_swigregister", NURBSFECollection_swigregister, METH_O, NULL}, { "NURBSFECollection_swiginit", NURBSFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearFECollection", _wrap_new_LinearFECollection, METH_NOARGS, "new_LinearFECollection() -> LinearFECollection"}, - { "LinearFECollection_FiniteElementForGeometry", _wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearFECollection_DofForGeometry", _wrap_LinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearFECollection_DofOrderForOrientation", _wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearFECollection_Name", _wrap_LinearFECollection_Name, METH_O, "Name(LinearFECollection self) -> char const *"}, { "delete_LinearFECollection", _wrap_delete_LinearFECollection, METH_O, "delete_LinearFECollection(LinearFECollection self)"}, { "LinearFECollection_swigregister", LinearFECollection_swigregister, METH_O, NULL}, { "LinearFECollection_swiginit", LinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticFECollection", _wrap_new_QuadraticFECollection, METH_NOARGS, "new_QuadraticFECollection() -> QuadraticFECollection"}, - { "QuadraticFECollection_FiniteElementForGeometry", _wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticFECollection_DofForGeometry", _wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticFECollection_DofOrderForOrientation", _wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticFECollection_Name", _wrap_QuadraticFECollection_Name, METH_O, "Name(QuadraticFECollection self) -> char const *"}, { "delete_QuadraticFECollection", _wrap_delete_QuadraticFECollection, METH_O, "delete_QuadraticFECollection(QuadraticFECollection self)"}, { "QuadraticFECollection_swigregister", QuadraticFECollection_swigregister, METH_O, NULL}, { "QuadraticFECollection_swiginit", QuadraticFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosFECollection", _wrap_new_QuadraticPosFECollection, METH_NOARGS, "new_QuadraticPosFECollection() -> QuadraticPosFECollection"}, - { "QuadraticPosFECollection_FiniteElementForGeometry", _wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosFECollection_DofForGeometry", _wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosFECollection_DofOrderForOrientation", _wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosFECollection_Name", _wrap_QuadraticPosFECollection_Name, METH_O, "Name(QuadraticPosFECollection self) -> char const *"}, { "delete_QuadraticPosFECollection", _wrap_delete_QuadraticPosFECollection, METH_O, "delete_QuadraticPosFECollection(QuadraticPosFECollection self)"}, { "QuadraticPosFECollection_swigregister", QuadraticPosFECollection_swigregister, METH_O, NULL}, { "QuadraticPosFECollection_swiginit", QuadraticPosFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicFECollection", _wrap_new_CubicFECollection, METH_NOARGS, "new_CubicFECollection() -> CubicFECollection"}, - { "CubicFECollection_FiniteElementForGeometry", _wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicFECollection_DofForGeometry", _wrap_CubicFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicFECollection_DofOrderForOrientation", _wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicFECollection_Name", _wrap_CubicFECollection_Name, METH_O, "Name(CubicFECollection self) -> char const *"}, { "delete_CubicFECollection", _wrap_delete_CubicFECollection, METH_O, "delete_CubicFECollection(CubicFECollection self)"}, { "CubicFECollection_swigregister", CubicFECollection_swigregister, METH_O, NULL}, { "CubicFECollection_swiginit", CubicFECollection_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFECollection", _wrap_new_CrouzeixRaviartFECollection, METH_NOARGS, "new_CrouzeixRaviartFECollection() -> CrouzeixRaviartFECollection"}, - { "CrouzeixRaviartFECollection_FiniteElementForGeometry", _wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CrouzeixRaviartFECollection_DofForGeometry", _wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CrouzeixRaviartFECollection_DofOrderForOrientation", _wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CrouzeixRaviartFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CrouzeixRaviartFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CrouzeixRaviartFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CrouzeixRaviartFECollection_Name", _wrap_CrouzeixRaviartFECollection_Name, METH_O, "Name(CrouzeixRaviartFECollection self) -> char const *"}, { "delete_CrouzeixRaviartFECollection", _wrap_delete_CrouzeixRaviartFECollection, METH_O, "delete_CrouzeixRaviartFECollection(CrouzeixRaviartFECollection self)"}, { "CrouzeixRaviartFECollection_swigregister", CrouzeixRaviartFECollection_swigregister, METH_O, NULL}, { "CrouzeixRaviartFECollection_swiginit", CrouzeixRaviartFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearNonConf3DFECollection", _wrap_new_LinearNonConf3DFECollection, METH_NOARGS, "new_LinearNonConf3DFECollection() -> LinearNonConf3DFECollection"}, - { "LinearNonConf3DFECollection_FiniteElementForGeometry", _wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearNonConf3DFECollection_DofForGeometry", _wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearNonConf3DFECollection_DofOrderForOrientation", _wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearNonConf3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearNonConf3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearNonConf3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearNonConf3DFECollection_Name", _wrap_LinearNonConf3DFECollection_Name, METH_O, "Name(LinearNonConf3DFECollection self) -> char const *"}, { "delete_LinearNonConf3DFECollection", _wrap_delete_LinearNonConf3DFECollection, METH_O, "delete_LinearNonConf3DFECollection(LinearNonConf3DFECollection self)"}, { "LinearNonConf3DFECollection_swigregister", LinearNonConf3DFECollection_swigregister, METH_O, NULL}, { "LinearNonConf3DFECollection_swiginit", LinearNonConf3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_2DFECollection", _wrap_new_RT0_2DFECollection, METH_NOARGS, "new_RT0_2DFECollection() -> RT0_2DFECollection"}, - { "RT0_2DFECollection_FiniteElementForGeometry", _wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_2DFECollection_DofForGeometry", _wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_2DFECollection_DofOrderForOrientation", _wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_2DFECollection_Name", _wrap_RT0_2DFECollection_Name, METH_O, "Name(RT0_2DFECollection self) -> char const *"}, { "delete_RT0_2DFECollection", _wrap_delete_RT0_2DFECollection, METH_O, "delete_RT0_2DFECollection(RT0_2DFECollection self)"}, { "RT0_2DFECollection_swigregister", RT0_2DFECollection_swigregister, METH_O, NULL}, { "RT0_2DFECollection_swiginit", RT0_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_2DFECollection", _wrap_new_RT1_2DFECollection, METH_NOARGS, "new_RT1_2DFECollection() -> RT1_2DFECollection"}, - { "RT1_2DFECollection_FiniteElementForGeometry", _wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_2DFECollection_DofForGeometry", _wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_2DFECollection_DofOrderForOrientation", _wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_2DFECollection_Name", _wrap_RT1_2DFECollection_Name, METH_O, "Name(RT1_2DFECollection self) -> char const *"}, { "delete_RT1_2DFECollection", _wrap_delete_RT1_2DFECollection, METH_O, "delete_RT1_2DFECollection(RT1_2DFECollection self)"}, { "RT1_2DFECollection_swigregister", RT1_2DFECollection_swigregister, METH_O, NULL}, { "RT1_2DFECollection_swiginit", RT1_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT2_2DFECollection", _wrap_new_RT2_2DFECollection, METH_NOARGS, "new_RT2_2DFECollection() -> RT2_2DFECollection"}, - { "RT2_2DFECollection_FiniteElementForGeometry", _wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT2_2DFECollection_DofForGeometry", _wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT2_2DFECollection_DofOrderForOrientation", _wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT2_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT2_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT2_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT2_2DFECollection_Name", _wrap_RT2_2DFECollection_Name, METH_O, "Name(RT2_2DFECollection self) -> char const *"}, { "delete_RT2_2DFECollection", _wrap_delete_RT2_2DFECollection, METH_O, "delete_RT2_2DFECollection(RT2_2DFECollection self)"}, { "RT2_2DFECollection_swigregister", RT2_2DFECollection_swigregister, METH_O, NULL}, { "RT2_2DFECollection_swiginit", RT2_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const2DFECollection", _wrap_new_Const2DFECollection, METH_NOARGS, "new_Const2DFECollection() -> Const2DFECollection"}, - { "Const2DFECollection_FiniteElementForGeometry", _wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const2DFECollection_DofForGeometry", _wrap_Const2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const2DFECollection_DofOrderForOrientation", _wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const2DFECollection_Name", _wrap_Const2DFECollection_Name, METH_O, "Name(Const2DFECollection self) -> char const *"}, { "delete_Const2DFECollection", _wrap_delete_Const2DFECollection, METH_O, "delete_Const2DFECollection(Const2DFECollection self)"}, { "Const2DFECollection_swigregister", Const2DFECollection_swigregister, METH_O, NULL}, { "Const2DFECollection_swiginit", Const2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont2DFECollection", _wrap_new_LinearDiscont2DFECollection, METH_NOARGS, "new_LinearDiscont2DFECollection() -> LinearDiscont2DFECollection"}, - { "LinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont2DFECollection_DofForGeometry", _wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont2DFECollection_DofOrderForOrientation", _wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont2DFECollection_Name", _wrap_LinearDiscont2DFECollection_Name, METH_O, "Name(LinearDiscont2DFECollection self) -> char const *"}, { "delete_LinearDiscont2DFECollection", _wrap_delete_LinearDiscont2DFECollection, METH_O, "delete_LinearDiscont2DFECollection(LinearDiscont2DFECollection self)"}, { "LinearDiscont2DFECollection_swigregister", LinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont2DFECollection_swiginit", LinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussLinearDiscont2DFECollection", _wrap_new_GaussLinearDiscont2DFECollection, METH_NOARGS, "new_GaussLinearDiscont2DFECollection() -> GaussLinearDiscont2DFECollection"}, - { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussLinearDiscont2DFECollection_DofForGeometry", _wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussLinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussLinearDiscont2DFECollection_Name", _wrap_GaussLinearDiscont2DFECollection_Name, METH_O, "Name(GaussLinearDiscont2DFECollection self) -> char const *"}, { "delete_GaussLinearDiscont2DFECollection", _wrap_delete_GaussLinearDiscont2DFECollection, METH_O, "delete_GaussLinearDiscont2DFECollection(GaussLinearDiscont2DFECollection self)"}, { "GaussLinearDiscont2DFECollection_swigregister", GaussLinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussLinearDiscont2DFECollection_swiginit", GaussLinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFECollection", _wrap_new_P1OnQuadFECollection, METH_NOARGS, "new_P1OnQuadFECollection() -> P1OnQuadFECollection"}, - { "P1OnQuadFECollection_FiniteElementForGeometry", _wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "P1OnQuadFECollection_DofForGeometry", _wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "P1OnQuadFECollection_DofOrderForOrientation", _wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "P1OnQuadFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "P1OnQuadFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "P1OnQuadFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "P1OnQuadFECollection_Name", _wrap_P1OnQuadFECollection_Name, METH_O, "Name(P1OnQuadFECollection self) -> char const *"}, { "delete_P1OnQuadFECollection", _wrap_delete_P1OnQuadFECollection, METH_O, "delete_P1OnQuadFECollection(P1OnQuadFECollection self)"}, { "P1OnQuadFECollection_swigregister", P1OnQuadFECollection_swigregister, METH_O, NULL}, { "P1OnQuadFECollection_swiginit", P1OnQuadFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont2DFECollection", _wrap_new_QuadraticDiscont2DFECollection, METH_NOARGS, "new_QuadraticDiscont2DFECollection() -> QuadraticDiscont2DFECollection"}, - { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont2DFECollection_DofForGeometry", _wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont2DFECollection_Name", _wrap_QuadraticDiscont2DFECollection_Name, METH_O, "Name(QuadraticDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticDiscont2DFECollection", _wrap_delete_QuadraticDiscont2DFECollection, METH_O, "delete_QuadraticDiscont2DFECollection(QuadraticDiscont2DFECollection self)"}, { "QuadraticDiscont2DFECollection_swigregister", QuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont2DFECollection_swiginit", QuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosDiscont2DFECollection", _wrap_new_QuadraticPosDiscont2DFECollection, METH_NOARGS, "new_QuadraticPosDiscont2DFECollection() -> QuadraticPosDiscont2DFECollection"}, - { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosDiscont2DFECollection_DofForGeometry", _wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosDiscont2DFECollection_Name", _wrap_QuadraticPosDiscont2DFECollection_Name, METH_O, "Name(QuadraticPosDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticPosDiscont2DFECollection", _wrap_delete_QuadraticPosDiscont2DFECollection, METH_O, "delete_QuadraticPosDiscont2DFECollection(QuadraticPosDiscont2DFECollection self)"}, { "QuadraticPosDiscont2DFECollection_swigregister", QuadraticPosDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticPosDiscont2DFECollection_swiginit", QuadraticPosDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussQuadraticDiscont2DFECollection", _wrap_new_GaussQuadraticDiscont2DFECollection, METH_NOARGS, "new_GaussQuadraticDiscont2DFECollection() -> GaussQuadraticDiscont2DFECollection"}, - { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussQuadraticDiscont2DFECollection_DofForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussQuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussQuadraticDiscont2DFECollection_Name", _wrap_GaussQuadraticDiscont2DFECollection_Name, METH_O, "Name(GaussQuadraticDiscont2DFECollection self) -> char const *"}, { "delete_GaussQuadraticDiscont2DFECollection", _wrap_delete_GaussQuadraticDiscont2DFECollection, METH_O, "delete_GaussQuadraticDiscont2DFECollection(GaussQuadraticDiscont2DFECollection self)"}, { "GaussQuadraticDiscont2DFECollection_swigregister", GaussQuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussQuadraticDiscont2DFECollection_swiginit", GaussQuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicDiscont2DFECollection", _wrap_new_CubicDiscont2DFECollection, METH_NOARGS, "new_CubicDiscont2DFECollection() -> CubicDiscont2DFECollection"}, - { "CubicDiscont2DFECollection_FiniteElementForGeometry", _wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicDiscont2DFECollection_DofForGeometry", _wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicDiscont2DFECollection_DofOrderForOrientation", _wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicDiscont2DFECollection_Name", _wrap_CubicDiscont2DFECollection_Name, METH_O, "Name(CubicDiscont2DFECollection self) -> char const *"}, { "delete_CubicDiscont2DFECollection", _wrap_delete_CubicDiscont2DFECollection, METH_O, "delete_CubicDiscont2DFECollection(CubicDiscont2DFECollection self)"}, { "CubicDiscont2DFECollection_swigregister", CubicDiscont2DFECollection_swigregister, METH_O, NULL}, { "CubicDiscont2DFECollection_swiginit", CubicDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const3DFECollection", _wrap_new_Const3DFECollection, METH_NOARGS, "new_Const3DFECollection() -> Const3DFECollection"}, - { "Const3DFECollection_FiniteElementForGeometry", _wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const3DFECollection_DofForGeometry", _wrap_Const3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const3DFECollection_DofOrderForOrientation", _wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const3DFECollection_Name", _wrap_Const3DFECollection_Name, METH_O, "Name(Const3DFECollection self) -> char const *"}, { "delete_Const3DFECollection", _wrap_delete_Const3DFECollection, METH_O, "delete_Const3DFECollection(Const3DFECollection self)"}, { "Const3DFECollection_swigregister", Const3DFECollection_swigregister, METH_O, NULL}, { "Const3DFECollection_swiginit", Const3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont3DFECollection", _wrap_new_LinearDiscont3DFECollection, METH_NOARGS, "new_LinearDiscont3DFECollection() -> LinearDiscont3DFECollection"}, - { "LinearDiscont3DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont3DFECollection_DofForGeometry", _wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont3DFECollection_DofOrderForOrientation", _wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont3DFECollection_Name", _wrap_LinearDiscont3DFECollection_Name, METH_O, "Name(LinearDiscont3DFECollection self) -> char const *"}, { "delete_LinearDiscont3DFECollection", _wrap_delete_LinearDiscont3DFECollection, METH_O, "delete_LinearDiscont3DFECollection(LinearDiscont3DFECollection self)"}, { "LinearDiscont3DFECollection_swigregister", LinearDiscont3DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont3DFECollection_swiginit", LinearDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont3DFECollection", _wrap_new_QuadraticDiscont3DFECollection, METH_NOARGS, "new_QuadraticDiscont3DFECollection() -> QuadraticDiscont3DFECollection"}, - { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont3DFECollection_DofForGeometry", _wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont3DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont3DFECollection_Name", _wrap_QuadraticDiscont3DFECollection_Name, METH_O, "Name(QuadraticDiscont3DFECollection self) -> char const *"}, { "delete_QuadraticDiscont3DFECollection", _wrap_delete_QuadraticDiscont3DFECollection, METH_O, "delete_QuadraticDiscont3DFECollection(QuadraticDiscont3DFECollection self)"}, { "QuadraticDiscont3DFECollection_swigregister", QuadraticDiscont3DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont3DFECollection_swiginit", QuadraticDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinearFECollection", _wrap_new_RefinedLinearFECollection, METH_NOARGS, "new_RefinedLinearFECollection() -> RefinedLinearFECollection"}, - { "RefinedLinearFECollection_FiniteElementForGeometry", _wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RefinedLinearFECollection_DofForGeometry", _wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RefinedLinearFECollection_DofOrderForOrientation", _wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RefinedLinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RefinedLinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RefinedLinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RefinedLinearFECollection_Name", _wrap_RefinedLinearFECollection_Name, METH_O, "Name(RefinedLinearFECollection self) -> char const *"}, { "delete_RefinedLinearFECollection", _wrap_delete_RefinedLinearFECollection, METH_O, "delete_RefinedLinearFECollection(RefinedLinearFECollection self)"}, { "RefinedLinearFECollection_swigregister", RefinedLinearFECollection_swigregister, METH_O, NULL}, { "RefinedLinearFECollection_swiginit", RefinedLinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_ND1_3DFECollection", _wrap_new_ND1_3DFECollection, METH_NOARGS, "new_ND1_3DFECollection() -> ND1_3DFECollection"}, - { "ND1_3DFECollection_FiniteElementForGeometry", _wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND1_3DFECollection_DofForGeometry", _wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND1_3DFECollection_DofOrderForOrientation", _wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND1_3DFECollection_Name", _wrap_ND1_3DFECollection_Name, METH_O, "Name(ND1_3DFECollection self) -> char const *"}, { "delete_ND1_3DFECollection", _wrap_delete_ND1_3DFECollection, METH_O, "delete_ND1_3DFECollection(ND1_3DFECollection self)"}, { "ND1_3DFECollection_swigregister", ND1_3DFECollection_swigregister, METH_O, NULL}, { "ND1_3DFECollection_swiginit", ND1_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_3DFECollection", _wrap_new_RT0_3DFECollection, METH_NOARGS, "new_RT0_3DFECollection() -> RT0_3DFECollection"}, - { "RT0_3DFECollection_FiniteElementForGeometry", _wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_3DFECollection_DofForGeometry", _wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_3DFECollection_DofOrderForOrientation", _wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_3DFECollection_Name", _wrap_RT0_3DFECollection_Name, METH_O, "Name(RT0_3DFECollection self) -> char const *"}, { "delete_RT0_3DFECollection", _wrap_delete_RT0_3DFECollection, METH_O, "delete_RT0_3DFECollection(RT0_3DFECollection self)"}, { "RT0_3DFECollection_swigregister", RT0_3DFECollection_swigregister, METH_O, NULL}, { "RT0_3DFECollection_swiginit", RT0_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_3DFECollection", _wrap_new_RT1_3DFECollection, METH_NOARGS, "new_RT1_3DFECollection() -> RT1_3DFECollection"}, - { "RT1_3DFECollection_FiniteElementForGeometry", _wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_3DFECollection_DofForGeometry", _wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_3DFECollection_DofOrderForOrientation", _wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_3DFECollection_Name", _wrap_RT1_3DFECollection_Name, METH_O, "Name(RT1_3DFECollection self) -> char const *"}, { "delete_RT1_3DFECollection", _wrap_delete_RT1_3DFECollection, METH_O, "delete_RT1_3DFECollection(RT1_3DFECollection self)"}, { "RT1_3DFECollection_swigregister", RT1_3DFECollection_swigregister, METH_O, NULL}, { "RT1_3DFECollection_swiginit", RT1_3DFECollection_swiginit, METH_VARARGS, NULL}, - { "new_Local_FECollection", _wrap_new_Local_FECollection, METH_O, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, - { "Local_FECollection_FiniteElementForGeometry", _wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, - { "Local_FECollection_DofForGeometry", _wrap_Local_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, - { "Local_FECollection_DofOrderForOrientation", _wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_Local_FECollection", (PyCFunction)(void(*)(void))_wrap_new_Local_FECollection, METH_VARARGS|METH_KEYWORDS, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, + { "Local_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, + { "Local_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, + { "Local_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Local_FECollection_Name", _wrap_Local_FECollection_Name, METH_O, "Name(Local_FECollection self) -> char const *"}, { "delete_Local_FECollection", _wrap_delete_Local_FECollection, METH_O, "delete_Local_FECollection(Local_FECollection self)"}, { "Local_FECollection_swigregister", Local_FECollection_swigregister, METH_O, NULL}, diff --git a/mfem/_par/fe_wrap.cxx b/mfem/_par/fe_wrap.cxx index 0f04190b..6b499fc6 100644 --- a/mfem/_par/fe_wrap.cxx +++ b/mfem/_par/fe_wrap.cxx @@ -3694,19 +3694,21 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_BasisType_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_Check", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3728,19 +3730,21 @@ SWIGINTERN PyObject *_wrap_BasisType_Check(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_BasisType_CheckNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_CheckNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_CheckNodal", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3762,19 +3766,21 @@ SWIGINTERN PyObject *_wrap_BasisType_CheckNodal(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BasisType_GetQuadrature1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetQuadrature1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetQuadrature1D", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3796,19 +3802,21 @@ SWIGINTERN PyObject *_wrap_BasisType_GetQuadrature1D(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BasisType_GetNodalBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetNodalBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"qpt_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetNodalBasis", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3830,19 +3838,21 @@ SWIGINTERN PyObject *_wrap_BasisType_GetNodalBasis(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_BasisType_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; char *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_Name", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3864,19 +3874,21 @@ SWIGINTERN PyObject *_wrap_BasisType_Name(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_BasisType_GetChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; char result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetChar", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3898,17 +3910,19 @@ SWIGINTERN PyObject *_wrap_BasisType_GetChar(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_BasisType_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; char arg1 ; char val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_ident", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetType", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_char(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "BasisType_GetType" "', argument " "1"" of type '" "char""'"); } @@ -4977,7 +4991,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetDerivMapType(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -4988,15 +5002,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5004,7 +5023,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5032,7 +5051,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5043,15 +5062,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5059,7 +5083,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5087,7 +5111,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5098,15 +5122,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5114,7 +5143,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5142,7 +5171,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5153,15 +5182,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysDShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysDShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5169,7 +5203,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysDShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5395,7 +5429,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcVShape(PyObject *self, PyObject *ar } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5406,15 +5440,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysVShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysVShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysVShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysVShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5422,7 +5461,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysVShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysVShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5450,7 +5489,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5461,15 +5500,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5477,7 +5521,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5505,7 +5549,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5516,15 +5560,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5532,7 +5581,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5560,7 +5609,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5571,15 +5620,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5587,7 +5641,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5615,7 +5669,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5626,15 +5680,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5642,7 +5701,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5670,7 +5729,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; int arg2 ; @@ -5682,26 +5741,32 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face", (char *)"dofs", (char *)"ndofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_GetFaceDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetFaceDofs" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetFaceDofs" "', argument " "3"" of type '" "int **""'"); } arg3 = reinterpret_cast< int ** >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_GetFaceDofs" "', argument " "4"" of type '" "int *""'"); } @@ -5726,7 +5791,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5737,15 +5802,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"Hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5753,7 +5823,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5781,7 +5851,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5792,15 +5862,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"Hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5808,7 +5883,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5836,7 +5911,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5847,15 +5922,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"Laplacian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLaplacian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysLaplacian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5863,7 +5943,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5891,7 +5971,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5902,15 +5982,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"Laplacian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLinLaplacian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysLinLaplacian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5918,7 +6003,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5946,7 +6031,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5957,15 +6042,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5973,7 +6063,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -6001,7 +6091,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6012,15 +6102,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6028,7 +6123,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -6056,7 +6151,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6070,15 +6165,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDP int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6086,7 +6187,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6094,7 +6195,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6252,7 +6353,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -6266,15 +6367,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -6282,7 +6389,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6290,7 +6397,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -6318,7 +6425,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; int arg2 ; @@ -6327,21 +6434,26 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6524,7 +6636,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_Project(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6538,15 +6650,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectGrad" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6554,7 +6672,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6562,7 +6680,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6590,7 +6708,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6604,15 +6722,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectCurl" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6620,7 +6744,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6628,7 +6752,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6656,7 +6780,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6670,15 +6794,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"div", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectDiv", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectDiv", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectDiv" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6686,7 +6816,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6694,7 +6824,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectDiv" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6722,7 +6852,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -6733,16 +6863,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -6750,7 +6885,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -6809,19 +6944,21 @@ SWIGINTERN PyObject *_wrap_delete_FiniteElement(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_FiniteElement_IsClosedType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_IsClosedType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_IsClosedType", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -6843,19 +6980,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_IsClosedType(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElement_IsOpenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_IsOpenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_IsOpenType", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -6877,19 +7016,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_IsOpenType(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_VerifyClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_VerifyClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_VerifyClosed", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -6911,19 +7052,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_VerifyClosed(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElement_VerifyOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_VerifyOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_VerifyOpen", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -6945,19 +7088,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_VerifyOpen(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_VerifyNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_VerifyNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_VerifyNodal", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -6986,25 +7131,29 @@ SWIGINTERN PyObject *FiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(self), return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_SetMapType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_SetMapType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_SetMapType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ScalarFiniteElement_SetMapType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_SetMapType" "', argument " "1"" of type '" "mfem::ScalarFiniteElement *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7026,7 +7175,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_SetMapType(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7040,15 +7189,21 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", (char *)"fine_fe", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_NodalLocalInterpolation", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ScalarFiniteElement_NodalLocalInterpolation", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "1"" of type '" "mfem::ScalarFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7056,7 +7211,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7064,7 +7219,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "4"" of type '" "mfem::ScalarFiniteElement const &""'"); } @@ -7092,7 +7247,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7106,15 +7261,21 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", (char *)"fine_fe", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_ScalarLocalInterpolation", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ScalarFiniteElement_ScalarLocalInterpolation", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "1"" of type '" "mfem::ScalarFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7122,7 +7283,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7130,7 +7291,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "4"" of type '" "mfem::ScalarFiniteElement const &""'"); } @@ -7158,7 +7319,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -7169,16 +7330,21 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSED int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ScalarFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::ScalarFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -7186,7 +7352,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -7252,7 +7418,7 @@ SWIGINTERN PyObject *ScalarFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(s return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7263,15 +7429,20 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NodalFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7279,7 +7450,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7307,7 +7478,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SW } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7318,15 +7489,20 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NodalFiniteElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7334,7 +7510,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7362,7 +7538,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7376,15 +7552,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7392,7 +7574,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7400,7 +7582,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7558,7 +7740,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_Project__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -7572,15 +7754,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -7588,7 +7776,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7596,7 +7784,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7779,7 +7967,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_Project(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7793,15 +7981,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7809,7 +8003,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7817,7 +8011,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7845,7 +8039,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7859,15 +8053,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"div", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_ProjectDiv", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_ProjectDiv", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7875,7 +8075,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7883,7 +8083,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7952,7 +8152,7 @@ SWIGINTERN PyObject *NodalFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(se return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PositiveFiniteElement *arg1 = (mfem::PositiveFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7963,15 +8163,20 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PositiveFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PositiveFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::PositiveFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PositiveFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7979,7 +8184,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -8007,7 +8212,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PositiveFiniteElement *arg1 = (mfem::PositiveFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8021,15 +8226,21 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PositiveFiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:PositiveFiniteElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::PositiveFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PositiveFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8037,7 +8248,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -8045,7 +8256,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -8668,118 +8879,68 @@ SWIGINTERN PyObject *PositiveFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_VectorFiniteElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; mfem::Geometry::Type arg2 ; int arg3 ; int arg4 ; int arg5 ; - int arg6 ; + int arg6 = (int) mfem::FunctionSpace::Pk ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"D", (char *)"G", (char *)"Do", (char *)"O", (char *)"M", (char *)"F", NULL + }; mfem::VectorFiniteElement *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:new_VectorFiniteElement", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorFiniteElement" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - result = (mfem::VectorFiniteElement *)new mfem::VectorFiniteElement(arg1,arg2,arg3,arg4,arg5,arg6); + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFiniteElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorFiniteElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Geometry::Type arg2 ; - int arg3 ; - int arg4 ; - int arg5 ; - int val2 ; - int ecode2 = 0 ; - mfem::VectorFiniteElement *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorFiniteElement" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); } { try { - result = (mfem::VectorFiniteElement *)new mfem::VectorFiniteElement(arg1,arg2,arg3,arg4,arg5); + result = (mfem::VectorFiniteElement *)new mfem::VectorFiniteElement(arg1,arg2,arg3,arg4,arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8797,134 +8958,6 @@ SWIGINTERN PyObject *_wrap_new_VectorFiniteElement__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_VectorFiniteElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFiniteElement", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorFiniteElement__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorFiniteElement__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFiniteElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorFiniteElement::VectorFiniteElement(int,mfem::Geometry::Type,int,int,int,int)\n" - " mfem::VectorFiniteElement::VectorFiniteElement(int,mfem::Geometry::Type,int,int,int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_VectorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorFiniteElement *arg1 = (mfem::VectorFiniteElement *) 0 ; @@ -8995,7 +9028,7 @@ SWIGINTERN PyObject *_wrap_new_PointFiniteElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PointFiniteElement *arg1 = (mfem::PointFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9006,15 +9039,20 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PointFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PointFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::PointFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PointFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PointFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9022,7 +9060,7 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PointFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PointFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9050,7 +9088,7 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PointFiniteElement *arg1 = (mfem::PointFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9061,15 +9099,20 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PointFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PointFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::PointFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PointFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PointFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9077,7 +9120,7 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PointFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PointFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9175,7 +9218,7 @@ SWIGINTERN PyObject *_wrap_new_Linear1DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear1DFiniteElement *arg1 = (mfem::Linear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9186,15 +9229,20 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Linear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9202,7 +9250,7 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9230,7 +9278,7 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear1DFiniteElement *arg1 = (mfem::Linear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9241,15 +9289,20 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Linear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9257,7 +9310,7 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9355,7 +9408,7 @@ SWIGINTERN PyObject *_wrap_new_Linear2DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear2DFiniteElement *arg1 = (mfem::Linear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9366,15 +9419,20 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Linear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9382,7 +9440,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9410,7 +9468,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear2DFiniteElement *arg1 = (mfem::Linear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9421,15 +9479,20 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Linear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9437,7 +9500,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9465,7 +9528,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear2DFiniteElement *arg1 = (mfem::Linear2DFiniteElement *) 0 ; int arg2 ; @@ -9474,21 +9537,26 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::Linear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9586,7 +9654,7 @@ SWIGINTERN PyObject *_wrap_new_BiLinear2DFiniteElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9597,15 +9665,20 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9613,7 +9686,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9641,7 +9714,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9652,15 +9725,20 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9668,7 +9746,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9696,7 +9774,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9707,15 +9785,20 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9723,7 +9806,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9751,7 +9834,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; int arg2 ; @@ -9760,21 +9843,26 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9872,7 +9960,7 @@ SWIGINTERN PyObject *_wrap_new_GaussLinear2DFiniteElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinear2DFiniteElement *arg1 = (mfem::GaussLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9883,15 +9971,20 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9899,7 +9992,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9927,7 +10020,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinear2DFiniteElement *arg1 = (mfem::GaussLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9938,15 +10031,20 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9954,7 +10052,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9982,7 +10080,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinear2DFiniteElement *arg1 = (mfem::GaussLinear2DFiniteElement *) 0 ; int arg2 ; @@ -9991,21 +10089,26 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_ProjectDelta(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussLinear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::GaussLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLinear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10103,7 +10206,7 @@ SWIGINTERN PyObject *_wrap_new_GaussBiLinear2DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiLinear2DFiniteElement *arg1 = (mfem::GaussBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10114,15 +10217,20 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10130,7 +10238,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10158,7 +10266,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiLinear2DFiniteElement *arg1 = (mfem::GaussBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10169,15 +10277,20 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10185,7 +10298,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10213,7 +10326,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiLinear2DFiniteElement *arg1 = (mfem::GaussBiLinear2DFiniteElement *) 0 ; int arg2 ; @@ -10222,21 +10335,26 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_ProjectDelta(PyObject *S int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiLinear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiLinear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiLinear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::GaussBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiLinear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiLinear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10334,7 +10452,7 @@ SWIGINTERN PyObject *_wrap_new_P1OnQuadFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFiniteElement *arg1 = (mfem::P1OnQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10345,15 +10463,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P1OnQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10361,7 +10484,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10389,7 +10512,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFiniteElement *arg1 = (mfem::P1OnQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10400,15 +10523,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P1OnQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10416,7 +10544,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10444,7 +10572,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFiniteElement *arg1 = (mfem::P1OnQuadFiniteElement *) 0 ; int arg2 ; @@ -10453,21 +10581,26 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P1OnQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1OnQuadFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10565,7 +10698,7 @@ SWIGINTERN PyObject *_wrap_new_Quad1DFiniteElement(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad1DFiniteElement *arg1 = (mfem::Quad1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10576,15 +10709,20 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Quad1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10592,7 +10730,7 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10620,7 +10758,7 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad1DFiniteElement *arg1 = (mfem::Quad1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10631,15 +10769,20 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Quad1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10647,7 +10790,7 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10745,7 +10888,7 @@ SWIGINTERN PyObject *_wrap_new_QuadPos1DFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadPos1DFiniteElement *arg1 = (mfem::QuadPos1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10756,15 +10899,20 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadPos1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadPos1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::QuadPos1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::QuadPos1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10772,7 +10920,7 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10800,7 +10948,7 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadPos1DFiniteElement *arg1 = (mfem::QuadPos1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10811,15 +10959,20 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadPos1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadPos1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::QuadPos1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::QuadPos1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10827,7 +10980,7 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10925,7 +11078,7 @@ SWIGINTERN PyObject *_wrap_new_Quad2DFiniteElement(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10936,15 +11089,20 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10952,7 +11110,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10980,7 +11138,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10991,15 +11149,20 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11007,7 +11170,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11035,7 +11198,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11046,15 +11209,20 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11062,7 +11230,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11090,7 +11258,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; int arg2 ; @@ -11099,21 +11267,26 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSED int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11211,7 +11384,7 @@ SWIGINTERN PyObject *_wrap_new_GaussQuad2DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuad2DFiniteElement *arg1 = (mfem::GaussQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11222,15 +11395,20 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussQuad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussQuad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11238,7 +11416,7 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11266,7 +11444,7 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuad2DFiniteElement *arg1 = (mfem::GaussQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11277,15 +11455,20 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussQuad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussQuad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11293,7 +11476,7 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11391,7 +11574,7 @@ SWIGINTERN PyObject *_wrap_new_BiQuad2DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuad2DFiniteElement *arg1 = (mfem::BiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11402,15 +11585,20 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11418,7 +11606,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11446,7 +11634,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuad2DFiniteElement *arg1 = (mfem::BiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11457,15 +11645,20 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11473,7 +11666,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11501,7 +11694,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuad2DFiniteElement *arg1 = (mfem::BiQuad2DFiniteElement *) 0 ; int arg2 ; @@ -11510,21 +11703,26 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuad2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuad2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuad2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::BiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuad2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuad2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11622,7 +11820,7 @@ SWIGINTERN PyObject *_wrap_new_BiQuadPos2DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11633,15 +11831,20 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11649,7 +11852,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11677,7 +11880,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11688,15 +11891,20 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11704,7 +11912,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11732,7 +11940,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -11743,15 +11951,20 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -11759,7 +11972,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12252,7 +12465,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_Project(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; int arg2 ; @@ -12261,21 +12474,26 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_ProjectDelta(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12373,7 +12591,7 @@ SWIGINTERN PyObject *_wrap_new_GaussBiQuad2DFiniteElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiQuad2DFiniteElement *arg1 = (mfem::GaussBiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12384,15 +12602,20 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiQuad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiQuad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussBiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12400,7 +12623,7 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12428,7 +12651,7 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiQuad2DFiniteElement *arg1 = (mfem::GaussBiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12439,15 +12662,20 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiQuad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiQuad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussBiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12455,7 +12683,7 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12553,7 +12781,7 @@ SWIGINTERN PyObject *_wrap_new_BiCubic2DFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiCubic2DFiniteElement *arg1 = (mfem::BiCubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12564,15 +12792,20 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCubic2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCubic2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiCubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiCubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12580,7 +12813,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12608,7 +12841,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiCubic2DFiniteElement *arg1 = (mfem::BiCubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12619,15 +12852,20 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCubic2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCubic2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiCubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiCubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12635,7 +12873,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12663,7 +12901,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiCubic2DFiniteElement *arg1 = (mfem::BiCubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12674,15 +12912,20 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCubic2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCubic2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::BiCubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiCubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12690,7 +12933,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12788,7 +13031,7 @@ SWIGINTERN PyObject *_wrap_new_Cubic1DFiniteElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic1DFiniteElement *arg1 = (mfem::Cubic1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12799,15 +13042,20 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Cubic1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12815,7 +13063,7 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12843,7 +13091,7 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic1DFiniteElement *arg1 = (mfem::Cubic1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12854,15 +13102,20 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Cubic1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12870,7 +13123,7 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12968,7 +13221,7 @@ SWIGINTERN PyObject *_wrap_new_Cubic2DFiniteElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic2DFiniteElement *arg1 = (mfem::Cubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12979,15 +13232,20 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Cubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12995,7 +13253,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13023,7 +13281,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic2DFiniteElement *arg1 = (mfem::Cubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13034,15 +13292,20 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Cubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13050,7 +13313,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13078,7 +13341,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic2DFiniteElement *arg1 = (mfem::Cubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13089,15 +13352,20 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::Cubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13105,7 +13373,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13203,7 +13471,7 @@ SWIGINTERN PyObject *_wrap_new_Cubic3DFiniteElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic3DFiniteElement *arg1 = (mfem::Cubic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13214,15 +13482,20 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Cubic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13230,7 +13503,7 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13258,7 +13531,7 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic3DFiniteElement *arg1 = (mfem::Cubic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13269,15 +13542,20 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Cubic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13285,7 +13563,7 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13383,7 +13661,7 @@ SWIGINTERN PyObject *_wrap_new_P0TriangleFiniteElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TriangleFiniteElement *arg1 = (mfem::P0TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13394,15 +13672,20 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TriangleFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TriangleFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13410,7 +13693,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13438,7 +13721,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TriangleFiniteElement *arg1 = (mfem::P0TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13449,15 +13732,20 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TriangleFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TriangleFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13465,7 +13753,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13493,7 +13781,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TriangleFiniteElement *arg1 = (mfem::P0TriangleFiniteElement *) 0 ; int arg2 ; @@ -13502,21 +13790,26 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TriangleFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TriangleFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TriangleFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TriangleFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TriangleFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13614,7 +13907,7 @@ SWIGINTERN PyObject *_wrap_new_P0QuadFiniteElement(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0QuadFiniteElement *arg1 = (mfem::P0QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13625,15 +13918,20 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0QuadFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0QuadFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13641,7 +13939,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13669,7 +13967,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0QuadFiniteElement *arg1 = (mfem::P0QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13680,15 +13978,20 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0QuadFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0QuadFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13696,7 +13999,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13724,7 +14027,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0QuadFiniteElement *arg1 = (mfem::P0QuadFiniteElement *) 0 ; int arg2 ; @@ -13733,21 +14036,26 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSED int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0QuadFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0QuadFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0QuadFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0QuadFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0QuadFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13845,7 +14153,7 @@ SWIGINTERN PyObject *_wrap_new_Linear3DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13856,15 +14164,20 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13872,7 +14185,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13900,7 +14213,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13911,15 +14224,20 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13927,7 +14245,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13955,7 +14273,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; int arg2 ; @@ -13964,21 +14282,26 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear3DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14006,7 +14329,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; int arg2 ; @@ -14018,26 +14341,32 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_GetFaceDofs(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face", (char *)"dofs", (char *)"ndofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Linear3DFiniteElement_GetFaceDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_GetFaceDofs" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_GetFaceDofs" "', argument " "3"" of type '" "int **""'"); } arg3 = reinterpret_cast< int ** >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Linear3DFiniteElement_GetFaceDofs" "', argument " "4"" of type '" "int *""'"); } @@ -14132,7 +14461,7 @@ SWIGINTERN PyObject *_wrap_new_Quadratic3DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quadratic3DFiniteElement *arg1 = (mfem::Quadratic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14143,15 +14472,20 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quadratic3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quadratic3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Quadratic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quadratic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14159,7 +14493,7 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14187,7 +14521,7 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quadratic3DFiniteElement *arg1 = (mfem::Quadratic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14198,15 +14532,20 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quadratic3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quadratic3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Quadratic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quadratic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14214,7 +14553,7 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14312,7 +14651,7 @@ SWIGINTERN PyObject *_wrap_new_TriLinear3DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TriLinear3DFiniteElement *arg1 = (mfem::TriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14323,15 +14662,20 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TriLinear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TriLinear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::TriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::TriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14339,7 +14683,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14367,7 +14711,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TriLinear3DFiniteElement *arg1 = (mfem::TriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14378,15 +14722,20 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TriLinear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TriLinear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::TriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::TriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14394,7 +14743,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14422,7 +14771,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TriLinear3DFiniteElement *arg1 = (mfem::TriLinear3DFiniteElement *) 0 ; int arg2 ; @@ -14431,21 +14780,26 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_ProjectDelta(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TriLinear3DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TriLinear3DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriLinear3DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::TriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::TriLinear3DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TriLinear3DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14543,7 +14897,7 @@ SWIGINTERN PyObject *_wrap_new_CrouzeixRaviartFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFiniteElement *arg1 = (mfem::CrouzeixRaviartFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14554,15 +14908,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14570,7 +14929,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14598,7 +14957,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFiniteElement *arg1 = (mfem::CrouzeixRaviartFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14609,15 +14968,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14625,7 +14989,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14653,7 +15017,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFiniteElement *arg1 = (mfem::CrouzeixRaviartFiniteElement *) 0 ; int arg2 ; @@ -14662,21 +15026,26 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_ProjectDelta(PyObject *S int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14774,7 +15143,7 @@ SWIGINTERN PyObject *_wrap_new_CrouzeixRaviartQuadFiniteElement(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartQuadFiniteElement *arg1 = (mfem::CrouzeixRaviartQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14785,15 +15154,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartQuadFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartQuadFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14801,7 +15175,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14829,7 +15203,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject * } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartQuadFiniteElement *arg1 = (mfem::CrouzeixRaviartQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14840,15 +15214,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartQuadFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartQuadFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14856,7 +15235,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14929,46 +15308,27 @@ SWIGINTERN PyObject *CrouzeixRaviartQuadFiniteElement_swiginit(PyObject *SWIGUNU return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"Ord", NULL + }; mfem::P0SegmentFiniteElement *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::P0SegmentFiniteElement *)new mfem::P0SegmentFiniteElement(arg1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_P0SegmentFiniteElement", kwnames, &obj0)) SWIG_fail; + if (obj0) { + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__P0SegmentFiniteElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::P0SegmentFiniteElement *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::P0SegmentFiniteElement *)new mfem::P0SegmentFiniteElement(); + result = (mfem::P0SegmentFiniteElement *)new mfem::P0SegmentFiniteElement(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14986,42 +15346,7 @@ SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_P0SegmentFiniteElement", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_P0SegmentFiniteElement__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_P0SegmentFiniteElement__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_P0SegmentFiniteElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::P0SegmentFiniteElement::P0SegmentFiniteElement(int)\n" - " mfem::P0SegmentFiniteElement::P0SegmentFiniteElement()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0SegmentFiniteElement *arg1 = (mfem::P0SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15032,15 +15357,20 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0SegmentFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0SegmentFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15048,7 +15378,7 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15076,7 +15406,7 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0SegmentFiniteElement *arg1 = (mfem::P0SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15087,15 +15417,20 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0SegmentFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0SegmentFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15103,7 +15438,7 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -15364,7 +15699,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TriangleFiniteElement *arg1 = (mfem::RT0TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15375,15 +15710,20 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TriangleFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TriangleFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15391,7 +15731,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15419,7 +15759,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TriangleFiniteElement *arg1 = (mfem::RT0TriangleFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -15430,15 +15770,20 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TriangleFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TriangleFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -15446,7 +15791,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -16082,7 +16427,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0QuadFiniteElement *arg1 = (mfem::RT0QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -16093,15 +16438,20 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0QuadFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0QuadFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16109,7 +16459,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -16137,7 +16487,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0QuadFiniteElement *arg1 = (mfem::RT0QuadFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -16148,15 +16498,20 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0QuadFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0QuadFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -16164,7 +16519,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -16800,7 +17155,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1TriangleFiniteElement *arg1 = (mfem::RT1TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -16811,15 +17166,20 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1TriangleFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1TriangleFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT1TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16827,7 +17187,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -16855,7 +17215,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1TriangleFiniteElement *arg1 = (mfem::RT1TriangleFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -16866,15 +17226,20 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1TriangleFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1TriangleFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT1TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -16882,7 +17247,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -17518,7 +17883,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1QuadFiniteElement *arg1 = (mfem::RT1QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -17529,15 +17894,20 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1QuadFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1QuadFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT1QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17545,7 +17915,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -17573,7 +17943,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1QuadFiniteElement *arg1 = (mfem::RT1QuadFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -17584,15 +17954,20 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1QuadFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1QuadFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT1QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -17600,7 +17975,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -18236,7 +18611,7 @@ SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2TriangleFiniteElement *arg1 = (mfem::RT2TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -18247,15 +18622,20 @@ SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT2TriangleFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2TriangleFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT2TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT2TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -18263,7 +18643,7 @@ SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -18524,7 +18904,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2QuadFiniteElement *arg1 = (mfem::RT2QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -18535,15 +18915,20 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT2QuadFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2QuadFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT2QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT2QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -18551,7 +18936,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -18579,7 +18964,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2QuadFiniteElement *arg1 = (mfem::RT2QuadFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -18590,15 +18975,20 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT2QuadFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2QuadFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT2QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT2QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -18606,7 +18996,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19079,7 +19469,7 @@ SWIGINTERN PyObject *_wrap_new_P1SegmentFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1SegmentFiniteElement *arg1 = (mfem::P1SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19090,15 +19480,20 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1SegmentFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1SegmentFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P1SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19106,7 +19501,7 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19134,7 +19529,7 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1SegmentFiniteElement *arg1 = (mfem::P1SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19145,15 +19540,20 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1SegmentFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1SegmentFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P1SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19161,7 +19561,7 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19259,7 +19659,7 @@ SWIGINTERN PyObject *_wrap_new_P2SegmentFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P2SegmentFiniteElement *arg1 = (mfem::P2SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19270,15 +19670,20 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P2SegmentFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P2SegmentFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P2SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P2SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19286,7 +19691,7 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19314,7 +19719,7 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P2SegmentFiniteElement *arg1 = (mfem::P2SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19325,15 +19730,20 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P2SegmentFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P2SegmentFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P2SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P2SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19341,7 +19751,7 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19414,19 +19824,21 @@ SWIGINTERN PyObject *P2SegmentFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_Lagrange1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Lagrange1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"degree", NULL + }; mfem::Lagrange1DFiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_Lagrange1DFiniteElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -19448,7 +19860,7 @@ SWIGINTERN PyObject *_wrap_new_Lagrange1DFiniteElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Lagrange1DFiniteElement *arg1 = (mfem::Lagrange1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19459,15 +19871,20 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Lagrange1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Lagrange1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Lagrange1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Lagrange1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19475,7 +19892,7 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19503,7 +19920,7 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Lagrange1DFiniteElement *arg1 = (mfem::Lagrange1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19514,15 +19931,20 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Lagrange1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Lagrange1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Lagrange1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Lagrange1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19530,7 +19952,7 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19628,7 +20050,7 @@ SWIGINTERN PyObject *_wrap_new_P1TetNonConfFiniteElement(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1TetNonConfFiniteElement *arg1 = (mfem::P1TetNonConfFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19639,15 +20061,20 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1TetNonConfFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1TetNonConfFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P1TetNonConfFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1TetNonConfFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19655,7 +20082,7 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19683,7 +20110,7 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1TetNonConfFiniteElement *arg1 = (mfem::P1TetNonConfFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19694,15 +20121,20 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1TetNonConfFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1TetNonConfFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P1TetNonConfFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1TetNonConfFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19710,7 +20142,7 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19808,7 +20240,7 @@ SWIGINTERN PyObject *_wrap_new_P0TetFiniteElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TetFiniteElement *arg1 = (mfem::P0TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19819,15 +20251,20 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TetFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TetFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TetFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TetFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19835,7 +20272,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TetFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TetFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19863,7 +20300,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TetFiniteElement *arg1 = (mfem::P0TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19874,15 +20311,20 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TetFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TetFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19890,7 +20332,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19918,7 +20360,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P0TetFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TetFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TetFiniteElement *arg1 = (mfem::P0TetFiniteElement *) 0 ; int arg2 ; @@ -19927,21 +20369,26 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TetFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TetFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TetFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TetFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TetFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20039,7 +20486,7 @@ SWIGINTERN PyObject *_wrap_new_P0HexFiniteElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0HexFiniteElement *arg1 = (mfem::P0HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20050,15 +20497,20 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0HexFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0HexFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0HexFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0HexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20066,7 +20518,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0HexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0HexFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20094,7 +20546,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0HexFiniteElement *arg1 = (mfem::P0HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20105,15 +20557,20 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0HexFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0HexFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20121,7 +20578,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -20149,7 +20606,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P0HexFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0HexFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0HexFiniteElement *arg1 = (mfem::P0HexFiniteElement *) 0 ; int arg2 ; @@ -20158,21 +20615,26 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0HexFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0HexFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0HexFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0HexFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0HexFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20245,19 +20707,21 @@ SWIGINTERN PyObject *P0HexFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_LagrangeHexFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_LagrangeHexFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"degree", NULL + }; mfem::LagrangeHexFiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_LagrangeHexFiniteElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -20279,7 +20743,7 @@ SWIGINTERN PyObject *_wrap_new_LagrangeHexFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LagrangeHexFiniteElement *arg1 = (mfem::LagrangeHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20290,15 +20754,20 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LagrangeHexFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LagrangeHexFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::LagrangeHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::LagrangeHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20306,7 +20775,7 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20334,7 +20803,7 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LagrangeHexFiniteElement *arg1 = (mfem::LagrangeHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20345,15 +20814,20 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LagrangeHexFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LagrangeHexFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::LagrangeHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::LagrangeHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20361,7 +20835,7 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -20459,7 +20933,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinear1DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear1DFiniteElement *arg1 = (mfem::RefinedLinear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20470,15 +20944,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedLinear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20486,7 +20965,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20514,7 +20993,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear1DFiniteElement *arg1 = (mfem::RefinedLinear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20525,15 +21004,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedLinear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20541,7 +21025,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -20639,7 +21123,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinear2DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear2DFiniteElement *arg1 = (mfem::RefinedLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20650,15 +21134,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20666,7 +21155,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20694,7 +21183,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear2DFiniteElement *arg1 = (mfem::RefinedLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20705,15 +21194,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20721,7 +21215,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -20819,7 +21313,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinear3DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear3DFiniteElement *arg1 = (mfem::RefinedLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20830,15 +21324,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20846,7 +21345,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20874,7 +21373,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear3DFiniteElement *arg1 = (mfem::RefinedLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20885,15 +21384,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20901,7 +21405,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -20999,7 +21503,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedBiLinear2DFiniteElement(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedBiLinear2DFiniteElement *arg1 = (mfem::RefinedBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21010,15 +21514,20 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedBiLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedBiLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21026,7 +21535,7 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21054,7 +21563,7 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SW } -SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedBiLinear2DFiniteElement *arg1 = (mfem::RefinedBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21065,15 +21574,20 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedBiLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedBiLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21081,7 +21595,7 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21179,7 +21693,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedTriLinear3DFiniteElement(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedTriLinear3DFiniteElement *arg1 = (mfem::RefinedTriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21190,15 +21704,20 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedTriLinear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedTriLinear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedTriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedTriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21206,7 +21725,7 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21234,7 +21753,7 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *S } -SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedTriLinear3DFiniteElement *arg1 = (mfem::RefinedTriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21245,15 +21764,20 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedTriLinear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedTriLinear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedTriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedTriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21261,7 +21785,7 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21522,7 +22046,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1HexFiniteElement *arg1 = (mfem::Nedelec1HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21533,15 +22057,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1HexFiniteElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1HexFiniteElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::Nedelec1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21549,7 +22078,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21577,7 +22106,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1HexFiniteElement *arg1 = (mfem::Nedelec1HexFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -21588,15 +22117,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1HexFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1HexFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::Nedelec1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -21604,7 +22138,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -22240,7 +22774,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1TetFiniteElement *arg1 = (mfem::Nedelec1TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22251,15 +22785,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1TetFiniteElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1TetFiniteElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::Nedelec1TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22267,7 +22806,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -22295,7 +22834,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1TetFiniteElement *arg1 = (mfem::Nedelec1TetFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -22306,15 +22845,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1TetFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1TetFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::Nedelec1TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -22322,7 +22866,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -22958,7 +23502,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcVShape(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0HexFiniteElement *arg1 = (mfem::RT0HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22969,15 +23513,20 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0HexFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0HexFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22985,7 +23534,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -23013,7 +23562,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0HexFiniteElement *arg1 = (mfem::RT0HexFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -23024,15 +23573,20 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0HexFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0HexFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -23040,7 +23594,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -23676,7 +24230,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcVShape(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1HexFiniteElement *arg1 = (mfem::RT1HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -23687,15 +24241,20 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1HexFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1HexFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -23703,7 +24262,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -23731,7 +24290,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1HexFiniteElement *arg1 = (mfem::RT1HexFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -23742,15 +24301,20 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1HexFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1HexFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -23758,7 +24322,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -24394,7 +24958,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcVShape(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TetFiniteElement *arg1 = (mfem::RT0TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -24405,15 +24969,20 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TetFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TetFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -24421,7 +24990,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -24449,7 +25018,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TetFiniteElement *arg1 = (mfem::RT0TetFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -24460,15 +25029,20 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TetFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TetFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -24476,7 +25050,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -24949,7 +25523,7 @@ SWIGINTERN PyObject *_wrap_new_RotTriLinearHexFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RotTriLinearHexFiniteElement *arg1 = (mfem::RotTriLinearHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -24960,15 +25534,20 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RotTriLinearHexFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RotTriLinearHexFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RotTriLinearHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RotTriLinearHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -24976,7 +25555,7 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -25004,7 +25583,7 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RotTriLinearHexFiniteElement *arg1 = (mfem::RotTriLinearHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -25015,15 +25594,20 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RotTriLinearHexFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RotTriLinearHexFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RotTriLinearHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RotTriLinearHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -25031,7 +25615,7 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -25129,19 +25713,21 @@ SWIGINTERN PyObject *_wrap_new_Poly_1D(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Poly_1D_Binom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_Binom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Poly_1D_Binom", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -25163,33 +25749,38 @@ SWIGINTERN PyObject *_wrap_Poly_1D_Binom(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Poly_1D_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_GetPoints", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Poly_1D_GetPoints", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_GetPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -25211,32 +25802,40 @@ SWIGINTERN PyObject *_wrap_Poly_1D_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; - int arg3 ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL + }; double *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Poly_1D_OpenPoints", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_OpenPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { @@ -25258,138 +25857,40 @@ SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_OpenPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); - } - arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double *)(arg1)->OpenPoints(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Poly_1D_OpenPoints", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_OpenPoints__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_OpenPoints__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Poly_1D_OpenPoints'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Poly_1D::OpenPoints(int const,int const)\n" - " mfem::Poly_1D::OpenPoints(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; double *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Poly_1D_ClosedPoints", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_ClosedPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { @@ -25411,139 +25912,38 @@ SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_ClosedPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); - } - arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double *)(arg1)->ClosedPoints(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Poly_1D_ClosedPoints", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_ClosedPoints__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_ClosedPoints__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Poly_1D_ClosedPoints'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Poly_1D::ClosedPoints(int const,int const)\n" - " mfem::Poly_1D::ClosedPoints(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_GetBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_GetBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL + }; mfem::Poly_1D::Basis *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_GetBasis", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Poly_1D_GetBasis", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_GetBasis" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -25839,23 +26239,27 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcBasis(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Poly_1D_CalcDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_CalcDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double arg2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_CalcDelta", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Poly_1D_CalcDelta", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcDelta" "', argument " "2"" of type '" "double""'"); } @@ -25880,22 +26284,26 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcDelta(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Poly_1D_ChebyshevPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_ChebyshevPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_ChebyshevPoints", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Poly_1D_ChebyshevPoints", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Poly_1D_ChebyshevPoints" "', argument " "2"" of type '" "double *""'"); } @@ -26123,7 +26531,7 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcBinomTerms(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_Poly_1D_CalcDBinomTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_CalcDBinomTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double arg2 ; @@ -26135,26 +26543,32 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcDBinomTerms(PyObject *SWIGUNUSEDPARM(self int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"x", (char *)"y", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_CalcDBinomTerms", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Poly_1D_CalcDBinomTerms", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcDBinomTerms" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Poly_1D_CalcDBinomTerms" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Poly_1D_CalcDBinomTerms" "', argument " "4"" of type '" "double *""'"); } @@ -26574,7 +26988,7 @@ SWIGINTERN PyObject *Poly_1D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TensorBasisElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TensorBasisElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -26582,29 +26996,35 @@ SWIGINTERN PyObject *_wrap_new_TensorBasisElement(PyObject *SWIGUNUSEDPARM(self) mfem::TensorBasisElement::DofMapType arg4 ; int val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"dims", (char *)"p", (char *)"btype", (char *)"dmtype", NULL + }; mfem::TensorBasisElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_TensorBasisElement", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_TensorBasisElement", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TensorBasisElement" "', argument " "4"" of type '" "mfem::TensorBasisElement::DofMapType""'"); } @@ -26734,19 +27154,21 @@ SWIGINTERN PyObject *_wrap_TensorBasisElement_GetDofMap(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_TensorBasisElement_GetTensorProductGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TensorBasisElement_GetTensorProductGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"dim", NULL + }; mfem::Geometry::Type result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:TensorBasisElement_GetTensorProductGeometry", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -26768,25 +27190,29 @@ SWIGINTERN PyObject *_wrap_TensorBasisElement_GetTensorProductGeometry(PyObject } -SWIGINTERN PyObject *_wrap_TensorBasisElement_Pow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TensorBasisElement_Pow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"base", (char *)"dim", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "TensorBasisElement_Pow", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TensorBasisElement_Pow", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -26853,7 +27279,7 @@ SWIGINTERN PyObject *TensorBasisElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalTensorFiniteElement *arg1 = (mfem::NodalTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -26864,16 +27290,21 @@ SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGU int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NodalTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NodalTensorFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::NodalTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -26881,7 +27312,7 @@ SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -26947,7 +27378,7 @@ SWIGINTERN PyObject *NodalTensorFiniteElement_swigregister(PyObject *SWIGUNUSEDP return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PositiveTensorFiniteElement *arg1 = (mfem::PositiveTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -26958,16 +27389,21 @@ SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SW int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PositiveTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PositiveTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PositiveTensorFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PositiveTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::PositiveTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PositiveTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -26975,7 +27411,7 @@ SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -27041,7 +27477,7 @@ SWIGINTERN PyObject *PositiveTensorFiniteElement_swigregister(PyObject *SWIGUNUS return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -27052,47 +27488,56 @@ SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPAR mfem::TensorBasisElement::DofMapType arg7 ; int val7 ; int ecode7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"dims", (char *)"d", (char *)"p", (char *)"cbtype", (char *)"obtype", (char *)"M", (char *)"dmtype", NULL + }; mfem::VectorTensorFiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorTensorFiniteElement", 7, 7, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:new_VectorTensorFiniteElement", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg6 = PyArray_PyIntAsInt(obj5); } - ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); + ecode7 = SWIG_AsVal_int(obj6, &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VectorTensorFiniteElement" "', argument " "7"" of type '" "mfem::TensorBasisElement::DofMapType""'"); } @@ -27117,7 +27562,7 @@ SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -27128,16 +27573,21 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIG int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorTensorFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -27145,7 +27595,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -27170,7 +27620,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -27181,16 +27631,21 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject * int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuadOpen", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorTensorFiniteElement_GetDofToQuadOpen", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -27198,7 +27653,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -27223,7 +27678,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject * } -SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -27237,16 +27692,22 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", (char *)"closed", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetTensorDofToQuad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorTensorFiniteElement_GetTensorDofToQuad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -27254,12 +27715,12 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } arg3 = static_cast< mfem::DofToQuad::Mode >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "4"" of type '" "bool""'"); } @@ -27329,24 +27790,31 @@ SWIGINTERN PyObject *VectorTensorFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_SegmentElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_SegmentElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -27368,95 +27836,7 @@ SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_SegmentElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::H1_SegmentElement *)new mfem::H1_SegmentElement(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_SegmentElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_SegmentElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_SegmentElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_SegmentElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_SegmentElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_SegmentElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_SegmentElement::H1_SegmentElement(int const,int const)\n" - " mfem::H1_SegmentElement::H1_SegmentElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_SegmentElement *arg1 = (mfem::H1_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -27467,15 +27847,20 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -27483,7 +27868,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -27511,7 +27896,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_SegmentElement *arg1 = (mfem::H1_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -27522,15 +27907,20 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -27538,7 +27928,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -27566,7 +27956,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_SegmentElement *arg1 = (mfem::H1_SegmentElement *) 0 ; int arg2 ; @@ -27575,21 +27965,26 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -27662,24 +28057,31 @@ SWIGINTERN PyObject *H1_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_QuadrilateralElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_QuadrilateralElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -27701,95 +28103,7 @@ SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::H1_QuadrilateralElement *)new mfem::H1_QuadrilateralElement(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_QuadrilateralElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_QuadrilateralElement::H1_QuadrilateralElement(int const,int const)\n" - " mfem::H1_QuadrilateralElement::H1_QuadrilateralElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_QuadrilateralElement *arg1 = (mfem::H1_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -27800,15 +28114,20 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -27816,7 +28135,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -27844,7 +28163,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_QuadrilateralElement *arg1 = (mfem::H1_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -27855,15 +28174,20 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -27871,7 +28195,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -27899,7 +28223,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_QuadrilateralElement *arg1 = (mfem::H1_QuadrilateralElement *) 0 ; int arg2 ; @@ -27908,21 +28232,26 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -27995,60 +28324,35 @@ SWIGINTERN PyObject *H1_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_HexahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_HexahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1_HexahedronElement *)new mfem::H1_HexahedronElement(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_HexahedronElement *)new mfem::H1_HexahedronElement(arg1); + result = (mfem::H1_HexahedronElement *)new mfem::H1_HexahedronElement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -28066,63 +28370,7 @@ SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_HexahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_HexahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_HexahedronElement::H1_HexahedronElement(int const,int const)\n" - " mfem::H1_HexahedronElement::H1_HexahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_HexahedronElement *arg1 = (mfem::H1_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28133,15 +28381,20 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28149,7 +28402,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28177,7 +28430,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_HexahedronElement *arg1 = (mfem::H1_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28188,15 +28441,20 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28204,7 +28462,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -28232,7 +28490,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_H1_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_HexahedronElement *arg1 = (mfem::H1_HexahedronElement *) 0 ; int arg2 ; @@ -28241,21 +28499,26 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28328,19 +28591,21 @@ SWIGINTERN PyObject *H1_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_SegmentElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_SegmentElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -28362,7 +28627,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_SegmentElement *arg1 = (mfem::H1Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28373,15 +28638,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28389,7 +28659,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28417,7 +28687,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_SegmentElement *arg1 = (mfem::H1Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28428,15 +28698,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28444,7 +28719,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -28472,7 +28747,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_SegmentElement *arg1 = (mfem::H1Pos_SegmentElement *) 0 ; int arg2 ; @@ -28481,21 +28756,26 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28568,19 +28848,21 @@ SWIGINTERN PyObject *H1Pos_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_QuadrilateralElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_QuadrilateralElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -28602,7 +28884,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_QuadrilateralElement *arg1 = (mfem::H1Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28613,15 +28895,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28629,7 +28916,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28657,7 +28944,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_QuadrilateralElement *arg1 = (mfem::H1Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28668,15 +28955,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28684,7 +28976,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -28712,7 +29004,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_QuadrilateralElement *arg1 = (mfem::H1Pos_QuadrilateralElement *) 0 ; int arg2 ; @@ -28721,21 +29013,26 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_ProjectDelta(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28808,19 +29105,21 @@ SWIGINTERN PyObject *H1Pos_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Ser_QuadrilateralElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Ser_QuadrilateralElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -28842,7 +29141,7 @@ SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28853,15 +29152,20 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Ser_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28869,7 +29173,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28897,7 +29201,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -28908,15 +29212,20 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Ser_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -28924,7 +29233,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -28952,7 +29261,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -28963,15 +29272,20 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Ser_QuadrilateralElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -28979,7 +29293,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -29337,19 +29651,21 @@ SWIGINTERN PyObject *H1Ser_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_HexahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_HexahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -29371,7 +29687,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -29382,15 +29698,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -29398,7 +29719,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -29426,7 +29747,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -29437,15 +29758,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -29453,7 +29779,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -29481,7 +29807,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; int arg2 ; @@ -29490,21 +29816,26 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -29577,24 +29908,31 @@ SWIGINTERN PyObject *H1Pos_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_TriangleElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_TriangleElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -29616,95 +29954,7 @@ SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_TriangleElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TriangleElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_TriangleElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TriangleElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TriangleElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_TriangleElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_TriangleElement::H1_TriangleElement(int const,int const)\n" - " mfem::H1_TriangleElement::H1_TriangleElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TriangleElement *arg1 = (mfem::H1_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -29715,15 +29965,20 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TriangleElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TriangleElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TriangleElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -29731,7 +29986,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TriangleElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -29759,7 +30014,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TriangleElement *arg1 = (mfem::H1_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -29770,15 +30025,20 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TriangleElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TriangleElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TriangleElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -29786,7 +30046,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TriangleElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -29814,7 +30074,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TriangleElement *arg1 = (mfem::H1_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -29825,15 +30085,20 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"ddshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TriangleElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TriangleElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TriangleElement_CalcHessian" "', argument " "1"" of type '" "mfem::H1_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TriangleElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -29841,7 +30106,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TriangleElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TriangleElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -29914,60 +30179,35 @@ SWIGINTERN PyObject *H1_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_TetrahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_TetrahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::H1_TetrahedronElement *)new mfem::H1_TetrahedronElement(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TetrahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_TetrahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_TetrahedronElement *)new mfem::H1_TetrahedronElement(arg1); + result = (mfem::H1_TetrahedronElement *)new mfem::H1_TetrahedronElement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -29985,63 +30225,7 @@ SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_TetrahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TetrahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TetrahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_TetrahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_TetrahedronElement::H1_TetrahedronElement(int const,int const)\n" - " mfem::H1_TetrahedronElement::H1_TetrahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TetrahedronElement *arg1 = (mfem::H1_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30052,15 +30236,20 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TetrahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TetrahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30068,7 +30257,7 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -30096,7 +30285,7 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TetrahedronElement *arg1 = (mfem::H1_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30107,15 +30296,20 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TetrahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TetrahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30123,7 +30317,7 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -30151,7 +30345,7 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TetrahedronElement *arg1 = (mfem::H1_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30162,15 +30356,20 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcHessian(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"ddshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TetrahedronElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TetrahedronElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30178,7 +30377,7 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcHessian(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -30251,19 +30450,21 @@ SWIGINTERN PyObject *H1_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -30695,19 +30896,21 @@ SWIGINTERN PyObject *H1Pos_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -31167,60 +31370,35 @@ SWIGINTERN PyObject *H1Pos_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_WedgeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_WedgeElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_WedgeElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::H1_WedgeElement *)new mfem::H1_WedgeElement(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_WedgeElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_WedgeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_WedgeElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_WedgeElement *)new mfem::H1_WedgeElement(arg1); + result = (mfem::H1_WedgeElement *)new mfem::H1_WedgeElement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -31238,63 +31416,7 @@ SWIGINTERN PyObject *_wrap_new_H1_WedgeElement__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_H1_WedgeElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_WedgeElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_WedgeElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_WedgeElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_WedgeElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_WedgeElement::H1_WedgeElement(int const,int const)\n" - " mfem::H1_WedgeElement::H1_WedgeElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_WedgeElement *arg1 = (mfem::H1_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31305,15 +31427,20 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31321,7 +31448,7 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -31349,7 +31476,7 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_WedgeElement *arg1 = (mfem::H1_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31360,15 +31487,20 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31376,7 +31508,7 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -31659,19 +31791,21 @@ SWIGINTERN PyObject *BiCubic3DFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_WedgeElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_WedgeElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -31693,7 +31827,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_WedgeElement *arg1 = (mfem::H1Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31704,15 +31838,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31720,7 +31859,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -31748,7 +31887,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_WedgeElement *arg1 = (mfem::H1Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31759,15 +31898,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31775,7 +31919,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -31848,24 +31992,31 @@ SWIGINTERN PyObject *H1Pos_WedgeElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_SegmentElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_SegmentElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -31887,95 +32038,7 @@ SWIGINTERN PyObject *_wrap_new_L2_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_L2_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_SegmentElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::L2_SegmentElement *)new mfem::L2_SegmentElement(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_SegmentElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_SegmentElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_SegmentElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_SegmentElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_SegmentElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_SegmentElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_SegmentElement::L2_SegmentElement(int const,int const)\n" - " mfem::L2_SegmentElement::L2_SegmentElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_SegmentElement *arg1 = (mfem::L2_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31986,15 +32049,20 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32002,7 +32070,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32030,7 +32098,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_SegmentElement *arg1 = (mfem::L2_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32041,15 +32109,20 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32057,7 +32130,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32085,7 +32158,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_SegmentElement *arg1 = (mfem::L2_SegmentElement *) 0 ; int arg2 ; @@ -32094,21 +32167,26 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32181,19 +32259,21 @@ SWIGINTERN PyObject *L2_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_SegmentElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_SegmentElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -32215,7 +32295,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_SegmentElement *arg1 = (mfem::L2Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32226,15 +32306,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32242,7 +32327,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32270,7 +32355,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_SegmentElement *arg1 = (mfem::L2Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32281,15 +32366,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32297,7 +32387,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32325,7 +32415,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_SegmentElement *arg1 = (mfem::L2Pos_SegmentElement *) 0 ; int arg2 ; @@ -32334,21 +32424,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32421,60 +32516,35 @@ SWIGINTERN PyObject *L2Pos_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_QuadrilateralElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_QuadrilateralElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::L2_QuadrilateralElement *)new mfem::L2_QuadrilateralElement(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_QuadrilateralElement *)new mfem::L2_QuadrilateralElement(arg1); + result = (mfem::L2_QuadrilateralElement *)new mfem::L2_QuadrilateralElement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -32492,63 +32562,7 @@ SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_QuadrilateralElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_QuadrilateralElement::L2_QuadrilateralElement(int const,int const)\n" - " mfem::L2_QuadrilateralElement::L2_QuadrilateralElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32559,15 +32573,20 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32575,7 +32594,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32603,7 +32622,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32614,15 +32633,20 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32630,7 +32654,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32658,7 +32682,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; int arg2 ; @@ -32667,21 +32691,26 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32709,7 +32738,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -32723,15 +32752,21 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:L2_QuadrilateralElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -32739,7 +32774,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -32747,7 +32782,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -32820,19 +32855,21 @@ SWIGINTERN PyObject *L2_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_QuadrilateralElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_QuadrilateralElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -32854,7 +32891,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_QuadrilateralElement *arg1 = (mfem::L2Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32865,15 +32902,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32881,7 +32923,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32909,7 +32951,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_QuadrilateralElement *arg1 = (mfem::L2Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32920,15 +32962,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32936,7 +32983,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32964,7 +33011,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_QuadrilateralElement *arg1 = (mfem::L2Pos_QuadrilateralElement *) 0 ; int arg2 ; @@ -32973,21 +33020,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_ProjectDelta(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -33060,24 +33112,31 @@ SWIGINTERN PyObject *L2Pos_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_HexahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_HexahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -33099,95 +33158,7 @@ SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::L2_HexahedronElement *)new mfem::L2_HexahedronElement(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_HexahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_HexahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_HexahedronElement::L2_HexahedronElement(int const,int const)\n" - " mfem::L2_HexahedronElement::L2_HexahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_HexahedronElement *arg1 = (mfem::L2_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -33198,15 +33169,20 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -33214,7 +33190,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -33242,7 +33218,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_HexahedronElement *arg1 = (mfem::L2_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -33253,15 +33229,20 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -33269,7 +33250,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -33297,7 +33278,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_HexahedronElement *arg1 = (mfem::L2_HexahedronElement *) 0 ; int arg2 ; @@ -33306,21 +33287,26 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -33393,19 +33379,21 @@ SWIGINTERN PyObject *L2_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_HexahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_HexahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -33427,7 +33415,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_HexahedronElement *arg1 = (mfem::L2Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -33438,15 +33426,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -33454,7 +33447,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -33482,7 +33475,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_HexahedronElement *arg1 = (mfem::L2Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -33493,15 +33486,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -33509,7 +33507,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -33537,7 +33535,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_HexahedronElement *arg1 = (mfem::L2Pos_HexahedronElement *) 0 ; int arg2 ; @@ -33546,21 +33544,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -33633,60 +33636,35 @@ SWIGINTERN PyObject *L2Pos_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_TriangleElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_TriangleElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::L2_TriangleElement *)new mfem::L2_TriangleElement(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_TriangleElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_TriangleElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_TriangleElement *)new mfem::L2_TriangleElement(arg1); + result = (mfem::L2_TriangleElement *)new mfem::L2_TriangleElement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -33704,63 +33682,7 @@ SWIGINTERN PyObject *_wrap_new_L2_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_L2_TriangleElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_TriangleElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TriangleElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TriangleElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_TriangleElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_TriangleElement::L2_TriangleElement(int const,int const)\n" - " mfem::L2_TriangleElement::L2_TriangleElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -33771,15 +33693,20 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TriangleElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -33787,7 +33714,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -33815,7 +33742,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -33826,15 +33753,20 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TriangleElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -33842,7 +33774,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -33870,7 +33802,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; int arg2 ; @@ -33879,21 +33811,26 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TriangleElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -33921,7 +33858,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -33935,15 +33872,21 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:L2_TriangleElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -33951,7 +33894,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -33959,7 +33902,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -34032,19 +33975,21 @@ SWIGINTERN PyObject *L2_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -34066,7 +34011,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TriangleElement *arg1 = (mfem::L2Pos_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34077,15 +34022,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TriangleElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TriangleElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34093,7 +34043,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34121,7 +34071,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TriangleElement *arg1 = (mfem::L2Pos_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34132,15 +34082,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TriangleElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TriangleElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34148,7 +34103,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -34176,7 +34131,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TriangleElement *arg1 = (mfem::L2Pos_TriangleElement *) 0 ; int arg2 ; @@ -34185,21 +34140,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TriangleElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TriangleElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TriangleElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TriangleElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TriangleElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34272,60 +34232,35 @@ SWIGINTERN PyObject *L2Pos_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_TetrahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_TetrahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::L2_TetrahedronElement *)new mfem::L2_TetrahedronElement(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_TetrahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_TetrahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_TetrahedronElement *)new mfem::L2_TetrahedronElement(arg1); + result = (mfem::L2_TetrahedronElement *)new mfem::L2_TetrahedronElement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -34343,63 +34278,7 @@ SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_TetrahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TetrahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TetrahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_TetrahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_TetrahedronElement::L2_TetrahedronElement(int const,int const)\n" - " mfem::L2_TetrahedronElement::L2_TetrahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TetrahedronElement *arg1 = (mfem::L2_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34410,15 +34289,20 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TetrahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TetrahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34426,7 +34310,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34454,7 +34338,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TetrahedronElement *arg1 = (mfem::L2_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34465,15 +34349,20 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TetrahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TetrahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34481,7 +34370,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -34509,7 +34398,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TetrahedronElement *arg1 = (mfem::L2_TetrahedronElement *) 0 ; int arg2 ; @@ -34518,21 +34407,26 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TetrahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TetrahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TetrahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TetrahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TetrahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34605,19 +34499,21 @@ SWIGINTERN PyObject *L2_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -34639,7 +34535,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TetrahedronElement *arg1 = (mfem::L2Pos_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34650,15 +34546,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TetrahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TetrahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34666,7 +34567,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34694,7 +34595,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TetrahedronElement *arg1 = (mfem::L2Pos_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34705,15 +34606,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TetrahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TetrahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34721,7 +34627,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -34749,7 +34655,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TetrahedronElement *arg1 = (mfem::L2Pos_TetrahedronElement *) 0 ; int arg2 ; @@ -34758,21 +34664,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_ProjectDelta(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TetrahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TetrahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TetrahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TetrahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TetrahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34845,60 +34756,35 @@ SWIGINTERN PyObject *L2Pos_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_WedgeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_WedgeElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_WedgeElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::L2_WedgeElement *)new mfem::L2_WedgeElement(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_WedgeElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_WedgeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_WedgeElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_WedgeElement *)new mfem::L2_WedgeElement(arg1); + result = (mfem::L2_WedgeElement *)new mfem::L2_WedgeElement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -34916,63 +34802,7 @@ SWIGINTERN PyObject *_wrap_new_L2_WedgeElement__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_L2_WedgeElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_WedgeElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_WedgeElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_WedgeElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_WedgeElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_WedgeElement::L2_WedgeElement(int const,int const)\n" - " mfem::L2_WedgeElement::L2_WedgeElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_WedgeElement *arg1 = (mfem::L2_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34983,15 +34813,20 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34999,7 +34834,7 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35027,7 +34862,7 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_WedgeElement *arg1 = (mfem::L2_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35038,15 +34873,20 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35054,7 +34894,7 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -35197,19 +35037,21 @@ SWIGINTERN PyObject *P0WedgeFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_WedgeElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_WedgeElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -35231,7 +35073,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_WedgeElement *arg1 = (mfem::L2Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35242,15 +35084,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35258,7 +35105,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35286,7 +35133,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_WedgeElement *arg1 = (mfem::L2Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35297,15 +35144,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35313,7 +35165,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -35386,106 +35238,45 @@ SWIGINTERN PyObject *L2Pos_WedgeElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::RT_QuadrilateralElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_RT_QuadrilateralElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1,arg2,arg3); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::RT_QuadrilateralElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1,arg2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::RT_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1); + result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -35503,97 +35294,6 @@ SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_QuadrilateralElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_QuadrilateralElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RT_QuadrilateralElement::RT_QuadrilateralElement(int const,int const,int const)\n" - " mfem::RT_QuadrilateralElement::RT_QuadrilateralElement(int const,int const)\n" - " mfem::RT_QuadrilateralElement::RT_QuadrilateralElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; @@ -35757,7 +35457,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcVShape(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35768,15 +35468,20 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_QuadrilateralElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35784,7 +35489,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35812,7 +35517,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -35823,15 +35528,20 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_QuadrilateralElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -35839,7 +35549,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -35867,7 +35577,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObjec } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -35878,15 +35588,20 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_QuadrilateralElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -35894,7 +35609,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -35922,7 +35637,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -35936,15 +35651,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -35952,7 +35673,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -35960,7 +35681,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -36248,7 +35969,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_Project__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -36262,15 +35983,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -36278,7 +36005,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -36286,7 +36013,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -36518,7 +36245,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_Project(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -36532,15 +36259,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -36548,7 +36281,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -36556,7 +36289,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -36584,7 +36317,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -36598,15 +36331,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -36614,7 +36353,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -36622,7 +36361,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -36695,106 +36434,45 @@ SWIGINTERN PyObject *RT_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::RT_HexahedronElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_RT_HexahedronElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1,arg2,arg3); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::RT_HexahedronElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1,arg2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::RT_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1); + result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -36812,97 +36490,6 @@ SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_2(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_HexahedronElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_HexahedronElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_HexahedronElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RT_HexahedronElement::RT_HexahedronElement(int const,int const,int const)\n" - " mfem::RT_HexahedronElement::RT_HexahedronElement(int const,int const)\n" - " mfem::RT_HexahedronElement::RT_HexahedronElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; @@ -37066,7 +36653,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37077,15 +36664,20 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_HexahedronElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37093,7 +36685,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -37121,7 +36713,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -37132,15 +36724,20 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_HexahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -37148,7 +36745,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -37176,7 +36773,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject * } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -37187,15 +36784,20 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_HexahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -37203,7 +36805,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -37231,7 +36833,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SW } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -37245,15 +36847,21 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_HexahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -37261,7 +36869,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -37269,7 +36877,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -37557,7 +37165,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_Project__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -37571,15 +37179,21 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_HexahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -37587,7 +37201,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -37595,7 +37209,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -37827,7 +37441,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_Project(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -37841,15 +37455,21 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_HexahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -37857,7 +37477,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -37865,7 +37485,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -37938,19 +37558,21 @@ SWIGINTERN PyObject *RT_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RT_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::RT_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_RT_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -38135,7 +37757,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcVShape(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -38146,15 +37768,20 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TriangleElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -38162,7 +37789,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -38190,7 +37817,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -38201,15 +37828,20 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TriangleElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -38217,7 +37849,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -38245,7 +37877,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SW } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -38256,15 +37888,20 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TriangleElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -38272,7 +37909,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -38300,7 +37937,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -38314,15 +37951,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -38330,7 +37973,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -38338,7 +37981,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -38626,7 +38269,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_Project__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -38640,15 +38283,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -38656,7 +38305,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -38664,7 +38313,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -38896,7 +38545,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_Project(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -38910,15 +38559,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -38926,7 +38581,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -38934,7 +38589,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -38962,7 +38617,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -38976,15 +38631,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -38992,7 +38653,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -39000,7 +38661,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -39073,19 +38734,21 @@ SWIGINTERN PyObject *RT_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RT_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::RT_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_RT_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -39270,7 +38933,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcVShape(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -39281,15 +38944,20 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TetrahedronElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -39297,7 +38965,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -39325,7 +38993,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -39336,15 +39004,20 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TetrahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -39352,7 +39025,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -39380,7 +39053,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -39391,15 +39064,20 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TetrahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -39407,7 +39085,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -39435,7 +39113,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *S } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -39449,15 +39127,21 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TetrahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -39465,7 +39149,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -39473,7 +39157,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -39761,7 +39445,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_Project__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -39775,15 +39459,21 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TetrahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -39791,7 +39481,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -39799,7 +39489,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -40031,7 +39721,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_Project(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -40045,15 +39735,21 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TetrahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -40061,7 +39757,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -40069,7 +39765,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -40142,106 +39838,45 @@ SWIGINTERN PyObject *RT_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::ND_HexahedronElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_ND_HexahedronElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1,arg2,arg3); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_HexahedronElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1,arg2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::ND_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1); + result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -40259,97 +39894,6 @@ SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_2(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_HexahedronElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_HexahedronElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_HexahedronElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_HexahedronElement::ND_HexahedronElement(int const,int const,int const)\n" - " mfem::ND_HexahedronElement::ND_HexahedronElement(int const,int const)\n" - " mfem::ND_HexahedronElement::ND_HexahedronElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; @@ -40513,7 +40057,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -40524,15 +40068,20 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_HexahedronElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -40540,7 +40089,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -40568,7 +40117,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -40579,15 +40128,20 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_HexahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -40595,7 +40149,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -40623,7 +40177,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject * } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -40634,15 +40188,20 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_HexahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -40650,7 +40209,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -40678,7 +40237,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SW } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -40692,15 +40251,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -40708,7 +40273,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -40716,7 +40281,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -41004,7 +40569,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_Project__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -41018,15 +40583,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -41034,7 +40605,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -41042,7 +40613,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -41274,7 +40845,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_Project(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -41288,15 +40859,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -41304,7 +40881,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -41312,7 +40889,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -41340,7 +40917,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -41354,15 +40931,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -41370,7 +40953,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -41378,7 +40961,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -41451,106 +41034,45 @@ SWIGINTERN PyObject *ND_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::ND_QuadrilateralElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_ND_QuadrilateralElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1,arg2,arg3); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_QuadrilateralElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1,arg2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::ND_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1); + result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -41568,97 +41090,6 @@ SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_QuadrilateralElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_QuadrilateralElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_QuadrilateralElement::ND_QuadrilateralElement(int const,int const,int const)\n" - " mfem::ND_QuadrilateralElement::ND_QuadrilateralElement(int const,int const)\n" - " mfem::ND_QuadrilateralElement::ND_QuadrilateralElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; @@ -41822,7 +41253,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcVShape(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -41833,15 +41264,20 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_QuadrilateralElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -41849,7 +41285,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -41877,7 +41313,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -41888,15 +41324,20 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_QuadrilateralElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -41904,7 +41345,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -41932,7 +41373,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObjec } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -41943,15 +41384,20 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_QuadrilateralElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -41959,7 +41405,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -41987,7 +41433,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -42001,15 +41447,21 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_QuadrilateralElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -42017,7 +41469,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -42025,7 +41477,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -42313,7 +41765,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_Project__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -42327,15 +41779,21 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_QuadrilateralElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -42343,7 +41801,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -42351,7 +41809,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -42583,7 +42041,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_Project(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -42597,15 +42055,21 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_QuadrilateralElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -42613,7 +42077,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -42621,7 +42085,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -42694,19 +42158,21 @@ SWIGINTERN PyObject *ND_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ND_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::ND_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ND_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -42891,7 +42357,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcVShape(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -42902,15 +42368,20 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TetrahedronElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -42918,7 +42389,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -42946,7 +42417,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -42957,15 +42428,20 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TetrahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -42973,7 +42449,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -43001,7 +42477,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -43012,15 +42488,20 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TetrahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -43028,7 +42509,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -43056,7 +42537,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *S } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -43070,15 +42551,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -43086,7 +42573,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -43094,7 +42581,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -43382,7 +42869,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_Project__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -43396,15 +42883,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -43412,7 +42905,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -43420,7 +42913,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -43652,7 +43145,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_Project(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -43666,15 +43159,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -43682,7 +43181,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -43690,7 +43189,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -43718,7 +43217,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -43732,15 +43231,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -43748,7 +43253,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -43756,7 +43261,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -43829,19 +43334,21 @@ SWIGINTERN PyObject *ND_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ND_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::ND_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ND_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -44026,7 +43533,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcVShape(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -44037,15 +43544,20 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TriangleElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -44053,7 +43565,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -44081,7 +43593,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -44092,15 +43604,20 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TriangleElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -44108,7 +43625,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -44136,7 +43653,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SW } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -44147,15 +43664,20 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TriangleElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -44163,7 +43685,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -44191,7 +43713,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -44205,15 +43727,21 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TriangleElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -44221,7 +43749,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -44229,7 +43757,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -44517,7 +44045,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_Project__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -44531,15 +44059,21 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TriangleElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -44547,7 +44081,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -44555,7 +44089,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -44787,7 +44321,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_Project(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -44801,15 +44335,21 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TriangleElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -44817,7 +44357,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -44825,7 +44365,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -44898,24 +44438,31 @@ SWIGINTERN PyObject *ND_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"ob_type", NULL + }; mfem::ND_SegmentElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_ND_SegmentElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -44937,95 +44484,7 @@ SWIGINTERN PyObject *_wrap_new_ND_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_ND_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::ND_SegmentElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::ND_SegmentElement *)new mfem::ND_SegmentElement(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_SegmentElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_SegmentElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_SegmentElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_SegmentElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_SegmentElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_SegmentElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_SegmentElement::ND_SegmentElement(int const,int const)\n" - " mfem::ND_SegmentElement::ND_SegmentElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -45036,15 +44495,20 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -45052,7 +44516,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -45243,7 +44707,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcVShape(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -45254,15 +44718,20 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_SegmentElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -45270,7 +44739,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -45298,7 +44767,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWI } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -45309,15 +44778,20 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_SegmentElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -45325,7 +44799,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -45353,7 +44827,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -45367,15 +44841,21 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_SegmentElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -45383,7 +44863,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -45391,7 +44871,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -45679,7 +45159,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_Project__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -45693,15 +45173,21 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_SegmentElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -45709,7 +45195,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -45717,7 +45203,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -45949,7 +45435,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_Project(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -45963,15 +45449,21 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_SegmentElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -45979,7 +45471,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -45987,7 +45479,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -46094,7 +45586,7 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_Reset(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFiniteElement *arg1 = (mfem::NURBSFiniteElement *) 0 ; int *arg2 = (int *) 0 ; @@ -46102,15 +45594,19 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetIJK(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"IJK", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFiniteElement_SetIJK", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFiniteElement_SetIJK", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFiniteElement_SetIJK" "', argument " "1"" of type '" "mfem::NURBSFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBSFiniteElement_SetIJK" "', argument " "2"" of type '" "int const *""'"); } @@ -46170,25 +45666,29 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_GetPatch(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetPatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetPatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFiniteElement *arg1 = (mfem::NURBSFiniteElement *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFiniteElement_SetPatch", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFiniteElement_SetPatch", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFiniteElement_SetPatch" "', argument " "1"" of type '" "mfem::NURBSFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -46245,25 +45745,29 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_GetElement(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFiniteElement *arg1 = (mfem::NURBSFiniteElement *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"e", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFiniteElement_SetElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFiniteElement_SetElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFiniteElement_SetElement" "', argument " "1"" of type '" "mfem::NURBSFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -46430,19 +45934,21 @@ SWIGINTERN PyObject *NURBSFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(se return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_NURBS1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_NURBS1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::NURBS1DFiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_NURBS1DFiniteElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -46498,7 +46004,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_SetOrder(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -46509,15 +46015,20 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -46525,7 +46036,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -46553,7 +46064,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -46564,15 +46075,20 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -46580,7 +46096,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -46608,7 +46124,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -46619,15 +46135,20 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS1DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -46635,7 +46156,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -46869,7 +46390,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_SetOrder(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -46880,15 +46401,20 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -46896,7 +46422,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -46924,7 +46450,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -46935,15 +46461,20 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -46951,7 +46482,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -46979,7 +46510,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -46990,15 +46521,20 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -47006,7 +46542,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -47257,7 +46793,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_SetOrder(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -47268,15 +46804,20 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -47284,7 +46825,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -47312,7 +46853,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -47323,15 +46864,20 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -47339,7 +46885,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -47367,7 +46913,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -47378,15 +46924,20 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS3DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -47394,7 +46945,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -47470,13 +47021,13 @@ SWIGINTERN PyObject *NURBS3DFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "BasisType_Check", _wrap_BasisType_Check, METH_O, "BasisType_Check(int b_type) -> int"}, - { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "BasisType_CheckNodal(int b_type) -> int"}, - { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "BasisType_GetQuadrature1D(int b_type) -> int"}, - { "BasisType_GetNodalBasis", _wrap_BasisType_GetNodalBasis, METH_O, "BasisType_GetNodalBasis(int qpt_type) -> int"}, - { "BasisType_Name", _wrap_BasisType_Name, METH_O, "BasisType_Name(int b_type) -> char const *"}, - { "BasisType_GetChar", _wrap_BasisType_GetChar, METH_O, "BasisType_GetChar(int b_type) -> char"}, - { "BasisType_GetType", _wrap_BasisType_GetType, METH_O, "BasisType_GetType(char b_ident) -> int"}, + { "BasisType_Check", (PyCFunction)(void(*)(void))_wrap_BasisType_Check, METH_VARARGS|METH_KEYWORDS, "BasisType_Check(int b_type) -> int"}, + { "BasisType_CheckNodal", (PyCFunction)(void(*)(void))_wrap_BasisType_CheckNodal, METH_VARARGS|METH_KEYWORDS, "BasisType_CheckNodal(int b_type) -> int"}, + { "BasisType_GetQuadrature1D", (PyCFunction)(void(*)(void))_wrap_BasisType_GetQuadrature1D, METH_VARARGS|METH_KEYWORDS, "BasisType_GetQuadrature1D(int b_type) -> int"}, + { "BasisType_GetNodalBasis", (PyCFunction)(void(*)(void))_wrap_BasisType_GetNodalBasis, METH_VARARGS|METH_KEYWORDS, "BasisType_GetNodalBasis(int qpt_type) -> int"}, + { "BasisType_Name", (PyCFunction)(void(*)(void))_wrap_BasisType_Name, METH_VARARGS|METH_KEYWORDS, "BasisType_Name(int b_type) -> char const *"}, + { "BasisType_GetChar", (PyCFunction)(void(*)(void))_wrap_BasisType_GetChar, METH_VARARGS|METH_KEYWORDS, "BasisType_GetChar(int b_type) -> char"}, + { "BasisType_GetType", (PyCFunction)(void(*)(void))_wrap_BasisType_GetType, METH_VARARGS|METH_KEYWORDS, "BasisType_GetType(char b_ident) -> int"}, { "new_BasisType", _wrap_new_BasisType, METH_NOARGS, "new_BasisType() -> BasisType"}, { "delete_BasisType", _wrap_delete_BasisType, METH_O, "delete_BasisType(BasisType self)"}, { "BasisType_swigregister", BasisType_swigregister, METH_O, NULL}, @@ -47517,67 +47068,67 @@ static PyMethodDef SwigMethods[] = { { "FiniteElement_GetMapType", _wrap_FiniteElement_GetMapType, METH_O, "FiniteElement_GetMapType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivType", _wrap_FiniteElement_GetDerivType, METH_O, "FiniteElement_GetDerivType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivMapType", _wrap_FiniteElement_GetDerivMapType, METH_O, "FiniteElement_GetDerivMapType(FiniteElement self) -> int"}, - { "FiniteElement_CalcShape", _wrap_FiniteElement_CalcShape, METH_VARARGS, "FiniteElement_CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "FiniteElement_CalcPhysShape", _wrap_FiniteElement_CalcPhysShape, METH_VARARGS, "FiniteElement_CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, - { "FiniteElement_CalcDShape", _wrap_FiniteElement_CalcDShape, METH_VARARGS, "FiniteElement_CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "FiniteElement_CalcPhysDShape", _wrap_FiniteElement_CalcPhysDShape, METH_VARARGS, "FiniteElement_CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, + { "FiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "FiniteElement_CalcPhysShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, + { "FiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "FiniteElement_CalcPhysDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, { "FiniteElement_GetNodes", _wrap_FiniteElement_GetNodes, METH_O, "FiniteElement_GetNodes(FiniteElement self) -> IntegrationRule"}, { "FiniteElement_CalcVShape", _wrap_FiniteElement_CalcVShape, METH_VARARGS, "\n" "FiniteElement_CalcVShape(FiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "FiniteElement_CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "FiniteElement_CalcPhysVShape", _wrap_FiniteElement_CalcPhysVShape, METH_VARARGS, "FiniteElement_CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, - { "FiniteElement_CalcDivShape", _wrap_FiniteElement_CalcDivShape, METH_VARARGS, "FiniteElement_CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "FiniteElement_CalcPhysDivShape", _wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS, "FiniteElement_CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, - { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "FiniteElement_CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "FiniteElement_CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, - { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "FiniteElement_GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, - { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "FiniteElement_CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "FiniteElement_GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "FiniteElement_GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "FiniteElement_GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_ProjectMatrixCoefficient", _wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "FiniteElement_ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, - { "FiniteElement_ProjectDelta", _wrap_FiniteElement_ProjectDelta, METH_VARARGS, "FiniteElement_ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, + { "FiniteElement_CalcPhysVShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysVShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, + { "FiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "FiniteElement_CalcPhysDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, + { "FiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "FiniteElement_CalcPhysCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, + { "FiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "FiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysHessian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "FiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "FiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, { "FiniteElement_Project", _wrap_FiniteElement_Project, METH_VARARGS, "\n" "FiniteElement_Project(FiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "FiniteElement_Project(FiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "FiniteElement_Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "FiniteElement_ProjectGrad", _wrap_FiniteElement_ProjectGrad, METH_VARARGS, "FiniteElement_ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "FiniteElement_ProjectCurl", _wrap_FiniteElement_ProjectCurl, METH_VARARGS, "FiniteElement_ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, - { "FiniteElement_ProjectDiv", _wrap_FiniteElement_ProjectDiv, METH_VARARGS, "FiniteElement_ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, - { "FiniteElement_GetDofToQuad", _wrap_FiniteElement_GetDofToQuad, METH_VARARGS, "FiniteElement_GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "FiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "FiniteElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "FiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "FiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_FiniteElement", _wrap_delete_FiniteElement, METH_O, "delete_FiniteElement(FiniteElement self)"}, - { "FiniteElement_IsClosedType", _wrap_FiniteElement_IsClosedType, METH_O, "FiniteElement_IsClosedType(int b_type) -> bool"}, - { "FiniteElement_IsOpenType", _wrap_FiniteElement_IsOpenType, METH_O, "FiniteElement_IsOpenType(int b_type) -> bool"}, - { "FiniteElement_VerifyClosed", _wrap_FiniteElement_VerifyClosed, METH_O, "FiniteElement_VerifyClosed(int b_type) -> int"}, - { "FiniteElement_VerifyOpen", _wrap_FiniteElement_VerifyOpen, METH_O, "FiniteElement_VerifyOpen(int b_type) -> int"}, - { "FiniteElement_VerifyNodal", _wrap_FiniteElement_VerifyNodal, METH_O, "FiniteElement_VerifyNodal(int b_type) -> int"}, + { "FiniteElement_IsClosedType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsClosedType, METH_VARARGS|METH_KEYWORDS, "FiniteElement_IsClosedType(int b_type) -> bool"}, + { "FiniteElement_IsOpenType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsOpenType, METH_VARARGS|METH_KEYWORDS, "FiniteElement_IsOpenType(int b_type) -> bool"}, + { "FiniteElement_VerifyClosed", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyClosed, METH_VARARGS|METH_KEYWORDS, "FiniteElement_VerifyClosed(int b_type) -> int"}, + { "FiniteElement_VerifyOpen", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyOpen, METH_VARARGS|METH_KEYWORDS, "FiniteElement_VerifyOpen(int b_type) -> int"}, + { "FiniteElement_VerifyNodal", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyNodal, METH_VARARGS|METH_KEYWORDS, "FiniteElement_VerifyNodal(int b_type) -> int"}, { "FiniteElement_swigregister", FiniteElement_swigregister, METH_O, NULL}, - { "ScalarFiniteElement_SetMapType", _wrap_ScalarFiniteElement_SetMapType, METH_VARARGS, "ScalarFiniteElement_SetMapType(ScalarFiniteElement self, int M)"}, - { "ScalarFiniteElement_NodalLocalInterpolation", _wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS, "ScalarFiniteElement_NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_ScalarLocalInterpolation", _wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS, "ScalarFiniteElement_ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_GetDofToQuad", _wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS, "ScalarFiniteElement_GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "ScalarFiniteElement_SetMapType", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_SetMapType, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_SetMapType(ScalarFiniteElement self, int M)"}, + { "ScalarFiniteElement_NodalLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_ScalarLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_ScalarFiniteElement", _wrap_delete_ScalarFiniteElement, METH_O, "delete_ScalarFiniteElement(ScalarFiniteElement self)"}, { "ScalarFiniteElement_swigregister", ScalarFiniteElement_swigregister, METH_O, NULL}, - { "NodalFiniteElement_GetLocalInterpolation", _wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS, "NodalFiniteElement_GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_GetLocalRestriction", _wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS, "NodalFiniteElement_GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "NodalFiniteElement_GetTransferMatrix", _wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS, "NodalFiniteElement_GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_ProjectMatrixCoefficient", _wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "NodalFiniteElement_ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "NodalFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "NodalFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "NodalFiniteElement_Project", _wrap_NodalFiniteElement_Project, METH_VARARGS, "\n" "NodalFiniteElement_Project(NodalFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "NodalFiniteElement_Project(NodalFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "NodalFiniteElement_Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "NodalFiniteElement_ProjectGrad", _wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS, "NodalFiniteElement_ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "NodalFiniteElement_ProjectDiv", _wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS, "NodalFiniteElement_ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "NodalFiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "NodalFiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, { "delete_NodalFiniteElement", _wrap_delete_NodalFiniteElement, METH_O, "delete_NodalFiniteElement(NodalFiniteElement self)"}, { "NodalFiniteElement_swigregister", NodalFiniteElement_swigregister, METH_O, NULL}, - { "PositiveFiniteElement_GetLocalInterpolation", _wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS, "PositiveFiniteElement_GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "PositiveFiniteElement_GetTransferMatrix", _wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS, "PositiveFiniteElement_GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "PositiveFiniteElement_GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "PositiveFiniteElement_GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "PositiveFiniteElement_Project", _wrap_PositiveFiniteElement_Project, METH_VARARGS, "\n" "PositiveFiniteElement_Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "PositiveFiniteElement_Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47588,95 +47139,95 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_PositiveFiniteElement", _wrap_delete_PositiveFiniteElement, METH_O, "delete_PositiveFiniteElement(PositiveFiniteElement self)"}, { "PositiveFiniteElement_swigregister", PositiveFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorFiniteElement", _wrap_new_VectorFiniteElement, METH_VARARGS, "VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk)"}, + { "new_VectorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk) -> VectorFiniteElement"}, { "delete_VectorFiniteElement", _wrap_delete_VectorFiniteElement, METH_O, "delete_VectorFiniteElement(VectorFiniteElement self)"}, { "VectorFiniteElement_swigregister", VectorFiniteElement_swigregister, METH_O, NULL}, { "VectorFiniteElement_swiginit", VectorFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_PointFiniteElement", _wrap_new_PointFiniteElement, METH_NOARGS, "new_PointFiniteElement() -> PointFiniteElement"}, - { "PointFiniteElement_CalcShape", _wrap_PointFiniteElement_CalcShape, METH_VARARGS, "PointFiniteElement_CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "PointFiniteElement_CalcDShape", _wrap_PointFiniteElement_CalcDShape, METH_VARARGS, "PointFiniteElement_CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "PointFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "PointFiniteElement_CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "PointFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "PointFiniteElement_CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_PointFiniteElement", _wrap_delete_PointFiniteElement, METH_O, "delete_PointFiniteElement(PointFiniteElement self)"}, { "PointFiniteElement_swigregister", PointFiniteElement_swigregister, METH_O, NULL}, { "PointFiniteElement_swiginit", PointFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear1DFiniteElement", _wrap_new_Linear1DFiniteElement, METH_NOARGS, "new_Linear1DFiniteElement() -> Linear1DFiniteElement"}, - { "Linear1DFiniteElement_CalcShape", _wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS, "Linear1DFiniteElement_CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear1DFiniteElement_CalcDShape", _wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS, "Linear1DFiniteElement_CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Linear1DFiniteElement_CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Linear1DFiniteElement_CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Linear1DFiniteElement", _wrap_delete_Linear1DFiniteElement, METH_O, "delete_Linear1DFiniteElement(Linear1DFiniteElement self)"}, { "Linear1DFiniteElement_swigregister", Linear1DFiniteElement_swigregister, METH_O, NULL}, { "Linear1DFiniteElement_swiginit", Linear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear2DFiniteElement", _wrap_new_Linear2DFiniteElement, METH_NOARGS, "new_Linear2DFiniteElement() -> Linear2DFiniteElement"}, - { "Linear2DFiniteElement_CalcShape", _wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS, "Linear2DFiniteElement_CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear2DFiniteElement_CalcDShape", _wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS, "Linear2DFiniteElement_CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear2DFiniteElement_ProjectDelta", _wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS, "Linear2DFiniteElement_ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Linear2DFiniteElement_CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Linear2DFiniteElement_CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "Linear2DFiniteElement_ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Linear2DFiniteElement", _wrap_delete_Linear2DFiniteElement, METH_O, "delete_Linear2DFiniteElement(Linear2DFiniteElement self)"}, { "Linear2DFiniteElement_swigregister", Linear2DFiniteElement_swigregister, METH_O, NULL}, { "Linear2DFiniteElement_swiginit", Linear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiLinear2DFiniteElement", _wrap_new_BiLinear2DFiniteElement, METH_NOARGS, "new_BiLinear2DFiniteElement() -> BiLinear2DFiniteElement"}, - { "BiLinear2DFiniteElement_CalcShape", _wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS, "BiLinear2DFiniteElement_CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiLinear2DFiniteElement_CalcDShape", _wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "BiLinear2DFiniteElement_CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiLinear2DFiniteElement_CalcHessian", _wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS, "BiLinear2DFiniteElement_CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "BiLinear2DFiniteElement_ProjectDelta", _wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "BiLinear2DFiniteElement_ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiLinear2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiLinear2DFiniteElement", _wrap_delete_BiLinear2DFiniteElement, METH_O, "delete_BiLinear2DFiniteElement(BiLinear2DFiniteElement self)"}, { "BiLinear2DFiniteElement_swigregister", BiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "BiLinear2DFiniteElement_swiginit", BiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussLinear2DFiniteElement", _wrap_new_GaussLinear2DFiniteElement, METH_NOARGS, "new_GaussLinear2DFiniteElement() -> GaussLinear2DFiniteElement"}, - { "GaussLinear2DFiniteElement_CalcShape", _wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS, "GaussLinear2DFiniteElement_CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussLinear2DFiniteElement_CalcDShape", _wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS, "GaussLinear2DFiniteElement_CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussLinear2DFiniteElement_ProjectDelta", _wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "GaussLinear2DFiniteElement_ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussLinear2DFiniteElement_CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussLinear2DFiniteElement_CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "GaussLinear2DFiniteElement_ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussLinear2DFiniteElement", _wrap_delete_GaussLinear2DFiniteElement, METH_O, "delete_GaussLinear2DFiniteElement(GaussLinear2DFiniteElement self)"}, { "GaussLinear2DFiniteElement_swigregister", GaussLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussLinear2DFiniteElement_swiginit", GaussLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiLinear2DFiniteElement", _wrap_new_GaussBiLinear2DFiniteElement, METH_NOARGS, "new_GaussBiLinear2DFiniteElement() -> GaussBiLinear2DFiniteElement"}, - { "GaussBiLinear2DFiniteElement_CalcShape", _wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "GaussBiLinear2DFiniteElement_CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiLinear2DFiniteElement_CalcDShape", _wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "GaussBiLinear2DFiniteElement_CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussBiLinear2DFiniteElement_ProjectDelta", _wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "GaussBiLinear2DFiniteElement_ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussBiLinear2DFiniteElement_CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussBiLinear2DFiniteElement_CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "GaussBiLinear2DFiniteElement_ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussBiLinear2DFiniteElement", _wrap_delete_GaussBiLinear2DFiniteElement, METH_O, "delete_GaussBiLinear2DFiniteElement(GaussBiLinear2DFiniteElement self)"}, { "GaussBiLinear2DFiniteElement_swigregister", GaussBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiLinear2DFiniteElement_swiginit", GaussBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFiniteElement", _wrap_new_P1OnQuadFiniteElement, METH_NOARGS, "new_P1OnQuadFiniteElement() -> P1OnQuadFiniteElement"}, - { "P1OnQuadFiniteElement_CalcShape", _wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS, "P1OnQuadFiniteElement_CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1OnQuadFiniteElement_CalcDShape", _wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS, "P1OnQuadFiniteElement_CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P1OnQuadFiniteElement_ProjectDelta", _wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS, "P1OnQuadFiniteElement_ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, + { "P1OnQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFiniteElement_CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1OnQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFiniteElement_CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1OnQuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFiniteElement_ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P1OnQuadFiniteElement", _wrap_delete_P1OnQuadFiniteElement, METH_O, "delete_P1OnQuadFiniteElement(P1OnQuadFiniteElement self)"}, { "P1OnQuadFiniteElement_swigregister", P1OnQuadFiniteElement_swigregister, METH_O, NULL}, { "P1OnQuadFiniteElement_swiginit", P1OnQuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad1DFiniteElement", _wrap_new_Quad1DFiniteElement, METH_NOARGS, "new_Quad1DFiniteElement() -> Quad1DFiniteElement"}, - { "Quad1DFiniteElement_CalcShape", _wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS, "Quad1DFiniteElement_CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad1DFiniteElement_CalcDShape", _wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS, "Quad1DFiniteElement_CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Quad1DFiniteElement_CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Quad1DFiniteElement_CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quad1DFiniteElement", _wrap_delete_Quad1DFiniteElement, METH_O, "delete_Quad1DFiniteElement(Quad1DFiniteElement self)"}, { "Quad1DFiniteElement_swigregister", Quad1DFiniteElement_swigregister, METH_O, NULL}, { "Quad1DFiniteElement_swiginit", Quad1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_QuadPos1DFiniteElement", _wrap_new_QuadPos1DFiniteElement, METH_NOARGS, "new_QuadPos1DFiniteElement() -> QuadPos1DFiniteElement"}, - { "QuadPos1DFiniteElement_CalcShape", _wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS, "QuadPos1DFiniteElement_CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "QuadPos1DFiniteElement_CalcDShape", _wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS, "QuadPos1DFiniteElement_CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "QuadPos1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "QuadPos1DFiniteElement_CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "QuadPos1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "QuadPos1DFiniteElement_CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_QuadPos1DFiniteElement", _wrap_delete_QuadPos1DFiniteElement, METH_O, "delete_QuadPos1DFiniteElement(QuadPos1DFiniteElement self)"}, { "QuadPos1DFiniteElement_swigregister", QuadPos1DFiniteElement_swigregister, METH_O, NULL}, { "QuadPos1DFiniteElement_swiginit", QuadPos1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad2DFiniteElement", _wrap_new_Quad2DFiniteElement, METH_NOARGS, "new_Quad2DFiniteElement() -> Quad2DFiniteElement"}, - { "Quad2DFiniteElement_CalcShape", _wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS, "Quad2DFiniteElement_CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad2DFiniteElement_CalcDShape", _wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS, "Quad2DFiniteElement_CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Quad2DFiniteElement_CalcHessian", _wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS, "Quad2DFiniteElement_CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "Quad2DFiniteElement_ProjectDelta", _wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS, "Quad2DFiniteElement_ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, + { "Quad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Quad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Quad2DFiniteElement", _wrap_delete_Quad2DFiniteElement, METH_O, "delete_Quad2DFiniteElement(Quad2DFiniteElement self)"}, { "Quad2DFiniteElement_swigregister", Quad2DFiniteElement_swigregister, METH_O, NULL}, { "Quad2DFiniteElement_swiginit", Quad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussQuad2DFiniteElement", _wrap_new_GaussQuad2DFiniteElement, METH_NOARGS, "new_GaussQuad2DFiniteElement() -> GaussQuad2DFiniteElement"}, - { "GaussQuad2DFiniteElement_CalcShape", _wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS, "GaussQuad2DFiniteElement_CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussQuad2DFiniteElement_CalcDShape", _wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS, "GaussQuad2DFiniteElement_CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussQuad2DFiniteElement_CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussQuad2DFiniteElement_CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussQuad2DFiniteElement", _wrap_delete_GaussQuad2DFiniteElement, METH_O, "delete_GaussQuad2DFiniteElement(GaussQuad2DFiniteElement self)"}, { "GaussQuad2DFiniteElement_swigregister", GaussQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussQuad2DFiniteElement_swiginit", GaussQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuad2DFiniteElement", _wrap_new_BiQuad2DFiniteElement, METH_NOARGS, "new_BiQuad2DFiniteElement() -> BiQuad2DFiniteElement"}, - { "BiQuad2DFiniteElement_CalcShape", _wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS, "BiQuad2DFiniteElement_CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuad2DFiniteElement_CalcDShape", _wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "BiQuad2DFiniteElement_CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuad2DFiniteElement_ProjectDelta", _wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS, "BiQuad2DFiniteElement_ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiQuad2DFiniteElement_CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiQuad2DFiniteElement_CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "BiQuad2DFiniteElement_ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuad2DFiniteElement", _wrap_delete_BiQuad2DFiniteElement, METH_O, "delete_BiQuad2DFiniteElement(BiQuad2DFiniteElement self)"}, { "BiQuad2DFiniteElement_swigregister", BiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuad2DFiniteElement_swiginit", BiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuadPos2DFiniteElement", _wrap_new_BiQuadPos2DFiniteElement, METH_NOARGS, "new_BiQuadPos2DFiniteElement() -> BiQuadPos2DFiniteElement"}, - { "BiQuadPos2DFiniteElement_CalcShape", _wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS, "BiQuadPos2DFiniteElement_CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuadPos2DFiniteElement_CalcDShape", _wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS, "BiQuadPos2DFiniteElement_CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuadPos2DFiniteElement_GetLocalInterpolation", _wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS, "BiQuadPos2DFiniteElement_GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "BiQuadPos2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuadPos2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuadPos2DFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "BiQuadPos2DFiniteElement_Project", _wrap_BiQuadPos2DFiniteElement_Project, METH_VARARGS, "\n" "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47684,93 +47235,93 @@ static PyMethodDef SwigMethods[] = { "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" ""}, - { "BiQuadPos2DFiniteElement_ProjectDelta", _wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS, "BiQuadPos2DFiniteElement_ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuadPos2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuadPos2DFiniteElement", _wrap_delete_BiQuadPos2DFiniteElement, METH_O, "delete_BiQuadPos2DFiniteElement(BiQuadPos2DFiniteElement self)"}, { "BiQuadPos2DFiniteElement_swigregister", BiQuadPos2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuadPos2DFiniteElement_swiginit", BiQuadPos2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiQuad2DFiniteElement", _wrap_new_GaussBiQuad2DFiniteElement, METH_NOARGS, "new_GaussBiQuad2DFiniteElement() -> GaussBiQuad2DFiniteElement"}, - { "GaussBiQuad2DFiniteElement_CalcShape", _wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS, "GaussBiQuad2DFiniteElement_CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiQuad2DFiniteElement_CalcDShape", _wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "GaussBiQuad2DFiniteElement_CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussBiQuad2DFiniteElement_CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussBiQuad2DFiniteElement_CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussBiQuad2DFiniteElement", _wrap_delete_GaussBiQuad2DFiniteElement, METH_O, "delete_GaussBiQuad2DFiniteElement(GaussBiQuad2DFiniteElement self)"}, { "GaussBiQuad2DFiniteElement_swigregister", GaussBiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiQuad2DFiniteElement_swiginit", GaussBiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiCubic2DFiniteElement", _wrap_new_BiCubic2DFiniteElement, METH_NOARGS, "new_BiCubic2DFiniteElement() -> BiCubic2DFiniteElement"}, - { "BiCubic2DFiniteElement_CalcShape", _wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS, "BiCubic2DFiniteElement_CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiCubic2DFiniteElement_CalcDShape", _wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS, "BiCubic2DFiniteElement_CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiCubic2DFiniteElement_CalcHessian", _wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS, "BiCubic2DFiniteElement_CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiCubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiCubic2DFiniteElement_CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiCubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiCubic2DFiniteElement_CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiCubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "BiCubic2DFiniteElement_CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_BiCubic2DFiniteElement", _wrap_delete_BiCubic2DFiniteElement, METH_O, "delete_BiCubic2DFiniteElement(BiCubic2DFiniteElement self)"}, { "BiCubic2DFiniteElement_swigregister", BiCubic2DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic2DFiniteElement_swiginit", BiCubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic1DFiniteElement", _wrap_new_Cubic1DFiniteElement, METH_NOARGS, "new_Cubic1DFiniteElement() -> Cubic1DFiniteElement"}, - { "Cubic1DFiniteElement_CalcShape", _wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS, "Cubic1DFiniteElement_CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic1DFiniteElement_CalcDShape", _wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS, "Cubic1DFiniteElement_CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Cubic1DFiniteElement_CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Cubic1DFiniteElement_CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic1DFiniteElement", _wrap_delete_Cubic1DFiniteElement, METH_O, "delete_Cubic1DFiniteElement(Cubic1DFiniteElement self)"}, { "Cubic1DFiniteElement_swigregister", Cubic1DFiniteElement_swigregister, METH_O, NULL}, { "Cubic1DFiniteElement_swiginit", Cubic1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic2DFiniteElement", _wrap_new_Cubic2DFiniteElement, METH_NOARGS, "new_Cubic2DFiniteElement() -> Cubic2DFiniteElement"}, - { "Cubic2DFiniteElement_CalcShape", _wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS, "Cubic2DFiniteElement_CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic2DFiniteElement_CalcDShape", _wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS, "Cubic2DFiniteElement_CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Cubic2DFiniteElement_CalcHessian", _wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS, "Cubic2DFiniteElement_CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Cubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Cubic2DFiniteElement_CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Cubic2DFiniteElement_CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "Cubic2DFiniteElement_CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_Cubic2DFiniteElement", _wrap_delete_Cubic2DFiniteElement, METH_O, "delete_Cubic2DFiniteElement(Cubic2DFiniteElement self)"}, { "Cubic2DFiniteElement_swigregister", Cubic2DFiniteElement_swigregister, METH_O, NULL}, { "Cubic2DFiniteElement_swiginit", Cubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic3DFiniteElement", _wrap_new_Cubic3DFiniteElement, METH_NOARGS, "new_Cubic3DFiniteElement() -> Cubic3DFiniteElement"}, - { "Cubic3DFiniteElement_CalcShape", _wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS, "Cubic3DFiniteElement_CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic3DFiniteElement_CalcDShape", _wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS, "Cubic3DFiniteElement_CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Cubic3DFiniteElement_CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Cubic3DFiniteElement_CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic3DFiniteElement", _wrap_delete_Cubic3DFiniteElement, METH_O, "delete_Cubic3DFiniteElement(Cubic3DFiniteElement self)"}, { "Cubic3DFiniteElement_swigregister", Cubic3DFiniteElement_swigregister, METH_O, NULL}, { "Cubic3DFiniteElement_swiginit", Cubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TriangleFiniteElement", _wrap_new_P0TriangleFiniteElement, METH_NOARGS, "new_P0TriangleFiniteElement() -> P0TriangleFiniteElement"}, - { "P0TriangleFiniteElement_CalcShape", _wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS, "P0TriangleFiniteElement_CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TriangleFiniteElement_CalcDShape", _wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS, "P0TriangleFiniteElement_CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TriangleFiniteElement_ProjectDelta", _wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS, "P0TriangleFiniteElement_ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, + { "P0TriangleFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0TriangleFiniteElement_CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TriangleFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0TriangleFiniteElement_CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TriangleFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0TriangleFiniteElement_ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TriangleFiniteElement", _wrap_delete_P0TriangleFiniteElement, METH_O, "delete_P0TriangleFiniteElement(P0TriangleFiniteElement self)"}, { "P0TriangleFiniteElement_swigregister", P0TriangleFiniteElement_swigregister, METH_O, NULL}, { "P0TriangleFiniteElement_swiginit", P0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0QuadFiniteElement", _wrap_new_P0QuadFiniteElement, METH_NOARGS, "new_P0QuadFiniteElement() -> P0QuadFiniteElement"}, - { "P0QuadFiniteElement_CalcShape", _wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS, "P0QuadFiniteElement_CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0QuadFiniteElement_CalcDShape", _wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS, "P0QuadFiniteElement_CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0QuadFiniteElement_ProjectDelta", _wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS, "P0QuadFiniteElement_ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, + { "P0QuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0QuadFiniteElement_CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0QuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0QuadFiniteElement_CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0QuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0QuadFiniteElement_ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0QuadFiniteElement", _wrap_delete_P0QuadFiniteElement, METH_O, "delete_P0QuadFiniteElement(P0QuadFiniteElement self)"}, { "P0QuadFiniteElement_swigregister", P0QuadFiniteElement_swigregister, METH_O, NULL}, { "P0QuadFiniteElement_swiginit", P0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear3DFiniteElement", _wrap_new_Linear3DFiniteElement, METH_NOARGS, "new_Linear3DFiniteElement() -> Linear3DFiniteElement"}, - { "Linear3DFiniteElement_CalcShape", _wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS, "Linear3DFiniteElement_CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear3DFiniteElement_CalcDShape", _wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS, "Linear3DFiniteElement_CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear3DFiniteElement_ProjectDelta", _wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS, "Linear3DFiniteElement_ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, - { "Linear3DFiniteElement_GetFaceDofs", _wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS, "Linear3DFiniteElement_GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "Linear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear3DFiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, { "delete_Linear3DFiniteElement", _wrap_delete_Linear3DFiniteElement, METH_O, "delete_Linear3DFiniteElement(Linear3DFiniteElement self)"}, { "Linear3DFiniteElement_swigregister", Linear3DFiniteElement_swigregister, METH_O, NULL}, { "Linear3DFiniteElement_swiginit", Linear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quadratic3DFiniteElement", _wrap_new_Quadratic3DFiniteElement, METH_NOARGS, "new_Quadratic3DFiniteElement() -> Quadratic3DFiniteElement"}, - { "Quadratic3DFiniteElement_CalcShape", _wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS, "Quadratic3DFiniteElement_CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quadratic3DFiniteElement_CalcDShape", _wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS, "Quadratic3DFiniteElement_CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quadratic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Quadratic3DFiniteElement_CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quadratic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Quadratic3DFiniteElement_CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quadratic3DFiniteElement", _wrap_delete_Quadratic3DFiniteElement, METH_O, "delete_Quadratic3DFiniteElement(Quadratic3DFiniteElement self)"}, { "Quadratic3DFiniteElement_swigregister", Quadratic3DFiniteElement_swigregister, METH_O, NULL}, { "Quadratic3DFiniteElement_swiginit", Quadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_TriLinear3DFiniteElement", _wrap_new_TriLinear3DFiniteElement, METH_NOARGS, "new_TriLinear3DFiniteElement() -> TriLinear3DFiniteElement"}, - { "TriLinear3DFiniteElement_CalcShape", _wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS, "TriLinear3DFiniteElement_CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "TriLinear3DFiniteElement_CalcDShape", _wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "TriLinear3DFiniteElement_CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "TriLinear3DFiniteElement_ProjectDelta", _wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS, "TriLinear3DFiniteElement_ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, + { "TriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "TriLinear3DFiniteElement_CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "TriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "TriLinear3DFiniteElement_CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "TriLinear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "TriLinear3DFiniteElement_ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, { "delete_TriLinear3DFiniteElement", _wrap_delete_TriLinear3DFiniteElement, METH_O, "delete_TriLinear3DFiniteElement(TriLinear3DFiniteElement self)"}, { "TriLinear3DFiniteElement_swigregister", TriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "TriLinear3DFiniteElement_swiginit", TriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFiniteElement", _wrap_new_CrouzeixRaviartFiniteElement, METH_NOARGS, "new_CrouzeixRaviartFiniteElement() -> CrouzeixRaviartFiniteElement"}, - { "CrouzeixRaviartFiniteElement_CalcShape", _wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS, "CrouzeixRaviartFiniteElement_CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartFiniteElement_CalcDShape", _wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS, "CrouzeixRaviartFiniteElement_CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "CrouzeixRaviartFiniteElement_ProjectDelta", _wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS, "CrouzeixRaviartFiniteElement_ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, + { "CrouzeixRaviartFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFiniteElement_CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFiniteElement_CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFiniteElement_ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, { "delete_CrouzeixRaviartFiniteElement", _wrap_delete_CrouzeixRaviartFiniteElement, METH_O, "delete_CrouzeixRaviartFiniteElement(CrouzeixRaviartFiniteElement self)"}, { "CrouzeixRaviartFiniteElement_swigregister", CrouzeixRaviartFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartFiniteElement_swiginit", CrouzeixRaviartFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartQuadFiniteElement", _wrap_new_CrouzeixRaviartQuadFiniteElement, METH_NOARGS, "new_CrouzeixRaviartQuadFiniteElement() -> CrouzeixRaviartQuadFiniteElement"}, - { "CrouzeixRaviartQuadFiniteElement_CalcShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS, "CrouzeixRaviartQuadFiniteElement_CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartQuadFiniteElement_CalcDShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS, "CrouzeixRaviartQuadFiniteElement_CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartQuadFiniteElement_CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartQuadFiniteElement_CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_CrouzeixRaviartQuadFiniteElement", _wrap_delete_CrouzeixRaviartQuadFiniteElement, METH_O, "delete_CrouzeixRaviartQuadFiniteElement(CrouzeixRaviartQuadFiniteElement self)"}, { "CrouzeixRaviartQuadFiniteElement_swigregister", CrouzeixRaviartQuadFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartQuadFiniteElement_swiginit", CrouzeixRaviartQuadFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_P0SegmentFiniteElement", _wrap_new_P0SegmentFiniteElement, METH_VARARGS, "P0SegmentFiniteElement(int Ord=0)"}, - { "P0SegmentFiniteElement_CalcShape", _wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS, "P0SegmentFiniteElement_CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0SegmentFiniteElement_CalcDShape", _wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS, "P0SegmentFiniteElement_CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_P0SegmentFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_P0SegmentFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_P0SegmentFiniteElement(int Ord=0) -> P0SegmentFiniteElement"}, + { "P0SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0SegmentFiniteElement_CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0SegmentFiniteElement_CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P0SegmentFiniteElement", _wrap_delete_P0SegmentFiniteElement, METH_O, "delete_P0SegmentFiniteElement(P0SegmentFiniteElement self)"}, { "P0SegmentFiniteElement_swigregister", P0SegmentFiniteElement_swigregister, METH_O, NULL}, { "P0SegmentFiniteElement_swiginit", P0SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -47779,8 +47330,8 @@ static PyMethodDef SwigMethods[] = { "RT0TriangleFiniteElement_CalcVShape(RT0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0TriangleFiniteElement_CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TriangleFiniteElement_CalcDivShape", _wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS, "RT0TriangleFiniteElement_CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TriangleFiniteElement_GetLocalInterpolation", _wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0TriangleFiniteElement_GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0TriangleFiniteElement_CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0TriangleFiniteElement_GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TriangleFiniteElement_Project", _wrap_RT0TriangleFiniteElement_Project, METH_VARARGS, "\n" "RT0TriangleFiniteElement_Project(RT0TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0TriangleFiniteElement_Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47795,8 +47346,8 @@ static PyMethodDef SwigMethods[] = { "RT0QuadFiniteElement_CalcVShape(RT0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0QuadFiniteElement_CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0QuadFiniteElement_CalcDivShape", _wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS, "RT0QuadFiniteElement_CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0QuadFiniteElement_GetLocalInterpolation", _wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0QuadFiniteElement_GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0QuadFiniteElement_CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0QuadFiniteElement_GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0QuadFiniteElement_Project", _wrap_RT0QuadFiniteElement_Project, METH_VARARGS, "\n" "RT0QuadFiniteElement_Project(RT0QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0QuadFiniteElement_Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47811,8 +47362,8 @@ static PyMethodDef SwigMethods[] = { "RT1TriangleFiniteElement_CalcVShape(RT1TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT1TriangleFiniteElement_CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1TriangleFiniteElement_CalcDivShape", _wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS, "RT1TriangleFiniteElement_CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1TriangleFiniteElement_GetLocalInterpolation", _wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT1TriangleFiniteElement_GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT1TriangleFiniteElement_CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT1TriangleFiniteElement_GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1TriangleFiniteElement_Project", _wrap_RT1TriangleFiniteElement_Project, METH_VARARGS, "\n" "RT1TriangleFiniteElement_Project(RT1TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT1TriangleFiniteElement_Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47827,8 +47378,8 @@ static PyMethodDef SwigMethods[] = { "RT1QuadFiniteElement_CalcVShape(RT1QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT1QuadFiniteElement_CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1QuadFiniteElement_CalcDivShape", _wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS, "RT1QuadFiniteElement_CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1QuadFiniteElement_GetLocalInterpolation", _wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT1QuadFiniteElement_GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT1QuadFiniteElement_CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT1QuadFiniteElement_GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1QuadFiniteElement_Project", _wrap_RT1QuadFiniteElement_Project, METH_VARARGS, "\n" "RT1QuadFiniteElement_Project(RT1QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT1QuadFiniteElement_Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47843,7 +47394,7 @@ static PyMethodDef SwigMethods[] = { "RT2TriangleFiniteElement_CalcVShape(RT2TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT2TriangleFiniteElement_CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2TriangleFiniteElement_CalcDivShape", _wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS, "RT2TriangleFiniteElement_CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT2TriangleFiniteElement_CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, { "delete_RT2TriangleFiniteElement", _wrap_delete_RT2TriangleFiniteElement, METH_O, "delete_RT2TriangleFiniteElement(RT2TriangleFiniteElement self)"}, { "RT2TriangleFiniteElement_swigregister", RT2TriangleFiniteElement_swigregister, METH_O, NULL}, { "RT2TriangleFiniteElement_swiginit", RT2TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -47852,8 +47403,8 @@ static PyMethodDef SwigMethods[] = { "RT2QuadFiniteElement_CalcVShape(RT2QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT2QuadFiniteElement_CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2QuadFiniteElement_CalcDivShape", _wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS, "RT2QuadFiniteElement_CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT2QuadFiniteElement_GetLocalInterpolation", _wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT2QuadFiniteElement_GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT2QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT2QuadFiniteElement_CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT2QuadFiniteElement_GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT2QuadFiniteElement_Project", _wrap_RT2QuadFiniteElement_Project, METH_VARARGS, "\n" "RT2QuadFiniteElement_Project(RT2QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT2QuadFiniteElement_Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47864,76 +47415,76 @@ static PyMethodDef SwigMethods[] = { { "RT2QuadFiniteElement_swigregister", RT2QuadFiniteElement_swigregister, METH_O, NULL}, { "RT2QuadFiniteElement_swiginit", RT2QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1SegmentFiniteElement", _wrap_new_P1SegmentFiniteElement, METH_NOARGS, "new_P1SegmentFiniteElement() -> P1SegmentFiniteElement"}, - { "P1SegmentFiniteElement_CalcShape", _wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS, "P1SegmentFiniteElement_CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1SegmentFiniteElement_CalcDShape", _wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS, "P1SegmentFiniteElement_CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P1SegmentFiniteElement_CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P1SegmentFiniteElement_CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1SegmentFiniteElement", _wrap_delete_P1SegmentFiniteElement, METH_O, "delete_P1SegmentFiniteElement(P1SegmentFiniteElement self)"}, { "P1SegmentFiniteElement_swigregister", P1SegmentFiniteElement_swigregister, METH_O, NULL}, { "P1SegmentFiniteElement_swiginit", P1SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P2SegmentFiniteElement", _wrap_new_P2SegmentFiniteElement, METH_NOARGS, "new_P2SegmentFiniteElement() -> P2SegmentFiniteElement"}, - { "P2SegmentFiniteElement_CalcShape", _wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS, "P2SegmentFiniteElement_CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P2SegmentFiniteElement_CalcDShape", _wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS, "P2SegmentFiniteElement_CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P2SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P2SegmentFiniteElement_CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P2SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P2SegmentFiniteElement_CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P2SegmentFiniteElement", _wrap_delete_P2SegmentFiniteElement, METH_O, "delete_P2SegmentFiniteElement(P2SegmentFiniteElement self)"}, { "P2SegmentFiniteElement_swigregister", P2SegmentFiniteElement_swigregister, METH_O, NULL}, { "P2SegmentFiniteElement_swiginit", P2SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_Lagrange1DFiniteElement", _wrap_new_Lagrange1DFiniteElement, METH_O, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, - { "Lagrange1DFiniteElement_CalcShape", _wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS, "Lagrange1DFiniteElement_CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Lagrange1DFiniteElement_CalcDShape", _wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS, "Lagrange1DFiniteElement_CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_Lagrange1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_Lagrange1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, + { "Lagrange1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Lagrange1DFiniteElement_CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Lagrange1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Lagrange1DFiniteElement_CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Lagrange1DFiniteElement", _wrap_delete_Lagrange1DFiniteElement, METH_O, "delete_Lagrange1DFiniteElement(Lagrange1DFiniteElement self)"}, { "Lagrange1DFiniteElement_swigregister", Lagrange1DFiniteElement_swigregister, METH_O, NULL}, { "Lagrange1DFiniteElement_swiginit", Lagrange1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1TetNonConfFiniteElement", _wrap_new_P1TetNonConfFiniteElement, METH_NOARGS, "new_P1TetNonConfFiniteElement() -> P1TetNonConfFiniteElement"}, - { "P1TetNonConfFiniteElement_CalcShape", _wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS, "P1TetNonConfFiniteElement_CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1TetNonConfFiniteElement_CalcDShape", _wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS, "P1TetNonConfFiniteElement_CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1TetNonConfFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P1TetNonConfFiniteElement_CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1TetNonConfFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P1TetNonConfFiniteElement_CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1TetNonConfFiniteElement", _wrap_delete_P1TetNonConfFiniteElement, METH_O, "delete_P1TetNonConfFiniteElement(P1TetNonConfFiniteElement self)"}, { "P1TetNonConfFiniteElement_swigregister", P1TetNonConfFiniteElement_swigregister, METH_O, NULL}, { "P1TetNonConfFiniteElement_swiginit", P1TetNonConfFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TetFiniteElement", _wrap_new_P0TetFiniteElement, METH_NOARGS, "new_P0TetFiniteElement() -> P0TetFiniteElement"}, - { "P0TetFiniteElement_CalcShape", _wrap_P0TetFiniteElement_CalcShape, METH_VARARGS, "P0TetFiniteElement_CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TetFiniteElement_CalcDShape", _wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS, "P0TetFiniteElement_CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TetFiniteElement_ProjectDelta", _wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS, "P0TetFiniteElement_ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, + { "P0TetFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0TetFiniteElement_CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TetFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0TetFiniteElement_CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TetFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0TetFiniteElement_ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TetFiniteElement", _wrap_delete_P0TetFiniteElement, METH_O, "delete_P0TetFiniteElement(P0TetFiniteElement self)"}, { "P0TetFiniteElement_swigregister", P0TetFiniteElement_swigregister, METH_O, NULL}, { "P0TetFiniteElement_swiginit", P0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0HexFiniteElement", _wrap_new_P0HexFiniteElement, METH_NOARGS, "new_P0HexFiniteElement() -> P0HexFiniteElement"}, - { "P0HexFiniteElement_CalcShape", _wrap_P0HexFiniteElement_CalcShape, METH_VARARGS, "P0HexFiniteElement_CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0HexFiniteElement_CalcDShape", _wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS, "P0HexFiniteElement_CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0HexFiniteElement_ProjectDelta", _wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS, "P0HexFiniteElement_ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, + { "P0HexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0HexFiniteElement_CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0HexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0HexFiniteElement_CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0HexFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0HexFiniteElement_ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0HexFiniteElement", _wrap_delete_P0HexFiniteElement, METH_O, "delete_P0HexFiniteElement(P0HexFiniteElement self)"}, { "P0HexFiniteElement_swigregister", P0HexFiniteElement_swigregister, METH_O, NULL}, { "P0HexFiniteElement_swiginit", P0HexFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_LagrangeHexFiniteElement", _wrap_new_LagrangeHexFiniteElement, METH_O, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, - { "LagrangeHexFiniteElement_CalcShape", _wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS, "LagrangeHexFiniteElement_CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "LagrangeHexFiniteElement_CalcDShape", _wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS, "LagrangeHexFiniteElement_CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_LagrangeHexFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_LagrangeHexFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, + { "LagrangeHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "LagrangeHexFiniteElement_CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "LagrangeHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "LagrangeHexFiniteElement_CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_LagrangeHexFiniteElement", _wrap_delete_LagrangeHexFiniteElement, METH_O, "delete_LagrangeHexFiniteElement(LagrangeHexFiniteElement self)"}, { "LagrangeHexFiniteElement_swigregister", LagrangeHexFiniteElement_swigregister, METH_O, NULL}, { "LagrangeHexFiniteElement_swiginit", LagrangeHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear1DFiniteElement", _wrap_new_RefinedLinear1DFiniteElement, METH_NOARGS, "new_RefinedLinear1DFiniteElement() -> RefinedLinear1DFiniteElement"}, - { "RefinedLinear1DFiniteElement_CalcShape", _wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS, "RefinedLinear1DFiniteElement_CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear1DFiniteElement_CalcDShape", _wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS, "RefinedLinear1DFiniteElement_CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear1DFiniteElement_CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear1DFiniteElement_CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear1DFiniteElement", _wrap_delete_RefinedLinear1DFiniteElement, METH_O, "delete_RefinedLinear1DFiniteElement(RefinedLinear1DFiniteElement self)"}, { "RefinedLinear1DFiniteElement_swigregister", RefinedLinear1DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear1DFiniteElement_swiginit", RefinedLinear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear2DFiniteElement", _wrap_new_RefinedLinear2DFiniteElement, METH_NOARGS, "new_RefinedLinear2DFiniteElement() -> RefinedLinear2DFiniteElement"}, - { "RefinedLinear2DFiniteElement_CalcShape", _wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS, "RefinedLinear2DFiniteElement_CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear2DFiniteElement_CalcDShape", _wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS, "RefinedLinear2DFiniteElement_CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear2DFiniteElement_CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear2DFiniteElement_CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear2DFiniteElement", _wrap_delete_RefinedLinear2DFiniteElement, METH_O, "delete_RefinedLinear2DFiniteElement(RefinedLinear2DFiniteElement self)"}, { "RefinedLinear2DFiniteElement_swigregister", RefinedLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear2DFiniteElement_swiginit", RefinedLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear3DFiniteElement", _wrap_new_RefinedLinear3DFiniteElement, METH_NOARGS, "new_RefinedLinear3DFiniteElement() -> RefinedLinear3DFiniteElement"}, - { "RefinedLinear3DFiniteElement_CalcShape", _wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS, "RefinedLinear3DFiniteElement_CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear3DFiniteElement_CalcDShape", _wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS, "RefinedLinear3DFiniteElement_CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear3DFiniteElement_CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear3DFiniteElement_CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear3DFiniteElement", _wrap_delete_RefinedLinear3DFiniteElement, METH_O, "delete_RefinedLinear3DFiniteElement(RefinedLinear3DFiniteElement self)"}, { "RefinedLinear3DFiniteElement_swigregister", RefinedLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear3DFiniteElement_swiginit", RefinedLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedBiLinear2DFiniteElement", _wrap_new_RefinedBiLinear2DFiniteElement, METH_NOARGS, "new_RefinedBiLinear2DFiniteElement() -> RefinedBiLinear2DFiniteElement"}, - { "RefinedBiLinear2DFiniteElement_CalcShape", _wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "RefinedBiLinear2DFiniteElement_CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedBiLinear2DFiniteElement_CalcDShape", _wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "RefinedBiLinear2DFiniteElement_CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedBiLinear2DFiniteElement_CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedBiLinear2DFiniteElement_CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedBiLinear2DFiniteElement", _wrap_delete_RefinedBiLinear2DFiniteElement, METH_O, "delete_RefinedBiLinear2DFiniteElement(RefinedBiLinear2DFiniteElement self)"}, { "RefinedBiLinear2DFiniteElement_swigregister", RefinedBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedBiLinear2DFiniteElement_swiginit", RefinedBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedTriLinear3DFiniteElement", _wrap_new_RefinedTriLinear3DFiniteElement, METH_NOARGS, "new_RefinedTriLinear3DFiniteElement() -> RefinedTriLinear3DFiniteElement"}, - { "RefinedTriLinear3DFiniteElement_CalcShape", _wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS, "RefinedTriLinear3DFiniteElement_CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedTriLinear3DFiniteElement_CalcDShape", _wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "RefinedTriLinear3DFiniteElement_CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedTriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedTriLinear3DFiniteElement_CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedTriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedTriLinear3DFiniteElement_CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedTriLinear3DFiniteElement", _wrap_delete_RefinedTriLinear3DFiniteElement, METH_O, "delete_RefinedTriLinear3DFiniteElement(RefinedTriLinear3DFiniteElement self)"}, { "RefinedTriLinear3DFiniteElement_swigregister", RefinedTriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedTriLinear3DFiniteElement_swiginit", RefinedTriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -47942,8 +47493,8 @@ static PyMethodDef SwigMethods[] = { "Nedelec1HexFiniteElement_CalcVShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "Nedelec1HexFiniteElement_CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1HexFiniteElement_CalcCurlShape", _wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS, "Nedelec1HexFiniteElement_CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1HexFiniteElement_GetLocalInterpolation", _wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "Nedelec1HexFiniteElement_GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1HexFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "Nedelec1HexFiniteElement_CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "Nedelec1HexFiniteElement_GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1HexFiniteElement_Project", _wrap_Nedelec1HexFiniteElement_Project, METH_VARARGS, "\n" "Nedelec1HexFiniteElement_Project(Nedelec1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Nedelec1HexFiniteElement_Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47958,8 +47509,8 @@ static PyMethodDef SwigMethods[] = { "Nedelec1TetFiniteElement_CalcVShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "Nedelec1TetFiniteElement_CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1TetFiniteElement_CalcCurlShape", _wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS, "Nedelec1TetFiniteElement_CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1TetFiniteElement_GetLocalInterpolation", _wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "Nedelec1TetFiniteElement_GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1TetFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "Nedelec1TetFiniteElement_CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "Nedelec1TetFiniteElement_GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1TetFiniteElement_Project", _wrap_Nedelec1TetFiniteElement_Project, METH_VARARGS, "\n" "Nedelec1TetFiniteElement_Project(Nedelec1TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Nedelec1TetFiniteElement_Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47974,8 +47525,8 @@ static PyMethodDef SwigMethods[] = { "RT0HexFiniteElement_CalcVShape(RT0HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0HexFiniteElement_CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0HexFiniteElement_CalcDivShape", _wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS, "RT0HexFiniteElement_CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0HexFiniteElement_GetLocalInterpolation", _wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0HexFiniteElement_GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0HexFiniteElement_CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0HexFiniteElement_GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0HexFiniteElement_Project", _wrap_RT0HexFiniteElement_Project, METH_VARARGS, "\n" "RT0HexFiniteElement_Project(RT0HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0HexFiniteElement_Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -47990,8 +47541,8 @@ static PyMethodDef SwigMethods[] = { "RT1HexFiniteElement_CalcVShape(RT1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT1HexFiniteElement_CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1HexFiniteElement_CalcDivShape", _wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS, "RT1HexFiniteElement_CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1HexFiniteElement_GetLocalInterpolation", _wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT1HexFiniteElement_GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT1HexFiniteElement_CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT1HexFiniteElement_GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1HexFiniteElement_Project", _wrap_RT1HexFiniteElement_Project, METH_VARARGS, "\n" "RT1HexFiniteElement_Project(RT1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT1HexFiniteElement_Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48006,8 +47557,8 @@ static PyMethodDef SwigMethods[] = { "RT0TetFiniteElement_CalcVShape(RT0TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0TetFiniteElement_CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TetFiniteElement_CalcDivShape", _wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS, "RT0TetFiniteElement_CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TetFiniteElement_GetLocalInterpolation", _wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0TetFiniteElement_GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TetFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0TetFiniteElement_CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0TetFiniteElement_GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TetFiniteElement_Project", _wrap_RT0TetFiniteElement_Project, METH_VARARGS, "\n" "RT0TetFiniteElement_Project(RT0TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0TetFiniteElement_Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48018,29 +47569,29 @@ static PyMethodDef SwigMethods[] = { { "RT0TetFiniteElement_swigregister", RT0TetFiniteElement_swigregister, METH_O, NULL}, { "RT0TetFiniteElement_swiginit", RT0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RotTriLinearHexFiniteElement", _wrap_new_RotTriLinearHexFiniteElement, METH_NOARGS, "new_RotTriLinearHexFiniteElement() -> RotTriLinearHexFiniteElement"}, - { "RotTriLinearHexFiniteElement_CalcShape", _wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS, "RotTriLinearHexFiniteElement_CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RotTriLinearHexFiniteElement_CalcDShape", _wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS, "RotTriLinearHexFiniteElement_CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RotTriLinearHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RotTriLinearHexFiniteElement_CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RotTriLinearHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RotTriLinearHexFiniteElement_CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RotTriLinearHexFiniteElement", _wrap_delete_RotTriLinearHexFiniteElement, METH_O, "delete_RotTriLinearHexFiniteElement(RotTriLinearHexFiniteElement self)"}, { "RotTriLinearHexFiniteElement_swigregister", RotTriLinearHexFiniteElement_swigregister, METH_O, NULL}, { "RotTriLinearHexFiniteElement_swiginit", RotTriLinearHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Poly_1D", _wrap_new_Poly_1D, METH_NOARGS, "new_Poly_1D() -> Poly_1D"}, - { "Poly_1D_Binom", _wrap_Poly_1D_Binom, METH_O, "Poly_1D_Binom(int const p) -> int const *"}, - { "Poly_1D_GetPoints", _wrap_Poly_1D_GetPoints, METH_VARARGS, "Poly_1D_GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, - { "Poly_1D_OpenPoints", _wrap_Poly_1D_OpenPoints, METH_VARARGS, "Poly_1D_OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const"}, - { "Poly_1D_ClosedPoints", _wrap_Poly_1D_ClosedPoints, METH_VARARGS, "Poly_1D_ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const"}, - { "Poly_1D_GetBasis", _wrap_Poly_1D_GetBasis, METH_VARARGS, "Poly_1D_GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, + { "Poly_1D_Binom", (PyCFunction)(void(*)(void))_wrap_Poly_1D_Binom, METH_VARARGS|METH_KEYWORDS, "Poly_1D_Binom(int const p) -> int const *"}, + { "Poly_1D_GetPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, + { "Poly_1D_OpenPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_OpenPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const *"}, + { "Poly_1D_ClosedPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ClosedPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const *"}, + { "Poly_1D_GetBasis", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetBasis, METH_VARARGS|METH_KEYWORDS, "Poly_1D_GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, { "Poly_1D_CalcBasis", _wrap_Poly_1D_CalcBasis, METH_VARARGS, "\n" "Poly_1D_CalcBasis(int const p, double const x, double * u)\n" "Poly_1D_CalcBasis(int const p, double const x, double * u, double * d)\n" "Poly_1D_CalcBasis(int const p, double const x, double * u, double * d, double * dd)\n" ""}, - { "Poly_1D_CalcDelta", _wrap_Poly_1D_CalcDelta, METH_VARARGS, "Poly_1D_CalcDelta(int const p, double const x) -> double"}, - { "Poly_1D_ChebyshevPoints", _wrap_Poly_1D_ChebyshevPoints, METH_VARARGS, "Poly_1D_ChebyshevPoints(int const p, double * x)"}, + { "Poly_1D_CalcDelta", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDelta, METH_VARARGS|METH_KEYWORDS, "Poly_1D_CalcDelta(int const p, double const x) -> double"}, + { "Poly_1D_ChebyshevPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ChebyshevPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_ChebyshevPoints(int const p, double * x)"}, { "Poly_1D_CalcBinomTerms", _wrap_Poly_1D_CalcBinomTerms, METH_VARARGS, "\n" "Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u)\n" "Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)\n" ""}, - { "Poly_1D_CalcDBinomTerms", _wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS, "Poly_1D_CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, + { "Poly_1D_CalcDBinomTerms", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS|METH_KEYWORDS, "Poly_1D_CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, { "Poly_1D_CalcBernstein", _wrap_Poly_1D_CalcBernstein, METH_VARARGS, "\n" "Poly_1D_CalcBernstein(int const p, double const x, double * u)\n" "Poly_1D_CalcBernstein(int const p, double const x, double * u, double * d)\n" @@ -48052,67 +47603,67 @@ static PyMethodDef SwigMethods[] = { { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, - { "new_TensorBasisElement", _wrap_new_TensorBasisElement, METH_VARARGS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, + { "new_TensorBasisElement", (PyCFunction)(void(*)(void))_wrap_new_TensorBasisElement, METH_VARARGS|METH_KEYWORDS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, { "TensorBasisElement_GetBasisType", _wrap_TensorBasisElement_GetBasisType, METH_O, "TensorBasisElement_GetBasisType(TensorBasisElement self) -> int"}, { "TensorBasisElement_GetBasis1D", _wrap_TensorBasisElement_GetBasis1D, METH_O, "TensorBasisElement_GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &"}, { "TensorBasisElement_GetDofMap", _wrap_TensorBasisElement_GetDofMap, METH_O, "TensorBasisElement_GetDofMap(TensorBasisElement self) -> intArray"}, - { "TensorBasisElement_GetTensorProductGeometry", _wrap_TensorBasisElement_GetTensorProductGeometry, METH_O, "TensorBasisElement_GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, - { "TensorBasisElement_Pow", _wrap_TensorBasisElement_Pow, METH_VARARGS, "TensorBasisElement_Pow(int base, int dim) -> int"}, + { "TensorBasisElement_GetTensorProductGeometry", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_GetTensorProductGeometry, METH_VARARGS|METH_KEYWORDS, "TensorBasisElement_GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, + { "TensorBasisElement_Pow", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_Pow, METH_VARARGS|METH_KEYWORDS, "TensorBasisElement_Pow(int base, int dim) -> int"}, { "delete_TensorBasisElement", _wrap_delete_TensorBasisElement, METH_O, "delete_TensorBasisElement(TensorBasisElement self)"}, { "TensorBasisElement_swigregister", TensorBasisElement_swigregister, METH_O, NULL}, { "TensorBasisElement_swiginit", TensorBasisElement_swiginit, METH_VARARGS, NULL}, - { "NodalTensorFiniteElement_GetDofToQuad", _wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS, "NodalTensorFiniteElement_GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "NodalTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "NodalTensorFiniteElement_GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_NodalTensorFiniteElement", _wrap_delete_NodalTensorFiniteElement, METH_O, "delete_NodalTensorFiniteElement(NodalTensorFiniteElement self)"}, { "NodalTensorFiniteElement_swigregister", NodalTensorFiniteElement_swigregister, METH_O, NULL}, - { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "PositiveTensorFiniteElement_GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "PositiveTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "PositiveTensorFiniteElement_GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, - { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "new_VectorTensorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorTensorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "VectorTensorFiniteElement_GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS|METH_KEYWORDS, "VectorTensorFiniteElement_GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS|METH_KEYWORDS, "VectorTensorFiniteElement_GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, - { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "H1_SegmentElement_CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "H1_SegmentElement_CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_SegmentElement_ProjectDelta", _wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS, "H1_SegmentElement_ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1_SegmentElement(int const p, int const btype=GaussLobatto) -> H1_SegmentElement"}, + { "H1_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_SegmentElement_CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_SegmentElement_CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1_SegmentElement_ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1_SegmentElement", _wrap_delete_H1_SegmentElement, METH_O, "delete_H1_SegmentElement(H1_SegmentElement self)"}, { "H1_SegmentElement_swigregister", H1_SegmentElement_swigregister, METH_O, NULL}, { "H1_SegmentElement_swiginit", H1_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_QuadrilateralElement", _wrap_new_H1_QuadrilateralElement, METH_VARARGS, "H1_QuadrilateralElement(int const p, int const btype=GaussLobatto)"}, - { "H1_QuadrilateralElement_CalcShape", _wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS, "H1_QuadrilateralElement_CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_QuadrilateralElement_CalcDShape", _wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1_QuadrilateralElement_CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_QuadrilateralElement_ProjectDelta", _wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS, "H1_QuadrilateralElement_ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1_QuadrilateralElement(int const p, int const btype=GaussLobatto) -> H1_QuadrilateralElement"}, + { "H1_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_QuadrilateralElement_CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_QuadrilateralElement_CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1_QuadrilateralElement_ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1_QuadrilateralElement", _wrap_delete_H1_QuadrilateralElement, METH_O, "delete_H1_QuadrilateralElement(H1_QuadrilateralElement self)"}, { "H1_QuadrilateralElement_swigregister", H1_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1_QuadrilateralElement_swiginit", H1_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_HexahedronElement", _wrap_new_H1_HexahedronElement, METH_VARARGS, "H1_HexahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_HexahedronElement_CalcShape", _wrap_H1_HexahedronElement_CalcShape, METH_VARARGS, "H1_HexahedronElement_CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_HexahedronElement_CalcDShape", _wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS, "H1_HexahedronElement_CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_HexahedronElement_ProjectDelta", _wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS, "H1_HexahedronElement_ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_HexahedronElement(int const p, int const btype=GaussLobatto) -> H1_HexahedronElement"}, + { "H1_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_HexahedronElement_CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_HexahedronElement_CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1_HexahedronElement_ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1_HexahedronElement", _wrap_delete_H1_HexahedronElement, METH_O, "delete_H1_HexahedronElement(H1_HexahedronElement self)"}, { "H1_HexahedronElement_swigregister", H1_HexahedronElement_swigregister, METH_O, NULL}, { "H1_HexahedronElement_swiginit", H1_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_SegmentElement", _wrap_new_H1Pos_SegmentElement, METH_O, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, - { "H1Pos_SegmentElement_CalcShape", _wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS, "H1Pos_SegmentElement_CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_SegmentElement_CalcDShape", _wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS, "H1Pos_SegmentElement_CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_SegmentElement_ProjectDelta", _wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS, "H1Pos_SegmentElement_ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, + { "H1Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_SegmentElement_CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_SegmentElement_CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1Pos_SegmentElement_ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_SegmentElement", _wrap_delete_H1Pos_SegmentElement, METH_O, "delete_H1Pos_SegmentElement(H1Pos_SegmentElement self)"}, { "H1Pos_SegmentElement_swigregister", H1Pos_SegmentElement_swigregister, METH_O, NULL}, { "H1Pos_SegmentElement_swiginit", H1Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_QuadrilateralElement", _wrap_new_H1Pos_QuadrilateralElement, METH_O, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, - { "H1Pos_QuadrilateralElement_CalcShape", _wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "H1Pos_QuadrilateralElement_CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_QuadrilateralElement_CalcDShape", _wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1Pos_QuadrilateralElement_CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_QuadrilateralElement_ProjectDelta", _wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "H1Pos_QuadrilateralElement_ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, + { "H1Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_QuadrilateralElement_CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_QuadrilateralElement_CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1Pos_QuadrilateralElement_ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, - { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "H1Ser_QuadrilateralElement_GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "new_H1Ser_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Ser_QuadrilateralElement_CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Ser_QuadrilateralElement_CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "H1Ser_QuadrilateralElement_GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48121,28 +47672,28 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, - { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_HexahedronElement_ProjectDelta", _wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "H1Pos_HexahedronElement_ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, + { "H1Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_HexahedronElement_CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_HexahedronElement_CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1Pos_HexahedronElement_ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_HexahedronElement", _wrap_delete_H1Pos_HexahedronElement, METH_O, "delete_H1Pos_HexahedronElement(H1Pos_HexahedronElement self)"}, { "H1Pos_HexahedronElement_swigregister", H1Pos_HexahedronElement_swigregister, METH_O, NULL}, { "H1Pos_HexahedronElement_swiginit", H1Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TriangleElement", _wrap_new_H1_TriangleElement, METH_VARARGS, "H1_TriangleElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TriangleElement_CalcShape", _wrap_H1_TriangleElement_CalcShape, METH_VARARGS, "H1_TriangleElement_CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TriangleElement_CalcDShape", _wrap_H1_TriangleElement_CalcDShape, METH_VARARGS, "H1_TriangleElement_CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TriangleElement_CalcHessian", _wrap_H1_TriangleElement_CalcHessian, METH_VARARGS, "H1_TriangleElement_CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TriangleElement(int const p, int const btype=GaussLobatto) -> H1_TriangleElement"}, + { "H1_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_TriangleElement_CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_TriangleElement_CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TriangleElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "H1_TriangleElement_CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TriangleElement", _wrap_delete_H1_TriangleElement, METH_O, "delete_H1_TriangleElement(H1_TriangleElement self)"}, { "H1_TriangleElement_swigregister", H1_TriangleElement_swigregister, METH_O, NULL}, { "H1_TriangleElement_swiginit", H1_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TetrahedronElement", _wrap_new_H1_TetrahedronElement, METH_VARARGS, "H1_TetrahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TetrahedronElement_CalcShape", _wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS, "H1_TetrahedronElement_CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TetrahedronElement_CalcDShape", _wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS, "H1_TetrahedronElement_CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TetrahedronElement_CalcHessian", _wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS, "H1_TetrahedronElement_CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TetrahedronElement(int const p, int const btype=GaussLobatto) -> H1_TetrahedronElement"}, + { "H1_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_TetrahedronElement_CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_TetrahedronElement_CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TetrahedronElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "H1_TetrahedronElement_CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TetrahedronElement", _wrap_delete_H1_TetrahedronElement, METH_O, "delete_H1_TetrahedronElement(H1_TetrahedronElement self)"}, { "H1_TetrahedronElement_swigregister", H1_TetrahedronElement_swigregister, METH_O, NULL}, { "H1_TetrahedronElement_swiginit", H1_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TriangleElement", _wrap_new_H1Pos_TriangleElement, METH_O, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, + { "new_H1Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, { "H1Pos_TriangleElement_CalcShape", _wrap_H1Pos_TriangleElement_CalcShape, METH_VARARGS, "\n" "H1Pos_TriangleElement_CalcShape(int const p, double const x, double const y, double * shape)\n" "H1Pos_TriangleElement_CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -48154,7 +47705,7 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_TriangleElement", _wrap_delete_H1Pos_TriangleElement, METH_O, "delete_H1Pos_TriangleElement(H1Pos_TriangleElement self)"}, { "H1Pos_TriangleElement_swigregister", H1Pos_TriangleElement_swigregister, METH_O, NULL}, { "H1Pos_TriangleElement_swiginit", H1Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TetrahedronElement", _wrap_new_H1Pos_TetrahedronElement, METH_O, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, + { "new_H1Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, { "H1Pos_TetrahedronElement_CalcShape", _wrap_H1Pos_TetrahedronElement_CalcShape, METH_VARARGS, "\n" "H1Pos_TetrahedronElement_CalcShape(int const p, double const x, double const y, double const z, double * shape)\n" "H1Pos_TetrahedronElement_CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -48166,9 +47717,9 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_TetrahedronElement", _wrap_delete_H1Pos_TetrahedronElement, METH_O, "delete_H1Pos_TetrahedronElement(H1Pos_TetrahedronElement self)"}, { "H1Pos_TetrahedronElement_swigregister", H1Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "H1Pos_TetrahedronElement_swiginit", H1Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_WedgeElement", _wrap_new_H1_WedgeElement, METH_VARARGS, "H1_WedgeElement(int const p, int const btype=GaussLobatto)"}, - { "H1_WedgeElement_CalcShape", _wrap_H1_WedgeElement_CalcShape, METH_VARARGS, "H1_WedgeElement_CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_WedgeElement_CalcDShape", _wrap_H1_WedgeElement_CalcDShape, METH_VARARGS, "H1_WedgeElement_CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1_WedgeElement(int const p, int const btype=GaussLobatto) -> H1_WedgeElement"}, + { "H1_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_WedgeElement_CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_WedgeElement_CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1_WedgeElement", _wrap_delete_H1_WedgeElement, METH_O, "delete_H1_WedgeElement(H1_WedgeElement self)"}, { "H1_WedgeElement_swigregister", H1_WedgeElement_swigregister, METH_O, NULL}, { "H1_WedgeElement_swiginit", H1_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -48184,87 +47735,87 @@ static PyMethodDef SwigMethods[] = { { "delete_BiCubic3DFiniteElement", _wrap_delete_BiCubic3DFiniteElement, METH_O, "delete_BiCubic3DFiniteElement(BiCubic3DFiniteElement self)"}, { "BiCubic3DFiniteElement_swigregister", BiCubic3DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic3DFiniteElement_swiginit", BiCubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_WedgeElement", _wrap_new_H1Pos_WedgeElement, METH_O, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, - { "H1Pos_WedgeElement_CalcShape", _wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS, "H1Pos_WedgeElement_CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_WedgeElement_CalcDShape", _wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS, "H1Pos_WedgeElement_CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, + { "H1Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_WedgeElement_CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_WedgeElement_CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1Pos_WedgeElement", _wrap_delete_H1Pos_WedgeElement, METH_O, "delete_H1Pos_WedgeElement(H1Pos_WedgeElement self)"}, { "H1Pos_WedgeElement_swigregister", H1Pos_WedgeElement_swigregister, METH_O, NULL}, { "H1Pos_WedgeElement_swiginit", H1Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_SegmentElement", _wrap_new_L2_SegmentElement, METH_VARARGS, "L2_SegmentElement(int const p, int const btype=GaussLegendre)"}, - { "L2_SegmentElement_CalcShape", _wrap_L2_SegmentElement_CalcShape, METH_VARARGS, "L2_SegmentElement_CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_SegmentElement_CalcDShape", _wrap_L2_SegmentElement_CalcDShape, METH_VARARGS, "L2_SegmentElement_CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_SegmentElement_ProjectDelta", _wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS, "L2_SegmentElement_ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2_SegmentElement(int const p, int const btype=GaussLegendre) -> L2_SegmentElement"}, + { "L2_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_SegmentElement_CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_SegmentElement_CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_SegmentElement_ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2_SegmentElement", _wrap_delete_L2_SegmentElement, METH_O, "delete_L2_SegmentElement(L2_SegmentElement self)"}, { "L2_SegmentElement_swigregister", L2_SegmentElement_swigregister, METH_O, NULL}, { "L2_SegmentElement_swiginit", L2_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_SegmentElement", _wrap_new_L2Pos_SegmentElement, METH_O, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, - { "L2Pos_SegmentElement_CalcShape", _wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS, "L2Pos_SegmentElement_CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_SegmentElement_CalcDShape", _wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS, "L2Pos_SegmentElement_CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_SegmentElement_ProjectDelta", _wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS, "L2Pos_SegmentElement_ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, + { "L2Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_SegmentElement_CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_SegmentElement_CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_SegmentElement_ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_SegmentElement", _wrap_delete_L2Pos_SegmentElement, METH_O, "delete_L2Pos_SegmentElement(L2Pos_SegmentElement self)"}, { "L2Pos_SegmentElement_swigregister", L2Pos_SegmentElement_swigregister, METH_O, NULL}, { "L2Pos_SegmentElement_swiginit", L2Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_QuadrilateralElement", _wrap_new_L2_QuadrilateralElement, METH_VARARGS, "L2_QuadrilateralElement(int const p, int const btype=GaussLegendre)"}, - { "L2_QuadrilateralElement_CalcShape", _wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS, "L2_QuadrilateralElement_CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_QuadrilateralElement_CalcDShape", _wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS, "L2_QuadrilateralElement_CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_QuadrilateralElement_ProjectDelta", _wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS, "L2_QuadrilateralElement_ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, - { "L2_QuadrilateralElement_ProjectCurl", _wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS, "L2_QuadrilateralElement_ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2_QuadrilateralElement(int const p, int const btype=GaussLegendre) -> L2_QuadrilateralElement"}, + { "L2_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "L2_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_QuadrilateralElement", _wrap_delete_L2_QuadrilateralElement, METH_O, "delete_L2_QuadrilateralElement(L2_QuadrilateralElement self)"}, { "L2_QuadrilateralElement_swigregister", L2_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2_QuadrilateralElement_swiginit", L2_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_QuadrilateralElement", _wrap_new_L2Pos_QuadrilateralElement, METH_O, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, - { "L2Pos_QuadrilateralElement_CalcShape", _wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "L2Pos_QuadrilateralElement_CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_QuadrilateralElement_CalcDShape", _wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "L2Pos_QuadrilateralElement_CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_QuadrilateralElement_ProjectDelta", _wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "L2Pos_QuadrilateralElement_ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, + { "L2Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_QuadrilateralElement_CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_QuadrilateralElement_CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_QuadrilateralElement_ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_QuadrilateralElement", _wrap_delete_L2Pos_QuadrilateralElement, METH_O, "delete_L2Pos_QuadrilateralElement(L2Pos_QuadrilateralElement self)"}, { "L2Pos_QuadrilateralElement_swigregister", L2Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2Pos_QuadrilateralElement_swiginit", L2Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_HexahedronElement", _wrap_new_L2_HexahedronElement, METH_VARARGS, "L2_HexahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_HexahedronElement_CalcShape", _wrap_L2_HexahedronElement_CalcShape, METH_VARARGS, "L2_HexahedronElement_CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_HexahedronElement_CalcDShape", _wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS, "L2_HexahedronElement_CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_HexahedronElement_ProjectDelta", _wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS, "L2_HexahedronElement_ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_HexahedronElement(int const p, int const btype=GaussLegendre) -> L2_HexahedronElement"}, + { "L2_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_HexahedronElement_CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_HexahedronElement_CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_HexahedronElement_ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_HexahedronElement", _wrap_delete_L2_HexahedronElement, METH_O, "delete_L2_HexahedronElement(L2_HexahedronElement self)"}, { "L2_HexahedronElement_swigregister", L2_HexahedronElement_swigregister, METH_O, NULL}, { "L2_HexahedronElement_swiginit", L2_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_HexahedronElement", _wrap_new_L2Pos_HexahedronElement, METH_O, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, - { "L2Pos_HexahedronElement_CalcShape", _wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS, "L2Pos_HexahedronElement_CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_HexahedronElement_CalcDShape", _wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS, "L2Pos_HexahedronElement_CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_HexahedronElement_ProjectDelta", _wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "L2Pos_HexahedronElement_ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, + { "L2Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_HexahedronElement_CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_HexahedronElement_CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_HexahedronElement_ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_HexahedronElement", _wrap_delete_L2Pos_HexahedronElement, METH_O, "delete_L2Pos_HexahedronElement(L2Pos_HexahedronElement self)"}, { "L2Pos_HexahedronElement_swigregister", L2Pos_HexahedronElement_swigregister, METH_O, NULL}, { "L2Pos_HexahedronElement_swiginit", L2Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TriangleElement", _wrap_new_L2_TriangleElement, METH_VARARGS, "L2_TriangleElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TriangleElement_CalcShape", _wrap_L2_TriangleElement_CalcShape, METH_VARARGS, "L2_TriangleElement_CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TriangleElement_CalcDShape", _wrap_L2_TriangleElement_CalcDShape, METH_VARARGS, "L2_TriangleElement_CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TriangleElement_ProjectDelta", _wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS, "L2_TriangleElement_ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, - { "L2_TriangleElement_ProjectCurl", _wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS, "L2_TriangleElement_ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TriangleElement(int const p, int const btype=GaussLegendre) -> L2_TriangleElement"}, + { "L2_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, + { "L2_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_TriangleElement", _wrap_delete_L2_TriangleElement, METH_O, "delete_L2_TriangleElement(L2_TriangleElement self)"}, { "L2_TriangleElement_swigregister", L2_TriangleElement_swigregister, METH_O, NULL}, { "L2_TriangleElement_swiginit", L2_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TriangleElement", _wrap_new_L2Pos_TriangleElement, METH_O, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, - { "L2Pos_TriangleElement_CalcShape", _wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS, "L2Pos_TriangleElement_CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TriangleElement_CalcDShape", _wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS, "L2Pos_TriangleElement_CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TriangleElement_ProjectDelta", _wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS, "L2Pos_TriangleElement_ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, + { "L2Pos_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TriangleElement_CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TriangleElement_CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_TriangleElement_ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TriangleElement", _wrap_delete_L2Pos_TriangleElement, METH_O, "delete_L2Pos_TriangleElement(L2Pos_TriangleElement self)"}, { "L2Pos_TriangleElement_swigregister", L2Pos_TriangleElement_swigregister, METH_O, NULL}, { "L2Pos_TriangleElement_swiginit", L2Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TetrahedronElement", _wrap_new_L2_TetrahedronElement, METH_VARARGS, "L2_TetrahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TetrahedronElement_CalcShape", _wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS, "L2_TetrahedronElement_CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TetrahedronElement_CalcDShape", _wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS, "L2_TetrahedronElement_CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TetrahedronElement_ProjectDelta", _wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS, "L2_TetrahedronElement_ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TetrahedronElement(int const p, int const btype=GaussLegendre) -> L2_TetrahedronElement"}, + { "L2_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_TetrahedronElement_CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_TetrahedronElement_CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_TetrahedronElement_ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_TetrahedronElement", _wrap_delete_L2_TetrahedronElement, METH_O, "delete_L2_TetrahedronElement(L2_TetrahedronElement self)"}, { "L2_TetrahedronElement_swigregister", L2_TetrahedronElement_swigregister, METH_O, NULL}, { "L2_TetrahedronElement_swiginit", L2_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TetrahedronElement", _wrap_new_L2Pos_TetrahedronElement, METH_O, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, - { "L2Pos_TetrahedronElement_CalcShape", _wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS, "L2Pos_TetrahedronElement_CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TetrahedronElement_CalcDShape", _wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "L2Pos_TetrahedronElement_CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TetrahedronElement_ProjectDelta", _wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS, "L2Pos_TetrahedronElement_ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, + { "L2Pos_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TetrahedronElement_CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TetrahedronElement_CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_TetrahedronElement_ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TetrahedronElement", _wrap_delete_L2Pos_TetrahedronElement, METH_O, "delete_L2Pos_TetrahedronElement(L2Pos_TetrahedronElement self)"}, { "L2Pos_TetrahedronElement_swigregister", L2Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "L2Pos_TetrahedronElement_swiginit", L2Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_WedgeElement", _wrap_new_L2_WedgeElement, METH_VARARGS, "L2_WedgeElement(int const p, int const btype=GaussLegendre)"}, - { "L2_WedgeElement_CalcShape", _wrap_L2_WedgeElement_CalcShape, METH_VARARGS, "L2_WedgeElement_CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_WedgeElement_CalcDShape", _wrap_L2_WedgeElement_CalcDShape, METH_VARARGS, "L2_WedgeElement_CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2_WedgeElement(int const p, int const btype=GaussLegendre) -> L2_WedgeElement"}, + { "L2_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_WedgeElement_CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_WedgeElement_CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2_WedgeElement", _wrap_delete_L2_WedgeElement, METH_O, "delete_L2_WedgeElement(L2_WedgeElement self)"}, { "L2_WedgeElement_swigregister", L2_WedgeElement_swigregister, METH_O, NULL}, { "L2_WedgeElement_swiginit", L2_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -48272,22 +47823,22 @@ static PyMethodDef SwigMethods[] = { { "delete_P0WedgeFiniteElement", _wrap_delete_P0WedgeFiniteElement, METH_O, "delete_P0WedgeFiniteElement(P0WedgeFiniteElement self)"}, { "P0WedgeFiniteElement_swigregister", P0WedgeFiniteElement_swigregister, METH_O, NULL}, { "P0WedgeFiniteElement_swiginit", P0WedgeFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_WedgeElement", _wrap_new_L2Pos_WedgeElement, METH_O, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, - { "L2Pos_WedgeElement_CalcShape", _wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS, "L2Pos_WedgeElement_CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_WedgeElement_CalcDShape", _wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS, "L2Pos_WedgeElement_CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, + { "L2Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_WedgeElement_CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_WedgeElement_CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2Pos_WedgeElement", _wrap_delete_L2Pos_WedgeElement, METH_O, "delete_L2Pos_WedgeElement(L2Pos_WedgeElement self)"}, { "L2Pos_WedgeElement_swigregister", L2Pos_WedgeElement_swigregister, METH_O, NULL}, { "L2Pos_WedgeElement_swiginit", L2Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_QuadrilateralElement", _wrap_new_RT_QuadrilateralElement, METH_VARARGS, "RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_RT_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_QuadrilateralElement"}, { "RT_QuadrilateralElement_CalcVShape", _wrap_RT_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "RT_QuadrilateralElement_CalcVShape(RT_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_QuadrilateralElement_CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_QuadrilateralElement_CalcDivShape", _wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS, "RT_QuadrilateralElement_CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_QuadrilateralElement_GetLocalInterpolation", _wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "RT_QuadrilateralElement_GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_GetLocalRestriction", _wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "RT_QuadrilateralElement_GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_QuadrilateralElement_GetTransferMatrix", _wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "RT_QuadrilateralElement_GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_QuadrilateralElement_ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_QuadrilateralElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_QuadrilateralElement_Project", _wrap_RT_QuadrilateralElement_Project, METH_VARARGS, "\n" "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48295,21 +47846,21 @@ static PyMethodDef SwigMethods[] = { "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_QuadrilateralElement_ProjectGrad", _wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS, "RT_QuadrilateralElement_ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_QuadrilateralElement_ProjectCurl", _wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS, "RT_QuadrilateralElement_ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_QuadrilateralElement", _wrap_delete_RT_QuadrilateralElement, METH_O, "delete_RT_QuadrilateralElement(RT_QuadrilateralElement self)"}, { "RT_QuadrilateralElement_swigregister", RT_QuadrilateralElement_swigregister, METH_O, NULL}, { "RT_QuadrilateralElement_swiginit", RT_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_HexahedronElement", _wrap_new_RT_HexahedronElement, METH_VARARGS, "RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_HexahedronElement"}, { "RT_HexahedronElement_CalcVShape", _wrap_RT_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "RT_HexahedronElement_CalcVShape(RT_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_HexahedronElement_CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_HexahedronElement_CalcDivShape", _wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS, "RT_HexahedronElement_CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_HexahedronElement_GetLocalInterpolation", _wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "RT_HexahedronElement_GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_GetLocalRestriction", _wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS, "RT_HexahedronElement_GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_HexahedronElement_GetTransferMatrix", _wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS, "RT_HexahedronElement_GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_ProjectMatrixCoefficient", _wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_HexahedronElement_ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_HexahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_HexahedronElement_Project", _wrap_RT_HexahedronElement_Project, METH_VARARGS, "\n" "RT_HexahedronElement_Project(RT_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_HexahedronElement_Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48317,20 +47868,20 @@ static PyMethodDef SwigMethods[] = { "RT_HexahedronElement_Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_HexahedronElement_Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_HexahedronElement_ProjectCurl", _wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS, "RT_HexahedronElement_ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_HexahedronElement", _wrap_delete_RT_HexahedronElement, METH_O, "delete_RT_HexahedronElement(RT_HexahedronElement self)"}, { "RT_HexahedronElement_swigregister", RT_HexahedronElement_swigregister, METH_O, NULL}, { "RT_HexahedronElement_swiginit", RT_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TriangleElement", _wrap_new_RT_TriangleElement, METH_O, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, + { "new_RT_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, { "RT_TriangleElement_CalcVShape", _wrap_RT_TriangleElement_CalcVShape, METH_VARARGS, "\n" "RT_TriangleElement_CalcVShape(RT_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_TriangleElement_CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TriangleElement_CalcDivShape", _wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS, "RT_TriangleElement_CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TriangleElement_GetLocalInterpolation", _wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS, "RT_TriangleElement_GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_GetLocalRestriction", _wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS, "RT_TriangleElement_GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TriangleElement_GetTransferMatrix", _wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS, "RT_TriangleElement_GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_ProjectMatrixCoefficient", _wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_TriangleElement_ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TriangleElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TriangleElement_Project", _wrap_RT_TriangleElement_Project, METH_VARARGS, "\n" "RT_TriangleElement_Project(RT_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TriangleElement_Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48338,21 +47889,21 @@ static PyMethodDef SwigMethods[] = { "RT_TriangleElement_Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TriangleElement_Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TriangleElement_ProjectGrad", _wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS, "RT_TriangleElement_ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_TriangleElement_ProjectCurl", _wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS, "RT_TriangleElement_ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TriangleElement", _wrap_delete_RT_TriangleElement, METH_O, "delete_RT_TriangleElement(RT_TriangleElement self)"}, { "RT_TriangleElement_swigregister", RT_TriangleElement_swigregister, METH_O, NULL}, { "RT_TriangleElement_swiginit", RT_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TetrahedronElement", _wrap_new_RT_TetrahedronElement, METH_O, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, + { "new_RT_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, { "RT_TetrahedronElement_CalcVShape", _wrap_RT_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "RT_TetrahedronElement_CalcVShape(RT_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_TetrahedronElement_CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TetrahedronElement_CalcDivShape", _wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS, "RT_TetrahedronElement_CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TetrahedronElement_GetLocalInterpolation", _wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "RT_TetrahedronElement_GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_GetLocalRestriction", _wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "RT_TetrahedronElement_GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TetrahedronElement_GetTransferMatrix", _wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "RT_TetrahedronElement_GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_ProjectMatrixCoefficient", _wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_TetrahedronElement_ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TetrahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TetrahedronElement_Project", _wrap_RT_TetrahedronElement_Project, METH_VARARGS, "\n" "RT_TetrahedronElement_Project(RT_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TetrahedronElement_Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48360,20 +47911,20 @@ static PyMethodDef SwigMethods[] = { "RT_TetrahedronElement_Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TetrahedronElement_Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TetrahedronElement_ProjectCurl", _wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS, "RT_TetrahedronElement_ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TetrahedronElement", _wrap_delete_RT_TetrahedronElement, METH_O, "delete_RT_TetrahedronElement(RT_TetrahedronElement self)"}, { "RT_TetrahedronElement_swigregister", RT_TetrahedronElement_swigregister, METH_O, NULL}, { "RT_TetrahedronElement_swiginit", RT_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_HexahedronElement", _wrap_new_ND_HexahedronElement, METH_VARARGS, "ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_HexahedronElement"}, { "ND_HexahedronElement_CalcVShape", _wrap_ND_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "ND_HexahedronElement_CalcVShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_HexahedronElement_CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_HexahedronElement_CalcCurlShape", _wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS, "ND_HexahedronElement_CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_HexahedronElement_GetLocalInterpolation", _wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "ND_HexahedronElement_GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_GetLocalRestriction", _wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS, "ND_HexahedronElement_GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_HexahedronElement_GetTransferMatrix", _wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS, "ND_HexahedronElement_GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_ProjectMatrixCoefficient", _wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_HexahedronElement_ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_HexahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_HexahedronElement_Project", _wrap_ND_HexahedronElement_Project, METH_VARARGS, "\n" "ND_HexahedronElement_Project(ND_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_HexahedronElement_Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48381,21 +47932,21 @@ static PyMethodDef SwigMethods[] = { "ND_HexahedronElement_Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_HexahedronElement_Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_HexahedronElement_ProjectGrad", _wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS, "ND_HexahedronElement_ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_HexahedronElement_ProjectCurl", _wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS, "ND_HexahedronElement_ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_HexahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_HexahedronElement", _wrap_delete_ND_HexahedronElement, METH_O, "delete_ND_HexahedronElement(ND_HexahedronElement self)"}, { "ND_HexahedronElement_swigregister", ND_HexahedronElement_swigregister, METH_O, NULL}, { "ND_HexahedronElement_swiginit", ND_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_QuadrilateralElement", _wrap_new_ND_QuadrilateralElement, METH_VARARGS, "ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_ND_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_QuadrilateralElement"}, { "ND_QuadrilateralElement_CalcVShape", _wrap_ND_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "ND_QuadrilateralElement_CalcVShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_QuadrilateralElement_CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_QuadrilateralElement_CalcCurlShape", _wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS, "ND_QuadrilateralElement_CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_QuadrilateralElement_GetLocalInterpolation", _wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "ND_QuadrilateralElement_GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_GetLocalRestriction", _wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "ND_QuadrilateralElement_GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_QuadrilateralElement_GetTransferMatrix", _wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "ND_QuadrilateralElement_GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_QuadrilateralElement_ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_QuadrilateralElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_QuadrilateralElement_Project", _wrap_ND_QuadrilateralElement_Project, METH_VARARGS, "\n" "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48403,20 +47954,20 @@ static PyMethodDef SwigMethods[] = { "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_QuadrilateralElement_ProjectGrad", _wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ND_QuadrilateralElement_ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_QuadrilateralElement", _wrap_delete_ND_QuadrilateralElement, METH_O, "delete_ND_QuadrilateralElement(ND_QuadrilateralElement self)"}, { "ND_QuadrilateralElement_swigregister", ND_QuadrilateralElement_swigregister, METH_O, NULL}, { "ND_QuadrilateralElement_swiginit", ND_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TetrahedronElement", _wrap_new_ND_TetrahedronElement, METH_O, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, + { "new_ND_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, { "ND_TetrahedronElement_CalcVShape", _wrap_ND_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "ND_TetrahedronElement_CalcVShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_TetrahedronElement_CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TetrahedronElement_CalcCurlShape", _wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS, "ND_TetrahedronElement_CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TetrahedronElement_GetLocalInterpolation", _wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "ND_TetrahedronElement_GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_GetLocalRestriction", _wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "ND_TetrahedronElement_GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TetrahedronElement_GetTransferMatrix", _wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "ND_TetrahedronElement_GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_ProjectMatrixCoefficient", _wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_TetrahedronElement_ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TetrahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TetrahedronElement_Project", _wrap_ND_TetrahedronElement_Project, METH_VARARGS, "\n" "ND_TetrahedronElement_Project(ND_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TetrahedronElement_Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48424,21 +47975,21 @@ static PyMethodDef SwigMethods[] = { "ND_TetrahedronElement_Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TetrahedronElement_Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TetrahedronElement_ProjectGrad", _wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS, "ND_TetrahedronElement_ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_TetrahedronElement_ProjectCurl", _wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS, "ND_TetrahedronElement_ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_TetrahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_TetrahedronElement", _wrap_delete_ND_TetrahedronElement, METH_O, "delete_ND_TetrahedronElement(ND_TetrahedronElement self)"}, { "ND_TetrahedronElement_swigregister", ND_TetrahedronElement_swigregister, METH_O, NULL}, { "ND_TetrahedronElement_swiginit", ND_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TriangleElement", _wrap_new_ND_TriangleElement, METH_O, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, + { "new_ND_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, { "ND_TriangleElement_CalcVShape", _wrap_ND_TriangleElement_CalcVShape, METH_VARARGS, "\n" "ND_TriangleElement_CalcVShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_TriangleElement_CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TriangleElement_CalcCurlShape", _wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS, "ND_TriangleElement_CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TriangleElement_GetLocalInterpolation", _wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS, "ND_TriangleElement_GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_GetLocalRestriction", _wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS, "ND_TriangleElement_GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TriangleElement_GetTransferMatrix", _wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS, "ND_TriangleElement_GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_ProjectMatrixCoefficient", _wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_TriangleElement_ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TriangleElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TriangleElement_Project", _wrap_ND_TriangleElement_Project, METH_VARARGS, "\n" "ND_TriangleElement_Project(ND_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TriangleElement_Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48446,20 +47997,20 @@ static PyMethodDef SwigMethods[] = { "ND_TriangleElement_Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TriangleElement_Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TriangleElement_ProjectGrad", _wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS, "ND_TriangleElement_ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_TriangleElement", _wrap_delete_ND_TriangleElement, METH_O, "delete_ND_TriangleElement(ND_TriangleElement self)"}, { "ND_TriangleElement_swigregister", ND_TriangleElement_swigregister, METH_O, NULL}, { "ND_TriangleElement_swiginit", ND_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_SegmentElement", _wrap_new_ND_SegmentElement, METH_VARARGS, "ND_SegmentElement(int const p, int const ob_type=GaussLegendre)"}, - { "ND_SegmentElement_CalcShape", _wrap_ND_SegmentElement_CalcShape, METH_VARARGS, "ND_SegmentElement_CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "new_ND_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_ND_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_ND_SegmentElement(int const p, int const ob_type=GaussLegendre) -> ND_SegmentElement"}, + { "ND_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, { "ND_SegmentElement_CalcVShape", _wrap_ND_SegmentElement_CalcVShape, METH_VARARGS, "\n" "ND_SegmentElement_CalcVShape(ND_SegmentElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_SegmentElement_CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_SegmentElement_GetLocalInterpolation", _wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS, "ND_SegmentElement_GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_GetLocalRestriction", _wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS, "ND_SegmentElement_GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_SegmentElement_GetTransferMatrix", _wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS, "ND_SegmentElement_GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_ProjectMatrixCoefficient", _wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_SegmentElement_ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_SegmentElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_SegmentElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_SegmentElement_Project", _wrap_ND_SegmentElement_Project, METH_VARARGS, "\n" "ND_SegmentElement_Project(ND_SegmentElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_SegmentElement_Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48467,26 +48018,26 @@ static PyMethodDef SwigMethods[] = { "ND_SegmentElement_Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_SegmentElement_Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_SegmentElement_ProjectGrad", _wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS, "ND_SegmentElement_ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_SegmentElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_SegmentElement", _wrap_delete_ND_SegmentElement, METH_O, "delete_ND_SegmentElement(ND_SegmentElement self)"}, { "ND_SegmentElement_swigregister", ND_SegmentElement_swigregister, METH_O, NULL}, { "ND_SegmentElement_swiginit", ND_SegmentElement_swiginit, METH_VARARGS, NULL}, { "NURBSFiniteElement_Reset", _wrap_NURBSFiniteElement_Reset, METH_O, "NURBSFiniteElement_Reset(NURBSFiniteElement self)"}, - { "NURBSFiniteElement_SetIJK", _wrap_NURBSFiniteElement_SetIJK, METH_VARARGS, "NURBSFiniteElement_SetIJK(NURBSFiniteElement self, int const * IJK)"}, + { "NURBSFiniteElement_SetIJK", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetIJK, METH_VARARGS|METH_KEYWORDS, "NURBSFiniteElement_SetIJK(NURBSFiniteElement self, int const * IJK)"}, { "NURBSFiniteElement_GetPatch", _wrap_NURBSFiniteElement_GetPatch, METH_O, "NURBSFiniteElement_GetPatch(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetPatch", _wrap_NURBSFiniteElement_SetPatch, METH_VARARGS, "NURBSFiniteElement_SetPatch(NURBSFiniteElement self, int p)"}, + { "NURBSFiniteElement_SetPatch", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetPatch, METH_VARARGS|METH_KEYWORDS, "NURBSFiniteElement_SetPatch(NURBSFiniteElement self, int p)"}, { "NURBSFiniteElement_GetElement", _wrap_NURBSFiniteElement_GetElement, METH_O, "NURBSFiniteElement_GetElement(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetElement", _wrap_NURBSFiniteElement_SetElement, METH_VARARGS, "NURBSFiniteElement_SetElement(NURBSFiniteElement self, int e)"}, + { "NURBSFiniteElement_SetElement", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetElement, METH_VARARGS|METH_KEYWORDS, "NURBSFiniteElement_SetElement(NURBSFiniteElement self, int e)"}, { "NURBSFiniteElement_KnotVectors", _wrap_NURBSFiniteElement_KnotVectors, METH_O, "NURBSFiniteElement_KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &"}, { "NURBSFiniteElement_Weights", _wrap_NURBSFiniteElement_Weights, METH_O, "NURBSFiniteElement_Weights(NURBSFiniteElement self) -> Vector"}, { "NURBSFiniteElement_SetOrder", _wrap_NURBSFiniteElement_SetOrder, METH_O, "NURBSFiniteElement_SetOrder(NURBSFiniteElement self)"}, { "delete_NURBSFiniteElement", _wrap_delete_NURBSFiniteElement, METH_O, "delete_NURBSFiniteElement(NURBSFiniteElement self)"}, { "NURBSFiniteElement_swigregister", NURBSFiniteElement_swigregister, METH_O, NULL}, - { "new_NURBS1DFiniteElement", _wrap_new_NURBS1DFiniteElement, METH_O, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, + { "new_NURBS1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_NURBS1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "NURBS1DFiniteElement_SetOrder(NURBS1DFiniteElement self)"}, - { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "NURBS1DFiniteElement_CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "NURBS1DFiniteElement_CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "NURBS1DFiniteElement_CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "NURBS1DFiniteElement_CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "NURBS1DFiniteElement_CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "NURBS1DFiniteElement_CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -48495,9 +48046,9 @@ static PyMethodDef SwigMethods[] = { "new_NURBS2DFiniteElement(int px, int py) -> NURBS2DFiniteElement\n" ""}, { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "NURBS2DFiniteElement_SetOrder(NURBS2DFiniteElement self)"}, - { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "NURBS2DFiniteElement_CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "NURBS2DFiniteElement_CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "NURBS2DFiniteElement_CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "NURBS2DFiniteElement_CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "NURBS2DFiniteElement_CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "NURBS2DFiniteElement_CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -48506,9 +48057,9 @@ static PyMethodDef SwigMethods[] = { "new_NURBS3DFiniteElement(int px, int py, int pz) -> NURBS3DFiniteElement\n" ""}, { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "NURBS3DFiniteElement_SetOrder(NURBS3DFiniteElement self)"}, - { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "NURBS3DFiniteElement_CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "NURBS3DFiniteElement_CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "NURBS3DFiniteElement_CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "NURBS3DFiniteElement_CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "NURBS3DFiniteElement_CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "NURBS3DFiniteElement_CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -48518,13 +48069,13 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "BasisType_Check", _wrap_BasisType_Check, METH_O, "Check(int b_type) -> int"}, - { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "CheckNodal(int b_type) -> int"}, - { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "GetQuadrature1D(int b_type) -> int"}, - { "BasisType_GetNodalBasis", _wrap_BasisType_GetNodalBasis, METH_O, "GetNodalBasis(int qpt_type) -> int"}, - { "BasisType_Name", _wrap_BasisType_Name, METH_O, "Name(int b_type) -> char const *"}, - { "BasisType_GetChar", _wrap_BasisType_GetChar, METH_O, "GetChar(int b_type) -> char"}, - { "BasisType_GetType", _wrap_BasisType_GetType, METH_O, "GetType(char b_ident) -> int"}, + { "BasisType_Check", (PyCFunction)(void(*)(void))_wrap_BasisType_Check, METH_VARARGS|METH_KEYWORDS, "Check(int b_type) -> int"}, + { "BasisType_CheckNodal", (PyCFunction)(void(*)(void))_wrap_BasisType_CheckNodal, METH_VARARGS|METH_KEYWORDS, "CheckNodal(int b_type) -> int"}, + { "BasisType_GetQuadrature1D", (PyCFunction)(void(*)(void))_wrap_BasisType_GetQuadrature1D, METH_VARARGS|METH_KEYWORDS, "GetQuadrature1D(int b_type) -> int"}, + { "BasisType_GetNodalBasis", (PyCFunction)(void(*)(void))_wrap_BasisType_GetNodalBasis, METH_VARARGS|METH_KEYWORDS, "GetNodalBasis(int qpt_type) -> int"}, + { "BasisType_Name", (PyCFunction)(void(*)(void))_wrap_BasisType_Name, METH_VARARGS|METH_KEYWORDS, "Name(int b_type) -> char const *"}, + { "BasisType_GetChar", (PyCFunction)(void(*)(void))_wrap_BasisType_GetChar, METH_VARARGS|METH_KEYWORDS, "GetChar(int b_type) -> char"}, + { "BasisType_GetType", (PyCFunction)(void(*)(void))_wrap_BasisType_GetType, METH_VARARGS|METH_KEYWORDS, "GetType(char b_ident) -> int"}, { "new_BasisType", _wrap_new_BasisType, METH_NOARGS, "new_BasisType() -> BasisType"}, { "delete_BasisType", _wrap_delete_BasisType, METH_O, "delete_BasisType(BasisType self)"}, { "BasisType_swigregister", BasisType_swigregister, METH_O, NULL}, @@ -48565,67 +48116,67 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FiniteElement_GetMapType", _wrap_FiniteElement_GetMapType, METH_O, "GetMapType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivType", _wrap_FiniteElement_GetDerivType, METH_O, "GetDerivType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivMapType", _wrap_FiniteElement_GetDerivMapType, METH_O, "GetDerivMapType(FiniteElement self) -> int"}, - { "FiniteElement_CalcShape", _wrap_FiniteElement_CalcShape, METH_VARARGS, "CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "FiniteElement_CalcPhysShape", _wrap_FiniteElement_CalcPhysShape, METH_VARARGS, "CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, - { "FiniteElement_CalcDShape", _wrap_FiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "FiniteElement_CalcPhysDShape", _wrap_FiniteElement_CalcPhysDShape, METH_VARARGS, "CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, + { "FiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "FiniteElement_CalcPhysShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, + { "FiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "FiniteElement_CalcPhysDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, { "FiniteElement_GetNodes", _wrap_FiniteElement_GetNodes, METH_O, "GetNodes(FiniteElement self) -> IntegrationRule"}, { "FiniteElement_CalcVShape", _wrap_FiniteElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(FiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "FiniteElement_CalcPhysVShape", _wrap_FiniteElement_CalcPhysVShape, METH_VARARGS, "CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, - { "FiniteElement_CalcDivShape", _wrap_FiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "FiniteElement_CalcPhysDivShape", _wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS, "CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, - { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, - { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, - { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_ProjectMatrixCoefficient", _wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, - { "FiniteElement_ProjectDelta", _wrap_FiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, + { "FiniteElement_CalcPhysVShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysVShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, + { "FiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "FiniteElement_CalcPhysDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, + { "FiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "FiniteElement_CalcPhysCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, + { "FiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "FiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysHessian, METH_VARARGS|METH_KEYWORDS, "CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS|METH_KEYWORDS, "CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS|METH_KEYWORDS, "CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "FiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "FiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, { "FiniteElement_Project", _wrap_FiniteElement_Project, METH_VARARGS, "\n" "Project(FiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(FiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "FiniteElement_ProjectGrad", _wrap_FiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "FiniteElement_ProjectCurl", _wrap_FiniteElement_ProjectCurl, METH_VARARGS, "ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, - { "FiniteElement_ProjectDiv", _wrap_FiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, - { "FiniteElement_GetDofToQuad", _wrap_FiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "FiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "FiniteElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "FiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "FiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_FiniteElement", _wrap_delete_FiniteElement, METH_O, "delete_FiniteElement(FiniteElement self)"}, - { "FiniteElement_IsClosedType", _wrap_FiniteElement_IsClosedType, METH_O, "IsClosedType(int b_type) -> bool"}, - { "FiniteElement_IsOpenType", _wrap_FiniteElement_IsOpenType, METH_O, "IsOpenType(int b_type) -> bool"}, - { "FiniteElement_VerifyClosed", _wrap_FiniteElement_VerifyClosed, METH_O, "VerifyClosed(int b_type) -> int"}, - { "FiniteElement_VerifyOpen", _wrap_FiniteElement_VerifyOpen, METH_O, "VerifyOpen(int b_type) -> int"}, - { "FiniteElement_VerifyNodal", _wrap_FiniteElement_VerifyNodal, METH_O, "VerifyNodal(int b_type) -> int"}, + { "FiniteElement_IsClosedType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsClosedType, METH_VARARGS|METH_KEYWORDS, "IsClosedType(int b_type) -> bool"}, + { "FiniteElement_IsOpenType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsOpenType, METH_VARARGS|METH_KEYWORDS, "IsOpenType(int b_type) -> bool"}, + { "FiniteElement_VerifyClosed", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyClosed, METH_VARARGS|METH_KEYWORDS, "VerifyClosed(int b_type) -> int"}, + { "FiniteElement_VerifyOpen", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyOpen, METH_VARARGS|METH_KEYWORDS, "VerifyOpen(int b_type) -> int"}, + { "FiniteElement_VerifyNodal", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyNodal, METH_VARARGS|METH_KEYWORDS, "VerifyNodal(int b_type) -> int"}, { "FiniteElement_swigregister", FiniteElement_swigregister, METH_O, NULL}, - { "ScalarFiniteElement_SetMapType", _wrap_ScalarFiniteElement_SetMapType, METH_VARARGS, "SetMapType(ScalarFiniteElement self, int M)"}, - { "ScalarFiniteElement_NodalLocalInterpolation", _wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS, "NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_ScalarLocalInterpolation", _wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS, "ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_GetDofToQuad", _wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "ScalarFiniteElement_SetMapType", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_SetMapType, METH_VARARGS|METH_KEYWORDS, "SetMapType(ScalarFiniteElement self, int M)"}, + { "ScalarFiniteElement_NodalLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_ScalarLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_ScalarFiniteElement", _wrap_delete_ScalarFiniteElement, METH_O, "delete_ScalarFiniteElement(ScalarFiniteElement self)"}, { "ScalarFiniteElement_swigregister", ScalarFiniteElement_swigregister, METH_O, NULL}, - { "NodalFiniteElement_GetLocalInterpolation", _wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_GetLocalRestriction", _wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "NodalFiniteElement_GetTransferMatrix", _wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_ProjectMatrixCoefficient", _wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "NodalFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "NodalFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "NodalFiniteElement_Project", _wrap_NodalFiniteElement_Project, METH_VARARGS, "\n" "Project(NodalFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(NodalFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "NodalFiniteElement_ProjectGrad", _wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "NodalFiniteElement_ProjectDiv", _wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "NodalFiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "NodalFiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, { "delete_NodalFiniteElement", _wrap_delete_NodalFiniteElement, METH_O, "delete_NodalFiniteElement(NodalFiniteElement self)"}, { "NodalFiniteElement_swigregister", NodalFiniteElement_swigregister, METH_O, NULL}, - { "PositiveFiniteElement_GetLocalInterpolation", _wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "PositiveFiniteElement_GetTransferMatrix", _wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "PositiveFiniteElement_Project", _wrap_PositiveFiniteElement_Project, METH_VARARGS, "\n" "Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48636,95 +48187,95 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_PositiveFiniteElement", _wrap_delete_PositiveFiniteElement, METH_O, "delete_PositiveFiniteElement(PositiveFiniteElement self)"}, { "PositiveFiniteElement_swigregister", PositiveFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorFiniteElement", _wrap_new_VectorFiniteElement, METH_VARARGS, "VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk)"}, + { "new_VectorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk) -> VectorFiniteElement"}, { "delete_VectorFiniteElement", _wrap_delete_VectorFiniteElement, METH_O, "delete_VectorFiniteElement(VectorFiniteElement self)"}, { "VectorFiniteElement_swigregister", VectorFiniteElement_swigregister, METH_O, NULL}, { "VectorFiniteElement_swiginit", VectorFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_PointFiniteElement", _wrap_new_PointFiniteElement, METH_NOARGS, "new_PointFiniteElement() -> PointFiniteElement"}, - { "PointFiniteElement_CalcShape", _wrap_PointFiniteElement_CalcShape, METH_VARARGS, "CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "PointFiniteElement_CalcDShape", _wrap_PointFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "PointFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "PointFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_PointFiniteElement", _wrap_delete_PointFiniteElement, METH_O, "delete_PointFiniteElement(PointFiniteElement self)"}, { "PointFiniteElement_swigregister", PointFiniteElement_swigregister, METH_O, NULL}, { "PointFiniteElement_swiginit", PointFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear1DFiniteElement", _wrap_new_Linear1DFiniteElement, METH_NOARGS, "new_Linear1DFiniteElement() -> Linear1DFiniteElement"}, - { "Linear1DFiniteElement_CalcShape", _wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear1DFiniteElement_CalcDShape", _wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Linear1DFiniteElement", _wrap_delete_Linear1DFiniteElement, METH_O, "delete_Linear1DFiniteElement(Linear1DFiniteElement self)"}, { "Linear1DFiniteElement_swigregister", Linear1DFiniteElement_swigregister, METH_O, NULL}, { "Linear1DFiniteElement_swiginit", Linear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear2DFiniteElement", _wrap_new_Linear2DFiniteElement, METH_NOARGS, "new_Linear2DFiniteElement() -> Linear2DFiniteElement"}, - { "Linear2DFiniteElement_CalcShape", _wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear2DFiniteElement_CalcDShape", _wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear2DFiniteElement_ProjectDelta", _wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Linear2DFiniteElement", _wrap_delete_Linear2DFiniteElement, METH_O, "delete_Linear2DFiniteElement(Linear2DFiniteElement self)"}, { "Linear2DFiniteElement_swigregister", Linear2DFiniteElement_swigregister, METH_O, NULL}, { "Linear2DFiniteElement_swiginit", Linear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiLinear2DFiniteElement", _wrap_new_BiLinear2DFiniteElement, METH_NOARGS, "new_BiLinear2DFiniteElement() -> BiLinear2DFiniteElement"}, - { "BiLinear2DFiniteElement_CalcShape", _wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiLinear2DFiniteElement_CalcDShape", _wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiLinear2DFiniteElement_CalcHessian", _wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "BiLinear2DFiniteElement_ProjectDelta", _wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiLinear2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiLinear2DFiniteElement", _wrap_delete_BiLinear2DFiniteElement, METH_O, "delete_BiLinear2DFiniteElement(BiLinear2DFiniteElement self)"}, { "BiLinear2DFiniteElement_swigregister", BiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "BiLinear2DFiniteElement_swiginit", BiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussLinear2DFiniteElement", _wrap_new_GaussLinear2DFiniteElement, METH_NOARGS, "new_GaussLinear2DFiniteElement() -> GaussLinear2DFiniteElement"}, - { "GaussLinear2DFiniteElement_CalcShape", _wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussLinear2DFiniteElement_CalcDShape", _wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussLinear2DFiniteElement_ProjectDelta", _wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussLinear2DFiniteElement", _wrap_delete_GaussLinear2DFiniteElement, METH_O, "delete_GaussLinear2DFiniteElement(GaussLinear2DFiniteElement self)"}, { "GaussLinear2DFiniteElement_swigregister", GaussLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussLinear2DFiniteElement_swiginit", GaussLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiLinear2DFiniteElement", _wrap_new_GaussBiLinear2DFiniteElement, METH_NOARGS, "new_GaussBiLinear2DFiniteElement() -> GaussBiLinear2DFiniteElement"}, - { "GaussBiLinear2DFiniteElement_CalcShape", _wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiLinear2DFiniteElement_CalcDShape", _wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussBiLinear2DFiniteElement_ProjectDelta", _wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussBiLinear2DFiniteElement", _wrap_delete_GaussBiLinear2DFiniteElement, METH_O, "delete_GaussBiLinear2DFiniteElement(GaussBiLinear2DFiniteElement self)"}, { "GaussBiLinear2DFiniteElement_swigregister", GaussBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiLinear2DFiniteElement_swiginit", GaussBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFiniteElement", _wrap_new_P1OnQuadFiniteElement, METH_NOARGS, "new_P1OnQuadFiniteElement() -> P1OnQuadFiniteElement"}, - { "P1OnQuadFiniteElement_CalcShape", _wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1OnQuadFiniteElement_CalcDShape", _wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P1OnQuadFiniteElement_ProjectDelta", _wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, + { "P1OnQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1OnQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1OnQuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P1OnQuadFiniteElement", _wrap_delete_P1OnQuadFiniteElement, METH_O, "delete_P1OnQuadFiniteElement(P1OnQuadFiniteElement self)"}, { "P1OnQuadFiniteElement_swigregister", P1OnQuadFiniteElement_swigregister, METH_O, NULL}, { "P1OnQuadFiniteElement_swiginit", P1OnQuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad1DFiniteElement", _wrap_new_Quad1DFiniteElement, METH_NOARGS, "new_Quad1DFiniteElement() -> Quad1DFiniteElement"}, - { "Quad1DFiniteElement_CalcShape", _wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad1DFiniteElement_CalcDShape", _wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quad1DFiniteElement", _wrap_delete_Quad1DFiniteElement, METH_O, "delete_Quad1DFiniteElement(Quad1DFiniteElement self)"}, { "Quad1DFiniteElement_swigregister", Quad1DFiniteElement_swigregister, METH_O, NULL}, { "Quad1DFiniteElement_swiginit", Quad1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_QuadPos1DFiniteElement", _wrap_new_QuadPos1DFiniteElement, METH_NOARGS, "new_QuadPos1DFiniteElement() -> QuadPos1DFiniteElement"}, - { "QuadPos1DFiniteElement_CalcShape", _wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "QuadPos1DFiniteElement_CalcDShape", _wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "QuadPos1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "QuadPos1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_QuadPos1DFiniteElement", _wrap_delete_QuadPos1DFiniteElement, METH_O, "delete_QuadPos1DFiniteElement(QuadPos1DFiniteElement self)"}, { "QuadPos1DFiniteElement_swigregister", QuadPos1DFiniteElement_swigregister, METH_O, NULL}, { "QuadPos1DFiniteElement_swiginit", QuadPos1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad2DFiniteElement", _wrap_new_Quad2DFiniteElement, METH_NOARGS, "new_Quad2DFiniteElement() -> Quad2DFiniteElement"}, - { "Quad2DFiniteElement_CalcShape", _wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad2DFiniteElement_CalcDShape", _wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Quad2DFiniteElement_CalcHessian", _wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "Quad2DFiniteElement_ProjectDelta", _wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, + { "Quad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Quad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Quad2DFiniteElement", _wrap_delete_Quad2DFiniteElement, METH_O, "delete_Quad2DFiniteElement(Quad2DFiniteElement self)"}, { "Quad2DFiniteElement_swigregister", Quad2DFiniteElement_swigregister, METH_O, NULL}, { "Quad2DFiniteElement_swiginit", Quad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussQuad2DFiniteElement", _wrap_new_GaussQuad2DFiniteElement, METH_NOARGS, "new_GaussQuad2DFiniteElement() -> GaussQuad2DFiniteElement"}, - { "GaussQuad2DFiniteElement_CalcShape", _wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussQuad2DFiniteElement_CalcDShape", _wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussQuad2DFiniteElement", _wrap_delete_GaussQuad2DFiniteElement, METH_O, "delete_GaussQuad2DFiniteElement(GaussQuad2DFiniteElement self)"}, { "GaussQuad2DFiniteElement_swigregister", GaussQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussQuad2DFiniteElement_swiginit", GaussQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuad2DFiniteElement", _wrap_new_BiQuad2DFiniteElement, METH_NOARGS, "new_BiQuad2DFiniteElement() -> BiQuad2DFiniteElement"}, - { "BiQuad2DFiniteElement_CalcShape", _wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuad2DFiniteElement_CalcDShape", _wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuad2DFiniteElement_ProjectDelta", _wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuad2DFiniteElement", _wrap_delete_BiQuad2DFiniteElement, METH_O, "delete_BiQuad2DFiniteElement(BiQuad2DFiniteElement self)"}, { "BiQuad2DFiniteElement_swigregister", BiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuad2DFiniteElement_swiginit", BiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuadPos2DFiniteElement", _wrap_new_BiQuadPos2DFiniteElement, METH_NOARGS, "new_BiQuadPos2DFiniteElement() -> BiQuadPos2DFiniteElement"}, - { "BiQuadPos2DFiniteElement_CalcShape", _wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuadPos2DFiniteElement_CalcDShape", _wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuadPos2DFiniteElement_GetLocalInterpolation", _wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "BiQuadPos2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuadPos2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuadPos2DFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "BiQuadPos2DFiniteElement_Project", _wrap_BiQuadPos2DFiniteElement_Project, METH_VARARGS, "\n" "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48732,93 +48283,93 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" ""}, - { "BiQuadPos2DFiniteElement_ProjectDelta", _wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuadPos2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuadPos2DFiniteElement", _wrap_delete_BiQuadPos2DFiniteElement, METH_O, "delete_BiQuadPos2DFiniteElement(BiQuadPos2DFiniteElement self)"}, { "BiQuadPos2DFiniteElement_swigregister", BiQuadPos2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuadPos2DFiniteElement_swiginit", BiQuadPos2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiQuad2DFiniteElement", _wrap_new_GaussBiQuad2DFiniteElement, METH_NOARGS, "new_GaussBiQuad2DFiniteElement() -> GaussBiQuad2DFiniteElement"}, - { "GaussBiQuad2DFiniteElement_CalcShape", _wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiQuad2DFiniteElement_CalcDShape", _wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussBiQuad2DFiniteElement", _wrap_delete_GaussBiQuad2DFiniteElement, METH_O, "delete_GaussBiQuad2DFiniteElement(GaussBiQuad2DFiniteElement self)"}, { "GaussBiQuad2DFiniteElement_swigregister", GaussBiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiQuad2DFiniteElement_swiginit", GaussBiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiCubic2DFiniteElement", _wrap_new_BiCubic2DFiniteElement, METH_NOARGS, "new_BiCubic2DFiniteElement() -> BiCubic2DFiniteElement"}, - { "BiCubic2DFiniteElement_CalcShape", _wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiCubic2DFiniteElement_CalcDShape", _wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiCubic2DFiniteElement_CalcHessian", _wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiCubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiCubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiCubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_BiCubic2DFiniteElement", _wrap_delete_BiCubic2DFiniteElement, METH_O, "delete_BiCubic2DFiniteElement(BiCubic2DFiniteElement self)"}, { "BiCubic2DFiniteElement_swigregister", BiCubic2DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic2DFiniteElement_swiginit", BiCubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic1DFiniteElement", _wrap_new_Cubic1DFiniteElement, METH_NOARGS, "new_Cubic1DFiniteElement() -> Cubic1DFiniteElement"}, - { "Cubic1DFiniteElement_CalcShape", _wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic1DFiniteElement_CalcDShape", _wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic1DFiniteElement", _wrap_delete_Cubic1DFiniteElement, METH_O, "delete_Cubic1DFiniteElement(Cubic1DFiniteElement self)"}, { "Cubic1DFiniteElement_swigregister", Cubic1DFiniteElement_swigregister, METH_O, NULL}, { "Cubic1DFiniteElement_swiginit", Cubic1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic2DFiniteElement", _wrap_new_Cubic2DFiniteElement, METH_NOARGS, "new_Cubic2DFiniteElement() -> Cubic2DFiniteElement"}, - { "Cubic2DFiniteElement_CalcShape", _wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic2DFiniteElement_CalcDShape", _wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Cubic2DFiniteElement_CalcHessian", _wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Cubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_Cubic2DFiniteElement", _wrap_delete_Cubic2DFiniteElement, METH_O, "delete_Cubic2DFiniteElement(Cubic2DFiniteElement self)"}, { "Cubic2DFiniteElement_swigregister", Cubic2DFiniteElement_swigregister, METH_O, NULL}, { "Cubic2DFiniteElement_swiginit", Cubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic3DFiniteElement", _wrap_new_Cubic3DFiniteElement, METH_NOARGS, "new_Cubic3DFiniteElement() -> Cubic3DFiniteElement"}, - { "Cubic3DFiniteElement_CalcShape", _wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic3DFiniteElement_CalcDShape", _wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic3DFiniteElement", _wrap_delete_Cubic3DFiniteElement, METH_O, "delete_Cubic3DFiniteElement(Cubic3DFiniteElement self)"}, { "Cubic3DFiniteElement_swigregister", Cubic3DFiniteElement_swigregister, METH_O, NULL}, { "Cubic3DFiniteElement_swiginit", Cubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TriangleFiniteElement", _wrap_new_P0TriangleFiniteElement, METH_NOARGS, "new_P0TriangleFiniteElement() -> P0TriangleFiniteElement"}, - { "P0TriangleFiniteElement_CalcShape", _wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TriangleFiniteElement_CalcDShape", _wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TriangleFiniteElement_ProjectDelta", _wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, + { "P0TriangleFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TriangleFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TriangleFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TriangleFiniteElement", _wrap_delete_P0TriangleFiniteElement, METH_O, "delete_P0TriangleFiniteElement(P0TriangleFiniteElement self)"}, { "P0TriangleFiniteElement_swigregister", P0TriangleFiniteElement_swigregister, METH_O, NULL}, { "P0TriangleFiniteElement_swiginit", P0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0QuadFiniteElement", _wrap_new_P0QuadFiniteElement, METH_NOARGS, "new_P0QuadFiniteElement() -> P0QuadFiniteElement"}, - { "P0QuadFiniteElement_CalcShape", _wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0QuadFiniteElement_CalcDShape", _wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0QuadFiniteElement_ProjectDelta", _wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, + { "P0QuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0QuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0QuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0QuadFiniteElement", _wrap_delete_P0QuadFiniteElement, METH_O, "delete_P0QuadFiniteElement(P0QuadFiniteElement self)"}, { "P0QuadFiniteElement_swigregister", P0QuadFiniteElement_swigregister, METH_O, NULL}, { "P0QuadFiniteElement_swiginit", P0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear3DFiniteElement", _wrap_new_Linear3DFiniteElement, METH_NOARGS, "new_Linear3DFiniteElement() -> Linear3DFiniteElement"}, - { "Linear3DFiniteElement_CalcShape", _wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear3DFiniteElement_CalcDShape", _wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear3DFiniteElement_ProjectDelta", _wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, - { "Linear3DFiniteElement_GetFaceDofs", _wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "Linear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear3DFiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, { "delete_Linear3DFiniteElement", _wrap_delete_Linear3DFiniteElement, METH_O, "delete_Linear3DFiniteElement(Linear3DFiniteElement self)"}, { "Linear3DFiniteElement_swigregister", Linear3DFiniteElement_swigregister, METH_O, NULL}, { "Linear3DFiniteElement_swiginit", Linear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quadratic3DFiniteElement", _wrap_new_Quadratic3DFiniteElement, METH_NOARGS, "new_Quadratic3DFiniteElement() -> Quadratic3DFiniteElement"}, - { "Quadratic3DFiniteElement_CalcShape", _wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quadratic3DFiniteElement_CalcDShape", _wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quadratic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quadratic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quadratic3DFiniteElement", _wrap_delete_Quadratic3DFiniteElement, METH_O, "delete_Quadratic3DFiniteElement(Quadratic3DFiniteElement self)"}, { "Quadratic3DFiniteElement_swigregister", Quadratic3DFiniteElement_swigregister, METH_O, NULL}, { "Quadratic3DFiniteElement_swiginit", Quadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_TriLinear3DFiniteElement", _wrap_new_TriLinear3DFiniteElement, METH_NOARGS, "new_TriLinear3DFiniteElement() -> TriLinear3DFiniteElement"}, - { "TriLinear3DFiniteElement_CalcShape", _wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "TriLinear3DFiniteElement_CalcDShape", _wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "TriLinear3DFiniteElement_ProjectDelta", _wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, + { "TriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "TriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "TriLinear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, { "delete_TriLinear3DFiniteElement", _wrap_delete_TriLinear3DFiniteElement, METH_O, "delete_TriLinear3DFiniteElement(TriLinear3DFiniteElement self)"}, { "TriLinear3DFiniteElement_swigregister", TriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "TriLinear3DFiniteElement_swiginit", TriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFiniteElement", _wrap_new_CrouzeixRaviartFiniteElement, METH_NOARGS, "new_CrouzeixRaviartFiniteElement() -> CrouzeixRaviartFiniteElement"}, - { "CrouzeixRaviartFiniteElement_CalcShape", _wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartFiniteElement_CalcDShape", _wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "CrouzeixRaviartFiniteElement_ProjectDelta", _wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, + { "CrouzeixRaviartFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, { "delete_CrouzeixRaviartFiniteElement", _wrap_delete_CrouzeixRaviartFiniteElement, METH_O, "delete_CrouzeixRaviartFiniteElement(CrouzeixRaviartFiniteElement self)"}, { "CrouzeixRaviartFiniteElement_swigregister", CrouzeixRaviartFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartFiniteElement_swiginit", CrouzeixRaviartFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartQuadFiniteElement", _wrap_new_CrouzeixRaviartQuadFiniteElement, METH_NOARGS, "new_CrouzeixRaviartQuadFiniteElement() -> CrouzeixRaviartQuadFiniteElement"}, - { "CrouzeixRaviartQuadFiniteElement_CalcShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartQuadFiniteElement_CalcDShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_CrouzeixRaviartQuadFiniteElement", _wrap_delete_CrouzeixRaviartQuadFiniteElement, METH_O, "delete_CrouzeixRaviartQuadFiniteElement(CrouzeixRaviartQuadFiniteElement self)"}, { "CrouzeixRaviartQuadFiniteElement_swigregister", CrouzeixRaviartQuadFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartQuadFiniteElement_swiginit", CrouzeixRaviartQuadFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_P0SegmentFiniteElement", _wrap_new_P0SegmentFiniteElement, METH_VARARGS, "P0SegmentFiniteElement(int Ord=0)"}, - { "P0SegmentFiniteElement_CalcShape", _wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0SegmentFiniteElement_CalcDShape", _wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_P0SegmentFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_P0SegmentFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_P0SegmentFiniteElement(int Ord=0) -> P0SegmentFiniteElement"}, + { "P0SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P0SegmentFiniteElement", _wrap_delete_P0SegmentFiniteElement, METH_O, "delete_P0SegmentFiniteElement(P0SegmentFiniteElement self)"}, { "P0SegmentFiniteElement_swigregister", P0SegmentFiniteElement_swigregister, METH_O, NULL}, { "P0SegmentFiniteElement_swiginit", P0SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -48827,8 +48378,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TriangleFiniteElement_CalcDivShape", _wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TriangleFiniteElement_GetLocalInterpolation", _wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TriangleFiniteElement_Project", _wrap_RT0TriangleFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48843,8 +48394,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0QuadFiniteElement_CalcDivShape", _wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0QuadFiniteElement_GetLocalInterpolation", _wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0QuadFiniteElement_Project", _wrap_RT0QuadFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48859,8 +48410,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT1TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1TriangleFiniteElement_CalcDivShape", _wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1TriangleFiniteElement_GetLocalInterpolation", _wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1TriangleFiniteElement_Project", _wrap_RT1TriangleFiniteElement_Project, METH_VARARGS, "\n" "Project(RT1TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48875,8 +48426,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT1QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1QuadFiniteElement_CalcDivShape", _wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1QuadFiniteElement_GetLocalInterpolation", _wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1QuadFiniteElement_Project", _wrap_RT1QuadFiniteElement_Project, METH_VARARGS, "\n" "Project(RT1QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48891,7 +48442,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT2TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2TriangleFiniteElement_CalcDivShape", _wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, { "delete_RT2TriangleFiniteElement", _wrap_delete_RT2TriangleFiniteElement, METH_O, "delete_RT2TriangleFiniteElement(RT2TriangleFiniteElement self)"}, { "RT2TriangleFiniteElement_swigregister", RT2TriangleFiniteElement_swigregister, METH_O, NULL}, { "RT2TriangleFiniteElement_swiginit", RT2TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -48900,8 +48451,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT2QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2QuadFiniteElement_CalcDivShape", _wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT2QuadFiniteElement_GetLocalInterpolation", _wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT2QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT2QuadFiniteElement_Project", _wrap_RT2QuadFiniteElement_Project, METH_VARARGS, "\n" "Project(RT2QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -48912,76 +48463,76 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "RT2QuadFiniteElement_swigregister", RT2QuadFiniteElement_swigregister, METH_O, NULL}, { "RT2QuadFiniteElement_swiginit", RT2QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1SegmentFiniteElement", _wrap_new_P1SegmentFiniteElement, METH_NOARGS, "new_P1SegmentFiniteElement() -> P1SegmentFiniteElement"}, - { "P1SegmentFiniteElement_CalcShape", _wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1SegmentFiniteElement_CalcDShape", _wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1SegmentFiniteElement", _wrap_delete_P1SegmentFiniteElement, METH_O, "delete_P1SegmentFiniteElement(P1SegmentFiniteElement self)"}, { "P1SegmentFiniteElement_swigregister", P1SegmentFiniteElement_swigregister, METH_O, NULL}, { "P1SegmentFiniteElement_swiginit", P1SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P2SegmentFiniteElement", _wrap_new_P2SegmentFiniteElement, METH_NOARGS, "new_P2SegmentFiniteElement() -> P2SegmentFiniteElement"}, - { "P2SegmentFiniteElement_CalcShape", _wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P2SegmentFiniteElement_CalcDShape", _wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P2SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P2SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P2SegmentFiniteElement", _wrap_delete_P2SegmentFiniteElement, METH_O, "delete_P2SegmentFiniteElement(P2SegmentFiniteElement self)"}, { "P2SegmentFiniteElement_swigregister", P2SegmentFiniteElement_swigregister, METH_O, NULL}, { "P2SegmentFiniteElement_swiginit", P2SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_Lagrange1DFiniteElement", _wrap_new_Lagrange1DFiniteElement, METH_O, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, - { "Lagrange1DFiniteElement_CalcShape", _wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Lagrange1DFiniteElement_CalcDShape", _wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_Lagrange1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_Lagrange1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, + { "Lagrange1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Lagrange1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Lagrange1DFiniteElement", _wrap_delete_Lagrange1DFiniteElement, METH_O, "delete_Lagrange1DFiniteElement(Lagrange1DFiniteElement self)"}, { "Lagrange1DFiniteElement_swigregister", Lagrange1DFiniteElement_swigregister, METH_O, NULL}, { "Lagrange1DFiniteElement_swiginit", Lagrange1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1TetNonConfFiniteElement", _wrap_new_P1TetNonConfFiniteElement, METH_NOARGS, "new_P1TetNonConfFiniteElement() -> P1TetNonConfFiniteElement"}, - { "P1TetNonConfFiniteElement_CalcShape", _wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1TetNonConfFiniteElement_CalcDShape", _wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1TetNonConfFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1TetNonConfFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1TetNonConfFiniteElement", _wrap_delete_P1TetNonConfFiniteElement, METH_O, "delete_P1TetNonConfFiniteElement(P1TetNonConfFiniteElement self)"}, { "P1TetNonConfFiniteElement_swigregister", P1TetNonConfFiniteElement_swigregister, METH_O, NULL}, { "P1TetNonConfFiniteElement_swiginit", P1TetNonConfFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TetFiniteElement", _wrap_new_P0TetFiniteElement, METH_NOARGS, "new_P0TetFiniteElement() -> P0TetFiniteElement"}, - { "P0TetFiniteElement_CalcShape", _wrap_P0TetFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TetFiniteElement_CalcDShape", _wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TetFiniteElement_ProjectDelta", _wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, + { "P0TetFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TetFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TetFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TetFiniteElement", _wrap_delete_P0TetFiniteElement, METH_O, "delete_P0TetFiniteElement(P0TetFiniteElement self)"}, { "P0TetFiniteElement_swigregister", P0TetFiniteElement_swigregister, METH_O, NULL}, { "P0TetFiniteElement_swiginit", P0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0HexFiniteElement", _wrap_new_P0HexFiniteElement, METH_NOARGS, "new_P0HexFiniteElement() -> P0HexFiniteElement"}, - { "P0HexFiniteElement_CalcShape", _wrap_P0HexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0HexFiniteElement_CalcDShape", _wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0HexFiniteElement_ProjectDelta", _wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, + { "P0HexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0HexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0HexFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0HexFiniteElement", _wrap_delete_P0HexFiniteElement, METH_O, "delete_P0HexFiniteElement(P0HexFiniteElement self)"}, { "P0HexFiniteElement_swigregister", P0HexFiniteElement_swigregister, METH_O, NULL}, { "P0HexFiniteElement_swiginit", P0HexFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_LagrangeHexFiniteElement", _wrap_new_LagrangeHexFiniteElement, METH_O, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, - { "LagrangeHexFiniteElement_CalcShape", _wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "LagrangeHexFiniteElement_CalcDShape", _wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_LagrangeHexFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_LagrangeHexFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, + { "LagrangeHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "LagrangeHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_LagrangeHexFiniteElement", _wrap_delete_LagrangeHexFiniteElement, METH_O, "delete_LagrangeHexFiniteElement(LagrangeHexFiniteElement self)"}, { "LagrangeHexFiniteElement_swigregister", LagrangeHexFiniteElement_swigregister, METH_O, NULL}, { "LagrangeHexFiniteElement_swiginit", LagrangeHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear1DFiniteElement", _wrap_new_RefinedLinear1DFiniteElement, METH_NOARGS, "new_RefinedLinear1DFiniteElement() -> RefinedLinear1DFiniteElement"}, - { "RefinedLinear1DFiniteElement_CalcShape", _wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear1DFiniteElement_CalcDShape", _wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear1DFiniteElement", _wrap_delete_RefinedLinear1DFiniteElement, METH_O, "delete_RefinedLinear1DFiniteElement(RefinedLinear1DFiniteElement self)"}, { "RefinedLinear1DFiniteElement_swigregister", RefinedLinear1DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear1DFiniteElement_swiginit", RefinedLinear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear2DFiniteElement", _wrap_new_RefinedLinear2DFiniteElement, METH_NOARGS, "new_RefinedLinear2DFiniteElement() -> RefinedLinear2DFiniteElement"}, - { "RefinedLinear2DFiniteElement_CalcShape", _wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear2DFiniteElement_CalcDShape", _wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear2DFiniteElement", _wrap_delete_RefinedLinear2DFiniteElement, METH_O, "delete_RefinedLinear2DFiniteElement(RefinedLinear2DFiniteElement self)"}, { "RefinedLinear2DFiniteElement_swigregister", RefinedLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear2DFiniteElement_swiginit", RefinedLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear3DFiniteElement", _wrap_new_RefinedLinear3DFiniteElement, METH_NOARGS, "new_RefinedLinear3DFiniteElement() -> RefinedLinear3DFiniteElement"}, - { "RefinedLinear3DFiniteElement_CalcShape", _wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear3DFiniteElement_CalcDShape", _wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear3DFiniteElement", _wrap_delete_RefinedLinear3DFiniteElement, METH_O, "delete_RefinedLinear3DFiniteElement(RefinedLinear3DFiniteElement self)"}, { "RefinedLinear3DFiniteElement_swigregister", RefinedLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear3DFiniteElement_swiginit", RefinedLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedBiLinear2DFiniteElement", _wrap_new_RefinedBiLinear2DFiniteElement, METH_NOARGS, "new_RefinedBiLinear2DFiniteElement() -> RefinedBiLinear2DFiniteElement"}, - { "RefinedBiLinear2DFiniteElement_CalcShape", _wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedBiLinear2DFiniteElement_CalcDShape", _wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedBiLinear2DFiniteElement", _wrap_delete_RefinedBiLinear2DFiniteElement, METH_O, "delete_RefinedBiLinear2DFiniteElement(RefinedBiLinear2DFiniteElement self)"}, { "RefinedBiLinear2DFiniteElement_swigregister", RefinedBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedBiLinear2DFiniteElement_swiginit", RefinedBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedTriLinear3DFiniteElement", _wrap_new_RefinedTriLinear3DFiniteElement, METH_NOARGS, "new_RefinedTriLinear3DFiniteElement() -> RefinedTriLinear3DFiniteElement"}, - { "RefinedTriLinear3DFiniteElement_CalcShape", _wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedTriLinear3DFiniteElement_CalcDShape", _wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedTriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedTriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedTriLinear3DFiniteElement", _wrap_delete_RefinedTriLinear3DFiniteElement, METH_O, "delete_RefinedTriLinear3DFiniteElement(RefinedTriLinear3DFiniteElement self)"}, { "RefinedTriLinear3DFiniteElement_swigregister", RefinedTriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedTriLinear3DFiniteElement_swiginit", RefinedTriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -48990,8 +48541,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1HexFiniteElement_CalcCurlShape", _wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1HexFiniteElement_GetLocalInterpolation", _wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1HexFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1HexFiniteElement_Project", _wrap_Nedelec1HexFiniteElement_Project, METH_VARARGS, "\n" "Project(Nedelec1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49006,8 +48557,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1TetFiniteElement_CalcCurlShape", _wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1TetFiniteElement_GetLocalInterpolation", _wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1TetFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1TetFiniteElement_Project", _wrap_Nedelec1TetFiniteElement_Project, METH_VARARGS, "\n" "Project(Nedelec1TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49022,8 +48573,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0HexFiniteElement_CalcDivShape", _wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0HexFiniteElement_GetLocalInterpolation", _wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0HexFiniteElement_Project", _wrap_RT0HexFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49038,8 +48589,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1HexFiniteElement_CalcDivShape", _wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1HexFiniteElement_GetLocalInterpolation", _wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1HexFiniteElement_Project", _wrap_RT1HexFiniteElement_Project, METH_VARARGS, "\n" "Project(RT1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49054,8 +48605,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TetFiniteElement_CalcDivShape", _wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TetFiniteElement_GetLocalInterpolation", _wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TetFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TetFiniteElement_Project", _wrap_RT0TetFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49066,29 +48617,29 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "RT0TetFiniteElement_swigregister", RT0TetFiniteElement_swigregister, METH_O, NULL}, { "RT0TetFiniteElement_swiginit", RT0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RotTriLinearHexFiniteElement", _wrap_new_RotTriLinearHexFiniteElement, METH_NOARGS, "new_RotTriLinearHexFiniteElement() -> RotTriLinearHexFiniteElement"}, - { "RotTriLinearHexFiniteElement_CalcShape", _wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RotTriLinearHexFiniteElement_CalcDShape", _wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RotTriLinearHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RotTriLinearHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RotTriLinearHexFiniteElement", _wrap_delete_RotTriLinearHexFiniteElement, METH_O, "delete_RotTriLinearHexFiniteElement(RotTriLinearHexFiniteElement self)"}, { "RotTriLinearHexFiniteElement_swigregister", RotTriLinearHexFiniteElement_swigregister, METH_O, NULL}, { "RotTriLinearHexFiniteElement_swiginit", RotTriLinearHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Poly_1D", _wrap_new_Poly_1D, METH_NOARGS, "new_Poly_1D() -> Poly_1D"}, - { "Poly_1D_Binom", _wrap_Poly_1D_Binom, METH_O, "Binom(int const p) -> int const *"}, - { "Poly_1D_GetPoints", _wrap_Poly_1D_GetPoints, METH_VARARGS, "GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, - { "Poly_1D_OpenPoints", _wrap_Poly_1D_OpenPoints, METH_VARARGS, "OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const"}, - { "Poly_1D_ClosedPoints", _wrap_Poly_1D_ClosedPoints, METH_VARARGS, "ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const"}, - { "Poly_1D_GetBasis", _wrap_Poly_1D_GetBasis, METH_VARARGS, "GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, + { "Poly_1D_Binom", (PyCFunction)(void(*)(void))_wrap_Poly_1D_Binom, METH_VARARGS|METH_KEYWORDS, "Binom(int const p) -> int const *"}, + { "Poly_1D_GetPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetPoints, METH_VARARGS|METH_KEYWORDS, "GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, + { "Poly_1D_OpenPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_OpenPoints, METH_VARARGS|METH_KEYWORDS, "OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const *"}, + { "Poly_1D_ClosedPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ClosedPoints, METH_VARARGS|METH_KEYWORDS, "ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const *"}, + { "Poly_1D_GetBasis", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetBasis, METH_VARARGS|METH_KEYWORDS, "GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, { "Poly_1D_CalcBasis", _wrap_Poly_1D_CalcBasis, METH_VARARGS, "\n" "CalcBasis(int const p, double const x, double * u)\n" "CalcBasis(int const p, double const x, double * u, double * d)\n" "CalcBasis(int const p, double const x, double * u, double * d, double * dd)\n" ""}, - { "Poly_1D_CalcDelta", _wrap_Poly_1D_CalcDelta, METH_VARARGS, "CalcDelta(int const p, double const x) -> double"}, - { "Poly_1D_ChebyshevPoints", _wrap_Poly_1D_ChebyshevPoints, METH_VARARGS, "ChebyshevPoints(int const p, double * x)"}, + { "Poly_1D_CalcDelta", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDelta, METH_VARARGS|METH_KEYWORDS, "CalcDelta(int const p, double const x) -> double"}, + { "Poly_1D_ChebyshevPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ChebyshevPoints, METH_VARARGS|METH_KEYWORDS, "ChebyshevPoints(int const p, double * x)"}, { "Poly_1D_CalcBinomTerms", _wrap_Poly_1D_CalcBinomTerms, METH_VARARGS, "\n" "CalcBinomTerms(int const p, double const x, double const y, double * u)\n" "CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)\n" ""}, - { "Poly_1D_CalcDBinomTerms", _wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS, "CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, + { "Poly_1D_CalcDBinomTerms", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS|METH_KEYWORDS, "CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, { "Poly_1D_CalcBernstein", _wrap_Poly_1D_CalcBernstein, METH_VARARGS, "\n" "CalcBernstein(int const p, double const x, double * u)\n" "CalcBernstein(int const p, double const x, double * u, double * d)\n" @@ -49100,67 +48651,67 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, - { "new_TensorBasisElement", _wrap_new_TensorBasisElement, METH_VARARGS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, + { "new_TensorBasisElement", (PyCFunction)(void(*)(void))_wrap_new_TensorBasisElement, METH_VARARGS|METH_KEYWORDS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, { "TensorBasisElement_GetBasisType", _wrap_TensorBasisElement_GetBasisType, METH_O, "GetBasisType(TensorBasisElement self) -> int"}, { "TensorBasisElement_GetBasis1D", _wrap_TensorBasisElement_GetBasis1D, METH_O, "GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &"}, { "TensorBasisElement_GetDofMap", _wrap_TensorBasisElement_GetDofMap, METH_O, "GetDofMap(TensorBasisElement self) -> intArray"}, - { "TensorBasisElement_GetTensorProductGeometry", _wrap_TensorBasisElement_GetTensorProductGeometry, METH_O, "GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, - { "TensorBasisElement_Pow", _wrap_TensorBasisElement_Pow, METH_VARARGS, "Pow(int base, int dim) -> int"}, + { "TensorBasisElement_GetTensorProductGeometry", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_GetTensorProductGeometry, METH_VARARGS|METH_KEYWORDS, "GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, + { "TensorBasisElement_Pow", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_Pow, METH_VARARGS|METH_KEYWORDS, "Pow(int base, int dim) -> int"}, { "delete_TensorBasisElement", _wrap_delete_TensorBasisElement, METH_O, "delete_TensorBasisElement(TensorBasisElement self)"}, { "TensorBasisElement_swigregister", TensorBasisElement_swigregister, METH_O, NULL}, { "TensorBasisElement_swiginit", TensorBasisElement_swiginit, METH_VARARGS, NULL}, - { "NodalTensorFiniteElement_GetDofToQuad", _wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "NodalTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_NodalTensorFiniteElement", _wrap_delete_NodalTensorFiniteElement, METH_O, "delete_NodalTensorFiniteElement(NodalTensorFiniteElement self)"}, { "NodalTensorFiniteElement_swigregister", NodalTensorFiniteElement_swigregister, METH_O, NULL}, - { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "PositiveTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, - { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "new_VectorTensorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorTensorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS|METH_KEYWORDS, "GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, - { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_SegmentElement_ProjectDelta", _wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1_SegmentElement(int const p, int const btype=GaussLobatto) -> H1_SegmentElement"}, + { "H1_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1_SegmentElement", _wrap_delete_H1_SegmentElement, METH_O, "delete_H1_SegmentElement(H1_SegmentElement self)"}, { "H1_SegmentElement_swigregister", H1_SegmentElement_swigregister, METH_O, NULL}, { "H1_SegmentElement_swiginit", H1_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_QuadrilateralElement", _wrap_new_H1_QuadrilateralElement, METH_VARARGS, "H1_QuadrilateralElement(int const p, int const btype=GaussLobatto)"}, - { "H1_QuadrilateralElement_CalcShape", _wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_QuadrilateralElement_CalcDShape", _wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_QuadrilateralElement_ProjectDelta", _wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1_QuadrilateralElement(int const p, int const btype=GaussLobatto) -> H1_QuadrilateralElement"}, + { "H1_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1_QuadrilateralElement", _wrap_delete_H1_QuadrilateralElement, METH_O, "delete_H1_QuadrilateralElement(H1_QuadrilateralElement self)"}, { "H1_QuadrilateralElement_swigregister", H1_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1_QuadrilateralElement_swiginit", H1_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_HexahedronElement", _wrap_new_H1_HexahedronElement, METH_VARARGS, "H1_HexahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_HexahedronElement_CalcShape", _wrap_H1_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_HexahedronElement_CalcDShape", _wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_HexahedronElement_ProjectDelta", _wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_HexahedronElement(int const p, int const btype=GaussLobatto) -> H1_HexahedronElement"}, + { "H1_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1_HexahedronElement", _wrap_delete_H1_HexahedronElement, METH_O, "delete_H1_HexahedronElement(H1_HexahedronElement self)"}, { "H1_HexahedronElement_swigregister", H1_HexahedronElement_swigregister, METH_O, NULL}, { "H1_HexahedronElement_swiginit", H1_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_SegmentElement", _wrap_new_H1Pos_SegmentElement, METH_O, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, - { "H1Pos_SegmentElement_CalcShape", _wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_SegmentElement_CalcDShape", _wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_SegmentElement_ProjectDelta", _wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, + { "H1Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_SegmentElement", _wrap_delete_H1Pos_SegmentElement, METH_O, "delete_H1Pos_SegmentElement(H1Pos_SegmentElement self)"}, { "H1Pos_SegmentElement_swigregister", H1Pos_SegmentElement_swigregister, METH_O, NULL}, { "H1Pos_SegmentElement_swiginit", H1Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_QuadrilateralElement", _wrap_new_H1Pos_QuadrilateralElement, METH_O, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, - { "H1Pos_QuadrilateralElement_CalcShape", _wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_QuadrilateralElement_CalcDShape", _wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_QuadrilateralElement_ProjectDelta", _wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, + { "H1Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, - { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "new_H1Ser_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" "Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49169,28 +48720,28 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, - { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_HexahedronElement_ProjectDelta", _wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, + { "H1Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_HexahedronElement", _wrap_delete_H1Pos_HexahedronElement, METH_O, "delete_H1Pos_HexahedronElement(H1Pos_HexahedronElement self)"}, { "H1Pos_HexahedronElement_swigregister", H1Pos_HexahedronElement_swigregister, METH_O, NULL}, { "H1Pos_HexahedronElement_swiginit", H1Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TriangleElement", _wrap_new_H1_TriangleElement, METH_VARARGS, "H1_TriangleElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TriangleElement_CalcShape", _wrap_H1_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TriangleElement_CalcDShape", _wrap_H1_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TriangleElement_CalcHessian", _wrap_H1_TriangleElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TriangleElement(int const p, int const btype=GaussLobatto) -> H1_TriangleElement"}, + { "H1_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TriangleElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TriangleElement", _wrap_delete_H1_TriangleElement, METH_O, "delete_H1_TriangleElement(H1_TriangleElement self)"}, { "H1_TriangleElement_swigregister", H1_TriangleElement_swigregister, METH_O, NULL}, { "H1_TriangleElement_swiginit", H1_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TetrahedronElement", _wrap_new_H1_TetrahedronElement, METH_VARARGS, "H1_TetrahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TetrahedronElement_CalcShape", _wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TetrahedronElement_CalcDShape", _wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TetrahedronElement_CalcHessian", _wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TetrahedronElement(int const p, int const btype=GaussLobatto) -> H1_TetrahedronElement"}, + { "H1_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TetrahedronElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TetrahedronElement", _wrap_delete_H1_TetrahedronElement, METH_O, "delete_H1_TetrahedronElement(H1_TetrahedronElement self)"}, { "H1_TetrahedronElement_swigregister", H1_TetrahedronElement_swigregister, METH_O, NULL}, { "H1_TetrahedronElement_swiginit", H1_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TriangleElement", _wrap_new_H1Pos_TriangleElement, METH_O, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, + { "new_H1Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, { "H1Pos_TriangleElement_CalcShape", _wrap_H1Pos_TriangleElement_CalcShape, METH_VARARGS, "\n" "CalcShape(int const p, double const x, double const y, double * shape)\n" "CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -49202,7 +48753,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_H1Pos_TriangleElement", _wrap_delete_H1Pos_TriangleElement, METH_O, "delete_H1Pos_TriangleElement(H1Pos_TriangleElement self)"}, { "H1Pos_TriangleElement_swigregister", H1Pos_TriangleElement_swigregister, METH_O, NULL}, { "H1Pos_TriangleElement_swiginit", H1Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TetrahedronElement", _wrap_new_H1Pos_TetrahedronElement, METH_O, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, + { "new_H1Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, { "H1Pos_TetrahedronElement_CalcShape", _wrap_H1Pos_TetrahedronElement_CalcShape, METH_VARARGS, "\n" "CalcShape(int const p, double const x, double const y, double const z, double * shape)\n" "CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -49214,9 +48765,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_H1Pos_TetrahedronElement", _wrap_delete_H1Pos_TetrahedronElement, METH_O, "delete_H1Pos_TetrahedronElement(H1Pos_TetrahedronElement self)"}, { "H1Pos_TetrahedronElement_swigregister", H1Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "H1Pos_TetrahedronElement_swiginit", H1Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_WedgeElement", _wrap_new_H1_WedgeElement, METH_VARARGS, "H1_WedgeElement(int const p, int const btype=GaussLobatto)"}, - { "H1_WedgeElement_CalcShape", _wrap_H1_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_WedgeElement_CalcDShape", _wrap_H1_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1_WedgeElement(int const p, int const btype=GaussLobatto) -> H1_WedgeElement"}, + { "H1_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1_WedgeElement", _wrap_delete_H1_WedgeElement, METH_O, "delete_H1_WedgeElement(H1_WedgeElement self)"}, { "H1_WedgeElement_swigregister", H1_WedgeElement_swigregister, METH_O, NULL}, { "H1_WedgeElement_swiginit", H1_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -49232,87 +48783,87 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BiCubic3DFiniteElement", _wrap_delete_BiCubic3DFiniteElement, METH_O, "delete_BiCubic3DFiniteElement(BiCubic3DFiniteElement self)"}, { "BiCubic3DFiniteElement_swigregister", BiCubic3DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic3DFiniteElement_swiginit", BiCubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_WedgeElement", _wrap_new_H1Pos_WedgeElement, METH_O, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, - { "H1Pos_WedgeElement_CalcShape", _wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_WedgeElement_CalcDShape", _wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, + { "H1Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1Pos_WedgeElement", _wrap_delete_H1Pos_WedgeElement, METH_O, "delete_H1Pos_WedgeElement(H1Pos_WedgeElement self)"}, { "H1Pos_WedgeElement_swigregister", H1Pos_WedgeElement_swigregister, METH_O, NULL}, { "H1Pos_WedgeElement_swiginit", H1Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_SegmentElement", _wrap_new_L2_SegmentElement, METH_VARARGS, "L2_SegmentElement(int const p, int const btype=GaussLegendre)"}, - { "L2_SegmentElement_CalcShape", _wrap_L2_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_SegmentElement_CalcDShape", _wrap_L2_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_SegmentElement_ProjectDelta", _wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2_SegmentElement(int const p, int const btype=GaussLegendre) -> L2_SegmentElement"}, + { "L2_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2_SegmentElement", _wrap_delete_L2_SegmentElement, METH_O, "delete_L2_SegmentElement(L2_SegmentElement self)"}, { "L2_SegmentElement_swigregister", L2_SegmentElement_swigregister, METH_O, NULL}, { "L2_SegmentElement_swiginit", L2_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_SegmentElement", _wrap_new_L2Pos_SegmentElement, METH_O, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, - { "L2Pos_SegmentElement_CalcShape", _wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_SegmentElement_CalcDShape", _wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_SegmentElement_ProjectDelta", _wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, + { "L2Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_SegmentElement", _wrap_delete_L2Pos_SegmentElement, METH_O, "delete_L2Pos_SegmentElement(L2Pos_SegmentElement self)"}, { "L2Pos_SegmentElement_swigregister", L2Pos_SegmentElement_swigregister, METH_O, NULL}, { "L2Pos_SegmentElement_swiginit", L2Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_QuadrilateralElement", _wrap_new_L2_QuadrilateralElement, METH_VARARGS, "L2_QuadrilateralElement(int const p, int const btype=GaussLegendre)"}, - { "L2_QuadrilateralElement_CalcShape", _wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_QuadrilateralElement_CalcDShape", _wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_QuadrilateralElement_ProjectDelta", _wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, - { "L2_QuadrilateralElement_ProjectCurl", _wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2_QuadrilateralElement(int const p, int const btype=GaussLegendre) -> L2_QuadrilateralElement"}, + { "L2_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "L2_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_QuadrilateralElement", _wrap_delete_L2_QuadrilateralElement, METH_O, "delete_L2_QuadrilateralElement(L2_QuadrilateralElement self)"}, { "L2_QuadrilateralElement_swigregister", L2_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2_QuadrilateralElement_swiginit", L2_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_QuadrilateralElement", _wrap_new_L2Pos_QuadrilateralElement, METH_O, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, - { "L2Pos_QuadrilateralElement_CalcShape", _wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_QuadrilateralElement_CalcDShape", _wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_QuadrilateralElement_ProjectDelta", _wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, + { "L2Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_QuadrilateralElement", _wrap_delete_L2Pos_QuadrilateralElement, METH_O, "delete_L2Pos_QuadrilateralElement(L2Pos_QuadrilateralElement self)"}, { "L2Pos_QuadrilateralElement_swigregister", L2Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2Pos_QuadrilateralElement_swiginit", L2Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_HexahedronElement", _wrap_new_L2_HexahedronElement, METH_VARARGS, "L2_HexahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_HexahedronElement_CalcShape", _wrap_L2_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_HexahedronElement_CalcDShape", _wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_HexahedronElement_ProjectDelta", _wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_HexahedronElement(int const p, int const btype=GaussLegendre) -> L2_HexahedronElement"}, + { "L2_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_HexahedronElement", _wrap_delete_L2_HexahedronElement, METH_O, "delete_L2_HexahedronElement(L2_HexahedronElement self)"}, { "L2_HexahedronElement_swigregister", L2_HexahedronElement_swigregister, METH_O, NULL}, { "L2_HexahedronElement_swiginit", L2_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_HexahedronElement", _wrap_new_L2Pos_HexahedronElement, METH_O, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, - { "L2Pos_HexahedronElement_CalcShape", _wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_HexahedronElement_CalcDShape", _wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_HexahedronElement_ProjectDelta", _wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, + { "L2Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_HexahedronElement", _wrap_delete_L2Pos_HexahedronElement, METH_O, "delete_L2Pos_HexahedronElement(L2Pos_HexahedronElement self)"}, { "L2Pos_HexahedronElement_swigregister", L2Pos_HexahedronElement_swigregister, METH_O, NULL}, { "L2Pos_HexahedronElement_swiginit", L2Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TriangleElement", _wrap_new_L2_TriangleElement, METH_VARARGS, "L2_TriangleElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TriangleElement_CalcShape", _wrap_L2_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TriangleElement_CalcDShape", _wrap_L2_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TriangleElement_ProjectDelta", _wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, - { "L2_TriangleElement_ProjectCurl", _wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TriangleElement(int const p, int const btype=GaussLegendre) -> L2_TriangleElement"}, + { "L2_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, + { "L2_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_TriangleElement", _wrap_delete_L2_TriangleElement, METH_O, "delete_L2_TriangleElement(L2_TriangleElement self)"}, { "L2_TriangleElement_swigregister", L2_TriangleElement_swigregister, METH_O, NULL}, { "L2_TriangleElement_swiginit", L2_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TriangleElement", _wrap_new_L2Pos_TriangleElement, METH_O, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, - { "L2Pos_TriangleElement_CalcShape", _wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TriangleElement_CalcDShape", _wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TriangleElement_ProjectDelta", _wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, + { "L2Pos_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TriangleElement", _wrap_delete_L2Pos_TriangleElement, METH_O, "delete_L2Pos_TriangleElement(L2Pos_TriangleElement self)"}, { "L2Pos_TriangleElement_swigregister", L2Pos_TriangleElement_swigregister, METH_O, NULL}, { "L2Pos_TriangleElement_swiginit", L2Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TetrahedronElement", _wrap_new_L2_TetrahedronElement, METH_VARARGS, "L2_TetrahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TetrahedronElement_CalcShape", _wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TetrahedronElement_CalcDShape", _wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TetrahedronElement_ProjectDelta", _wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TetrahedronElement(int const p, int const btype=GaussLegendre) -> L2_TetrahedronElement"}, + { "L2_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_TetrahedronElement", _wrap_delete_L2_TetrahedronElement, METH_O, "delete_L2_TetrahedronElement(L2_TetrahedronElement self)"}, { "L2_TetrahedronElement_swigregister", L2_TetrahedronElement_swigregister, METH_O, NULL}, { "L2_TetrahedronElement_swiginit", L2_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TetrahedronElement", _wrap_new_L2Pos_TetrahedronElement, METH_O, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, - { "L2Pos_TetrahedronElement_CalcShape", _wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TetrahedronElement_CalcDShape", _wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TetrahedronElement_ProjectDelta", _wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, + { "L2Pos_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TetrahedronElement", _wrap_delete_L2Pos_TetrahedronElement, METH_O, "delete_L2Pos_TetrahedronElement(L2Pos_TetrahedronElement self)"}, { "L2Pos_TetrahedronElement_swigregister", L2Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "L2Pos_TetrahedronElement_swiginit", L2Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_WedgeElement", _wrap_new_L2_WedgeElement, METH_VARARGS, "L2_WedgeElement(int const p, int const btype=GaussLegendre)"}, - { "L2_WedgeElement_CalcShape", _wrap_L2_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_WedgeElement_CalcDShape", _wrap_L2_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2_WedgeElement(int const p, int const btype=GaussLegendre) -> L2_WedgeElement"}, + { "L2_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2_WedgeElement", _wrap_delete_L2_WedgeElement, METH_O, "delete_L2_WedgeElement(L2_WedgeElement self)"}, { "L2_WedgeElement_swigregister", L2_WedgeElement_swigregister, METH_O, NULL}, { "L2_WedgeElement_swiginit", L2_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -49320,22 +48871,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_P0WedgeFiniteElement", _wrap_delete_P0WedgeFiniteElement, METH_O, "delete_P0WedgeFiniteElement(P0WedgeFiniteElement self)"}, { "P0WedgeFiniteElement_swigregister", P0WedgeFiniteElement_swigregister, METH_O, NULL}, { "P0WedgeFiniteElement_swiginit", P0WedgeFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_WedgeElement", _wrap_new_L2Pos_WedgeElement, METH_O, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, - { "L2Pos_WedgeElement_CalcShape", _wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_WedgeElement_CalcDShape", _wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, + { "L2Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2Pos_WedgeElement", _wrap_delete_L2Pos_WedgeElement, METH_O, "delete_L2Pos_WedgeElement(L2Pos_WedgeElement self)"}, { "L2Pos_WedgeElement_swigregister", L2Pos_WedgeElement_swigregister, METH_O, NULL}, { "L2Pos_WedgeElement_swiginit", L2Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_QuadrilateralElement", _wrap_new_RT_QuadrilateralElement, METH_VARARGS, "RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_RT_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_QuadrilateralElement"}, { "RT_QuadrilateralElement_CalcVShape", _wrap_RT_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_QuadrilateralElement_CalcDivShape", _wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_QuadrilateralElement_GetLocalInterpolation", _wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_GetLocalRestriction", _wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_QuadrilateralElement_GetTransferMatrix", _wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_QuadrilateralElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_QuadrilateralElement_Project", _wrap_RT_QuadrilateralElement_Project, METH_VARARGS, "\n" "Project(RT_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49343,21 +48894,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_QuadrilateralElement_ProjectGrad", _wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_QuadrilateralElement_ProjectCurl", _wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_QuadrilateralElement", _wrap_delete_RT_QuadrilateralElement, METH_O, "delete_RT_QuadrilateralElement(RT_QuadrilateralElement self)"}, { "RT_QuadrilateralElement_swigregister", RT_QuadrilateralElement_swigregister, METH_O, NULL}, { "RT_QuadrilateralElement_swiginit", RT_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_HexahedronElement", _wrap_new_RT_HexahedronElement, METH_VARARGS, "RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_HexahedronElement"}, { "RT_HexahedronElement_CalcVShape", _wrap_RT_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_HexahedronElement_CalcDivShape", _wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_HexahedronElement_GetLocalInterpolation", _wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_GetLocalRestriction", _wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_HexahedronElement_GetTransferMatrix", _wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_ProjectMatrixCoefficient", _wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_HexahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_HexahedronElement_Project", _wrap_RT_HexahedronElement_Project, METH_VARARGS, "\n" "Project(RT_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49365,20 +48916,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_HexahedronElement_ProjectCurl", _wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_HexahedronElement", _wrap_delete_RT_HexahedronElement, METH_O, "delete_RT_HexahedronElement(RT_HexahedronElement self)"}, { "RT_HexahedronElement_swigregister", RT_HexahedronElement_swigregister, METH_O, NULL}, { "RT_HexahedronElement_swiginit", RT_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TriangleElement", _wrap_new_RT_TriangleElement, METH_O, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, + { "new_RT_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, { "RT_TriangleElement_CalcVShape", _wrap_RT_TriangleElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TriangleElement_CalcDivShape", _wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TriangleElement_GetLocalInterpolation", _wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_GetLocalRestriction", _wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TriangleElement_GetTransferMatrix", _wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_ProjectMatrixCoefficient", _wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TriangleElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TriangleElement_Project", _wrap_RT_TriangleElement_Project, METH_VARARGS, "\n" "Project(RT_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49386,21 +48937,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TriangleElement_ProjectGrad", _wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_TriangleElement_ProjectCurl", _wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TriangleElement", _wrap_delete_RT_TriangleElement, METH_O, "delete_RT_TriangleElement(RT_TriangleElement self)"}, { "RT_TriangleElement_swigregister", RT_TriangleElement_swigregister, METH_O, NULL}, { "RT_TriangleElement_swiginit", RT_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TetrahedronElement", _wrap_new_RT_TetrahedronElement, METH_O, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, + { "new_RT_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, { "RT_TetrahedronElement_CalcVShape", _wrap_RT_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TetrahedronElement_CalcDivShape", _wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TetrahedronElement_GetLocalInterpolation", _wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_GetLocalRestriction", _wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TetrahedronElement_GetTransferMatrix", _wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_ProjectMatrixCoefficient", _wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TetrahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TetrahedronElement_Project", _wrap_RT_TetrahedronElement_Project, METH_VARARGS, "\n" "Project(RT_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49408,20 +48959,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TetrahedronElement_ProjectCurl", _wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TetrahedronElement", _wrap_delete_RT_TetrahedronElement, METH_O, "delete_RT_TetrahedronElement(RT_TetrahedronElement self)"}, { "RT_TetrahedronElement_swigregister", RT_TetrahedronElement_swigregister, METH_O, NULL}, { "RT_TetrahedronElement_swiginit", RT_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_HexahedronElement", _wrap_new_ND_HexahedronElement, METH_VARARGS, "ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_HexahedronElement"}, { "ND_HexahedronElement_CalcVShape", _wrap_ND_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_HexahedronElement_CalcCurlShape", _wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_HexahedronElement_GetLocalInterpolation", _wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_GetLocalRestriction", _wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_HexahedronElement_GetTransferMatrix", _wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_ProjectMatrixCoefficient", _wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_HexahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_HexahedronElement_Project", _wrap_ND_HexahedronElement_Project, METH_VARARGS, "\n" "Project(ND_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49429,21 +48980,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_HexahedronElement_ProjectGrad", _wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_HexahedronElement_ProjectCurl", _wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_HexahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_HexahedronElement", _wrap_delete_ND_HexahedronElement, METH_O, "delete_ND_HexahedronElement(ND_HexahedronElement self)"}, { "ND_HexahedronElement_swigregister", ND_HexahedronElement_swigregister, METH_O, NULL}, { "ND_HexahedronElement_swiginit", ND_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_QuadrilateralElement", _wrap_new_ND_QuadrilateralElement, METH_VARARGS, "ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_ND_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_QuadrilateralElement"}, { "ND_QuadrilateralElement_CalcVShape", _wrap_ND_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_QuadrilateralElement_CalcCurlShape", _wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_QuadrilateralElement_GetLocalInterpolation", _wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_GetLocalRestriction", _wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_QuadrilateralElement_GetTransferMatrix", _wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_QuadrilateralElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_QuadrilateralElement_Project", _wrap_ND_QuadrilateralElement_Project, METH_VARARGS, "\n" "Project(ND_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49451,20 +49002,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_QuadrilateralElement_ProjectGrad", _wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_QuadrilateralElement", _wrap_delete_ND_QuadrilateralElement, METH_O, "delete_ND_QuadrilateralElement(ND_QuadrilateralElement self)"}, { "ND_QuadrilateralElement_swigregister", ND_QuadrilateralElement_swigregister, METH_O, NULL}, { "ND_QuadrilateralElement_swiginit", ND_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TetrahedronElement", _wrap_new_ND_TetrahedronElement, METH_O, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, + { "new_ND_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, { "ND_TetrahedronElement_CalcVShape", _wrap_ND_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TetrahedronElement_CalcCurlShape", _wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TetrahedronElement_GetLocalInterpolation", _wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_GetLocalRestriction", _wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TetrahedronElement_GetTransferMatrix", _wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_ProjectMatrixCoefficient", _wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TetrahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TetrahedronElement_Project", _wrap_ND_TetrahedronElement_Project, METH_VARARGS, "\n" "Project(ND_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49472,21 +49023,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TetrahedronElement_ProjectGrad", _wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_TetrahedronElement_ProjectCurl", _wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_TetrahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_TetrahedronElement", _wrap_delete_ND_TetrahedronElement, METH_O, "delete_ND_TetrahedronElement(ND_TetrahedronElement self)"}, { "ND_TetrahedronElement_swigregister", ND_TetrahedronElement_swigregister, METH_O, NULL}, { "ND_TetrahedronElement_swiginit", ND_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TriangleElement", _wrap_new_ND_TriangleElement, METH_O, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, + { "new_ND_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, { "ND_TriangleElement_CalcVShape", _wrap_ND_TriangleElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TriangleElement_CalcCurlShape", _wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TriangleElement_GetLocalInterpolation", _wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_GetLocalRestriction", _wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TriangleElement_GetTransferMatrix", _wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_ProjectMatrixCoefficient", _wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TriangleElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TriangleElement_Project", _wrap_ND_TriangleElement_Project, METH_VARARGS, "\n" "Project(ND_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49494,20 +49045,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TriangleElement_ProjectGrad", _wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_TriangleElement", _wrap_delete_ND_TriangleElement, METH_O, "delete_ND_TriangleElement(ND_TriangleElement self)"}, { "ND_TriangleElement_swigregister", ND_TriangleElement_swigregister, METH_O, NULL}, { "ND_TriangleElement_swiginit", ND_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_SegmentElement", _wrap_new_ND_SegmentElement, METH_VARARGS, "ND_SegmentElement(int const p, int const ob_type=GaussLegendre)"}, - { "ND_SegmentElement_CalcShape", _wrap_ND_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "new_ND_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_ND_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_ND_SegmentElement(int const p, int const ob_type=GaussLegendre) -> ND_SegmentElement"}, + { "ND_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, { "ND_SegmentElement_CalcVShape", _wrap_ND_SegmentElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_SegmentElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_SegmentElement_GetLocalInterpolation", _wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_GetLocalRestriction", _wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_SegmentElement_GetTransferMatrix", _wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_ProjectMatrixCoefficient", _wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_SegmentElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_SegmentElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_SegmentElement_Project", _wrap_ND_SegmentElement_Project, METH_VARARGS, "\n" "Project(ND_SegmentElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -49515,26 +49066,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_SegmentElement_ProjectGrad", _wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_SegmentElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_SegmentElement", _wrap_delete_ND_SegmentElement, METH_O, "delete_ND_SegmentElement(ND_SegmentElement self)"}, { "ND_SegmentElement_swigregister", ND_SegmentElement_swigregister, METH_O, NULL}, { "ND_SegmentElement_swiginit", ND_SegmentElement_swiginit, METH_VARARGS, NULL}, { "NURBSFiniteElement_Reset", _wrap_NURBSFiniteElement_Reset, METH_O, "Reset(NURBSFiniteElement self)"}, - { "NURBSFiniteElement_SetIJK", _wrap_NURBSFiniteElement_SetIJK, METH_VARARGS, "SetIJK(NURBSFiniteElement self, int const * IJK)"}, + { "NURBSFiniteElement_SetIJK", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetIJK, METH_VARARGS|METH_KEYWORDS, "SetIJK(NURBSFiniteElement self, int const * IJK)"}, { "NURBSFiniteElement_GetPatch", _wrap_NURBSFiniteElement_GetPatch, METH_O, "GetPatch(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetPatch", _wrap_NURBSFiniteElement_SetPatch, METH_VARARGS, "SetPatch(NURBSFiniteElement self, int p)"}, + { "NURBSFiniteElement_SetPatch", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetPatch, METH_VARARGS|METH_KEYWORDS, "SetPatch(NURBSFiniteElement self, int p)"}, { "NURBSFiniteElement_GetElement", _wrap_NURBSFiniteElement_GetElement, METH_O, "GetElement(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetElement", _wrap_NURBSFiniteElement_SetElement, METH_VARARGS, "SetElement(NURBSFiniteElement self, int e)"}, + { "NURBSFiniteElement_SetElement", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetElement, METH_VARARGS|METH_KEYWORDS, "SetElement(NURBSFiniteElement self, int e)"}, { "NURBSFiniteElement_KnotVectors", _wrap_NURBSFiniteElement_KnotVectors, METH_O, "KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &"}, { "NURBSFiniteElement_Weights", _wrap_NURBSFiniteElement_Weights, METH_O, "Weights(NURBSFiniteElement self) -> Vector"}, { "NURBSFiniteElement_SetOrder", _wrap_NURBSFiniteElement_SetOrder, METH_O, "SetOrder(NURBSFiniteElement self)"}, { "delete_NURBSFiniteElement", _wrap_delete_NURBSFiniteElement, METH_O, "delete_NURBSFiniteElement(NURBSFiniteElement self)"}, { "NURBSFiniteElement_swigregister", NURBSFiniteElement_swigregister, METH_O, NULL}, - { "new_NURBS1DFiniteElement", _wrap_new_NURBS1DFiniteElement, METH_O, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, + { "new_NURBS1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_NURBS1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS1DFiniteElement self)"}, - { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -49543,9 +49094,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_NURBS2DFiniteElement(int px, int py) -> NURBS2DFiniteElement\n" ""}, { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS2DFiniteElement self)"}, - { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -49554,9 +49105,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_NURBS3DFiniteElement(int px, int py, int pz) -> NURBS3DFiniteElement\n" ""}, { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS3DFiniteElement self)"}, - { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/fespace.py b/mfem/_par/fespace.py index 03b08851..c43e3c11 100644 --- a/mfem/_par/fespace.py +++ b/mfem/_par/fespace.py @@ -198,9 +198,9 @@ def GetElementRestriction(self, e_ordering): return _fespace.FiniteElementSpace_GetElementRestriction(self, e_ordering) GetElementRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementRestriction) - def GetFaceRestriction(self, *args): + def GetFaceRestriction(self, *args, **kwargs): r"""GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator""" - return _fespace.FiniteElementSpace_GetFaceRestriction(self, *args) + return _fespace.FiniteElementSpace_GetFaceRestriction(self, *args, **kwargs) GetFaceRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceRestriction) def GetQuadratureInterpolator(self, *args): diff --git a/mfem/_par/fespace_wrap.cxx b/mfem/_par/fespace_wrap.cxx index affb4168..aa57d1ab 100644 --- a/mfem/_par/fespace_wrap.cxx +++ b/mfem/_par/fespace_wrap.cxx @@ -3786,7 +3786,7 @@ SWIGINTERN void mfem_FiniteElementSpace_Save__SWIG_1(mfem::FiniteElementSpace *s self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_FiniteElementSpace_Save__SWIG_3(mfem::FiniteElementSpace *self){ +SWIGINTERN void mfem_FiniteElementSpace_Save__SWIG_2(mfem::FiniteElementSpace *self){ self -> Save(std::cout); } SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_1(mfem::QuadratureSpace *self,char const *file,int precision=8){ @@ -3800,7 +3800,7 @@ SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_1(mfem::QuadratureSpace *self,ch self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_3(mfem::QuadratureSpace *self){ +SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_2(mfem::QuadratureSpace *self){ self -> Save(std::cout); } @@ -3897,8 +3897,8 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_0(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; - mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; + mfem::Mesh *arg2 = (mfem::Mesh *) NULL ; + mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3907,7 +3907,7 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPA int res3 = 0 ; mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); @@ -3916,16 +3916,20 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::Mesh *""'"); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::Mesh *""'"); + } + arg2 = reinterpret_cast< mfem::Mesh * >(argp2); } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); + } + arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); { try { result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,arg2,(mfem::FiniteElementCollection const *)arg3); @@ -3943,62 +3947,46 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; + int arg3 = (int) 1 ; + int arg4 = (int) mfem::Ordering::byNODES ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,arg2); + arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace((mfem::FiniteElementSpace const &)*arg1); + result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4011,44 +3999,56 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_3(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - int arg3 ; - int arg4 ; + mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; + mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; + int arg4 = (int) 1 ; + int arg5 = (int) mfem::Ordering::byNODES ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3,arg4); + result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4061,496 +4061,169 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_4(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::FiniteElementSpace *result = 0 ; +SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "new_FiniteElementSpace", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_FiniteElementSpace__SWIG_0(self, argc, argv); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); + if ((argc >= 1) && (argc <= 3)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 1) { + return _wrap_new_FiniteElementSpace__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_new_FiniteElementSpace__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_FiniteElementSpace__SWIG_1(self, argc, argv); + } + } + } } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if ((argc >= 2) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 3) { + return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); + } + } + } + } } - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3); + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FiniteElementSpace'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::FiniteElementSpace::FiniteElementSpace()\n" + " mfem::FiniteElementSpace::FiniteElementSpace(mfem::FiniteElementSpace const &,mfem::Mesh *,mfem::FiniteElementCollection const *)\n" + " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::FiniteElementCollection const *,int,int)\n" + " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::FiniteElementSpace *result = 0 ; + PyObject *swig_obj[1] ; + mfem::Mesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetMesh" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2); + result = (mfem::Mesh *)((mfem::FiniteElementSpace const *)arg1)->GetMesh(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); - } - arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); - } - arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); - } - arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_FiniteElementSpace", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_FiniteElementSpace__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_9(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_8(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_7(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FiniteElementSpace'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::FiniteElementSpace()\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::FiniteElementSpace const &,mfem::Mesh *,mfem::FiniteElementCollection const *)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::FiniteElementSpace const &,mfem::Mesh *)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::FiniteElementSpace const &)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::FiniteElementCollection const *,int,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::FiniteElementCollection const *,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::FiniteElementCollection const *)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Mesh *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetMesh" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - try { - result = (mfem::Mesh *)((mfem::FiniteElementSpace const *)arg1)->GetMesh(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNURBSext__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNURBSext__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; @@ -4852,7 +4525,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetRestrictionMatrix(PyObject *SWI } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::ElementDofOrdering arg2 ; @@ -4860,16 +4533,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"e_ordering", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementRestriction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetElementRestriction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } @@ -4889,12 +4566,12 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SW } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::ElementDofOrdering arg2 ; mfem::FaceType arg3 ; - mfem::L2FaceValues arg4 ; + mfem::L2FaceValues arg4 = (mfem::L2FaceValues) mfem::L2FaceValues::DoubleValued ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -4903,76 +4580,41 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(PyObjec int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"e_ordering", (char *)"arg3", (char *)"mul", NULL + }; mfem::Operator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_GetFaceRestriction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } arg3 = static_cast< mfem::FaceType >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); - } - arg4 = static_cast< mfem::L2FaceValues >(val4); - { - try { - result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::ElementDofOrdering arg2 ; - mfem::FaceType arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::Operator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); - } - arg3 = static_cast< mfem::FaceType >(val3); { try { - result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3); + result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4985,72 +4627,6 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceRestriction", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetFaceRestriction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues) const\n" - " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -5173,7 +4749,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator(PyObject } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -5184,16 +4760,21 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyOb int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"type", NULL + }; mfem::FaceQuadratureInterpolator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceQuadratureInterpolator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceQuadratureInterpolator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -5201,7 +4782,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "3"" of type '" "mfem::FaceType""'"); } @@ -5251,26 +4832,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVDim(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetOrder" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5287,26 +4872,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetOrder(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetFaceOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceOrder" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5743,7 +5332,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNBE(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FaceType arg2 ; @@ -5751,16 +5340,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"type", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetNFbyType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); } @@ -5780,26 +5373,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5816,7 +5413,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -5825,21 +5422,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vertices", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementVertices", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementVertices" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5862,26 +5464,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBdrElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6036,26 +5642,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementTransformation(PyObject } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::ElementTransformation *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBdrElementTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6072,26 +5682,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementTransformation(PyObje } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetAttribute" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6108,26 +5722,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetAttribute(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBdrAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrAttribute" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6144,7 +5762,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrAttribute(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6153,21 +5771,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6190,7 +5813,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6199,21 +5822,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetBdrElementDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetBdrElementDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6236,7 +5864,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6245,21 +5873,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6282,7 +5915,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6291,21 +5924,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeDofs(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6328,7 +5966,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeDofs(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6337,254 +5975,36 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexDofs(PyObject *SWIGUNUSED int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetVertexDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetVertexDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetVertexDofs(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementInteriorDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetElementInteriorDofs(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceInteriorDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetFaceInteriorDofs(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNumElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetNumElementInteriorDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNumElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (int)((mfem::FiniteElementSpace const *)arg1)->GetNumElementInteriorDofs(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeInteriorDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetEdgeInteriorDofs(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if (PyInt_Check(swig_obj[2])) { - arg3 = PyInt_AsLong(swig_obj[2]); - } else if ((PyArray_PyIntAsInt(swig_obj[2]) != -1) || !PyErr_Occurred()) { - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; - } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(*arg2,arg3); + ((mfem::FiniteElementSpace const *)arg1)->GetVertexDofs(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6597,32 +6017,45 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementInteriorDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(*arg2); + ((mfem::FiniteElementSpace const *)arg1)->GetElementInteriorDofs(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6635,50 +6068,45 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; mfem::Array< int > *arg3 = 0 ; - int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceInteriorDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if (PyInt_Check(swig_obj[3])) { - arg4 = PyInt_AsLong(swig_obj[3]); - } else if ((PyArray_PyIntAsInt(swig_obj[3]) != -1) || !PyErr_Occurred()) { - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; - } - } { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(arg2,*arg3,arg4); + ((mfem::FiniteElementSpace const *)arg1)->GetFaceInteriorDofs(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6691,235 +6119,163 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_2(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNumElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; - mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetNumElementInteriorDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNumElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(arg2,*arg3); + result = (int)((mfem::FiniteElementSpace const *)arg1)->GetNumElementInteriorDofs(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_DofsToVDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(self, argc, argv); - } - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeInteriorDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyInt_Check(argv[2])) { - _v = 1; - } else if ((PyArray_PyIntAsInt(argv[2]) != -1) || !PyErr_Occurred()) { - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_3(self, argc, argv); - } - } - } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyInt_Check(argv[3])) { - _v = 1; - } else if ((PyArray_PyIntAsInt(argv[3]) != -1) || !PyErr_Occurred()) { - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_2(self, argc, argv); - } - } - } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + { + try { + ((mfem::FiniteElementSpace const *)arg1)->GetEdgeInteriorDofs(arg2,*arg3); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_DofsToVDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::DofsToVDofs(mfem::Array< int > &,int) const\n" - " mfem::FiniteElementSpace::DofsToVDofs(mfem::Array< int > &) const\n" - " mfem::FiniteElementSpace::DofsToVDofs(int,mfem::Array< int > &,int) const\n" - " mfem::FiniteElementSpace::DofsToVDofs(int,mfem::Array< int > &) const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - int arg3 ; - int arg4 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofToVDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - { - if (PyInt_Check(swig_obj[3])) { - arg4 = PyInt_AsLong(swig_obj[3]); - } else if ((PyArray_PyIntAsInt(swig_obj[3]) != -1) || !PyErr_Occurred()) { - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (swig_obj[2]) { + { + if (PyInt_Check(swig_obj[2])) { + arg3 = PyInt_AsLong(swig_obj[2]); + } else if ((PyArray_PyIntAsInt(swig_obj[2]) != -1) || !PyErr_Occurred()) { + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } } } { try { - result = (int)((mfem::FiniteElementSpace const *)arg1)->DofToVDof(arg2,arg3,arg4); + ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; - int arg3 ; + mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - int result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofToVDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { @@ -6928,65 +6284,78 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_1(PyObject *SWIGUN }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (swig_obj[3]) { + { + if (PyInt_Check(swig_obj[3])) { + arg4 = PyInt_AsLong(swig_obj[3]); + } else if ((PyArray_PyIntAsInt(swig_obj[3]) != -1) || !PyErr_Occurred()) { + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } + } } { try { - result = (int)((mfem::FiniteElementSpace const *)arg1)->DofToVDof(arg2,arg3); + ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_DofToVDof", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_DofsToVDofs", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; + if (PyInt_Check(argv[2])) { + _v = 1; + } else if ((PyArray_PyIntAsInt(argv[2]) != -1) || !PyErr_Occurred()) { + _v = 1; } else { - _v = 1; + _v = 0; } } if (_v) { - return _wrap_FiniteElementSpace_DofToVDof__SWIG_1(self, argc, argv); + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(self, argc, argv); } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); @@ -7001,15 +6370,13 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *self, PyObject } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(self, argc, argv); + } { if (PyInt_Check(argv[3])) { _v = 1; @@ -7020,7 +6387,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *self, PyObject } } if (_v) { - return _wrap_FiniteElementSpace_DofToVDof__SWIG_0(self, argc, argv); + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(self, argc, argv); } } } @@ -7028,34 +6395,100 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_DofToVDof'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_DofsToVDofs'.\n" " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::DofToVDof(int,int,int) const\n" - " mfem::FiniteElementSpace::DofToVDof(int,int) const\n"); + " mfem::FiniteElementSpace::DofsToVDofs(mfem::Array< int > &,int) const\n" + " mfem::FiniteElementSpace::DofsToVDofs(int,mfem::Array< int > &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_VDofToDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; + int arg3 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dof", (char *)"vd", (char *)"ndofs", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_VDofToDof", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_DofToVDof", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofToVDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + if (obj3) { + { + if (PyInt_Check(obj3)) { + arg4 = PyInt_AsLong(obj3); + } else if ((PyArray_PyIntAsInt(obj3) != -1) || !PyErr_Occurred()) { + arg4 = PyArray_PyIntAsInt(obj3); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } + } + } + { + try { + result = (int)((mfem::FiniteElementSpace const *)arg1)->DofToVDof(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElementSpace_VDofToDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdof", NULL + }; + int result; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_VDofToDof", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_VDofToDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7072,16 +6505,18 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_VDofToDof(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_AdjustVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_AdjustVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vdofs", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElementSpace_AdjustVDofs", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_AdjustVDofs" "', argument " "1"" of type '" "mfem::Array< int > &""'"); } @@ -7104,7 +6539,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_AdjustVDofs(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7113,21 +6548,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7150,7 +6590,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7159,21 +6599,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetBdrElementVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetBdrElementVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7196,7 +6641,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7205,21 +6650,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7242,7 +6692,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7251,21 +6701,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7288,7 +6743,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7297,21 +6752,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetVertexVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetVertexVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetVertexVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetVertexVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7334,7 +6794,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7343,21 +6803,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject * int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementInteriorVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementInteriorVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementInteriorVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementInteriorVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7380,7 +6845,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject * } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7389,21 +6854,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorVDofs(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeInteriorVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeInteriorVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeInteriorVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeInteriorVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7573,26 +7043,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementToDofTable(PyObject * } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementForDof", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetElementForDof", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementForDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7609,26 +7083,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementForDof(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetLocalDofForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetLocalDofForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetLocalDofForDof", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetLocalDofForDof", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetLocalDofForDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7645,26 +7123,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetLocalDofForDof(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetFE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFE" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7681,146 +7163,34 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFE(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBE" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetBE(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetFaceElement(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetEdgeElement(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTraceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; - mfem::Geometry::Type arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetTraceElement", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBE" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "3"" of type '" "mfem::Geometry::Type""'"); - } - arg3 = static_cast< mfem::Geometry::Type >(val3); { try { - result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetTraceElement(arg2,arg3); + result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetBE(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7833,384 +7203,261 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTraceElement(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetFaceElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { - if (PyInt_Check(swig_obj[3])) { - arg4 = PyInt_AsLong(swig_obj[3]); - } else if ((PyArray_PyIntAsInt(swig_obj[3]) != -1) || !PyErr_Occurred()) { - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; - } + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } { try { - ((mfem::FiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); + result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetFaceElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetEdgeElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3); + result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetEdgeElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEssentialVDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyInt_Check(argv[3])) { - _v = 1; - } else if ((PyArray_PyIntAsInt(argv[3]) != -1) || !PyErr_Occurred()) { - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetEssentialVDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::GetEssentialVDofs(mfem::Array< int > const &,mfem::Array< int > &,int) const\n" - " mfem::FiniteElementSpace::GetEssentialVDofs(mfem::Array< int > const &,mfem::Array< int > &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTraceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; + int arg2 ; + mfem::Geometry::Type arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"geom_type", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetTraceElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { - if (PyInt_Check(swig_obj[3])) { - arg4 = PyInt_AsLong(swig_obj[3]); - } else if ((PyArray_PyIntAsInt(swig_obj[3]) != -1) || !PyErr_Occurred()) { - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; - } + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "3"" of type '" "mfem::Geometry::Type""'"); + } + arg3 = static_cast< mfem::Geometry::Type >(val3); { try { - (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); + result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetTraceElement(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"ess_vdofs", (char *)"component", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_GetEssentialVDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEssentialTrueDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyInt_Check(argv[3])) { - _v = 1; - } else if ((PyArray_PyIntAsInt(argv[3]) != -1) || !PyErr_Occurred()) { - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_0(self, argc, argv); - } - } + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (obj3) { + { + if (PyInt_Check(obj3)) { + arg4 = PyInt_AsLong(obj3); + } else if ((PyArray_PyIntAsInt(obj3) != -1) || !PyErr_Occurred()) { + arg4 = PyArray_PyIntAsInt(obj3); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; } } } - + { + try { + ((mfem::FiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetEssentialTrueDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::GetEssentialTrueDofs(mfem::Array< int > const &,mfem::Array< int > &,int)\n" - " mfem::FiniteElementSpace::GetEssentialTrueDofs(mfem::Array< int > const &,mfem::Array< int > &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_MarkerToList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Array< int > *arg1 = 0 ; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"ess_tdof_list", (char *)"component", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_MarkerToList", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_GetEssentialTrueDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (obj3) { + { + if (PyInt_Check(obj3)) { + arg4 = PyInt_AsLong(obj3); + } else if ((PyArray_PyIntAsInt(obj3) != -1) || !PyErr_Occurred()) { + arg4 = PyArray_PyIntAsInt(obj3); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } + } + } { try { - mfem::FiniteElementSpace::MarkerToList((mfem::Array< int > const &)*arg1,*arg2); + (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8223,49 +7470,40 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_MarkerToList(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_MarkerToList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"marker", (char *)"list", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_MarkerToList", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ListToMarker" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - mfem::FiniteElementSpace::ListToMarker((mfem::Array< int > const &)*arg1,arg2,*arg3,arg4); + mfem::FiniteElementSpace::MarkerToList((mfem::Array< int > const &)*arg1,*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8278,18 +7516,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_0(PyObject *SWI } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; int arg2 ; mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"list", (char *)"marker_size", (char *)"marker", (char *)"mark_val", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_ListToMarker", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } @@ -8298,12 +7544,12 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWI } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8311,9 +7557,17 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } { try { - mfem::FiniteElementSpace::ListToMarker((mfem::Array< int > const &)*arg1,arg2,*arg3); + mfem::FiniteElementSpace::ListToMarker((mfem::Array< int > const &)*arg1,arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8326,81 +7580,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_ListToMarker", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_ListToMarker__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_FiniteElementSpace_ListToMarker__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_ListToMarker'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::ListToMarker(mfem::Array< int > const &,int,mfem::Array< int > &,int)\n" - " mfem::FiniteElementSpace::ListToMarker(mfem::Array< int > const &,int,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8411,15 +7591,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dofs", (char *)"cdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_ConvertToConformingVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_ConvertToConformingVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -8427,7 +7612,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8450,7 +7635,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -8461,15 +7646,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"cdofs", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_ConvertFromConformingVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_ConvertFromConformingVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -8477,7 +7667,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8500,7 +7690,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObjec } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -8508,16 +7698,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"cfes", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_D2C_GlobalRestrictionMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_D2C_GlobalRestrictionMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_D2C_GlobalRestrictionMatrix" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_D2C_GlobalRestrictionMatrix" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -8537,7 +7731,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObje } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -8545,16 +7739,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"cfes", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_D2Const_GlobalRestrictionMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_D2Const_GlobalRestrictionMatrix" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_D2Const_GlobalRestrictionMatrix" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -8574,7 +7772,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(Py } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -8582,16 +7780,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"lfes", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_H2L_GlobalRestrictionMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_H2L_GlobalRestrictionMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_H2L_GlobalRestrictionMatrix" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_H2L_GlobalRestrictionMatrix" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -8611,7 +7813,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObje } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -8622,15 +7824,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"coarse_fes", (char *)"T", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetTransferOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetTransferOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -8638,7 +7845,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -8661,7 +7868,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -8672,15 +7879,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"coarse_fes", (char *)"T", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetTrueTransferOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetTrueTransferOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -8688,7 +7900,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -8711,56 +7923,36 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject * } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"want_transform", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:FiniteElementSpace_Update", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Update" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_Update" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->Update(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Update" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_Update" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { try { - (arg1)->Update(); + (arg1)->Update(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8773,48 +7965,6 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_Update", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_Update__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FiniteElementSpace_Update__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_Update'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::Update(bool)\n" - " mfem::FiniteElementSpace::Update()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetUpdateOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -8922,7 +8072,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetUpdateOperator(PyObject *self, } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; bool arg2 ; @@ -8930,15 +8080,19 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *S int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"own", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_SetUpdateOperatorOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_SetUpdateOperatorOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_SetUpdateOperatorOwner" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_SetUpdateOperatorOwner" "', argument " "2"" of type '" "bool""'"); } @@ -8958,7 +8112,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *S } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Operator::Type arg2 ; @@ -8966,15 +8120,19 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorType(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_SetUpdateOperatorType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_SetUpdateOperatorType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_SetUpdateOperatorType" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_SetUpdateOperatorType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -9108,7 +8266,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -9119,21 +8277,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Load(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"input", NULL + }; mfem::FiniteElementCollection *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_Load", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_Load", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Load" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_Load" "', argument " "2"" of type '" "mfem::Mesh *""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__istream, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_Load" "', argument " "3"" of type '" "std::istream &""'"); } @@ -9189,14 +8352,14 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_1(PyObject *SWIGUNUSEDP PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Save" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); @@ -9207,11 +8370,13 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_1(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -9231,44 +8396,6 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_1(PyObject *SWIGUNUSEDP SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Save" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_FiniteElementSpace_Save__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; @@ -9282,7 +8409,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_3(PyObject *SWIGUNUSEDP arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { try { - mfem_FiniteElementSpace_Save__SWIG_3(arg1); + mfem_FiniteElementSpace_Save__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9309,10 +8436,10 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_FiniteElementSpace_Save__SWIG_3(self, argc, argv); + return _wrap_FiniteElementSpace_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); @@ -9321,7 +8448,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save(PyObject *self, PyObject *arg int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_FiniteElementSpace_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_FiniteElementSpace_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_FiniteElementSpace_Save__SWIG_1(self, argc, argv); + } } } } @@ -9345,36 +8485,12 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save(PyObject *self, PyObject *arg } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_FiniteElementSpace_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::FiniteElementSpace::Save(std::ostream &) const\n" " mfem::FiniteElementSpace::Save(char const *,int)\n" - " mfem::FiniteElementSpace::Save(char const *)\n" " mfem::FiniteElementSpace::Save()\n"); return 0; } @@ -9575,26 +8691,30 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_GetSize(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_QuadratureSpace_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureSpace_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadratureSpace_GetElementIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureSpace_GetElementIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureSpace_GetElementIntRule" "', argument " "1"" of type '" "mfem::QuadratureSpace const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -9670,14 +8790,14 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureSpace_Save" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); @@ -9688,11 +8808,13 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureSpace_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -9712,44 +8834,6 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureSpace_Save" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureSpace_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_QuadratureSpace_Save__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; void *argp1 = 0 ; @@ -9763,7 +8847,7 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_3(PyObject *SWIGUNUSEDPARM arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); { try { - mfem_QuadratureSpace_Save__SWIG_3(arg1); + mfem_QuadratureSpace_Save__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9790,10 +8874,10 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_QuadratureSpace_Save__SWIG_3(self, argc, argv); + return _wrap_QuadratureSpace_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); @@ -9802,7 +8886,20 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_QuadratureSpace_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_QuadratureSpace_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_QuadratureSpace_Save__SWIG_1(self, argc, argv); + } } } } @@ -9826,36 +8923,12 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save(PyObject *self, PyObject *args) } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_QuadratureSpace_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureSpace_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::QuadratureSpace::Save(std::ostream &) const\n" " mfem::QuadratureSpace::Save(char const *,int)\n" - " mfem::QuadratureSpace::Save(char const *)\n" " mfem::QuadratureSpace::Save()\n"); return 0; } @@ -9901,7 +8974,7 @@ SWIGINTERN PyObject *_wrap_delete_GridTransfer(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_GridTransfer_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridTransfer_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridTransfer *arg1 = (mfem::GridTransfer *) 0 ; mfem::Operator::Type arg2 ; @@ -9909,15 +8982,19 @@ SWIGINTERN PyObject *_wrap_GridTransfer_SetOperatorType(PyObject *SWIGUNUSEDPARM int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"type", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridTransfer_SetOperatorType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridTransfer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridTransfer_SetOperatorType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridTransfer, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTransfer_SetOperatorType" "', argument " "1"" of type '" "mfem::GridTransfer *""'"); } arg1 = reinterpret_cast< mfem::GridTransfer * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTransfer_SetOperatorType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -10064,7 +9141,7 @@ SWIGINTERN PyObject *GridTransfer_swigregister(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -10072,11 +9149,15 @@ SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"coarse_fes", (char *)"fine_fes", NULL + }; mfem::InterpolationGridTransfer *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_InterpolationGridTransfer", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_InterpolationGridTransfer", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterpolationGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -10084,7 +9165,7 @@ SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolationGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterpolationGridTransfer" "', argument " "2"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -10136,72 +9217,45 @@ SWIGINTERN PyObject *_wrap_delete_InterpolationGridTransfer(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InterpolationGridTransfer *arg1 = (mfem::InterpolationGridTransfer *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; - bool arg3 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mass_integ_", (char *)"own_mass_integ_", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InterpolationGridTransfer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:InterpolationGridTransfer_SetMassIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InterpolationGridTransfer, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "1"" of type '" "mfem::InterpolationGridTransfer *""'"); } arg1 = reinterpret_cast< mfem::InterpolationGridTransfer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetMassIntegrator(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::InterpolationGridTransfer *arg1 = (mfem::InterpolationGridTransfer *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InterpolationGridTransfer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "1"" of type '" "mfem::InterpolationGridTransfer *""'"); - } - arg1 = reinterpret_cast< mfem::InterpolationGridTransfer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); { try { - (arg1)->SetMassIntegrator(arg2); + (arg1)->SetMassIntegrator(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10214,58 +9268,6 @@ SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_1(P } -SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "InterpolationGridTransfer_SetMassIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__InterpolationGridTransfer, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__InterpolationGridTransfer, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterpolationGridTransfer_SetMassIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::InterpolationGridTransfer::SetMassIntegrator(mfem::BilinearFormIntegrator *,bool)\n" - " mfem::InterpolationGridTransfer::SetMassIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_ForwardOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::InterpolationGridTransfer *arg1 = (mfem::InterpolationGridTransfer *) 0 ; @@ -10337,7 +9339,7 @@ SWIGINTERN PyObject *InterpolationGridTransfer_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -10345,11 +9347,15 @@ SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"coarse_fes", (char *)"fine_fes", NULL + }; mfem::L2ProjectionGridTransfer *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_L2ProjectionGridTransfer", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_L2ProjectionGridTransfer", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ProjectionGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -10357,7 +9363,7 @@ SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ProjectionGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_L2ProjectionGridTransfer" "', argument " "2"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -10480,17 +9486,19 @@ SWIGINTERN PyObject *L2ProjectionGridTransfer_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_UsesTensorBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_UsesTensorBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"fes", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:UsesTensorBasis", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsesTensorBasis" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -10524,7 +9532,7 @@ static PyMethodDef SwigMethods[] = { "FiniteElementSpace()\n" "FiniteElementSpace(FiniteElementSpace orig, Mesh mesh=None, FiniteElementCollection fec=None)\n" "FiniteElementSpace(Mesh mesh, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" - "FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + "new_FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES) -> FiniteElementSpace\n" ""}, { "FiniteElementSpace_GetMesh", _wrap_FiniteElementSpace_GetMesh, METH_O, "FiniteElementSpace_GetMesh(FiniteElementSpace self) -> Mesh"}, { "FiniteElementSpace_GetNURBSext", _wrap_FiniteElementSpace_GetNURBSext, METH_VARARGS, "\n" @@ -10538,16 +9546,16 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetConformingRestriction", _wrap_FiniteElementSpace_GetConformingRestriction, METH_O, "FiniteElementSpace_GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix"}, { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "FiniteElementSpace_GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "FiniteElementSpace_GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, - { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "FiniteElementSpace_GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, - { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "FiniteElementSpace_GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "FiniteElementSpace_GetElementRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" ""}, - { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "FiniteElementSpace_GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "FiniteElementSpace_GetVDim(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "FiniteElementSpace_GetOrder(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "FiniteElementSpace_GetFaceOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetOrder, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFaceOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceOrder(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetNDofs", _wrap_FiniteElementSpace_GetNDofs, METH_O, "FiniteElementSpace_GetNDofs(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetVSize", _wrap_FiniteElementSpace_GetVSize, METH_O, "FiniteElementSpace_GetVSize(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetTrueVSize", _wrap_FiniteElementSpace_GetTrueVSize, METH_O, "FiniteElementSpace_GetTrueVSize(FiniteElementSpace self) -> int"}, @@ -10562,73 +9570,73 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "FiniteElementSpace_GetNE(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "FiniteElementSpace_GetNF(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "FiniteElementSpace_GetNBE(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "FiniteElementSpace_GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, - { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "FiniteElementSpace_GetElementType(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "FiniteElementSpace_GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, - { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "FiniteElementSpace_GetBdrElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, + { "FiniteElementSpace_GetElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, + { "FiniteElementSpace_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementType(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetElementTransformation", _wrap_FiniteElementSpace_GetElementTransformation, METH_VARARGS, "\n" "FiniteElementSpace_GetElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation\n" "FiniteElementSpace_GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "FiniteElementSpace_GetBdrElementTransformation", _wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS, "FiniteElementSpace_GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, - { "FiniteElementSpace_GetAttribute", _wrap_FiniteElementSpace_GetAttribute, METH_VARARGS, "FiniteElementSpace_GetAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetBdrAttribute", _wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS, "FiniteElementSpace_GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementDofs", _wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS, "FiniteElementSpace_GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetBdrElementDofs", _wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "FiniteElementSpace_GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceDofs", _wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS, "FiniteElementSpace_GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetEdgeDofs", _wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetVertexDofs", _wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS, "FiniteElementSpace_GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetElementInteriorDofs", _wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceInteriorDofs", _wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetNumElementInteriorDofs", _wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetEdgeInteriorDofs", _wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementTransformation", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, + { "FiniteElementSpace_GetAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetAttribute, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetEdgeDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetVertexDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetNumElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetEdgeInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, { "FiniteElementSpace_DofsToVDofs", _wrap_FiniteElementSpace_DofsToVDofs, METH_VARARGS, "\n" "FiniteElementSpace_DofsToVDofs(FiniteElementSpace self, intArray dofs, int ndofs=-1)\n" "FiniteElementSpace_DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)\n" ""}, - { "FiniteElementSpace_DofToVDof", _wrap_FiniteElementSpace_DofToVDof, METH_VARARGS, "FiniteElementSpace_DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, - { "FiniteElementSpace_VDofToDof", _wrap_FiniteElementSpace_VDofToDof, METH_VARARGS, "FiniteElementSpace_VDofToDof(FiniteElementSpace self, int vdof) -> int"}, - { "FiniteElementSpace_AdjustVDofs", _wrap_FiniteElementSpace_AdjustVDofs, METH_O, "FiniteElementSpace_AdjustVDofs(intArray vdofs)"}, - { "FiniteElementSpace_GetElementVDofs", _wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS, "FiniteElementSpace_GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetBdrElementVDofs", _wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS, "FiniteElementSpace_GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetFaceVDofs", _wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS, "FiniteElementSpace_GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeVDofs", _wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetVertexVDofs", _wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS, "FiniteElementSpace_GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetElementInteriorVDofs", _wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS, "FiniteElementSpace_GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeInteriorVDofs", _wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_DofToVDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_DofToVDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, + { "FiniteElementSpace_VDofToDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_VDofToDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_VDofToDof(FiniteElementSpace self, int vdof) -> int"}, + { "FiniteElementSpace_AdjustVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_AdjustVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_AdjustVDofs(intArray vdofs)"}, + { "FiniteElementSpace_GetElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetBdrElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetFaceVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetVertexVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetElementInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, { "FiniteElementSpace_RebuildElementToDofTable", _wrap_FiniteElementSpace_RebuildElementToDofTable, METH_O, "FiniteElementSpace_RebuildElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_ReorderElementToDofTable", _wrap_FiniteElementSpace_ReorderElementToDofTable, METH_O, "FiniteElementSpace_ReorderElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_BuildDofToArrays", _wrap_FiniteElementSpace_BuildDofToArrays, METH_O, "FiniteElementSpace_BuildDofToArrays(FiniteElementSpace self)"}, { "FiniteElementSpace_GetElementToDofTable", _wrap_FiniteElementSpace_GetElementToDofTable, METH_O, "FiniteElementSpace_GetElementToDofTable(FiniteElementSpace self) -> Table"}, { "FiniteElementSpace_GetBdrElementToDofTable", _wrap_FiniteElementSpace_GetBdrElementToDofTable, METH_O, "FiniteElementSpace_GetBdrElementToDofTable(FiniteElementSpace self) -> Table"}, - { "FiniteElementSpace_GetElementForDof", _wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS, "FiniteElementSpace_GetElementForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetLocalDofForDof", _wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS, "FiniteElementSpace_GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFE", _wrap_FiniteElementSpace_GetFE, METH_VARARGS, "FiniteElementSpace_GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetBE", _wrap_FiniteElementSpace_GetBE, METH_VARARGS, "FiniteElementSpace_GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetFaceElement", _wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS, "FiniteElementSpace_GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetEdgeElement", _wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS, "FiniteElementSpace_GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetTraceElement", _wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS, "FiniteElementSpace_GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, - { "FiniteElementSpace_GetEssentialVDofs", _wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "FiniteElementSpace_GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, - { "FiniteElementSpace_GetEssentialTrueDofs", _wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "FiniteElementSpace_GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, - { "FiniteElementSpace_MarkerToList", _wrap_FiniteElementSpace_MarkerToList, METH_VARARGS, "FiniteElementSpace_MarkerToList(intArray marker, intArray list)"}, - { "FiniteElementSpace_ListToMarker", _wrap_FiniteElementSpace_ListToMarker, METH_VARARGS, "FiniteElementSpace_ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, - { "FiniteElementSpace_ConvertToConformingVDofs", _wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS, "FiniteElementSpace_ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, - { "FiniteElementSpace_ConvertFromConformingVDofs", _wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS, "FiniteElementSpace_ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, - { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS, "FiniteElementSpace_D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS, "FiniteElementSpace_D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS, "FiniteElementSpace_H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, - { "FiniteElementSpace_GetTransferOperator", _wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS, "FiniteElementSpace_GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_GetTrueTransferOperator", _wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "FiniteElementSpace_GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_Update", _wrap_FiniteElementSpace_Update, METH_VARARGS, "FiniteElementSpace_Update(FiniteElementSpace self, bool want_transform=True)"}, + { "FiniteElementSpace_GetElementForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetLocalDofForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFE, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetBE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBE, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetFaceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetEdgeElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetTraceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, + { "FiniteElementSpace_GetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, + { "FiniteElementSpace_GetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "FiniteElementSpace_MarkerToList", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_MarkerToList, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_MarkerToList(intArray marker, intArray list)"}, + { "FiniteElementSpace_ListToMarker", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ListToMarker, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, + { "FiniteElementSpace_ConvertToConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, + { "FiniteElementSpace_ConvertFromConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, + { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, + { "FiniteElementSpace_GetTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_GetTrueTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_Update", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Update, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_Update(FiniteElementSpace self, bool want_transform=True)"}, { "FiniteElementSpace_GetUpdateOperator", _wrap_FiniteElementSpace_GetUpdateOperator, METH_VARARGS, "\n" "FiniteElementSpace_GetUpdateOperator(FiniteElementSpace self) -> Operator\n" "FiniteElementSpace_GetUpdateOperator(FiniteElementSpace self, OperatorHandle T)\n" ""}, - { "FiniteElementSpace_SetUpdateOperatorOwner", _wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS, "FiniteElementSpace_SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, - { "FiniteElementSpace_SetUpdateOperatorType", _wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS, "FiniteElementSpace_SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, + { "FiniteElementSpace_SetUpdateOperatorOwner", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, + { "FiniteElementSpace_SetUpdateOperatorType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, { "FiniteElementSpace_UpdatesFinished", _wrap_FiniteElementSpace_UpdatesFinished, METH_O, "FiniteElementSpace_UpdatesFinished(FiniteElementSpace self)"}, { "FiniteElementSpace_GetSequence", _wrap_FiniteElementSpace_GetSequence, METH_O, "FiniteElementSpace_GetSequence(FiniteElementSpace self) -> long"}, - { "FiniteElementSpace_Load", _wrap_FiniteElementSpace_Load, METH_VARARGS, "FiniteElementSpace_Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, + { "FiniteElementSpace_Load", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Load, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, { "delete_FiniteElementSpace", _wrap_delete_FiniteElementSpace, METH_O, "delete_FiniteElementSpace(FiniteElementSpace self)"}, { "FiniteElementSpace_Save", _wrap_FiniteElementSpace_Save, METH_VARARGS, "\n" "FiniteElementSpace_Save(FiniteElementSpace self, std::ostream & out)\n" @@ -10643,7 +9651,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_QuadratureSpace", _wrap_delete_QuadratureSpace, METH_O, "delete_QuadratureSpace(QuadratureSpace self)"}, { "QuadratureSpace_GetSize", _wrap_QuadratureSpace_GetSize, METH_O, "QuadratureSpace_GetSize(QuadratureSpace self) -> int"}, - { "QuadratureSpace_GetElementIntRule", _wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS, "QuadratureSpace_GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, + { "QuadratureSpace_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "QuadratureSpace_GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, { "QuadratureSpace_Save", _wrap_QuadratureSpace_Save, METH_VARARGS, "\n" "QuadratureSpace_Save(QuadratureSpace self, std::ostream & out)\n" "QuadratureSpace_Save(QuadratureSpace self, char const * file, int precision=8)\n" @@ -10652,26 +9660,26 @@ static PyMethodDef SwigMethods[] = { { "QuadratureSpace_swigregister", QuadratureSpace_swigregister, METH_O, NULL}, { "QuadratureSpace_swiginit", QuadratureSpace_swiginit, METH_VARARGS, NULL}, { "delete_GridTransfer", _wrap_delete_GridTransfer, METH_O, "delete_GridTransfer(GridTransfer self)"}, - { "GridTransfer_SetOperatorType", _wrap_GridTransfer_SetOperatorType, METH_VARARGS, "GridTransfer_SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, + { "GridTransfer_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_GridTransfer_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "GridTransfer_SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, { "GridTransfer_ForwardOperator", _wrap_GridTransfer_ForwardOperator, METH_O, "GridTransfer_ForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_BackwardOperator", _wrap_GridTransfer_BackwardOperator, METH_O, "GridTransfer_BackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueForwardOperator", _wrap_GridTransfer_TrueForwardOperator, METH_O, "GridTransfer_TrueForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueBackwardOperator", _wrap_GridTransfer_TrueBackwardOperator, METH_O, "GridTransfer_TrueBackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_swigregister", GridTransfer_swigregister, METH_O, NULL}, - { "new_InterpolationGridTransfer", _wrap_new_InterpolationGridTransfer, METH_VARARGS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, + { "new_InterpolationGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_InterpolationGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, { "delete_InterpolationGridTransfer", _wrap_delete_InterpolationGridTransfer, METH_O, "delete_InterpolationGridTransfer(InterpolationGridTransfer self)"}, - { "InterpolationGridTransfer_SetMassIntegrator", _wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS, "InterpolationGridTransfer_SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, + { "InterpolationGridTransfer_SetMassIntegrator", (PyCFunction)(void(*)(void))_wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS|METH_KEYWORDS, "InterpolationGridTransfer_SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, { "InterpolationGridTransfer_ForwardOperator", _wrap_InterpolationGridTransfer_ForwardOperator, METH_O, "InterpolationGridTransfer_ForwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_BackwardOperator", _wrap_InterpolationGridTransfer_BackwardOperator, METH_O, "InterpolationGridTransfer_BackwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_swigregister", InterpolationGridTransfer_swigregister, METH_O, NULL}, { "InterpolationGridTransfer_swiginit", InterpolationGridTransfer_swiginit, METH_VARARGS, NULL}, - { "new_L2ProjectionGridTransfer", _wrap_new_L2ProjectionGridTransfer, METH_VARARGS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, + { "new_L2ProjectionGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_L2ProjectionGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, { "L2ProjectionGridTransfer_ForwardOperator", _wrap_L2ProjectionGridTransfer_ForwardOperator, METH_O, "L2ProjectionGridTransfer_ForwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "L2ProjectionGridTransfer_BackwardOperator", _wrap_L2ProjectionGridTransfer_BackwardOperator, METH_O, "L2ProjectionGridTransfer_BackwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, - { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, + { "UsesTensorBasis", (PyCFunction)(void(*)(void))_wrap_UsesTensorBasis, METH_VARARGS|METH_KEYWORDS, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; @@ -10686,7 +9694,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FiniteElementSpace()\n" "FiniteElementSpace(FiniteElementSpace orig, Mesh mesh=None, FiniteElementCollection fec=None)\n" "FiniteElementSpace(Mesh mesh, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" - "FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + "new_FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES) -> FiniteElementSpace\n" ""}, { "FiniteElementSpace_GetMesh", _wrap_FiniteElementSpace_GetMesh, METH_O, "GetMesh(FiniteElementSpace self) -> Mesh"}, { "FiniteElementSpace_GetNURBSext", _wrap_FiniteElementSpace_GetNURBSext, METH_VARARGS, "\n" @@ -10700,16 +9708,16 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FiniteElementSpace_GetConformingRestriction", _wrap_FiniteElementSpace_GetConformingRestriction, METH_O, "GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix"}, { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, - { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, - { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "FiniteElementSpace_GetElementRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS|METH_KEYWORDS, "GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS|METH_KEYWORDS, "GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" "GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" "GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" ""}, - { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS|METH_KEYWORDS, "GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "GetVDim(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "GetOrder(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "GetFaceOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetOrder, METH_VARARGS|METH_KEYWORDS, "GetOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFaceOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS|METH_KEYWORDS, "GetFaceOrder(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetNDofs", _wrap_FiniteElementSpace_GetNDofs, METH_O, "GetNDofs(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetVSize", _wrap_FiniteElementSpace_GetVSize, METH_O, "GetVSize(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetTrueVSize", _wrap_FiniteElementSpace_GetTrueVSize, METH_O, "GetTrueVSize(FiniteElementSpace self) -> int"}, @@ -10724,73 +9732,73 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "GetNE(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "GetNF(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "GetNBE(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, - { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "GetElementType(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, - { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "GetBdrElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, + { "FiniteElementSpace_GetElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementType, METH_VARARGS|METH_KEYWORDS, "GetElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, + { "FiniteElementSpace_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "GetBdrElementType(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetElementTransformation", _wrap_FiniteElementSpace_GetElementTransformation, METH_VARARGS, "\n" "GetElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation\n" "GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "FiniteElementSpace_GetBdrElementTransformation", _wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS, "GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, - { "FiniteElementSpace_GetAttribute", _wrap_FiniteElementSpace_GetAttribute, METH_VARARGS, "GetAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetBdrAttribute", _wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementDofs", _wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS, "GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetBdrElementDofs", _wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceDofs", _wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetEdgeDofs", _wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS, "GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetVertexDofs", _wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS, "GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetElementInteriorDofs", _wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS, "GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceInteriorDofs", _wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS, "GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetNumElementInteriorDofs", _wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS, "GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetEdgeInteriorDofs", _wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS, "GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementTransformation", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS|METH_KEYWORDS, "GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, + { "FiniteElementSpace_GetAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetAttribute, METH_VARARGS|METH_KEYWORDS, "GetAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS|METH_KEYWORDS, "GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS|METH_KEYWORDS, "GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetEdgeDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetVertexDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS|METH_KEYWORDS, "GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetNumElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetEdgeInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, { "FiniteElementSpace_DofsToVDofs", _wrap_FiniteElementSpace_DofsToVDofs, METH_VARARGS, "\n" "DofsToVDofs(FiniteElementSpace self, intArray dofs, int ndofs=-1)\n" "DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)\n" ""}, - { "FiniteElementSpace_DofToVDof", _wrap_FiniteElementSpace_DofToVDof, METH_VARARGS, "DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, - { "FiniteElementSpace_VDofToDof", _wrap_FiniteElementSpace_VDofToDof, METH_VARARGS, "VDofToDof(FiniteElementSpace self, int vdof) -> int"}, - { "FiniteElementSpace_AdjustVDofs", _wrap_FiniteElementSpace_AdjustVDofs, METH_O, "AdjustVDofs(intArray vdofs)"}, - { "FiniteElementSpace_GetElementVDofs", _wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS, "GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetBdrElementVDofs", _wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS, "GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetFaceVDofs", _wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS, "GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeVDofs", _wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS, "GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetVertexVDofs", _wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS, "GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetElementInteriorVDofs", _wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS, "GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeInteriorVDofs", _wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS, "GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_DofToVDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_DofToVDof, METH_VARARGS|METH_KEYWORDS, "DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, + { "FiniteElementSpace_VDofToDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_VDofToDof, METH_VARARGS|METH_KEYWORDS, "VDofToDof(FiniteElementSpace self, int vdof) -> int"}, + { "FiniteElementSpace_AdjustVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_AdjustVDofs, METH_VARARGS|METH_KEYWORDS, "AdjustVDofs(intArray vdofs)"}, + { "FiniteElementSpace_GetElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS|METH_KEYWORDS, "GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetBdrElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS|METH_KEYWORDS, "GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetFaceVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetVertexVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS|METH_KEYWORDS, "GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetElementInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, { "FiniteElementSpace_RebuildElementToDofTable", _wrap_FiniteElementSpace_RebuildElementToDofTable, METH_O, "RebuildElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_ReorderElementToDofTable", _wrap_FiniteElementSpace_ReorderElementToDofTable, METH_O, "ReorderElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_BuildDofToArrays", _wrap_FiniteElementSpace_BuildDofToArrays, METH_O, "BuildDofToArrays(FiniteElementSpace self)"}, { "FiniteElementSpace_GetElementToDofTable", _wrap_FiniteElementSpace_GetElementToDofTable, METH_O, "GetElementToDofTable(FiniteElementSpace self) -> Table"}, { "FiniteElementSpace_GetBdrElementToDofTable", _wrap_FiniteElementSpace_GetBdrElementToDofTable, METH_O, "GetBdrElementToDofTable(FiniteElementSpace self) -> Table"}, - { "FiniteElementSpace_GetElementForDof", _wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS, "GetElementForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetLocalDofForDof", _wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS, "GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFE", _wrap_FiniteElementSpace_GetFE, METH_VARARGS, "GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetBE", _wrap_FiniteElementSpace_GetBE, METH_VARARGS, "GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetFaceElement", _wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS, "GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetEdgeElement", _wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS, "GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetTraceElement", _wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS, "GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, - { "FiniteElementSpace_GetEssentialVDofs", _wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, - { "FiniteElementSpace_GetEssentialTrueDofs", _wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, - { "FiniteElementSpace_MarkerToList", _wrap_FiniteElementSpace_MarkerToList, METH_VARARGS, "MarkerToList(intArray marker, intArray list)"}, - { "FiniteElementSpace_ListToMarker", _wrap_FiniteElementSpace_ListToMarker, METH_VARARGS, "ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, - { "FiniteElementSpace_ConvertToConformingVDofs", _wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS, "ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, - { "FiniteElementSpace_ConvertFromConformingVDofs", _wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS, "ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, - { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS, "D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS, "D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS, "H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, - { "FiniteElementSpace_GetTransferOperator", _wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS, "GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_GetTrueTransferOperator", _wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_Update", _wrap_FiniteElementSpace_Update, METH_VARARGS, "Update(FiniteElementSpace self, bool want_transform=True)"}, + { "FiniteElementSpace_GetElementForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS|METH_KEYWORDS, "GetElementForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetLocalDofForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS|METH_KEYWORDS, "GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFE, METH_VARARGS|METH_KEYWORDS, "GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetBE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBE, METH_VARARGS|METH_KEYWORDS, "GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetFaceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS|METH_KEYWORDS, "GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetEdgeElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS|METH_KEYWORDS, "GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetTraceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS|METH_KEYWORDS, "GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, + { "FiniteElementSpace_GetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, + { "FiniteElementSpace_GetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "FiniteElementSpace_MarkerToList", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_MarkerToList, METH_VARARGS|METH_KEYWORDS, "MarkerToList(intArray marker, intArray list)"}, + { "FiniteElementSpace_ListToMarker", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ListToMarker, METH_VARARGS|METH_KEYWORDS, "ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, + { "FiniteElementSpace_ConvertToConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS|METH_KEYWORDS, "ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, + { "FiniteElementSpace_ConvertFromConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS|METH_KEYWORDS, "ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, + { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, + { "FiniteElementSpace_GetTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS|METH_KEYWORDS, "GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_GetTrueTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS|METH_KEYWORDS, "GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_Update", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Update, METH_VARARGS|METH_KEYWORDS, "Update(FiniteElementSpace self, bool want_transform=True)"}, { "FiniteElementSpace_GetUpdateOperator", _wrap_FiniteElementSpace_GetUpdateOperator, METH_VARARGS, "\n" "GetUpdateOperator(FiniteElementSpace self) -> Operator\n" "GetUpdateOperator(FiniteElementSpace self, OperatorHandle T)\n" ""}, - { "FiniteElementSpace_SetUpdateOperatorOwner", _wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS, "SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, - { "FiniteElementSpace_SetUpdateOperatorType", _wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS, "SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, + { "FiniteElementSpace_SetUpdateOperatorOwner", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS|METH_KEYWORDS, "SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, + { "FiniteElementSpace_SetUpdateOperatorType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS|METH_KEYWORDS, "SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, { "FiniteElementSpace_UpdatesFinished", _wrap_FiniteElementSpace_UpdatesFinished, METH_O, "UpdatesFinished(FiniteElementSpace self)"}, { "FiniteElementSpace_GetSequence", _wrap_FiniteElementSpace_GetSequence, METH_O, "GetSequence(FiniteElementSpace self) -> long"}, - { "FiniteElementSpace_Load", _wrap_FiniteElementSpace_Load, METH_VARARGS, "Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, + { "FiniteElementSpace_Load", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Load, METH_VARARGS|METH_KEYWORDS, "Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, { "delete_FiniteElementSpace", _wrap_delete_FiniteElementSpace, METH_O, "delete_FiniteElementSpace(FiniteElementSpace self)"}, { "FiniteElementSpace_Save", _wrap_FiniteElementSpace_Save, METH_VARARGS, "\n" "Save(FiniteElementSpace self, std::ostream & out)\n" @@ -10805,7 +9813,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_QuadratureSpace", _wrap_delete_QuadratureSpace, METH_O, "delete_QuadratureSpace(QuadratureSpace self)"}, { "QuadratureSpace_GetSize", _wrap_QuadratureSpace_GetSize, METH_O, "GetSize(QuadratureSpace self) -> int"}, - { "QuadratureSpace_GetElementIntRule", _wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, + { "QuadratureSpace_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, { "QuadratureSpace_Save", _wrap_QuadratureSpace_Save, METH_VARARGS, "\n" "Save(QuadratureSpace self, std::ostream & out)\n" "Save(QuadratureSpace self, char const * file, int precision=8)\n" @@ -10814,26 +9822,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "QuadratureSpace_swigregister", QuadratureSpace_swigregister, METH_O, NULL}, { "QuadratureSpace_swiginit", QuadratureSpace_swiginit, METH_VARARGS, NULL}, { "delete_GridTransfer", _wrap_delete_GridTransfer, METH_O, "delete_GridTransfer(GridTransfer self)"}, - { "GridTransfer_SetOperatorType", _wrap_GridTransfer_SetOperatorType, METH_VARARGS, "SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, + { "GridTransfer_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_GridTransfer_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, { "GridTransfer_ForwardOperator", _wrap_GridTransfer_ForwardOperator, METH_O, "ForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_BackwardOperator", _wrap_GridTransfer_BackwardOperator, METH_O, "BackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueForwardOperator", _wrap_GridTransfer_TrueForwardOperator, METH_O, "TrueForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueBackwardOperator", _wrap_GridTransfer_TrueBackwardOperator, METH_O, "TrueBackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_swigregister", GridTransfer_swigregister, METH_O, NULL}, - { "new_InterpolationGridTransfer", _wrap_new_InterpolationGridTransfer, METH_VARARGS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, + { "new_InterpolationGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_InterpolationGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, { "delete_InterpolationGridTransfer", _wrap_delete_InterpolationGridTransfer, METH_O, "delete_InterpolationGridTransfer(InterpolationGridTransfer self)"}, - { "InterpolationGridTransfer_SetMassIntegrator", _wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS, "SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, + { "InterpolationGridTransfer_SetMassIntegrator", (PyCFunction)(void(*)(void))_wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS|METH_KEYWORDS, "SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, { "InterpolationGridTransfer_ForwardOperator", _wrap_InterpolationGridTransfer_ForwardOperator, METH_O, "ForwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_BackwardOperator", _wrap_InterpolationGridTransfer_BackwardOperator, METH_O, "BackwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_swigregister", InterpolationGridTransfer_swigregister, METH_O, NULL}, { "InterpolationGridTransfer_swiginit", InterpolationGridTransfer_swiginit, METH_VARARGS, NULL}, - { "new_L2ProjectionGridTransfer", _wrap_new_L2ProjectionGridTransfer, METH_VARARGS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, + { "new_L2ProjectionGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_L2ProjectionGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, { "L2ProjectionGridTransfer_ForwardOperator", _wrap_L2ProjectionGridTransfer_ForwardOperator, METH_O, "ForwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "L2ProjectionGridTransfer_BackwardOperator", _wrap_L2ProjectionGridTransfer_BackwardOperator, METH_O, "BackwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, - { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, + { "UsesTensorBasis", (PyCFunction)(void(*)(void))_wrap_UsesTensorBasis, METH_VARARGS|METH_KEYWORDS, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/geom_wrap.cxx b/mfem/_par/geom_wrap.cxx index b8b21063..ca331147 100644 --- a/mfem/_par/geom_wrap.cxx +++ b/mfem/_par/geom_wrap.cxx @@ -3555,26 +3555,30 @@ SWIGINTERN PyObject *_wrap_delete_Geometry(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Geometry_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetVertices" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3596,26 +3600,30 @@ SWIGINTERN PyObject *_wrap_Geometry_GetVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Geometry_GetCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::IntegrationPoint *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetCenter" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3637,22 +3645,26 @@ SWIGINTERN PyObject *_wrap_Geometry_GetCenter(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Geometry_GetRandomPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetRandomPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; mfem::IntegrationPoint *arg2 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"GeomType", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetRandomPoint", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetRandomPoint", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_GetRandomPoint" "', argument " "2"" of type '" "mfem::IntegrationPoint &""'"); } @@ -3991,26 +4003,30 @@ SWIGINTERN PyObject *_wrap_Geometry_ProjectPoint(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_Geometry_GetGeomToPerfGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetGeomToPerfGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetGeomToPerfGeomJac", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetGeomToPerfGeomJac", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeomToPerfGeomJac" "', argument " "1"" of type '" "mfem::Geometry const *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4032,26 +4048,30 @@ SWIGINTERN PyObject *_wrap_Geometry_GetGeomToPerfGeomJac(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Geometry_GetPerfGeomToGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetPerfGeomToGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPerfGeomToGeomJac", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetPerfGeomToGeomJac", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPerfGeomToGeomJac" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4073,7 +4093,7 @@ SWIGINTERN PyObject *_wrap_Geometry_GetPerfGeomToGeomJac(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; @@ -4082,21 +4102,26 @@ SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"pm", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPerfPointMat", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Geometry_GetPerfPointMat", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPerfPointMat" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Geometry_GetPerfPointMat" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -4124,7 +4149,7 @@ SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; @@ -4136,21 +4161,27 @@ SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"J", (char *)"PJ", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Geometry_JacToPerfJac", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Geometry_JacToPerfJac", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_JacToPerfJac" "', argument " "1"" of type '" "mfem::Geometry const *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Geometry_JacToPerfJac" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -4158,7 +4189,7 @@ SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Geometry_JacToPerfJac" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Geometry_JacToPerfJac" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -4186,26 +4217,30 @@ SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Geometry_NumBdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_NumBdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Geometry_NumBdr", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_NumBdr", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_NumBdr" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4599,88 +4634,51 @@ SWIGINTERN PyObject *_wrap_RefinedGeometry_Type_get(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_RefinedGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RefinedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; int arg3 ; - int arg4 ; + int arg4 = (int) 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"NPts", (char *)"NRefG", (char *)"NRefE", (char *)"NBdrE", NULL + }; mfem::RefinedGeometry *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_RefinedGeometry", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = PyArray_PyIntAsInt(obj2); } - { - try { - result = (mfem::RefinedGeometry *)new mfem::RefinedGeometry(arg1,arg2,arg3,arg4); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RefinedGeometry, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RefinedGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::RefinedGeometry *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (mfem::RefinedGeometry *)new mfem::RefinedGeometry(arg1,arg2,arg3); + result = (mfem::RefinedGeometry *)new mfem::RefinedGeometry(arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4698,102 +4696,6 @@ SWIGINTERN PyObject *_wrap_new_RefinedGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_RefinedGeometry(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RefinedGeometry", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RefinedGeometry__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RefinedGeometry__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RefinedGeometry'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RefinedGeometry::RefinedGeometry(int,int,int,int)\n" - " mfem::RefinedGeometry::RefinedGeometry(int,int,int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_RefinedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::RefinedGeometry *arg1 = (mfem::RefinedGeometry *) 0 ; @@ -4864,25 +4766,29 @@ SWIGINTERN PyObject *_wrap_new_GeometryRefiner(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_GeometryRefiner_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeometryRefiner_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeometryRefiner_SetType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeometryRefiner_SetType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_SetType" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); } arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4939,40 +4845,49 @@ SWIGINTERN PyObject *_wrap_GeometryRefiner_GetType(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; mfem::Geometry::Type arg2 ; int arg3 ; - int arg4 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Geom", (char *)"Times", (char *)"ETimes", NULL + }; mfem::RefinedGeometry *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:GeometryRefiner_Refine", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_Refine" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); } arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeometryRefiner_Refine" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { @@ -4994,7 +4909,7 @@ SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometryRefiner_RefineInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; mfem::Geometry::Type arg2 ; @@ -5003,151 +4918,30 @@ SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_1(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - mfem::RefinedGeometry *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_Refine" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); - } - arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeometryRefiner_Refine" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::RefinedGeometry *)(arg1)->Refine(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RefinedGeometry, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Geom", (char *)"Times", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GeometryRefiner_Refine", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeometryRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GeometryRefiner_Refine__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeometryRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GeometryRefiner_Refine__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GeometryRefiner_Refine'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeometryRefiner::Refine(mfem::Geometry::Type,int,int)\n" - " mfem::GeometryRefiner::Refine(mfem::Geometry::Type,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeometryRefiner_RefineInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; - mfem::Geometry::Type arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[3] ; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GeometryRefiner_RefineInterior", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GeometryRefiner_RefineInterior", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_RefineInterior" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); } arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeometryRefiner_RefineInterior" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5235,9 +5029,9 @@ static PyMethodDef SwigMethods[] = { { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"}, - { "Geometry_GetVertices", _wrap_Geometry_GetVertices, METH_VARARGS, "Geometry_GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, - { "Geometry_GetCenter", _wrap_Geometry_GetCenter, METH_VARARGS, "Geometry_GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, - { "Geometry_GetRandomPoint", _wrap_Geometry_GetRandomPoint, METH_VARARGS, "Geometry_GetRandomPoint(int GeomType, IntegrationPoint ip)"}, + { "Geometry_GetVertices", (PyCFunction)(void(*)(void))_wrap_Geometry_GetVertices, METH_VARARGS|METH_KEYWORDS, "Geometry_GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, + { "Geometry_GetCenter", (PyCFunction)(void(*)(void))_wrap_Geometry_GetCenter, METH_VARARGS|METH_KEYWORDS, "Geometry_GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, + { "Geometry_GetRandomPoint", (PyCFunction)(void(*)(void))_wrap_Geometry_GetRandomPoint, METH_VARARGS|METH_KEYWORDS, "Geometry_GetRandomPoint(int GeomType, IntegrationPoint ip)"}, { "Geometry_CheckPoint", _wrap_Geometry_CheckPoint, METH_VARARGS, "\n" "Geometry_CheckPoint(int GeomType, IntegrationPoint ip) -> bool\n" "Geometry_CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool\n" @@ -5246,11 +5040,11 @@ static PyMethodDef SwigMethods[] = { "Geometry_ProjectPoint(int GeomType, IntegrationPoint beg, IntegrationPoint end) -> bool\n" "Geometry_ProjectPoint(int GeomType, IntegrationPoint ip) -> bool\n" ""}, - { "Geometry_GetGeomToPerfGeomJac", _wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS, "Geometry_GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfGeomToGeomJac", _wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS, "Geometry_GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfPointMat", _wrap_Geometry_GetPerfPointMat, METH_VARARGS, "Geometry_GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, - { "Geometry_JacToPerfJac", _wrap_Geometry_JacToPerfJac, METH_VARARGS, "Geometry_JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, - { "Geometry_NumBdr", _wrap_Geometry_NumBdr, METH_VARARGS, "Geometry_NumBdr(Geometry self, int GeomType) -> int"}, + { "Geometry_GetGeomToPerfGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS|METH_KEYWORDS, "Geometry_GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfGeomToGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS|METH_KEYWORDS, "Geometry_GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfPointMat", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfPointMat, METH_VARARGS|METH_KEYWORDS, "Geometry_GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, + { "Geometry_JacToPerfJac", (PyCFunction)(void(*)(void))_wrap_Geometry_JacToPerfJac, METH_VARARGS|METH_KEYWORDS, "Geometry_JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, + { "Geometry_NumBdr", (PyCFunction)(void(*)(void))_wrap_Geometry_NumBdr, METH_VARARGS|METH_KEYWORDS, "Geometry_NumBdr(Geometry self, int GeomType) -> int"}, { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL}, { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL}, { "RefinedGeometry_Times_set", _wrap_RefinedGeometry_Times_set, METH_VARARGS, "RefinedGeometry_Times_set(RefinedGeometry self, int Times)"}, @@ -5266,15 +5060,15 @@ static PyMethodDef SwigMethods[] = { { "RefinedGeometry_NumBdrEdges_get", _wrap_RefinedGeometry_NumBdrEdges_get, METH_O, "RefinedGeometry_NumBdrEdges_get(RefinedGeometry self) -> int"}, { "RefinedGeometry_Type_set", _wrap_RefinedGeometry_Type_set, METH_VARARGS, "RefinedGeometry_Type_set(RefinedGeometry self, int Type)"}, { "RefinedGeometry_Type_get", _wrap_RefinedGeometry_Type_get, METH_O, "RefinedGeometry_Type_get(RefinedGeometry self) -> int"}, - { "new_RefinedGeometry", _wrap_new_RefinedGeometry, METH_VARARGS, "RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0)"}, + { "new_RefinedGeometry", (PyCFunction)(void(*)(void))_wrap_new_RefinedGeometry, METH_VARARGS|METH_KEYWORDS, "new_RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0) -> RefinedGeometry"}, { "delete_RefinedGeometry", _wrap_delete_RefinedGeometry, METH_O, "delete_RefinedGeometry(RefinedGeometry self)"}, { "RefinedGeometry_swigregister", RefinedGeometry_swigregister, METH_O, NULL}, { "RefinedGeometry_swiginit", RefinedGeometry_swiginit, METH_VARARGS, NULL}, { "new_GeometryRefiner", _wrap_new_GeometryRefiner, METH_NOARGS, "new_GeometryRefiner() -> GeometryRefiner"}, - { "GeometryRefiner_SetType", _wrap_GeometryRefiner_SetType, METH_VARARGS, "GeometryRefiner_SetType(GeometryRefiner self, int const t)"}, + { "GeometryRefiner_SetType", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_SetType, METH_VARARGS|METH_KEYWORDS, "GeometryRefiner_SetType(GeometryRefiner self, int const t)"}, { "GeometryRefiner_GetType", _wrap_GeometryRefiner_GetType, METH_O, "GeometryRefiner_GetType(GeometryRefiner self) -> int"}, - { "GeometryRefiner_Refine", _wrap_GeometryRefiner_Refine, METH_VARARGS, "GeometryRefiner_Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, - { "GeometryRefiner_RefineInterior", _wrap_GeometryRefiner_RefineInterior, METH_VARARGS, "GeometryRefiner_RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, + { "GeometryRefiner_Refine", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_Refine, METH_VARARGS|METH_KEYWORDS, "GeometryRefiner_Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, + { "GeometryRefiner_RefineInterior", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_RefineInterior, METH_VARARGS|METH_KEYWORDS, "GeometryRefiner_RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, { "delete_GeometryRefiner", _wrap_delete_GeometryRefiner, METH_O, "delete_GeometryRefiner(GeometryRefiner self)"}, { "GeometryRefiner_swigregister", GeometryRefiner_swigregister, METH_O, NULL}, { "GeometryRefiner_swiginit", GeometryRefiner_swiginit, METH_VARARGS, NULL}, @@ -5288,9 +5082,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"}, - { "Geometry_GetVertices", _wrap_Geometry_GetVertices, METH_VARARGS, "GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, - { "Geometry_GetCenter", _wrap_Geometry_GetCenter, METH_VARARGS, "GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, - { "Geometry_GetRandomPoint", _wrap_Geometry_GetRandomPoint, METH_VARARGS, "GetRandomPoint(int GeomType, IntegrationPoint ip)"}, + { "Geometry_GetVertices", (PyCFunction)(void(*)(void))_wrap_Geometry_GetVertices, METH_VARARGS|METH_KEYWORDS, "GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, + { "Geometry_GetCenter", (PyCFunction)(void(*)(void))_wrap_Geometry_GetCenter, METH_VARARGS|METH_KEYWORDS, "GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, + { "Geometry_GetRandomPoint", (PyCFunction)(void(*)(void))_wrap_Geometry_GetRandomPoint, METH_VARARGS|METH_KEYWORDS, "GetRandomPoint(int GeomType, IntegrationPoint ip)"}, { "Geometry_CheckPoint", _wrap_Geometry_CheckPoint, METH_VARARGS, "\n" "CheckPoint(int GeomType, IntegrationPoint ip) -> bool\n" "CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool\n" @@ -5299,11 +5093,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ProjectPoint(int GeomType, IntegrationPoint beg, IntegrationPoint end) -> bool\n" "ProjectPoint(int GeomType, IntegrationPoint ip) -> bool\n" ""}, - { "Geometry_GetGeomToPerfGeomJac", _wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS, "GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfGeomToGeomJac", _wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS, "GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfPointMat", _wrap_Geometry_GetPerfPointMat, METH_VARARGS, "GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, - { "Geometry_JacToPerfJac", _wrap_Geometry_JacToPerfJac, METH_VARARGS, "JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, - { "Geometry_NumBdr", _wrap_Geometry_NumBdr, METH_VARARGS, "NumBdr(Geometry self, int GeomType) -> int"}, + { "Geometry_GetGeomToPerfGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS|METH_KEYWORDS, "GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfGeomToGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS|METH_KEYWORDS, "GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfPointMat", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfPointMat, METH_VARARGS|METH_KEYWORDS, "GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, + { "Geometry_JacToPerfJac", (PyCFunction)(void(*)(void))_wrap_Geometry_JacToPerfJac, METH_VARARGS|METH_KEYWORDS, "JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, + { "Geometry_NumBdr", (PyCFunction)(void(*)(void))_wrap_Geometry_NumBdr, METH_VARARGS|METH_KEYWORDS, "NumBdr(Geometry self, int GeomType) -> int"}, { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL}, { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL}, { "RefinedGeometry_Times_set", _wrap_RefinedGeometry_Times_set, METH_VARARGS, "RefinedGeometry_Times_set(RefinedGeometry self, int Times)"}, @@ -5319,15 +5113,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "RefinedGeometry_NumBdrEdges_get", _wrap_RefinedGeometry_NumBdrEdges_get, METH_O, "RefinedGeometry_NumBdrEdges_get(RefinedGeometry self) -> int"}, { "RefinedGeometry_Type_set", _wrap_RefinedGeometry_Type_set, METH_VARARGS, "RefinedGeometry_Type_set(RefinedGeometry self, int Type)"}, { "RefinedGeometry_Type_get", _wrap_RefinedGeometry_Type_get, METH_O, "RefinedGeometry_Type_get(RefinedGeometry self) -> int"}, - { "new_RefinedGeometry", _wrap_new_RefinedGeometry, METH_VARARGS, "RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0)"}, + { "new_RefinedGeometry", (PyCFunction)(void(*)(void))_wrap_new_RefinedGeometry, METH_VARARGS|METH_KEYWORDS, "new_RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0) -> RefinedGeometry"}, { "delete_RefinedGeometry", _wrap_delete_RefinedGeometry, METH_O, "delete_RefinedGeometry(RefinedGeometry self)"}, { "RefinedGeometry_swigregister", RefinedGeometry_swigregister, METH_O, NULL}, { "RefinedGeometry_swiginit", RefinedGeometry_swiginit, METH_VARARGS, NULL}, { "new_GeometryRefiner", _wrap_new_GeometryRefiner, METH_NOARGS, "new_GeometryRefiner() -> GeometryRefiner"}, - { "GeometryRefiner_SetType", _wrap_GeometryRefiner_SetType, METH_VARARGS, "SetType(GeometryRefiner self, int const t)"}, + { "GeometryRefiner_SetType", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_SetType, METH_VARARGS|METH_KEYWORDS, "SetType(GeometryRefiner self, int const t)"}, { "GeometryRefiner_GetType", _wrap_GeometryRefiner_GetType, METH_O, "GetType(GeometryRefiner self) -> int"}, - { "GeometryRefiner_Refine", _wrap_GeometryRefiner_Refine, METH_VARARGS, "Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, - { "GeometryRefiner_RefineInterior", _wrap_GeometryRefiner_RefineInterior, METH_VARARGS, "RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, + { "GeometryRefiner_Refine", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_Refine, METH_VARARGS|METH_KEYWORDS, "Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, + { "GeometryRefiner_RefineInterior", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_RefineInterior, METH_VARARGS|METH_KEYWORDS, "RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, { "delete_GeometryRefiner", _wrap_delete_GeometryRefiner, METH_O, "delete_GeometryRefiner(GeometryRefiner self)"}, { "GeometryRefiner_swigregister", GeometryRefiner_swigregister, METH_O, NULL}, { "GeometryRefiner_swiginit", GeometryRefiner_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/globals.py b/mfem/_par/globals.py index 78ab457e..cd213347 100644 --- a/mfem/_par/globals.py +++ b/mfem/_par/globals.py @@ -92,8 +92,8 @@ def IsEnabled(self): _globals.OutStream_swigregister(OutStream) -def MakeParFilename(*args): - return _globals.MakeParFilename(*args) +def MakeParFilename(*args, **kwargs): + return _globals.MakeParFilename(*args, **kwargs) MakeParFilename = _globals.MakeParFilename cvar = _globals.cvar diff --git a/mfem/_par/globals_wrap.cxx b/mfem/_par/globals_wrap.cxx index addcf9e1..d5c007a0 100644 --- a/mfem/_par/globals_wrap.cxx +++ b/mfem/_par/globals_wrap.cxx @@ -2934,17 +2934,19 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_OutStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OutStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; std::ostream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"out", NULL + }; mfem::OutStream *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_OutStream", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutStream" "', argument " "1"" of type '" "std::ostream &""'"); } @@ -2975,7 +2977,7 @@ SWIGINTERN PyObject *_wrap_new_OutStream(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_OutStream_SetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OutStream_SetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OutStream *arg1 = (mfem::OutStream *) 0 ; std::ostream *arg2 = 0 ; @@ -2983,15 +2985,19 @@ SWIGINTERN PyObject *_wrap_OutStream_SetStream(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OutStream_SetStream", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OutStream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OutStream_SetStream", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OutStream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutStream_SetStream" "', argument " "1"" of type '" "mfem::OutStream *""'"); } arg1 = reinterpret_cast< mfem::OutStream * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutStream_SetStream" "', argument " "2"" of type '" "std::ostream &""'"); } @@ -3210,12 +3216,12 @@ SWIGINTERN PyObject *Swig_var_err_get(void) { } -SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MakeParFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; std::string *arg1 = 0 ; int arg2 ; - std::string arg3 ; - int arg4 ; + std::string arg3 = (std::string) (std::string)"" ; + int arg4 = (int) (int)6 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -3224,78 +3230,17 @@ SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_0(PyObject *SWIGUNUSEDPARM(self int res3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"prefix", (char *)"myid", (char *)"suffix", (char *)"width", NULL + }; std::string result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); - } - arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MakeParFilename" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MakeParFilename" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - { - try { - result = mfem::MakeParFilename((std::string const &)*arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj((new std::string(static_cast< const std::string& >(result))), SWIGTYPE_p_std__string, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - int arg2 ; - std::string arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 ; - int res3 = 0 ; - std::string result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:MakeParFilename", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); } @@ -3303,74 +3248,36 @@ SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_1(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); } arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MakeParFilename" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - { - try { - result = mfem::MakeParFilename((std::string const &)*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj((new std::string(static_cast< const std::string& >(result))), SWIGTYPE_p_std__string, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - std::string result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MakeParFilename" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); } - arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MakeParFilename" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); { try { - result = mfem::MakeParFilename((std::string const &)*arg1,arg2); + result = mfem::MakeParFilename((std::string const &)*arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3391,108 +3298,33 @@ SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_2(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_MakeParFilename(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MakeParFilename", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MakeParFilename__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MakeParFilename__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MakeParFilename__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MakeParFilename'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MakeParFilename(std::string const &,int const,std::string const,int const)\n" - " mfem::MakeParFilename(std::string const &,int const,std::string const)\n" - " mfem::MakeParFilename(std::string const &,int const)\n"); - return 0; -} - - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, - { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, + { "new_OutStream", (PyCFunction)(void(*)(void))_wrap_new_OutStream, METH_VARARGS|METH_KEYWORDS, NULL}, + { "OutStream_SetStream", (PyCFunction)(void(*)(void))_wrap_OutStream_SetStream, METH_VARARGS|METH_KEYWORDS, NULL}, { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, { "OutStream_Disable", _wrap_OutStream_Disable, METH_O, NULL}, { "OutStream_IsEnabled", _wrap_OutStream_IsEnabled, METH_O, NULL}, { "delete_OutStream", _wrap_delete_OutStream, METH_O, NULL}, { "OutStream_swigregister", OutStream_swigregister, METH_O, NULL}, { "OutStream_swiginit", OutStream_swiginit, METH_VARARGS, NULL}, - { "MakeParFilename", _wrap_MakeParFilename, METH_VARARGS, NULL}, + { "MakeParFilename", (PyCFunction)(void(*)(void))_wrap_MakeParFilename, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, - { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, + { "new_OutStream", (PyCFunction)(void(*)(void))_wrap_new_OutStream, METH_VARARGS|METH_KEYWORDS, NULL}, + { "OutStream_SetStream", (PyCFunction)(void(*)(void))_wrap_OutStream_SetStream, METH_VARARGS|METH_KEYWORDS, NULL}, { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, { "OutStream_Disable", _wrap_OutStream_Disable, METH_O, NULL}, { "OutStream_IsEnabled", _wrap_OutStream_IsEnabled, METH_O, NULL}, { "delete_OutStream", _wrap_delete_OutStream, METH_O, NULL}, { "OutStream_swigregister", OutStream_swigregister, METH_O, NULL}, { "OutStream_swiginit", OutStream_swiginit, METH_VARARGS, NULL}, - { "MakeParFilename", _wrap_MakeParFilename, METH_VARARGS, NULL}, + { "MakeParFilename", (PyCFunction)(void(*)(void))_wrap_MakeParFilename, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/gridfunc_wrap.cxx b/mfem/_par/gridfunc_wrap.cxx index 0c986fe7..3d09e434 100644 --- a/mfem/_par/gridfunc_wrap.cxx +++ b/mfem/_par/gridfunc_wrap.cxx @@ -3994,7 +3994,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GridFunction_MakeOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; @@ -4002,15 +4002,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeOwner(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_fec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_MakeOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_MakeOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeOwner" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeOwner" "', argument " "2"" of type '" "mfem::FiniteElementCollection *""'"); } @@ -4182,7 +4186,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetTrueVector(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_GridFunction_GetTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4190,15 +4194,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetTrueDofs(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetTrueDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetTrueDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetTrueDofs" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetTrueDofs" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4250,7 +4258,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_SetTrueVector(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4258,15 +4266,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SetFromTrueDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_SetFromTrueDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SetFromTrueDofs" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SetFromTrueDofs" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4323,13 +4335,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_0(PyObject *SWIGUNU mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::Array< double > *arg3 = 0 ; - int arg4 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); @@ -4349,11 +4361,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "3"" of type '" "mfem::Array< double > &""'"); } arg3 = reinterpret_cast< mfem::Array< double > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { @@ -4370,119 +4384,217 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::Array< double > *arg3 = 0 ; + mfem::IntegrationPoint *arg3 = 0 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"ip", (char *)"vdim", NULL + }; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:GridFunction_GetValue", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetNodalValues" "', argument " "3"" of type '" "mfem::Array< double > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "3"" of type '" "mfem::Array< double > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } - arg3 = reinterpret_cast< mfem::Array< double > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetNodalValues(arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->GetValue(arg2,(mfem::IntegrationPoint const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationPoint *arg3 = 0 ; - int arg4 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double result; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"ip", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GridFunction_GetVectorValue", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + try { + ((mfem::GridFunction const *)arg1)->GetVectorValue(arg2,(mfem::IntegrationPoint const &)*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 = (int) 1 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { - result = (double)((mfem::GridFunction const *)arg1)->GetValue(arg2,(mfem::IntegrationPoint const &)*arg3,arg4); + ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::IntegrationPoint *arg3 = 0 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double result; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4491,38 +4603,62 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValue__SWIG_1(PyObject *SWIGUNUSEDPAR }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } } - arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); { try { - result = (double)((mfem::GridFunction const *)arg1)->GetValue(arg2,(mfem::IntegrationPoint const &)*arg3); + ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValue", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValues", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -4537,15 +4673,33 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *self, PyObject *args) } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationPoint, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetValue__SWIG_1(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); + } + } } } } } - if (argc == 4) { + if ((argc >= 5) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -4560,19 +4714,32 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *self, PyObject *args) } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationPoint, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetValue__SWIG_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); + } + } } } } @@ -4580,32 +4747,32 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *self, PyObject *args) } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValue'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValues'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &,int) const\n" - " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &) const\n"); + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::IntegrationPoint *arg3 = 0 ; + mfem::IntegrationRule *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValue", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4614,25 +4781,33 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM( }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } - arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } { try { - ((mfem::GridFunction const *)arg1)->GetVectorValue(arg2,(mfem::IntegrationPoint const &)*arg3,*arg4); + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4645,24 +4820,27 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - int arg5 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4673,29 +4851,39 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4708,83 +4896,129 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetLaplacians", 0, 6, argv))) SWIG_fail; + --argc; + if ((argc >= 4) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); + } + } + } + } + } } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + if ((argc >= 5) && (argc <= 6)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); + } + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetLaplacians'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; + mfem::DenseMatrix *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4795,37 +5029,31 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4838,13 +5066,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -4854,10 +5083,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -4868,31 +5097,39 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4905,15 +5142,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValues", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetHessians", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 4) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -4932,16 +5169,29 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); + if (argc <= 4) { + return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); + } } } } } } - if (argc == 5) { + if ((argc >= 5) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -4960,95 +5210,27 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetValues__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetValues__SWIG_2(self, argc, argv); - } + if (argc <= 5) { + return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); + } } } } @@ -5057,87 +5239,118 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetHessians'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; + int arg3 ; + mfem::IntegrationRule *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + int arg7 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"side", (char *)"ir", (char *)"vals", (char *)"tr", (char *)"vdim", NULL + }; + int result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:GridFunction_GetFaceValues", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + if (obj6) { + { + if ((PyArray_PyIntAsInt(obj6) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(obj6); + } } { try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; + mfem::ElementTransformation *arg2 = 0 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; @@ -5146,34 +5359,36 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUS if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + ((mfem::GridFunction const *)arg1)->GetVectorValues(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5186,14 +5401,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -5203,10 +5417,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUS void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -5217,37 +5431,31 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUS } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } { try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + ((mfem::GridFunction const *)arg1)->GetVectorValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5260,141 +5468,36 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetLaplacians", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_3(self, argc, argv); - } - } - } - } - } + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValues", 0, 5, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_GetVectorValues__SWIG_0(self, argc, argv); + } + } + } + } } if (argc == 5) { int _v; @@ -5415,62 +5518,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject * _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_2(self, argc, argv); - } + return _wrap_GridFunction_GetVectorValues__SWIG_1(self, argc, argv); } } } @@ -5479,123 +5534,172 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject * } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetLaplacians'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetVectorValues'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetVectorValues(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" + " mfem::GridFunction::GetVectorValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetFaceVectorValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; + int arg3 ; + mfem::IntegrationRule *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"side", (char *)"ir", (char *)"vals", (char *)"tr", NULL + }; + int result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:GridFunction_GetFaceVectorValues", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + result = (int)((mfem::GridFunction const *)arg1)->GetFaceVectorValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"orig_func", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetValuesFrom", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + { + try { + (arg1)->GetValuesFrom((mfem::GridFunction const &)*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetBdrValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::GridFunction *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"orig_func", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetBdrValuesFrom", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + (arg1)->GetBdrValuesFrom((mfem::GridFunction const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5608,14 +5712,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; + int arg6 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -5624,52 +5728,63 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_2(PyObject *SWIGUNUSED int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"ir", (char *)"vals", (char *)"tr", (char *)"comp", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:GridFunction_GetVectorFieldValues", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); + } } { try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + ((mfem::GridFunction const *)arg1)->GetVectorFieldValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5682,61 +5797,70 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_2(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ReorderByNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ReorderByNodes" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + try { + (arg1)->ReorderByNodes(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 = (int) 1 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetNodalValues(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5749,76 +5873,42 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetHessians", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetNodalValues", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 4) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); - } + if (argc <= 2) { + return _wrap_GridFunction_GetNodalValues__SWIG_1(self, argc, argv); } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_3(self, argc, argv); - } - } + return _wrap_GridFunction_GetNodalValues__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -5833,403 +5923,403 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *ar } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_2(self, argc, argv); - } + if (argc <= 3) { + return _wrap_GridFunction_GetNodalValues__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_GridFunction_GetNodalValues__SWIG_0(self, argc, argv); + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetHessians'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetNodalValues'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetNodalValues(int,mfem::Array< double > &,int) const\n" + " mfem::GridFunction::GetNodalValues(mfem::Vector &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldNodalValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; - int arg7 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"val", (char *)"comp", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetVectorFieldNodalValues", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + arg3 = PyArray_PyIntAsInt(obj2); } - arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + { + try { + ((mfem::GridFunction const *)arg1)->GetVectorFieldNodalValues(*arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::GridFunction *arg2 = 0 ; + int arg3 = (int) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vec_field", (char *)"comp", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:GridFunction_ProjectVectorFieldOn", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6,arg7); + (arg1)->ProjectVectorFieldOn(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetDerivative(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::GridFunction *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"comp", (char *)"der_comp", (char *)"der", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GridFunction_GetDerivative", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDerivative" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); - } - arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); { try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); + (arg1)->GetDerivative(arg2,arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetFaceValues", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetFaceValues__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetFaceValues__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetFaceValues'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetFaceValues(int,int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetFaceValues(int,int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetDivergence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::ElementTransformation *arg2 = 0 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", NULL + }; + double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetDivergence", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDivergence" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + { + try { + result = (double)((mfem::GridFunction const *)arg1)->GetDivergence(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", (char *)"curl", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetCurl", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetCurl" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::GridFunction const *)arg1)->GetCurl(*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", (char *)"grad", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetGradient", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + ((mfem::GridFunction const *)arg1)->GetGradient(*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - ((mfem::GridFunction const *)arg1)->GetVectorValues(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + ((mfem::GridFunction const *)arg1)->GetGradients(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6242,26 +6332,23 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -6272,31 +6359,23 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_1(PyObject *SWIGUN } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetVectorValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetGradients(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6309,13 +6388,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetGradients(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[6] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValues", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetGradients", 0, 4, argv))) SWIG_fail; --argc; if (argc == 4) { int _v; @@ -6334,13 +6413,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetVectorValues__SWIG_0(self, argc, argv); + return _wrap_GridFunction_GetGradients__SWIG_0(self, argc, argv); } } } } } - if (argc == 5) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -6362,12 +6441,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetVectorValues__SWIG_1(self, argc, argv); - } + return _wrap_GridFunction_GetGradients__SWIG_1(self, argc, argv); } } } @@ -6375,121 +6449,61 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetVectorValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetGradients'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetVectorValues(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" - " mfem::GridFunction::GetVectorValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetGradients(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" + " mfem::GridFunction::GetGradients(int const,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceVectorValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject *swig_obj[6] ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetFaceVectorValues", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetVectorGradient", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); - { - try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceVectorValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetValuesFrom", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - (arg1)->GetValuesFrom((mfem::GridFunction const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + { + try { + ((mfem::GridFunction const *)arg1)->GetVectorGradient(*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } resultobj = SWIG_Py_Void(); return resultobj; @@ -6498,7 +6512,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValuesFrom(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GridFunction_GetBdrValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetElementAverages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::GridFunction *arg2 = 0 ; @@ -6506,25 +6520,29 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetBdrValuesFrom(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"avgs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetBdrValuesFrom", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetElementAverages", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetElementAverages" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - (arg1)->GetBdrValuesFrom((mfem::GridFunction const &)*arg2); + ((mfem::GridFunction const *)arg1)->GetElementAverages(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6537,14 +6555,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetBdrValuesFrom(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -6554,10 +6571,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_0(PyObject *S void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -6566,39 +6583,33 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_0(PyObject *S }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetVectorFieldValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,(mfem::Vector const &)*arg4,(mfem::Vector const &)*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6611,26 +6622,26 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_0(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 = (double) 0.0 ; + double arg5 = (double) mfem::infinity() ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -6639,33 +6650,31 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_1(PyObject *S }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetVectorFieldValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6678,15 +6687,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorFieldValues", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ImposeBounds", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 5) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -6701,25 +6710,33 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyO } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + if (argc <= 3) { + return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[3], NULL); _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - return _wrap_GridFunction_GetVectorFieldValues__SWIG_1(self, argc, argv); + return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); } } } } } } - if (argc == 6) { + if (argc == 5) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -6734,28 +6751,16 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyO } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetVectorFieldValues__SWIG_0(self, argc, argv); - } + return _wrap_GridFunction_ImposeBounds__SWIG_0(self, argc, argv); } } } @@ -6764,31 +6769,45 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyO } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetVectorFieldValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ImposeBounds'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetVectorFieldValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetVectorFieldValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,mfem::Vector const &,mfem::Vector const &)\n" + " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,double,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ReorderByNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"src", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_ProjectGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ReorderByNodes" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectGridFunction" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - (arg1)->ReorderByNodes(); + (arg1)->ProjectGridFunction((mfem::GridFunction const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6801,39 +6820,32 @@ SWIGINTERN PyObject *_wrap_GridFunction_ReorderByNodes(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; - int arg3 ; + mfem::Coefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->GetNodalValues(*arg2,arg3); + (arg1)->ProjectCoefficient(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6846,33 +6858,53 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - ((mfem::GridFunction const *)arg1)->GetNodalValues(*arg2); - } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + { + try { + (arg1)->ProjectCoefficient(*arg2,*arg3,arg4); + } catch (Swig::DirectorException &e) { SWIG_fail; } @@ -6884,156 +6916,32 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_3(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetNodalValues", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetNodalValues'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetNodalValues(int,mfem::Array< double > &,int) const\n" - " mfem::GridFunction::GetNodalValues(int,mfem::Array< double > &) const\n" - " mfem::GridFunction::GetNodalValues(mfem::Vector &,int) const\n" - " mfem::GridFunction::GetNodalValues(mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldNodalValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; - int arg3 ; + mfem::VectorCoefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorFieldNodalValues", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->GetVectorFieldNodalValues(*arg2,arg3); + (arg1)->ProjectCoefficient(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7046,39 +6954,43 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldNodalValues(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; - int arg3 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectVectorFieldOn(*arg2,arg3); + (arg1)->ProjectCoefficient(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7091,10 +7003,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_0(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; + mfem::Coefficient **arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7103,20 +7015,17 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_1(PyObject *S if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); { try { - (arg1)->ProjectVectorFieldOn(*arg2); + (arg1)->ProjectCoefficient(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7129,13 +7038,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectVectorFieldOn", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectCoefficient", 0, 4, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -7144,10 +7053,38 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn(PyObject *self, PyO _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_2(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectVectorFieldOn__SWIG_1(self, argc, argv); + return _wrap_GridFunction_ProjectCoefficient__SWIG_4(self, argc, argv); } } } @@ -7158,74 +7095,89 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn(PyObject *self, PyO _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectVectorFieldOn__SWIG_0(self, argc, argv); + return _wrap_GridFunction_ProjectCoefficient__SWIG_3(self, argc, argv); } } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectVectorFieldOn'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectVectorFieldOn(mfem::GridFunction &,int)\n" - " mfem::GridFunction::ProjectVectorFieldOn(mfem::GridFunction &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetDerivative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - int arg3 ; - mfem::GridFunction *arg4 = 0 ; + if ((argc >= 3) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectCoefficient'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &,int)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient *[])\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetDerivative", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDerivative" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - (arg1)->GetDerivative(arg2,arg3,*arg4); + (arg1)->ProjectDiscCoefficient(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7238,84 +7190,86 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetDerivative(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GridFunction_GetDivergence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::GridFunction::AvgType arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; - double result; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetDivergence", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDivergence" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); + } + arg3 = static_cast< mfem::GridFunction::AvgType >(val3); { try { - result = (double)((mfem::GridFunction const *)arg1)->GetDivergence(*arg2); + (arg1)->ProjectDiscCoefficient(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::GridFunction::AvgType arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetCurl", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetCurl" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); - } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); + } + arg3 = static_cast< mfem::GridFunction::AvgType >(val3); { try { - ((mfem::GridFunction const *)arg1)->GetCurl(*arg2,*arg3); + (arg1)->ProjectDiscCoefficient(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7328,44 +7282,116 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetCurl(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_GridFunction_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectDiscCoefficient", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectDiscCoefficient'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &)\n" + " mfem::GridFunction::ProjectDiscCoefficient(mfem::Coefficient &,mfem::GridFunction::AvgType)\n" + " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &,mfem::GridFunction::AvgType)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetGradient", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetGradient(*arg2,*arg3); + (arg1)->ProjectBdrCoefficient(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7378,54 +7404,43 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetGradient(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetGradients(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + (arg1)->ProjectBdrCoefficient(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7438,50 +7453,40 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Coefficient **arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetGradients(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + (arg1)->ProjectBdrCoefficient(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7494,113 +7499,125 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_GridFunction_GetGradients(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetGradients", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficient", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetGradients__SWIG_0(self, argc, argv); - } + return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(self, argc, argv); } } } } - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(self, argc, argv); } } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetGradients__SWIG_1(self, argc, argv); - } + return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetGradients'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectBdrCoefficient'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetGradients(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" - " mfem::GridFunction::GetGradients(int const,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient &,mfem::Array< int > &)\n" + " mfem::GridFunction::ProjectBdrCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" + " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient *[],mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::DenseMatrix *arg3 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vcoeff", (char *)"bdr_attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorGradient", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_ProjectBdrCoefficientNormal", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetVectorGradient(*arg2,*arg3); + (arg1)->ProjectBdrCoefficientNormal(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7613,33 +7630,49 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorGradient(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetElementAverages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientTangent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vcoeff", (char *)"bdr_attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetElementAverages", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_ProjectBdrCoefficientTangent", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetElementAverages" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetElementAverages(*arg2); + (arg1)->ProjectBdrCoefficientTangent(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7652,353 +7685,273 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetElementAverages(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,(mfem::Vector const &)*arg4,(mfem::Vector const &)*arg5); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - double arg5 ; + mfem::Coefficient **arg2 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "double""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); } - arg5 = static_cast< double >(val5); - { - try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,arg4,arg5); + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,arg4); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; + mfem::Array< int > *arg4 = (mfem::Array< int > *) NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeL2Error" "', argument " "4"" of type '" "mfem::Array< int > *""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[6] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ImposeBounds", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL2Error", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_3(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL2Error__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + { + _v = PyList_Check(argv[2]) ? 1 : 0; } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_2(self, argc, argv); - } + return _wrap_GridFunction_ComputeL2Error__SWIG_0(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL2Error__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_0(self, argc, argv); - } - } + return _wrap_GridFunction_ComputeL2Error__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); + if (argc <= 3) { + return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); - } + return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); } } } @@ -8006,329 +7959,280 @@ SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds(PyObject *self, PyObject *a } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ImposeBounds'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL2Error'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,mfem::Vector const &,mfem::Vector const &)\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,double,double)\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,double)\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &)\n"); + " mfem::GridFunction::ComputeL2Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeL2Error(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[],mfem::Array< int > *) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeH1Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; + mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; + mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; + double arg5 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"exsol", (char *)"exgrad", (char *)"ell_coef", (char *)"Nu", (char *)"norm_type", NULL + }; + double result; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ProjectGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:GridFunction_ComputeH1Error", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectGridFunction" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeH1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - (arg1)->ProjectGridFunction((mfem::GridFunction const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - try { - (arg1)->ProjectCoefficient(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeH1Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeH1Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeH1Error" "', argument " "4"" of type '" "mfem::Coefficient *""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ComputeH1Error" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg6 = PyArray_PyIntAsInt(obj5); } { try { - (arg1)->ProjectCoefficient(*arg2,*arg3,arg4); + result = (double)((mfem::GridFunction const *)arg1)->ComputeH1Error(arg2,arg3,arg4,arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectCoefficient(*arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; + mfem::Coefficient **arg2 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - (arg1)->ProjectCoefficient(*arg2); + result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - (arg1)->ProjectCoefficient(*arg2,*arg3); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); { try { - (arg1)->ProjectCoefficient(arg2); + result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectCoefficient", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeMaxError", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -8338,272 +8242,296 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient(PyObject *self, PyObj int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_0(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_ComputeMaxError__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeMaxError__SWIG_0(self, argc, argv); + } } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_3(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_ComputeMaxError__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeMaxError__SWIG_1(self, argc, argv); + } } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_4(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_ComputeMaxError__SWIG_2(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_2(self, argc, argv); + { + _v = PyList_Check(argv[2]) ? 1 : 0; } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_1(self, argc, argv); - } + return _wrap_GridFunction_ComputeMaxError__SWIG_2(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectCoefficient'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeMaxError'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &,int)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient *[])\n"); + " mfem::GridFunction::ComputeMaxError(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeMaxError(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeMaxError(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - (arg1)->ProjectDiscCoefficient(*arg2); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction::AvgType arg3 ; + mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; + mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; + int arg4 ; + mfem::Array< int > *arg5 = (mfem::Array< int > *) NULL ; + mfem::IntegrationRule **arg6 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"exsol", (char *)"exgrad", (char *)"norm_type", (char *)"elems", (char *)"irs", NULL + }; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OO:GridFunction_ComputeW11Error", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); - } - arg3 = static_cast< mfem::GridFunction::AvgType >(val3); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); + } + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeW11Error" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + } + if (obj5) { + { + if (PyList_Check(obj5)) { + int size = PyList_Size(obj5); + int i = 0; + arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(obj5,i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg6[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } { try { - (arg1)->ProjectDiscCoefficient(*arg2,arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction::AvgType arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); - } - arg3 = static_cast< mfem::GridFunction::AvgType >(val3); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } { try { - (arg1)->ProjectDiscCoefficient(*arg2,arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectDiscCoefficient", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL1Error", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -8613,17 +8541,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient(PyObject *self, P int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_GridFunction_ComputeL1Error__SWIG_0(self, argc, argv); + } { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); + _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(self, argc, argv); + return _wrap_GridFunction_ComputeL1Error__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -8633,113 +8563,184 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient(PyObject *self, P int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_GridFunction_ComputeL1Error__SWIG_1(self, argc, argv); + } { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); + _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(self, argc, argv); + return _wrap_GridFunction_ComputeL1Error__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectDiscCoefficient'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL1Error'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &)\n" - " mfem::GridFunction::ProjectDiscCoefficient(mfem::Coefficient &,mfem::GridFunction::AvgType)\n" - " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &,mfem::GridFunction::AvgType)\n"); + " mfem::GridFunction::ComputeL1Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeL1Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + double arg2 ; + mfem::Coefficient *arg3 = 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; + mfem::IntegrationRule **arg5 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - (arg1)->ProjectBdrCoefficient(*arg2,*arg3); + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); } - resultobj = SWIG_Py_Void(); + if (swig_obj[4]) { + { + if (PyList_Check(swig_obj[4])) { + int size = PyList_Size(swig_obj[4]); + int i = 0; + arg5 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[4],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg5[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } + { + try { + result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,(mfem::IntegrationRule const *(*))arg5); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + double arg2 ; + mfem::Coefficient *arg3 = 0 ; + mfem::GridFunction *arg4 = 0 ; + mfem::Coefficient *arg5 = (mfem::Coefficient *) NULL ; + mfem::IntegrationRule **arg6 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); + if (swig_obj[4]) { + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); + } + arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); + } + if (swig_obj[5]) { + { + if (PyList_Check(swig_obj[5])) { + int size = PyList_Size(swig_obj[5]); + int i = 0; + arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[5],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg6[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficient(*arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,(mfem::IntegrationRule const *(*))arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8752,11 +8753,12 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - mfem::Array< int > *arg3 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8764,28 +8766,52 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(PyObject * void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficient(arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8798,120 +8824,65 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(PyObject * } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficient", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectBdrCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectBdrCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient *[],mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficientNormal", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficientNormal(*arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8924,44 +8895,65 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientNormal(PyObject *SW } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientTangent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficientTangent", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficientTangent(*arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8974,53 +8966,83 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientTangent(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; + double arg2 ; + mfem::VectorCoefficient *arg3 = 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; + mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) NULL ; + mfem::IntegrationRule **arg6 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; + void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); + } + if (swig_obj[4]) { + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); + } + arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); + } + if (swig_obj[5]) { + { + if (PyList_Check(swig_obj[5])) { + int size = PyList_Size(swig_obj[5]); + int i = 0; + arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[5],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg6[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9033,311 +9055,534 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; +SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeLpError", 0, 6, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[4]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); + } + } + } + } + } } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2); + if ((argc >= 3) && (argc <= 6)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[5]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeLpError'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - mfem::IntegrationRule **arg3 ; + double arg2 ; + mfem::VectorCoefficient *arg3 = 0 ; + mfem::GridFunction *arg4 = 0 ; + mfem::Coefficient *arg5 = (mfem::Coefficient *) NULL ; + mfem::VectorCoefficient *arg6 = (mfem::VectorCoefficient *) NULL ; + mfem::IntegrationRule **arg7 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); + } + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); + if (swig_obj[4]) { + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); } + arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(arg2,(mfem::IntegrationRule const *(*))arg3); + if (swig_obj[5]) { + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "6"" of type '" "mfem::VectorCoefficient *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg6 = reinterpret_cast< mfem::VectorCoefficient * >(argp6); } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + if (swig_obj[6]) { + { + if (PyList_Check(swig_obj[6])) { + int size = PyList_Size(swig_obj[6]); + int i = 0; + arg7 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[6],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg7[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(arg2); + ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,arg6,(mfem::IntegrationRule const *(*))arg7); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - mfem::Array< int > *arg4 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[8] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementLpErrors", 0, 7, argv))) SWIG_fail; + --argc; + if ((argc >= 4) && (argc <= 6)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[5]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); + } + } + } } - arg3[i] = reinterpret_cast(temp); } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeL2Error" "', argument " "4"" of type '" "mfem::Array< int > *""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3,arg4); + if ((argc >= 4) && (argc <= 7)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 6) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[6]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + } + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementLpErrors'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL1Errors", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_0(self, argc, argv); + } + } + } + } + } + if ((argc >= 3) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL1Errors'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ComputeElementL1Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementL1Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2); + ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL2Error", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL2Errors", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -9347,25 +9592,24 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_3(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_0(self, argc, argv); + } + } } } } - if (argc == 2) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -9375,68 +9619,140 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_0(self, argc, argv); + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_1(self, argc, argv); + } } } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_5(self, argc, argv); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL2Errors'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ComputeElementL2Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementL2Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } } } - if (argc == 3) { + { + try { + ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementMaxErrors", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(self, argc, argv); + } } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -9446,15 +9762,18 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_4(self, argc, argv); + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(self, argc, argv); } } } @@ -9462,737 +9781,547 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL2Error'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementMaxErrors'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[],mfem::Array< int > *) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &) const\n"); + " mfem::GridFunction::ComputeElementMaxErrors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementMaxErrors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeH1Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - double arg5 ; - int arg6 ; + mfem::BilinearFormIntegrator *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + bool arg4 = (bool) true ; + int arg5 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - PyObject *swig_obj[6] ; - double result; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blfi", (char *)"flux", (char *)"wcoef", (char *)"subdomain", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ComputeH1Error", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:GridFunction_ComputeFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeH1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeH1Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); + } + arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeH1Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeH1Error" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ComputeH1Error" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeH1Error(arg2,arg3,arg4,arg5,arg6); + (arg1)->ComputeFlux(*arg2,*arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; + double val2 ; + int ecode2 = 0 ; + mfem::GridFunction *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Assign" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_Assign" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); + result = (mfem::GridFunction *) &(arg1)->operator =(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + mfem::GridFunction *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Assign" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_Assign" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_Assign" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2); + result = (mfem::GridFunction *) &(arg1)->operator =((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; +SWIGINTERN PyObject *_wrap_GridFunction_Assign(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_Assign", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_Assign__SWIG_0(self, argc, argv); + } + } } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_Assign__SWIG_2(self, argc, argv); } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(arg2,(mfem::IntegrationRule const *(*))arg3); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GridFunction_Assign__SWIG_1(self, argc, argv); + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_Assign'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::operator =(mfem::GridFunction const &)\n" + " mfem::GridFunction::operator =(double)\n" + " mfem::GridFunction::operator =(mfem::Vector const &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Update" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(arg2); + (arg1)->Update(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; + mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_FESpace" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); + result = (mfem::FiniteElementSpace *)(arg1)->FESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_FESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; + mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_FESpace" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2); + result = (mfem::FiniteElementSpace *)((mfem::GridFunction const *)arg1)->FESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_FESpace(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeMaxError", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_FESpace", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_4(self, argc, argv); - } - } + return _wrap_GridFunction_FESpace__SWIG_0(self, argc, argv); } } - if (argc == 3) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_2(self, argc, argv); - } - } + return _wrap_GridFunction_FESpace__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeMaxError'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_FESpace'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::VectorCoefficient &) const\n"); - return 0; + " mfem::GridFunction::FESpace()\n" + " mfem::GridFunction::FESpace() const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_SetSpace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SetSpace" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SetSpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); + (arg1)->SetSpace(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2); + (arg1)->MakeRef(*arg2,arg3,arg4); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; - int arg4 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - mfem::IntegrationRule **arg6 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeW11Error" "', argument " "5"" of type '" "mfem::Array< int > *""'"); - } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if (PyList_Check(swig_obj[5])) { - int size = PyList_Size(swig_obj[5]); - int i = 0; - arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[5],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg6[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); + (arg1)->MakeRef(*arg2,arg3); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; - int arg4 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + double *arg3 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeW11Error" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeRef" "', argument " "3"" of type '" "double *""'"); } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + arg3 = reinterpret_cast< double * >(argp3); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4,arg5); + (arg1)->MakeRef(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::Vector *arg3 = 0 ; int arg4 ; void *argp1 = 0 ; int res1 = 0 ; @@ -10200,24 +10329,26 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_2(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double result; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeRef" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -10226,69 +10357,88 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_2(PyObject *SWIGUN } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4); + (arg1)->MakeRef(arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeW11Error", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_MakeRef", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_ComputeW11Error__SWIG_2(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_GridFunction_MakeRef__SWIG_0_1(self, argc, argv); + } } } } - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_MakeRef__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { @@ -10299,29 +10449,24 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error(PyObject *self, PyObject } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeW11Error__SWIG_1(self, argc, argv); - } + return _wrap_GridFunction_MakeRef__SWIG_0_0(self, argc, argv); } } } } } - if (argc == 6) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { { @@ -10333,17 +10478,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error(PyObject *self, PyObject } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[5]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeW11Error__SWIG_0(self, argc, argv); - } - } + return _wrap_GridFunction_MakeRef__SWIG_2(self, argc, argv); } } } @@ -10351,149 +10486,120 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeW11Error'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_MakeRef'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeW11Error(mfem::Coefficient *,mfem::VectorCoefficient *,int,mfem::Array< int > *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeW11Error(mfem::Coefficient *,mfem::VectorCoefficient *,int,mfem::Array< int > *) const\n" - " mfem::GridFunction::ComputeW11Error(mfem::Coefficient *,mfem::VectorCoefficient *,int) const\n"); + " MakeRef(mfem::Vector &,int,int)\n" + " MakeRef(mfem::Vector &,int)\n" + " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,double *)\n" + " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,mfem::Vector &,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeTRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + double *arg3 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeTRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeTRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeTRef" "', argument " "3"" of type '" "double *""'"); } + arg3 = reinterpret_cast< double * >(argp3); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); + (arg1)->MakeTRef(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeTRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeTRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeTRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeTRef" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeTRef" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2); + (arg1)->MakeTRef(arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeTRef(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL1Error", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_MakeTRef", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_3(self, argc, argv); - } - } - } if (argc == 3) { int _v; void *vptr = 0; @@ -10501,299 +10607,279 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error(PyObject *self, PyObject _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_2(self, argc, argv); + return _wrap_GridFunction_MakeTRef__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_0(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_MakeTRef__SWIG_1(self, argc, argv); + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL1Error'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_MakeTRef'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeL1Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL1Error(mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeL1Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL1Error(mfem::VectorCoefficient &) const\n"); + " mfem::GridFunction::MakeTRef(mfem::FiniteElementSpace *,double *)\n" + " mfem::GridFunction::MakeTRef(mfem::FiniteElementSpace *,mfem::Vector &,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::IntegrationRule **arg5 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Save" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); { - if (PyList_Check(swig_obj[4])) { - int size = PyList_Size(swig_obj[4]); - int i = 0; - arg5 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[4],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg5[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,(mfem::IntegrationRule const *(*))arg5); + ((mfem::GridFunction const *)arg1)->Save(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; + std::ostream *arg2 = 0 ; + std::string *arg3 = 0 ; + int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", (char *)"field_name", (char *)"ref", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GridFunction_SaveVTK", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveVTK" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); + { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_SaveVTK" "', argument " "3"" of type '" "std::string const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_SaveVTK" "', argument " "3"" of type '" "std::string const &""'"); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + arg3 = reinterpret_cast< std::string * >(argp3); + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4); + (arg1)->SaveVTK(*arg2,(std::string const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; + std::ostream *arg2 = 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", (char *)"TimesToRefine", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:GridFunction_SaveSTL", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveSTL" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3); + (arg1)->SaveSTL(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_GridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - mfem::IntegrationRule **arg6 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridFunction" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - { - if (PyList_Check(swig_obj[5])) { - int size = PyList_Size(swig_obj[5]); - int i = 0; - arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[5],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg6[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } { try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,(mfem::IntegrationRule const *(*))arg6); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10806,4119 +10892,565 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_0(PyObject } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GridFunction__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + char *arg2 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + mfem::GridFunction *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridFunction" "', argument " "2"" of type '" "char const *""'"); } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); + arg2 = reinterpret_cast< char * >(buf2); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5); + result = (mfem::GridFunction *)new_mfem_GridFunction__SWIG_6(arg1,(char const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NEW | 0 ); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GridFunction__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + mfem::GridFunction *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunction" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridFunction" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridFunction" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4); + result = (mfem::GridFunction *)new_mfem_GridFunction__SWIG_7(arg1,(mfem::Vector const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); +SWIGINTERN PyObject *_wrap_new_GridFunction(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GridFunction", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_GridFunction__SWIG_0(self, argc, argv); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_GridFunction__SWIG_1(self, argc, argv); + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_GridFunction__SWIG_2(self, argc, argv); + } } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_GridFunction__SWIG_3(self, argc, argv); + } + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_GridFunction__SWIG_4(self, argc, argv); + } + } } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_GridFunction__SWIG_6(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_GridFunction__SWIG_5(self, argc, argv); } - arg4[i] = reinterpret_cast(temp); } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_GridFunction__SWIG_7(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GridFunction'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GridFunction()\n" + " mfem::GridFunction::GridFunction(mfem::GridFunction const &)\n" + " mfem::GridFunction::GridFunction(mfem::FiniteElementSpace *)\n" + " mfem::GridFunction::GridFunction(mfem::FiniteElementSpace *,double *)\n" + " mfem::GridFunction::GridFunction(mfem::Mesh *,std::istream &)\n" + " mfem::GridFunction::GridFunction(mfem::Mesh *,mfem::GridFunction *[],int)\n" + " mfem::GridFunction::GridFunction(mfem::Mesh *,char const *)\n" + " mfem::GridFunction::GridFunction(mfem::FiniteElementSpace *,mfem::Vector const &,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_SaveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf_file", (char *)"precision", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_SaveToFile", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveToFile" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SaveToFile" "', argument " "2"" of type '" "char const *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + arg2 = reinterpret_cast< char * >(buf2); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3); + mfem_GridFunction_SaveToFile((mfem::GridFunction const *)arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_iadd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; + mfem::GridFunction *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_iadd", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_iadd" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_iadd" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_iadd" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); + result = (mfem::GridFunction *) &mfem_GridFunction_iadd(arg1,*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_isub__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + mfem::GridFunction *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_isub" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_isub" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_isub" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3); + result = (mfem::GridFunction *) &mfem_GridFunction_isub__SWIG_0(arg1,*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_isub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double val2 ; + int ecode2 = 0 ; + mfem::GridFunction *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_isub" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_isub" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); + result = (mfem::GridFunction *) &mfem_GridFunction_isub__SWIG_1(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; +SWIGINTERN PyObject *_wrap_GridFunction_isub(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_isub", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_isub__SWIG_0(self, argc, argv); + } + } } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GridFunction_isub__SWIG_1(self, argc, argv); + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_isub'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::isub(mfem::GridFunction &)\n" + " mfem::GridFunction::isub(double)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_imul(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) 0 ; - mfem::IntegrationRule **arg6 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; + mfem::GridFunction *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_imul", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_imul" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_imul" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); - } - arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); - { - if (PyList_Check(swig_obj[5])) { - int size = PyList_Size(swig_obj[5]); - int i = 0; - arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[5],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg6[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); + result = (mfem::GridFunction *) &mfem_GridFunction_imul(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_idiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) 0 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; + mfem::GridFunction *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_idiv", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_idiv" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_idiv" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); - } - arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,arg5); + result = (mfem::GridFunction *) &mfem_GridFunction_idiv(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Save" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_Save" "', argument " "2"" of type '" "char const *""'"); } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4); + mfem_GridFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeLpError", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_6(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_5(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[4]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_4(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[5]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_3(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeLpError'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg6 = (mfem::VectorCoefficient *) 0 ; - mfem::IntegrationRule **arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "6"" of type '" "mfem::VectorCoefficient *""'"); - } - arg6 = reinterpret_cast< mfem::VectorCoefficient * >(argp6); - { - if (PyList_Check(swig_obj[6])) { - int size = PyList_Size(swig_obj[6]); - int i = 0; - arg7 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[6],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg7[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,arg6,(mfem::IntegrationRule const *(*))arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg6 = (mfem::VectorCoefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "6"" of type '" "mfem::VectorCoefficient *""'"); - } - arg6 = reinterpret_cast< mfem::VectorCoefficient * >(argp6); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementLpErrors", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_6(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_5(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[5]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_4(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[6]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_3(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementLpErrors'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::VectorCoefficient *) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL1Errors", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL1Errors'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL2Errors", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL2Errors'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementMaxErrors", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementMaxErrors'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::BilinearFormIntegrator *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - bool arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->ComputeFlux(*arg2,*arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::BilinearFormIntegrator *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - (arg1)->ComputeFlux(*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::BilinearFormIntegrator *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - (arg1)->ComputeFlux(*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeFlux", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeFlux__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GridFunction_ComputeFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_ComputeFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool,int)\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool)\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Assign__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Assign" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_Assign" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::GridFunction *) &(arg1)->operator =(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Assign__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Assign" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_Assign" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_Assign" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - result = (mfem::GridFunction *) &(arg1)->operator =((mfem::Vector const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Assign(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_Assign", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_Assign__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_Assign__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GridFunction_Assign__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_Assign'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::operator =(mfem::GridFunction const &)\n" - " mfem::GridFunction::operator =(double)\n" - " mfem::GridFunction::operator =(mfem::Vector const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Update" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - try { - (arg1)->Update(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_FESpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_FESpace" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)(arg1)->FESpace(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_FESpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_FESpace" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)((mfem::GridFunction const *)arg1)->FESpace(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_FESpace(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_FESpace", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_FESpace__SWIG_0(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_FESpace__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_FESpace'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::FESpace()\n" - " mfem::GridFunction::FESpace() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SetSpace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SetSpace" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SetSpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - { - try { - (arg1)->SetSpace(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->MakeRef(*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->MakeRef(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - double *arg3 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeRef" "', argument " "3"" of type '" "double *""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - { - try { - (arg1)->MakeRef(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeRef" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeRef" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->MakeRef(arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeRef(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_MakeRef", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_0_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_0_0(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_MakeRef__SWIG_2(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_MakeRef'.\n" - " Possible C/C++ prototypes are:\n" - " MakeRef(mfem::Vector &,int,int)\n" - " MakeRef(mfem::Vector &,int)\n" - " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,double *)\n" - " mfem::GridFunction::MakeRef(mfem::FiniteElementSpace *,mfem::Vector &,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeTRef__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - double *arg3 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeTRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeTRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeTRef" "', argument " "3"" of type '" "double *""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - { - try { - (arg1)->MakeTRef(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeTRef__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeTRef" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeTRef" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_MakeTRef" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_MakeTRef" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->MakeTRef(arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_MakeTRef(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_MakeTRef", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_MakeTRef__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_MakeTRef__SWIG_1(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_MakeTRef'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::MakeTRef(mfem::FiniteElementSpace *,double *)\n" - " mfem::GridFunction::MakeTRef(mfem::FiniteElementSpace *,mfem::Vector &,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Save" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->Save(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - std::ostream *arg2 = 0 ; - std::string *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SaveVTK", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveVTK" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_SaveVTK" "', argument " "3"" of type '" "std::string const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_SaveVTK" "', argument " "3"" of type '" "std::string const &""'"); - } - arg3 = reinterpret_cast< std::string * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->SaveVTK(*arg2,(std::string const &)*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveSTL" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->SaveSTL(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveSTL" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->SaveSTL(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_SaveSTL", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_SaveSTL__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_SaveSTL__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_SaveSTL'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::SaveSTL(std::ostream &,int)\n" - " mfem::GridFunction::SaveSTL(std::ostream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_GridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GridFunction" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GridFunction__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridFunction" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - result = (mfem::GridFunction *)new_mfem_GridFunction__SWIG_6(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NEW | 0 ); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GridFunction__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Vector *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunction" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridFunction" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GridFunction" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::GridFunction *)new_mfem_GridFunction__SWIG_7(arg1,(mfem::Vector const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GridFunction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GridFunction", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GridFunction__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GridFunction__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GridFunction__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GridFunction__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GridFunction__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GridFunction__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_GridFunction__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_GridFunction__SWIG_7(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GridFunction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GridFunction()\n" - " mfem::GridFunction::GridFunction(mfem::GridFunction const &)\n" - " mfem::GridFunction::GridFunction(mfem::FiniteElementSpace *)\n" - " mfem::GridFunction::GridFunction(mfem::FiniteElementSpace *,double *)\n" - " mfem::GridFunction::GridFunction(mfem::Mesh *,std::istream &)\n" - " mfem::GridFunction::GridFunction(mfem::Mesh *,mfem::GridFunction *[],int)\n" - " mfem::GridFunction::GridFunction(mfem::Mesh *,char const *)\n" - " mfem::GridFunction::GridFunction(mfem::FiniteElementSpace *,mfem::Vector const &,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_SaveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SaveToFile", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveToFile" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SaveToFile" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_GridFunction_SaveToFile((mfem::GridFunction const *)arg1,(char const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_iadd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - mfem::GridFunction *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_iadd", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_iadd" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_iadd" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_iadd" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - result = (mfem::GridFunction *) &mfem_GridFunction_iadd(arg1,*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_isub__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_isub" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_isub" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_isub" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - result = (mfem::GridFunction *) &mfem_GridFunction_isub__SWIG_0(arg1,*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_isub__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_isub" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_isub" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::GridFunction *) &mfem_GridFunction_isub__SWIG_1(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_isub(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_isub", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_isub__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GridFunction_isub__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_isub'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::isub(mfem::GridFunction &)\n" - " mfem::GridFunction::isub(double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_imul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::GridFunction *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_imul", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_imul" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_imul" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::GridFunction *) &mfem_GridFunction_imul(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_idiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::GridFunction *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_idiv", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_idiv" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_idiv" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::GridFunction *) &mfem_GridFunction_idiv(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Save" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_GridFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Save" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_GridFunction_Save__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } @@ -14931,7 +11463,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_Save", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -14940,7 +11472,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_Save__SWIG_1(self, argc, argv); + } } } } @@ -14964,36 +11509,12 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::GridFunction::Save(std::ostream &) const\n" - " mfem::GridFunction::Save(char const *,int)\n" - " mfem::GridFunction::Save(char const *)\n"); + " mfem::GridFunction::Save(char const *,int)\n"); return 0; } @@ -15124,22 +11645,24 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_1(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; mfem::QuadratureFunction *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); } arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -15157,45 +11680,17 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_2(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::QuadratureFunction *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - { - try { - result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; double *arg2 = (double *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; mfem::QuadratureFunction *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); @@ -15206,51 +11701,17 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_4(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureFunction" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1,arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - double *arg2 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::QuadratureFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureFunction" "', argument " "2"" of type '" "double *""'"); } - arg2 = reinterpret_cast< double * >(argp2); { try { - result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1,arg2); + result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15263,7 +11724,7 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_5(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; std::istream *arg2 = 0 ; @@ -15311,45 +11772,25 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args if (!(argc = SWIG_Python_UnpackTuple(args, "new_QuadratureFunction", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_QuadratureFunction__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureFunction__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureFunction__SWIG_3(self, argc, argv); - } + return _wrap_new_QuadratureFunction__SWIG_0(self, argc, argv); } - if (argc == 2) { + if (argc == 1) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureFunction__SWIG_5(self, argc, argv); - } + return _wrap_new_QuadratureFunction__SWIG_1(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_QuadratureFunction__SWIG_2(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15363,21 +11804,7 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args } } } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureFunction__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); @@ -15387,6 +11814,9 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_QuadratureFunction__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15396,11 +11826,25 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args } } if (_v) { - return _wrap_new_QuadratureFunction__SWIG_4(self, argc, argv); + return _wrap_new_QuadratureFunction__SWIG_3(self, argc, argv); } } } } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_QuadratureFunction__SWIG_4(self, argc, argv); + } + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuadratureFunction'.\n" @@ -15408,9 +11852,7 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args " mfem::QuadratureFunction::QuadratureFunction()\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureFunction const &)\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *,int)\n" - " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *)\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *,double *,int)\n" - " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *,double *)\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::Mesh *,std::istream &)\n"); return 0; } @@ -15479,13 +11921,13 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_0(PyObject *SWIGUNU PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; - int arg3 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); @@ -15496,11 +11938,13 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_SetSpace" "', argument " "2"" of type '" "mfem::QuadratureSpace *""'"); } arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -15518,46 +11962,11 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_0(PyObject *SWIGUNU SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_SetSpace" "', argument " "2"" of type '" "mfem::QuadratureSpace *""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); - { - try { - (arg1)->SetSpace(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; double *arg3 = (double *) 0 ; - int arg4 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -15565,7 +11974,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_2(PyObject *SWIGUNU void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); @@ -15581,58 +11990,17 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_2(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_SetSpace" "', argument " "3"" of type '" "double *""'"); } arg3 = reinterpret_cast< double * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->SetSpace(arg2,arg3,arg4); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; - double *arg3 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_SetSpace" "', argument " "2"" of type '" "mfem::QuadratureSpace *""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_SetSpace" "', argument " "3"" of type '" "double *""'"); } - arg3 = reinterpret_cast< double * >(argp3); { try { - (arg1)->SetSpace(arg2,arg3); + (arg1)->SetSpace(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15653,21 +12021,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_SetSpace", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_SetSpace__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); @@ -15677,25 +12031,9 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_SetSpace__SWIG_3(self, argc, argv); + if (argc <= 2) { + return _wrap_QuadratureFunction_SetSpace__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15710,7 +12048,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); @@ -15724,6 +12062,9 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_QuadratureFunction_SetSpace__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15733,7 +12074,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject } } if (_v) { - return _wrap_QuadratureFunction_SetSpace__SWIG_2(self, argc, argv); + return _wrap_QuadratureFunction_SetSpace__SWIG_1(self, argc, argv); } } } @@ -15744,9 +12085,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_SetSpace'.\n" " Possible C/C++ prototypes are:\n" " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,int)\n" - " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *)\n" - " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,double *,int)\n" - " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,double *)\n"); + " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,double *,int)\n"); return 0; } @@ -15781,25 +12120,29 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetVDim(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdim_", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunction_SetVDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureFunction_SetVDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetVDim" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -15846,7 +12189,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_OwnsSpace(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetOwnsSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_SetOwnsSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; bool arg2 ; @@ -15854,103 +12197,26 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetOwnsSpace(PyObject *SWIGUNUSEDP int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"own", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunction_SetOwnsSpace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureFunction_SetOwnsSpace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetOwnsSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunction_SetOwnsSpace" "', argument " "2"" of type '" "bool""'"); } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetOwnsSpace(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::IntegrationRule *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunction_GetElementIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementIntRule" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::IntegrationRule *) &((mfem::QuadratureFunction const *)arg1)->GetElementIntRule(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = static_cast< bool >(val2); { try { - (arg1)->GetElementValues(arg2,*arg3); + (arg1)->SetOwnsSpace(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15963,56 +12229,51 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_0(PyObject } -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; int arg2 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureFunction_GetElementIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementIntRule" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::QuadratureFunction const *)arg1)->GetElementValues(arg2,*arg3); + result = (mfem::IntegrationRule *) &((mfem::QuadratureFunction const *)arg1)->GetElementIntRule(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -16030,14 +12291,14 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_2(PyObject }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { (arg1)->GetElementValues(arg2,*arg3); @@ -16053,11 +12314,11 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_2(PyObject } -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -16075,14 +12336,14 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { ((mfem::QuadratureFunction const *)arg1)->GetElementValues(arg2,*arg3); @@ -16098,290 +12359,136 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject } -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_GetElementValues", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_3(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_GetElementValues'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &)\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &) const\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &)\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::QuadratureFunction const *)arg1)->Save(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - mfem_QuadratureFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); + (arg1)->GetElementValues(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - char *arg2 = (char *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_Save" "', argument " "2"" of type '" "char const *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - mfem_QuadratureFunction_Save__SWIG_1(arg1,(char const *)arg2); + ((mfem::QuadratureFunction const *)arg1)->GetElementValues(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_Save", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_GetElementValues", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_QuadratureFunction_Save__SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_QuadratureFunction_GetElementValues__SWIG_0(self, argc, argv); + } } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); _v = SWIG_CheckState(res); if (_v) { { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); _v = 0; } else { @@ -16389,7 +12496,12 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_QuadratureFunction_Save__SWIG_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_QuadratureFunction_GetElementValues__SWIG_1(self, argc, argv); + } } } } @@ -16399,403 +12511,360 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_QuadratureFunction_Save__SWIG_1(self, argc, argv); + return _wrap_QuadratureFunction_GetElementValues__SWIG_2(self, argc, argv); } } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_Save'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureFunction::Save(std::ostream &) const\n" - " mfem::QuadratureFunction::Save(char const *,int)\n" - " mfem::QuadratureFunction::Save(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *QuadratureFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__QuadratureFunction, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *QuadratureFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::ostream *arg1 = 0 ; - mfem::QuadratureFunction *arg2 = 0 ; - PyMFEM::wFILE *temp1 = 0 ; - std::ofstream out1 ; - void *argp2 = 0 ; - int res2 = 0 ; - std::ostream *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp1->isSTDOUT() == 1) { - arg1 = &std::cout; - } - else { - out1.open(temp1->getFilename()); - out1.precision(temp1->getPrecision()); - arg1 = &out1; - } - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureFunction * >(argp2); - { - try { - result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::QuadratureFunction const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } - return resultobj; -fail: - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } - PyErr_Clear(); - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; -} - - -SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { + if (argc == 3) { int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap___lshift____SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); if (_v) { - return _wrap___lshift____SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_QuadratureFunction_GetElementValues__SWIG_3(self, argc, argv); + } } } } fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_GetElementValues'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &)\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &) const\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &)\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &) const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - int arg6 ; - bool arg7 ; + mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - bool val7 ; - int ecode7 = 0 ; - double result; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ZZErrorEstimator" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7); + ((mfem::QuadratureFunction const *)arg1)->Save(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - int arg6 ; + mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_Save" "', argument " "2"" of type '" "char const *""'"); } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6); + mfem_QuadratureFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_Save", 0, 3, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_QuadratureFunction_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_QuadratureFunction_Save__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_QuadratureFunction_Save__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_Save'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::QuadratureFunction::Save(std::ostream &) const\n" + " mfem::QuadratureFunction::Save(char const *,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *QuadratureFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__QuadratureFunction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *QuadratureFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + std::ostream *arg1 = 0 ; + mfem::QuadratureFunction *arg2 = 0 ; + PyMFEM::wFILE *temp1 = 0 ; + std::ofstream out1 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + std::ostream *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp1->isSTDOUT() == 1) { + arg1 = &std::cout; + } + else { + out1.open(temp1->getFilename()); + out1.precision(temp1->getPrecision()); + arg1 = &out1; + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + arg2 = reinterpret_cast< mfem::QuadratureFunction * >(argp2); { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5); + result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::QuadratureFunction const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } return resultobj; fail: - return NULL; + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap___lshift____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap___lshift____SWIG_2(self, argc, argv); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::Array< int > *arg5 = (mfem::Array< int > *) NULL ; + int arg6 = (int) 1 ; + bool arg7 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -16804,10 +12873,24 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"blfi", (char *)"u", (char *)"flux", (char *)"error_estimates", (char *)"aniso_flags", (char *)"with_subdomains", (char *)"with_coeff", NULL + }; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:ZZErrorEstimator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -16815,7 +12898,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } @@ -16823,7 +12906,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } @@ -16831,7 +12914,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -16839,9 +12922,31 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + } + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); + } + } + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ZZErrorEstimator" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + } { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4); + result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16854,164 +12959,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ZZErrorEstimator", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZZErrorEstimator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int,bool)\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int)\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *)\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -17023,22 +12971,28 @@ SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"i", (char *)"gf1", (char *)"gf2", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ComputeElementLpDistance", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ComputeElementLpDistance", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ComputeElementLpDistance" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComputeElementLpDistance" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } @@ -17046,7 +13000,7 @@ SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeElementLpDistance" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ComputeElementLpDistance" "', argument " "4"" of type '" "mfem::GridFunction &""'"); } @@ -17069,7 +13023,7 @@ SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::Coefficient *arg2 = 0 ; @@ -17078,16 +13032,21 @@ SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"m", (char *)"s", (char *)"_n", NULL + }; mfem::ExtrudeCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ExtrudeCoefficient", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_ExtrudeCoefficient", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtrudeCoefficient" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExtrudeCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } @@ -17096,10 +13055,10 @@ SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self) } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -17116,7 +13075,7 @@ SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ExtrudeCoefficient *arg1 = (mfem::ExtrudeCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -17127,16 +13086,21 @@ SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ExtrudeCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ExtrudeCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ExtrudeCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ExtrudeCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtrudeCoefficient_Eval" "', argument " "1"" of type '" "mfem::ExtrudeCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ExtrudeCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtrudeCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -17144,7 +13108,7 @@ SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtrudeCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtrudeCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17207,7 +13171,7 @@ SWIGINTERN PyObject *ExtrudeCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -17219,30 +13183,36 @@ SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"mesh2d", (char *)"sol", (char *)"ny", NULL + }; mfem::GridFunction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Extrude1DGridFunction", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Extrude1DGridFunction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude1DGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Extrude1DGridFunction" "', argument " "2"" of type '" "mfem::Mesh *""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Extrude1DGridFunction" "', argument " "3"" of type '" "mfem::GridFunction *""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -17262,19 +13232,19 @@ SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "GridFunction_MakeOwner", _wrap_GridFunction_MakeOwner, METH_VARARGS, "GridFunction_MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, + { "GridFunction_MakeOwner", (PyCFunction)(void(*)(void))_wrap_GridFunction_MakeOwner, METH_VARARGS|METH_KEYWORDS, "GridFunction_MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, { "GridFunction_OwnFEC", _wrap_GridFunction_OwnFEC, METH_O, "GridFunction_OwnFEC(GridFunction self) -> FiniteElementCollection"}, { "GridFunction_VectorDim", _wrap_GridFunction_VectorDim, METH_O, "GridFunction_VectorDim(GridFunction self) -> int"}, { "GridFunction_GetTrueVector", _wrap_GridFunction_GetTrueVector, METH_VARARGS, "\n" "GridFunction_GetTrueVector(GridFunction self) -> Vector\n" "GridFunction_GetTrueVector(GridFunction self) -> Vector\n" ""}, - { "GridFunction_GetTrueDofs", _wrap_GridFunction_GetTrueDofs, METH_VARARGS, "GridFunction_GetTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_GetTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetTrueDofs, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetTrueVector", _wrap_GridFunction_SetTrueVector, METH_O, "GridFunction_SetTrueVector(GridFunction self)"}, - { "GridFunction_SetFromTrueDofs", _wrap_GridFunction_SetFromTrueDofs, METH_VARARGS, "GridFunction_SetFromTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetFromTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetFromTrueDofs, METH_VARARGS|METH_KEYWORDS, "GridFunction_SetFromTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetFromTrueVector", _wrap_GridFunction_SetFromTrueVector, METH_O, "GridFunction_SetFromTrueVector(GridFunction self)"}, - { "GridFunction_GetValue", _wrap_GridFunction_GetValue, METH_VARARGS, "GridFunction_GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, - { "GridFunction_GetVectorValue", _wrap_GridFunction_GetVectorValue, METH_VARARGS, "GridFunction_GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, + { "GridFunction_GetValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValue, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, + { "GridFunction_GetVectorValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorValue, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, { "GridFunction_GetValues", _wrap_GridFunction_GetValues, METH_VARARGS, "\n" "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" @@ -17287,37 +13257,37 @@ static PyMethodDef SwigMethods[] = { "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" ""}, - { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GridFunction_GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, + { "GridFunction_GetFaceValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" "GridFunction_GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" "GridFunction_GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr)\n" ""}, - { "GridFunction_GetFaceVectorValues", _wrap_GridFunction_GetFaceVectorValues, METH_VARARGS, "GridFunction_GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, - { "GridFunction_GetValuesFrom", _wrap_GridFunction_GetValuesFrom, METH_VARARGS, "GridFunction_GetValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetBdrValuesFrom", _wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS, "GridFunction_GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetVectorFieldValues", _wrap_GridFunction_GetVectorFieldValues, METH_VARARGS, "GridFunction_GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, + { "GridFunction_GetFaceVectorValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceVectorValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, + { "GridFunction_GetValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValuesFrom, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetBdrValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetVectorFieldValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, { "GridFunction_ReorderByNodes", _wrap_GridFunction_ReorderByNodes, METH_O, "GridFunction_ReorderByNodes(GridFunction self)"}, { "GridFunction_GetNodalValues", _wrap_GridFunction_GetNodalValues, METH_VARARGS, "\n" "GridFunction_GetNodalValues(GridFunction self, int i, doubleArray nval, int vdim=1)\n" "GridFunction_GetNodalValues(GridFunction self, Vector nval, int vdim=1)\n" ""}, - { "GridFunction_GetVectorFieldNodalValues", _wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS, "GridFunction_GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, - { "GridFunction_ProjectVectorFieldOn", _wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS, "GridFunction_ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, - { "GridFunction_GetDerivative", _wrap_GridFunction_GetDerivative, METH_VARARGS, "GridFunction_GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, - { "GridFunction_GetDivergence", _wrap_GridFunction_GetDivergence, METH_VARARGS, "GridFunction_GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, - { "GridFunction_GetCurl", _wrap_GridFunction_GetCurl, METH_VARARGS, "GridFunction_GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, - { "GridFunction_GetGradient", _wrap_GridFunction_GetGradient, METH_VARARGS, "GridFunction_GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, + { "GridFunction_GetVectorFieldNodalValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, + { "GridFunction_ProjectVectorFieldOn", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, + { "GridFunction_GetDerivative", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDerivative, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, + { "GridFunction_GetDivergence", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDivergence, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, + { "GridFunction_GetCurl", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetCurl, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, + { "GridFunction_GetGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetGradient, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, { "GridFunction_GetGradients", _wrap_GridFunction_GetGradients, METH_VARARGS, "\n" "GridFunction_GetGradients(GridFunction self, ElementTransformation tr, IntegrationRule ir, DenseMatrix grad)\n" "GridFunction_GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad)\n" ""}, - { "GridFunction_GetVectorGradient", _wrap_GridFunction_GetVectorGradient, METH_VARARGS, "GridFunction_GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, - { "GridFunction_GetElementAverages", _wrap_GridFunction_GetElementAverages, METH_VARARGS, "GridFunction_GetElementAverages(GridFunction self, GridFunction avgs)"}, + { "GridFunction_GetVectorGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorGradient, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, + { "GridFunction_GetElementAverages", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetElementAverages, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetElementAverages(GridFunction self, GridFunction avgs)"}, { "GridFunction_ImposeBounds", _wrap_GridFunction_ImposeBounds, METH_VARARGS, "\n" "GridFunction_ImposeBounds(GridFunction self, int i, Vector weights, Vector _lo, Vector _hi)\n" "GridFunction_ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity())\n" ""}, - { "GridFunction_ProjectGridFunction", _wrap_GridFunction_ProjectGridFunction, METH_VARARGS, "GridFunction_ProjectGridFunction(GridFunction self, GridFunction src)"}, + { "GridFunction_ProjectGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectGridFunction, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectGridFunction(GridFunction self, GridFunction src)"}, { "GridFunction_ProjectCoefficient", _wrap_GridFunction_ProjectCoefficient, METH_VARARGS, "\n" "GridFunction_ProjectCoefficient(GridFunction self, Coefficient coeff)\n" "GridFunction_ProjectCoefficient(GridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" @@ -17335,20 +13305,20 @@ static PyMethodDef SwigMethods[] = { "GridFunction_ProjectBdrCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray attr)\n" "GridFunction_ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" ""}, - { "GridFunction_ProjectBdrCoefficientNormal", _wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS, "GridFunction_ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, - { "GridFunction_ProjectBdrCoefficientTangent", _wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "GridFunction_ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientNormal", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientTangent", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, { "GridFunction_ComputeL2Error", _wrap_GridFunction_ComputeL2Error, METH_VARARGS, "\n" "GridFunction_ComputeL2Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeL2Error(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double\n" ""}, - { "GridFunction_ComputeH1Error", _wrap_GridFunction_ComputeH1Error, METH_VARARGS, "GridFunction_ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, + { "GridFunction_ComputeH1Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeH1Error, METH_VARARGS|METH_KEYWORDS, "GridFunction_ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, { "GridFunction_ComputeMaxError", _wrap_GridFunction_ComputeMaxError, METH_VARARGS, "\n" "GridFunction_ComputeMaxError(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeMaxError(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" ""}, - { "GridFunction_ComputeW11Error", _wrap_GridFunction_ComputeW11Error, METH_VARARGS, "GridFunction_ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, + { "GridFunction_ComputeW11Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeW11Error, METH_VARARGS|METH_KEYWORDS, "GridFunction_ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, { "GridFunction_ComputeL1Error", _wrap_GridFunction_ComputeL1Error, METH_VARARGS, "\n" "GridFunction_ComputeL1Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" @@ -17373,7 +13343,7 @@ static PyMethodDef SwigMethods[] = { "GridFunction_ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" "GridFunction_ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" ""}, - { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "GridFunction_ComputeFlux", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeFlux, METH_VARARGS|METH_KEYWORDS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" "GridFunction_Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" "GridFunction_Assign(GridFunction self, double value) -> GridFunction\n" @@ -17384,7 +13354,7 @@ static PyMethodDef SwigMethods[] = { "GridFunction_FESpace(GridFunction self) -> FiniteElementSpace\n" "GridFunction_FESpace(GridFunction self) -> FiniteElementSpace\n" ""}, - { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "GridFunction_SetSpace(GridFunction self, FiniteElementSpace f)"}, + { "GridFunction_SetSpace", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetSpace, METH_VARARGS|METH_KEYWORDS, "GridFunction_SetSpace(GridFunction self, FiniteElementSpace f)"}, { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" "GridFunction_MakeRef(GridFunction self, Vector base, int offset, int size)\n" "GridFunction_MakeRef(GridFunction self, Vector base, int offset)\n" @@ -17395,8 +13365,8 @@ static PyMethodDef SwigMethods[] = { "GridFunction_MakeTRef(GridFunction self, FiniteElementSpace f, double * tv)\n" "GridFunction_MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset)\n" ""}, - { "GridFunction_SaveVTK", _wrap_GridFunction_SaveVTK, METH_VARARGS, "GridFunction_SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, - { "GridFunction_SaveSTL", _wrap_GridFunction_SaveSTL, METH_VARARGS, "GridFunction_SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, + { "GridFunction_SaveVTK", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveVTK, METH_VARARGS|METH_KEYWORDS, "GridFunction_SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, + { "GridFunction_SaveSTL", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveSTL, METH_VARARGS|METH_KEYWORDS, "GridFunction_SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, { "delete_GridFunction", _wrap_delete_GridFunction, METH_O, "delete_GridFunction(GridFunction self)"}, { "new_GridFunction", _wrap_new_GridFunction, METH_VARARGS, "\n" "GridFunction()\n" @@ -17408,14 +13378,14 @@ static PyMethodDef SwigMethods[] = { "GridFunction(Mesh m, char const * grid_file)\n" "new_GridFunction(FiniteElementSpace fes, Vector v, int offset) -> GridFunction\n" ""}, - { "GridFunction_SaveToFile", _wrap_GridFunction_SaveToFile, METH_VARARGS, "GridFunction_SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, - { "GridFunction_iadd", _wrap_GridFunction_iadd, METH_VARARGS, "GridFunction_iadd(GridFunction self, GridFunction c) -> GridFunction"}, + { "GridFunction_SaveToFile", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveToFile, METH_VARARGS|METH_KEYWORDS, "GridFunction_SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, + { "GridFunction_iadd", (PyCFunction)(void(*)(void))_wrap_GridFunction_iadd, METH_VARARGS|METH_KEYWORDS, "GridFunction_iadd(GridFunction self, GridFunction c) -> GridFunction"}, { "GridFunction_isub", _wrap_GridFunction_isub, METH_VARARGS, "\n" "GridFunction_isub(GridFunction self, GridFunction c) -> GridFunction\n" "GridFunction_isub(GridFunction self, double c) -> GridFunction\n" ""}, - { "GridFunction_imul", _wrap_GridFunction_imul, METH_VARARGS, "GridFunction_imul(GridFunction self, double c) -> GridFunction"}, - { "GridFunction_idiv", _wrap_GridFunction_idiv, METH_VARARGS, "GridFunction_idiv(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_imul", (PyCFunction)(void(*)(void))_wrap_GridFunction_imul, METH_VARARGS|METH_KEYWORDS, "GridFunction_imul(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_idiv", (PyCFunction)(void(*)(void))_wrap_GridFunction_idiv, METH_VARARGS|METH_KEYWORDS, "GridFunction_idiv(GridFunction self, double c) -> GridFunction"}, { "GridFunction_Save", _wrap_GridFunction_Save, METH_VARARGS, "\n" "GridFunction_Save(GridFunction self, std::ostream & out)\n" "GridFunction_Save(GridFunction self, char const * file, int precision=8)\n" @@ -17436,10 +13406,10 @@ static PyMethodDef SwigMethods[] = { "QuadratureFunction_SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1)\n" ""}, { "QuadratureFunction_GetVDim", _wrap_QuadratureFunction_GetVDim, METH_O, "QuadratureFunction_GetVDim(QuadratureFunction self) -> int"}, - { "QuadratureFunction_SetVDim", _wrap_QuadratureFunction_SetVDim, METH_VARARGS, "QuadratureFunction_SetVDim(QuadratureFunction self, int vdim_)"}, + { "QuadratureFunction_SetVDim", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetVDim, METH_VARARGS|METH_KEYWORDS, "QuadratureFunction_SetVDim(QuadratureFunction self, int vdim_)"}, { "QuadratureFunction_OwnsSpace", _wrap_QuadratureFunction_OwnsSpace, METH_O, "QuadratureFunction_OwnsSpace(QuadratureFunction self) -> bool"}, - { "QuadratureFunction_SetOwnsSpace", _wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS, "QuadratureFunction_SetOwnsSpace(QuadratureFunction self, bool own)"}, - { "QuadratureFunction_GetElementIntRule", _wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS, "QuadratureFunction_GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, + { "QuadratureFunction_SetOwnsSpace", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS|METH_KEYWORDS, "QuadratureFunction_SetOwnsSpace(QuadratureFunction self, bool own)"}, + { "QuadratureFunction_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "QuadratureFunction_GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, { "QuadratureFunction_GetElementValues", _wrap_QuadratureFunction_GetElementValues, METH_VARARGS, "\n" "QuadratureFunction_GetElementValues(QuadratureFunction self, int idx, Vector values)\n" "QuadratureFunction_GetElementValues(QuadratureFunction self, int idx, Vector values)\n" @@ -17457,33 +13427,33 @@ static PyMethodDef SwigMethods[] = { "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" ""}, - { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, - { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, - { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, - { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "ExtrudeCoefficient_Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "ZZErrorEstimator", (PyCFunction)(void(*)(void))_wrap_ZZErrorEstimator, METH_VARARGS|METH_KEYWORDS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, + { "ComputeElementLpDistance", (PyCFunction)(void(*)(void))_wrap_ComputeElementLpDistance, METH_VARARGS|METH_KEYWORDS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, + { "new_ExtrudeCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ExtrudeCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, + { "ExtrudeCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ExtrudeCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ExtrudeCoefficient_Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ExtrudeCoefficient", _wrap_delete_ExtrudeCoefficient, METH_O, "delete_ExtrudeCoefficient(ExtrudeCoefficient self)"}, { "ExtrudeCoefficient_swigregister", ExtrudeCoefficient_swigregister, METH_O, NULL}, { "ExtrudeCoefficient_swiginit", ExtrudeCoefficient_swiginit, METH_VARARGS, NULL}, - { "Extrude1DGridFunction", _wrap_Extrude1DGridFunction, METH_VARARGS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, + { "Extrude1DGridFunction", (PyCFunction)(void(*)(void))_wrap_Extrude1DGridFunction, METH_VARARGS|METH_KEYWORDS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "GridFunction_MakeOwner", _wrap_GridFunction_MakeOwner, METH_VARARGS, "MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, + { "GridFunction_MakeOwner", (PyCFunction)(void(*)(void))_wrap_GridFunction_MakeOwner, METH_VARARGS|METH_KEYWORDS, "MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, { "GridFunction_OwnFEC", _wrap_GridFunction_OwnFEC, METH_O, "OwnFEC(GridFunction self) -> FiniteElementCollection"}, { "GridFunction_VectorDim", _wrap_GridFunction_VectorDim, METH_O, "VectorDim(GridFunction self) -> int"}, { "GridFunction_GetTrueVector", _wrap_GridFunction_GetTrueVector, METH_VARARGS, "\n" "GetTrueVector(GridFunction self) -> Vector\n" "GetTrueVector(GridFunction self) -> Vector\n" ""}, - { "GridFunction_GetTrueDofs", _wrap_GridFunction_GetTrueDofs, METH_VARARGS, "GetTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_GetTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetTrueDofs, METH_VARARGS|METH_KEYWORDS, "GetTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetTrueVector", _wrap_GridFunction_SetTrueVector, METH_O, "SetTrueVector(GridFunction self)"}, - { "GridFunction_SetFromTrueDofs", _wrap_GridFunction_SetFromTrueDofs, METH_VARARGS, "SetFromTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetFromTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetFromTrueDofs, METH_VARARGS|METH_KEYWORDS, "SetFromTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetFromTrueVector", _wrap_GridFunction_SetFromTrueVector, METH_O, "SetFromTrueVector(GridFunction self)"}, - { "GridFunction_GetValue", _wrap_GridFunction_GetValue, METH_VARARGS, "GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, - { "GridFunction_GetVectorValue", _wrap_GridFunction_GetVectorValue, METH_VARARGS, "GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, + { "GridFunction_GetValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValue, METH_VARARGS|METH_KEYWORDS, "GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, + { "GridFunction_GetVectorValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorValue, METH_VARARGS|METH_KEYWORDS, "GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, { "GridFunction_GetValues", _wrap_GridFunction_GetValues, METH_VARARGS, "\n" "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" @@ -17496,37 +13466,37 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" ""}, - { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, + { "GridFunction_GetFaceValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceValues, METH_VARARGS|METH_KEYWORDS, "GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" "GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" "GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr)\n" ""}, - { "GridFunction_GetFaceVectorValues", _wrap_GridFunction_GetFaceVectorValues, METH_VARARGS, "GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, - { "GridFunction_GetValuesFrom", _wrap_GridFunction_GetValuesFrom, METH_VARARGS, "GetValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetBdrValuesFrom", _wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS, "GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetVectorFieldValues", _wrap_GridFunction_GetVectorFieldValues, METH_VARARGS, "GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, + { "GridFunction_GetFaceVectorValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceVectorValues, METH_VARARGS|METH_KEYWORDS, "GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, + { "GridFunction_GetValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValuesFrom, METH_VARARGS|METH_KEYWORDS, "GetValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetBdrValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS|METH_KEYWORDS, "GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetVectorFieldValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldValues, METH_VARARGS|METH_KEYWORDS, "GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, { "GridFunction_ReorderByNodes", _wrap_GridFunction_ReorderByNodes, METH_O, "ReorderByNodes(GridFunction self)"}, { "GridFunction_GetNodalValues", _wrap_GridFunction_GetNodalValues, METH_VARARGS, "\n" "GetNodalValues(GridFunction self, int i, doubleArray nval, int vdim=1)\n" "GetNodalValues(GridFunction self, Vector nval, int vdim=1)\n" ""}, - { "GridFunction_GetVectorFieldNodalValues", _wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS, "GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, - { "GridFunction_ProjectVectorFieldOn", _wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS, "ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, - { "GridFunction_GetDerivative", _wrap_GridFunction_GetDerivative, METH_VARARGS, "GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, - { "GridFunction_GetDivergence", _wrap_GridFunction_GetDivergence, METH_VARARGS, "GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, - { "GridFunction_GetCurl", _wrap_GridFunction_GetCurl, METH_VARARGS, "GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, - { "GridFunction_GetGradient", _wrap_GridFunction_GetGradient, METH_VARARGS, "GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, + { "GridFunction_GetVectorFieldNodalValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS|METH_KEYWORDS, "GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, + { "GridFunction_ProjectVectorFieldOn", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS|METH_KEYWORDS, "ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, + { "GridFunction_GetDerivative", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDerivative, METH_VARARGS|METH_KEYWORDS, "GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, + { "GridFunction_GetDivergence", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDivergence, METH_VARARGS|METH_KEYWORDS, "GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, + { "GridFunction_GetCurl", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetCurl, METH_VARARGS|METH_KEYWORDS, "GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, + { "GridFunction_GetGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, { "GridFunction_GetGradients", _wrap_GridFunction_GetGradients, METH_VARARGS, "\n" "GetGradients(GridFunction self, ElementTransformation tr, IntegrationRule ir, DenseMatrix grad)\n" "GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad)\n" ""}, - { "GridFunction_GetVectorGradient", _wrap_GridFunction_GetVectorGradient, METH_VARARGS, "GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, - { "GridFunction_GetElementAverages", _wrap_GridFunction_GetElementAverages, METH_VARARGS, "GetElementAverages(GridFunction self, GridFunction avgs)"}, + { "GridFunction_GetVectorGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorGradient, METH_VARARGS|METH_KEYWORDS, "GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, + { "GridFunction_GetElementAverages", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetElementAverages, METH_VARARGS|METH_KEYWORDS, "GetElementAverages(GridFunction self, GridFunction avgs)"}, { "GridFunction_ImposeBounds", _wrap_GridFunction_ImposeBounds, METH_VARARGS, "\n" "ImposeBounds(GridFunction self, int i, Vector weights, Vector _lo, Vector _hi)\n" "ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity())\n" ""}, - { "GridFunction_ProjectGridFunction", _wrap_GridFunction_ProjectGridFunction, METH_VARARGS, "ProjectGridFunction(GridFunction self, GridFunction src)"}, + { "GridFunction_ProjectGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectGridFunction, METH_VARARGS|METH_KEYWORDS, "ProjectGridFunction(GridFunction self, GridFunction src)"}, { "GridFunction_ProjectCoefficient", _wrap_GridFunction_ProjectCoefficient, METH_VARARGS, "\n" "ProjectCoefficient(GridFunction self, Coefficient coeff)\n" "ProjectCoefficient(GridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" @@ -17544,20 +13514,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ProjectBdrCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray attr)\n" "ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" ""}, - { "GridFunction_ProjectBdrCoefficientNormal", _wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS, "ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, - { "GridFunction_ProjectBdrCoefficientTangent", _wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientNormal", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS|METH_KEYWORDS, "ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientTangent", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS|METH_KEYWORDS, "ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, { "GridFunction_ComputeL2Error", _wrap_GridFunction_ComputeL2Error, METH_VARARGS, "\n" "ComputeL2Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeL2Error(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double\n" ""}, - { "GridFunction_ComputeH1Error", _wrap_GridFunction_ComputeH1Error, METH_VARARGS, "ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, + { "GridFunction_ComputeH1Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeH1Error, METH_VARARGS|METH_KEYWORDS, "ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, { "GridFunction_ComputeMaxError", _wrap_GridFunction_ComputeMaxError, METH_VARARGS, "\n" "ComputeMaxError(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeMaxError(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" ""}, - { "GridFunction_ComputeW11Error", _wrap_GridFunction_ComputeW11Error, METH_VARARGS, "ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, + { "GridFunction_ComputeW11Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeW11Error, METH_VARARGS|METH_KEYWORDS, "ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, { "GridFunction_ComputeL1Error", _wrap_GridFunction_ComputeL1Error, METH_VARARGS, "\n" "ComputeL1Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" @@ -17582,7 +13552,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" "ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" ""}, - { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "GridFunction_ComputeFlux", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeFlux, METH_VARARGS|METH_KEYWORDS, "ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" "Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" "Assign(GridFunction self, double value) -> GridFunction\n" @@ -17593,7 +13563,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FESpace(GridFunction self) -> FiniteElementSpace\n" "FESpace(GridFunction self) -> FiniteElementSpace\n" ""}, - { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "SetSpace(GridFunction self, FiniteElementSpace f)"}, + { "GridFunction_SetSpace", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetSpace, METH_VARARGS|METH_KEYWORDS, "SetSpace(GridFunction self, FiniteElementSpace f)"}, { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" "MakeRef(GridFunction self, Vector base, int offset, int size)\n" "MakeRef(GridFunction self, Vector base, int offset)\n" @@ -17604,8 +13574,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MakeTRef(GridFunction self, FiniteElementSpace f, double * tv)\n" "MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset)\n" ""}, - { "GridFunction_SaveVTK", _wrap_GridFunction_SaveVTK, METH_VARARGS, "SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, - { "GridFunction_SaveSTL", _wrap_GridFunction_SaveSTL, METH_VARARGS, "SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, + { "GridFunction_SaveVTK", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveVTK, METH_VARARGS|METH_KEYWORDS, "SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, + { "GridFunction_SaveSTL", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveSTL, METH_VARARGS|METH_KEYWORDS, "SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, { "delete_GridFunction", _wrap_delete_GridFunction, METH_O, "delete_GridFunction(GridFunction self)"}, { "new_GridFunction", _wrap_new_GridFunction, METH_VARARGS, "\n" "GridFunction()\n" @@ -17617,14 +13587,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GridFunction(Mesh m, char const * grid_file)\n" "new_GridFunction(FiniteElementSpace fes, Vector v, int offset) -> GridFunction\n" ""}, - { "GridFunction_SaveToFile", _wrap_GridFunction_SaveToFile, METH_VARARGS, "SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, - { "GridFunction_iadd", _wrap_GridFunction_iadd, METH_VARARGS, "iadd(GridFunction self, GridFunction c) -> GridFunction"}, + { "GridFunction_SaveToFile", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveToFile, METH_VARARGS|METH_KEYWORDS, "SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, + { "GridFunction_iadd", (PyCFunction)(void(*)(void))_wrap_GridFunction_iadd, METH_VARARGS|METH_KEYWORDS, "iadd(GridFunction self, GridFunction c) -> GridFunction"}, { "GridFunction_isub", _wrap_GridFunction_isub, METH_VARARGS, "\n" "isub(GridFunction self, GridFunction c) -> GridFunction\n" "isub(GridFunction self, double c) -> GridFunction\n" ""}, - { "GridFunction_imul", _wrap_GridFunction_imul, METH_VARARGS, "imul(GridFunction self, double c) -> GridFunction"}, - { "GridFunction_idiv", _wrap_GridFunction_idiv, METH_VARARGS, "idiv(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_imul", (PyCFunction)(void(*)(void))_wrap_GridFunction_imul, METH_VARARGS|METH_KEYWORDS, "imul(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_idiv", (PyCFunction)(void(*)(void))_wrap_GridFunction_idiv, METH_VARARGS|METH_KEYWORDS, "idiv(GridFunction self, double c) -> GridFunction"}, { "GridFunction_Save", _wrap_GridFunction_Save, METH_VARARGS, "\n" "Save(GridFunction self, std::ostream & out)\n" "Save(GridFunction self, char const * file, int precision=8)\n" @@ -17645,10 +13615,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1)\n" ""}, { "QuadratureFunction_GetVDim", _wrap_QuadratureFunction_GetVDim, METH_O, "GetVDim(QuadratureFunction self) -> int"}, - { "QuadratureFunction_SetVDim", _wrap_QuadratureFunction_SetVDim, METH_VARARGS, "SetVDim(QuadratureFunction self, int vdim_)"}, + { "QuadratureFunction_SetVDim", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetVDim, METH_VARARGS|METH_KEYWORDS, "SetVDim(QuadratureFunction self, int vdim_)"}, { "QuadratureFunction_OwnsSpace", _wrap_QuadratureFunction_OwnsSpace, METH_O, "OwnsSpace(QuadratureFunction self) -> bool"}, - { "QuadratureFunction_SetOwnsSpace", _wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS, "SetOwnsSpace(QuadratureFunction self, bool own)"}, - { "QuadratureFunction_GetElementIntRule", _wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, + { "QuadratureFunction_SetOwnsSpace", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS|METH_KEYWORDS, "SetOwnsSpace(QuadratureFunction self, bool own)"}, + { "QuadratureFunction_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, { "QuadratureFunction_GetElementValues", _wrap_QuadratureFunction_GetElementValues, METH_VARARGS, "\n" "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" @@ -17666,14 +13636,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" ""}, - { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, - { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, - { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, - { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "ZZErrorEstimator", (PyCFunction)(void(*)(void))_wrap_ZZErrorEstimator, METH_VARARGS|METH_KEYWORDS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, + { "ComputeElementLpDistance", (PyCFunction)(void(*)(void))_wrap_ComputeElementLpDistance, METH_VARARGS|METH_KEYWORDS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, + { "new_ExtrudeCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ExtrudeCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, + { "ExtrudeCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ExtrudeCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ExtrudeCoefficient", _wrap_delete_ExtrudeCoefficient, METH_O, "delete_ExtrudeCoefficient(ExtrudeCoefficient self)"}, { "ExtrudeCoefficient_swigregister", ExtrudeCoefficient_swigregister, METH_O, NULL}, { "ExtrudeCoefficient_swiginit", ExtrudeCoefficient_swiginit, METH_VARARGS, NULL}, - { "Extrude1DGridFunction", _wrap_Extrude1DGridFunction, METH_VARARGS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, + { "Extrude1DGridFunction", (PyCFunction)(void(*)(void))_wrap_Extrude1DGridFunction, METH_VARARGS|METH_KEYWORDS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/handle_wrap.cxx b/mfem/_par/handle_wrap.cxx index 25506707..2956aee9 100644 --- a/mfem/_par/handle_wrap.cxx +++ b/mfem/_par/handle_wrap.cxx @@ -3811,61 +3811,36 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_OwnsOperator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"own", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:OperatorHandle_SetOperatorOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetOperatorOwner(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); { try { - (arg1)->SetOperatorOwner(); + (arg1)->SetOperatorOwner(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3883,48 +3858,6 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_SetOperatorOwner", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_OperatorHandle_SetOperatorOwner__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_OperatorHandle_SetOperatorOwner__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_SetOperatorOwner'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::OperatorHandle::SetOperatorOwner(bool)\n" - " mfem::OperatorHandle::SetOperatorOwner()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OperatorHandle_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -3959,7 +3892,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Clear(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Operator::Type arg2 ; @@ -3967,15 +3900,19 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_SetType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_SetType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_SetType" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OperatorHandle_SetType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -4000,7 +3937,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_OperatorHandle_MakeSquareBlockDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MakeSquareBlockDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; MPI_Comm arg2 ; @@ -4013,17 +3950,24 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeSquareBlockDiag(PyObject *SWIGUNUS int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"comm", (char *)"glob_size", (char *)"row_starts", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MakeSquareBlockDiag", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:OperatorHandle_MakeSquareBlockDiag", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MakeSquareBlockDiag" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[1], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj1, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "OperatorHandle_MakeSquareBlockDiag" "', argument " "2"" of type '" "MPI_Comm""'"); } @@ -4031,17 +3975,17 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeSquareBlockDiag(PyObject *SWIGUNUS if (SWIG_IsNewObj(res)) delete ptr; } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_MakeSquareBlockDiag" "', argument " "4"" of type '" "HYPRE_Int *""'"); } arg4 = reinterpret_cast< HYPRE_Int * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_MakeSquareBlockDiag" "', argument " "5"" of type '" "mfem::SparseMatrix *""'"); } @@ -4066,7 +4010,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeSquareBlockDiag(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRectangularBlockDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRectangularBlockDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; MPI_Comm arg2 ; @@ -4083,17 +4027,26 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRectangularBlockDiag(PyObject *SWI int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"comm", (char *)"glob_num_rows", (char *)"glob_num_cols", (char *)"row_starts", (char *)"col_starts", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MakeRectangularBlockDiag", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:OperatorHandle_MakeRectangularBlockDiag", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MakeRectangularBlockDiag" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[1], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj1, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "OperatorHandle_MakeRectangularBlockDiag" "', argument " "2"" of type '" "MPI_Comm""'"); } @@ -4101,28 +4054,28 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRectangularBlockDiag(PyObject *SWI if (SWIG_IsNewObj(res)) delete ptr; } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_MakeRectangularBlockDiag" "', argument " "5"" of type '" "HYPRE_Int *""'"); } arg5 = reinterpret_cast< HYPRE_Int * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_MakeRectangularBlockDiag" "', argument " "6"" of type '" "HYPRE_Int *""'"); } arg6 = reinterpret_cast< HYPRE_Int * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_MakeRectangularBlockDiag" "', argument " "7"" of type '" "mfem::SparseMatrix *""'"); } @@ -4147,7 +4100,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRectangularBlockDiag(PyObject *SWI } -SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4158,15 +4111,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MakePtAP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_MakePtAP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MakePtAP" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_MakePtAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } @@ -4174,7 +4132,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MakePtAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_MakePtAP" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -4202,7 +4160,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4216,15 +4174,21 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self) int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Rt", (char *)"A", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MakeRAP", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OperatorHandle_MakeRAP", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MakeRAP" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_MakeRAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } @@ -4232,7 +4196,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MakeRAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_MakeRAP" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -4240,7 +4204,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MakeRAP" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } arg3 = reinterpret_cast< mfem::OperatorHandle * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_MakeRAP" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); } @@ -4311,7 +4275,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4322,15 +4286,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"ess_dof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_EliminateRowsCols", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_EliminateRowsCols", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } @@ -4338,7 +4307,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -4366,7 +4335,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4383,15 +4352,22 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A_e", (char *)"ess_dof_list", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_EliminateBC", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:OperatorHandle_EliminateBC", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_EliminateBC" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_EliminateBC" "', argument " "2"" of type '" "mfem::OperatorHandle const &""'"); } @@ -4399,7 +4375,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateBC" "', argument " "2"" of type '" "mfem::OperatorHandle const &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -4407,7 +4383,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -4415,7 +4391,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_EliminateBC" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -4513,7 +4489,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Is(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::HypreParMatrix **arg2 = 0 ; @@ -4521,15 +4497,19 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_Get", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_Get", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Get" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__HypreParMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Get" "', argument " "2"" of type '" "mfem::HypreParMatrix *&""'"); } @@ -4557,77 +4537,45 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_OperatorHandle_Reset__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; - bool arg3 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"own_A", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:OperatorHandle_Reset", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Reset" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Reset" "', argument " "2"" of type '" "mfem::HypreParMatrix *""'"); } arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OperatorHandle_Reset" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR Reset< mfem::HypreParMatrix >(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_Reset__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Reset" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Reset" "', argument " "2"" of type '" "mfem::HypreParMatrix *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OperatorHandle_Reset" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR Reset< mfem::HypreParMatrix >(arg2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR Reset< mfem::HypreParMatrix >(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4645,58 +4593,6 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Reset__SWIG_3(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_OperatorHandle_Reset(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_Reset", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_OperatorHandle_Reset__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_OperatorHandle_Reset__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_Reset'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::OperatorHandle::Reset< mfem::HypreParMatrix >(mfem::HypreParMatrix *,bool)\n" - " mfem::OperatorHandle::Reset< mfem::HypreParMatrix >(mfem::HypreParMatrix *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -4783,7 +4679,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -4809,30 +4705,40 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Po", (char *)"Ri", (char *)"Pi", (char *)"x", (char *)"b", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_InitTVectors", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:OperatorHandle_InitTVectors", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_InitTVectors" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -4840,7 +4746,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -4848,7 +4754,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -4856,7 +4762,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -5059,7 +4965,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetMemoryClass(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5070,15 +4976,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Mult" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5086,7 +4997,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5114,7 +5025,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5125,15 +5036,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MultTranspose" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5141,7 +5057,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5169,7 +5085,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_OperatorHandle_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5177,16 +5093,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetGradient(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_GetGradient" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5354,7 +5274,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetOutputRestriction(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5363,7 +5283,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI mfem::Operator **arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5378,14 +5298,25 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", (char *)"copy_interior", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO|O:OperatorHandle_FormLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5393,7 +5324,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5401,7 +5332,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5409,7 +5340,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } @@ -5417,7 +5348,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -5425,7 +5356,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -5433,11 +5364,13 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + if (obj7) { + { + if ((PyArray_PyIntAsInt(obj7) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(obj7); + } } { try { @@ -5459,15 +5392,16 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Array< int > *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Operator **arg5 = 0 ; - mfem::Vector *arg6 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Operator **arg6 = 0 ; mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5482,64 +5416,85 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_1(PyObject *SWI int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:OperatorHandle_FormRectangularLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + arg6 = reinterpret_cast< mfem::Operator ** >(argp6); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); { try { - (*arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (*arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5557,243 +5512,35 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 +SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"X", (char *)"b", (char *)"x", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_FormLinearSystem", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_OperatorHandle_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_FormLinearSystem__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_FormLinearSystem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::Operator **arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - mfem::Vector *arg8 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - void *argp8 = 0 ; - int res8 = 0 ; - PyObject *swig_obj[8] ; - - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); - } - arg6 = reinterpret_cast< mfem::Operator ** >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res8)) { - SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); - } - if (!argp8) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); - } - arg8 = reinterpret_cast< mfem::Vector * >(argp8); - { - try { - (*arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_RecoverFEMSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OperatorHandle_RecoverFEMSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5801,7 +5548,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -5809,7 +5556,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5837,7 +5584,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5848,15 +5595,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_FormSystemOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5864,7 +5616,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); } @@ -5892,7 +5644,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5906,15 +5658,21 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OperatorHandle_FormRectangularSystemOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5922,7 +5680,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -5930,7 +5688,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); } @@ -5958,7 +5716,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Operator **arg2 = 0 ; @@ -5966,15 +5724,19 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_FormDiscreteOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); } @@ -6002,98 +5764,32 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_PrintMatlab" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (*arg1)->PrintMatlab(*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + int arg3 = (int) 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", (char *)"n", (char *)"m", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:OperatorHandle_PrintMatlab", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_PrintMatlab" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } @@ -6107,75 +5803,25 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_1(PyObject *SWIGUNUS arg2 = &out2; } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (*arg1)->PrintMatlab(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_PrintMatlab" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } } { try { - (*arg1)->PrintMatlab(*arg2); + (*arg1)->PrintMatlab(*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6203,115 +5849,6 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_2(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_PrintMatlab", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_PrintMatlab__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_PrintMatlab__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_PrintMatlab__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_PrintMatlab'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Operator::PrintMatlab(std::ostream &,int,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OperatorHandle_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -6371,43 +5908,43 @@ static PyMethodDef SwigMethods[] = { { "OperatorHandle___ref__", _wrap_OperatorHandle___ref__, METH_O, "OperatorHandle___ref__(OperatorHandle self) -> Operator"}, { "OperatorHandle_Type", _wrap_OperatorHandle_Type, METH_O, "OperatorHandle_Type(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_OwnsOperator", _wrap_OperatorHandle_OwnsOperator, METH_O, "OperatorHandle_OwnsOperator(OperatorHandle self) -> bool"}, - { "OperatorHandle_SetOperatorOwner", _wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS, "OperatorHandle_SetOperatorOwner(OperatorHandle self, bool own=True)"}, + { "OperatorHandle_SetOperatorOwner", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_SetOperatorOwner(OperatorHandle self, bool own=True)"}, { "OperatorHandle_Clear", _wrap_OperatorHandle_Clear, METH_O, "OperatorHandle_Clear(OperatorHandle self)"}, - { "OperatorHandle_SetType", _wrap_OperatorHandle_SetType, METH_VARARGS, "OperatorHandle_SetType(OperatorHandle self, mfem::Operator::Type tid)"}, - { "OperatorHandle_MakeSquareBlockDiag", _wrap_OperatorHandle_MakeSquareBlockDiag, METH_VARARGS, "OperatorHandle_MakeSquareBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * row_starts, SparseMatrix diag)"}, - { "OperatorHandle_MakeRectangularBlockDiag", _wrap_OperatorHandle_MakeRectangularBlockDiag, METH_VARARGS, "OperatorHandle_MakeRectangularBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_num_rows, HYPRE_Int glob_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag)"}, - { "OperatorHandle_MakePtAP", _wrap_OperatorHandle_MakePtAP, METH_VARARGS, "OperatorHandle_MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_MakeRAP", _wrap_OperatorHandle_MakeRAP, METH_VARARGS, "OperatorHandle_MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_EliminateRowsCols", _wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS, "OperatorHandle_EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, - { "OperatorHandle_EliminateBC", _wrap_OperatorHandle_EliminateBC, METH_VARARGS, "OperatorHandle_EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, + { "OperatorHandle_SetType", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetType, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_SetType(OperatorHandle self, mfem::Operator::Type tid)"}, + { "OperatorHandle_MakeSquareBlockDiag", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeSquareBlockDiag, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MakeSquareBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * row_starts, SparseMatrix diag)"}, + { "OperatorHandle_MakeRectangularBlockDiag", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeRectangularBlockDiag, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MakeRectangularBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_num_rows, HYPRE_Int glob_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag)"}, + { "OperatorHandle_MakePtAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakePtAP, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_MakeRAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeRAP, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_EliminateRowsCols", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, + { "OperatorHandle_EliminateBC", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateBC, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, { "OperatorHandle_As", _wrap_OperatorHandle_As, METH_O, "OperatorHandle_As(OperatorHandle self) -> HypreParMatrix"}, { "OperatorHandle_Is", _wrap_OperatorHandle_Is, METH_O, "OperatorHandle_Is(OperatorHandle self) -> HypreParMatrix"}, - { "OperatorHandle_Get", _wrap_OperatorHandle_Get, METH_VARARGS, "OperatorHandle_Get(OperatorHandle self, mfem::HypreParMatrix *& A)"}, - { "OperatorHandle_Reset", _wrap_OperatorHandle_Reset, METH_VARARGS, "OperatorHandle_Reset(OperatorHandle self, HypreParMatrix A, bool own_A=True)"}, + { "OperatorHandle_Get", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Get, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_Get(OperatorHandle self, mfem::HypreParMatrix *& A)"}, + { "OperatorHandle_Reset", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Reset, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_Reset(OperatorHandle self, HypreParMatrix A, bool own_A=True)"}, { "OperatorHandle_ConvertFrom", _wrap_OperatorHandle_ConvertFrom, METH_VARARGS, "\n" "OperatorHandle_ConvertFrom(OperatorHandle self, OperatorHandle A)\n" "OperatorHandle_ConvertFrom(OperatorHandle self, HypreParMatrix A)\n" ""}, - { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "OperatorHandle_InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "OperatorHandle_InitTVectors", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_InitTVectors, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "OperatorHandle_Height(OperatorHandle self) -> int"}, { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "OperatorHandle_NumRows(OperatorHandle self) -> int"}, { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "OperatorHandle_Width(OperatorHandle self) -> int"}, { "OperatorHandle_NumCols", _wrap_OperatorHandle_NumCols, METH_O, "OperatorHandle_NumCols(OperatorHandle self) -> int"}, { "OperatorHandle_GetMemoryClass", _wrap_OperatorHandle_GetMemoryClass, METH_O, "OperatorHandle_GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass"}, - { "OperatorHandle_Mult", _wrap_OperatorHandle_Mult, METH_VARARGS, "OperatorHandle_Mult(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_MultTranspose", _wrap_OperatorHandle_MultTranspose, METH_VARARGS, "OperatorHandle_MultTranspose(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "OperatorHandle_GetGradient(OperatorHandle self, Vector x) -> Operator"}, + { "OperatorHandle_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Mult, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_Mult(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_MultTranspose", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MultTranspose, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MultTranspose(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_GetGradient", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_GetGradient, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_GetGradient(OperatorHandle self, Vector x) -> Operator"}, { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "OperatorHandle_GetProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "OperatorHandle_GetRestriction(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "OperatorHandle_GetOutputProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "OperatorHandle_GetOutputRestriction(OperatorHandle self) -> Operator"}, - { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "OperatorHandle_FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "OperatorHandle_FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "OperatorHandle_RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, - { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "OperatorHandle_FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "OperatorHandle_FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "OperatorHandle_FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, - { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "OperatorHandle_PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, + { "OperatorHandle_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "OperatorHandle_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, + { "OperatorHandle_PrintMatlab", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_PrintMatlab, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "OperatorHandle_GetType(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, { "OperatorHandle_swiginit", OperatorHandle_swiginit, METH_VARARGS, NULL}, @@ -6427,43 +5964,43 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "OperatorHandle___ref__", _wrap_OperatorHandle___ref__, METH_O, "__ref__(OperatorHandle self) -> Operator"}, { "OperatorHandle_Type", _wrap_OperatorHandle_Type, METH_O, "Type(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_OwnsOperator", _wrap_OperatorHandle_OwnsOperator, METH_O, "OwnsOperator(OperatorHandle self) -> bool"}, - { "OperatorHandle_SetOperatorOwner", _wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS, "SetOperatorOwner(OperatorHandle self, bool own=True)"}, + { "OperatorHandle_SetOperatorOwner", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS|METH_KEYWORDS, "SetOperatorOwner(OperatorHandle self, bool own=True)"}, { "OperatorHandle_Clear", _wrap_OperatorHandle_Clear, METH_O, "Clear(OperatorHandle self)"}, - { "OperatorHandle_SetType", _wrap_OperatorHandle_SetType, METH_VARARGS, "SetType(OperatorHandle self, mfem::Operator::Type tid)"}, - { "OperatorHandle_MakeSquareBlockDiag", _wrap_OperatorHandle_MakeSquareBlockDiag, METH_VARARGS, "MakeSquareBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * row_starts, SparseMatrix diag)"}, - { "OperatorHandle_MakeRectangularBlockDiag", _wrap_OperatorHandle_MakeRectangularBlockDiag, METH_VARARGS, "MakeRectangularBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_num_rows, HYPRE_Int glob_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag)"}, - { "OperatorHandle_MakePtAP", _wrap_OperatorHandle_MakePtAP, METH_VARARGS, "MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_MakeRAP", _wrap_OperatorHandle_MakeRAP, METH_VARARGS, "MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_EliminateRowsCols", _wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS, "EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, - { "OperatorHandle_EliminateBC", _wrap_OperatorHandle_EliminateBC, METH_VARARGS, "EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, + { "OperatorHandle_SetType", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetType, METH_VARARGS|METH_KEYWORDS, "SetType(OperatorHandle self, mfem::Operator::Type tid)"}, + { "OperatorHandle_MakeSquareBlockDiag", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeSquareBlockDiag, METH_VARARGS|METH_KEYWORDS, "MakeSquareBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_size, HYPRE_Int * row_starts, SparseMatrix diag)"}, + { "OperatorHandle_MakeRectangularBlockDiag", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeRectangularBlockDiag, METH_VARARGS|METH_KEYWORDS, "MakeRectangularBlockDiag(OperatorHandle self, MPI_Comm comm, HYPRE_Int glob_num_rows, HYPRE_Int glob_num_cols, HYPRE_Int * row_starts, HYPRE_Int * col_starts, SparseMatrix diag)"}, + { "OperatorHandle_MakePtAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakePtAP, METH_VARARGS|METH_KEYWORDS, "MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_MakeRAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeRAP, METH_VARARGS|METH_KEYWORDS, "MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_EliminateRowsCols", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS|METH_KEYWORDS, "EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, + { "OperatorHandle_EliminateBC", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateBC, METH_VARARGS|METH_KEYWORDS, "EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, { "OperatorHandle_As", _wrap_OperatorHandle_As, METH_O, "As(OperatorHandle self) -> HypreParMatrix"}, { "OperatorHandle_Is", _wrap_OperatorHandle_Is, METH_O, "Is(OperatorHandle self) -> HypreParMatrix"}, - { "OperatorHandle_Get", _wrap_OperatorHandle_Get, METH_VARARGS, "Get(OperatorHandle self, mfem::HypreParMatrix *& A)"}, - { "OperatorHandle_Reset", _wrap_OperatorHandle_Reset, METH_VARARGS, "Reset(OperatorHandle self, HypreParMatrix A, bool own_A=True)"}, + { "OperatorHandle_Get", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Get, METH_VARARGS|METH_KEYWORDS, "Get(OperatorHandle self, mfem::HypreParMatrix *& A)"}, + { "OperatorHandle_Reset", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Reset, METH_VARARGS|METH_KEYWORDS, "Reset(OperatorHandle self, HypreParMatrix A, bool own_A=True)"}, { "OperatorHandle_ConvertFrom", _wrap_OperatorHandle_ConvertFrom, METH_VARARGS, "\n" "ConvertFrom(OperatorHandle self, OperatorHandle A)\n" "ConvertFrom(OperatorHandle self, HypreParMatrix A)\n" ""}, - { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "OperatorHandle_InitTVectors", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_InitTVectors, METH_VARARGS|METH_KEYWORDS, "InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "Height(OperatorHandle self) -> int"}, { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "NumRows(OperatorHandle self) -> int"}, { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "Width(OperatorHandle self) -> int"}, { "OperatorHandle_NumCols", _wrap_OperatorHandle_NumCols, METH_O, "NumCols(OperatorHandle self) -> int"}, { "OperatorHandle_GetMemoryClass", _wrap_OperatorHandle_GetMemoryClass, METH_O, "GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass"}, - { "OperatorHandle_Mult", _wrap_OperatorHandle_Mult, METH_VARARGS, "Mult(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_MultTranspose", _wrap_OperatorHandle_MultTranspose, METH_VARARGS, "MultTranspose(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "GetGradient(OperatorHandle self, Vector x) -> Operator"}, + { "OperatorHandle_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_MultTranspose", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_GetGradient", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(OperatorHandle self, Vector x) -> Operator"}, { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "GetProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "GetRestriction(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "GetOutputProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "GetOutputRestriction(OperatorHandle self) -> Operator"}, - { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, - { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, - { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, + { "OperatorHandle_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "OperatorHandle_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, + { "OperatorHandle_PrintMatlab", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_PrintMatlab, METH_VARARGS|METH_KEYWORDS, "PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "GetType(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, { "OperatorHandle_swiginit", OperatorHandle_swiginit, METH_VARARGS, NULL}, @@ -7693,10 +7230,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/hash_wrap.cxx b/mfem/_par/hash_wrap.cxx index edf4b001..6cab7bc7 100644 --- a/mfem/_par/hash_wrap.cxx +++ b/mfem/_par/hash_wrap.cxx @@ -3292,7 +3292,7 @@ SWIGINTERN PyObject *Hashed4_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -3303,10 +3303,15 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "sort3", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:sort3", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort3" "', argument " "1"" of type '" "int &""'"); } @@ -3314,7 +3319,7 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort3" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort3" "', argument " "2"" of type '" "int &""'"); } @@ -3322,7 +3327,7 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort3" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort3" "', argument " "3"" of type '" "int &""'"); } @@ -3353,7 +3358,7 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -3367,10 +3372,16 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "sort4", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:sort4", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort4" "', argument " "1"" of type '" "int &""'"); } @@ -3378,7 +3389,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort4" "', argument " "2"" of type '" "int &""'"); } @@ -3386,7 +3397,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort4" "', argument " "3"" of type '" "int &""'"); } @@ -3394,7 +3405,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4" "', argument " "3"" of type '" "int &""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sort4" "', argument " "4"" of type '" "int &""'"); } @@ -3425,7 +3436,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -3439,10 +3450,16 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "sort4_ext", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:sort4_ext", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); } @@ -3450,7 +3467,7 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); } @@ -3458,7 +3475,7 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); } @@ -3466,7 +3483,7 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sort4_ext" "', argument " "4"" of type '" "int &""'"); } @@ -3522,9 +3539,9 @@ static PyMethodDef SwigMethods[] = { { "delete_Hashed4", _wrap_delete_Hashed4, METH_O, "delete_Hashed4(Hashed4 self)"}, { "Hashed4_swigregister", Hashed4_swigregister, METH_O, NULL}, { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, - { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, - { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, - { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, + { "sort3", (PyCFunction)(void(*)(void))_wrap_sort3, METH_VARARGS|METH_KEYWORDS, "sort3(int & a, int & b, int & c)"}, + { "sort4", (PyCFunction)(void(*)(void))_wrap_sort4, METH_VARARGS|METH_KEYWORDS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", (PyCFunction)(void(*)(void))_wrap_sort4_ext, METH_VARARGS|METH_KEYWORDS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; @@ -3553,9 +3570,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_Hashed4", _wrap_delete_Hashed4, METH_O, "delete_Hashed4(Hashed4 self)"}, { "Hashed4_swigregister", Hashed4_swigregister, METH_O, NULL}, { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, - { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, - { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, - { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, + { "sort3", (PyCFunction)(void(*)(void))_wrap_sort3, METH_VARARGS|METH_KEYWORDS, "sort3(int & a, int & b, int & c)"}, + { "sort4", (PyCFunction)(void(*)(void))_wrap_sort4, METH_VARARGS|METH_KEYWORDS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", (PyCFunction)(void(*)(void))_wrap_sort4_ext, METH_VARARGS|METH_KEYWORDS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/hybridization_wrap.cxx b/mfem/_par/hybridization_wrap.cxx index e551b1e0..b948ce73 100644 --- a/mfem/_par/hybridization_wrap.cxx +++ b/mfem/_par/hybridization_wrap.cxx @@ -3440,7 +3440,7 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_Hybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Hybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -3448,16 +3448,20 @@ SWIGINTERN PyObject *_wrap_new_Hybridization(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"fespace", (char *)"c_fespace", NULL + }; mfem::Hybridization *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_Hybridization", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_Hybridization", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hybridization" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hybridization" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -3506,7 +3510,7 @@ SWIGINTERN PyObject *_wrap_delete_Hybridization(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -3514,15 +3518,19 @@ SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c_integ", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_SetConstraintIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Hybridization_SetConstraintIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_SetConstraintIntegrator" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_SetConstraintIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -3542,7 +3550,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -3550,15 +3558,19 @@ SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Hybridization_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_Init" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_Init" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -3581,7 +3593,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; int arg2 ; @@ -3590,21 +3602,26 @@ SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_AssembleMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Hybridization_AssembleMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_AssembleMatrix" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_AssembleMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -3627,7 +3644,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Hybridization_AssembleBdrMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_AssembleBdrMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; int arg2 ; @@ -3636,21 +3653,26 @@ SWIGINTERN PyObject *_wrap_Hybridization_AssembleBdrMatrix(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_el", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_AssembleBdrMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Hybridization_AssembleBdrMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_AssembleBdrMatrix" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_AssembleBdrMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -3839,7 +3861,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_GetParallelMatrix(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_Hybridization_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::Operator::Type arg2 ; @@ -3847,15 +3869,19 @@ SWIGINTERN PyObject *_wrap_Hybridization_SetOperatorType(PyObject *SWIGUNUSEDPAR int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_SetOperatorType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Hybridization_SetOperatorType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_SetOperatorType" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Hybridization_SetOperatorType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -3875,7 +3901,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_SetOperatorType(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3886,15 +3912,20 @@ SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"b_r", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_ReduceRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Hybridization_ReduceRHS", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_ReduceRHS" "', argument " "1"" of type '" "mfem::Hybridization const *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_ReduceRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3902,7 +3933,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hybridization_ReduceRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_ReduceRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3925,7 +3956,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3939,15 +3970,21 @@ SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"sol_r", (char *)"sol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_ComputeSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Hybridization_ComputeSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_ComputeSolution" "', argument " "1"" of type '" "mfem::Hybridization const *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_ComputeSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3955,7 +3992,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hybridization_ComputeSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_ComputeSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -3963,7 +4000,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hybridization_ComputeSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Hybridization_ComputeSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -4029,21 +4066,21 @@ SWIGINTERN PyObject *Hybridization_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, + { "new_Hybridization", (PyCFunction)(void(*)(void))_wrap_new_Hybridization, METH_VARARGS|METH_KEYWORDS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, - { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "Hybridization_SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, - { "Hybridization_Init", _wrap_Hybridization_Init, METH_VARARGS, "Hybridization_Init(Hybridization self, intArray ess_tdof_list)"}, - { "Hybridization_AssembleMatrix", _wrap_Hybridization_AssembleMatrix, METH_VARARGS, "Hybridization_AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, - { "Hybridization_AssembleBdrMatrix", _wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS, "Hybridization_AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, + { "Hybridization_SetConstraintIntegrator", (PyCFunction)(void(*)(void))_wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS|METH_KEYWORDS, "Hybridization_SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, + { "Hybridization_Init", (PyCFunction)(void(*)(void))_wrap_Hybridization_Init, METH_VARARGS|METH_KEYWORDS, "Hybridization_Init(Hybridization self, intArray ess_tdof_list)"}, + { "Hybridization_AssembleMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleMatrix, METH_VARARGS|METH_KEYWORDS, "Hybridization_AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, + { "Hybridization_AssembleBdrMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS|METH_KEYWORDS, "Hybridization_AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, { "Hybridization_Finalize", _wrap_Hybridization_Finalize, METH_O, "Hybridization_Finalize(Hybridization self)"}, { "Hybridization_GetMatrix", _wrap_Hybridization_GetMatrix, METH_O, "Hybridization_GetMatrix(Hybridization self) -> SparseMatrix"}, { "Hybridization_GetParallelMatrix", _wrap_Hybridization_GetParallelMatrix, METH_VARARGS, "\n" "Hybridization_GetParallelMatrix(Hybridization self) -> HypreParMatrix\n" "Hybridization_GetParallelMatrix(Hybridization self, OperatorHandle H_h)\n" ""}, - { "Hybridization_SetOperatorType", _wrap_Hybridization_SetOperatorType, METH_VARARGS, "Hybridization_SetOperatorType(Hybridization self, mfem::Operator::Type tid)"}, - { "Hybridization_ReduceRHS", _wrap_Hybridization_ReduceRHS, METH_VARARGS, "Hybridization_ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, - { "Hybridization_ComputeSolution", _wrap_Hybridization_ComputeSolution, METH_VARARGS, "Hybridization_ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, + { "Hybridization_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_Hybridization_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "Hybridization_SetOperatorType(Hybridization self, mfem::Operator::Type tid)"}, + { "Hybridization_ReduceRHS", (PyCFunction)(void(*)(void))_wrap_Hybridization_ReduceRHS, METH_VARARGS|METH_KEYWORDS, "Hybridization_ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, + { "Hybridization_ComputeSolution", (PyCFunction)(void(*)(void))_wrap_Hybridization_ComputeSolution, METH_VARARGS|METH_KEYWORDS, "Hybridization_ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, { "Hybridization_Reset", _wrap_Hybridization_Reset, METH_O, "Hybridization_Reset(Hybridization self)"}, { "Hybridization_swigregister", Hybridization_swigregister, METH_O, NULL}, { "Hybridization_swiginit", Hybridization_swiginit, METH_VARARGS, NULL}, @@ -4053,21 +4090,21 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, + { "new_Hybridization", (PyCFunction)(void(*)(void))_wrap_new_Hybridization, METH_VARARGS|METH_KEYWORDS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, - { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, - { "Hybridization_Init", _wrap_Hybridization_Init, METH_VARARGS, "Init(Hybridization self, intArray ess_tdof_list)"}, - { "Hybridization_AssembleMatrix", _wrap_Hybridization_AssembleMatrix, METH_VARARGS, "AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, - { "Hybridization_AssembleBdrMatrix", _wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS, "AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, + { "Hybridization_SetConstraintIntegrator", (PyCFunction)(void(*)(void))_wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS|METH_KEYWORDS, "SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, + { "Hybridization_Init", (PyCFunction)(void(*)(void))_wrap_Hybridization_Init, METH_VARARGS|METH_KEYWORDS, "Init(Hybridization self, intArray ess_tdof_list)"}, + { "Hybridization_AssembleMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, + { "Hybridization_AssembleBdrMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, { "Hybridization_Finalize", _wrap_Hybridization_Finalize, METH_O, "Finalize(Hybridization self)"}, { "Hybridization_GetMatrix", _wrap_Hybridization_GetMatrix, METH_O, "GetMatrix(Hybridization self) -> SparseMatrix"}, { "Hybridization_GetParallelMatrix", _wrap_Hybridization_GetParallelMatrix, METH_VARARGS, "\n" "GetParallelMatrix(Hybridization self) -> HypreParMatrix\n" "GetParallelMatrix(Hybridization self, OperatorHandle H_h)\n" ""}, - { "Hybridization_SetOperatorType", _wrap_Hybridization_SetOperatorType, METH_VARARGS, "SetOperatorType(Hybridization self, mfem::Operator::Type tid)"}, - { "Hybridization_ReduceRHS", _wrap_Hybridization_ReduceRHS, METH_VARARGS, "ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, - { "Hybridization_ComputeSolution", _wrap_Hybridization_ComputeSolution, METH_VARARGS, "ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, + { "Hybridization_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_Hybridization_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "SetOperatorType(Hybridization self, mfem::Operator::Type tid)"}, + { "Hybridization_ReduceRHS", (PyCFunction)(void(*)(void))_wrap_Hybridization_ReduceRHS, METH_VARARGS|METH_KEYWORDS, "ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, + { "Hybridization_ComputeSolution", (PyCFunction)(void(*)(void))_wrap_Hybridization_ComputeSolution, METH_VARARGS|METH_KEYWORDS, "ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, { "Hybridization_Reset", _wrap_Hybridization_Reset, METH_O, "Reset(Hybridization self)"}, { "Hybridization_swigregister", Hybridization_swigregister, METH_O, NULL}, { "Hybridization_swiginit", Hybridization_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/hypre.py b/mfem/_par/hypre.py index e67e89f2..85435f9a 100644 --- a/mfem/_par/hypre.py +++ b/mfem/_par/hypre.py @@ -488,7 +488,7 @@ def get_local_true_nnz(self): get_local_true_nnz = _swig_new_instance_method(_hypre.HypreParMatrix_get_local_true_nnz) def GetCooDataArray(self, base_i=0, base_j=0): - r"""GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject""" + r"""GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject *""" return _hypre.HypreParMatrix_GetCooDataArray(self, base_i, base_j) GetCooDataArray = _swig_new_instance_method(_hypre.HypreParMatrix_GetCooDataArray) diff --git a/mfem/_par/hypre_wrap.cxx b/mfem/_par/hypre_wrap.cxx index 03cee99b..44b4e544 100644 --- a/mfem/_par/hypre_wrap.cxx +++ b/mfem/_par/hypre_wrap.cxx @@ -3765,7 +3765,7 @@ SWIGINTERN PyObject *mfem_HypreParMatrix_get_local_true_nnz(mfem::HypreParMatrix return o; } -SWIGINTERN PyObject *mfem_HypreParMatrix_GetCooDataArray__SWIG_0(mfem::HypreParMatrix *self,HYPRE_Int const base_i=0,HYPRE_Int const base_j=0){ +SWIGINTERN PyObject *mfem_HypreParMatrix_GetCooDataArray(mfem::HypreParMatrix *self,HYPRE_Int const base_i=0,HYPRE_Int const base_j=0){ //hypre_ParCSRMatrix *matrix = static_cast(*pmatrix); hypre_ParCSRMatrix *matrix = static_cast(*self); @@ -3952,7 +3952,7 @@ SWIGINTERN PyObject *mfem_HypreParMatrix_GetCooDataArray__SWIG_0(mfem::HypreParM Py_XDECREF(o); return Py_None; } -SWIGINTERN void mfem_HypreParMatrix_PrintCommPkg__SWIG_2(mfem::HypreParMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_HypreParMatrix_PrintCommPkg__SWIG_1(mfem::HypreParMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -4229,12 +4229,12 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_2(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = 0 ; - int arg2 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::HypreParVector *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreParVector" "', argument " "1"" of type '" "mfem::HypreParMatrix const &""'"); @@ -4243,11 +4243,13 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_3(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreParVector" "', argument " "1"" of type '" "mfem::HypreParMatrix const &""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -4270,42 +4272,6 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_3(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::HypreParVector *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreParVector" "', argument " "1"" of type '" "mfem::HypreParMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreParVector" "', argument " "1"" of type '" "mfem::HypreParMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - try { - result = (mfem::HypreParVector *)new mfem::HypreParVector((mfem::HypreParMatrix const &)*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; HYPRE_ParVector arg1 ; void *argp1 ; @@ -4346,7 +4312,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_5(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParVector__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; void *argp1 = 0 ; @@ -4395,12 +4361,25 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector(PyObject *self, PyObject *args) { return _wrap_new_HypreParVector__SWIG_2(self, argc, argv); } } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParVector__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_new_HypreParVector__SWIG_3(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_HypreParVector__SWIG_3(self, argc, argv); + } } } if (argc == 1) { @@ -4408,7 +4387,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParVector__SWIG_5(self, argc, argv); + return _wrap_new_HypreParVector__SWIG_4(self, argc, argv); } } if (argc == 1) { @@ -4417,25 +4396,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParVector__SWIG_6(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_HypreParVector__SWIG_3(self, argc, argv); - } + return _wrap_new_HypreParVector__SWIG_5(self, argc, argv); } } if (argc == 3) { @@ -4503,7 +4464,6 @@ SWIGINTERN PyObject *_wrap_new_HypreParVector(PyObject *self, PyObject *args) { " mfem::HypreParVector::HypreParVector(MPI_Comm,HYPRE_Int,double *,HYPRE_Int *)\n" " mfem::HypreParVector::HypreParVector(mfem::HypreParVector const &)\n" " mfem::HypreParVector::HypreParVector(mfem::HypreParMatrix const &,int)\n" - " mfem::HypreParVector::HypreParVector(mfem::HypreParMatrix const &)\n" " mfem::HypreParVector::HypreParVector(HYPRE_ParVector)\n" " mfem::HypreParVector::HypreParVector(mfem::ParFiniteElementSpace *)\n"); return 0; @@ -4650,25 +4610,29 @@ SWIGINTERN PyObject *_wrap_HypreParVector_StealParVector(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_HypreParVector_SetOwnership(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParVector_SetOwnership(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParVector *arg1 = (mfem::HypreParVector *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"own", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParVector_SetOwnership", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParVector_SetOwnership", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParVector_SetOwnership" "', argument " "1"" of type '" "mfem::HypreParVector *""'"); } arg1 = reinterpret_cast< mfem::HypreParVector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4760,38 +4724,42 @@ SWIGINTERN PyObject *_wrap_HypreParVector_GlobalVector(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_HypreParVector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParVector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParVector *arg1 = (mfem::HypreParVector *) 0 ; double *arg2 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_data", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParVector_SetData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParVector_SetData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParVector_SetData" "', argument " "1"" of type '" "mfem::HypreParVector *""'"); } arg1 = reinterpret_cast< mfem::HypreParVector * >(argp1); { int i, si; - if (SWIG_ConvertPtr(swig_obj[1], (void **) &arg2, SWIGTYPE_p_double, 0|0) != -1){ + if (SWIG_ConvertPtr(obj1, (void **) &arg2, SWIGTYPE_p_double, 0|0) != -1){ } - else if (PyArray_Check(swig_obj[1])){ - arg2 = (double *) PyArray_DATA((PyArrayObject *)swig_obj[1]); - // arg2 = (double *) PyArray_DATA(swig_obj[1]); + else if (PyArray_Check(obj1)){ + arg2 = (double *) PyArray_DATA((PyArrayObject *)obj1); + // arg2 = (double *) PyArray_DATA(obj1); } else { - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - si = PyList_Size(swig_obj[1]); + si = PyList_Size(obj1); arg2 = (double *) malloc((si)*sizeof(double)); for (i = 0; i < si; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (double)PyFloat_AsDouble(s); } else if (PyFloat_Check(s)) { @@ -4824,26 +4792,30 @@ SWIGINTERN PyObject *_wrap_HypreParVector_SetData(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_HypreParVector_Randomize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParVector_Randomize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParVector *arg1 = (mfem::HypreParVector *) 0 ; HYPRE_Int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"seed", NULL + }; HYPRE_Int result; - if (!SWIG_Python_UnpackTuple(args, "HypreParVector_Randomize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParVector_Randomize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParVector_Randomize" "', argument " "1"" of type '" "mfem::HypreParVector *""'"); } arg1 = reinterpret_cast< mfem::HypreParVector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4865,7 +4837,7 @@ SWIGINTERN PyObject *_wrap_HypreParVector_Randomize(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_HypreParVector_Print(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParVector_Print(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParVector *arg1 = (mfem::HypreParVector *) 0 ; char *arg2 = (char *) 0 ; @@ -4874,15 +4846,19 @@ SWIGINTERN PyObject *_wrap_HypreParVector_Print(PyObject *SWIGUNUSEDPARM(self), int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fname", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParVector_Print", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParVector_Print", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParVector_Print" "', argument " "1"" of type '" "mfem::HypreParVector const *""'"); } arg1 = reinterpret_cast< mfem::HypreParVector * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParVector_Print" "', argument " "2"" of type '" "char const *""'"); } @@ -4989,7 +4965,7 @@ SWIGINTERN PyObject *HypreParVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ParNormlp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNormlp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; double arg2 ; @@ -4998,11 +4974,16 @@ SWIGINTERN PyObject *_wrap_ParNormlp(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"vec", (char *)"p", (char *)"comm", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ParNormlp", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParNormlp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNormlp" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -5010,14 +4991,14 @@ SWIGINTERN PyObject *_wrap_ParNormlp(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParNormlp" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNormlp" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[2], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ParNormlp" "', argument " "3"" of type '" "MPI_Comm""'"); } @@ -5072,24 +5053,26 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; hypre_ParCSRMatrix *arg1 = (hypre_ParCSRMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; mfem::HypreParMatrix *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_hypre_ParCSRMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreParMatrix" "', argument " "1"" of type '" "hypre_ParCSRMatrix *""'"); } arg1 = reinterpret_cast< hypre_ParCSRMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HypreParMatrix" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_HypreParMatrix" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (mfem::HypreParMatrix *)new mfem::HypreParMatrix(arg1,arg2); @@ -5111,39 +5094,6 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - hypre_ParCSRMatrix *arg1 = (hypre_ParCSRMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::HypreParMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_hypre_ParCSRMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreParMatrix" "', argument " "1"" of type '" "hypre_ParCSRMatrix *""'"); - } - arg1 = reinterpret_cast< hypre_ParCSRMatrix * >(argp1); - { - try { - result = (mfem::HypreParMatrix *)new mfem::HypreParMatrix(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; HYPRE_Int arg2 ; @@ -5201,7 +5151,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; HYPRE_Int arg2 ; @@ -5274,7 +5224,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; HYPRE_Int arg2 ; @@ -5363,7 +5313,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; HYPRE_Int arg2 ; @@ -5491,7 +5441,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; HYPRE_Int *arg2 = (HYPRE_Int *) 0 ; @@ -5550,7 +5500,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; HYPRE_Int arg2 ; @@ -5623,7 +5573,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_8(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; int arg2 ; @@ -5735,7 +5685,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_9(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; int arg2 ; @@ -5839,7 +5789,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_10(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreParMatrix__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = 0 ; void *argp1 = 0 ; @@ -5886,29 +5836,15 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_HypreParMatrix__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_hypre_ParCSRMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_HypreParMatrix__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_HypreParMatrix__SWIG_11(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_hypre_ParCSRMatrix, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_HypreParMatrix__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[1], NULL); _v = SWIG_CheckState(res); @@ -5918,6 +5854,14 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { } } } + if (argc == 1) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_HypreParMatrix__SWIG_10(self, argc, argv); + } + } if (argc == 4) { int _v; int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); @@ -5935,7 +5879,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_7(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_6(self, argc, argv); } } } @@ -5963,7 +5907,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_3(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_2(self, argc, argv); } } } @@ -6023,18 +5967,18 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { } if (_v) { if (argc <= 5) { - return _wrap_new_HypreParMatrix__SWIG_10(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_9(self, argc, argv); } if (argc <= 6) { - return _wrap_new_HypreParMatrix__SWIG_10(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_9(self, argc, argv); } if (argc <= 7) { - return _wrap_new_HypreParMatrix__SWIG_10(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_9(self, argc, argv); } if (argc <= 8) { - return _wrap_new_HypreParMatrix__SWIG_10(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_9(self, argc, argv); } - return _wrap_new_HypreParMatrix__SWIG_10(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_9(self, argc, argv); } } } @@ -6076,7 +6020,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_4(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_3(self, argc, argv); } } } @@ -6119,7 +6063,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_8(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_7(self, argc, argv); } } } @@ -6170,7 +6114,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_5(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_4(self, argc, argv); } } } @@ -6240,7 +6184,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_HypreParMatrix__SWIG_9(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_8(self, argc, argv); } } } @@ -6321,7 +6265,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_HypreParMatrix__SWIG_6(self, argc, argv); + return _wrap_new_HypreParMatrix__SWIG_5(self, argc, argv); } } } @@ -6342,7 +6286,6 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::HypreParMatrix::HypreParMatrix()\n" " mfem::HypreParMatrix::HypreParMatrix(hypre_ParCSRMatrix *,bool)\n" - " mfem::HypreParMatrix::HypreParMatrix(hypre_ParCSRMatrix *)\n" " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,HYPRE_Int,HYPRE_Int *,mfem::SparseMatrix *)\n" " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,HYPRE_Int,HYPRE_Int,HYPRE_Int *,HYPRE_Int *,mfem::SparseMatrix *)\n" " mfem::HypreParMatrix::HypreParMatrix(MPI_Comm,HYPRE_Int,HYPRE_Int,HYPRE_Int *,HYPRE_Int *,mfem::SparseMatrix *,mfem::SparseMatrix *,HYPRE_Int *)\n" @@ -6356,7 +6299,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParMatrix(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreParMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParMatrix *arg2 = 0 ; @@ -6364,15 +6307,19 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"master", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_MakeRef", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParMatrix_MakeRef", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MakeRef" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_MakeRef" "', argument " "2"" of type '" "mfem::HypreParMatrix const &""'"); } @@ -6470,7 +6417,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_StealData(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_HypreParMatrix_SetOwnerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_SetOwnerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; signed char arg2 ; @@ -6484,25 +6431,31 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_SetOwnerFlags(PyObject *SWIGUNUSEDPARM int ecode3 = 0 ; signed char val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", (char *)"offd", (char *)"colmap", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_SetOwnerFlags", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:HypreParMatrix_SetOwnerFlags", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_SetOwnerFlags" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - ecode2 = SWIG_AsVal_signed_SS_char(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_signed_SS_char(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_SetOwnerFlags" "', argument " "2"" of type '" "signed char""'"); } arg2 = static_cast< signed char >(val2); - ecode3 = SWIG_AsVal_signed_SS_char(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_signed_SS_char(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreParMatrix_SetOwnerFlags" "', argument " "3"" of type '" "signed char""'"); } arg3 = static_cast< signed char >(val3); - ecode4 = SWIG_AsVal_signed_SS_char(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_signed_SS_char(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_SetOwnerFlags" "', argument " "4"" of type '" "signed char""'"); } @@ -7141,7 +7094,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetDiag(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetOffd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_GetOffd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -7152,15 +7105,20 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetOffd(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offd", (char *)"cmap", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_GetOffd", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HypreParMatrix_GetOffd", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetOffd" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_GetOffd" "', argument " "2"" of type '" "mfem::SparseMatrix &""'"); } @@ -7168,7 +7126,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetOffd(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_GetOffd" "', argument " "2"" of type '" "mfem::SparseMatrix &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_GetOffd" "', argument " "3"" of type '" "HYPRE_Int *&""'"); } @@ -7196,12 +7154,12 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetOffd(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::Array2D< mfem::HypreParMatrix * > *arg2 = 0 ; - bool arg3 ; - bool arg4 ; + bool arg3 = (bool) false ; + bool arg4 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7210,14 +7168,21 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_0(PyObject *SWIGUNUSED int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blocks", (char *)"interleaved_rows", (char *)"interleaved_cols", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:HypreParMatrix_GetBlocks", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetBlocks" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::HypreParMatrix * > &""'"); } @@ -7225,16 +7190,20 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::HypreParMatrix * > &""'"); } arg2 = reinterpret_cast< mfem::Array2D< mfem::HypreParMatrix * > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreParMatrix_GetBlocks" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_GetBlocks" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreParMatrix_GetBlocks" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_GetBlocks" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { ((mfem::HypreParMatrix const *)arg1)->GetBlocks(*arg2,arg3,arg4); @@ -7255,40 +7224,24 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::Array2D< mfem::HypreParMatrix * > *arg2 = 0 ; - bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + PyObject *swig_obj[1] ; + mfem::HypreParMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetBlocks" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Transpose" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::HypreParMatrix * > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::HypreParMatrix * > &""'"); - } - arg2 = reinterpret_cast< mfem::Array2D< mfem::HypreParMatrix * > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreParMatrix_GetBlocks" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); { try { - ((mfem::HypreParMatrix const *)arg1)->GetBlocks(*arg2,arg3); + result = (mfem::HypreParMatrix *)((mfem::HypreParMatrix const *)arg1)->Transpose(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7299,39 +7252,31 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_1(PyObject *SWIGUNUSED // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_GetNumRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::Array2D< mfem::HypreParMatrix * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetBlocks" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetNumRows" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::HypreParMatrix * > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::HypreParMatrix * > &""'"); - } - arg2 = reinterpret_cast< mfem::Array2D< mfem::HypreParMatrix * > * >(argp2); { try { - ((mfem::HypreParMatrix const *)arg1)->GetBlocks(*arg2); + result = (int)((mfem::HypreParMatrix const *)arg1)->GetNumRows(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7342,169 +7287,20 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks__SWIG_2(PyObject *SWIGUNUSED // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetBlocks(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_GetBlocks", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_GetBlocks__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_GetBlocks__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_GetBlocks__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_GetBlocks'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreParMatrix::GetBlocks(mfem::Array2D< mfem::HypreParMatrix * > &,bool,bool) const\n" - " mfem::HypreParMatrix::GetBlocks(mfem::Array2D< mfem::HypreParMatrix * > &,bool) const\n" - " mfem::HypreParMatrix::GetBlocks(mfem::Array2D< mfem::HypreParMatrix * > &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Transpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::HypreParMatrix *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Transpose" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - try { - result = (mfem::HypreParMatrix *)((mfem::HypreParMatrix const *)arg1)->Transpose(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetNumRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetNumRows" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - try { - result = (int)((mfem::HypreParMatrix const *)arg1)->GetNumRows(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetNumCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; +SWIGINTERN PyObject *_wrap_HypreParMatrix_GetNumCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; if (!args) SWIG_fail; swig_obj[0] = args; @@ -7678,8 +7474,8 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_0(PyObject *SWIGUNUSEDPARM( mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParVector *arg2 = 0 ; mfem::HypreParVector *arg3 = 0 ; - double arg4 ; - double arg5 ; + double arg4 = (double) 1.0 ; + double arg5 = (double) 0.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7692,7 +7488,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_0(PyObject *SWIGUNUSEDPARM( int ecode5 = 0 ; HYPRE_Int result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); @@ -7714,16 +7510,20 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); } arg3 = reinterpret_cast< mfem::HypreParVector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_Mult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_Mult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } { try { result = (HYPRE_Int)(arg1)->Mult(*arg2,*arg3,arg4,arg5); @@ -7747,49 +7547,71 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::HypreParVector *arg2 = 0 ; - mfem::HypreParVector *arg3 = 0 ; - double arg4 ; + HYPRE_ParVector arg2 ; + HYPRE_ParVector arg3 ; + double arg4 = (double) 1.0 ; + double arg5 = (double) 0.0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; + void *argp2 ; int res2 = 0 ; - void *argp3 = 0 ; + void *argp3 ; int res3 = 0 ; double val4 ; int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; HYPRE_Int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParVector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); + } else { + HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); + { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); + } else { + HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } } - arg2 = reinterpret_cast< mfem::HypreParVector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParVector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_Mult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } - arg3 = reinterpret_cast< mfem::HypreParVector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_Mult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - result = (HYPRE_Int)(arg1)->Mult(*arg2,*arg3,arg4); + result = (HYPRE_Int)(arg1)->Mult(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7807,44 +7629,64 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParVector *arg2 = 0 ; mfem::HypreParVector *arg3 = 0 ; + double arg4 = (double) 1.0 ; + double arg5 = (double) 0.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; HYPRE_Int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParVector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); } arg2 = reinterpret_cast< mfem::HypreParVector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParVector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); } arg3 = reinterpret_cast< mfem::HypreParVector * >(argp3); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_MultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HypreParMatrix_MultTranspose" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } { try { - result = (HYPRE_Int)(arg1)->Mult(*arg2,*arg3); + result = (HYPRE_Int)(arg1)->MultTranspose(*arg2,*arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7862,208 +7704,59 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_2(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - HYPRE_ParVector arg2 ; - HYPRE_ParVector arg3 ; + double arg2 ; + mfem::Vector *arg3 = 0 ; double arg4 ; - double arg5 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - void *argp3 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; int res3 = 0 ; double val4 ; int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - HYPRE_Int result; + void *argp5 = 0 ; + int res5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); - } else { - HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); - } else { - HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_Mult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "double""'"); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "double""'"); } - arg5 = static_cast< double >(val5); - { - try { - result = (HYPRE_Int)(arg1)->Mult(arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - HYPRE_ParVector arg2 ; - HYPRE_ParVector arg3 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - void *argp3 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - HYPRE_Int result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); - } else { - HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); - } else { - HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_Mult" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - { - try { - result = (HYPRE_Int)(arg1)->Mult(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - HYPRE_ParVector arg2 ; - HYPRE_ParVector arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - void *argp3 ; - int res3 = 0 ; - HYPRE_Int result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "HYPRE_ParVector""'"); - } else { - HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); } - { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_HYPRE_ParVector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "HYPRE_ParVector""'"); - } else { - HYPRE_ParVector * temp = reinterpret_cast< HYPRE_ParVector * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (HYPRE_Int)(arg1)->Mult(arg2,arg3); + ((mfem::HypreParMatrix const *)arg1)->Mult(arg2,(mfem::Vector const &)*arg3,arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8074,67 +7767,66 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_5(PyObject *SWIGUNUSEDPARM( // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::HypreParVector *arg2 = 0 ; - mfem::HypreParVector *arg3 = 0 ; + double arg2 ; + mfem::Vector *arg3 = 0 ; double arg4 ; - double arg5 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; double val4 ; int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - HYPRE_Int result; + void *argp5 = 0 ; + int res5 = 0 ; if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParVector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); - } - arg2 = reinterpret_cast< mfem::HypreParVector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParVector, 0 ); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg3 = reinterpret_cast< mfem::HypreParVector * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_MultTranspose" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "HypreParMatrix_MultTranspose" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HypreParMatrix_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (HYPRE_Int)(arg1)->MultTranspose(*arg2,*arg3,arg4,arg5); + ((mfem::HypreParMatrix const *)arg1)->MultTranspose(arg2,(mfem::Vector const &)*arg3,arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8145,59 +7837,50 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_0(PyObject *SWIGUN // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::HypreParVector *arg2 = 0 ; - mfem::HypreParVector *arg3 = 0 ; - double arg4 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - HYPRE_Int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParVector, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::HypreParVector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParVector, 0 ); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::HypreParVector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_MultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (HYPRE_Int)(arg1)->MultTranspose(*arg2,*arg3,arg4); + ((mfem::HypreParMatrix const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8208,121 +7891,190 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_1(PyObject *SWIGUN // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::HypreParVector *arg2 = 0 ; - mfem::HypreParVector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - HYPRE_Int result; +SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParVector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::HypreParVector &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_Mult", 0, 5, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_HypreParMatrix_Mult__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_HypreParMatrix_Mult__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_HypreParMatrix_Mult__SWIG_0(self, argc, argv); + } + } + } + } + } } - arg2 = reinterpret_cast< mfem::HypreParVector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParVector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_HypreParMatrix_Mult__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_HypreParMatrix_Mult__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_HypreParMatrix_Mult__SWIG_1(self, argc, argv); + } + } + } + } + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::HypreParVector &""'"); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_HypreParMatrix_Mult__SWIG_3(self, argc, argv); + } + } + } } - arg3 = reinterpret_cast< mfem::HypreParVector * >(argp3); - { - try { - result = (HYPRE_Int)(arg1)->MultTranspose(*arg2,*arg3); + if (argc == 5) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_HypreParMatrix_Mult__SWIG_2(self, argc, argv); + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_Mult'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HypreParMatrix::Mult(mfem::HypreParVector &,mfem::HypreParVector &,double,double)\n" + " mfem::HypreParMatrix::Mult(HYPRE_ParVector,HYPRE_ParVector,double,double)\n" + " mfem::HypreParMatrix::Mult(double,mfem::Vector const &,double,mfem::Vector &) const\n" + " mfem::HypreParMatrix::Mult(mfem::Vector const &,mfem::Vector &) const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - double arg2 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; - mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_Mult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - ((mfem::HypreParMatrix const *)arg1)->Mult(arg2,(mfem::Vector const &)*arg3,arg4,*arg5); + ((mfem::HypreParMatrix const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8340,193 +8092,15 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_6(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - double arg2 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - mfem::Vector *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; +SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreParMatrix_MultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HypreParMatrix_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - ((mfem::HypreParMatrix const *)arg1)->MultTranspose(arg2,(mfem::Vector const &)*arg3,arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Mult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::HypreParMatrix const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_Mult", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_MultTranspose", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_7(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); @@ -8540,96 +8114,43 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_4(self, argc, argv); + if (argc <= 3) { + return _wrap_HypreParMatrix_MultTranspose__SWIG_0(self, argc, argv); } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_HYPRE_ParVector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { { int res = SWIG_AsVal_double(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 4) { + return _wrap_HypreParMatrix_MultTranspose__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_3(self, argc, argv); + return _wrap_HypreParMatrix_MultTranspose__SWIG_0(self, argc, argv); } } } } } } - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_0(self, argc, argv); - } - } + return _wrap_HypreParMatrix_MultTranspose__SWIG_2(self, argc, argv); } } } @@ -8657,7 +8178,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_HypreParMatrix_Mult__SWIG_6(self, argc, argv); + return _wrap_HypreParMatrix_MultTranspose__SWIG_1(self, argc, argv); } } } @@ -8666,261 +8187,65 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Mult(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_Mult'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_MultTranspose'.\n" " Possible C/C++ prototypes are:\n" - " mfem::HypreParMatrix::Mult(mfem::HypreParVector &,mfem::HypreParVector &,double,double)\n" - " mfem::HypreParMatrix::Mult(mfem::HypreParVector &,mfem::HypreParVector &,double)\n" - " mfem::HypreParMatrix::Mult(mfem::HypreParVector &,mfem::HypreParVector &)\n" - " mfem::HypreParMatrix::Mult(HYPRE_ParVector,HYPRE_ParVector,double,double)\n" - " mfem::HypreParMatrix::Mult(HYPRE_ParVector,HYPRE_ParVector,double)\n" - " mfem::HypreParMatrix::Mult(HYPRE_ParVector,HYPRE_ParVector)\n" - " mfem::HypreParMatrix::Mult(double,mfem::Vector const &,double,mfem::Vector &) const\n" - " mfem::HypreParMatrix::Mult(mfem::Vector const &,mfem::Vector &) const\n"); + " mfem::HypreParMatrix::MultTranspose(mfem::HypreParVector &,mfem::HypreParVector &,double,double)\n" + " mfem::HypreParMatrix::MultTranspose(double,mfem::Vector const &,double,mfem::Vector &) const\n" + " mfem::HypreParMatrix::MultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int arg4 ; + int *arg5 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"alpha", (char *)"x", (char *)"beta", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HypreParMatrix_BooleanMult", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_BooleanMult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_BooleanMult" "', argument " "3"" of type '" "int const *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + arg3 = reinterpret_cast< int * >(argp3); + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::HypreParMatrix const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_MultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_MultTranspose", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_MultTranspose__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_MultTranspose__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_MultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__HypreParVector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_MultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_MultTranspose__SWIG_3(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_MultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreParMatrix::MultTranspose(mfem::HypreParVector &,mfem::HypreParVector &,double,double)\n" - " mfem::HypreParMatrix::MultTranspose(mfem::HypreParVector &,mfem::HypreParVector &,double)\n" - " mfem::HypreParMatrix::MultTranspose(mfem::HypreParVector &,mfem::HypreParVector &)\n" - " mfem::HypreParMatrix::MultTranspose(double,mfem::Vector const &,double,mfem::Vector &) const\n" - " mfem::HypreParMatrix::MultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - int arg2 ; - int *arg3 = (int *) 0 ; - int arg4 ; - int *arg5 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_BooleanMult", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_BooleanMult" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_BooleanMult" "', argument " "3"" of type '" "int const *""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HypreParMatrix_BooleanMult" "', argument " "5"" of type '" "int *""'"); - } - arg5 = reinterpret_cast< int * >(argp5); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HypreParMatrix_BooleanMult" "', argument " "5"" of type '" "int *""'"); + } + arg5 = reinterpret_cast< int * >(argp5); { try { (arg1)->BooleanMult(arg2,(int const *)arg3,arg4,arg5); @@ -8941,7 +8266,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_HypreParMatrix_BooleanMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_BooleanMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; int arg2 ; @@ -8954,32 +8279,39 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_BooleanMultTranspose(PyObject *SWIGUNU int res3 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"alpha", (char *)"x", (char *)"beta", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_BooleanMultTranspose", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HypreParMatrix_BooleanMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_BooleanMultTranspose" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "int const *""'"); } arg3 = reinterpret_cast< int * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HypreParMatrix_BooleanMultTranspose" "', argument " "5"" of type '" "int *""'"); } @@ -9004,7 +8336,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_BooleanMultTranspose(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_HypreParMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParMatrix *arg2 = 0 ; @@ -9012,16 +8344,20 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"B", NULL + }; mfem::HypreParMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix___iadd__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParMatrix___iadd__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix___iadd__" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix___iadd__" "', argument " "2"" of type '" "mfem::HypreParMatrix const &""'"); } @@ -9049,7 +8385,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; double arg2 ; @@ -9060,21 +8396,26 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Add(PyObject *SWIGUNUSEDPARM(self), Py int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"beta", (char *)"B", NULL + }; mfem::HypreParMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_Add", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HypreParMatrix_Add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Add" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_Add" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Add" "', argument " "3"" of type '" "mfem::HypreParMatrix const &""'"); } @@ -9102,26 +8443,32 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Add(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_HypreParMatrix_LeftDiagMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_LeftDiagMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; - HYPRE_Int *arg3 = (HYPRE_Int *) 0 ; + HYPRE_Int *arg3 = (HYPRE_Int *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"D", (char *)"row_starts", NULL + }; mfem::HypreParMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:HypreParMatrix_LeftDiagMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -9129,11 +8476,13 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_LeftDiagMult__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "3"" of type '" "HYPRE_Int *""'"); + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "3"" of type '" "HYPRE_Int *""'"); + } + arg3 = reinterpret_cast< HYPRE_Int * >(argp3); } - arg3 = reinterpret_cast< HYPRE_Int * >(argp3); { try { result = (mfem::HypreParMatrix *)((mfem::HypreParMatrix const *)arg1)->LeftDiagMult((mfem::SparseMatrix const &)*arg2,arg3); @@ -9154,33 +8503,37 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_LeftDiagMult__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_HypreParMatrix_LeftDiagMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::SparseMatrix *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - mfem::HypreParMatrix *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParMatrix_ScaleRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_ScaleRows" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_ScaleRows" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_LeftDiagMult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_ScaleRows" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::HypreParMatrix *)((mfem::HypreParMatrix const *)arg1)->LeftDiagMult((mfem::SparseMatrix const &)*arg2); + (arg1)->ScaleRows((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9191,123 +8544,34 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_LeftDiagMult__SWIG_1(PyObject *SWIGUNU // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_LeftDiagMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_HypreParMatrix_InvScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; + mfem::Vector *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_LeftDiagMult", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_LeftDiagMult__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_LeftDiagMult__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_LeftDiagMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreParMatrix::LeftDiagMult(mfem::SparseMatrix const &,HYPRE_Int *) const\n" - " mfem::HypreParMatrix::LeftDiagMult(mfem::SparseMatrix const &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_ScaleRows", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_ScaleRows" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_ScaleRows" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HypreParMatrix_ScaleRows" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->ScaleRows((mfem::Vector const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_InvScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_InvScaleRows", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParMatrix_InvScaleRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_InvScaleRows" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_InvScaleRows" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9335,7 +8599,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_InvScaleRows(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_HypreParMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; double arg2 ; @@ -9343,15 +8607,19 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix___imul__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix___imul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParMatrix___imul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix___imul__" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix___imul__" "', argument " "2"" of type '" "double""'"); } @@ -9376,61 +8644,36 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix___imul__(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Threshold__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - double arg2 ; + double arg2 = (double) 0.0 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"threshold", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:HypreParMatrix_Threshold", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Threshold" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_Threshold" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->Threshold(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Threshold__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Threshold" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreParMatrix_Threshold" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); { try { - (arg1)->Threshold(); + (arg1)->Threshold(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9448,48 +8691,6 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Threshold__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Threshold(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_Threshold", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_Threshold__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreParMatrix_Threshold__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_Threshold'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreParMatrix::Threshold(double)\n" - " mfem::HypreParMatrix::Threshold()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateZeroRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; @@ -9686,7 +8887,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateRowsCols(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9694,16 +8895,20 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateCols(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"cols", NULL + }; mfem::HypreParMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_EliminateCols", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParMatrix_EliminateCols", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9731,7 +8936,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateCols(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9739,15 +8944,19 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateRows(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_EliminateRows", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParMatrix_EliminateRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_EliminateRows" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_EliminateRows" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9775,40 +8984,51 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_EliminateRows(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Print(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; char *arg2 = (char *) 0 ; - HYPRE_Int arg3 ; - HYPRE_Int arg4 ; + HYPRE_Int arg3 = (HYPRE_Int) 0 ; + HYPRE_Int arg4 = (HYPRE_Int) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fname", (char *)"offi", (char *)"offj", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:HypreParMatrix_Print", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Print" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { @@ -9832,37 +9052,46 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - char *arg2 = (char *) 0 ; - HYPRE_Int arg3 ; + MPI_Comm arg2 ; + char *arg3 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"comm", (char *)"fname", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HypreParMatrix_Read", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Print" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Read" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Print" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HypreParMatrix_Read" "', argument " "2"" of type '" "MPI_Comm""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Read" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); { try { - (arg1)->Print((char const *)arg2,arg3); + (arg1)->Read(arg2,(char const *)arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9874,38 +9103,54 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } -SWIGINTERN PyObject *_wrap_HypreParMatrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_Read_IJMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - char *arg2 = (char *) 0 ; + MPI_Comm arg2 ; + char *arg3 = (char *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"comm", (char *)"fname", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HypreParMatrix_Read_IJMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Print" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Read_IJMatrix" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_Print" "', argument " "2"" of type '" "char const *""'"); + { + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(obj1, &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HypreParMatrix_Read_IJMatrix" "', argument " "2"" of type '" "MPI_Comm""'"); + } + arg2 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Read_IJMatrix" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); { try { - (arg1)->Print((char const *)arg2); + (arg1)->Read_IJMatrix(arg2,(char const *)arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9917,206 +9162,10 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Print(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_Print", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_Print__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_HypreParMatrix_Print__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_HypreParMatrix_Print__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_Print'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreParMatrix::Print(char const *,HYPRE_Int,HYPRE_Int)\n" - " mfem::HypreParMatrix::Print(char const *,HYPRE_Int)\n" - " mfem::HypreParMatrix::Print(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - MPI_Comm arg2 ; - char *arg3 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_Read", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Read" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[1], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HypreParMatrix_Read" "', argument " "2"" of type '" "MPI_Comm""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Read" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - try { - (arg1)->Read(arg2,(char const *)arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_Read_IJMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - MPI_Comm arg2 ; - char *arg3 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "HypreParMatrix_Read_IJMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_Read_IJMatrix" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[1], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "HypreParMatrix_Read_IJMatrix" "', argument " "2"" of type '" "MPI_Comm""'"); - } - arg2 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreParMatrix_Read_IJMatrix" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - try { - (arg1)->Read_IJMatrix(arg2,(char const *)arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } @@ -10124,31 +9173,34 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_Read_IJMatrix(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -10181,38 +9233,6 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - try { - ((mfem::HypreParMatrix const *)arg1)->PrintCommPkg(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_delete_HypreParMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; @@ -10422,36 +9442,46 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_get_local_true_nnz(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetCooDataArray__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_GetCooDataArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - HYPRE_Int arg2 ; - HYPRE_Int arg3 ; + HYPRE_Int arg2 = (HYPRE_Int) (HYPRE_Int)0 ; + HYPRE_Int arg3 = (HYPRE_Int) (HYPRE_Int)0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"base_i", (char *)"base_j", NULL + }; PyObject *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:HypreParMatrix_GetCooDataArray", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetCooDataArray" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - result = (PyObject *)mfem_HypreParMatrix_GetCooDataArray__SWIG_0(arg1,arg2,arg3); + result = (PyObject *)mfem_HypreParMatrix_GetCooDataArray(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10469,229 +9499,39 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_GetCooDataArray__SWIG_0(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetCooDataArray__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - HYPRE_Int arg2 ; + char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *result = 0 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetCooDataArray" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (PyObject *)mfem_HypreParMatrix_GetCooDataArray__SWIG_0(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = result; - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetCooDataArray__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_GetCooDataArray" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - try { - result = (PyObject *)mfem_HypreParMatrix_GetCooDataArray__SWIG_0(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = result; - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_GetCooDataArray(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_GetCooDataArray", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_GetCooDataArray__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_HypreParMatrix_GetCooDataArray__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_HypreParMatrix_GetCooDataArray__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_GetCooDataArray'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreParMatrix::GetCooDataArray(HYPRE_Int const,HYPRE_Int const)\n" - " mfem::HypreParMatrix::GetCooDataArray(HYPRE_Int const)\n" - " mfem::HypreParMatrix::GetCooDataArray()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "2"" of type '" "char const *""'"); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_HypreParMatrix_PrintCommPkg__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "1"" of type '" "mfem::HypreParMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParMatrix_PrintCommPkg" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_HypreParMatrix_PrintCommPkg__SWIG_2(arg1,(char const *)arg2); + mfem_HypreParMatrix_PrintCommPkg__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10719,34 +9559,15 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "HypreParMatrix_PrintCommPkg", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_PrintCommPkg__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreParMatrix_PrintCommPkg__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_HypreParMatrix_PrintCommPkg__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -10761,7 +9582,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg(PyObject *self, PyObject } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); @@ -10770,6 +9591,9 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg(PyObject *self, PyObject int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_HypreParMatrix_PrintCommPkg__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10779,7 +9603,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg(PyObject *self, PyObject } } if (_v) { - return _wrap_HypreParMatrix_PrintCommPkg__SWIG_2(self, argc, argv); + return _wrap_HypreParMatrix_PrintCommPkg__SWIG_1(self, argc, argv); } } } @@ -10789,9 +9613,7 @@ SWIGINTERN PyObject *_wrap_HypreParMatrix_PrintCommPkg(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreParMatrix_PrintCommPkg'.\n" " Possible C/C++ prototypes are:\n" " mfem::HypreParMatrix::PrintCommPkg(std::ostream &) const\n" - " mfem::HypreParMatrix::PrintCommPkg() const\n" - " mfem::HypreParMatrix::PrintCommPkg(char const *,int)\n" - " mfem::HypreParMatrix::PrintCommPkg(char const *)\n"); + " mfem::HypreParMatrix::PrintCommPkg(char const *,int)\n"); return 0; } @@ -10807,79 +9629,46 @@ SWIGINTERN PyObject *HypreParMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ParMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; - bool arg3 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"own_matrix", NULL + }; mfem::HypreParMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:ParMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); } arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMult" "', argument " "2"" of type '" "mfem::HypreParMatrix const *""'"); } arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMult" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - result = (mfem::HypreParMatrix *)mfem::ParMult((mfem::HypreParMatrix const *)arg1,(mfem::HypreParMatrix const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::HypreParMatrix *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMult" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMult" "', argument " "2"" of type '" "mfem::HypreParMatrix const *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMult" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); { try { - result = (mfem::HypreParMatrix *)mfem::ParMult((mfem::HypreParMatrix const *)arg1,(mfem::HypreParMatrix const *)arg2); + result = (mfem::HypreParMatrix *)mfem::ParMult((mfem::HypreParMatrix const *)arg1,(mfem::HypreParMatrix const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10895,912 +9684,124 @@ SWIGINTERN PyObject *_wrap_ParMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ss fail: return NULL; } - - -SWIGINTERN PyObject *_wrap_ParMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParMult", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMult__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParMult__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMult(mfem::HypreParMatrix const *,mfem::HypreParMatrix const *,bool)\n" - " mfem::ParMult(mfem::HypreParMatrix const *,mfem::HypreParMatrix const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParAdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; - mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - mfem::HypreParMatrix *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "ParAdd", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParAdd" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParAdd" "', argument " "2"" of type '" "mfem::HypreParMatrix const *""'"); - } - arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); - { - try { - result = (mfem::HypreParMatrix *)mfem::ParAdd((mfem::HypreParMatrix const *)arg1,(mfem::HypreParMatrix const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_EliminateBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - mfem::HypreParMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "EliminateBC", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EliminateBC" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EliminateBC" "', argument " "2"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "2"" of type '" "mfem::HypreParMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "EliminateBC" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - mfem::EliminateBC(*arg1,*arg2,(mfem::Array< int > const &)*arg3,(mfem::Vector const &)*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - double arg5 ; - int arg6 ; - double arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val7 ; - int ecode7 = 0 ; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HypreSmoother" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HypreSmoother" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HypreSmoother" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1,arg2,arg3,arg4,arg5,arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - double arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HypreSmoother" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HypreSmoother" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1,arg2,arg3,arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - double arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HypreSmoother" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HypreSmoother" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1,arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HypreSmoother" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreParMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::HypreSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); - { - try { - result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HypreSmoother(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_HypreSmoother", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_HypreSmoother__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_HypreSmoother__SWIG_7(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_HypreSmoother__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_HypreSmoother__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_HypreSmoother__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_HypreSmoother__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_HypreSmoother__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); - } - } - } - } - } - } + + +SWIGINTERN PyObject *_wrap_ParAdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = (mfem::HypreParMatrix *) 0 ; + mfem::HypreParMatrix *arg2 = (mfem::HypreParMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; + mfem::HypreParMatrix *result = 0 ; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParAdd", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParAdd" "', argument " "1"" of type '" "mfem::HypreParMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParAdd" "', argument " "2"" of type '" "mfem::HypreParMatrix const *""'"); + } + arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); + { + try { + result = (mfem::HypreParMatrix *)mfem::ParAdd((mfem::HypreParMatrix const *)arg1,(mfem::HypreParMatrix const *)arg2); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreParMatrix, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HypreSmoother'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreSmoother::HypreSmoother()\n" - " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &,int,int,double,double,int,double)\n" - " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &,int,int,double,double,int)\n" - " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &,int,int,double,double)\n" - " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &,int,int,double)\n" - " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &,int,int)\n" - " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &,int)\n" - " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetType__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_EliminateBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; - mfem::HypreSmoother::Type arg2 ; - int arg3 ; + mfem::HypreParMatrix *arg1 = 0 ; + mfem::HypreParMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"Ae", (char *)"ess_dof_list", (char *)"X", (char *)"B", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:EliminateBC", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetType" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EliminateBC" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); } - arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetType" "', argument " "2"" of type '" "mfem::HypreSmoother::Type""'"); - } - arg2 = static_cast< mfem::HypreSmoother::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EliminateBC" "', argument " "2"" of type '" "mfem::HypreParMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "2"" of type '" "mfem::HypreParMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::HypreParMatrix * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "EliminateBC" "', argument " "5"" of type '" "mfem::Vector &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EliminateBC" "', argument " "5"" of type '" "mfem::Vector &""'"); } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->SetType(arg2,arg3); + mfem::EliminateBC(*arg1,*arg2,(mfem::Array< int > const &)*arg3,(mfem::Vector const &)*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11818,29 +9819,107 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetType__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetType__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; - mfem::HypreSmoother::Type arg2 ; + mfem::HypreSmoother *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + { + try { + result = (mfem::HypreSmoother *)new mfem::HypreSmoother(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_HypreSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::HypreParMatrix *arg1 = 0 ; + int arg2 = (int) mfem::HypreSmoother::l1GS ; + int arg3 = (int) 1 ; + double arg4 = (double) 1.0 ; + double arg5 = (double) 1.0 ; + int arg6 = (int) 2 ; + double arg7 = (double) .3 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val7 ; + int ecode7 = 0 ; + mfem::HypreSmoother *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 7)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetType" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_HypreSmoother" "', argument " "1"" of type '" "mfem::HypreParMatrix &""'"); + } + arg1 = reinterpret_cast< mfem::HypreParMatrix * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_HypreSmoother" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_HypreSmoother" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_HypreSmoother" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetType" "', argument " "2"" of type '" "mfem::HypreSmoother::Type""'"); - } - arg2 = static_cast< mfem::HypreSmoother::Type >(val2); { try { - (arg1)->SetType(arg2); + result = (mfem::HypreSmoother *)new mfem::HypreSmoother(*arg1,arg2,arg3,arg4,arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11851,47 +9930,45 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetType__SWIG_1(PyObject *SWIGUNUSEDPAR // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HypreSmoother, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetType(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreSmoother(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreSmoother_SetType", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_HypreSmoother", 0, 7, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreSmoother, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreSmoother_SetType__SWIG_1(self, argc, argv); - } - } + if (argc == 0) { + return _wrap_new_HypreSmoother__SWIG_0(self, argc, argv); } - if (argc == 3) { + if ((argc >= 1) && (argc <= 7)) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreSmoother, 0); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); + } { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { + if (argc <= 2) { + return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11901,22 +9978,117 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetType(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_HypreSmoother_SetType__SWIG_0(self, argc, argv); + if (argc <= 3) { + return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 5) { + return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 6) { + return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_HypreSmoother__SWIG_1(self, argc, argv); + } + } + } + } } } } } - + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HypreSmoother'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::HypreSmoother::HypreSmoother()\n" + " mfem::HypreSmoother::HypreSmoother(mfem::HypreParMatrix &,int,int,double,double,int,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_HypreSmoother_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; + mfem::HypreSmoother::Type arg2 ; + int arg3 = (int) 1 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"type", (char *)"relax_times", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:HypreSmoother_SetType", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetType" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); + } + arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetType" "', argument " "2"" of type '" "mfem::HypreSmoother::Type""'"); + } + arg2 = static_cast< mfem::HypreSmoother::Type >(val2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + { + try { + (arg1)->SetType(arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreSmoother_SetType'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreSmoother::SetType(mfem::HypreSmoother::Type,int)\n" - " mfem::HypreSmoother::SetType(mfem::HypreSmoother::Type)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetSOROptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetSOROptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; double arg2 ; @@ -11927,20 +10099,25 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetSOROptions(PyObject *SWIGUNUSEDPARM( int ecode2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"relax_weight", (char *)"omega", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSmoother_SetSOROptions", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HypreSmoother_SetSOROptions", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetSOROptions" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetSOROptions" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreSmoother_SetSOROptions" "', argument " "3"" of type '" "double""'"); } @@ -11965,7 +10142,7 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetSOROptions(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetPolyOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetPolyOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; int arg2 ; @@ -11974,21 +10151,26 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetPolyOptions(PyObject *SWIGUNUSEDPARM int res1 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"poly_order", (char *)"poly_fraction", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSmoother_SetPolyOptions", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HypreSmoother_SetPolyOptions", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetPolyOptions" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreSmoother_SetPolyOptions" "', argument " "3"" of type '" "double""'"); } @@ -12013,7 +10195,7 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetPolyOptions(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetTaubinOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetTaubinOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; double arg2 ; @@ -12025,29 +10207,35 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetTaubinOptions(PyObject *SWIGUNUSEDPA int ecode2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_lambda", (char *)"mu", (char *)"iter", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSmoother_SetTaubinOptions", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:HypreSmoother_SetTaubinOptions", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetTaubinOptions" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetTaubinOptions" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreSmoother_SetTaubinOptions" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -12069,7 +10257,7 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetTaubinOptions(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; char *arg2 = (char *) 0 ; @@ -12078,15 +10266,19 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowByName(PyObject *SWIGUNUSEDPAR int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"window_name", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSmoother_SetWindowByName", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreSmoother_SetWindowByName", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetWindowByName" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreSmoother_SetWindowByName" "', argument " "2"" of type '" "char const *""'"); } @@ -12113,7 +10305,7 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowByName(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; double arg2 ; @@ -12127,25 +10319,31 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowParameters(PyObject *SWIGUNUSE int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"b", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSmoother_SetWindowParameters", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:HypreSmoother_SetWindowParameters", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetWindowParameters" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetWindowParameters" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HypreSmoother_SetWindowParameters" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HypreSmoother_SetWindowParameters" "', argument " "4"" of type '" "double""'"); } @@ -12170,7 +10368,7 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetWindowParameters(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetFIRCoefficients(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetFIRCoefficients(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; double arg2 ; @@ -12178,15 +10376,19 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetFIRCoefficients(PyObject *SWIGUNUSED int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_eig", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSmoother_SetFIRCoefficients", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreSmoother_SetFIRCoefficients", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetFIRCoefficients" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetFIRCoefficients" "', argument " "2"" of type '" "double""'"); } @@ -12211,61 +10413,36 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetFIRCoefficients(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetPositiveDiagonal__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetPositiveDiagonal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pos", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:HypreSmoother_SetPositiveDiagonal", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetPositiveDiagonal" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetPositiveDiagonal" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetPositiveDiagonal(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HypreSmoother_SetPositiveDiagonal__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetPositiveDiagonal" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSmoother_SetPositiveDiagonal" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); { try { - (arg1)->SetPositiveDiagonal(); + (arg1)->SetPositiveDiagonal(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12283,49 +10460,7 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetPositiveDiagonal__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_HypreSmoother_SetPositiveDiagonal(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "HypreSmoother_SetPositiveDiagonal", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreSmoother, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HypreSmoother_SetPositiveDiagonal__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HypreSmoother, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HypreSmoother_SetPositiveDiagonal__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HypreSmoother_SetPositiveDiagonal'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HypreSmoother::SetPositiveDiagonal(bool)\n" - " mfem::HypreSmoother::SetPositiveDiagonal()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_HypreSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSmoother *arg1 = (mfem::HypreSmoother *) 0 ; mfem::Operator *arg2 = 0 ; @@ -12333,15 +10468,19 @@ SWIGINTERN PyObject *_wrap_HypreSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSmoother_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreSmoother_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSmoother_SetOperator" "', argument " "1"" of type '" "mfem::HypreSmoother *""'"); } arg1 = reinterpret_cast< mfem::HypreSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -12646,7 +10785,7 @@ SWIGINTERN PyObject *_wrap_HypreSolver_SolveFcn(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSolver *arg1 = (mfem::HypreSolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -12654,15 +10793,19 @@ SWIGINTERN PyObject *_wrap_HypreSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSolver_SetOperator" "', argument " "1"" of type '" "mfem::HypreSolver *""'"); } arg1 = reinterpret_cast< mfem::HypreSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -12852,7 +10995,7 @@ SWIGINTERN PyObject *_wrap_HypreSolver_Mult(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreSolver_SetErrorMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreSolver_SetErrorMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreSolver *arg1 = (mfem::HypreSolver *) 0 ; mfem::HypreSolver::ErrorMode arg2 ; @@ -12860,15 +11003,19 @@ SWIGINTERN PyObject *_wrap_HypreSolver_SetErrorMode(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"err_mode", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreSolver_SetErrorMode", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreSolver_SetErrorMode", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreSolver_SetErrorMode" "', argument " "1"" of type '" "mfem::HypreSolver const *""'"); } arg1 = reinterpret_cast< mfem::HypreSolver * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreSolver_SetErrorMode" "', argument " "2"" of type '" "mfem::HypreSolver::ErrorMode""'"); } @@ -13040,7 +11187,7 @@ SWIGINTERN PyObject *_wrap_new_HyprePCG(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HyprePCG_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyprePCG_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; mfem::Operator *arg2 = 0 ; @@ -13048,15 +11195,19 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyprePCG_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyprePCG_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetOperator" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyprePCG_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -13084,7 +11235,7 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HyprePCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyprePCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; double arg2 ; @@ -13092,15 +11243,19 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyprePCG_SetTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyprePCG_SetTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetTol" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HyprePCG_SetTol" "', argument " "2"" of type '" "double""'"); } @@ -13125,25 +11280,29 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_HyprePCG_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyprePCG_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_iter", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyprePCG_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyprePCG_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetMaxIter" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -13165,160 +11324,33 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_HyprePCG_SetLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "HyprePCG_SetLogging", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetLogging" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); - } - arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetLogging(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HyprePCG_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "HyprePCG_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetPrintLevel" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); - } - arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetPrintLevel(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HyprePCG_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; - mfem::HypreSolver *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "HyprePCG_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetPreconditioner" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); - } - arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreSolver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyprePCG_SetPreconditioner" "', argument " "2"" of type '" "mfem::HypreSolver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyprePCG_SetPreconditioner" "', argument " "2"" of type '" "mfem::HypreSolver &""'"); - } - arg2 = reinterpret_cast< mfem::HypreSolver * >(argp2); - { - try { - (arg1)->SetPreconditioner(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HyprePCG_SetLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; int arg2 ; - double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"logging", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyprePCG_SetLogging", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetResidualConvergenceOptions" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetLogging" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HyprePCG_SetResidualConvergenceOptions" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { - (arg1)->SetResidualConvergenceOptions(arg2,arg3); + (arg1)->SetLogging(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13336,28 +11368,33 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_0(PyObje } -SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HyprePCG_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"print_lvl", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyprePCG_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetResidualConvergenceOptions" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetPrintLevel" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - (arg1)->SetResidualConvergenceOptions(arg2); + (arg1)->SetPrintLevel(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13375,21 +11412,37 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_HyprePCG_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; + mfem::HypreSolver *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"precond", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyprePCG_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetResidualConvergenceOptions" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetPreconditioner" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreSolver, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyprePCG_SetPreconditioner" "', argument " "2"" of type '" "mfem::HypreSolver &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyprePCG_SetPreconditioner" "', argument " "2"" of type '" "mfem::HypreSolver &""'"); + } + arg2 = reinterpret_cast< mfem::HypreSolver * >(argp2); { try { - (arg1)->SetResidualConvergenceOptions(); + (arg1)->SetPreconditioner(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13407,75 +11460,60 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_2(PyObje } -SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_HyprePCG_SetResidualConvergenceOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; + int arg2 = (int) -1 ; + double arg3 = (double) 0.0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"res_frequency", (char *)"rtol", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "HyprePCG_SetResidualConvergenceOptions", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HyprePCG, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_2(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:HyprePCG_SetResidualConvergenceOptions", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_SetResidualConvergenceOptions" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HyprePCG, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_1(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__HyprePCG, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_HyprePCG_SetResidualConvergenceOptions__SWIG_0(self, argc, argv); - } - } + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HyprePCG_SetResidualConvergenceOptions" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } + { + try { + (arg1)->SetResidualConvergenceOptions(arg2,arg3); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HyprePCG_SetResidualConvergenceOptions'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HyprePCG::SetResidualConvergenceOptions(int,double)\n" - " mfem::HyprePCG::SetResidualConvergenceOptions(int)\n" - " mfem::HyprePCG::SetResidualConvergenceOptions()\n"); - return 0; + return NULL; } @@ -13513,7 +11551,7 @@ SWIGINTERN PyObject *_wrap_HyprePCG_SetZeroInintialIterate(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_HyprePCG_GetNumIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyprePCG_GetNumIterations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyprePCG *arg1 = (mfem::HyprePCG *) 0 ; int *arg2 = 0 ; @@ -13521,15 +11559,19 @@ SWIGINTERN PyObject *_wrap_HyprePCG_GetNumIterations(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"num_iterations", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyprePCG_GetNumIterations", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyprePCG_GetNumIterations", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyprePCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyprePCG_GetNumIterations" "', argument " "1"" of type '" "mfem::HyprePCG *""'"); } arg1 = reinterpret_cast< mfem::HyprePCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyprePCG_GetNumIterations" "', argument " "2"" of type '" "int &""'"); } @@ -13940,7 +11982,7 @@ SWIGINTERN PyObject *_wrap_new_HypreGMRES(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreGMRES_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreGMRES_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; mfem::Operator *arg2 = 0 ; @@ -13948,15 +11990,19 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetOperator(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreGMRES_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetOperator" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); } arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreGMRES_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -13984,7 +12030,7 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetOperator(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_HypreGMRES_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreGMRES_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; double arg2 ; @@ -13992,15 +12038,19 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetTol(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreGMRES_SetTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetTol" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); } arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreGMRES_SetTol" "', argument " "2"" of type '" "double""'"); } @@ -14025,25 +12075,29 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetTol(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_HypreGMRES_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreGMRES_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_iter", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreGMRES_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetMaxIter" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); } arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -14065,25 +12119,29 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreGMRES_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreGMRES_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetKDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreGMRES_SetKDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetKDim" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); } arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -14105,25 +12163,29 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetKDim(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_HypreGMRES_SetLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreGMRES_SetLogging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"logging", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetLogging", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreGMRES_SetLogging", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetLogging" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); } arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -14145,25 +12207,29 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetLogging(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreGMRES_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreGMRES_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"print_lvl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreGMRES_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetPrintLevel" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); } arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -14185,7 +12251,7 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetPrintLevel(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_HypreGMRES_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreGMRES_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreGMRES *arg1 = (mfem::HypreGMRES *) 0 ; mfem::HypreSolver *arg2 = 0 ; @@ -14193,15 +12259,19 @@ SWIGINTERN PyObject *_wrap_HypreGMRES_SetPreconditioner(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"precond", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreGMRES_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreGMRES_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreGMRES, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreGMRES_SetPreconditioner" "', argument " "1"" of type '" "mfem::HypreGMRES *""'"); } arg1 = reinterpret_cast< mfem::HypreGMRES * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreSolver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreSolver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreGMRES_SetPreconditioner" "', argument " "2"" of type '" "mfem::HypreSolver &""'"); } @@ -14771,7 +12841,7 @@ SWIGINTERN PyObject *_wrap_new_HypreDiagScale(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreDiagScale_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreDiagScale_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreDiagScale *arg1 = (mfem::HypreDiagScale *) 0 ; mfem::Operator *arg2 = 0 ; @@ -14779,15 +12849,19 @@ SWIGINTERN PyObject *_wrap_HypreDiagScale_SetOperator(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreDiagScale_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreDiagScale, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreDiagScale_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreDiagScale, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreDiagScale_SetOperator" "', argument " "1"" of type '" "mfem::HypreDiagScale *""'"); } arg1 = reinterpret_cast< mfem::HypreDiagScale * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreDiagScale_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -15071,7 +13145,7 @@ SWIGINTERN PyObject *_wrap_new_HypreParaSails(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreParaSails_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParaSails_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParaSails *arg1 = (mfem::HypreParaSails *) 0 ; mfem::Operator *arg2 = 0 ; @@ -15079,15 +13153,19 @@ SWIGINTERN PyObject *_wrap_HypreParaSails_SetOperator(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParaSails_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParaSails, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParaSails_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParaSails, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParaSails_SetOperator" "', argument " "1"" of type '" "mfem::HypreParaSails *""'"); } arg1 = reinterpret_cast< mfem::HypreParaSails * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreParaSails_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -15115,25 +13193,29 @@ SWIGINTERN PyObject *_wrap_HypreParaSails_SetOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_HypreParaSails_SetSymmetry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreParaSails_SetSymmetry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreParaSails *arg1 = (mfem::HypreParaSails *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sym", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreParaSails_SetSymmetry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreParaSails, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreParaSails_SetSymmetry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreParaSails, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreParaSails_SetSymmetry" "', argument " "1"" of type '" "mfem::HypreParaSails *""'"); } arg1 = reinterpret_cast< mfem::HypreParaSails * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -15376,7 +13458,7 @@ SWIGINTERN PyObject *_wrap_new_HypreEuclid(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreEuclid_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreEuclid_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreEuclid *arg1 = (mfem::HypreEuclid *) 0 ; mfem::Operator *arg2 = 0 ; @@ -15384,15 +13466,19 @@ SWIGINTERN PyObject *_wrap_HypreEuclid_SetOperator(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreEuclid_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreEuclid, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreEuclid_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreEuclid, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreEuclid_SetOperator" "', argument " "1"" of type '" "mfem::HypreEuclid *""'"); } arg1 = reinterpret_cast< mfem::HypreEuclid * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreEuclid_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -15626,7 +13712,7 @@ SWIGINTERN PyObject *_wrap_new_HypreBoomerAMG(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreBoomerAMG *arg1 = (mfem::HypreBoomerAMG *) 0 ; mfem::Operator *arg2 = 0 ; @@ -15634,15 +13720,19 @@ SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetOperator(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreBoomerAMG_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreBoomerAMG_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreBoomerAMG_SetOperator" "', argument " "1"" of type '" "mfem::HypreBoomerAMG *""'"); } arg1 = reinterpret_cast< mfem::HypreBoomerAMG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreBoomerAMG_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -15670,25 +13760,29 @@ SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetSystemsOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetSystemsOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreBoomerAMG *arg1 = (mfem::HypreBoomerAMG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreBoomerAMG_SetSystemsOptions", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreBoomerAMG_SetSystemsOptions", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreBoomerAMG_SetSystemsOptions" "', argument " "1"" of type '" "mfem::HypreBoomerAMG *""'"); } arg1 = reinterpret_cast< mfem::HypreBoomerAMG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -15710,7 +13804,7 @@ SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetSystemsOptions(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetElasticityOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetElasticityOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreBoomerAMG *arg1 = (mfem::HypreBoomerAMG *) 0 ; mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; @@ -15718,15 +13812,19 @@ SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetElasticityOptions(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fespace", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreBoomerAMG_SetElasticityOptions", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreBoomerAMG_SetElasticityOptions", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreBoomerAMG_SetElasticityOptions" "', argument " "1"" of type '" "mfem::HypreBoomerAMG *""'"); } arg1 = reinterpret_cast< mfem::HypreBoomerAMG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreBoomerAMG_SetElasticityOptions" "', argument " "2"" of type '" "mfem::ParFiniteElementSpace *""'"); } @@ -15751,25 +13849,29 @@ SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetElasticityOptions(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreBoomerAMG_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreBoomerAMG *arg1 = (mfem::HypreBoomerAMG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"print_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreBoomerAMG_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreBoomerAMG_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreBoomerAMG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreBoomerAMG_SetPrintLevel" "', argument " "1"" of type '" "mfem::HypreBoomerAMG *""'"); } arg1 = reinterpret_cast< mfem::HypreBoomerAMG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16024,7 +14126,7 @@ SWIGINTERN PyObject *_wrap_new_HypreAMS(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreAMS_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAMS_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAMS *arg1 = (mfem::HypreAMS *) 0 ; mfem::Operator *arg2 = 0 ; @@ -16032,15 +14134,19 @@ SWIGINTERN PyObject *_wrap_HypreAMS_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAMS_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAMS, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAMS_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAMS_SetOperator" "', argument " "1"" of type '" "mfem::HypreAMS *""'"); } arg1 = reinterpret_cast< mfem::HypreAMS * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreAMS_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -16068,25 +14174,29 @@ SWIGINTERN PyObject *_wrap_HypreAMS_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreAMS_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAMS_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAMS *arg1 = (mfem::HypreAMS *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"print_lvl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAMS_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAMS, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAMS_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAMS, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAMS_SetPrintLevel" "', argument " "1"" of type '" "mfem::HypreAMS *""'"); } arg1 = reinterpret_cast< mfem::HypreAMS * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16375,7 +14485,7 @@ SWIGINTERN PyObject *_wrap_new_HypreADS(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_HypreADS_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreADS_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreADS *arg1 = (mfem::HypreADS *) 0 ; mfem::Operator *arg2 = 0 ; @@ -16383,15 +14493,19 @@ SWIGINTERN PyObject *_wrap_HypreADS_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreADS_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreADS, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreADS_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreADS, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreADS_SetOperator" "', argument " "1"" of type '" "mfem::HypreADS *""'"); } arg1 = reinterpret_cast< mfem::HypreADS * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreADS_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -16419,25 +14533,29 @@ SWIGINTERN PyObject *_wrap_HypreADS_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreADS_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreADS_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreADS *arg1 = (mfem::HypreADS *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"print_lvl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreADS_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreADS, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreADS_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreADS, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreADS_SetPrintLevel" "', argument " "1"" of type '" "mfem::HypreADS *""'"); } arg1 = reinterpret_cast< mfem::HypreADS * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16574,17 +14692,19 @@ SWIGINTERN PyObject *HypreADS_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HypreLOBPCG(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreLOBPCG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; MPI_Comm arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"comm", NULL + }; mfem::HypreLOBPCG *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_HypreLOBPCG", kwnames, &obj0)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj0, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HypreLOBPCG" "', argument " "1"" of type '" "MPI_Comm""'"); } @@ -16645,7 +14765,7 @@ SWIGINTERN PyObject *_wrap_delete_HypreLOBPCG(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; double arg2 ; @@ -16653,15 +14773,19 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetTol(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetTol" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreLOBPCG_SetTol" "', argument " "2"" of type '" "double""'"); } @@ -16686,7 +14810,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetTol(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; double arg2 ; @@ -16694,15 +14818,19 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetRelTol(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rel_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetRelTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetRelTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetRelTol" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreLOBPCG_SetRelTol" "', argument " "2"" of type '" "double""'"); } @@ -16727,25 +14855,29 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetRelTol(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_iter", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetMaxIter" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16767,25 +14899,29 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetMaxIter(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"logging", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetPrintLevel" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16807,25 +14943,29 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPrintLevel(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetNumModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetNumModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"num_eigs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetNumModes", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetNumModes", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetNumModes" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16847,25 +14987,29 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetNumModes(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPrecondUsageMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPrecondUsageMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pcg_mode", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetPrecondUsageMode", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetPrecondUsageMode", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetPrecondUsageMode" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16887,25 +15031,29 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPrecondUsageMode(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetRandomSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetRandomSeed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetRandomSeed", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetRandomSeed", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetRandomSeed" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16927,7 +15075,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetRandomSeed(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetInitialVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetInitialVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; int arg2 ; @@ -16936,21 +15084,26 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetInitialVectors(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"num_vecs", (char *)"vecs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetInitialVectors", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HypreLOBPCG_SetInitialVectors", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetInitialVectors" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_mfem__HypreParVector, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_mfem__HypreParVector, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HypreLOBPCG_SetInitialVectors" "', argument " "3"" of type '" "mfem::HypreParVector **""'"); } @@ -16975,7 +15128,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetInitialVectors(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; mfem::Solver *arg2 = 0 ; @@ -16983,15 +15136,19 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPreconditioner(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"precond", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetPreconditioner" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreLOBPCG_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } @@ -17019,7 +15176,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetPreconditioner(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; mfem::Operator *arg2 = 0 ; @@ -17027,15 +15184,19 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetOperator(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetOperator" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreLOBPCG_SetOperator" "', argument " "2"" of type '" "mfem::Operator &""'"); } @@ -17063,7 +15224,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetOperator(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetMassMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetMassMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; mfem::Operator *arg2 = 0 ; @@ -17071,15 +15232,19 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetMassMatrix(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetMassMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetMassMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetMassMatrix" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreLOBPCG_SetMassMatrix" "', argument " "2"" of type '" "mfem::Operator &""'"); } @@ -17107,7 +15272,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetMassMatrix(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetSubSpaceProjector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetSubSpaceProjector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; mfem::Operator *arg2 = 0 ; @@ -17115,15 +15280,19 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_SetSubSpaceProjector(PyObject *SWIGUNUSED int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"proj", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_SetSubSpaceProjector", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_SetSubSpaceProjector", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_SetSubSpaceProjector" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreLOBPCG_SetSubSpaceProjector" "', argument " "2"" of type '" "mfem::Operator &""'"); } @@ -17185,7 +15354,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_Solve(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_GetEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_GetEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; mfem::Array< double > *arg2 = 0 ; @@ -17193,15 +15362,19 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_GetEigenvalues(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"eigenvalues", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_GetEigenvalues", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_GetEigenvalues", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_GetEigenvalues" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreLOBPCG_GetEigenvalues" "', argument " "2"" of type '" "mfem::Array< double > &""'"); } @@ -17229,7 +15402,7 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_GetEigenvalues(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_HypreLOBPCG_GetEigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreLOBPCG_GetEigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreLOBPCG *arg1 = (mfem::HypreLOBPCG *) 0 ; unsigned int arg2 ; @@ -17237,16 +15410,20 @@ SWIGINTERN PyObject *_wrap_HypreLOBPCG_GetEigenvector(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::HypreParVector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "HypreLOBPCG_GetEigenvector", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreLOBPCG_GetEigenvector", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreLOBPCG, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreLOBPCG_GetEigenvector" "', argument " "1"" of type '" "mfem::HypreLOBPCG *""'"); } arg1 = reinterpret_cast< mfem::HypreLOBPCG * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreLOBPCG_GetEigenvector" "', argument " "2"" of type '" "unsigned int""'"); } @@ -17317,17 +15494,19 @@ SWIGINTERN PyObject *HypreLOBPCG_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HypreAME(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HypreAME(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; MPI_Comm arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"comm", NULL + }; mfem::HypreAME *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_HypreAME", kwnames, &obj0)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj0, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_HypreAME" "', argument " "1"" of type '" "MPI_Comm""'"); } @@ -17388,7 +15567,7 @@ SWIGINTERN PyObject *_wrap_delete_HypreAME(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_HypreAME_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; double arg2 ; @@ -17396,15 +15575,19 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetTol" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreAME_SetTol" "', argument " "2"" of type '" "double""'"); } @@ -17429,7 +15612,7 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_HypreAME_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; double arg2 ; @@ -17437,15 +15620,19 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetRelTol(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rel_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetRelTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetRelTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetRelTol" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreAME_SetRelTol" "', argument " "2"" of type '" "double""'"); } @@ -17470,25 +15657,29 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetRelTol(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_HypreAME_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_iter", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetMaxIter" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -17510,25 +15701,29 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_HypreAME_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"logging", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetPrintLevel" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -17550,25 +15745,29 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_HypreAME_SetNumModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetNumModes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"num_eigs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetNumModes", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetNumModes", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetNumModes" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -17590,7 +15789,7 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetNumModes(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreAME_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; mfem::HypreSolver *arg2 = 0 ; @@ -17598,15 +15797,19 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetPreconditioner(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"precond", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetPreconditioner" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreSolver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreSolver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreAME_SetPreconditioner" "', argument " "2"" of type '" "mfem::HypreSolver &""'"); } @@ -17634,7 +15837,7 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetPreconditioner(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_HypreAME_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; mfem::HypreParMatrix *arg2 = 0 ; @@ -17642,15 +15845,19 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetOperator" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreAME_SetOperator" "', argument " "2"" of type '" "mfem::HypreParMatrix &""'"); } @@ -17678,7 +15885,7 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_HypreAME_SetMassMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_SetMassMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; mfem::HypreParMatrix *arg2 = 0 ; @@ -17686,15 +15893,19 @@ SWIGINTERN PyObject *_wrap_HypreAME_SetMassMatrix(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_SetMassMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_SetMassMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_SetMassMatrix" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreAME_SetMassMatrix" "', argument " "2"" of type '" "mfem::HypreParMatrix &""'"); } @@ -17756,7 +15967,7 @@ SWIGINTERN PyObject *_wrap_HypreAME_Solve(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_HypreAME_GetEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_GetEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; mfem::Array< double > *arg2 = 0 ; @@ -17764,15 +15975,19 @@ SWIGINTERN PyObject *_wrap_HypreAME_GetEigenvalues(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"eigenvalues", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_GetEigenvalues", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_GetEigenvalues", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_GetEigenvalues" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HypreAME_GetEigenvalues" "', argument " "2"" of type '" "mfem::Array< double > &""'"); } @@ -17800,7 +16015,7 @@ SWIGINTERN PyObject *_wrap_HypreAME_GetEigenvalues(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HypreAME_GetEigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HypreAME_GetEigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HypreAME *arg1 = (mfem::HypreAME *) 0 ; unsigned int arg2 ; @@ -17808,16 +16023,20 @@ SWIGINTERN PyObject *_wrap_HypreAME_GetEigenvector(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; unsigned int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::HypreParVector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "HypreAME_GetEigenvector", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HypreAME_GetEigenvector", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HypreAME, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HypreAME_GetEigenvector" "', argument " "1"" of type '" "mfem::HypreAME *""'"); } arg1 = reinterpret_cast< mfem::HypreAME * >(argp1); - ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HypreAME_GetEigenvector" "', argument " "2"" of type '" "unsigned int""'"); } @@ -17904,17 +16123,17 @@ static PyMethodDef SwigMethods[] = { { "HypreParVector_Partitioning", _wrap_HypreParVector_Partitioning, METH_O, "HypreParVector_Partitioning(HypreParVector self) -> HYPRE_Int *"}, { "HypreParVector_GlobalSize", _wrap_HypreParVector_GlobalSize, METH_O, "HypreParVector_GlobalSize(HypreParVector self) -> HYPRE_Int"}, { "HypreParVector_StealParVector", _wrap_HypreParVector_StealParVector, METH_O, "HypreParVector_StealParVector(HypreParVector self) -> hypre_ParVector *"}, - { "HypreParVector_SetOwnership", _wrap_HypreParVector_SetOwnership, METH_VARARGS, "HypreParVector_SetOwnership(HypreParVector self, int own)"}, + { "HypreParVector_SetOwnership", (PyCFunction)(void(*)(void))_wrap_HypreParVector_SetOwnership, METH_VARARGS|METH_KEYWORDS, "HypreParVector_SetOwnership(HypreParVector self, int own)"}, { "HypreParVector_GetOwnership", _wrap_HypreParVector_GetOwnership, METH_O, "HypreParVector_GetOwnership(HypreParVector self) -> int"}, { "HypreParVector_GlobalVector", _wrap_HypreParVector_GlobalVector, METH_O, "HypreParVector_GlobalVector(HypreParVector self) -> Vector"}, - { "HypreParVector_SetData", _wrap_HypreParVector_SetData, METH_VARARGS, "HypreParVector_SetData(HypreParVector self, double * _data)"}, - { "HypreParVector_Randomize", _wrap_HypreParVector_Randomize, METH_VARARGS, "HypreParVector_Randomize(HypreParVector self, HYPRE_Int seed) -> HYPRE_Int"}, - { "HypreParVector_Print", _wrap_HypreParVector_Print, METH_VARARGS, "HypreParVector_Print(HypreParVector self, char const * fname)"}, + { "HypreParVector_SetData", (PyCFunction)(void(*)(void))_wrap_HypreParVector_SetData, METH_VARARGS|METH_KEYWORDS, "HypreParVector_SetData(HypreParVector self, double * _data)"}, + { "HypreParVector_Randomize", (PyCFunction)(void(*)(void))_wrap_HypreParVector_Randomize, METH_VARARGS|METH_KEYWORDS, "HypreParVector_Randomize(HypreParVector self, HYPRE_Int seed) -> HYPRE_Int"}, + { "HypreParVector_Print", (PyCFunction)(void(*)(void))_wrap_HypreParVector_Print, METH_VARARGS|METH_KEYWORDS, "HypreParVector_Print(HypreParVector self, char const * fname)"}, { "delete_HypreParVector", _wrap_delete_HypreParVector, METH_O, "delete_HypreParVector(HypreParVector self)"}, { "HypreParVector_GetPartitioningArray", _wrap_HypreParVector_GetPartitioningArray, METH_O, "HypreParVector_GetPartitioningArray(HypreParVector self) -> PyObject *"}, { "HypreParVector_swigregister", HypreParVector_swigregister, METH_O, NULL}, { "HypreParVector_swiginit", HypreParVector_swiginit, METH_VARARGS, NULL}, - { "ParNormlp", _wrap_ParNormlp, METH_VARARGS, "ParNormlp(Vector vec, double p, MPI_Comm comm) -> double"}, + { "ParNormlp", (PyCFunction)(void(*)(void))_wrap_ParNormlp, METH_VARARGS|METH_KEYWORDS, "ParNormlp(Vector vec, double p, MPI_Comm comm) -> double"}, { "new_HypreParMatrix", _wrap_new_HypreParMatrix, METH_VARARGS, "\n" "HypreParMatrix()\n" "HypreParMatrix(hypre_ParCSRMatrix * a, bool owner=True)\n" @@ -17928,10 +16147,10 @@ static PyMethodDef SwigMethods[] = { "HypreParMatrix(MPI_Comm comm, int nrows, HYPRE_Int glob_nrows, HYPRE_Int glob_ncols, int * I)\n" "new_HypreParMatrix(HypreParMatrix P) -> HypreParMatrix\n" ""}, - { "HypreParMatrix_MakeRef", _wrap_HypreParMatrix_MakeRef, METH_VARARGS, "HypreParMatrix_MakeRef(HypreParMatrix self, HypreParMatrix master)"}, + { "HypreParMatrix_MakeRef", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_MakeRef, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_MakeRef(HypreParMatrix self, HypreParMatrix master)"}, { "HypreParMatrix_GetComm", _wrap_HypreParMatrix_GetComm, METH_O, "HypreParMatrix_GetComm(HypreParMatrix self) -> MPI_Comm"}, { "HypreParMatrix_StealData", _wrap_HypreParMatrix_StealData, METH_O, "HypreParMatrix_StealData(HypreParMatrix self) -> hypre_ParCSRMatrix *"}, - { "HypreParMatrix_SetOwnerFlags", _wrap_HypreParMatrix_SetOwnerFlags, METH_VARARGS, "HypreParMatrix_SetOwnerFlags(HypreParMatrix self, signed char diag, signed char offd, signed char colmap)"}, + { "HypreParMatrix_SetOwnerFlags", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_SetOwnerFlags, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_SetOwnerFlags(HypreParMatrix self, signed char diag, signed char offd, signed char colmap)"}, { "HypreParMatrix_OwnsDiag", _wrap_HypreParMatrix_OwnsDiag, METH_O, "HypreParMatrix_OwnsDiag(HypreParMatrix self) -> signed char"}, { "HypreParMatrix_OwnsOffd", _wrap_HypreParMatrix_OwnsOffd, METH_O, "HypreParMatrix_OwnsOffd(HypreParMatrix self) -> signed char"}, { "HypreParMatrix_OwnsColMap", _wrap_HypreParMatrix_OwnsColMap, METH_O, "HypreParMatrix_OwnsColMap(HypreParMatrix self) -> signed char"}, @@ -17952,8 +16171,8 @@ static PyMethodDef SwigMethods[] = { "HypreParMatrix_GetDiag(HypreParMatrix self, Vector diag)\n" "HypreParMatrix_GetDiag(HypreParMatrix self, SparseMatrix diag)\n" ""}, - { "HypreParMatrix_GetOffd", _wrap_HypreParMatrix_GetOffd, METH_VARARGS, "HypreParMatrix_GetOffd(HypreParMatrix self, SparseMatrix offd, HYPRE_Int *& cmap)"}, - { "HypreParMatrix_GetBlocks", _wrap_HypreParMatrix_GetBlocks, METH_VARARGS, "HypreParMatrix_GetBlocks(HypreParMatrix self, mfem::Array2D< mfem::HypreParMatrix * > & blocks, bool interleaved_rows=False, bool interleaved_cols=False)"}, + { "HypreParMatrix_GetOffd", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_GetOffd, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_GetOffd(HypreParMatrix self, SparseMatrix offd, HYPRE_Int *& cmap)"}, + { "HypreParMatrix_GetBlocks", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_GetBlocks, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_GetBlocks(HypreParMatrix self, mfem::Array2D< mfem::HypreParMatrix * > & blocks, bool interleaved_rows=False, bool interleaved_cols=False)"}, { "HypreParMatrix_Transpose", _wrap_HypreParMatrix_Transpose, METH_O, "HypreParMatrix_Transpose(HypreParMatrix self) -> HypreParMatrix"}, { "HypreParMatrix_GetNumRows", _wrap_HypreParMatrix_GetNumRows, METH_O, "HypreParMatrix_GetNumRows(HypreParMatrix self) -> int"}, { "HypreParMatrix_GetNumCols", _wrap_HypreParMatrix_GetNumCols, METH_O, "HypreParMatrix_GetNumCols(HypreParMatrix self) -> int"}, @@ -17972,54 +16191,54 @@ static PyMethodDef SwigMethods[] = { "HypreParMatrix_MultTranspose(HypreParMatrix self, double a, Vector x, double b, Vector y)\n" "HypreParMatrix_MultTranspose(HypreParMatrix self, Vector x, Vector y)\n" ""}, - { "HypreParMatrix_BooleanMult", _wrap_HypreParMatrix_BooleanMult, METH_VARARGS, "HypreParMatrix_BooleanMult(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, - { "HypreParMatrix_BooleanMultTranspose", _wrap_HypreParMatrix_BooleanMultTranspose, METH_VARARGS, "HypreParMatrix_BooleanMultTranspose(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, - { "HypreParMatrix___iadd__", _wrap_HypreParMatrix___iadd__, METH_VARARGS, "HypreParMatrix___iadd__(HypreParMatrix self, HypreParMatrix B) -> HypreParMatrix"}, - { "HypreParMatrix_Add", _wrap_HypreParMatrix_Add, METH_VARARGS, "HypreParMatrix_Add(HypreParMatrix self, double const beta, HypreParMatrix B) -> HypreParMatrix"}, - { "HypreParMatrix_LeftDiagMult", _wrap_HypreParMatrix_LeftDiagMult, METH_VARARGS, "HypreParMatrix_LeftDiagMult(HypreParMatrix self, SparseMatrix D, HYPRE_Int * row_starts=None) -> HypreParMatrix"}, - { "HypreParMatrix_ScaleRows", _wrap_HypreParMatrix_ScaleRows, METH_VARARGS, "HypreParMatrix_ScaleRows(HypreParMatrix self, Vector s)"}, - { "HypreParMatrix_InvScaleRows", _wrap_HypreParMatrix_InvScaleRows, METH_VARARGS, "HypreParMatrix_InvScaleRows(HypreParMatrix self, Vector s)"}, - { "HypreParMatrix___imul__", _wrap_HypreParMatrix___imul__, METH_VARARGS, "HypreParMatrix___imul__(HypreParMatrix self, double s)"}, - { "HypreParMatrix_Threshold", _wrap_HypreParMatrix_Threshold, METH_VARARGS, "HypreParMatrix_Threshold(HypreParMatrix self, double threshold=0.0)"}, + { "HypreParMatrix_BooleanMult", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_BooleanMult, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_BooleanMult(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, + { "HypreParMatrix_BooleanMultTranspose", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_BooleanMultTranspose, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_BooleanMultTranspose(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, + { "HypreParMatrix___iadd__", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix___iadd__, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix___iadd__(HypreParMatrix self, HypreParMatrix B) -> HypreParMatrix"}, + { "HypreParMatrix_Add", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Add, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_Add(HypreParMatrix self, double const beta, HypreParMatrix B) -> HypreParMatrix"}, + { "HypreParMatrix_LeftDiagMult", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_LeftDiagMult, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_LeftDiagMult(HypreParMatrix self, SparseMatrix D, HYPRE_Int * row_starts=None) -> HypreParMatrix"}, + { "HypreParMatrix_ScaleRows", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_ScaleRows, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_ScaleRows(HypreParMatrix self, Vector s)"}, + { "HypreParMatrix_InvScaleRows", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_InvScaleRows, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_InvScaleRows(HypreParMatrix self, Vector s)"}, + { "HypreParMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix___imul__(HypreParMatrix self, double s)"}, + { "HypreParMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_Threshold(HypreParMatrix self, double threshold=0.0)"}, { "HypreParMatrix_EliminateZeroRows", _wrap_HypreParMatrix_EliminateZeroRows, METH_O, "HypreParMatrix_EliminateZeroRows(HypreParMatrix self)"}, { "HypreParMatrix_EliminateRowsCols", _wrap_HypreParMatrix_EliminateRowsCols, METH_VARARGS, "\n" "HypreParMatrix_EliminateRowsCols(HypreParMatrix self, intArray rows_cols, HypreParVector X, HypreParVector B)\n" "HypreParMatrix_EliminateRowsCols(HypreParMatrix self, intArray rows_cols) -> HypreParMatrix\n" ""}, - { "HypreParMatrix_EliminateCols", _wrap_HypreParMatrix_EliminateCols, METH_VARARGS, "HypreParMatrix_EliminateCols(HypreParMatrix self, intArray cols) -> HypreParMatrix"}, - { "HypreParMatrix_EliminateRows", _wrap_HypreParMatrix_EliminateRows, METH_VARARGS, "HypreParMatrix_EliminateRows(HypreParMatrix self, intArray rows)"}, - { "HypreParMatrix_Print", _wrap_HypreParMatrix_Print, METH_VARARGS, "HypreParMatrix_Print(HypreParMatrix self, char const * fname, HYPRE_Int offi=0, HYPRE_Int offj=0)"}, - { "HypreParMatrix_Read", _wrap_HypreParMatrix_Read, METH_VARARGS, "HypreParMatrix_Read(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, - { "HypreParMatrix_Read_IJMatrix", _wrap_HypreParMatrix_Read_IJMatrix, METH_VARARGS, "HypreParMatrix_Read_IJMatrix(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, + { "HypreParMatrix_EliminateCols", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_EliminateCols, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_EliminateCols(HypreParMatrix self, intArray cols) -> HypreParMatrix"}, + { "HypreParMatrix_EliminateRows", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_EliminateRows, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_EliminateRows(HypreParMatrix self, intArray rows)"}, + { "HypreParMatrix_Print", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Print, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_Print(HypreParMatrix self, char const * fname, HYPRE_Int offi=0, HYPRE_Int offj=0)"}, + { "HypreParMatrix_Read", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Read, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_Read(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, + { "HypreParMatrix_Read_IJMatrix", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Read_IJMatrix, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_Read_IJMatrix(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, { "delete_HypreParMatrix", _wrap_delete_HypreParMatrix, METH_O, "delete_HypreParMatrix(HypreParMatrix self)"}, { "HypreParMatrix_GetType", _wrap_HypreParMatrix_GetType, METH_O, "HypreParMatrix_GetType(HypreParMatrix self) -> mfem::Operator::Type"}, { "HypreParMatrix_GetRowPartArray", _wrap_HypreParMatrix_GetRowPartArray, METH_O, "HypreParMatrix_GetRowPartArray(HypreParMatrix self) -> PyObject *"}, { "HypreParMatrix_GetColPartArray", _wrap_HypreParMatrix_GetColPartArray, METH_O, "HypreParMatrix_GetColPartArray(HypreParMatrix self) -> PyObject *"}, { "HypreParMatrix_get_local_nnz", _wrap_HypreParMatrix_get_local_nnz, METH_O, "HypreParMatrix_get_local_nnz(HypreParMatrix self) -> HYPRE_Int"}, { "HypreParMatrix_get_local_true_nnz", _wrap_HypreParMatrix_get_local_true_nnz, METH_O, "HypreParMatrix_get_local_true_nnz(HypreParMatrix self) -> PyObject *"}, - { "HypreParMatrix_GetCooDataArray", _wrap_HypreParMatrix_GetCooDataArray, METH_VARARGS, "HypreParMatrix_GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject"}, + { "HypreParMatrix_GetCooDataArray", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_GetCooDataArray, METH_VARARGS|METH_KEYWORDS, "HypreParMatrix_GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject *"}, { "HypreParMatrix_PrintCommPkg", _wrap_HypreParMatrix_PrintCommPkg, METH_VARARGS, "\n" "HypreParMatrix_PrintCommPkg(HypreParMatrix self, std::ostream & out=mfem::out)\n" "HypreParMatrix_PrintCommPkg(HypreParMatrix self, char const * file, int precision=8)\n" ""}, { "HypreParMatrix_swigregister", HypreParMatrix_swigregister, METH_O, NULL}, { "HypreParMatrix_swiginit", HypreParMatrix_swiginit, METH_VARARGS, NULL}, - { "ParMult", _wrap_ParMult, METH_VARARGS, "ParMult(HypreParMatrix A, HypreParMatrix B, bool own_matrix=False) -> HypreParMatrix"}, - { "ParAdd", _wrap_ParAdd, METH_VARARGS, "ParAdd(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix"}, - { "EliminateBC", _wrap_EliminateBC, METH_VARARGS, "EliminateBC(HypreParMatrix A, HypreParMatrix Ae, intArray ess_dof_list, Vector X, Vector B)"}, + { "ParMult", (PyCFunction)(void(*)(void))_wrap_ParMult, METH_VARARGS|METH_KEYWORDS, "ParMult(HypreParMatrix A, HypreParMatrix B, bool own_matrix=False) -> HypreParMatrix"}, + { "ParAdd", (PyCFunction)(void(*)(void))_wrap_ParAdd, METH_VARARGS|METH_KEYWORDS, "ParAdd(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix"}, + { "EliminateBC", (PyCFunction)(void(*)(void))_wrap_EliminateBC, METH_VARARGS|METH_KEYWORDS, "EliminateBC(HypreParMatrix A, HypreParMatrix Ae, intArray ess_dof_list, Vector X, Vector B)"}, { "new_HypreSmoother", _wrap_new_HypreSmoother, METH_VARARGS, "\n" "HypreSmoother()\n" - "HypreSmoother(HypreParMatrix _A, int type=l1GS, int relax_times=1, double relax_weight=1.0, double omega=1.0, int poly_order=2, double poly_fraction=.3)\n" + "new_HypreSmoother(HypreParMatrix _A, int type=l1GS, int relax_times=1, double relax_weight=1.0, double omega=1.0, int poly_order=2, double poly_fraction=.3) -> HypreSmoother\n" ""}, - { "HypreSmoother_SetType", _wrap_HypreSmoother_SetType, METH_VARARGS, "HypreSmoother_SetType(HypreSmoother self, mfem::HypreSmoother::Type type, int relax_times=1)"}, - { "HypreSmoother_SetSOROptions", _wrap_HypreSmoother_SetSOROptions, METH_VARARGS, "HypreSmoother_SetSOROptions(HypreSmoother self, double relax_weight, double omega)"}, - { "HypreSmoother_SetPolyOptions", _wrap_HypreSmoother_SetPolyOptions, METH_VARARGS, "HypreSmoother_SetPolyOptions(HypreSmoother self, int poly_order, double poly_fraction)"}, - { "HypreSmoother_SetTaubinOptions", _wrap_HypreSmoother_SetTaubinOptions, METH_VARARGS, "HypreSmoother_SetTaubinOptions(HypreSmoother self, double _lambda, double mu, int iter)"}, - { "HypreSmoother_SetWindowByName", _wrap_HypreSmoother_SetWindowByName, METH_VARARGS, "HypreSmoother_SetWindowByName(HypreSmoother self, char const * window_name)"}, - { "HypreSmoother_SetWindowParameters", _wrap_HypreSmoother_SetWindowParameters, METH_VARARGS, "HypreSmoother_SetWindowParameters(HypreSmoother self, double a, double b, double c)"}, - { "HypreSmoother_SetFIRCoefficients", _wrap_HypreSmoother_SetFIRCoefficients, METH_VARARGS, "HypreSmoother_SetFIRCoefficients(HypreSmoother self, double max_eig)"}, - { "HypreSmoother_SetPositiveDiagonal", _wrap_HypreSmoother_SetPositiveDiagonal, METH_VARARGS, "HypreSmoother_SetPositiveDiagonal(HypreSmoother self, bool pos=True)"}, - { "HypreSmoother_SetOperator", _wrap_HypreSmoother_SetOperator, METH_VARARGS, "HypreSmoother_SetOperator(HypreSmoother self, Operator op)"}, + { "HypreSmoother_SetType", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetType, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetType(HypreSmoother self, mfem::HypreSmoother::Type type, int relax_times=1)"}, + { "HypreSmoother_SetSOROptions", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetSOROptions, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetSOROptions(HypreSmoother self, double relax_weight, double omega)"}, + { "HypreSmoother_SetPolyOptions", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetPolyOptions, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetPolyOptions(HypreSmoother self, int poly_order, double poly_fraction)"}, + { "HypreSmoother_SetTaubinOptions", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetTaubinOptions, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetTaubinOptions(HypreSmoother self, double _lambda, double mu, int iter)"}, + { "HypreSmoother_SetWindowByName", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetWindowByName, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetWindowByName(HypreSmoother self, char const * window_name)"}, + { "HypreSmoother_SetWindowParameters", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetWindowParameters, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetWindowParameters(HypreSmoother self, double a, double b, double c)"}, + { "HypreSmoother_SetFIRCoefficients", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetFIRCoefficients, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetFIRCoefficients(HypreSmoother self, double max_eig)"}, + { "HypreSmoother_SetPositiveDiagonal", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetPositiveDiagonal, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetPositiveDiagonal(HypreSmoother self, bool pos=True)"}, + { "HypreSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreSmoother_SetOperator(HypreSmoother self, Operator op)"}, { "HypreSmoother_Mult", _wrap_HypreSmoother_Mult, METH_VARARGS, "\n" "HypreSmoother_Mult(HypreSmoother self, HypreParVector b, HypreParVector x)\n" "HypreSmoother_Mult(HypreSmoother self, Vector b, Vector x)\n" @@ -18029,27 +16248,27 @@ static PyMethodDef SwigMethods[] = { { "HypreSmoother_swiginit", HypreSmoother_swiginit, METH_VARARGS, NULL}, { "HypreSolver_SetupFcn", _wrap_HypreSolver_SetupFcn, METH_O, "HypreSolver_SetupFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn"}, { "HypreSolver_SolveFcn", _wrap_HypreSolver_SolveFcn, METH_O, "HypreSolver_SolveFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn"}, - { "HypreSolver_SetOperator", _wrap_HypreSolver_SetOperator, METH_VARARGS, "HypreSolver_SetOperator(HypreSolver self, Operator op)"}, + { "HypreSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreSolver_SetOperator(HypreSolver self, Operator op)"}, { "HypreSolver_Mult", _wrap_HypreSolver_Mult, METH_VARARGS, "\n" "HypreSolver_Mult(HypreSolver self, HypreParVector b, HypreParVector x)\n" "HypreSolver_Mult(HypreSolver self, Vector b, Vector x)\n" ""}, - { "HypreSolver_SetErrorMode", _wrap_HypreSolver_SetErrorMode, METH_VARARGS, "HypreSolver_SetErrorMode(HypreSolver self, mfem::HypreSolver::ErrorMode err_mode)"}, + { "HypreSolver_SetErrorMode", (PyCFunction)(void(*)(void))_wrap_HypreSolver_SetErrorMode, METH_VARARGS|METH_KEYWORDS, "HypreSolver_SetErrorMode(HypreSolver self, mfem::HypreSolver::ErrorMode err_mode)"}, { "delete_HypreSolver", _wrap_delete_HypreSolver, METH_O, "delete_HypreSolver(HypreSolver self)"}, { "HypreSolver_swigregister", HypreSolver_swigregister, METH_O, NULL}, { "new_HyprePCG", _wrap_new_HyprePCG, METH_VARARGS, "\n" "HyprePCG(MPI_Comm comm)\n" "new_HyprePCG(HypreParMatrix _A) -> HyprePCG\n" ""}, - { "HyprePCG_SetOperator", _wrap_HyprePCG_SetOperator, METH_VARARGS, "HyprePCG_SetOperator(HyprePCG self, Operator op)"}, - { "HyprePCG_SetTol", _wrap_HyprePCG_SetTol, METH_VARARGS, "HyprePCG_SetTol(HyprePCG self, double tol)"}, - { "HyprePCG_SetMaxIter", _wrap_HyprePCG_SetMaxIter, METH_VARARGS, "HyprePCG_SetMaxIter(HyprePCG self, int max_iter)"}, - { "HyprePCG_SetLogging", _wrap_HyprePCG_SetLogging, METH_VARARGS, "HyprePCG_SetLogging(HyprePCG self, int logging)"}, - { "HyprePCG_SetPrintLevel", _wrap_HyprePCG_SetPrintLevel, METH_VARARGS, "HyprePCG_SetPrintLevel(HyprePCG self, int print_lvl)"}, - { "HyprePCG_SetPreconditioner", _wrap_HyprePCG_SetPreconditioner, METH_VARARGS, "HyprePCG_SetPreconditioner(HyprePCG self, HypreSolver precond)"}, - { "HyprePCG_SetResidualConvergenceOptions", _wrap_HyprePCG_SetResidualConvergenceOptions, METH_VARARGS, "HyprePCG_SetResidualConvergenceOptions(HyprePCG self, int res_frequency=-1, double rtol=0.0)"}, + { "HyprePCG_SetOperator", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetOperator, METH_VARARGS|METH_KEYWORDS, "HyprePCG_SetOperator(HyprePCG self, Operator op)"}, + { "HyprePCG_SetTol", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetTol, METH_VARARGS|METH_KEYWORDS, "HyprePCG_SetTol(HyprePCG self, double tol)"}, + { "HyprePCG_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "HyprePCG_SetMaxIter(HyprePCG self, int max_iter)"}, + { "HyprePCG_SetLogging", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetLogging, METH_VARARGS|METH_KEYWORDS, "HyprePCG_SetLogging(HyprePCG self, int logging)"}, + { "HyprePCG_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "HyprePCG_SetPrintLevel(HyprePCG self, int print_lvl)"}, + { "HyprePCG_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "HyprePCG_SetPreconditioner(HyprePCG self, HypreSolver precond)"}, + { "HyprePCG_SetResidualConvergenceOptions", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetResidualConvergenceOptions, METH_VARARGS|METH_KEYWORDS, "HyprePCG_SetResidualConvergenceOptions(HyprePCG self, int res_frequency=-1, double rtol=0.0)"}, { "HyprePCG_SetZeroInintialIterate", _wrap_HyprePCG_SetZeroInintialIterate, METH_O, "HyprePCG_SetZeroInintialIterate(HyprePCG self)"}, - { "HyprePCG_GetNumIterations", _wrap_HyprePCG_GetNumIterations, METH_VARARGS, "HyprePCG_GetNumIterations(HyprePCG self, int & num_iterations)"}, + { "HyprePCG_GetNumIterations", (PyCFunction)(void(*)(void))_wrap_HyprePCG_GetNumIterations, METH_VARARGS|METH_KEYWORDS, "HyprePCG_GetNumIterations(HyprePCG self, int & num_iterations)"}, { "HyprePCG_SetupFcn", _wrap_HyprePCG_SetupFcn, METH_O, "HyprePCG_SetupFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn"}, { "HyprePCG_SolveFcn", _wrap_HyprePCG_SolveFcn, METH_O, "HyprePCG_SolveFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn"}, { "HyprePCG_Mult", _wrap_HyprePCG_Mult, METH_VARARGS, "\n" @@ -18063,13 +16282,13 @@ static PyMethodDef SwigMethods[] = { "HypreGMRES(MPI_Comm comm)\n" "new_HypreGMRES(HypreParMatrix _A) -> HypreGMRES\n" ""}, - { "HypreGMRES_SetOperator", _wrap_HypreGMRES_SetOperator, METH_VARARGS, "HypreGMRES_SetOperator(HypreGMRES self, Operator op)"}, - { "HypreGMRES_SetTol", _wrap_HypreGMRES_SetTol, METH_VARARGS, "HypreGMRES_SetTol(HypreGMRES self, double tol)"}, - { "HypreGMRES_SetMaxIter", _wrap_HypreGMRES_SetMaxIter, METH_VARARGS, "HypreGMRES_SetMaxIter(HypreGMRES self, int max_iter)"}, - { "HypreGMRES_SetKDim", _wrap_HypreGMRES_SetKDim, METH_VARARGS, "HypreGMRES_SetKDim(HypreGMRES self, int dim)"}, - { "HypreGMRES_SetLogging", _wrap_HypreGMRES_SetLogging, METH_VARARGS, "HypreGMRES_SetLogging(HypreGMRES self, int logging)"}, - { "HypreGMRES_SetPrintLevel", _wrap_HypreGMRES_SetPrintLevel, METH_VARARGS, "HypreGMRES_SetPrintLevel(HypreGMRES self, int print_lvl)"}, - { "HypreGMRES_SetPreconditioner", _wrap_HypreGMRES_SetPreconditioner, METH_VARARGS, "HypreGMRES_SetPreconditioner(HypreGMRES self, HypreSolver precond)"}, + { "HypreGMRES_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreGMRES_SetOperator(HypreGMRES self, Operator op)"}, + { "HypreGMRES_SetTol", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetTol, METH_VARARGS|METH_KEYWORDS, "HypreGMRES_SetTol(HypreGMRES self, double tol)"}, + { "HypreGMRES_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "HypreGMRES_SetMaxIter(HypreGMRES self, int max_iter)"}, + { "HypreGMRES_SetKDim", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetKDim, METH_VARARGS|METH_KEYWORDS, "HypreGMRES_SetKDim(HypreGMRES self, int dim)"}, + { "HypreGMRES_SetLogging", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetLogging, METH_VARARGS|METH_KEYWORDS, "HypreGMRES_SetLogging(HypreGMRES self, int logging)"}, + { "HypreGMRES_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "HypreGMRES_SetPrintLevel(HypreGMRES self, int print_lvl)"}, + { "HypreGMRES_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "HypreGMRES_SetPreconditioner(HypreGMRES self, HypreSolver precond)"}, { "HypreGMRES_SetZeroInintialIterate", _wrap_HypreGMRES_SetZeroInintialIterate, METH_O, "HypreGMRES_SetZeroInintialIterate(HypreGMRES self)"}, { "HypreGMRES_SetupFcn", _wrap_HypreGMRES_SetupFcn, METH_O, "HypreGMRES_SetupFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn"}, { "HypreGMRES_SolveFcn", _wrap_HypreGMRES_SolveFcn, METH_O, "HypreGMRES_SolveFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn"}, @@ -18090,7 +16309,7 @@ static PyMethodDef SwigMethods[] = { "HypreDiagScale()\n" "new_HypreDiagScale(HypreParMatrix A) -> HypreDiagScale\n" ""}, - { "HypreDiagScale_SetOperator", _wrap_HypreDiagScale_SetOperator, METH_VARARGS, "HypreDiagScale_SetOperator(HypreDiagScale self, Operator op)"}, + { "HypreDiagScale_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreDiagScale_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreDiagScale_SetOperator(HypreDiagScale self, Operator op)"}, { "HypreDiagScale_SetupFcn", _wrap_HypreDiagScale_SetupFcn, METH_O, "HypreDiagScale_SetupFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, { "HypreDiagScale_SolveFcn", _wrap_HypreDiagScale_SolveFcn, METH_O, "HypreDiagScale_SolveFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, { "HypreDiagScale_GetData", _wrap_HypreDiagScale_GetData, METH_O, "HypreDiagScale_GetData(HypreDiagScale self) -> HypreParMatrix"}, @@ -18101,8 +16320,8 @@ static PyMethodDef SwigMethods[] = { "HypreParaSails(MPI_Comm comm)\n" "new_HypreParaSails(HypreParMatrix A) -> HypreParaSails\n" ""}, - { "HypreParaSails_SetOperator", _wrap_HypreParaSails_SetOperator, METH_VARARGS, "HypreParaSails_SetOperator(HypreParaSails self, Operator op)"}, - { "HypreParaSails_SetSymmetry", _wrap_HypreParaSails_SetSymmetry, METH_VARARGS, "HypreParaSails_SetSymmetry(HypreParaSails self, int sym)"}, + { "HypreParaSails_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreParaSails_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreParaSails_SetOperator(HypreParaSails self, Operator op)"}, + { "HypreParaSails_SetSymmetry", (PyCFunction)(void(*)(void))_wrap_HypreParaSails_SetSymmetry, METH_VARARGS|METH_KEYWORDS, "HypreParaSails_SetSymmetry(HypreParaSails self, int sym)"}, { "HypreParaSails_SetupFcn", _wrap_HypreParaSails_SetupFcn, METH_O, "HypreParaSails_SetupFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, { "HypreParaSails_SolveFcn", _wrap_HypreParaSails_SolveFcn, METH_O, "HypreParaSails_SolveFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreParaSails", _wrap_delete_HypreParaSails, METH_O, "delete_HypreParaSails(HypreParaSails self)"}, @@ -18112,7 +16331,7 @@ static PyMethodDef SwigMethods[] = { "HypreEuclid(MPI_Comm comm)\n" "new_HypreEuclid(HypreParMatrix A) -> HypreEuclid\n" ""}, - { "HypreEuclid_SetOperator", _wrap_HypreEuclid_SetOperator, METH_VARARGS, "HypreEuclid_SetOperator(HypreEuclid self, Operator op)"}, + { "HypreEuclid_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreEuclid_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreEuclid_SetOperator(HypreEuclid self, Operator op)"}, { "HypreEuclid_SetupFcn", _wrap_HypreEuclid_SetupFcn, METH_O, "HypreEuclid_SetupFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, { "HypreEuclid_SolveFcn", _wrap_HypreEuclid_SolveFcn, METH_O, "HypreEuclid_SolveFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreEuclid", _wrap_delete_HypreEuclid, METH_O, "delete_HypreEuclid(HypreEuclid self)"}, @@ -18122,10 +16341,10 @@ static PyMethodDef SwigMethods[] = { "HypreBoomerAMG()\n" "new_HypreBoomerAMG(HypreParMatrix A) -> HypreBoomerAMG\n" ""}, - { "HypreBoomerAMG_SetOperator", _wrap_HypreBoomerAMG_SetOperator, METH_VARARGS, "HypreBoomerAMG_SetOperator(HypreBoomerAMG self, Operator op)"}, - { "HypreBoomerAMG_SetSystemsOptions", _wrap_HypreBoomerAMG_SetSystemsOptions, METH_VARARGS, "HypreBoomerAMG_SetSystemsOptions(HypreBoomerAMG self, int dim)"}, - { "HypreBoomerAMG_SetElasticityOptions", _wrap_HypreBoomerAMG_SetElasticityOptions, METH_VARARGS, "HypreBoomerAMG_SetElasticityOptions(HypreBoomerAMG self, mfem::ParFiniteElementSpace * fespace)"}, - { "HypreBoomerAMG_SetPrintLevel", _wrap_HypreBoomerAMG_SetPrintLevel, METH_VARARGS, "HypreBoomerAMG_SetPrintLevel(HypreBoomerAMG self, int print_level)"}, + { "HypreBoomerAMG_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreBoomerAMG_SetOperator(HypreBoomerAMG self, Operator op)"}, + { "HypreBoomerAMG_SetSystemsOptions", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetSystemsOptions, METH_VARARGS|METH_KEYWORDS, "HypreBoomerAMG_SetSystemsOptions(HypreBoomerAMG self, int dim)"}, + { "HypreBoomerAMG_SetElasticityOptions", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetElasticityOptions, METH_VARARGS|METH_KEYWORDS, "HypreBoomerAMG_SetElasticityOptions(HypreBoomerAMG self, mfem::ParFiniteElementSpace * fespace)"}, + { "HypreBoomerAMG_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "HypreBoomerAMG_SetPrintLevel(HypreBoomerAMG self, int print_level)"}, { "HypreBoomerAMG_SetupFcn", _wrap_HypreBoomerAMG_SetupFcn, METH_O, "HypreBoomerAMG_SetupFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn"}, { "HypreBoomerAMG_SolveFcn", _wrap_HypreBoomerAMG_SolveFcn, METH_O, "HypreBoomerAMG_SolveFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreBoomerAMG", _wrap_delete_HypreBoomerAMG, METH_O, "delete_HypreBoomerAMG(HypreBoomerAMG self)"}, @@ -18135,8 +16354,8 @@ static PyMethodDef SwigMethods[] = { "HypreAMS(mfem::ParFiniteElementSpace * edge_fespace)\n" "new_HypreAMS(HypreParMatrix A, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS\n" ""}, - { "HypreAMS_SetOperator", _wrap_HypreAMS_SetOperator, METH_VARARGS, "HypreAMS_SetOperator(HypreAMS self, Operator op)"}, - { "HypreAMS_SetPrintLevel", _wrap_HypreAMS_SetPrintLevel, METH_VARARGS, "HypreAMS_SetPrintLevel(HypreAMS self, int print_lvl)"}, + { "HypreAMS_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreAMS_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreAMS_SetOperator(HypreAMS self, Operator op)"}, + { "HypreAMS_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreAMS_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "HypreAMS_SetPrintLevel(HypreAMS self, int print_lvl)"}, { "HypreAMS_SetSingularProblem", _wrap_HypreAMS_SetSingularProblem, METH_O, "HypreAMS_SetSingularProblem(HypreAMS self)"}, { "HypreAMS_SetupFcn", _wrap_HypreAMS_SetupFcn, METH_O, "HypreAMS_SetupFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn"}, { "HypreAMS_SolveFcn", _wrap_HypreAMS_SolveFcn, METH_O, "HypreAMS_SolveFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn"}, @@ -18147,46 +16366,46 @@ static PyMethodDef SwigMethods[] = { "HypreADS(mfem::ParFiniteElementSpace * face_fespace)\n" "new_HypreADS(HypreParMatrix A, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS\n" ""}, - { "HypreADS_SetOperator", _wrap_HypreADS_SetOperator, METH_VARARGS, "HypreADS_SetOperator(HypreADS self, Operator op)"}, - { "HypreADS_SetPrintLevel", _wrap_HypreADS_SetPrintLevel, METH_VARARGS, "HypreADS_SetPrintLevel(HypreADS self, int print_lvl)"}, + { "HypreADS_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreADS_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreADS_SetOperator(HypreADS self, Operator op)"}, + { "HypreADS_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreADS_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "HypreADS_SetPrintLevel(HypreADS self, int print_lvl)"}, { "HypreADS_SetupFcn", _wrap_HypreADS_SetupFcn, METH_O, "HypreADS_SetupFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, { "HypreADS_SolveFcn", _wrap_HypreADS_SolveFcn, METH_O, "HypreADS_SolveFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreADS", _wrap_delete_HypreADS, METH_O, "delete_HypreADS(HypreADS self)"}, { "HypreADS_swigregister", HypreADS_swigregister, METH_O, NULL}, { "HypreADS_swiginit", HypreADS_swiginit, METH_VARARGS, NULL}, - { "new_HypreLOBPCG", _wrap_new_HypreLOBPCG, METH_O, "new_HypreLOBPCG(MPI_Comm comm) -> HypreLOBPCG"}, + { "new_HypreLOBPCG", (PyCFunction)(void(*)(void))_wrap_new_HypreLOBPCG, METH_VARARGS|METH_KEYWORDS, "new_HypreLOBPCG(MPI_Comm comm) -> HypreLOBPCG"}, { "delete_HypreLOBPCG", _wrap_delete_HypreLOBPCG, METH_O, "delete_HypreLOBPCG(HypreLOBPCG self)"}, - { "HypreLOBPCG_SetTol", _wrap_HypreLOBPCG_SetTol, METH_VARARGS, "HypreLOBPCG_SetTol(HypreLOBPCG self, double tol)"}, - { "HypreLOBPCG_SetRelTol", _wrap_HypreLOBPCG_SetRelTol, METH_VARARGS, "HypreLOBPCG_SetRelTol(HypreLOBPCG self, double rel_tol)"}, - { "HypreLOBPCG_SetMaxIter", _wrap_HypreLOBPCG_SetMaxIter, METH_VARARGS, "HypreLOBPCG_SetMaxIter(HypreLOBPCG self, int max_iter)"}, - { "HypreLOBPCG_SetPrintLevel", _wrap_HypreLOBPCG_SetPrintLevel, METH_VARARGS, "HypreLOBPCG_SetPrintLevel(HypreLOBPCG self, int logging)"}, - { "HypreLOBPCG_SetNumModes", _wrap_HypreLOBPCG_SetNumModes, METH_VARARGS, "HypreLOBPCG_SetNumModes(HypreLOBPCG self, int num_eigs)"}, - { "HypreLOBPCG_SetPrecondUsageMode", _wrap_HypreLOBPCG_SetPrecondUsageMode, METH_VARARGS, "HypreLOBPCG_SetPrecondUsageMode(HypreLOBPCG self, int pcg_mode)"}, - { "HypreLOBPCG_SetRandomSeed", _wrap_HypreLOBPCG_SetRandomSeed, METH_VARARGS, "HypreLOBPCG_SetRandomSeed(HypreLOBPCG self, int s)"}, - { "HypreLOBPCG_SetInitialVectors", _wrap_HypreLOBPCG_SetInitialVectors, METH_VARARGS, "HypreLOBPCG_SetInitialVectors(HypreLOBPCG self, int num_vecs, mfem::HypreParVector ** vecs)"}, - { "HypreLOBPCG_SetPreconditioner", _wrap_HypreLOBPCG_SetPreconditioner, METH_VARARGS, "HypreLOBPCG_SetPreconditioner(HypreLOBPCG self, Solver precond)"}, - { "HypreLOBPCG_SetOperator", _wrap_HypreLOBPCG_SetOperator, METH_VARARGS, "HypreLOBPCG_SetOperator(HypreLOBPCG self, Operator A)"}, - { "HypreLOBPCG_SetMassMatrix", _wrap_HypreLOBPCG_SetMassMatrix, METH_VARARGS, "HypreLOBPCG_SetMassMatrix(HypreLOBPCG self, Operator M)"}, - { "HypreLOBPCG_SetSubSpaceProjector", _wrap_HypreLOBPCG_SetSubSpaceProjector, METH_VARARGS, "HypreLOBPCG_SetSubSpaceProjector(HypreLOBPCG self, Operator proj)"}, + { "HypreLOBPCG_SetTol", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetTol, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetTol(HypreLOBPCG self, double tol)"}, + { "HypreLOBPCG_SetRelTol", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetRelTol, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetRelTol(HypreLOBPCG self, double rel_tol)"}, + { "HypreLOBPCG_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetMaxIter(HypreLOBPCG self, int max_iter)"}, + { "HypreLOBPCG_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetPrintLevel(HypreLOBPCG self, int logging)"}, + { "HypreLOBPCG_SetNumModes", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetNumModes, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetNumModes(HypreLOBPCG self, int num_eigs)"}, + { "HypreLOBPCG_SetPrecondUsageMode", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetPrecondUsageMode, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetPrecondUsageMode(HypreLOBPCG self, int pcg_mode)"}, + { "HypreLOBPCG_SetRandomSeed", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetRandomSeed, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetRandomSeed(HypreLOBPCG self, int s)"}, + { "HypreLOBPCG_SetInitialVectors", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetInitialVectors, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetInitialVectors(HypreLOBPCG self, int num_vecs, mfem::HypreParVector ** vecs)"}, + { "HypreLOBPCG_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetPreconditioner(HypreLOBPCG self, Solver precond)"}, + { "HypreLOBPCG_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetOperator(HypreLOBPCG self, Operator A)"}, + { "HypreLOBPCG_SetMassMatrix", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetMassMatrix, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetMassMatrix(HypreLOBPCG self, Operator M)"}, + { "HypreLOBPCG_SetSubSpaceProjector", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetSubSpaceProjector, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_SetSubSpaceProjector(HypreLOBPCG self, Operator proj)"}, { "HypreLOBPCG_Solve", _wrap_HypreLOBPCG_Solve, METH_O, "HypreLOBPCG_Solve(HypreLOBPCG self)"}, - { "HypreLOBPCG_GetEigenvalues", _wrap_HypreLOBPCG_GetEigenvalues, METH_VARARGS, "HypreLOBPCG_GetEigenvalues(HypreLOBPCG self, doubleArray eigenvalues)"}, - { "HypreLOBPCG_GetEigenvector", _wrap_HypreLOBPCG_GetEigenvector, METH_VARARGS, "HypreLOBPCG_GetEigenvector(HypreLOBPCG self, unsigned int i) -> HypreParVector"}, + { "HypreLOBPCG_GetEigenvalues", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_GetEigenvalues, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_GetEigenvalues(HypreLOBPCG self, doubleArray eigenvalues)"}, + { "HypreLOBPCG_GetEigenvector", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_GetEigenvector, METH_VARARGS|METH_KEYWORDS, "HypreLOBPCG_GetEigenvector(HypreLOBPCG self, unsigned int i) -> HypreParVector"}, { "HypreLOBPCG_StealEigenvectors", _wrap_HypreLOBPCG_StealEigenvectors, METH_O, "HypreLOBPCG_StealEigenvectors(HypreLOBPCG self) -> mfem::HypreParVector **"}, { "HypreLOBPCG_swigregister", HypreLOBPCG_swigregister, METH_O, NULL}, { "HypreLOBPCG_swiginit", HypreLOBPCG_swiginit, METH_VARARGS, NULL}, - { "new_HypreAME", _wrap_new_HypreAME, METH_O, "new_HypreAME(MPI_Comm comm) -> HypreAME"}, + { "new_HypreAME", (PyCFunction)(void(*)(void))_wrap_new_HypreAME, METH_VARARGS|METH_KEYWORDS, "new_HypreAME(MPI_Comm comm) -> HypreAME"}, { "delete_HypreAME", _wrap_delete_HypreAME, METH_O, "delete_HypreAME(HypreAME self)"}, - { "HypreAME_SetTol", _wrap_HypreAME_SetTol, METH_VARARGS, "HypreAME_SetTol(HypreAME self, double tol)"}, - { "HypreAME_SetRelTol", _wrap_HypreAME_SetRelTol, METH_VARARGS, "HypreAME_SetRelTol(HypreAME self, double rel_tol)"}, - { "HypreAME_SetMaxIter", _wrap_HypreAME_SetMaxIter, METH_VARARGS, "HypreAME_SetMaxIter(HypreAME self, int max_iter)"}, - { "HypreAME_SetPrintLevel", _wrap_HypreAME_SetPrintLevel, METH_VARARGS, "HypreAME_SetPrintLevel(HypreAME self, int logging)"}, - { "HypreAME_SetNumModes", _wrap_HypreAME_SetNumModes, METH_VARARGS, "HypreAME_SetNumModes(HypreAME self, int num_eigs)"}, - { "HypreAME_SetPreconditioner", _wrap_HypreAME_SetPreconditioner, METH_VARARGS, "HypreAME_SetPreconditioner(HypreAME self, HypreSolver precond)"}, - { "HypreAME_SetOperator", _wrap_HypreAME_SetOperator, METH_VARARGS, "HypreAME_SetOperator(HypreAME self, HypreParMatrix A)"}, - { "HypreAME_SetMassMatrix", _wrap_HypreAME_SetMassMatrix, METH_VARARGS, "HypreAME_SetMassMatrix(HypreAME self, HypreParMatrix M)"}, + { "HypreAME_SetTol", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetTol, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetTol(HypreAME self, double tol)"}, + { "HypreAME_SetRelTol", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetRelTol, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetRelTol(HypreAME self, double rel_tol)"}, + { "HypreAME_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetMaxIter(HypreAME self, int max_iter)"}, + { "HypreAME_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetPrintLevel(HypreAME self, int logging)"}, + { "HypreAME_SetNumModes", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetNumModes, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetNumModes(HypreAME self, int num_eigs)"}, + { "HypreAME_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetPreconditioner(HypreAME self, HypreSolver precond)"}, + { "HypreAME_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetOperator, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetOperator(HypreAME self, HypreParMatrix A)"}, + { "HypreAME_SetMassMatrix", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetMassMatrix, METH_VARARGS|METH_KEYWORDS, "HypreAME_SetMassMatrix(HypreAME self, HypreParMatrix M)"}, { "HypreAME_Solve", _wrap_HypreAME_Solve, METH_O, "HypreAME_Solve(HypreAME self)"}, - { "HypreAME_GetEigenvalues", _wrap_HypreAME_GetEigenvalues, METH_VARARGS, "HypreAME_GetEigenvalues(HypreAME self, doubleArray eigenvalues)"}, - { "HypreAME_GetEigenvector", _wrap_HypreAME_GetEigenvector, METH_VARARGS, "HypreAME_GetEigenvector(HypreAME self, unsigned int i) -> HypreParVector"}, + { "HypreAME_GetEigenvalues", (PyCFunction)(void(*)(void))_wrap_HypreAME_GetEigenvalues, METH_VARARGS|METH_KEYWORDS, "HypreAME_GetEigenvalues(HypreAME self, doubleArray eigenvalues)"}, + { "HypreAME_GetEigenvector", (PyCFunction)(void(*)(void))_wrap_HypreAME_GetEigenvector, METH_VARARGS|METH_KEYWORDS, "HypreAME_GetEigenvector(HypreAME self, unsigned int i) -> HypreParVector"}, { "HypreAME_StealEigenvectors", _wrap_HypreAME_StealEigenvectors, METH_O, "HypreAME_StealEigenvectors(HypreAME self) -> mfem::HypreParVector **"}, { "HypreAME_swigregister", HypreAME_swigregister, METH_O, NULL}, { "HypreAME_swiginit", HypreAME_swiginit, METH_VARARGS, NULL}, @@ -18209,17 +16428,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "HypreParVector_Partitioning", _wrap_HypreParVector_Partitioning, METH_O, "Partitioning(HypreParVector self) -> HYPRE_Int *"}, { "HypreParVector_GlobalSize", _wrap_HypreParVector_GlobalSize, METH_O, "GlobalSize(HypreParVector self) -> HYPRE_Int"}, { "HypreParVector_StealParVector", _wrap_HypreParVector_StealParVector, METH_O, "StealParVector(HypreParVector self) -> hypre_ParVector *"}, - { "HypreParVector_SetOwnership", _wrap_HypreParVector_SetOwnership, METH_VARARGS, "SetOwnership(HypreParVector self, int own)"}, + { "HypreParVector_SetOwnership", (PyCFunction)(void(*)(void))_wrap_HypreParVector_SetOwnership, METH_VARARGS|METH_KEYWORDS, "SetOwnership(HypreParVector self, int own)"}, { "HypreParVector_GetOwnership", _wrap_HypreParVector_GetOwnership, METH_O, "GetOwnership(HypreParVector self) -> int"}, { "HypreParVector_GlobalVector", _wrap_HypreParVector_GlobalVector, METH_O, "GlobalVector(HypreParVector self) -> Vector"}, - { "HypreParVector_SetData", _wrap_HypreParVector_SetData, METH_VARARGS, "SetData(HypreParVector self, double * _data)"}, - { "HypreParVector_Randomize", _wrap_HypreParVector_Randomize, METH_VARARGS, "Randomize(HypreParVector self, HYPRE_Int seed) -> HYPRE_Int"}, - { "HypreParVector_Print", _wrap_HypreParVector_Print, METH_VARARGS, "Print(HypreParVector self, char const * fname)"}, + { "HypreParVector_SetData", (PyCFunction)(void(*)(void))_wrap_HypreParVector_SetData, METH_VARARGS|METH_KEYWORDS, "SetData(HypreParVector self, double * _data)"}, + { "HypreParVector_Randomize", (PyCFunction)(void(*)(void))_wrap_HypreParVector_Randomize, METH_VARARGS|METH_KEYWORDS, "Randomize(HypreParVector self, HYPRE_Int seed) -> HYPRE_Int"}, + { "HypreParVector_Print", (PyCFunction)(void(*)(void))_wrap_HypreParVector_Print, METH_VARARGS|METH_KEYWORDS, "Print(HypreParVector self, char const * fname)"}, { "delete_HypreParVector", _wrap_delete_HypreParVector, METH_O, "delete_HypreParVector(HypreParVector self)"}, { "HypreParVector_GetPartitioningArray", _wrap_HypreParVector_GetPartitioningArray, METH_O, "GetPartitioningArray(HypreParVector self) -> PyObject *"}, { "HypreParVector_swigregister", HypreParVector_swigregister, METH_O, NULL}, { "HypreParVector_swiginit", HypreParVector_swiginit, METH_VARARGS, NULL}, - { "ParNormlp", _wrap_ParNormlp, METH_VARARGS, "ParNormlp(Vector vec, double p, MPI_Comm comm) -> double"}, + { "ParNormlp", (PyCFunction)(void(*)(void))_wrap_ParNormlp, METH_VARARGS|METH_KEYWORDS, "ParNormlp(Vector vec, double p, MPI_Comm comm) -> double"}, { "new_HypreParMatrix", _wrap_new_HypreParMatrix, METH_VARARGS, "\n" "HypreParMatrix()\n" "HypreParMatrix(hypre_ParCSRMatrix * a, bool owner=True)\n" @@ -18233,10 +16452,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreParMatrix(MPI_Comm comm, int nrows, HYPRE_Int glob_nrows, HYPRE_Int glob_ncols, int * I)\n" "new_HypreParMatrix(HypreParMatrix P) -> HypreParMatrix\n" ""}, - { "HypreParMatrix_MakeRef", _wrap_HypreParMatrix_MakeRef, METH_VARARGS, "MakeRef(HypreParMatrix self, HypreParMatrix master)"}, + { "HypreParMatrix_MakeRef", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_MakeRef, METH_VARARGS|METH_KEYWORDS, "MakeRef(HypreParMatrix self, HypreParMatrix master)"}, { "HypreParMatrix_GetComm", _wrap_HypreParMatrix_GetComm, METH_O, "GetComm(HypreParMatrix self) -> MPI_Comm"}, { "HypreParMatrix_StealData", _wrap_HypreParMatrix_StealData, METH_O, "StealData(HypreParMatrix self) -> hypre_ParCSRMatrix *"}, - { "HypreParMatrix_SetOwnerFlags", _wrap_HypreParMatrix_SetOwnerFlags, METH_VARARGS, "SetOwnerFlags(HypreParMatrix self, signed char diag, signed char offd, signed char colmap)"}, + { "HypreParMatrix_SetOwnerFlags", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_SetOwnerFlags, METH_VARARGS|METH_KEYWORDS, "SetOwnerFlags(HypreParMatrix self, signed char diag, signed char offd, signed char colmap)"}, { "HypreParMatrix_OwnsDiag", _wrap_HypreParMatrix_OwnsDiag, METH_O, "OwnsDiag(HypreParMatrix self) -> signed char"}, { "HypreParMatrix_OwnsOffd", _wrap_HypreParMatrix_OwnsOffd, METH_O, "OwnsOffd(HypreParMatrix self) -> signed char"}, { "HypreParMatrix_OwnsColMap", _wrap_HypreParMatrix_OwnsColMap, METH_O, "OwnsColMap(HypreParMatrix self) -> signed char"}, @@ -18257,8 +16476,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetDiag(HypreParMatrix self, Vector diag)\n" "GetDiag(HypreParMatrix self, SparseMatrix diag)\n" ""}, - { "HypreParMatrix_GetOffd", _wrap_HypreParMatrix_GetOffd, METH_VARARGS, "GetOffd(HypreParMatrix self, SparseMatrix offd, HYPRE_Int *& cmap)"}, - { "HypreParMatrix_GetBlocks", _wrap_HypreParMatrix_GetBlocks, METH_VARARGS, "GetBlocks(HypreParMatrix self, mfem::Array2D< mfem::HypreParMatrix * > & blocks, bool interleaved_rows=False, bool interleaved_cols=False)"}, + { "HypreParMatrix_GetOffd", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_GetOffd, METH_VARARGS|METH_KEYWORDS, "GetOffd(HypreParMatrix self, SparseMatrix offd, HYPRE_Int *& cmap)"}, + { "HypreParMatrix_GetBlocks", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_GetBlocks, METH_VARARGS|METH_KEYWORDS, "GetBlocks(HypreParMatrix self, mfem::Array2D< mfem::HypreParMatrix * > & blocks, bool interleaved_rows=False, bool interleaved_cols=False)"}, { "HypreParMatrix_Transpose", _wrap_HypreParMatrix_Transpose, METH_O, "Transpose(HypreParMatrix self) -> HypreParMatrix"}, { "HypreParMatrix_GetNumRows", _wrap_HypreParMatrix_GetNumRows, METH_O, "GetNumRows(HypreParMatrix self) -> int"}, { "HypreParMatrix_GetNumCols", _wrap_HypreParMatrix_GetNumCols, METH_O, "GetNumCols(HypreParMatrix self) -> int"}, @@ -18277,54 +16496,54 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MultTranspose(HypreParMatrix self, double a, Vector x, double b, Vector y)\n" "MultTranspose(HypreParMatrix self, Vector x, Vector y)\n" ""}, - { "HypreParMatrix_BooleanMult", _wrap_HypreParMatrix_BooleanMult, METH_VARARGS, "BooleanMult(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, - { "HypreParMatrix_BooleanMultTranspose", _wrap_HypreParMatrix_BooleanMultTranspose, METH_VARARGS, "BooleanMultTranspose(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, - { "HypreParMatrix___iadd__", _wrap_HypreParMatrix___iadd__, METH_VARARGS, "__iadd__(HypreParMatrix self, HypreParMatrix B) -> HypreParMatrix"}, - { "HypreParMatrix_Add", _wrap_HypreParMatrix_Add, METH_VARARGS, "Add(HypreParMatrix self, double const beta, HypreParMatrix B) -> HypreParMatrix"}, - { "HypreParMatrix_LeftDiagMult", _wrap_HypreParMatrix_LeftDiagMult, METH_VARARGS, "LeftDiagMult(HypreParMatrix self, SparseMatrix D, HYPRE_Int * row_starts=None) -> HypreParMatrix"}, - { "HypreParMatrix_ScaleRows", _wrap_HypreParMatrix_ScaleRows, METH_VARARGS, "ScaleRows(HypreParMatrix self, Vector s)"}, - { "HypreParMatrix_InvScaleRows", _wrap_HypreParMatrix_InvScaleRows, METH_VARARGS, "InvScaleRows(HypreParMatrix self, Vector s)"}, - { "HypreParMatrix___imul__", _wrap_HypreParMatrix___imul__, METH_VARARGS, "__imul__(HypreParMatrix self, double s)"}, - { "HypreParMatrix_Threshold", _wrap_HypreParMatrix_Threshold, METH_VARARGS, "Threshold(HypreParMatrix self, double threshold=0.0)"}, + { "HypreParMatrix_BooleanMult", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_BooleanMult, METH_VARARGS|METH_KEYWORDS, "BooleanMult(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, + { "HypreParMatrix_BooleanMultTranspose", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_BooleanMultTranspose, METH_VARARGS|METH_KEYWORDS, "BooleanMultTranspose(HypreParMatrix self, int alpha, int const * x, int beta, int * y)"}, + { "HypreParMatrix___iadd__", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix___iadd__, METH_VARARGS|METH_KEYWORDS, "__iadd__(HypreParMatrix self, HypreParMatrix B) -> HypreParMatrix"}, + { "HypreParMatrix_Add", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Add, METH_VARARGS|METH_KEYWORDS, "Add(HypreParMatrix self, double const beta, HypreParMatrix B) -> HypreParMatrix"}, + { "HypreParMatrix_LeftDiagMult", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_LeftDiagMult, METH_VARARGS|METH_KEYWORDS, "LeftDiagMult(HypreParMatrix self, SparseMatrix D, HYPRE_Int * row_starts=None) -> HypreParMatrix"}, + { "HypreParMatrix_ScaleRows", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_ScaleRows, METH_VARARGS|METH_KEYWORDS, "ScaleRows(HypreParMatrix self, Vector s)"}, + { "HypreParMatrix_InvScaleRows", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_InvScaleRows, METH_VARARGS|METH_KEYWORDS, "InvScaleRows(HypreParMatrix self, Vector s)"}, + { "HypreParMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "__imul__(HypreParMatrix self, double s)"}, + { "HypreParMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "Threshold(HypreParMatrix self, double threshold=0.0)"}, { "HypreParMatrix_EliminateZeroRows", _wrap_HypreParMatrix_EliminateZeroRows, METH_O, "EliminateZeroRows(HypreParMatrix self)"}, { "HypreParMatrix_EliminateRowsCols", _wrap_HypreParMatrix_EliminateRowsCols, METH_VARARGS, "\n" "EliminateRowsCols(HypreParMatrix self, intArray rows_cols, HypreParVector X, HypreParVector B)\n" "EliminateRowsCols(HypreParMatrix self, intArray rows_cols) -> HypreParMatrix\n" ""}, - { "HypreParMatrix_EliminateCols", _wrap_HypreParMatrix_EliminateCols, METH_VARARGS, "EliminateCols(HypreParMatrix self, intArray cols) -> HypreParMatrix"}, - { "HypreParMatrix_EliminateRows", _wrap_HypreParMatrix_EliminateRows, METH_VARARGS, "EliminateRows(HypreParMatrix self, intArray rows)"}, - { "HypreParMatrix_Print", _wrap_HypreParMatrix_Print, METH_VARARGS, "Print(HypreParMatrix self, char const * fname, HYPRE_Int offi=0, HYPRE_Int offj=0)"}, - { "HypreParMatrix_Read", _wrap_HypreParMatrix_Read, METH_VARARGS, "Read(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, - { "HypreParMatrix_Read_IJMatrix", _wrap_HypreParMatrix_Read_IJMatrix, METH_VARARGS, "Read_IJMatrix(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, + { "HypreParMatrix_EliminateCols", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_EliminateCols, METH_VARARGS|METH_KEYWORDS, "EliminateCols(HypreParMatrix self, intArray cols) -> HypreParMatrix"}, + { "HypreParMatrix_EliminateRows", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_EliminateRows, METH_VARARGS|METH_KEYWORDS, "EliminateRows(HypreParMatrix self, intArray rows)"}, + { "HypreParMatrix_Print", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Print, METH_VARARGS|METH_KEYWORDS, "Print(HypreParMatrix self, char const * fname, HYPRE_Int offi=0, HYPRE_Int offj=0)"}, + { "HypreParMatrix_Read", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Read, METH_VARARGS|METH_KEYWORDS, "Read(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, + { "HypreParMatrix_Read_IJMatrix", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_Read_IJMatrix, METH_VARARGS|METH_KEYWORDS, "Read_IJMatrix(HypreParMatrix self, MPI_Comm comm, char const * fname)"}, { "delete_HypreParMatrix", _wrap_delete_HypreParMatrix, METH_O, "delete_HypreParMatrix(HypreParMatrix self)"}, { "HypreParMatrix_GetType", _wrap_HypreParMatrix_GetType, METH_O, "GetType(HypreParMatrix self) -> mfem::Operator::Type"}, { "HypreParMatrix_GetRowPartArray", _wrap_HypreParMatrix_GetRowPartArray, METH_O, "GetRowPartArray(HypreParMatrix self) -> PyObject *"}, { "HypreParMatrix_GetColPartArray", _wrap_HypreParMatrix_GetColPartArray, METH_O, "GetColPartArray(HypreParMatrix self) -> PyObject *"}, { "HypreParMatrix_get_local_nnz", _wrap_HypreParMatrix_get_local_nnz, METH_O, "get_local_nnz(HypreParMatrix self) -> HYPRE_Int"}, { "HypreParMatrix_get_local_true_nnz", _wrap_HypreParMatrix_get_local_true_nnz, METH_O, "get_local_true_nnz(HypreParMatrix self) -> PyObject *"}, - { "HypreParMatrix_GetCooDataArray", _wrap_HypreParMatrix_GetCooDataArray, METH_VARARGS, "GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject"}, + { "HypreParMatrix_GetCooDataArray", (PyCFunction)(void(*)(void))_wrap_HypreParMatrix_GetCooDataArray, METH_VARARGS|METH_KEYWORDS, "GetCooDataArray(HypreParMatrix self, HYPRE_Int const base_i=0, HYPRE_Int const base_j=0) -> PyObject *"}, { "HypreParMatrix_PrintCommPkg", _wrap_HypreParMatrix_PrintCommPkg, METH_VARARGS, "\n" "PrintCommPkg(HypreParMatrix self, std::ostream & out=mfem::out)\n" "PrintCommPkg(HypreParMatrix self, char const * file, int precision=8)\n" ""}, { "HypreParMatrix_swigregister", HypreParMatrix_swigregister, METH_O, NULL}, { "HypreParMatrix_swiginit", HypreParMatrix_swiginit, METH_VARARGS, NULL}, - { "ParMult", _wrap_ParMult, METH_VARARGS, "ParMult(HypreParMatrix A, HypreParMatrix B, bool own_matrix=False) -> HypreParMatrix"}, - { "ParAdd", _wrap_ParAdd, METH_VARARGS, "ParAdd(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix"}, - { "EliminateBC", _wrap_EliminateBC, METH_VARARGS, "EliminateBC(HypreParMatrix A, HypreParMatrix Ae, intArray ess_dof_list, Vector X, Vector B)"}, + { "ParMult", (PyCFunction)(void(*)(void))_wrap_ParMult, METH_VARARGS|METH_KEYWORDS, "ParMult(HypreParMatrix A, HypreParMatrix B, bool own_matrix=False) -> HypreParMatrix"}, + { "ParAdd", (PyCFunction)(void(*)(void))_wrap_ParAdd, METH_VARARGS|METH_KEYWORDS, "ParAdd(HypreParMatrix A, HypreParMatrix B) -> HypreParMatrix"}, + { "EliminateBC", (PyCFunction)(void(*)(void))_wrap_EliminateBC, METH_VARARGS|METH_KEYWORDS, "EliminateBC(HypreParMatrix A, HypreParMatrix Ae, intArray ess_dof_list, Vector X, Vector B)"}, { "new_HypreSmoother", _wrap_new_HypreSmoother, METH_VARARGS, "\n" "HypreSmoother()\n" - "HypreSmoother(HypreParMatrix _A, int type=l1GS, int relax_times=1, double relax_weight=1.0, double omega=1.0, int poly_order=2, double poly_fraction=.3)\n" + "new_HypreSmoother(HypreParMatrix _A, int type=l1GS, int relax_times=1, double relax_weight=1.0, double omega=1.0, int poly_order=2, double poly_fraction=.3) -> HypreSmoother\n" ""}, - { "HypreSmoother_SetType", _wrap_HypreSmoother_SetType, METH_VARARGS, "SetType(HypreSmoother self, mfem::HypreSmoother::Type type, int relax_times=1)"}, - { "HypreSmoother_SetSOROptions", _wrap_HypreSmoother_SetSOROptions, METH_VARARGS, "SetSOROptions(HypreSmoother self, double relax_weight, double omega)"}, - { "HypreSmoother_SetPolyOptions", _wrap_HypreSmoother_SetPolyOptions, METH_VARARGS, "SetPolyOptions(HypreSmoother self, int poly_order, double poly_fraction)"}, - { "HypreSmoother_SetTaubinOptions", _wrap_HypreSmoother_SetTaubinOptions, METH_VARARGS, "SetTaubinOptions(HypreSmoother self, double _lambda, double mu, int iter)"}, - { "HypreSmoother_SetWindowByName", _wrap_HypreSmoother_SetWindowByName, METH_VARARGS, "SetWindowByName(HypreSmoother self, char const * window_name)"}, - { "HypreSmoother_SetWindowParameters", _wrap_HypreSmoother_SetWindowParameters, METH_VARARGS, "SetWindowParameters(HypreSmoother self, double a, double b, double c)"}, - { "HypreSmoother_SetFIRCoefficients", _wrap_HypreSmoother_SetFIRCoefficients, METH_VARARGS, "SetFIRCoefficients(HypreSmoother self, double max_eig)"}, - { "HypreSmoother_SetPositiveDiagonal", _wrap_HypreSmoother_SetPositiveDiagonal, METH_VARARGS, "SetPositiveDiagonal(HypreSmoother self, bool pos=True)"}, - { "HypreSmoother_SetOperator", _wrap_HypreSmoother_SetOperator, METH_VARARGS, "SetOperator(HypreSmoother self, Operator op)"}, + { "HypreSmoother_SetType", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetType, METH_VARARGS|METH_KEYWORDS, "SetType(HypreSmoother self, mfem::HypreSmoother::Type type, int relax_times=1)"}, + { "HypreSmoother_SetSOROptions", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetSOROptions, METH_VARARGS|METH_KEYWORDS, "SetSOROptions(HypreSmoother self, double relax_weight, double omega)"}, + { "HypreSmoother_SetPolyOptions", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetPolyOptions, METH_VARARGS|METH_KEYWORDS, "SetPolyOptions(HypreSmoother self, int poly_order, double poly_fraction)"}, + { "HypreSmoother_SetTaubinOptions", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetTaubinOptions, METH_VARARGS|METH_KEYWORDS, "SetTaubinOptions(HypreSmoother self, double _lambda, double mu, int iter)"}, + { "HypreSmoother_SetWindowByName", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetWindowByName, METH_VARARGS|METH_KEYWORDS, "SetWindowByName(HypreSmoother self, char const * window_name)"}, + { "HypreSmoother_SetWindowParameters", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetWindowParameters, METH_VARARGS|METH_KEYWORDS, "SetWindowParameters(HypreSmoother self, double a, double b, double c)"}, + { "HypreSmoother_SetFIRCoefficients", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetFIRCoefficients, METH_VARARGS|METH_KEYWORDS, "SetFIRCoefficients(HypreSmoother self, double max_eig)"}, + { "HypreSmoother_SetPositiveDiagonal", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetPositiveDiagonal, METH_VARARGS|METH_KEYWORDS, "SetPositiveDiagonal(HypreSmoother self, bool pos=True)"}, + { "HypreSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreSmoother self, Operator op)"}, { "HypreSmoother_Mult", _wrap_HypreSmoother_Mult, METH_VARARGS, "\n" "Mult(HypreSmoother self, HypreParVector b, HypreParVector x)\n" "Mult(HypreSmoother self, Vector b, Vector x)\n" @@ -18334,27 +16553,27 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "HypreSmoother_swiginit", HypreSmoother_swiginit, METH_VARARGS, NULL}, { "HypreSolver_SetupFcn", _wrap_HypreSolver_SetupFcn, METH_O, "SetupFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn"}, { "HypreSolver_SolveFcn", _wrap_HypreSolver_SolveFcn, METH_O, "SolveFcn(HypreSolver self) -> HYPRE_PtrToParSolverFcn"}, - { "HypreSolver_SetOperator", _wrap_HypreSolver_SetOperator, METH_VARARGS, "SetOperator(HypreSolver self, Operator op)"}, + { "HypreSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreSolver self, Operator op)"}, { "HypreSolver_Mult", _wrap_HypreSolver_Mult, METH_VARARGS, "\n" "Mult(HypreSolver self, HypreParVector b, HypreParVector x)\n" "Mult(HypreSolver self, Vector b, Vector x)\n" ""}, - { "HypreSolver_SetErrorMode", _wrap_HypreSolver_SetErrorMode, METH_VARARGS, "SetErrorMode(HypreSolver self, mfem::HypreSolver::ErrorMode err_mode)"}, + { "HypreSolver_SetErrorMode", (PyCFunction)(void(*)(void))_wrap_HypreSolver_SetErrorMode, METH_VARARGS|METH_KEYWORDS, "SetErrorMode(HypreSolver self, mfem::HypreSolver::ErrorMode err_mode)"}, { "delete_HypreSolver", _wrap_delete_HypreSolver, METH_O, "delete_HypreSolver(HypreSolver self)"}, { "HypreSolver_swigregister", HypreSolver_swigregister, METH_O, NULL}, { "new_HyprePCG", _wrap_new_HyprePCG, METH_VARARGS, "\n" "HyprePCG(MPI_Comm comm)\n" "new_HyprePCG(HypreParMatrix _A) -> HyprePCG\n" ""}, - { "HyprePCG_SetOperator", _wrap_HyprePCG_SetOperator, METH_VARARGS, "SetOperator(HyprePCG self, Operator op)"}, - { "HyprePCG_SetTol", _wrap_HyprePCG_SetTol, METH_VARARGS, "SetTol(HyprePCG self, double tol)"}, - { "HyprePCG_SetMaxIter", _wrap_HyprePCG_SetMaxIter, METH_VARARGS, "SetMaxIter(HyprePCG self, int max_iter)"}, - { "HyprePCG_SetLogging", _wrap_HyprePCG_SetLogging, METH_VARARGS, "SetLogging(HyprePCG self, int logging)"}, - { "HyprePCG_SetPrintLevel", _wrap_HyprePCG_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HyprePCG self, int print_lvl)"}, - { "HyprePCG_SetPreconditioner", _wrap_HyprePCG_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HyprePCG self, HypreSolver precond)"}, - { "HyprePCG_SetResidualConvergenceOptions", _wrap_HyprePCG_SetResidualConvergenceOptions, METH_VARARGS, "SetResidualConvergenceOptions(HyprePCG self, int res_frequency=-1, double rtol=0.0)"}, + { "HyprePCG_SetOperator", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HyprePCG self, Operator op)"}, + { "HyprePCG_SetTol", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetTol, METH_VARARGS|METH_KEYWORDS, "SetTol(HyprePCG self, double tol)"}, + { "HyprePCG_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(HyprePCG self, int max_iter)"}, + { "HyprePCG_SetLogging", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetLogging, METH_VARARGS|METH_KEYWORDS, "SetLogging(HyprePCG self, int logging)"}, + { "HyprePCG_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(HyprePCG self, int print_lvl)"}, + { "HyprePCG_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(HyprePCG self, HypreSolver precond)"}, + { "HyprePCG_SetResidualConvergenceOptions", (PyCFunction)(void(*)(void))_wrap_HyprePCG_SetResidualConvergenceOptions, METH_VARARGS|METH_KEYWORDS, "SetResidualConvergenceOptions(HyprePCG self, int res_frequency=-1, double rtol=0.0)"}, { "HyprePCG_SetZeroInintialIterate", _wrap_HyprePCG_SetZeroInintialIterate, METH_O, "SetZeroInintialIterate(HyprePCG self)"}, - { "HyprePCG_GetNumIterations", _wrap_HyprePCG_GetNumIterations, METH_VARARGS, "GetNumIterations(HyprePCG self, int & num_iterations)"}, + { "HyprePCG_GetNumIterations", (PyCFunction)(void(*)(void))_wrap_HyprePCG_GetNumIterations, METH_VARARGS|METH_KEYWORDS, "GetNumIterations(HyprePCG self, int & num_iterations)"}, { "HyprePCG_SetupFcn", _wrap_HyprePCG_SetupFcn, METH_O, "SetupFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn"}, { "HyprePCG_SolveFcn", _wrap_HyprePCG_SolveFcn, METH_O, "SolveFcn(HyprePCG self) -> HYPRE_PtrToParSolverFcn"}, { "HyprePCG_Mult", _wrap_HyprePCG_Mult, METH_VARARGS, "\n" @@ -18368,13 +16587,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreGMRES(MPI_Comm comm)\n" "new_HypreGMRES(HypreParMatrix _A) -> HypreGMRES\n" ""}, - { "HypreGMRES_SetOperator", _wrap_HypreGMRES_SetOperator, METH_VARARGS, "SetOperator(HypreGMRES self, Operator op)"}, - { "HypreGMRES_SetTol", _wrap_HypreGMRES_SetTol, METH_VARARGS, "SetTol(HypreGMRES self, double tol)"}, - { "HypreGMRES_SetMaxIter", _wrap_HypreGMRES_SetMaxIter, METH_VARARGS, "SetMaxIter(HypreGMRES self, int max_iter)"}, - { "HypreGMRES_SetKDim", _wrap_HypreGMRES_SetKDim, METH_VARARGS, "SetKDim(HypreGMRES self, int dim)"}, - { "HypreGMRES_SetLogging", _wrap_HypreGMRES_SetLogging, METH_VARARGS, "SetLogging(HypreGMRES self, int logging)"}, - { "HypreGMRES_SetPrintLevel", _wrap_HypreGMRES_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreGMRES self, int print_lvl)"}, - { "HypreGMRES_SetPreconditioner", _wrap_HypreGMRES_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HypreGMRES self, HypreSolver precond)"}, + { "HypreGMRES_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreGMRES self, Operator op)"}, + { "HypreGMRES_SetTol", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetTol, METH_VARARGS|METH_KEYWORDS, "SetTol(HypreGMRES self, double tol)"}, + { "HypreGMRES_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(HypreGMRES self, int max_iter)"}, + { "HypreGMRES_SetKDim", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetKDim, METH_VARARGS|METH_KEYWORDS, "SetKDim(HypreGMRES self, int dim)"}, + { "HypreGMRES_SetLogging", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetLogging, METH_VARARGS|METH_KEYWORDS, "SetLogging(HypreGMRES self, int logging)"}, + { "HypreGMRES_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(HypreGMRES self, int print_lvl)"}, + { "HypreGMRES_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HypreGMRES_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(HypreGMRES self, HypreSolver precond)"}, { "HypreGMRES_SetZeroInintialIterate", _wrap_HypreGMRES_SetZeroInintialIterate, METH_O, "SetZeroInintialIterate(HypreGMRES self)"}, { "HypreGMRES_SetupFcn", _wrap_HypreGMRES_SetupFcn, METH_O, "SetupFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn"}, { "HypreGMRES_SolveFcn", _wrap_HypreGMRES_SolveFcn, METH_O, "SolveFcn(HypreGMRES self) -> HYPRE_PtrToParSolverFcn"}, @@ -18395,7 +16614,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreDiagScale()\n" "new_HypreDiagScale(HypreParMatrix A) -> HypreDiagScale\n" ""}, - { "HypreDiagScale_SetOperator", _wrap_HypreDiagScale_SetOperator, METH_VARARGS, "SetOperator(HypreDiagScale self, Operator op)"}, + { "HypreDiagScale_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreDiagScale_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreDiagScale self, Operator op)"}, { "HypreDiagScale_SetupFcn", _wrap_HypreDiagScale_SetupFcn, METH_O, "SetupFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, { "HypreDiagScale_SolveFcn", _wrap_HypreDiagScale_SolveFcn, METH_O, "SolveFcn(HypreDiagScale self) -> HYPRE_PtrToParSolverFcn"}, { "HypreDiagScale_GetData", _wrap_HypreDiagScale_GetData, METH_O, "GetData(HypreDiagScale self) -> HypreParMatrix"}, @@ -18406,8 +16625,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreParaSails(MPI_Comm comm)\n" "new_HypreParaSails(HypreParMatrix A) -> HypreParaSails\n" ""}, - { "HypreParaSails_SetOperator", _wrap_HypreParaSails_SetOperator, METH_VARARGS, "SetOperator(HypreParaSails self, Operator op)"}, - { "HypreParaSails_SetSymmetry", _wrap_HypreParaSails_SetSymmetry, METH_VARARGS, "SetSymmetry(HypreParaSails self, int sym)"}, + { "HypreParaSails_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreParaSails_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreParaSails self, Operator op)"}, + { "HypreParaSails_SetSymmetry", (PyCFunction)(void(*)(void))_wrap_HypreParaSails_SetSymmetry, METH_VARARGS|METH_KEYWORDS, "SetSymmetry(HypreParaSails self, int sym)"}, { "HypreParaSails_SetupFcn", _wrap_HypreParaSails_SetupFcn, METH_O, "SetupFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, { "HypreParaSails_SolveFcn", _wrap_HypreParaSails_SolveFcn, METH_O, "SolveFcn(HypreParaSails self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreParaSails", _wrap_delete_HypreParaSails, METH_O, "delete_HypreParaSails(HypreParaSails self)"}, @@ -18417,7 +16636,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreEuclid(MPI_Comm comm)\n" "new_HypreEuclid(HypreParMatrix A) -> HypreEuclid\n" ""}, - { "HypreEuclid_SetOperator", _wrap_HypreEuclid_SetOperator, METH_VARARGS, "SetOperator(HypreEuclid self, Operator op)"}, + { "HypreEuclid_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreEuclid_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreEuclid self, Operator op)"}, { "HypreEuclid_SetupFcn", _wrap_HypreEuclid_SetupFcn, METH_O, "SetupFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, { "HypreEuclid_SolveFcn", _wrap_HypreEuclid_SolveFcn, METH_O, "SolveFcn(HypreEuclid self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreEuclid", _wrap_delete_HypreEuclid, METH_O, "delete_HypreEuclid(HypreEuclid self)"}, @@ -18427,10 +16646,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreBoomerAMG()\n" "new_HypreBoomerAMG(HypreParMatrix A) -> HypreBoomerAMG\n" ""}, - { "HypreBoomerAMG_SetOperator", _wrap_HypreBoomerAMG_SetOperator, METH_VARARGS, "SetOperator(HypreBoomerAMG self, Operator op)"}, - { "HypreBoomerAMG_SetSystemsOptions", _wrap_HypreBoomerAMG_SetSystemsOptions, METH_VARARGS, "SetSystemsOptions(HypreBoomerAMG self, int dim)"}, - { "HypreBoomerAMG_SetElasticityOptions", _wrap_HypreBoomerAMG_SetElasticityOptions, METH_VARARGS, "SetElasticityOptions(HypreBoomerAMG self, mfem::ParFiniteElementSpace * fespace)"}, - { "HypreBoomerAMG_SetPrintLevel", _wrap_HypreBoomerAMG_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreBoomerAMG self, int print_level)"}, + { "HypreBoomerAMG_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreBoomerAMG self, Operator op)"}, + { "HypreBoomerAMG_SetSystemsOptions", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetSystemsOptions, METH_VARARGS|METH_KEYWORDS, "SetSystemsOptions(HypreBoomerAMG self, int dim)"}, + { "HypreBoomerAMG_SetElasticityOptions", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetElasticityOptions, METH_VARARGS|METH_KEYWORDS, "SetElasticityOptions(HypreBoomerAMG self, mfem::ParFiniteElementSpace * fespace)"}, + { "HypreBoomerAMG_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreBoomerAMG_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(HypreBoomerAMG self, int print_level)"}, { "HypreBoomerAMG_SetupFcn", _wrap_HypreBoomerAMG_SetupFcn, METH_O, "SetupFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn"}, { "HypreBoomerAMG_SolveFcn", _wrap_HypreBoomerAMG_SolveFcn, METH_O, "SolveFcn(HypreBoomerAMG self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreBoomerAMG", _wrap_delete_HypreBoomerAMG, METH_O, "delete_HypreBoomerAMG(HypreBoomerAMG self)"}, @@ -18440,8 +16659,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreAMS(mfem::ParFiniteElementSpace * edge_fespace)\n" "new_HypreAMS(HypreParMatrix A, mfem::ParFiniteElementSpace * edge_fespace) -> HypreAMS\n" ""}, - { "HypreAMS_SetOperator", _wrap_HypreAMS_SetOperator, METH_VARARGS, "SetOperator(HypreAMS self, Operator op)"}, - { "HypreAMS_SetPrintLevel", _wrap_HypreAMS_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreAMS self, int print_lvl)"}, + { "HypreAMS_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreAMS_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreAMS self, Operator op)"}, + { "HypreAMS_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreAMS_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(HypreAMS self, int print_lvl)"}, { "HypreAMS_SetSingularProblem", _wrap_HypreAMS_SetSingularProblem, METH_O, "SetSingularProblem(HypreAMS self)"}, { "HypreAMS_SetupFcn", _wrap_HypreAMS_SetupFcn, METH_O, "SetupFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn"}, { "HypreAMS_SolveFcn", _wrap_HypreAMS_SolveFcn, METH_O, "SolveFcn(HypreAMS self) -> HYPRE_PtrToParSolverFcn"}, @@ -18452,46 +16671,46 @@ static PyMethodDef SwigMethods_proxydocs[] = { "HypreADS(mfem::ParFiniteElementSpace * face_fespace)\n" "new_HypreADS(HypreParMatrix A, mfem::ParFiniteElementSpace * face_fespace) -> HypreADS\n" ""}, - { "HypreADS_SetOperator", _wrap_HypreADS_SetOperator, METH_VARARGS, "SetOperator(HypreADS self, Operator op)"}, - { "HypreADS_SetPrintLevel", _wrap_HypreADS_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreADS self, int print_lvl)"}, + { "HypreADS_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreADS_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreADS self, Operator op)"}, + { "HypreADS_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreADS_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(HypreADS self, int print_lvl)"}, { "HypreADS_SetupFcn", _wrap_HypreADS_SetupFcn, METH_O, "SetupFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, { "HypreADS_SolveFcn", _wrap_HypreADS_SolveFcn, METH_O, "SolveFcn(HypreADS self) -> HYPRE_PtrToParSolverFcn"}, { "delete_HypreADS", _wrap_delete_HypreADS, METH_O, "delete_HypreADS(HypreADS self)"}, { "HypreADS_swigregister", HypreADS_swigregister, METH_O, NULL}, { "HypreADS_swiginit", HypreADS_swiginit, METH_VARARGS, NULL}, - { "new_HypreLOBPCG", _wrap_new_HypreLOBPCG, METH_O, "new_HypreLOBPCG(MPI_Comm comm) -> HypreLOBPCG"}, + { "new_HypreLOBPCG", (PyCFunction)(void(*)(void))_wrap_new_HypreLOBPCG, METH_VARARGS|METH_KEYWORDS, "new_HypreLOBPCG(MPI_Comm comm) -> HypreLOBPCG"}, { "delete_HypreLOBPCG", _wrap_delete_HypreLOBPCG, METH_O, "delete_HypreLOBPCG(HypreLOBPCG self)"}, - { "HypreLOBPCG_SetTol", _wrap_HypreLOBPCG_SetTol, METH_VARARGS, "SetTol(HypreLOBPCG self, double tol)"}, - { "HypreLOBPCG_SetRelTol", _wrap_HypreLOBPCG_SetRelTol, METH_VARARGS, "SetRelTol(HypreLOBPCG self, double rel_tol)"}, - { "HypreLOBPCG_SetMaxIter", _wrap_HypreLOBPCG_SetMaxIter, METH_VARARGS, "SetMaxIter(HypreLOBPCG self, int max_iter)"}, - { "HypreLOBPCG_SetPrintLevel", _wrap_HypreLOBPCG_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreLOBPCG self, int logging)"}, - { "HypreLOBPCG_SetNumModes", _wrap_HypreLOBPCG_SetNumModes, METH_VARARGS, "SetNumModes(HypreLOBPCG self, int num_eigs)"}, - { "HypreLOBPCG_SetPrecondUsageMode", _wrap_HypreLOBPCG_SetPrecondUsageMode, METH_VARARGS, "SetPrecondUsageMode(HypreLOBPCG self, int pcg_mode)"}, - { "HypreLOBPCG_SetRandomSeed", _wrap_HypreLOBPCG_SetRandomSeed, METH_VARARGS, "SetRandomSeed(HypreLOBPCG self, int s)"}, - { "HypreLOBPCG_SetInitialVectors", _wrap_HypreLOBPCG_SetInitialVectors, METH_VARARGS, "SetInitialVectors(HypreLOBPCG self, int num_vecs, mfem::HypreParVector ** vecs)"}, - { "HypreLOBPCG_SetPreconditioner", _wrap_HypreLOBPCG_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HypreLOBPCG self, Solver precond)"}, - { "HypreLOBPCG_SetOperator", _wrap_HypreLOBPCG_SetOperator, METH_VARARGS, "SetOperator(HypreLOBPCG self, Operator A)"}, - { "HypreLOBPCG_SetMassMatrix", _wrap_HypreLOBPCG_SetMassMatrix, METH_VARARGS, "SetMassMatrix(HypreLOBPCG self, Operator M)"}, - { "HypreLOBPCG_SetSubSpaceProjector", _wrap_HypreLOBPCG_SetSubSpaceProjector, METH_VARARGS, "SetSubSpaceProjector(HypreLOBPCG self, Operator proj)"}, + { "HypreLOBPCG_SetTol", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetTol, METH_VARARGS|METH_KEYWORDS, "SetTol(HypreLOBPCG self, double tol)"}, + { "HypreLOBPCG_SetRelTol", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetRelTol, METH_VARARGS|METH_KEYWORDS, "SetRelTol(HypreLOBPCG self, double rel_tol)"}, + { "HypreLOBPCG_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(HypreLOBPCG self, int max_iter)"}, + { "HypreLOBPCG_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(HypreLOBPCG self, int logging)"}, + { "HypreLOBPCG_SetNumModes", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetNumModes, METH_VARARGS|METH_KEYWORDS, "SetNumModes(HypreLOBPCG self, int num_eigs)"}, + { "HypreLOBPCG_SetPrecondUsageMode", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetPrecondUsageMode, METH_VARARGS|METH_KEYWORDS, "SetPrecondUsageMode(HypreLOBPCG self, int pcg_mode)"}, + { "HypreLOBPCG_SetRandomSeed", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetRandomSeed, METH_VARARGS|METH_KEYWORDS, "SetRandomSeed(HypreLOBPCG self, int s)"}, + { "HypreLOBPCG_SetInitialVectors", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetInitialVectors, METH_VARARGS|METH_KEYWORDS, "SetInitialVectors(HypreLOBPCG self, int num_vecs, mfem::HypreParVector ** vecs)"}, + { "HypreLOBPCG_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(HypreLOBPCG self, Solver precond)"}, + { "HypreLOBPCG_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreLOBPCG self, Operator A)"}, + { "HypreLOBPCG_SetMassMatrix", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetMassMatrix, METH_VARARGS|METH_KEYWORDS, "SetMassMatrix(HypreLOBPCG self, Operator M)"}, + { "HypreLOBPCG_SetSubSpaceProjector", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_SetSubSpaceProjector, METH_VARARGS|METH_KEYWORDS, "SetSubSpaceProjector(HypreLOBPCG self, Operator proj)"}, { "HypreLOBPCG_Solve", _wrap_HypreLOBPCG_Solve, METH_O, "Solve(HypreLOBPCG self)"}, - { "HypreLOBPCG_GetEigenvalues", _wrap_HypreLOBPCG_GetEigenvalues, METH_VARARGS, "GetEigenvalues(HypreLOBPCG self, doubleArray eigenvalues)"}, - { "HypreLOBPCG_GetEigenvector", _wrap_HypreLOBPCG_GetEigenvector, METH_VARARGS, "GetEigenvector(HypreLOBPCG self, unsigned int i) -> HypreParVector"}, + { "HypreLOBPCG_GetEigenvalues", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_GetEigenvalues, METH_VARARGS|METH_KEYWORDS, "GetEigenvalues(HypreLOBPCG self, doubleArray eigenvalues)"}, + { "HypreLOBPCG_GetEigenvector", (PyCFunction)(void(*)(void))_wrap_HypreLOBPCG_GetEigenvector, METH_VARARGS|METH_KEYWORDS, "GetEigenvector(HypreLOBPCG self, unsigned int i) -> HypreParVector"}, { "HypreLOBPCG_StealEigenvectors", _wrap_HypreLOBPCG_StealEigenvectors, METH_O, "StealEigenvectors(HypreLOBPCG self) -> mfem::HypreParVector **"}, { "HypreLOBPCG_swigregister", HypreLOBPCG_swigregister, METH_O, NULL}, { "HypreLOBPCG_swiginit", HypreLOBPCG_swiginit, METH_VARARGS, NULL}, - { "new_HypreAME", _wrap_new_HypreAME, METH_O, "new_HypreAME(MPI_Comm comm) -> HypreAME"}, + { "new_HypreAME", (PyCFunction)(void(*)(void))_wrap_new_HypreAME, METH_VARARGS|METH_KEYWORDS, "new_HypreAME(MPI_Comm comm) -> HypreAME"}, { "delete_HypreAME", _wrap_delete_HypreAME, METH_O, "delete_HypreAME(HypreAME self)"}, - { "HypreAME_SetTol", _wrap_HypreAME_SetTol, METH_VARARGS, "SetTol(HypreAME self, double tol)"}, - { "HypreAME_SetRelTol", _wrap_HypreAME_SetRelTol, METH_VARARGS, "SetRelTol(HypreAME self, double rel_tol)"}, - { "HypreAME_SetMaxIter", _wrap_HypreAME_SetMaxIter, METH_VARARGS, "SetMaxIter(HypreAME self, int max_iter)"}, - { "HypreAME_SetPrintLevel", _wrap_HypreAME_SetPrintLevel, METH_VARARGS, "SetPrintLevel(HypreAME self, int logging)"}, - { "HypreAME_SetNumModes", _wrap_HypreAME_SetNumModes, METH_VARARGS, "SetNumModes(HypreAME self, int num_eigs)"}, - { "HypreAME_SetPreconditioner", _wrap_HypreAME_SetPreconditioner, METH_VARARGS, "SetPreconditioner(HypreAME self, HypreSolver precond)"}, - { "HypreAME_SetOperator", _wrap_HypreAME_SetOperator, METH_VARARGS, "SetOperator(HypreAME self, HypreParMatrix A)"}, - { "HypreAME_SetMassMatrix", _wrap_HypreAME_SetMassMatrix, METH_VARARGS, "SetMassMatrix(HypreAME self, HypreParMatrix M)"}, + { "HypreAME_SetTol", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetTol, METH_VARARGS|METH_KEYWORDS, "SetTol(HypreAME self, double tol)"}, + { "HypreAME_SetRelTol", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetRelTol, METH_VARARGS|METH_KEYWORDS, "SetRelTol(HypreAME self, double rel_tol)"}, + { "HypreAME_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(HypreAME self, int max_iter)"}, + { "HypreAME_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(HypreAME self, int logging)"}, + { "HypreAME_SetNumModes", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetNumModes, METH_VARARGS|METH_KEYWORDS, "SetNumModes(HypreAME self, int num_eigs)"}, + { "HypreAME_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(HypreAME self, HypreSolver precond)"}, + { "HypreAME_SetOperator", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(HypreAME self, HypreParMatrix A)"}, + { "HypreAME_SetMassMatrix", (PyCFunction)(void(*)(void))_wrap_HypreAME_SetMassMatrix, METH_VARARGS|METH_KEYWORDS, "SetMassMatrix(HypreAME self, HypreParMatrix M)"}, { "HypreAME_Solve", _wrap_HypreAME_Solve, METH_O, "Solve(HypreAME self)"}, - { "HypreAME_GetEigenvalues", _wrap_HypreAME_GetEigenvalues, METH_VARARGS, "GetEigenvalues(HypreAME self, doubleArray eigenvalues)"}, - { "HypreAME_GetEigenvector", _wrap_HypreAME_GetEigenvector, METH_VARARGS, "GetEigenvector(HypreAME self, unsigned int i) -> HypreParVector"}, + { "HypreAME_GetEigenvalues", (PyCFunction)(void(*)(void))_wrap_HypreAME_GetEigenvalues, METH_VARARGS|METH_KEYWORDS, "GetEigenvalues(HypreAME self, doubleArray eigenvalues)"}, + { "HypreAME_GetEigenvector", (PyCFunction)(void(*)(void))_wrap_HypreAME_GetEigenvector, METH_VARARGS|METH_KEYWORDS, "GetEigenvector(HypreAME self, unsigned int i) -> HypreParVector"}, { "HypreAME_StealEigenvectors", _wrap_HypreAME_StealEigenvectors, METH_O, "StealEigenvectors(HypreAME self) -> mfem::HypreParVector **"}, { "HypreAME_swigregister", HypreAME_swigregister, METH_O, NULL}, { "HypreAME_swiginit", HypreAME_swiginit, METH_VARARGS, NULL}, @@ -19614,10 +17833,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/intrules.py b/mfem/_par/intrules.py index 6148b78e..bb28d004 100644 --- a/mfem/_par/intrules.py +++ b/mfem/_par/intrules.py @@ -500,9 +500,9 @@ class IntegrationRules(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(IntegrationRules self, int Ref=0, int type=GaussLegendre) -> IntegrationRules""" - _intrules.IntegrationRules_swiginit(self, _intrules.new_IntegrationRules(*args)) + _intrules.IntegrationRules_swiginit(self, _intrules.new_IntegrationRules(*args, **kwargs)) def Get(self, GeomType, Order): r"""Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule""" diff --git a/mfem/_par/intrules_wrap.cxx b/mfem/_par/intrules_wrap.cxx index 751a9430..5df2be11 100644 --- a/mfem/_par/intrules_wrap.cxx +++ b/mfem/_par/intrules_wrap.cxx @@ -3556,7 +3556,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_OwnsData(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; mfem::IntegrationPoint **arg2 = (mfem::IntegrationPoint **) 0 ; @@ -3564,15 +3564,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_StealData(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_StealData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_StealData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_StealData" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__IntegrationPoint, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPointArray_StealData" "', argument " "2"" of type '" "mfem::IntegrationPoint **""'"); } @@ -3972,7 +3976,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Capacity(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -3980,15 +3984,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Reserve(PyObject *SWIGUNUSEDPAR int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"capacity", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Reserve", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_Reserve", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Reserve" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Reserve" "', argument " "2"" of type '" "int""'"); } @@ -4227,7 +4235,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Append(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -4235,16 +4243,20 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Prepend(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Prepend", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_Prepend", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Prepend" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPointArray_Prepend" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4457,7 +4469,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_DeleteAll(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; mfem::Array< mfem::IntegrationPoint > *arg2 = 0 ; @@ -4465,15 +4477,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Copy(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Copy" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPointArray_Copy" "', argument " "2"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); } @@ -4652,7 +4668,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_MakeRef(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -4666,25 +4682,31 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_GetSubArray(PyObject *SWIGUNUSE int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"sa_size", (char *)"sa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_GetSubArray", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IntegrationPointArray_GetSubArray", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); } @@ -5012,66 +5034,37 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_MemoryUsage(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; mfem::IntegrationPoint *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:IntegrationPointArray_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Read" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::IntegrationPoint *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Read" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); { try { - result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->Read(); + result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5092,48 +5085,6 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_IntegrationPointArray_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_IntegrationPointArray_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::Read(bool) const\n" - " mfem::Array< mfem::IntegrationPoint >::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5172,66 +5123,37 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostRead(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; mfem::IntegrationPoint *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:IntegrationPointArray_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Write" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::IntegrationPoint *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::IntegrationPoint *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Write" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); { try { - result = (mfem::IntegrationPoint *)(arg1)->Write(); + result = (mfem::IntegrationPoint *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5252,48 +5174,6 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_IntegrationPointArray_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_IntegrationPointArray_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::Write(bool)\n" - " mfem::Array< mfem::IntegrationPoint >::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5332,66 +5212,37 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostWrite(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; mfem::IntegrationPoint *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:IntegrationPointArray_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::IntegrationPoint *)(arg1)->ReadWrite(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::IntegrationPoint *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); { try { - result = (mfem::IntegrationPoint *)(arg1)->ReadWrite(); + result = (mfem::IntegrationPoint *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5412,48 +5263,6 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_IntegrationPointArray_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_IntegrationPointArray_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::ReadWrite(bool)\n" - " mfem::Array< mfem::IntegrationPoint >::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5492,7 +5301,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostReadWrite(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -5503,21 +5312,26 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSE int ecode2 = 0 ; void *argp3 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegrationPointArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray___setitem__" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray___setitem__" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntegrationPointArray___setitem__" "', argument " "3"" of type '" "mfem::IntegrationPoint const""'"); } @@ -5552,7 +5366,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_IntegrationPointArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -5560,16 +5374,20 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray___getitem__(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::IntegrationPoint *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray___getitem__" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray___getitem__" "', argument " "2"" of type '" "int""'"); } @@ -5996,7 +5814,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_index_get(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; int arg2 ; @@ -6004,15 +5822,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPoint_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Init" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPoint_Init" "', argument " "2"" of type '" "int""'"); } @@ -6091,7 +5913,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Set__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; double *arg2 = (double *) 0 ; @@ -6102,20 +5924,25 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Get(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"dim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Get", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegrationPoint_Get", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Get" "', argument " "1"" of type '" "mfem::IntegrationPoint const *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPoint_Get" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationPoint_Get" "', argument " "3"" of type '" "int""'"); } @@ -6281,7 +6108,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Set(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Set3w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_Set3w(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; double *arg2 = (double *) 0 ; @@ -6289,15 +6116,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Set3w(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Set3w", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPoint_Set3w", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Set3w" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPoint_Set3w" "', argument " "2"" of type '" "double const *""'"); } @@ -7296,7 +7127,7 @@ SWIGINTERN PyObject *_wrap_IntegrationRule_GetOrder(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_IntegrationRule_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRule_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; int arg2 ; @@ -7304,15 +7135,19 @@ SWIGINTERN PyObject *_wrap_IntegrationRule_SetOrder(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"order", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRule_SetOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationRule_SetOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRule_SetOrder" "', argument " "1"" of type '" "mfem::IntegrationRule *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRule_SetOrder" "', argument " "2"" of type '" "int""'"); } @@ -7600,7 +7435,7 @@ SWIGINTERN PyObject *IntegrationRule_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7611,20 +7446,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNU int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_GaussLegendre", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_GaussLegendre", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_GaussLegendre" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_GaussLegendre" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_GaussLegendre" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7652,7 +7492,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7663,20 +7503,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUS int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_GaussLobatto", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_GaussLobatto", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_GaussLobatto" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_GaussLobatto" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_GaussLobatto" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7704,7 +7549,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7715,20 +7560,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSE int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_OpenUniform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_OpenUniform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_OpenUniform" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_OpenUniform" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_OpenUniform" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7756,7 +7606,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7767,20 +7617,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNU int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_ClosedUniform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_ClosedUniform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_ClosedUniform" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_ClosedUniform" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_ClosedUniform" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7808,7 +7663,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7819,20 +7674,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGU int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_OpenHalfUniform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_OpenHalfUniform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_OpenHalfUniform" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_OpenHalfUniform" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_OpenHalfUniform" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7860,7 +7720,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GivePolyPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GivePolyPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7874,25 +7734,31 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GivePolyPoints(PyObject *SWIGUN int res3 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"pts", (char *)"type", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_GivePolyPoints", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:QuadratureFunctions1D_GivePolyPoints", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "3"" of type '" "double *""'"); } arg3 = reinterpret_cast< double * >(argp3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "4"" of type '" "int""'"); } @@ -7996,17 +7862,19 @@ SWIGINTERN PyObject *QuadratureFunctions1D_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_Quadrature1D_CheckClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadrature1D_CheckClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Quadrature1D_CheckClosed", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Quadrature1D_CheckClosed" "', argument " "1"" of type '" "int""'"); } @@ -8034,17 +7902,19 @@ SWIGINTERN PyObject *_wrap_Quadrature1D_CheckClosed(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Quadrature1D_CheckOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadrature1D_CheckOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Quadrature1D_CheckOpen", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Quadrature1D_CheckOpen" "', argument " "1"" of type '" "int""'"); } @@ -8148,94 +8018,39 @@ SWIGINTERN PyObject *Quadrature1D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + int arg1 = (int) 0 ; + int arg2 = (int) mfem::Quadrature1D::GaussLegendre ; int val1 ; int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"Ref", (char *)"type", NULL + }; mfem::IntegrationRules *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationRules" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntegrationRules" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - try { - result = (mfem::IntegrationRules *)new mfem::IntegrationRules(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_IntegrationRules", kwnames, &obj0, &obj1)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationRules" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRules, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - mfem::IntegrationRules *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationRules" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - { - try { - result = (mfem::IntegrationRules *)new mfem::IntegrationRules(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (obj1) { + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntegrationRules" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRules, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::IntegrationRules *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::IntegrationRules *)new mfem::IntegrationRules(); + result = (mfem::IntegrationRules *)new mfem::IntegrationRules(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8256,55 +8071,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_2(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_new_IntegrationRules(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntegrationRules", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_IntegrationRules__SWIG_2(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_IntegrationRules__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_IntegrationRules__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntegrationRules'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::IntegrationRules::IntegrationRules(int,int)\n" - " mfem::IntegrationRules::IntegrationRules(int)\n" - " mfem::IntegrationRules::IntegrationRules()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRules *arg1 = (mfem::IntegrationRules *) 0 ; int arg2 ; @@ -8315,21 +8082,26 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Order", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRules_Get", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegrationRules_Get", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRules_Get" "', argument " "1"" of type '" "mfem::IntegrationRules *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRules * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRules_Get" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationRules_Get" "', argument " "3"" of type '" "int""'"); } @@ -8357,7 +8129,7 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRules *arg1 = (mfem::IntegrationRules *) 0 ; int arg2 ; @@ -8371,25 +8143,31 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Order", (char *)"IntRule", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRules_Set", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IntegrationRules_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRules_Set" "', argument " "1"" of type '" "mfem::IntegrationRules *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRules * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRules_Set" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationRules_Set" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntegrationRules_Set" "', argument " "4"" of type '" "mfem::IntegrationRule &""'"); } @@ -8420,7 +8198,7 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IntegrationRules_SetOwnRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRules_SetOwnRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRules *arg1 = (mfem::IntegrationRules *) 0 ; int arg2 ; @@ -8428,15 +8206,19 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_SetOwnRules(PyObject *SWIGUNUSEDPARM int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"o", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRules_SetOwnRules", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationRules_SetOwnRules", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRules_SetOwnRules" "', argument " "1"" of type '" "mfem::IntegrationRules *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRules * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRules_SetOwnRules" "', argument " "2"" of type '" "int""'"); } @@ -8561,7 +8343,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "IntegrationPointArray_UseDevice", _wrap_IntegrationPointArray_UseDevice, METH_O, "IntegrationPointArray_UseDevice(IntegrationPointArray self) -> bool"}, { "IntegrationPointArray_OwnsData", _wrap_IntegrationPointArray_OwnsData, METH_O, "IntegrationPointArray_OwnsData(IntegrationPointArray self) -> bool"}, - { "IntegrationPointArray_StealData", _wrap_IntegrationPointArray_StealData, METH_VARARGS, "IntegrationPointArray_StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, + { "IntegrationPointArray_StealData", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_StealData, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, { "IntegrationPointArray_LoseData", _wrap_IntegrationPointArray_LoseData, METH_O, "IntegrationPointArray_LoseData(IntegrationPointArray self)"}, { "IntegrationPointArray_MakeDataOwner", _wrap_IntegrationPointArray_MakeDataOwner, METH_O, "IntegrationPointArray_MakeDataOwner(IntegrationPointArray self)"}, { "IntegrationPointArray_Size", _wrap_IntegrationPointArray_Size, METH_O, "IntegrationPointArray_Size(IntegrationPointArray self) -> int"}, @@ -8571,25 +8353,25 @@ static PyMethodDef SwigMethods[] = { "IntegrationPointArray_SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "IntegrationPointArray_Capacity", _wrap_IntegrationPointArray_Capacity, METH_O, "IntegrationPointArray_Capacity(IntegrationPointArray self) -> int"}, - { "IntegrationPointArray_Reserve", _wrap_IntegrationPointArray_Reserve, METH_VARARGS, "IntegrationPointArray_Reserve(IntegrationPointArray self, int capacity)"}, + { "IntegrationPointArray_Reserve", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Reserve, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Reserve(IntegrationPointArray self, int capacity)"}, { "IntegrationPointArray_Append", _wrap_IntegrationPointArray_Append, METH_VARARGS, "\n" "IntegrationPointArray_Append(IntegrationPointArray self, IntegrationPoint el) -> int\n" "IntegrationPointArray_Append(IntegrationPointArray self, IntegrationPoint els, int nels) -> int\n" "IntegrationPointArray_Append(IntegrationPointArray self, IntegrationPointArray els) -> int\n" ""}, - { "IntegrationPointArray_Prepend", _wrap_IntegrationPointArray_Prepend, METH_VARARGS, "IntegrationPointArray_Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, + { "IntegrationPointArray_Prepend", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Prepend, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, { "IntegrationPointArray_Last", _wrap_IntegrationPointArray_Last, METH_VARARGS, "\n" "IntegrationPointArray_Last(IntegrationPointArray self) -> IntegrationPoint\n" "IntegrationPointArray_Last(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_DeleteLast", _wrap_IntegrationPointArray_DeleteLast, METH_O, "IntegrationPointArray_DeleteLast(IntegrationPointArray self)"}, { "IntegrationPointArray_DeleteAll", _wrap_IntegrationPointArray_DeleteAll, METH_O, "IntegrationPointArray_DeleteAll(IntegrationPointArray self)"}, - { "IntegrationPointArray_Copy", _wrap_IntegrationPointArray_Copy, METH_VARARGS, "IntegrationPointArray_Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, + { "IntegrationPointArray_Copy", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Copy, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, { "IntegrationPointArray_MakeRef", _wrap_IntegrationPointArray_MakeRef, METH_VARARGS, "\n" "IntegrationPointArray_MakeRef(IntegrationPointArray self, IntegrationPoint arg2, int arg3)\n" "IntegrationPointArray_MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" ""}, - { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "IntegrationPointArray_GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, + { "IntegrationPointArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" @@ -8599,14 +8381,14 @@ static PyMethodDef SwigMethods[] = { "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "IntegrationPointArray_MemoryUsage(IntegrationPointArray self) -> long"}, - { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "IntegrationPointArray_Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Read", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Read, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "IntegrationPointArray_HostRead(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_Write", _wrap_IntegrationPointArray_Write, METH_VARARGS, "IntegrationPointArray_Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Write", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Write, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostWrite", _wrap_IntegrationPointArray_HostWrite, METH_O, "IntegrationPointArray_HostWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_ReadWrite", _wrap_IntegrationPointArray_ReadWrite, METH_VARARGS, "IntegrationPointArray_ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostReadWrite", _wrap_IntegrationPointArray_HostReadWrite, METH_O, "IntegrationPointArray_HostReadWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray___setitem__", _wrap_IntegrationPointArray___setitem__, METH_VARARGS, "IntegrationPointArray___setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, - { "IntegrationPointArray___getitem__", _wrap_IntegrationPointArray___getitem__, METH_VARARGS, "IntegrationPointArray___getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, + { "IntegrationPointArray___setitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___setitem__, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray___setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, + { "IntegrationPointArray___getitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___getitem__, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray___getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, { "IntegrationPointArray_Assign", _wrap_IntegrationPointArray_Assign, METH_VARARGS, "\n" "IntegrationPointArray_Assign(IntegrationPointArray self, IntegrationPoint arg2)\n" "IntegrationPointArray_Assign(IntegrationPointArray self, IntegrationPoint a)\n" @@ -8624,13 +8406,13 @@ static PyMethodDef SwigMethods[] = { { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, - { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "IntegrationPoint_Init(IntegrationPoint self, int const i)"}, - { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "IntegrationPoint_Get(IntegrationPoint self, double * p, int const dim)"}, + { "IntegrationPoint_Init", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Init, METH_VARARGS|METH_KEYWORDS, "IntegrationPoint_Init(IntegrationPoint self, int const i)"}, + { "IntegrationPoint_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Get, METH_VARARGS|METH_KEYWORDS, "IntegrationPoint_Get(IntegrationPoint self, double * p, int const dim)"}, { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" "IntegrationPoint_Set(IntegrationPoint self, double const * p, int const dim)\n" "IntegrationPoint_Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w)\n" ""}, - { "IntegrationPoint_Set3w", _wrap_IntegrationPoint_Set3w, METH_VARARGS, "IntegrationPoint_Set3w(IntegrationPoint self, double const * p)"}, + { "IntegrationPoint_Set3w", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Set3w, METH_VARARGS|METH_KEYWORDS, "IntegrationPoint_Set3w(IntegrationPoint self, double const * p)"}, { "IntegrationPoint_Set3", _wrap_IntegrationPoint_Set3, METH_VARARGS, "\n" "IntegrationPoint_Set3(IntegrationPoint self, double const x1, double const x2, double const x3)\n" "IntegrationPoint_Set3(IntegrationPoint self, double const * p)\n" @@ -8658,7 +8440,7 @@ static PyMethodDef SwigMethods[] = { "new_IntegrationRule(IntegrationRule irx, IntegrationRule iry, IntegrationRule irz) -> IntegrationRule\n" ""}, { "IntegrationRule_GetOrder", _wrap_IntegrationRule_GetOrder, METH_O, "IntegrationRule_GetOrder(IntegrationRule self) -> int"}, - { "IntegrationRule_SetOrder", _wrap_IntegrationRule_SetOrder, METH_VARARGS, "IntegrationRule_SetOrder(IntegrationRule self, int const order)"}, + { "IntegrationRule_SetOrder", (PyCFunction)(void(*)(void))_wrap_IntegrationRule_SetOrder, METH_VARARGS|METH_KEYWORDS, "IntegrationRule_SetOrder(IntegrationRule self, int const order)"}, { "IntegrationRule_GetNPoints", _wrap_IntegrationRule_GetNPoints, METH_O, "IntegrationRule_GetNPoints(IntegrationRule self) -> int"}, { "IntegrationRule_IntPoint", _wrap_IntegrationRule_IntPoint, METH_VARARGS, "\n" "IntegrationRule_IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" @@ -8668,26 +8450,26 @@ static PyMethodDef SwigMethods[] = { { "delete_IntegrationRule", _wrap_delete_IntegrationRule, METH_O, "delete_IntegrationRule(IntegrationRule self)"}, { "IntegrationRule_swigregister", IntegrationRule_swigregister, METH_O, NULL}, { "IntegrationRule_swiginit", IntegrationRule_swiginit, METH_VARARGS, NULL}, - { "QuadratureFunctions1D_GaussLegendre", _wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS, "QuadratureFunctions1D_GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GaussLobatto", _wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS, "QuadratureFunctions1D_GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenUniform", _wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS, "QuadratureFunctions1D_OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_ClosedUniform", _wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS, "QuadratureFunctions1D_ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenHalfUniform", _wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS, "QuadratureFunctions1D_OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GivePolyPoints", _wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS, "QuadratureFunctions1D_GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, + { "QuadratureFunctions1D_GaussLegendre", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GaussLobatto", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_ClosedUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenHalfUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GivePolyPoints", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, { "new_QuadratureFunctions1D", _wrap_new_QuadratureFunctions1D, METH_NOARGS, "new_QuadratureFunctions1D() -> QuadratureFunctions1D"}, { "delete_QuadratureFunctions1D", _wrap_delete_QuadratureFunctions1D, METH_O, "delete_QuadratureFunctions1D(QuadratureFunctions1D self)"}, { "QuadratureFunctions1D_swigregister", QuadratureFunctions1D_swigregister, METH_O, NULL}, { "QuadratureFunctions1D_swiginit", QuadratureFunctions1D_swiginit, METH_VARARGS, NULL}, - { "Quadrature1D_CheckClosed", _wrap_Quadrature1D_CheckClosed, METH_O, "Quadrature1D_CheckClosed(int type) -> int"}, - { "Quadrature1D_CheckOpen", _wrap_Quadrature1D_CheckOpen, METH_O, "Quadrature1D_CheckOpen(int type) -> int"}, + { "Quadrature1D_CheckClosed", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckClosed, METH_VARARGS|METH_KEYWORDS, "Quadrature1D_CheckClosed(int type) -> int"}, + { "Quadrature1D_CheckOpen", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckOpen, METH_VARARGS|METH_KEYWORDS, "Quadrature1D_CheckOpen(int type) -> int"}, { "new_Quadrature1D", _wrap_new_Quadrature1D, METH_NOARGS, "new_Quadrature1D() -> Quadrature1D"}, { "delete_Quadrature1D", _wrap_delete_Quadrature1D, METH_O, "delete_Quadrature1D(Quadrature1D self)"}, { "Quadrature1D_swigregister", Quadrature1D_swigregister, METH_O, NULL}, { "Quadrature1D_swiginit", Quadrature1D_swiginit, METH_VARARGS, NULL}, - { "new_IntegrationRules", _wrap_new_IntegrationRules, METH_VARARGS, "IntegrationRules(int Ref=0, int type=GaussLegendre)"}, - { "IntegrationRules_Get", _wrap_IntegrationRules_Get, METH_VARARGS, "IntegrationRules_Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, - { "IntegrationRules_Set", _wrap_IntegrationRules_Set, METH_VARARGS, "IntegrationRules_Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, - { "IntegrationRules_SetOwnRules", _wrap_IntegrationRules_SetOwnRules, METH_VARARGS, "IntegrationRules_SetOwnRules(IntegrationRules self, int o)"}, + { "new_IntegrationRules", (PyCFunction)(void(*)(void))_wrap_new_IntegrationRules, METH_VARARGS|METH_KEYWORDS, "new_IntegrationRules(int Ref=0, int type=GaussLegendre) -> IntegrationRules"}, + { "IntegrationRules_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Get, METH_VARARGS|METH_KEYWORDS, "IntegrationRules_Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, + { "IntegrationRules_Set", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Set, METH_VARARGS|METH_KEYWORDS, "IntegrationRules_Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, + { "IntegrationRules_SetOwnRules", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_SetOwnRules, METH_VARARGS|METH_KEYWORDS, "IntegrationRules_SetOwnRules(IntegrationRules self, int o)"}, { "delete_IntegrationRules", _wrap_delete_IntegrationRules, METH_O, "delete_IntegrationRules(IntegrationRules self)"}, { "IntegrationRules_swigregister", IntegrationRules_swigregister, METH_O, NULL}, { "IntegrationRules_swiginit", IntegrationRules_swiginit, METH_VARARGS, NULL}, @@ -8715,7 +8497,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "IntegrationPointArray_UseDevice", _wrap_IntegrationPointArray_UseDevice, METH_O, "UseDevice(IntegrationPointArray self) -> bool"}, { "IntegrationPointArray_OwnsData", _wrap_IntegrationPointArray_OwnsData, METH_O, "OwnsData(IntegrationPointArray self) -> bool"}, - { "IntegrationPointArray_StealData", _wrap_IntegrationPointArray_StealData, METH_VARARGS, "StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, + { "IntegrationPointArray_StealData", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_StealData, METH_VARARGS|METH_KEYWORDS, "StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, { "IntegrationPointArray_LoseData", _wrap_IntegrationPointArray_LoseData, METH_O, "LoseData(IntegrationPointArray self)"}, { "IntegrationPointArray_MakeDataOwner", _wrap_IntegrationPointArray_MakeDataOwner, METH_O, "MakeDataOwner(IntegrationPointArray self)"}, { "IntegrationPointArray_Size", _wrap_IntegrationPointArray_Size, METH_O, "Size(IntegrationPointArray self) -> int"}, @@ -8725,25 +8507,25 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "IntegrationPointArray_Capacity", _wrap_IntegrationPointArray_Capacity, METH_O, "Capacity(IntegrationPointArray self) -> int"}, - { "IntegrationPointArray_Reserve", _wrap_IntegrationPointArray_Reserve, METH_VARARGS, "Reserve(IntegrationPointArray self, int capacity)"}, + { "IntegrationPointArray_Reserve", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Reserve, METH_VARARGS|METH_KEYWORDS, "Reserve(IntegrationPointArray self, int capacity)"}, { "IntegrationPointArray_Append", _wrap_IntegrationPointArray_Append, METH_VARARGS, "\n" "Append(IntegrationPointArray self, IntegrationPoint el) -> int\n" "Append(IntegrationPointArray self, IntegrationPoint els, int nels) -> int\n" "Append(IntegrationPointArray self, IntegrationPointArray els) -> int\n" ""}, - { "IntegrationPointArray_Prepend", _wrap_IntegrationPointArray_Prepend, METH_VARARGS, "Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, + { "IntegrationPointArray_Prepend", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Prepend, METH_VARARGS|METH_KEYWORDS, "Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, { "IntegrationPointArray_Last", _wrap_IntegrationPointArray_Last, METH_VARARGS, "\n" "Last(IntegrationPointArray self) -> IntegrationPoint\n" "Last(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_DeleteLast", _wrap_IntegrationPointArray_DeleteLast, METH_O, "DeleteLast(IntegrationPointArray self)"}, { "IntegrationPointArray_DeleteAll", _wrap_IntegrationPointArray_DeleteAll, METH_O, "DeleteAll(IntegrationPointArray self)"}, - { "IntegrationPointArray_Copy", _wrap_IntegrationPointArray_Copy, METH_VARARGS, "Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, + { "IntegrationPointArray_Copy", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, { "IntegrationPointArray_MakeRef", _wrap_IntegrationPointArray_MakeRef, METH_VARARGS, "\n" "MakeRef(IntegrationPointArray self, IntegrationPoint arg2, int arg3)\n" "MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" ""}, - { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, + { "IntegrationPointArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" "begin(IntegrationPointArray self) -> IntegrationPoint\n" "begin(IntegrationPointArray self) -> IntegrationPoint\n" @@ -8753,14 +8535,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "end(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "MemoryUsage(IntegrationPointArray self) -> long"}, - { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Read", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Read, METH_VARARGS|METH_KEYWORDS, "Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "HostRead(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_Write", _wrap_IntegrationPointArray_Write, METH_VARARGS, "Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Write", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Write, METH_VARARGS|METH_KEYWORDS, "Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostWrite", _wrap_IntegrationPointArray_HostWrite, METH_O, "HostWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_ReadWrite", _wrap_IntegrationPointArray_ReadWrite, METH_VARARGS, "ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostReadWrite", _wrap_IntegrationPointArray_HostReadWrite, METH_O, "HostReadWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray___setitem__", _wrap_IntegrationPointArray___setitem__, METH_VARARGS, "__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, - { "IntegrationPointArray___getitem__", _wrap_IntegrationPointArray___getitem__, METH_VARARGS, "__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, + { "IntegrationPointArray___setitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, + { "IntegrationPointArray___getitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, { "IntegrationPointArray_Assign", _wrap_IntegrationPointArray_Assign, METH_VARARGS, "\n" "Assign(IntegrationPointArray self, IntegrationPoint arg2)\n" "Assign(IntegrationPointArray self, IntegrationPoint a)\n" @@ -8778,13 +8560,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, - { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "Init(IntegrationPoint self, int const i)"}, - { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "Get(IntegrationPoint self, double * p, int const dim)"}, + { "IntegrationPoint_Init", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Init, METH_VARARGS|METH_KEYWORDS, "Init(IntegrationPoint self, int const i)"}, + { "IntegrationPoint_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Get, METH_VARARGS|METH_KEYWORDS, "Get(IntegrationPoint self, double * p, int const dim)"}, { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" "Set(IntegrationPoint self, double const * p, int const dim)\n" "Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w)\n" ""}, - { "IntegrationPoint_Set3w", _wrap_IntegrationPoint_Set3w, METH_VARARGS, "Set3w(IntegrationPoint self, double const * p)"}, + { "IntegrationPoint_Set3w", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Set3w, METH_VARARGS|METH_KEYWORDS, "Set3w(IntegrationPoint self, double const * p)"}, { "IntegrationPoint_Set3", _wrap_IntegrationPoint_Set3, METH_VARARGS, "\n" "Set3(IntegrationPoint self, double const x1, double const x2, double const x3)\n" "Set3(IntegrationPoint self, double const * p)\n" @@ -8812,7 +8594,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_IntegrationRule(IntegrationRule irx, IntegrationRule iry, IntegrationRule irz) -> IntegrationRule\n" ""}, { "IntegrationRule_GetOrder", _wrap_IntegrationRule_GetOrder, METH_O, "GetOrder(IntegrationRule self) -> int"}, - { "IntegrationRule_SetOrder", _wrap_IntegrationRule_SetOrder, METH_VARARGS, "SetOrder(IntegrationRule self, int const order)"}, + { "IntegrationRule_SetOrder", (PyCFunction)(void(*)(void))_wrap_IntegrationRule_SetOrder, METH_VARARGS|METH_KEYWORDS, "SetOrder(IntegrationRule self, int const order)"}, { "IntegrationRule_GetNPoints", _wrap_IntegrationRule_GetNPoints, METH_O, "GetNPoints(IntegrationRule self) -> int"}, { "IntegrationRule_IntPoint", _wrap_IntegrationRule_IntPoint, METH_VARARGS, "\n" "IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" @@ -8822,26 +8604,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_IntegrationRule", _wrap_delete_IntegrationRule, METH_O, "delete_IntegrationRule(IntegrationRule self)"}, { "IntegrationRule_swigregister", IntegrationRule_swigregister, METH_O, NULL}, { "IntegrationRule_swiginit", IntegrationRule_swiginit, METH_VARARGS, NULL}, - { "QuadratureFunctions1D_GaussLegendre", _wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS, "GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GaussLobatto", _wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS, "GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenUniform", _wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS, "OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_ClosedUniform", _wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS, "ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenHalfUniform", _wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS, "OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GivePolyPoints", _wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS, "GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, + { "QuadratureFunctions1D_GaussLegendre", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS|METH_KEYWORDS, "GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GaussLobatto", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS|METH_KEYWORDS, "GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS|METH_KEYWORDS, "OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_ClosedUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS|METH_KEYWORDS, "ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenHalfUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS|METH_KEYWORDS, "OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GivePolyPoints", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS|METH_KEYWORDS, "GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, { "new_QuadratureFunctions1D", _wrap_new_QuadratureFunctions1D, METH_NOARGS, "new_QuadratureFunctions1D() -> QuadratureFunctions1D"}, { "delete_QuadratureFunctions1D", _wrap_delete_QuadratureFunctions1D, METH_O, "delete_QuadratureFunctions1D(QuadratureFunctions1D self)"}, { "QuadratureFunctions1D_swigregister", QuadratureFunctions1D_swigregister, METH_O, NULL}, { "QuadratureFunctions1D_swiginit", QuadratureFunctions1D_swiginit, METH_VARARGS, NULL}, - { "Quadrature1D_CheckClosed", _wrap_Quadrature1D_CheckClosed, METH_O, "CheckClosed(int type) -> int"}, - { "Quadrature1D_CheckOpen", _wrap_Quadrature1D_CheckOpen, METH_O, "CheckOpen(int type) -> int"}, + { "Quadrature1D_CheckClosed", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckClosed, METH_VARARGS|METH_KEYWORDS, "CheckClosed(int type) -> int"}, + { "Quadrature1D_CheckOpen", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckOpen, METH_VARARGS|METH_KEYWORDS, "CheckOpen(int type) -> int"}, { "new_Quadrature1D", _wrap_new_Quadrature1D, METH_NOARGS, "new_Quadrature1D() -> Quadrature1D"}, { "delete_Quadrature1D", _wrap_delete_Quadrature1D, METH_O, "delete_Quadrature1D(Quadrature1D self)"}, { "Quadrature1D_swigregister", Quadrature1D_swigregister, METH_O, NULL}, { "Quadrature1D_swiginit", Quadrature1D_swiginit, METH_VARARGS, NULL}, - { "new_IntegrationRules", _wrap_new_IntegrationRules, METH_VARARGS, "IntegrationRules(int Ref=0, int type=GaussLegendre)"}, - { "IntegrationRules_Get", _wrap_IntegrationRules_Get, METH_VARARGS, "Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, - { "IntegrationRules_Set", _wrap_IntegrationRules_Set, METH_VARARGS, "Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, - { "IntegrationRules_SetOwnRules", _wrap_IntegrationRules_SetOwnRules, METH_VARARGS, "SetOwnRules(IntegrationRules self, int o)"}, + { "new_IntegrationRules", (PyCFunction)(void(*)(void))_wrap_new_IntegrationRules, METH_VARARGS|METH_KEYWORDS, "new_IntegrationRules(int Ref=0, int type=GaussLegendre) -> IntegrationRules"}, + { "IntegrationRules_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Get, METH_VARARGS|METH_KEYWORDS, "Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, + { "IntegrationRules_Set", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Set, METH_VARARGS|METH_KEYWORDS, "Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, + { "IntegrationRules_SetOwnRules", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_SetOwnRules, METH_VARARGS|METH_KEYWORDS, "SetOwnRules(IntegrationRules self, int o)"}, { "delete_IntegrationRules", _wrap_delete_IntegrationRules, METH_O, "delete_IntegrationRules(IntegrationRules self)"}, { "IntegrationRules_swigregister", IntegrationRules_swigregister, METH_O, NULL}, { "IntegrationRules_swiginit", IntegrationRules_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/io_stream_wrap.cxx b/mfem/_par/io_stream_wrap.cxx index 9b6364f4..1c114dad 100644 --- a/mfem/_par/io_stream_wrap.cxx +++ b/mfem/_par/io_stream_wrap.cxx @@ -3101,7 +3101,7 @@ SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; - int arg2 ; + int arg2 = (int) 8 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -3109,42 +3109,20 @@ SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ int ecode2 = 0 ; PyMFEM::wFILE *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_wFILE" "', argument " "1"" of type '" "char const *""'"); } arg1 = reinterpret_cast< char * >(buf1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_wFILE" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (PyMFEM::wFILE *)new PyMFEM::wFILE((char const *)arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyMFEM__wFILE, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return resultobj; -fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - PyMFEM::wFILE *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_wFILE" "', argument " "1"" of type '" "char const *""'"); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_wFILE" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - arg1 = reinterpret_cast< char * >(buf1); - result = (PyMFEM::wFILE *)new PyMFEM::wFILE((char const *)arg1); + result = (PyMFEM::wFILE *)new PyMFEM::wFILE((char const *)arg1,arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyMFEM__wFILE, SWIG_POINTER_NEW | 0 ); if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return resultobj; @@ -3165,19 +3143,14 @@ SWIGINTERN PyObject *_wrap_new_wFILE(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_wFILE__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_wFILE__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_wFILE__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); @@ -3192,8 +3165,7 @@ SWIGINTERN PyObject *_wrap_new_wFILE(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_wFILE'.\n" " Possible C/C++ prototypes are:\n" " PyMFEM::wFILE::wFILE()\n" - " PyMFEM::wFILE::wFILE(char const *,int)\n" - " PyMFEM::wFILE::wFILE(char const *)\n"); + " PyMFEM::wFILE::wFILE(char const *,int)\n"); return 0; } @@ -3267,7 +3239,7 @@ SWIGINTERN PyObject *_wrap_wFILE_getPrecision(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_wFILE_setPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_wFILE_setPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyMFEM::wFILE *arg1 = (PyMFEM::wFILE *) 0 ; int arg2 ; @@ -3275,15 +3247,19 @@ SWIGINTERN PyObject *_wrap_wFILE_setPrecision(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"precision", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "wFILE_setPrecision", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyMFEM__wFILE, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:wFILE_setPrecision", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PyMFEM__wFILE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wFILE_setPrecision" "', argument " "1"" of type '" "PyMFEM::wFILE *""'"); } arg1 = reinterpret_cast< PyMFEM::wFILE * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wFILE_setPrecision" "', argument " "2"" of type '" "int""'"); } @@ -3334,12 +3310,12 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" "wFILE()\n" - "wFILE(char const * filename, int precision=8)\n" + "new_wFILE(char const * filename, int precision=8) -> wFILE\n" ""}, { "wFILE_isSTDOUT", _wrap_wFILE_isSTDOUT, METH_O, "wFILE_isSTDOUT(wFILE self) -> int"}, { "wFILE_getFilename", _wrap_wFILE_getFilename, METH_O, "wFILE_getFilename(wFILE self) -> char *"}, { "wFILE_getPrecision", _wrap_wFILE_getPrecision, METH_O, "wFILE_getPrecision(wFILE self) -> int"}, - { "wFILE_setPrecision", _wrap_wFILE_setPrecision, METH_VARARGS, "wFILE_setPrecision(wFILE self, int precision)"}, + { "wFILE_setPrecision", (PyCFunction)(void(*)(void))_wrap_wFILE_setPrecision, METH_VARARGS|METH_KEYWORDS, "wFILE_setPrecision(wFILE self, int precision)"}, { "delete_wFILE", _wrap_delete_wFILE, METH_O, "delete_wFILE(wFILE self)"}, { "wFILE_swigregister", wFILE_swigregister, METH_O, NULL}, { "wFILE_swiginit", wFILE_swiginit, METH_VARARGS, NULL}, @@ -3351,12 +3327,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" "wFILE()\n" - "wFILE(char const * filename, int precision=8)\n" + "new_wFILE(char const * filename, int precision=8) -> wFILE\n" ""}, { "wFILE_isSTDOUT", _wrap_wFILE_isSTDOUT, METH_O, "isSTDOUT(wFILE self) -> int"}, { "wFILE_getFilename", _wrap_wFILE_getFilename, METH_O, "getFilename(wFILE self) -> char *"}, { "wFILE_getPrecision", _wrap_wFILE_getPrecision, METH_O, "getPrecision(wFILE self) -> int"}, - { "wFILE_setPrecision", _wrap_wFILE_setPrecision, METH_VARARGS, "setPrecision(wFILE self, int precision)"}, + { "wFILE_setPrecision", (PyCFunction)(void(*)(void))_wrap_wFILE_setPrecision, METH_VARARGS|METH_KEYWORDS, "setPrecision(wFILE self, int precision)"}, { "delete_wFILE", _wrap_delete_wFILE, METH_O, "delete_wFILE(wFILE self)"}, { "wFILE_swigregister", wFILE_swigregister, METH_O, NULL}, { "wFILE_swiginit", wFILE_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/linearform_wrap.cxx b/mfem/_par/linearform_wrap.cxx index 5194c500..0ef18b14 100644 --- a/mfem/_par/linearform_wrap.cxx +++ b/mfem/_par/linearform_wrap.cxx @@ -3540,7 +3540,7 @@ SWIGINTERN PyObject *_wrap_LinearForm_FESpace(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearForm *arg1 = (mfem::LinearForm *) 0 ; mfem::LinearFormIntegrator *arg2 = (mfem::LinearFormIntegrator *) 0 ; @@ -3548,15 +3548,19 @@ SWIGINTERN PyObject *_wrap_LinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"lfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::LinearForm *""'"); } arg1 = reinterpret_cast< mfem::LinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::LinearFormIntegrator *""'"); } @@ -4234,7 +4238,7 @@ SWIGINTERN PyObject *_wrap_LinearForm_Update(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearForm *arg1 = (mfem::LinearForm *) 0 ; mfem::GridFunction *arg2 = 0 ; @@ -4242,16 +4246,20 @@ SWIGINTERN PyObject *_wrap_LinearForm___call__(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "LinearForm___call__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearForm___call__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearForm___call__" "', argument " "1"" of type '" "mfem::LinearForm const *""'"); } arg1 = reinterpret_cast< mfem::LinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearForm___call__" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } @@ -4328,7 +4336,7 @@ static PyMethodDef SwigMethods[] = { "LinearForm_FESpace(LinearForm self) -> FiniteElementSpace\n" "LinearForm_FESpace(LinearForm self) -> FiniteElementSpace\n" ""}, - { "LinearForm_AddDomainIntegrator", _wrap_LinearForm_AddDomainIntegrator, METH_VARARGS, "LinearForm_AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, + { "LinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_LinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "LinearForm_AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, { "LinearForm_AddBoundaryIntegrator", _wrap_LinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "LinearForm_AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" "LinearForm_AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" @@ -4349,7 +4357,7 @@ static PyMethodDef SwigMethods[] = { "LinearForm_Update(LinearForm self, FiniteElementSpace f)\n" "LinearForm_Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset)\n" ""}, - { "LinearForm___call__", _wrap_LinearForm___call__, METH_VARARGS, "LinearForm___call__(LinearForm self, GridFunction gf) -> double"}, + { "LinearForm___call__", (PyCFunction)(void(*)(void))_wrap_LinearForm___call__, METH_VARARGS|METH_KEYWORDS, "LinearForm___call__(LinearForm self, GridFunction gf) -> double"}, { "delete_LinearForm", _wrap_delete_LinearForm, METH_O, "delete_LinearForm(LinearForm self)"}, { "LinearForm_swigregister", LinearForm_swigregister, METH_O, NULL}, { "LinearForm_swiginit", LinearForm_swiginit, METH_VARARGS, NULL}, @@ -4370,7 +4378,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FESpace(LinearForm self) -> FiniteElementSpace\n" "FESpace(LinearForm self) -> FiniteElementSpace\n" ""}, - { "LinearForm_AddDomainIntegrator", _wrap_LinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, + { "LinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_LinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, { "LinearForm_AddBoundaryIntegrator", _wrap_LinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" @@ -4391,7 +4399,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Update(LinearForm self, FiniteElementSpace f)\n" "Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset)\n" ""}, - { "LinearForm___call__", _wrap_LinearForm___call__, METH_VARARGS, "__call__(LinearForm self, GridFunction gf) -> double"}, + { "LinearForm___call__", (PyCFunction)(void(*)(void))_wrap_LinearForm___call__, METH_VARARGS|METH_KEYWORDS, "__call__(LinearForm self, GridFunction gf) -> double"}, { "delete_LinearForm", _wrap_delete_LinearForm, METH_O, "delete_LinearForm(LinearForm self)"}, { "LinearForm_swigregister", LinearForm_swigregister, METH_O, NULL}, { "LinearForm_swiginit", LinearForm_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/lininteg_wrap.cxx b/mfem/_par/lininteg_wrap.cxx index a75c2383..89f138d7 100644 --- a/mfem/_par/lininteg_wrap.cxx +++ b/mfem/_par/lininteg_wrap.cxx @@ -3600,7 +3600,7 @@ SWIGINTERN PyObject *_wrap_LinearFormIntegrator_AssembleRHSElementVect(PyObject } -SWIGINTERN PyObject *_wrap_LinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFormIntegrator *arg1 = (mfem::LinearFormIntegrator *) 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -3608,15 +3608,19 @@ SWIGINTERN PyObject *_wrap_LinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LinearFormIntegrator_SetIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearFormIntegrator_SetIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFormIntegrator_SetIntRule" "', argument " "1"" of type '" "mfem::LinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::LinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearFormIntegrator_SetIntRule" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } @@ -3752,7 +3756,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_IsDelta(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaLFIntegrator *arg1 = (mfem::DeltaLFIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3760,15 +3764,19 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSED int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaLFIntegrator_GetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaLFIntegrator_GetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaLFIntegrator_GetDeltaCenter" "', argument " "1"" of type '" "mfem::DeltaLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DeltaLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaLFIntegrator_GetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3796,7 +3804,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaLFIntegrator *arg1 = (mfem::DeltaLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -3810,15 +3818,21 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DeltaLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::DeltaLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DeltaLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -3826,7 +3840,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -3834,7 +3848,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -3906,13 +3920,13 @@ SWIGINTERN PyObject *DeltaLFIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 2 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::DomainLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -3921,100 +3935,25 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1,arg2,arg3); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DomainLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DomainLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1,arg2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DomainLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DomainLFIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1); + result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4032,7 +3971,7 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -4084,35 +4023,15 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator(PyObject *self, PyObject *args if (!(argc = SWIG_Python_UnpackTuple(args, "new_DomainLFIntegrator", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_DomainLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_DomainLFIntegrator__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_new_DomainLFIntegrator__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4122,25 +4041,9 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator(PyObject *self, PyObject *args } } if (_v) { - return _wrap_new_DomainLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_DomainLFIntegrator__SWIG_0(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4155,13 +4058,25 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator(PyObject *self, PyObject *args } } } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_DomainLFIntegrator__SWIG_1(self, argc, argv); + } + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DomainLFIntegrator'.\n" " Possible C/C++ prototypes are:\n" " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &,int,int)\n" - " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &,int)\n" - " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &)\n" " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n"); return 0; } @@ -4232,7 +4147,7 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleRHSElementVect__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DomainLFIntegrator *arg1 = (mfem::DomainLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4246,15 +4161,21 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DomainLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DomainLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DomainLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DomainLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::DomainLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DomainLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4262,7 +4183,7 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4270,7 +4191,7 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -4472,17 +4393,23 @@ SWIGINTERN PyObject *DomainLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 1 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"QG", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_BoundaryLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -4490,17 +4417,21 @@ SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { @@ -4522,32 +4453,54 @@ SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - int arg2 ; + mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::BoundaryLFIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::BoundaryLFIntegrator *)new mfem::BoundaryLFIntegrator(*arg1,arg2); + (arg1)->AssembleRHSElementVect((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4558,32 +4511,61 @@ SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_1(PyObject *SWIGUNUSED // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryLFIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FaceElementTransformations *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::BoundaryLFIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); + } + arg3 = reinterpret_cast< mfem::FaceElementTransformations * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::BoundaryLFIntegrator *)new mfem::BoundaryLFIntegrator(*arg1); + (arg1)->AssembleRHSElementVect((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4594,222 +4576,16 @@ SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_2(PyObject *SWIGUNUSED // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryLFIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BoundaryLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BoundaryLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BoundaryLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BoundaryLFIntegrator::BoundaryLFIntegrator(mfem::Coefficient &,int,int)\n" - " mfem::BoundaryLFIntegrator::BoundaryLFIntegrator(mfem::Coefficient &,int)\n" - " mfem::BoundaryLFIntegrator::BoundaryLFIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->AssembleRHSElementVect((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FaceElementTransformations *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); - } - arg3 = reinterpret_cast< mfem::FaceElementTransformations * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->AssembleRHSElementVect((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[5] = { 0 }; @@ -4916,17 +4692,23 @@ SWIGINTERN PyObject *BoundaryLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 1 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"QG", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryNormalLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_BoundaryNormalLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -4934,100 +4716,25 @@ SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_0(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1,arg2,arg3); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryNormalLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1,arg2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryNormalLFIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1); + result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5045,82 +4752,6 @@ SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_2(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BoundaryNormalLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BoundaryNormalLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryNormalLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryNormalLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BoundaryNormalLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BoundaryNormalLFIntegrator::BoundaryNormalLFIntegrator(mfem::VectorCoefficient &,int,int)\n" - " mfem::BoundaryNormalLFIntegrator::BoundaryNormalLFIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::BoundaryNormalLFIntegrator::BoundaryNormalLFIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BoundaryNormalLFIntegrator *arg1 = (mfem::BoundaryNormalLFIntegrator *) 0 ; @@ -5342,126 +4973,41 @@ SWIGINTERN PyObject *_wrap_delete_BoundaryNormalLFIntegrator(PyObject *SWIGUNUSE // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *BoundaryNormalLFIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BoundaryNormalLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryTangentialLFIntegrator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryTangentialLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *BoundaryNormalLFIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BoundaryNormalLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; + int arg2 = (int) 1 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"QG", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryTangentialLFIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_BoundaryTangentialLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -5469,9 +5015,25 @@ SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1); + result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5489,82 +5051,6 @@ SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(PyObject * } -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BoundaryTangentialLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryTangentialLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryTangentialLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BoundaryTangentialLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BoundaryTangentialLFIntegrator::BoundaryTangentialLFIntegrator(mfem::VectorCoefficient &,int,int)\n" - " mfem::BoundaryTangentialLFIntegrator::BoundaryTangentialLFIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::BoundaryTangentialLFIntegrator::BoundaryTangentialLFIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BoundaryTangentialLFIntegrator *arg1 = (mfem::BoundaryTangentialLFIntegrator *) 0 ; @@ -5804,17 +5290,19 @@ SWIGINTERN PyObject *BoundaryTangentialLFIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"QF", NULL + }; mfem::VectorDomainLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorDomainLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDomainLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -5907,7 +5395,7 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleRHSElementVect__SWIG } -SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDomainLFIntegrator *arg1 = (mfem::VectorDomainLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5921,15 +5409,21 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyO int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDomainLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDomainLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorDomainLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDomainLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::VectorDomainLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDomainLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5937,7 +5431,7 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5945,7 +5439,7 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -6147,17 +5641,19 @@ SWIGINTERN PyObject *VectorDomainLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorBoundaryLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorBoundaryLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"QG", NULL + }; mfem::VectorBoundaryLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorBoundaryLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -6424,17 +5920,19 @@ SWIGINTERN PyObject *VectorBoundaryLFIntegrator_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"F", NULL + }; mfem::VectorFEDomainLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorFEDomainLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEDomainLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -6527,7 +6025,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect__SW } -SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEDomainLFIntegrator *arg1 = (mfem::VectorFEDomainLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6541,15 +6039,21 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEDomainLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::VectorFEDomainLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEDomainLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6557,7 +6061,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6565,7 +6069,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -6767,21 +6271,27 @@ SWIGINTERN PyObject *VectorFEDomainLFIntegrator_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - double arg2 ; - mfem::IntegrationRule *arg3 = (mfem::IntegrationRule *) 0 ; + double arg2 = (double) 1.0 ; + mfem::IntegrationRule *arg3 = (mfem::IntegrationRule *) NULL ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"f", (char *)"s", (char *)"ir", NULL + }; mfem::VectorBoundaryFluxLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_VectorBoundaryFluxLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -6789,99 +6299,23 @@ SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "3"" of type '" "mfem::IntegrationRule const *""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - { - try { - result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1,arg2,(mfem::IntegrationRule const *)arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::VectorBoundaryFluxLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1,arg2); + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "3"" of type '" "mfem::IntegrationRule const *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorBoundaryFluxLFIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1); + result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1,arg2,(mfem::IntegrationRule const *)arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6899,69 +6333,6 @@ SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_2(PyObject * } -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorBoundaryFluxLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorBoundaryFluxLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorBoundaryFluxLFIntegrator::VectorBoundaryFluxLFIntegrator(mfem::Coefficient &,double,mfem::IntegrationRule const *)\n" - " mfem::VectorBoundaryFluxLFIntegrator::VectorBoundaryFluxLFIntegrator(mfem::Coefficient &,double)\n" - " mfem::VectorBoundaryFluxLFIntegrator::VectorBoundaryFluxLFIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorBoundaryFluxLFIntegrator *arg1 = (mfem::VectorBoundaryFluxLFIntegrator *) 0 ; @@ -7531,17 +6902,19 @@ SWIGINTERN PyObject *VectorFEBoundaryFluxLFIntegrator_swiginit(PyObject *SWIGUNU return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryTangentLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryTangentLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"QG", NULL + }; mfem::VectorFEBoundaryTangentLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorFEBoundaryTangentLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEBoundaryTangentLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -7808,7 +7181,7 @@ SWIGINTERN PyObject *VectorFEBoundaryTangentLFIntegrator_swiginit(PyObject *SWIG return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -7822,11 +7195,17 @@ SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(s int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"_f", (char *)"_u", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryFlowIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_BoundaryFlowIntegrator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_BoundaryFlowIntegrator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryFlowIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -7834,7 +7213,7 @@ SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryFlowIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BoundaryFlowIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -7842,12 +7221,12 @@ SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryFlowIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BoundaryFlowIntegrator" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BoundaryFlowIntegrator" "', argument " "4"" of type '" "double""'"); } @@ -8620,7 +7999,7 @@ SWIGINTERN PyObject *DGDirichletLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; @@ -8637,11 +8016,18 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU int ecode4 = 0 ; double val5 ; int ecode5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"uD_", (char *)"lambda_", (char *)"mu_", (char *)"alpha_", (char *)"kappa_", NULL + }; mfem::DGElasticityDirichletLFIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DGElasticityDirichletLFIntegrator", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:new_DGElasticityDirichletLFIntegrator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -8649,7 +8035,7 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } @@ -8657,7 +8043,7 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } @@ -8665,12 +8051,12 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_double(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "5"" of type '" "double""'"); } @@ -8941,20 +8327,20 @@ static PyMethodDef SwigMethods[] = { "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" ""}, - { "LinearFormIntegrator_SetIntRule", _wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS, "LinearFormIntegrator_SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, + { "LinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "LinearFormIntegrator_SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, { "LinearFormIntegrator_GetIntRule", _wrap_LinearFormIntegrator_GetIntRule, METH_O, "LinearFormIntegrator_GetIntRule(LinearFormIntegrator self) -> IntegrationRule"}, { "delete_LinearFormIntegrator", _wrap_delete_LinearFormIntegrator, METH_O, "delete_LinearFormIntegrator(LinearFormIntegrator self)"}, { "LinearFormIntegrator_swigregister", LinearFormIntegrator_swigregister, METH_O, NULL}, { "DeltaLFIntegrator_IsDelta", _wrap_DeltaLFIntegrator_IsDelta, METH_O, "DeltaLFIntegrator_IsDelta(DeltaLFIntegrator self) -> bool"}, - { "DeltaLFIntegrator_GetDeltaCenter", _wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS, "DeltaLFIntegrator_GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, - { "DeltaLFIntegrator_AssembleDeltaElementVect", _wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "DeltaLFIntegrator_AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DeltaLFIntegrator_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "DeltaLFIntegrator_GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, + { "DeltaLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "DeltaLFIntegrator_AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "delete_DeltaLFIntegrator", _wrap_delete_DeltaLFIntegrator, METH_O, "delete_DeltaLFIntegrator(DeltaLFIntegrator self)"}, { "DeltaLFIntegrator_swigregister", DeltaLFIntegrator_swigregister, METH_O, NULL}, { "new_DomainLFIntegrator", _wrap_new_DomainLFIntegrator, METH_VARARGS, "\n" "DomainLFIntegrator(Coefficient QF, int a=2, int b=0)\n" "new_DomainLFIntegrator(Coefficient QF, IntegrationRule ir) -> DomainLFIntegrator\n" ""}, - { "DomainLFIntegrator_AssembleDeltaElementVect", _wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "DomainLFIntegrator_AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "DomainLFIntegrator_AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "DomainLFIntegrator_AssembleRHSElementVect", _wrap_DomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "DomainLFIntegrator_AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "DomainLFIntegrator_AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -8962,7 +8348,7 @@ static PyMethodDef SwigMethods[] = { { "delete_DomainLFIntegrator", _wrap_delete_DomainLFIntegrator, METH_O, "delete_DomainLFIntegrator(DomainLFIntegrator self)"}, { "DomainLFIntegrator_swigregister", DomainLFIntegrator_swigregister, METH_O, NULL}, { "DomainLFIntegrator_swiginit", DomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryLFIntegrator", _wrap_new_BoundaryLFIntegrator, METH_VARARGS, "BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1)"}, + { "new_BoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1) -> BoundaryLFIntegrator"}, { "BoundaryLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryLFIntegrator_AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryLFIntegrator_AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -8970,7 +8356,7 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryLFIntegrator", _wrap_delete_BoundaryLFIntegrator, METH_O, "delete_BoundaryLFIntegrator(BoundaryLFIntegrator self)"}, { "BoundaryLFIntegrator_swigregister", BoundaryLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryLFIntegrator_swiginit", BoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryNormalLFIntegrator", _wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS, "BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryNormalLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryNormalLFIntegrator"}, { "BoundaryNormalLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryNormalLFIntegrator_AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryNormalLFIntegrator_AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -8978,7 +8364,7 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryNormalLFIntegrator", _wrap_delete_BoundaryNormalLFIntegrator, METH_O, "delete_BoundaryNormalLFIntegrator(BoundaryNormalLFIntegrator self)"}, { "BoundaryNormalLFIntegrator_swigregister", BoundaryNormalLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryNormalLFIntegrator_swiginit", BoundaryNormalLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryTangentialLFIntegrator", _wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS, "BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryTangentialLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryTangentialLFIntegrator"}, { "BoundaryTangentialLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryTangentialLFIntegrator_AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryTangentialLFIntegrator_AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -8986,8 +8372,8 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryTangentialLFIntegrator", _wrap_delete_BoundaryTangentialLFIntegrator, METH_O, "delete_BoundaryTangentialLFIntegrator(BoundaryTangentialLFIntegrator self)"}, { "BoundaryTangentialLFIntegrator_swigregister", BoundaryTangentialLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryTangentialLFIntegrator_swiginit", BoundaryTangentialLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorDomainLFIntegrator", _wrap_new_VectorDomainLFIntegrator, METH_O, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, - { "VectorDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "VectorDomainLFIntegrator_AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, + { "VectorDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "VectorDomainLFIntegrator_AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorDomainLFIntegrator_AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorDomainLFIntegrator_AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -8995,7 +8381,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorDomainLFIntegrator", _wrap_delete_VectorDomainLFIntegrator, METH_O, "delete_VectorDomainLFIntegrator(VectorDomainLFIntegrator self)"}, { "VectorDomainLFIntegrator_swigregister", VectorDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorDomainLFIntegrator_swiginit", VectorDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryLFIntegrator", _wrap_new_VectorBoundaryLFIntegrator, METH_O, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, + { "new_VectorBoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, { "VectorBoundaryLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorBoundaryLFIntegrator_AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorBoundaryLFIntegrator_AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9003,8 +8389,8 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorBoundaryLFIntegrator", _wrap_delete_VectorBoundaryLFIntegrator, METH_O, "delete_VectorBoundaryLFIntegrator(VectorBoundaryLFIntegrator self)"}, { "VectorBoundaryLFIntegrator_swigregister", VectorBoundaryLFIntegrator_swigregister, METH_O, NULL}, { "VectorBoundaryLFIntegrator_swiginit", VectorBoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEDomainLFIntegrator", _wrap_new_VectorFEDomainLFIntegrator, METH_O, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, - { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "VectorFEDomainLFIntegrator_AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorFEDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, + { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "VectorFEDomainLFIntegrator_AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorFEDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorFEDomainLFIntegrator_AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorFEDomainLFIntegrator_AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9012,7 +8398,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFEDomainLFIntegrator", _wrap_delete_VectorFEDomainLFIntegrator, METH_O, "delete_VectorFEDomainLFIntegrator(VectorFEDomainLFIntegrator self)"}, { "VectorFEDomainLFIntegrator_swigregister", VectorFEDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEDomainLFIntegrator_swiginit", VectorFEDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryFluxLFIntegrator", _wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS, "VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None)"}, + { "new_VectorBoundaryFluxLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None) -> VectorBoundaryFluxLFIntegrator"}, { "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9031,7 +8417,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFEBoundaryFluxLFIntegrator", _wrap_delete_VectorFEBoundaryFluxLFIntegrator, METH_O, "delete_VectorFEBoundaryFluxLFIntegrator(VectorFEBoundaryFluxLFIntegrator self)"}, { "VectorFEBoundaryFluxLFIntegrator_swigregister", VectorFEBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryFluxLFIntegrator_swiginit", VectorFEBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEBoundaryTangentLFIntegrator", _wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_O, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, + { "new_VectorFEBoundaryTangentLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, { "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9039,7 +8425,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFEBoundaryTangentLFIntegrator", _wrap_delete_VectorFEBoundaryTangentLFIntegrator, METH_O, "delete_VectorFEBoundaryTangentLFIntegrator(VectorFEBoundaryTangentLFIntegrator self)"}, { "VectorFEBoundaryTangentLFIntegrator_swigregister", VectorFEBoundaryTangentLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryTangentLFIntegrator_swiginit", VectorFEBoundaryTangentLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryFlowIntegrator", _wrap_new_BoundaryFlowIntegrator, METH_VARARGS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, + { "new_BoundaryFlowIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryFlowIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, { "BoundaryFlowIntegrator_AssembleRHSElementVect", _wrap_BoundaryFlowIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryFlowIntegrator_AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryFlowIntegrator_AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9059,7 +8445,7 @@ static PyMethodDef SwigMethods[] = { { "delete_DGDirichletLFIntegrator", _wrap_delete_DGDirichletLFIntegrator, METH_O, "delete_DGDirichletLFIntegrator(DGDirichletLFIntegrator self)"}, { "DGDirichletLFIntegrator_swigregister", DGDirichletLFIntegrator_swigregister, METH_O, NULL}, { "DGDirichletLFIntegrator_swiginit", DGDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DGElasticityDirichletLFIntegrator", _wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, + { "new_DGElasticityDirichletLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, { "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGElasticityDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9077,20 +8463,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" ""}, - { "LinearFormIntegrator_SetIntRule", _wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, + { "LinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, { "LinearFormIntegrator_GetIntRule", _wrap_LinearFormIntegrator_GetIntRule, METH_O, "GetIntRule(LinearFormIntegrator self) -> IntegrationRule"}, { "delete_LinearFormIntegrator", _wrap_delete_LinearFormIntegrator, METH_O, "delete_LinearFormIntegrator(LinearFormIntegrator self)"}, { "LinearFormIntegrator_swigregister", LinearFormIntegrator_swigregister, METH_O, NULL}, { "DeltaLFIntegrator_IsDelta", _wrap_DeltaLFIntegrator_IsDelta, METH_O, "IsDelta(DeltaLFIntegrator self) -> bool"}, - { "DeltaLFIntegrator_GetDeltaCenter", _wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, - { "DeltaLFIntegrator_AssembleDeltaElementVect", _wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DeltaLFIntegrator_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, + { "DeltaLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "delete_DeltaLFIntegrator", _wrap_delete_DeltaLFIntegrator, METH_O, "delete_DeltaLFIntegrator(DeltaLFIntegrator self)"}, { "DeltaLFIntegrator_swigregister", DeltaLFIntegrator_swigregister, METH_O, NULL}, { "new_DomainLFIntegrator", _wrap_new_DomainLFIntegrator, METH_VARARGS, "\n" "DomainLFIntegrator(Coefficient QF, int a=2, int b=0)\n" "new_DomainLFIntegrator(Coefficient QF, IntegrationRule ir) -> DomainLFIntegrator\n" ""}, - { "DomainLFIntegrator_AssembleDeltaElementVect", _wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "DomainLFIntegrator_AssembleRHSElementVect", _wrap_DomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9098,7 +8484,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_DomainLFIntegrator", _wrap_delete_DomainLFIntegrator, METH_O, "delete_DomainLFIntegrator(DomainLFIntegrator self)"}, { "DomainLFIntegrator_swigregister", DomainLFIntegrator_swigregister, METH_O, NULL}, { "DomainLFIntegrator_swiginit", DomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryLFIntegrator", _wrap_new_BoundaryLFIntegrator, METH_VARARGS, "BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1)"}, + { "new_BoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1) -> BoundaryLFIntegrator"}, { "BoundaryLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9106,7 +8492,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryLFIntegrator", _wrap_delete_BoundaryLFIntegrator, METH_O, "delete_BoundaryLFIntegrator(BoundaryLFIntegrator self)"}, { "BoundaryLFIntegrator_swigregister", BoundaryLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryLFIntegrator_swiginit", BoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryNormalLFIntegrator", _wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS, "BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryNormalLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryNormalLFIntegrator"}, { "BoundaryNormalLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9114,7 +8500,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryNormalLFIntegrator", _wrap_delete_BoundaryNormalLFIntegrator, METH_O, "delete_BoundaryNormalLFIntegrator(BoundaryNormalLFIntegrator self)"}, { "BoundaryNormalLFIntegrator_swigregister", BoundaryNormalLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryNormalLFIntegrator_swiginit", BoundaryNormalLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryTangentialLFIntegrator", _wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS, "BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryTangentialLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryTangentialLFIntegrator"}, { "BoundaryTangentialLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9122,8 +8508,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryTangentialLFIntegrator", _wrap_delete_BoundaryTangentialLFIntegrator, METH_O, "delete_BoundaryTangentialLFIntegrator(BoundaryTangentialLFIntegrator self)"}, { "BoundaryTangentialLFIntegrator_swigregister", BoundaryTangentialLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryTangentialLFIntegrator_swiginit", BoundaryTangentialLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorDomainLFIntegrator", _wrap_new_VectorDomainLFIntegrator, METH_O, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, - { "VectorDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, + { "VectorDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9131,7 +8517,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorDomainLFIntegrator", _wrap_delete_VectorDomainLFIntegrator, METH_O, "delete_VectorDomainLFIntegrator(VectorDomainLFIntegrator self)"}, { "VectorDomainLFIntegrator_swigregister", VectorDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorDomainLFIntegrator_swiginit", VectorDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryLFIntegrator", _wrap_new_VectorBoundaryLFIntegrator, METH_O, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, + { "new_VectorBoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, { "VectorBoundaryLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9139,8 +8525,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorBoundaryLFIntegrator", _wrap_delete_VectorBoundaryLFIntegrator, METH_O, "delete_VectorBoundaryLFIntegrator(VectorBoundaryLFIntegrator self)"}, { "VectorBoundaryLFIntegrator_swigregister", VectorBoundaryLFIntegrator_swigregister, METH_O, NULL}, { "VectorBoundaryLFIntegrator_swiginit", VectorBoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEDomainLFIntegrator", _wrap_new_VectorFEDomainLFIntegrator, METH_O, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, - { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorFEDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, + { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorFEDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9148,7 +8534,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFEDomainLFIntegrator", _wrap_delete_VectorFEDomainLFIntegrator, METH_O, "delete_VectorFEDomainLFIntegrator(VectorFEDomainLFIntegrator self)"}, { "VectorFEDomainLFIntegrator_swigregister", VectorFEDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEDomainLFIntegrator_swiginit", VectorFEDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryFluxLFIntegrator", _wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS, "VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None)"}, + { "new_VectorBoundaryFluxLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None) -> VectorBoundaryFluxLFIntegrator"}, { "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9167,7 +8553,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFEBoundaryFluxLFIntegrator", _wrap_delete_VectorFEBoundaryFluxLFIntegrator, METH_O, "delete_VectorFEBoundaryFluxLFIntegrator(VectorFEBoundaryFluxLFIntegrator self)"}, { "VectorFEBoundaryFluxLFIntegrator_swigregister", VectorFEBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryFluxLFIntegrator_swiginit", VectorFEBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEBoundaryTangentLFIntegrator", _wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_O, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, + { "new_VectorFEBoundaryTangentLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, { "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9175,7 +8561,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFEBoundaryTangentLFIntegrator", _wrap_delete_VectorFEBoundaryTangentLFIntegrator, METH_O, "delete_VectorFEBoundaryTangentLFIntegrator(VectorFEBoundaryTangentLFIntegrator self)"}, { "VectorFEBoundaryTangentLFIntegrator_swigregister", VectorFEBoundaryTangentLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryTangentLFIntegrator_swiginit", VectorFEBoundaryTangentLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryFlowIntegrator", _wrap_new_BoundaryFlowIntegrator, METH_VARARGS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, + { "new_BoundaryFlowIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryFlowIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, { "BoundaryFlowIntegrator_AssembleRHSElementVect", _wrap_BoundaryFlowIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9195,7 +8581,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_DGDirichletLFIntegrator", _wrap_delete_DGDirichletLFIntegrator, METH_O, "delete_DGDirichletLFIntegrator(DGDirichletLFIntegrator self)"}, { "DGDirichletLFIntegrator_swigregister", DGDirichletLFIntegrator_swigregister, METH_O, NULL}, { "DGDirichletLFIntegrator_swiginit", DGDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DGElasticityDirichletLFIntegrator", _wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, + { "new_DGElasticityDirichletLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, { "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGElasticityDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" diff --git a/mfem/_par/matrix_wrap.cxx b/mfem/_par/matrix_wrap.cxx index e44233df..72242530 100644 --- a/mfem/_par/matrix_wrap.cxx +++ b/mfem/_par/matrix_wrap.cxx @@ -3339,7 +3339,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Matrix_Print__SWIG_3(mfem::Matrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Matrix_Print__SWIG_1(mfem::Matrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3647,25 +3647,29 @@ SWIGINTERN PyObject *_wrap_Matrix_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Matrix_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Matrix_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Matrix_Finalize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Matrix_Finalize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Finalize" "', argument " "1"" of type '" "mfem::Matrix *""'"); } arg1 = reinterpret_cast< mfem::Matrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3690,103 +3694,48 @@ SWIGINTERN PyObject *_wrap_Matrix_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObj SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix const *""'"); } arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::Matrix const *)arg1)->Print(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix const *""'"); - } - arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } { try { - ((mfem::Matrix const *)arg1)->Print(*arg2); + ((mfem::Matrix const *)arg1)->Print(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3814,38 +3763,6 @@ SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix const *""'"); - } - arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - { - try { - ((mfem::Matrix const *)arg1)->Print(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_delete_Matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; @@ -3880,18 +3797,18 @@ SWIGINTERN PyObject *_wrap_delete_Matrix(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix *""'"); @@ -3902,58 +3819,17 @@ SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Matrix_Print__SWIG_3(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix *""'"); - } - arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Matrix_Print__SWIG_3(arg1,(char const *)arg2); + mfem_Matrix_Print__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3981,34 +3857,15 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Matrix_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Matrix_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Matrix_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_Matrix_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -4019,19 +3876,9 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Matrix_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Matrix_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4041,27 +3888,23 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Matrix_Print__SWIG_3(self, argc, argv); + return _wrap_Matrix_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Matrix_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4071,7 +3914,7 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Matrix_Print__SWIG_0(self, argc, argv); + return _wrap_Matrix_Print__SWIG_1(self, argc, argv); } } } @@ -4081,10 +3924,7 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Matrix_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Matrix::Print(std::ostream &,int) const\n" - " mfem::Matrix::Print(std::ostream &) const\n" - " mfem::Matrix::Print() const\n" - " mfem::Matrix::Print(char const *,int)\n" - " mfem::Matrix::Print(char const *)\n"); + " mfem::Matrix::Print(char const *,int)\n"); return 0; } @@ -4172,7 +4012,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_NumNonZeroElems(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; int arg2 ; @@ -4184,22 +4024,28 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_GetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AbstractSparseMatrix_GetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_GetRow" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -4207,7 +4053,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractSparseMatrix_GetRow" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -4235,61 +4081,36 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - double arg2 ; + double arg2 = (double) (double)1e-12 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"threshold", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:AbstractSparseMatrix_EliminateZeroRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->EliminateZeroRows(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); { try { - (arg1)->EliminateZeroRows(); + (arg1)->EliminateZeroRows(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4307,49 +4128,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_EliminateZeroRows", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AbstractSparseMatrix_EliminateZeroRows'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::AbstractSparseMatrix::EliminateZeroRows(double const)\n" - " mfem::AbstractSparseMatrix::EliminateZeroRows()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4360,15 +4139,20 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AbstractSparseMatrix_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_Mult" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4376,7 +4160,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4404,12 +4188,12 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1. ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4418,14 +4202,21 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:AbstractSparseMatrix_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4433,7 +4224,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4441,11 +4232,13 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { ((mfem::AbstractSparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); @@ -4466,7 +4259,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4477,129 +4270,20 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_1(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::AbstractSparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_AbstractSparseMatrix_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_AbstractSparseMatrix_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AbstractSparseMatrix_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::AbstractSparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::AbstractSparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AbstractSparseMatrix_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4607,7 +4291,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4635,12 +4319,12 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1. ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4649,14 +4333,21 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObjec int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:AbstractSparseMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4664,7 +4355,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4672,68 +4363,16 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::AbstractSparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::AbstractSparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::AbstractSparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4751,66 +4390,6 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AbstractSparseMatrix_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::AbstractSparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::AbstractSparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_AbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; @@ -4861,7 +4440,7 @@ static PyMethodDef SwigMethods[] = { "Matrix_Elem(Matrix self, int i, int j) -> double const &\n" ""}, { "Matrix_Inverse", _wrap_Matrix_Inverse, METH_O, "Matrix_Inverse(Matrix self) -> MatrixInverse"}, - { "Matrix_Finalize", _wrap_Matrix_Finalize, METH_VARARGS, "Matrix_Finalize(Matrix self, int arg2)"}, + { "Matrix_Finalize", (PyCFunction)(void(*)(void))_wrap_Matrix_Finalize, METH_VARARGS|METH_KEYWORDS, "Matrix_Finalize(Matrix self, int arg2)"}, { "delete_Matrix", _wrap_delete_Matrix, METH_O, "delete_Matrix(Matrix self)"}, { "Matrix_Print", _wrap_Matrix_Print, METH_VARARGS, "\n" "Matrix_Print(Matrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -4871,12 +4450,12 @@ static PyMethodDef SwigMethods[] = { { "delete_MatrixInverse", _wrap_delete_MatrixInverse, METH_O, "delete_MatrixInverse(MatrixInverse self)"}, { "MatrixInverse_swigregister", MatrixInverse_swigregister, METH_O, NULL}, { "AbstractSparseMatrix_NumNonZeroElems", _wrap_AbstractSparseMatrix_NumNonZeroElems, METH_O, "AbstractSparseMatrix_NumNonZeroElems(AbstractSparseMatrix self) -> int"}, - { "AbstractSparseMatrix_GetRow", _wrap_AbstractSparseMatrix_GetRow, METH_VARARGS, "AbstractSparseMatrix_GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "AbstractSparseMatrix_EliminateZeroRows", _wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS, "AbstractSparseMatrix_EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, - { "AbstractSparseMatrix_Mult", _wrap_AbstractSparseMatrix_Mult, METH_VARARGS, "AbstractSparseMatrix_Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMult", _wrap_AbstractSparseMatrix_AddMult, METH_VARARGS, "AbstractSparseMatrix_AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, - { "AbstractSparseMatrix_MultTranspose", _wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS, "AbstractSparseMatrix_MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMultTranspose", _wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS, "AbstractSparseMatrix_AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "AbstractSparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, + { "AbstractSparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_AbstractSparseMatrix", _wrap_delete_AbstractSparseMatrix, METH_O, "delete_AbstractSparseMatrix(AbstractSparseMatrix self)"}, { "AbstractSparseMatrix_swigregister", AbstractSparseMatrix_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } @@ -4891,7 +4470,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Elem(Matrix self, int i, int j) -> double const &\n" ""}, { "Matrix_Inverse", _wrap_Matrix_Inverse, METH_O, "Inverse(Matrix self) -> MatrixInverse"}, - { "Matrix_Finalize", _wrap_Matrix_Finalize, METH_VARARGS, "Finalize(Matrix self, int arg2)"}, + { "Matrix_Finalize", (PyCFunction)(void(*)(void))_wrap_Matrix_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(Matrix self, int arg2)"}, { "delete_Matrix", _wrap_delete_Matrix, METH_O, "delete_Matrix(Matrix self)"}, { "Matrix_Print", _wrap_Matrix_Print, METH_VARARGS, "\n" "Print(Matrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -4901,12 +4480,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MatrixInverse", _wrap_delete_MatrixInverse, METH_O, "delete_MatrixInverse(MatrixInverse self)"}, { "MatrixInverse_swigregister", MatrixInverse_swigregister, METH_O, NULL}, { "AbstractSparseMatrix_NumNonZeroElems", _wrap_AbstractSparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(AbstractSparseMatrix self) -> int"}, - { "AbstractSparseMatrix_GetRow", _wrap_AbstractSparseMatrix_GetRow, METH_VARARGS, "GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "AbstractSparseMatrix_EliminateZeroRows", _wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, - { "AbstractSparseMatrix_Mult", _wrap_AbstractSparseMatrix_Mult, METH_VARARGS, "Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMult", _wrap_AbstractSparseMatrix_AddMult, METH_VARARGS, "AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, - { "AbstractSparseMatrix_MultTranspose", _wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMultTranspose", _wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "AbstractSparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, + { "AbstractSparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_AbstractSparseMatrix", _wrap_delete_AbstractSparseMatrix, METH_O, "delete_AbstractSparseMatrix(AbstractSparseMatrix self)"}, { "AbstractSparseMatrix_swigregister", AbstractSparseMatrix_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } diff --git a/mfem/_par/mem_manager.py b/mfem/_par/mem_manager.py index 61f282ee..e50daf44 100644 --- a/mfem/_par/mem_manager.py +++ b/mfem/_par/mem_manager.py @@ -127,12 +127,12 @@ def RegisterCheck(self, h_ptr): return _mem_manager.MemoryManager_RegisterCheck(self, h_ptr) RegisterCheck = _swig_new_instance_method(_mem_manager.MemoryManager_RegisterCheck) - def PrintPtrs(self, *args): - return _mem_manager.MemoryManager_PrintPtrs(self, *args) + def PrintPtrs(self, *args, **kwargs): + return _mem_manager.MemoryManager_PrintPtrs(self, *args, **kwargs) PrintPtrs = _swig_new_instance_method(_mem_manager.MemoryManager_PrintPtrs) - def PrintAliases(self, *args): - return _mem_manager.MemoryManager_PrintAliases(self, *args) + def PrintAliases(self, *args, **kwargs): + return _mem_manager.MemoryManager_PrintAliases(self, *args, **kwargs) PrintAliases = _swig_new_instance_method(_mem_manager.MemoryManager_PrintAliases) @staticmethod diff --git a/mfem/_par/mem_manager_wrap.cxx b/mfem/_par/mem_manager_wrap.cxx index af5ea2e1..045ad5d2 100644 --- a/mfem/_par/mem_manager_wrap.cxx +++ b/mfem/_par/mem_manager_wrap.cxx @@ -3102,17 +3102,19 @@ SWIGINTERN PyObject *Swig_var_MemoryTypeName_get(void) { } -SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"mt", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsHostMemory", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsHostMemory" "', argument " "1"" of type '" "mfem::MemoryType""'"); } @@ -3140,17 +3142,19 @@ SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"mt", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsDeviceMemory", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDeviceMemory" "', argument " "1"" of type '" "mfem::MemoryType""'"); } @@ -3178,17 +3182,19 @@ SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryClass arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"mc", NULL + }; mfem::MemoryType result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GetMemoryType", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetMemoryType" "', argument " "1"" of type '" "mfem::MemoryClass""'"); } @@ -3216,7 +3222,7 @@ SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryClass arg1 ; mfem::MemoryClass arg2 ; @@ -3224,16 +3230,20 @@ SWIGINTERN PyObject *_wrap___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"mc1", (char *)"mc2", NULL + }; mfem::MemoryClass result; - if (!SWIG_Python_UnpackTuple(args, "__mul__", 2, 2, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:__mul__", kwnames, &obj0, &obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__mul__" "', argument " "1"" of type '" "mfem::MemoryClass""'"); } arg1 = static_cast< mfem::MemoryClass >(val1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__mul__" "', argument " "2"" of type '" "mfem::MemoryClass""'"); } @@ -3365,7 +3375,7 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; mfem::MemoryType arg2 ; @@ -3376,20 +3386,25 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_mt", (char *)"d_mt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_Configure", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MemoryManager_Configure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_Configure" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryManager_Configure" "', argument " "2"" of type '" "mfem::MemoryType""'"); } arg2 = static_cast< mfem::MemoryType >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryManager_Configure" "', argument " "3"" of type '" "mfem::MemoryType""'"); } @@ -3454,23 +3469,27 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Destroy(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_ptr", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsKnown", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MemoryManager_IsKnown", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsKnown" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsKnown" "', argument " "2"" of type '" "void const *""'"); } @@ -3497,23 +3516,27 @@ SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_ptr", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsAlias", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MemoryManager_IsAlias", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsAlias" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsAlias" "', argument " "2"" of type '" "void const *""'"); } @@ -3540,22 +3563,26 @@ SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_ptr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_RegisterCheck", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MemoryManager_RegisterCheck", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_RegisterCheck" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_RegisterCheck" "', argument " "2"" of type '" "void *""'"); } @@ -3582,69 +3609,41 @@ SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MemoryManager_PrintPtrs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - { - try { - result = (int)(arg1)->PrintPtrs(*arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int result; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + arg2 = reinterpret_cast< std::ostream * >(argp2); } - arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); { try { - result = (int)(arg1)->PrintPtrs(); + result = (int)(arg1)->PrintPtrs(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3665,110 +3664,41 @@ SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintPtrs", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintPtrs__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintPtrs__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintPtrs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MemoryManager::PrintPtrs(std::ostream &)\n" - " mfem::MemoryManager::PrintPtrs()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MemoryManager_PrintAliases", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - { - try { - result = (int)(arg1)->PrintAliases(*arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int result; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + arg2 = reinterpret_cast< std::ostream * >(argp2); } - arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); { try { - result = (int)(arg1)->PrintAliases(); + result = (int)(arg1)->PrintAliases(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3789,47 +3719,6 @@ SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintAliases", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintAliases__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintAliases__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintAliases'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MemoryManager::PrintAliases(std::ostream &)\n" - " mfem::MemoryManager::PrintAliases()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_MemoryManager_GetHostMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryType result; @@ -3897,16 +3786,18 @@ SWIGINTERN PyObject *MemoryManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MemoryPrintFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryPrintFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; unsigned int arg1 ; unsigned int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"flags", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:MemoryPrintFlags", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MemoryPrintFlags" "', argument " "1"" of type '" "unsigned int""'"); } @@ -3967,50 +3858,50 @@ SWIGINTERN PyObject *Swig_var_mm_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, - { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, - { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, - { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, + { "IsHostMemory", (PyCFunction)(void(*)(void))_wrap_IsHostMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "IsDeviceMemory", (PyCFunction)(void(*)(void))_wrap_IsDeviceMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "GetMemoryType", (PyCFunction)(void(*)(void))_wrap_GetMemoryType, METH_VARARGS|METH_KEYWORDS, NULL}, + { "__mul__", (PyCFunction)(void(*)(void))_wrap___mul__, METH_VARARGS|METH_KEYWORDS, NULL}, { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, - { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, + { "MemoryManager_Configure", (PyCFunction)(void(*)(void))_wrap_MemoryManager_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, - { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, - { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, - { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, - { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, - { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_IsKnown", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsKnown, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_IsAlias", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsAlias, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_RegisterCheck", (PyCFunction)(void(*)(void))_wrap_MemoryManager_RegisterCheck, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintPtrs", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintPtrs, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintAliases", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintAliases, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, - { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, + { "MemoryPrintFlags", (PyCFunction)(void(*)(void))_wrap_MemoryPrintFlags, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, - { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, - { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, - { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, + { "IsHostMemory", (PyCFunction)(void(*)(void))_wrap_IsHostMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "IsDeviceMemory", (PyCFunction)(void(*)(void))_wrap_IsDeviceMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "GetMemoryType", (PyCFunction)(void(*)(void))_wrap_GetMemoryType, METH_VARARGS|METH_KEYWORDS, NULL}, + { "__mul__", (PyCFunction)(void(*)(void))_wrap___mul__, METH_VARARGS|METH_KEYWORDS, NULL}, { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, - { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, + { "MemoryManager_Configure", (PyCFunction)(void(*)(void))_wrap_MemoryManager_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, - { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, - { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, - { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, - { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, - { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_IsKnown", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsKnown, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_IsAlias", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsAlias, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_RegisterCheck", (PyCFunction)(void(*)(void))_wrap_MemoryManager_RegisterCheck, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintPtrs", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintPtrs, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintAliases", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintAliases, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, - { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, + { "MemoryPrintFlags", (PyCFunction)(void(*)(void))_wrap_MemoryPrintFlags, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/mesh.py b/mfem/_par/mesh.py index e4fc1ffc..8b9be363 100644 --- a/mfem/_par/mesh.py +++ b/mfem/_par/mesh.py @@ -697,7 +697,7 @@ def CartesianPartitioning(self, nxyz): CartesianPartitioning = _swig_new_instance_method(_mesh.Mesh_CartesianPartitioning) def GeneratePartitioning(self, nparts, part_method=1): - r"""GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int""" + r"""GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int *""" return _mesh.Mesh_GeneratePartitioning(self, nparts, part_method) GeneratePartitioning = _swig_new_instance_method(_mesh.Mesh_GeneratePartitioning) @@ -972,9 +972,9 @@ def PrintElementsByGeometry(dim, num_elems_by_geom, out): return _mesh.Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out) PrintElementsByGeometry = _swig_new_static_method(_mesh.Mesh_PrintElementsByGeometry) - def PrintCharacteristics(self, *args): + def PrintCharacteristics(self, *args, **kwargs): r"""PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)""" - return _mesh.Mesh_PrintCharacteristics(self, *args) + return _mesh.Mesh_PrintCharacteristics(self, *args, **kwargs) PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) def FindPoints(self, pp): diff --git a/mfem/_par/mesh_operators.py b/mfem/_par/mesh_operators.py index 64ad6eed..967a3f09 100644 --- a/mfem/_par/mesh_operators.py +++ b/mfem/_par/mesh_operators.py @@ -213,9 +213,9 @@ def __init__(self, est): r"""__init__(ThresholdRefiner self, ErrorEstimator est) -> ThresholdRefiner""" _mesh_operators.ThresholdRefiner_swiginit(self, _mesh_operators.new_ThresholdRefiner(est)) - def SetTotalErrorNormP(self, *args): + def SetTotalErrorNormP(self, *args, **kwargs): r"""SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())""" - return _mesh_operators.ThresholdRefiner_SetTotalErrorNormP(self, *args) + return _mesh_operators.ThresholdRefiner_SetTotalErrorNormP(self, *args, **kwargs) SetTotalErrorNormP = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorNormP) def SetTotalErrorGoal(self, err_goal): diff --git a/mfem/_par/mesh_operators_wrap.cxx b/mfem/_par/mesh_operators_wrap.cxx index 4367167b..9573041e 100644 --- a/mfem/_par/mesh_operators_wrap.cxx +++ b/mfem/_par/mesh_operators_wrap.cxx @@ -3352,7 +3352,7 @@ SWIG_AsVal_long (PyObject *obj, long* val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_MeshOperator_Apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MeshOperator_Apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MeshOperator *arg1 = (mfem::MeshOperator *) 0 ; mfem::Mesh *arg2 = 0 ; @@ -3360,16 +3360,20 @@ SWIGINTERN PyObject *_wrap_MeshOperator_Apply(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mesh", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MeshOperator_Apply", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MeshOperator_Apply", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshOperator_Apply" "', argument " "1"" of type '" "mfem::MeshOperator *""'"); } arg1 = reinterpret_cast< mfem::MeshOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshOperator_Apply" "', argument " "2"" of type '" "mfem::Mesh &""'"); } @@ -3736,7 +3740,7 @@ SWIGINTERN PyObject *_wrap_delete_MeshOperatorSequence(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MeshOperatorSequence_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MeshOperatorSequence_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MeshOperatorSequence *arg1 = (mfem::MeshOperatorSequence *) 0 ; mfem::MeshOperator *arg2 = (mfem::MeshOperator *) 0 ; @@ -3744,15 +3748,19 @@ SWIGINTERN PyObject *_wrap_MeshOperatorSequence_Append(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MeshOperatorSequence_Append", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MeshOperatorSequence, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MeshOperatorSequence_Append", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MeshOperatorSequence, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshOperatorSequence_Append" "', argument " "1"" of type '" "mfem::MeshOperatorSequence *""'"); } arg1 = reinterpret_cast< mfem::MeshOperatorSequence * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshOperatorSequence_Append" "', argument " "2"" of type '" "mfem::MeshOperator *""'"); } @@ -3842,17 +3850,19 @@ SWIGINTERN PyObject *MeshOperatorSequence_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ThresholdRefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ThresholdRefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ErrorEstimator *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"est", NULL + }; mfem::ThresholdRefiner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ThresholdRefiner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThresholdRefiner" "', argument " "1"" of type '" "mfem::ErrorEstimator &""'"); } @@ -3875,56 +3885,36 @@ SWIGINTERN PyObject *_wrap_new_ThresholdRefiner(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; - double arg2 ; + double arg2 = (double) mfem::infinity() ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"norm_p", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ThresholdRefiner_SetTotalErrorNormP", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->SetTotalErrorNormP(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); { try { - (arg1)->SetTotalErrorNormP(); + (arg1)->SetTotalErrorNormP(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3937,49 +3927,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetTotalErrorNormP", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ThresholdRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ThresholdRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ThresholdRefiner_SetTotalErrorNormP'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ThresholdRefiner::SetTotalErrorNormP(double)\n" - " mfem::ThresholdRefiner::SetTotalErrorNormP()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; double arg2 ; @@ -3987,15 +3935,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUS int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"err_goal", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetTotalErrorGoal", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetTotalErrorGoal", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorGoal" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorGoal" "', argument " "2"" of type '" "double""'"); } @@ -4015,7 +3967,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; double arg2 ; @@ -4023,15 +3975,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIG int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fraction", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetTotalErrorFraction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetTotalErrorFraction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorFraction" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorFraction" "', argument " "2"" of type '" "double""'"); } @@ -4051,7 +4007,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; double arg2 ; @@ -4059,15 +4015,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUS int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"err_goal", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetLocalErrorGoal", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetLocalErrorGoal", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetLocalErrorGoal" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetLocalErrorGoal" "', argument " "2"" of type '" "double""'"); } @@ -4087,7 +4047,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetMaxElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetMaxElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; long arg2 ; @@ -4095,15 +4055,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetMaxElements(PyObject *SWIGUNUSEDP int res1 = 0 ; long val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_elem", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetMaxElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetMaxElements", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetMaxElements" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetMaxElements" "', argument " "2"" of type '" "long""'"); } @@ -4181,25 +4145,29 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_PreferConformingRefinement(PyObject } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nc_limit", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetNCLimit", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetNCLimit", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetNCLimit" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4345,17 +4313,19 @@ SWIGINTERN PyObject *ThresholdRefiner_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ThresholdDerefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ThresholdDerefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ErrorEstimator *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"est", NULL + }; mfem::ThresholdDerefiner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ThresholdDerefiner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThresholdDerefiner" "', argument " "1"" of type '" "mfem::ErrorEstimator &""'"); } @@ -4378,7 +4348,7 @@ SWIGINTERN PyObject *_wrap_new_ThresholdDerefiner(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdDerefiner *arg1 = (mfem::ThresholdDerefiner *) 0 ; double arg2 ; @@ -4386,15 +4356,19 @@ SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDP int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"thresh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdDerefiner_SetThreshold", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdDerefiner_SetThreshold", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdDerefiner_SetThreshold" "', argument " "1"" of type '" "mfem::ThresholdDerefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdDerefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdDerefiner_SetThreshold" "', argument " "2"" of type '" "double""'"); } @@ -4414,25 +4388,29 @@ SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdDerefiner *arg1 = (mfem::ThresholdDerefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdDerefiner_SetOp", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdDerefiner_SetOp", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdDerefiner_SetOp" "', argument " "1"" of type '" "mfem::ThresholdDerefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdDerefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4449,25 +4427,29 @@ SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetOp(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdDerefiner *arg1 = (mfem::ThresholdDerefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nc_limit", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdDerefiner_SetNCLimit", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdDerefiner_SetNCLimit", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdDerefiner_SetNCLimit" "', argument " "1"" of type '" "mfem::ThresholdDerefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdDerefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4645,7 +4627,7 @@ SWIGINTERN PyObject *Rebalancer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "MeshOperator_Apply(MeshOperator self, Mesh mesh) -> bool"}, + { "MeshOperator_Apply", (PyCFunction)(void(*)(void))_wrap_MeshOperator_Apply, METH_VARARGS|METH_KEYWORDS, "MeshOperator_Apply(MeshOperator self, Mesh mesh) -> bool"}, { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "MeshOperator_Stop(MeshOperator self) -> bool"}, { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "MeshOperator_Repeat(MeshOperator self) -> bool"}, { "MeshOperator_Continue", _wrap_MeshOperator_Continue, METH_O, "MeshOperator_Continue(MeshOperator self) -> bool"}, @@ -4658,30 +4640,30 @@ static PyMethodDef SwigMethods[] = { { "MeshOperator_swigregister", MeshOperator_swigregister, METH_O, NULL}, { "new_MeshOperatorSequence", _wrap_new_MeshOperatorSequence, METH_VARARGS, NULL}, { "delete_MeshOperatorSequence", _wrap_delete_MeshOperatorSequence, METH_O, "delete_MeshOperatorSequence(MeshOperatorSequence self)"}, - { "MeshOperatorSequence_Append", _wrap_MeshOperatorSequence_Append, METH_VARARGS, "MeshOperatorSequence_Append(MeshOperatorSequence self, MeshOperator mc)"}, + { "MeshOperatorSequence_Append", (PyCFunction)(void(*)(void))_wrap_MeshOperatorSequence_Append, METH_VARARGS|METH_KEYWORDS, "MeshOperatorSequence_Append(MeshOperatorSequence self, MeshOperator mc)"}, { "MeshOperatorSequence_GetSequence", _wrap_MeshOperatorSequence_GetSequence, METH_O, "MeshOperatorSequence_GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &"}, { "MeshOperatorSequence_Reset", _wrap_MeshOperatorSequence_Reset, METH_O, "MeshOperatorSequence_Reset(MeshOperatorSequence self)"}, { "MeshOperatorSequence_swigregister", MeshOperatorSequence_swigregister, METH_O, NULL}, { "MeshOperatorSequence_swiginit", MeshOperatorSequence_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdRefiner", _wrap_new_ThresholdRefiner, METH_O, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, - { "ThresholdRefiner_SetTotalErrorNormP", _wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS, "ThresholdRefiner_SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, - { "ThresholdRefiner_SetTotalErrorGoal", _wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS, "ThresholdRefiner_SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetTotalErrorFraction", _wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS, "ThresholdRefiner_SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, - { "ThresholdRefiner_SetLocalErrorGoal", _wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS, "ThresholdRefiner_SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetMaxElements", _wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS, "ThresholdRefiner_SetMaxElements(ThresholdRefiner self, long max_elem)"}, + { "new_ThresholdRefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdRefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, + { "ThresholdRefiner_SetTotalErrorNormP", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, + { "ThresholdRefiner_SetTotalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetTotalErrorFraction", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, + { "ThresholdRefiner_SetLocalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetMaxElements", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetMaxElements(ThresholdRefiner self, long max_elem)"}, { "ThresholdRefiner_PreferNonconformingRefinement", _wrap_ThresholdRefiner_PreferNonconformingRefinement, METH_O, "ThresholdRefiner_PreferNonconformingRefinement(ThresholdRefiner self)"}, { "ThresholdRefiner_PreferConformingRefinement", _wrap_ThresholdRefiner_PreferConformingRefinement, METH_O, "ThresholdRefiner_PreferConformingRefinement(ThresholdRefiner self)"}, - { "ThresholdRefiner_SetNCLimit", _wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS, "ThresholdRefiner_SetNCLimit(ThresholdRefiner self, int nc_limit)"}, + { "ThresholdRefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetNCLimit(ThresholdRefiner self, int nc_limit)"}, { "ThresholdRefiner_GetNumMarkedElements", _wrap_ThresholdRefiner_GetNumMarkedElements, METH_O, "ThresholdRefiner_GetNumMarkedElements(ThresholdRefiner self) -> long"}, { "ThresholdRefiner_GetThreshold", _wrap_ThresholdRefiner_GetThreshold, METH_O, "ThresholdRefiner_GetThreshold(ThresholdRefiner self) -> double"}, { "ThresholdRefiner_Reset", _wrap_ThresholdRefiner_Reset, METH_O, "ThresholdRefiner_Reset(ThresholdRefiner self)"}, { "delete_ThresholdRefiner", _wrap_delete_ThresholdRefiner, METH_O, "delete_ThresholdRefiner(ThresholdRefiner self)"}, { "ThresholdRefiner_swigregister", ThresholdRefiner_swigregister, METH_O, NULL}, { "ThresholdRefiner_swiginit", ThresholdRefiner_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdDerefiner", _wrap_new_ThresholdDerefiner, METH_O, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, - { "ThresholdDerefiner_SetThreshold", _wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS, "ThresholdDerefiner_SetThreshold(ThresholdDerefiner self, double thresh)"}, - { "ThresholdDerefiner_SetOp", _wrap_ThresholdDerefiner_SetOp, METH_VARARGS, "ThresholdDerefiner_SetOp(ThresholdDerefiner self, int op)"}, - { "ThresholdDerefiner_SetNCLimit", _wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS, "ThresholdDerefiner_SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, + { "new_ThresholdDerefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdDerefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, + { "ThresholdDerefiner_SetThreshold", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS|METH_KEYWORDS, "ThresholdDerefiner_SetThreshold(ThresholdDerefiner self, double thresh)"}, + { "ThresholdDerefiner_SetOp", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetOp, METH_VARARGS|METH_KEYWORDS, "ThresholdDerefiner_SetOp(ThresholdDerefiner self, int op)"}, + { "ThresholdDerefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "ThresholdDerefiner_SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, { "ThresholdDerefiner_Reset", _wrap_ThresholdDerefiner_Reset, METH_O, "ThresholdDerefiner_Reset(ThresholdDerefiner self)"}, { "delete_ThresholdDerefiner", _wrap_delete_ThresholdDerefiner, METH_O, "delete_ThresholdDerefiner(ThresholdDerefiner self)"}, { "ThresholdDerefiner_swigregister", ThresholdDerefiner_swigregister, METH_O, NULL}, @@ -4697,7 +4679,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "Apply(MeshOperator self, Mesh mesh) -> bool"}, + { "MeshOperator_Apply", (PyCFunction)(void(*)(void))_wrap_MeshOperator_Apply, METH_VARARGS|METH_KEYWORDS, "Apply(MeshOperator self, Mesh mesh) -> bool"}, { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "Stop(MeshOperator self) -> bool"}, { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "Repeat(MeshOperator self) -> bool"}, { "MeshOperator_Continue", _wrap_MeshOperator_Continue, METH_O, "Continue(MeshOperator self) -> bool"}, @@ -4710,30 +4692,30 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "MeshOperator_swigregister", MeshOperator_swigregister, METH_O, NULL}, { "new_MeshOperatorSequence", _wrap_new_MeshOperatorSequence, METH_VARARGS, NULL}, { "delete_MeshOperatorSequence", _wrap_delete_MeshOperatorSequence, METH_O, "delete_MeshOperatorSequence(MeshOperatorSequence self)"}, - { "MeshOperatorSequence_Append", _wrap_MeshOperatorSequence_Append, METH_VARARGS, "Append(MeshOperatorSequence self, MeshOperator mc)"}, + { "MeshOperatorSequence_Append", (PyCFunction)(void(*)(void))_wrap_MeshOperatorSequence_Append, METH_VARARGS|METH_KEYWORDS, "Append(MeshOperatorSequence self, MeshOperator mc)"}, { "MeshOperatorSequence_GetSequence", _wrap_MeshOperatorSequence_GetSequence, METH_O, "GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &"}, { "MeshOperatorSequence_Reset", _wrap_MeshOperatorSequence_Reset, METH_O, "Reset(MeshOperatorSequence self)"}, { "MeshOperatorSequence_swigregister", MeshOperatorSequence_swigregister, METH_O, NULL}, { "MeshOperatorSequence_swiginit", MeshOperatorSequence_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdRefiner", _wrap_new_ThresholdRefiner, METH_O, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, - { "ThresholdRefiner_SetTotalErrorNormP", _wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS, "SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, - { "ThresholdRefiner_SetTotalErrorGoal", _wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS, "SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetTotalErrorFraction", _wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS, "SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, - { "ThresholdRefiner_SetLocalErrorGoal", _wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS, "SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetMaxElements", _wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS, "SetMaxElements(ThresholdRefiner self, long max_elem)"}, + { "new_ThresholdRefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdRefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, + { "ThresholdRefiner_SetTotalErrorNormP", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS|METH_KEYWORDS, "SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, + { "ThresholdRefiner_SetTotalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS|METH_KEYWORDS, "SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetTotalErrorFraction", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS|METH_KEYWORDS, "SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, + { "ThresholdRefiner_SetLocalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS|METH_KEYWORDS, "SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetMaxElements", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS|METH_KEYWORDS, "SetMaxElements(ThresholdRefiner self, long max_elem)"}, { "ThresholdRefiner_PreferNonconformingRefinement", _wrap_ThresholdRefiner_PreferNonconformingRefinement, METH_O, "PreferNonconformingRefinement(ThresholdRefiner self)"}, { "ThresholdRefiner_PreferConformingRefinement", _wrap_ThresholdRefiner_PreferConformingRefinement, METH_O, "PreferConformingRefinement(ThresholdRefiner self)"}, - { "ThresholdRefiner_SetNCLimit", _wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdRefiner self, int nc_limit)"}, + { "ThresholdRefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "SetNCLimit(ThresholdRefiner self, int nc_limit)"}, { "ThresholdRefiner_GetNumMarkedElements", _wrap_ThresholdRefiner_GetNumMarkedElements, METH_O, "GetNumMarkedElements(ThresholdRefiner self) -> long"}, { "ThresholdRefiner_GetThreshold", _wrap_ThresholdRefiner_GetThreshold, METH_O, "GetThreshold(ThresholdRefiner self) -> double"}, { "ThresholdRefiner_Reset", _wrap_ThresholdRefiner_Reset, METH_O, "Reset(ThresholdRefiner self)"}, { "delete_ThresholdRefiner", _wrap_delete_ThresholdRefiner, METH_O, "delete_ThresholdRefiner(ThresholdRefiner self)"}, { "ThresholdRefiner_swigregister", ThresholdRefiner_swigregister, METH_O, NULL}, { "ThresholdRefiner_swiginit", ThresholdRefiner_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdDerefiner", _wrap_new_ThresholdDerefiner, METH_O, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, - { "ThresholdDerefiner_SetThreshold", _wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS, "SetThreshold(ThresholdDerefiner self, double thresh)"}, - { "ThresholdDerefiner_SetOp", _wrap_ThresholdDerefiner_SetOp, METH_VARARGS, "SetOp(ThresholdDerefiner self, int op)"}, - { "ThresholdDerefiner_SetNCLimit", _wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, + { "new_ThresholdDerefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdDerefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, + { "ThresholdDerefiner_SetThreshold", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS|METH_KEYWORDS, "SetThreshold(ThresholdDerefiner self, double thresh)"}, + { "ThresholdDerefiner_SetOp", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetOp, METH_VARARGS|METH_KEYWORDS, "SetOp(ThresholdDerefiner self, int op)"}, + { "ThresholdDerefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, { "ThresholdDerefiner_Reset", _wrap_ThresholdDerefiner_Reset, METH_O, "Reset(ThresholdDerefiner self)"}, { "delete_ThresholdDerefiner", _wrap_delete_ThresholdDerefiner, METH_O, "delete_ThresholdDerefiner(ThresholdDerefiner self)"}, { "ThresholdDerefiner_swigregister", ThresholdDerefiner_swigregister, METH_O, NULL}, diff --git a/mfem/_par/mesh_wrap.cxx b/mfem/_par/mesh_wrap.cxx index e81f0683..34de867f 100644 --- a/mfem/_par/mesh_wrap.cxx +++ b/mfem/_par/mesh_wrap.cxx @@ -3666,7 +3666,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #define SWIG_From_double PyFloat_FromDouble -SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_32(int nx,int ny,int nz,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0,double sz=1.0){ +SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_12(int nx,int ny,int nz,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0,double sz=1.0){ mfem::Mesh *mesh; if (std::strcmp(type, "POINT")) { mesh = new mfem::Mesh(nx, ny, nz, mfem::Element::POINT, @@ -3702,7 +3702,7 @@ SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_32(int nx,int ny,int nz,char const *t } return mesh; } -SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_37(int nx,int ny,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0){ +SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_13(int nx,int ny,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0){ mfem::Mesh *mesh; if (std::strcmp(type, "POINT")) { mesh = new mfem::Mesh(nx, ny, mfem::Element::POINT, @@ -3825,7 +3825,7 @@ SWIGINTERN PyObject *mfem_Mesh_GetDomainArray(mfem::Mesh const *self,int idx){ } return array; } -SWIGINTERN void mfem_Mesh_PrintInfo__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_PrintInfo__SWIG_1(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3836,7 +3836,7 @@ SWIGINTERN void mfem_Mesh_PrintInfo__SWIG_2(mfem::Mesh *self,char const *file,in self -> PrintInfo(ofile); ofile.close(); } -SWIGINTERN void mfem_Mesh_Print__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_Print__SWIG_1(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3847,7 +3847,7 @@ SWIGINTERN void mfem_Mesh_Print__SWIG_2(mfem::Mesh *self,char const *file,int pr self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_Mesh_PrintXG__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_PrintXG__SWIG_1(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3858,7 +3858,7 @@ SWIGINTERN void mfem_Mesh_PrintXG__SWIG_2(mfem::Mesh *self,char const *file,int self -> PrintXG(ofile); ofile.close(); } -SWIGINTERN void mfem_Mesh_PrintVTK__SWIG_3(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_PrintVTK__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -4193,14 +4193,14 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_s SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; mfem::Mesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Mesh, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); @@ -4209,11 +4209,13 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (mfem::Mesh *)new mfem::Mesh((mfem::Mesh const &)*arg1,arg2); @@ -4230,37 +4232,6 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_s SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Mesh, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Mesh *)new mfem::Mesh((mfem::Mesh const &)*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -4273,7 +4244,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s int *arg9 = (int *) 0 ; int arg10 ; int arg11 ; - int arg12 ; + int arg12 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -4290,7 +4261,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s int res9 = 0 ; mfem::Mesh *result = 0 ; - if ((nobjs < 12) || (nobjs > 12)) SWIG_fail; + if ((nobjs < 11) || (nobjs > 12)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "double *""'"); @@ -4350,119 +4321,17 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s }; arg11 = PyArray_PyIntAsInt(swig_obj[10]); } - { - if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg12 = PyArray_PyIntAsInt(swig_obj[11]); - } - { - try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); + if (swig_obj[11]) { + { + if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg12 = PyArray_PyIntAsInt(swig_obj[11]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - double *arg1 = (double *) 0 ; - int arg2 ; - int *arg3 = (int *) 0 ; - mfem::Geometry::Type arg4 ; - int *arg5 = (int *) 0 ; - int arg6 ; - int *arg7 = (int *) 0 ; - mfem::Geometry::Type arg8 ; - int *arg9 = (int *) 0 ; - int arg10 ; - int arg11 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - int val4 ; - int ecode4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - int val8 ; - int ecode8 = 0 ; - void *argp9 = 0 ; - int res9 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 11) || (nobjs > 11)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "double *""'"); - } - arg1 = reinterpret_cast< double * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "int *""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Geometry::Type""'"); - } - arg4 = static_cast< mfem::Geometry::Type >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Mesh" "', argument " "5"" of type '" "int *""'"); - } - arg5 = reinterpret_cast< int * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Mesh" "', argument " "7"" of type '" "int *""'"); - } - arg7 = reinterpret_cast< int * >(argp7); - ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "mfem::Geometry::Type""'"); - } - arg8 = static_cast< mfem::Geometry::Type >(val8); - res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res9)) { - SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Mesh" "', argument " "9"" of type '" "int *""'"); - } - arg9 = reinterpret_cast< int * >(argp9); - { - if ((PyArray_PyIntAsInt(swig_obj[9]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg10 = PyArray_PyIntAsInt(swig_obj[9]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[10]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg11 = PyArray_PyIntAsInt(swig_obj[10]); } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4475,16 +4344,16 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; int arg3 ; - int arg4 ; - int arg5 ; + int arg4 = (int) 0 ; + int arg5 = (int) -1 ; mfem::Mesh *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -4503,110 +4372,25 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_s }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - { - try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4619,26 +4403,30 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_Mesh_NewElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_NewElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", NULL + }; mfem::Element *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_NewElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_NewElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4655,30 +4443,34 @@ SWIGINTERN PyObject *_wrap_Mesh_NewElement(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; double *arg2 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_AddVertex", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_AddVertex", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (double *) malloc((l)*sizeof(double)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (double)PyFloat_AsDouble(s); } else if (PyFloat_Check(s)) { @@ -4705,30 +4497,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddSegment", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -4740,12 +4538,14 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { (arg1)->AddSegment((int const *)arg2,arg3); @@ -4761,29 +4561,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddTri(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddTri", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTri" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -4795,9 +4602,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddSegment((int const *)arg2); + (arg1)->AddTri((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4810,86 +4625,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Mesh_AddSegment(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddSegment", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddSegment__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddSegment__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddSegment'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddSegment(int const *,int)\n" - " mfem::Mesh::AddSegment(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddTriangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddTriangle", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTri" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -4901,15 +4666,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddTri((int const *)arg2,arg3); + (arg1)->AddTriangle((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4922,29 +4689,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTri" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -4956,9 +4730,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddTri((int const *)arg2); + (arg1)->AddQuad((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4971,86 +4753,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTri(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddTri", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddTri__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddTri__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddTri'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddTri(int const *,int)\n" - " mfem::Mesh::AddTri(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddTet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddTet", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTet" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5062,15 +4794,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddTriangle((int const *)arg2,arg3); + (arg1)->AddTet((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5083,29 +4817,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddWedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddWedge", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddWedge" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5117,9 +4858,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddTriangle((int const *)arg2); + (arg1)->AddWedge((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5132,86 +4881,100 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Mesh_AddTriangle(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_AddHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddTriangle", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddTriangle__SWIG_1(self, argc, argv); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddHex", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + int i; + if (!PyList_Check(obj1)) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(obj1); + arg2 = (int *) malloc((l)*sizeof(int)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(obj1,i); + if (PyInt_Check(s)) { + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); + return NULL; } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddTriangle__SWIG_0(self, argc, argv); - } - } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - + { + try { + (arg1)->AddHex((int const *)arg2,arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddTriangle'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddTriangle(int const *,int)\n" - " mfem::Mesh::AddTriangle(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddHexAsTets", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsTets" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5223,15 +4986,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddQuad((int const *)arg2,arg3); + (arg1)->AddHexAsTets((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5244,29 +5009,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddHexAsWedges", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsWedges" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5278,9 +5050,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddQuad((int const *)arg2); + (arg1)->AddHexAsWedges((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5293,106 +5073,34 @@ SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddQuad(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddQuad", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddQuad__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddQuad__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddQuad'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddQuad(int const *,int)\n" - " mfem::Mesh::AddQuad(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + mfem::Element *arg2 = (mfem::Element *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"elem", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_AddElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTet" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddElement" "', argument " "2"" of type '" "mfem::Element *""'"); } + arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddTet((int const *)arg2,arg3); + (arg1)->AddElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5405,43 +5113,34 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + mfem::Element *arg2 = (mfem::Element *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"elem", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_AddBdrElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTet" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddBdrElement" "', argument " "2"" of type '" "mfem::Element *""'"); } + arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddTet((int const *)arg2); + (arg1)->AddBdrElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5454,86 +5153,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTet(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddTet", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddTet__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddTet__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddTet'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddTet(int const *,int)\n" - " mfem::Mesh::AddTet(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrSegment", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddWedge" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5545,15 +5194,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddWedge((int const *)arg2,arg3); + (arg1)->AddBdrSegment((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5566,29 +5217,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrTriangle", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddWedge" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5600,9 +5258,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddWedge((int const *)arg2); + (arg1)->AddBdrTriangle((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5615,86 +5281,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddWedge(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddWedge", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddWedge__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddWedge__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddWedge'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddWedge(int const *,int)\n" - " mfem::Mesh::AddWedge(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5706,15 +5322,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddHex((int const *)arg2,arg3); + (arg1)->AddBdrQuad((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5727,29 +5345,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrQuadAsTriangles", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuadAsTriangles" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5761,9 +5386,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddHex((int const *)arg2); + (arg1)->AddBdrQuadAsTriangles((int const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5776,106 +5409,85 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddHex(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_GenerateBoundaryElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddHex", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddHex__SWIG_1(self, argc, argv); - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GenerateBoundaryElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddHex__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + (arg1)->GenerateBoundaryElements(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddHex'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddHex(int const *,int)\n" - " mfem::Mesh::AddHex(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeTriMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsTets" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTriMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->AddHexAsTets((int const *)arg2,arg3); + (arg1)->FinalizeTriMesh(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5888,43 +5500,56 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeQuadMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsTets" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { - (arg1)->AddHexAsTets((int const *)arg2); + (arg1)->FinalizeQuadMesh(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5937,106 +5562,118 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddHexAsTets", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddHexAsTets__SWIG_1(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeTetMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddHexAsTets__SWIG_0(self, argc, argv); - } - } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTetMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + { + try { + (arg1)->FinalizeTetMesh(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddHexAsTets'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddHexAsTets(int const *,int)\n" - " mfem::Mesh::AddHexAsTets(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeWedgeMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsWedges" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->AddHexAsWedges((int const *)arg2,arg3); + (arg1)->FinalizeWedgeMesh(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6049,43 +5686,56 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeHexMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsWedges" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeHexMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { - (arg1)->AddHexAsWedges((int const *)arg2); + (arg1)->FinalizeHexMesh(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6098,86 +5748,88 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 = (int) 0 ; + bool arg3 = (bool) true ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refine", (char *)"fix_orientation", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddHexAsWedges", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddHexAsWedges__SWIG_1(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Mesh_FinalizeMesh", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddHexAsWedges__SWIG_0(self, argc, argv); - } - } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_FinalizeMesh" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } + { + try { + (arg1)->FinalizeMesh(arg2,arg3); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddHexAsWedges'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddHexAsWedges(int const *,int)\n" - " mfem::Mesh::AddHexAsWedges(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Element *arg2 = (mfem::Element *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_bdr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_AddElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_FinalizeTopology", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddElement" "', argument " "2"" of type '" "mfem::Element *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_FinalizeTopology" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddElement(arg2); + (arg1)->FinalizeTopology(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6190,30 +5842,47 @@ SWIGINTERN PyObject *_wrap_Mesh_AddElement(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Element *arg2 = (mfem::Element *) 0 ; + bool arg2 = (bool) false ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + bool val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refine", (char *)"fix_orientation", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_AddBdrElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Mesh_Finalize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddBdrElement" "', argument " "2"" of type '" "mfem::Element *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_Finalize" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddBdrElement(arg2); + (arg1)->Finalize(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6226,50 +5895,23 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrElement(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttributes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - (arg1)->AddBdrSegment((int const *)arg2,arg3); + (arg1)->SetAttributes(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6282,43 +5924,37 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ordering", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetHilbertElementOrdering", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->AddBdrSegment((int const *)arg2); + (arg1)->GetHilbertElementOrdering(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6331,106 +5967,48 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrSegment", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrSegment__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrSegment__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrSegment'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrSegment(int const *,int)\n" - " mfem::Mesh::AddBdrSegment(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ReorderElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + mfem::Array< int > *arg2 = 0 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ordering", (char *)"reorder_vertices", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_ReorderElements", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorderElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_ReorderElements" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } { try { - (arg1)->AddBdrTriangle((int const *)arg2,arg3); + (arg1)->ReorderElements((mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6443,306 +6021,397 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + int arg1 ; + int arg2 ; + int arg3 ; + mfem::Element::Type arg4 ; + bool arg5 = (bool) false ; + double arg6 = (double) 1.0 ; + double arg7 = (double) 1.0 ; + double arg8 = (double) 1.0 ; + bool arg9 = (bool) true ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + bool val9 ; + int ecode9 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 4) || (nobjs > 9)) SWIG_fail; { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); + } + arg4 = static_cast< mfem::Element::Type >(val4); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + } + if (swig_obj[8]) { + ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Mesh" "', argument " "9"" of type '" "bool""'"); + } + arg9 = static_cast< bool >(val9); } { try { - (arg1)->AddBdrTriangle((int const *)arg2); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + mfem::Element::Type arg3 ; + bool arg4 = (bool) false ; + double arg5 = (double) 1.0 ; + double arg6 = (double) 1.0 ; + bool arg7 = (bool) true ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + mfem::Mesh *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrTriangle", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrTriangle__SWIG_1(self, argc, argv); - } - } + if ((nobjs < 3) || (nobjs > 7)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrTriangle__SWIG_0(self, argc, argv); - } - } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); + } + arg3 = static_cast< mfem::Element::Type >(val3); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + } + { + try { + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrTriangle'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrTriangle(int const *,int)\n" - " mfem::Mesh::AddBdrTriangle(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; + int arg1 ; + double arg2 = (double) 1.0 ; + double val2 ; + int ecode2 = 0 ; + mfem::Mesh *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } - } + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } { try { - (arg1)->AddBdrQuad((int const *)arg2,arg3); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + char *arg1 = (char *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 1 ; + bool arg4 = (bool) true ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + mfem::Mesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + arg1 = reinterpret_cast< char * >(buf1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { - (arg1)->AddBdrQuad((int const *)arg2); + result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return resultobj; fail: + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + std::istream *arg1 = 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 1 ; + bool arg4 = (bool) true ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + mfem::Mesh *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrQuad", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrQuad__SWIG_1(self, argc, argv); - } + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + } + arg1 = reinterpret_cast< std::istream * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrQuad__SWIG_0(self, argc, argv); - } - } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + { + try { + result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2,arg3,arg4); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh **arg1 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Mesh *result = 0 ; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *[]""'"); + } + arg1 = reinterpret_cast< mfem::Mesh ** >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + try { + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrQuad'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrQuad(int const *,int)\n" - " mfem::Mesh::AddBdrQuad(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Mesh *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuadAsTriangles" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { @@ -6752,56 +6421,81 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_0(PyObject *SWIGUNUS } { try { - (arg1)->AddBdrQuadAsTriangles((int const *)arg2,arg3); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + std::istream *arg2 = 0 ; + int arg3 = (int) 0 ; + int arg4 = (int) 1 ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"input", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Mesh_Load", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuadAsTriangles" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } } + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_Load" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } { try { - (arg1)->AddBdrQuadAsTriangles((int const *)arg2); + (arg1)->Load(*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6814,63 +6508,7 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrQuadAsTriangles", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrQuadAsTriangles__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrQuadAsTriangles__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrQuadAsTriangles'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrQuadAsTriangles(int const *,int)\n" - " mfem::Mesh::AddBdrQuadAsTriangles(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GenerateBoundaryElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; @@ -6881,12 +6519,12 @@ SWIGINTERN PyObject *_wrap_Mesh_GenerateBoundaryElements(PyObject *SWIGUNUSEDPAR swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GenerateBoundaryElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Clear" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->GenerateBoundaryElements(); + (arg1)->Clear(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6899,644 +6537,457 @@ SWIGINTERN PyObject *_wrap_Mesh_GenerateBoundaryElements(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_MeshGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MeshGenerator" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTriMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - (arg1)->FinalizeTriMesh(arg2,arg3,arg4); + result = (int)(arg1)->MeshGenerator(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNV" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - (arg1)->FinalizeTriMesh(arg2,arg3); + result = (int)((mfem::Mesh const *)arg1)->GetNV(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - (arg1)->FinalizeTriMesh(arg2); + result = (int)((mfem::Mesh const *)arg1)->GetNE(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNBE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeTriMesh(); + result = (int)((mfem::Mesh const *)arg1)->GetNBE(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTriMesh", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_1(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_0(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (int)((mfem::Mesh const *)arg1)->GetNEdges(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTriMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeTriMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeTriMesh(int,int)\n" - " mfem::Mesh::FinalizeTriMesh(int)\n" - " mfem::Mesh::FinalizeTriMesh()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - (arg1)->FinalizeQuadMesh(arg2,arg3,arg4); + result = (int)((mfem::Mesh const *)arg1)->GetNFaces(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNumFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - (arg1)->FinalizeQuadMesh(arg2,arg3); + result = (int)((mfem::Mesh const *)arg1)->GetNumFaces(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::FaceType arg2 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"type", NULL + }; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetNFbyType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFbyType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); { try { - (arg1)->FinalizeQuadMesh(arg2); + result = (int)((mfem::Mesh const *)arg1)->GetNFbyType(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; + long result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_ReduceInt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReduceInt" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->FinalizeQuadMesh(); + result = (long)((mfem::Mesh const *)arg1)->ReduceInt(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeQuadMesh", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_1(self, argc, argv); - } - } - } +SWIGINTERN PyObject *_wrap_Mesh_GetGlobalNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + long result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGlobalNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_0(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (long)((mfem::Mesh const *)arg1)->GetGlobalNE(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_From_long(static_cast< long >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeQuadMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeQuadMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeQuadMesh(int,int)\n" - " mfem::Mesh::FinalizeQuadMesh(int)\n" - " mfem::Mesh::FinalizeQuadMesh()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::IntegrationRule *arg2 = 0 ; int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"flags", NULL + }; + mfem::GeometricFactors *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetGeometricFactors", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTetMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - (arg1)->FinalizeTetMesh(arg2,arg3,arg4); + result = (mfem::GeometricFactors *)(arg1)->GetGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::IntegrationRule *arg2 = 0 ; int arg3 ; + mfem::FaceType arg4 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"flags", (char *)"type", NULL + }; + mfem::FaceGeometricFactors *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceGeometricFactors", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); + } + arg4 = static_cast< mfem::FaceType >(val4); { try { - (arg1)->FinalizeTetMesh(arg2,arg3); + result = (mfem::FaceGeometricFactors *)(arg1)->GetFaceGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_DeleteGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DeleteGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - (arg1)->FinalizeTetMesh(arg2); + (arg1)->DeleteGeometricFactors(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7549,246 +7000,138 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_2(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_EulerNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeTetMesh(); + result = (int)((mfem::Mesh const *)arg1)->EulerNumber(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_EulerNumber2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTetMesh", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_3(self, argc, argv); - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber2D" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_2(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (int)((mfem::Mesh const *)arg1)->EulerNumber2D(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_0(self, argc, argv); - } - } - } - } - } - + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTetMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeTetMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeTetMesh(int,int)\n" - " mfem::Mesh::FinalizeTetMesh(int)\n" - " mfem::Mesh::FinalizeTetMesh()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Dimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Dimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - (arg1)->FinalizeWedgeMesh(arg2,arg3,arg4); + result = (int)((mfem::Mesh const *)arg1)->Dimension(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SpaceDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SpaceDimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - (arg1)->FinalizeWedgeMesh(arg2,arg3); + result = (int)((mfem::Mesh const *)arg1)->SpaceDimension(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -7799,63 +7142,62 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_2(PyObject *SWIGUNUSEDPA } { try { - (arg1)->FinalizeWedgeMesh(arg2); + result = (double *)((mfem::Mesh const *)arg1)->GetVertex(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - (arg1)->FinalizeWedgeMesh(); + result = (double *)(arg1)->GetVertex(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertex(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeWedgeMesh", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetVertex", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_3(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; @@ -7871,40 +7213,11 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *self, PyObject *args } } if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_1(self, argc, argv); - } + return _wrap_Mesh_GetVertex__SWIG_1(self, argc, argv); } } } - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -7919,75 +7232,71 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *self, PyObject *args } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_GetVertex__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeWedgeMesh'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetVertex'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeWedgeMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeWedgeMesh(int,int)\n" - " mfem::Mesh::FinalizeWedgeMesh(int)\n" - " mfem::Mesh::FinalizeWedgeMesh()\n"); + " mfem::Mesh::GetVertex(int) const\n" + " mfem::Mesh::GetVertex(int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - bool arg4 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", (char *)"elem_vtx", (char *)"attr", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetElementData", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeHexMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->FinalizeHexMesh(arg2,arg3,arg4); + ((mfem::Mesh const *)arg1)->GetElementData(arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8000,35 +7309,116 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", (char *)"bdr_elem_vtx", (char *)"bdr_attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetBdrElementData", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + try { + ((mfem::Mesh const *)arg1)->GetBdrElementData(arg2,*arg3,*arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = (double *) 0 ; + int arg3 ; + bool arg4 = (bool) false ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertices", (char *)"len_vertices", (char *)"zerocopy", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_ChangeVertexDataOwnership", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->FinalizeHexMesh(arg2,arg3); + (arg1)->ChangeVertexDataOwnership(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8041,17 +7431,48 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementsArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Element **result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementsArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (mfem::Element **)((mfem::Mesh const *)arg1)->GetElementsArray(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_mfem__Element, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Element *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -8062,63 +7483,62 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_2(PyObject *SWIGUNUSEDPARM } { try { - (arg1)->FinalizeHexMesh(arg2); + result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Element *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - (arg1)->FinalizeHexMesh(); + result = (mfem::Element *)(arg1)->GetElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElement(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeHexMesh", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElement", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_3(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; @@ -8134,40 +7554,11 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_1(self, argc, argv); - } + return _wrap_Mesh_GetElement__SWIG_1(self, argc, argv); } } } - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -8182,52 +7573,32 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *self, PyObject *args) } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_GetElement__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeHexMesh'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElement'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeHexMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeHexMesh(int,int)\n" - " mfem::Mesh::FinalizeHexMesh(int)\n" - " mfem::Mesh::FinalizeHexMesh()\n"); + " mfem::Mesh::GetElement(int) const\n" + " mfem::Mesh::GetElement(int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; + mfem::Element *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -8236,37 +7607,33 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(se }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_FinalizeMesh" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); { try { - (arg1)->FinalizeMesh(arg2,arg3); + result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetBdrElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Element *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -8277,63 +7644,27 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(se } { try { - (arg1)->FinalizeMesh(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->FinalizeMesh(); + result = (mfem::Element *)(arg1)->GetBdrElement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeMesh", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElement", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeMesh__SWIG_2(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; @@ -8349,11 +7680,11 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_FinalizeMesh__SWIG_1(self, argc, argv); + return _wrap_Mesh_GetBdrElement__SWIG_1(self, argc, argv); } } } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -8368,356 +7699,300 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *self, PyObject *args) { } } if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeMesh__SWIG_0(self, argc, argv); - } + return _wrap_Mesh_GetBdrElement__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeMesh'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElement'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeMesh(int,bool)\n" - " mfem::Mesh::FinalizeMesh(int)\n" - " mfem::Mesh::FinalizeMesh()\n"); + " mfem::Mesh::GetBdrElement(int) const\n" + " mfem::Mesh::GetBdrElement(int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Element *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_FinalizeTopology" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { - try { - (arg1)->FinalizeTopology(arg2); + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + try { + result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetFace(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Geometry::Type result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFaceBaseGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->FinalizeTopology(); + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceBaseGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTopology", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeTopology__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeTopology__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTopology'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeTopology(bool)\n" - " mfem::Mesh::FinalizeTopology()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - bool arg3 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Geometry::Type result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetElementBaseGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_Finalize" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->Finalize(arg2,arg3); + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetElementBaseGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Geometry::Type result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrElementBaseGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->Finalize(arg2); + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetBdrElementBaseGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_HasGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Geometry::Type arg2 ; void *argp1 = 0 ; int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", NULL + }; + bool result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_HasGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_HasGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_HasGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - (arg1)->Finalize(); + result = (bool)((mfem::Mesh const *)arg1)->HasGeometry(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Finalize", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Finalize__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_Finalize__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_Finalize__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Finalize(bool,bool)\n" - " mfem::Mesh::Finalize(bool)\n" - " mfem::Mesh::Finalize()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNumGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetNumGeometries", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttributes" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->SetAttributes(); + result = (int)((mfem::Mesh const *)arg1)->GetNumGeometries(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::Array< mfem::Geometry::Type > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", (char *)"el_geoms", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetHilbertElementOrdering", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetGeometries", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< mfem::Geometry::Type > * >(argp3); { try { - (arg1)->GetHilbertElementOrdering(*arg2); + ((mfem::Mesh const *)arg1)->GetGeometries(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8730,40 +8005,45 @@ SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - bool arg3 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetElementVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorderElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_ReorderElements" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ReorderElements((mfem::Array< int > const &)*arg2,arg3); + ((mfem::Mesh const *)arg1)->GetElementVertices(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8776,32 +8056,45 @@ SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetBdrElementVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorderElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ReorderElements((mfem::Array< int > const &)*arg2); + ((mfem::Mesh const *)arg1)->GetBdrElementVertices(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8814,1204 +8107,1159 @@ SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_ReorderElements(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_GetElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"edges", (char *)"cor", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_ReorderElements", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_ReorderElements__SWIG_1(self, argc, argv); - } - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetElementEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_ReorderElements__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + try { + ((mfem::Mesh const *)arg1)->GetElementEdges(arg2,*arg3,*arg4); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_ReorderElements'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::ReorderElements(mfem::Array< int > const &,bool)\n" - " mfem::Mesh::ReorderElements(mfem::Array< int > const &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - bool arg9 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - bool val9 ; - int ecode9 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"edges", (char *)"cor", NULL + }; - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetBdrElementEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9); - if (!SWIG_IsOK(ecode9)) { - SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Mesh" "', argument " "9"" of type '" "bool""'"); - } - arg9 = static_cast< bool >(val9); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + ((mfem::Mesh const *)arg1)->GetBdrElementEdges(arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"arg3", (char *)"arg4", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + ((mfem::Mesh const *)arg1)->GetFaceEdges(arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - double arg7 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Array< int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vert", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetFaceVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + ((mfem::Mesh const *)arg1)->GetFaceVertices(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Array< int > *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vert", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetEdgeVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6); + ((mfem::Mesh const *)arg1)->GetEdgeVertices(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); + result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceEdgeTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertexTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - int val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertexTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4); + result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetEdgeVertexTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_15(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - double arg5 ; - double arg6 ; - bool arg7 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"arg3", (char *)"arg4", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetElementFaces", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + ((mfem::Mesh const *)arg1)->GetElementFaces(arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_16(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - double arg5 ; - double arg6 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; + int *arg3 = (int *) 0 ; + int *arg4 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementFace" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementFace" "', argument " "4"" of type '" "int *""'"); + } + arg4 = reinterpret_cast< int * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6); + ((mfem::Mesh const *)arg1)->GetBdrElementFace(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_17(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdgeIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - double arg5 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + int result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrElementEdgeIndex", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdgeIndex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); + result = (int)((mfem::Mesh const *)arg1)->GetBdrElementEdgeIndex(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_18(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementAdjacentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_el", (char *)"el", (char *)"info", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetBdrElementAdjacentElement", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4); + ((mfem::Mesh const *)arg1)->GetBdrElementAdjacentElement(arg2,*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_19(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - int val3 ; - int ecode3 = 0 ; - mfem::Mesh *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Element::Type result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); + result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetElementType(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_20(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - double val2 ; - int ecode2 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Element::Type result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); + result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetBdrElementType(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_21(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"pointmat", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetPointMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg2 = PyArray_PyIntAsInt(obj1); } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1); + ((mfem::Mesh const *)arg1)->GetPointMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_22(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - bool arg4 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"pointmat", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetBdrPointMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - arg1 = reinterpret_cast< char * >(buf1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2,arg3,arg4); + ((mfem::Mesh const *)arg1)->GetBdrPointMatrix(arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_23(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetTransformationFEforElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int arg2 ; - int arg3 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Element::Type arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"arg1", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); - } - arg1 = reinterpret_cast< char * >(buf1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Mesh_GetTransformationFEforElementType", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Mesh_GetTransformationFEforElementType" "', argument " "1"" of type '" "mfem::Element::Type""'"); + } + arg1 = static_cast< mfem::Element::Type >(val1); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2,arg3); + result = (mfem::FiniteElement *)mfem::Mesh::GetTransformationFEforElementType(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_24(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::Mesh *result = 0 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< char * >(buf1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + } + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2); + (arg1)->GetElementTransformation(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_25(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::ElementTransformation *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg1 = reinterpret_cast< char * >(buf1); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1); + result = (mfem::ElementTransformation *)(arg1)->GetElementTransformation(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_26(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - std::istream *arg1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - bool arg4 ; + mfem::Vector *arg3 = 0 ; + mfem::IsoparametricTransformation *arg4 = (mfem::IsoparametricTransformation *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< std::istream * >(argp1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation *""'"); + } + arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2,arg3,arg4); + (arg1)->GetElementTransformation(arg2,(mfem::Vector const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_27(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementTransformation", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetElementTransformation__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetElementTransformation__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetElementTransformation__SWIG_2(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementTransformation'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetElementTransformation(int,mfem::IsoparametricTransformation *)\n" + " mfem::Mesh::GetElementTransformation(int)\n" + " mfem::Mesh::GetElementTransformation(int,mfem::Vector const &,mfem::IsoparametricTransformation *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - std::istream *arg1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + mfem::ElementTransformation *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< std::istream * >(argp1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2,arg3); + result = (mfem::ElementTransformation *)(arg1)->GetBdrElementTransformation(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_28(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - std::istream *arg1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< std::istream * >(argp1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_29(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::istream *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); } - arg1 = reinterpret_cast< std::istream * >(argp1); + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1); + (arg1)->GetBdrElementTransformation(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_30(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh **arg1 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::Mesh *result = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *[]""'"); - } - arg1 = reinterpret_cast< mfem::Mesh ** >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementTransformation", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetBdrElementTransformation__SWIG_0(self, argc, argv); + } + } } - { - try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetBdrElementTransformation__SWIG_1(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementTransformation'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetBdrElementTransformation(int)\n" + " mfem::Mesh::GetBdrElementTransformation(int,mfem::IsoparametricTransformation *)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_31(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -10020,127 +9268,81 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_31(PyObject *SWIGUNUSEDPARM(self), Py_ }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); } + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); + (arg1)->GetFaceTransformation(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetLocalFaceTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; + int arg2 ; int arg3 ; - int arg4 ; - bool arg5 ; + mfem::IsoparametricTransformation *arg4 = 0 ; + int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val5 ; - int ecode5 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face_type", (char *)"elem_type", (char *)"Transf", (char *)"info", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:Mesh_GetLocalFaceTransformation", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_Load" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - (arg1)->Load(*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + arg3 = PyArray_PyIntAsInt(obj2); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IsoparametricTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); } + arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg5 = PyArray_PyIntAsInt(obj4); } { try { - (arg1)->Load(*arg2,arg3,arg4); + (arg1)->GetLocalFaceTransformation(arg2,arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10153,96 +9355,48 @@ SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + mfem::ElementTransformation *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - (arg1)->Load(*arg2,arg3); + result = (mfem::ElementTransformation *)(arg1)->GetFaceTransformation(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - try { - (arg1)->Load(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Load(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Load", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetFaceTransformation", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -10250,141 +9404,83 @@ SWIGINTERN PyObject *_wrap_Mesh_Load(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Load__SWIG_3(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Load__SWIG_2(self, argc, argv); - } + return _wrap_Mesh_GetFaceTransformation__SWIG_1(self, argc, argv); } } } - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Load__SWIG_1(self, argc, argv); - } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_Load__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_GetFaceTransformation__SWIG_0(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Load'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetFaceTransformation'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Load(std::istream &,int,int,bool)\n" - " mfem::Mesh::Load(std::istream &,int,int)\n" - " mfem::Mesh::Load(std::istream &,int)\n" - " mfem::Mesh::Load(std::istream &)\n"); + " mfem::Mesh::GetFaceTransformation(int,mfem::IsoparametricTransformation *)\n" + " mfem::Mesh::GetFaceTransformation(int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp3 = 0 ; + int res3 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Clear" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + } + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - (arg1)->Clear(); + (arg1)->GetEdgeTransformation(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10397,498 +9493,667 @@ SWIGINTERN PyObject *_wrap_Mesh_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Mesh_MeshGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + mfem::ElementTransformation *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MeshGenerator" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (int)(arg1)->MeshGenerator(); + result = (mfem::ElementTransformation *)(arg1)->GetEdgeTransformation(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNV" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetEdgeTransformation", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetEdgeTransformation__SWIG_1(self, argc, argv); + } + } } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (int)((mfem::Mesh const *)arg1)->GetNV(); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetEdgeTransformation__SWIG_0(self, argc, argv); + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetEdgeTransformation'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetEdgeTransformation(int,mfem::IsoparametricTransformation *)\n" + " mfem::Mesh::GetEdgeTransformation(int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 = (int) 31 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FaceNo", (char *)"mask", NULL + }; + mfem::FaceElementTransformations *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_GetFaceElementTransformations", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNE(); + result = (mfem::FaceElementTransformations *)(arg1)->GetFaceElementTransformations(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetInteriorFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FaceNo", NULL + }; + mfem::FaceElementTransformations *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetInteriorFaceTransformations", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNBE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetInteriorFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNBE(); + result = (mfem::FaceElementTransformations *)(arg1)->GetInteriorFaceTransformations(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"BdrElemNo", NULL + }; + mfem::FaceElementTransformations *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrFaceTransformations", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNEdges(); + result = (mfem::FaceElementTransformations *)(arg1)->GetBdrFaceTransformations(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_FaceIsInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FaceNo", NULL + }; + bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_FaceIsInterior", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FaceIsInterior" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNFaces(); + result = (bool)((mfem::Mesh const *)arg1)->FaceIsInterior(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNumFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int *arg4 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", (char *)"Elem1", (char *)"Elem2", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceElements", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElements" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceElements" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceElements" "', argument " "4"" of type '" "int *""'"); + } + arg4 = reinterpret_cast< int * >(argp4); { try { - result = (int)((mfem::Mesh const *)arg1)->GetNumFaces(); + ((mfem::Mesh const *)arg1)->GetFaceElements(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceInfos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FaceType arg2 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int *arg4 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - int result; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", (char *)"Inf1", (char *)"Inf2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceInfos", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFbyType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceInfos" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); - } - arg2 = static_cast< mfem::FaceType >(val2); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceInfos" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceInfos" "', argument " "4"" of type '" "int *""'"); + } + arg4 = reinterpret_cast< int * >(argp4); { try { - result = (int)((mfem::Mesh const *)arg1)->GetNFbyType(arg2); + ((mfem::Mesh const *)arg1)->GetFaceInfos(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - long result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", NULL + }; + mfem::Geometry::Type result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_ReduceInt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFaceGeometryType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReduceInt" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometryType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - result = (long)((mfem::Mesh const *)arg1)->ReduceInt(arg2); + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceGeometryType(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_long(static_cast< long >(result)); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetGlobalNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - long result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", NULL + }; + mfem::Element::Type result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFaceElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGlobalNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (long)((mfem::Mesh const *)arg1)->GetGlobalNE(); + result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetFaceElementType(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_long(static_cast< long >(result)); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::IntegrationRule *arg2 = 0 ; - int arg3 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[3] ; - mfem::GeometricFactors *result = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fix_it", NULL + }; + int result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetGeometricFactors", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_CheckElementOrientation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckElementOrientation" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } { try { - result = (mfem::GeometricFactors *)(arg1)->GetGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3); + result = (int)(arg1)->CheckElementOrientation(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::IntegrationRule *arg2 = 0 ; - int arg3 ; - mfem::FaceType arg4 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val4 ; - int ecode4 = 0 ; - PyObject *swig_obj[4] ; - mfem::FaceGeometricFactors *result = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fix_it", NULL + }; + int result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_CheckBdrElementOrientation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); - } - arg4 = static_cast< mfem::FaceType >(val4); { try { - result = (mfem::FaceGeometricFactors *)(arg1)->GetFaceGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3,arg4); + result = (int)(arg1)->CheckBdrElementOrientation(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_DeleteGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DeleteGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->DeleteGeometricFactors(); + result = (int)((mfem::Mesh const *)arg1)->GetAttribute(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_EulerNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"attr", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_SetAttribute", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttribute" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } { try { - result = (int)((mfem::Mesh const *)arg1)->EulerNumber(); + (arg1)->SetAttribute(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_EulerNumber2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber2D" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (int)((mfem::Mesh const *)arg1)->EulerNumber2D(); + result = (int)((mfem::Mesh const *)arg1)->GetBdrAttribute(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10901,294 +10166,173 @@ SWIGINTERN PyObject *_wrap_Mesh_EulerNumber2D(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_Dimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_ElementToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int result; + mfem::Table *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Dimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (int)((mfem::Mesh const *)arg1)->Dimension(); + result = (mfem::Table *) &(arg1)->ElementToElementTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_SpaceDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_ElementToFaceTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int result; + mfem::Table *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SpaceDimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToFaceTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (int)((mfem::Mesh const *)arg1)->SpaceDimension(); + result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToFaceTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ElementToEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (double *)((mfem::Mesh const *)arg1)->GetVertex(arg2); + result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToEdgeTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertexToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (double *)(arg1)->GetVertex(arg2); + result = (mfem::Table *)(arg1)->GetVertexToElementTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertex(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetVertex", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetVertex__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetVertex__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetVertex'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetVertex(int) const\n" - " mfem::Mesh::GetVertex(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementData", 4, 4, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceToElementTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetElementData(arg2,*arg3,*arg4); + result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceToElementTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_ReorientTetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementData", 4, 4, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorientTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementData(arg2,*arg3,*arg4); + (arg1)->ReorientTetMesh(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11201,795 +10345,669 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementData(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_CartesianPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = (double *) 0 ; - int arg3 ; - bool arg4 ; + int *arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - bool val4 ; - int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nxyz", NULL + }; + int *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_CartesianPartitioning", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CartesianPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "2"" of type '" "double *""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "4"" of type '" "bool""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CartesianPartitioning" "', argument " "2"" of type '" "int []""'"); } - arg4 = static_cast< bool >(val4); + arg2 = reinterpret_cast< int * >(argp2); { try { - (arg1)->ChangeVertexDataOwnership(arg2,arg3,arg4); + result = (int *)(arg1)->CartesianPartitioning(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = (double *) 0 ; - int arg3 ; + int arg2 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nparts", (char *)"part_method", NULL + }; + int *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_GeneratePartitioning", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneratePartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "2"" of type '" "double *""'"); - } - arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->ChangeVertexDataOwnership(arg2,arg3); + result = (int *)(arg1)->GeneratePartitioning(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_ChangeVertexDataOwnership", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_ChangeVertexDataOwnership__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_ChangeVertexDataOwnership__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_ChangeVertexDataOwnership'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::ChangeVertexDataOwnership(double *,int,bool)\n" - " mfem::Mesh::ChangeVertexDataOwnership(double *,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementsArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CheckPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Element **result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"partitioning", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_CheckPartitioning", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementsArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckPartitioning" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); { try { - result = (mfem::Element **)((mfem::Mesh const *)arg1)->GetElementsArray(); + (arg1)->CheckPartitioning(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_CheckDisplacements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"displacements", (char *)"tmax", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_CheckDisplacements", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckDisplacements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); } + arg3 = reinterpret_cast< double * >(argp3); { try { - result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetElement(arg2); + (arg1)->CheckDisplacements((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_MoveVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"displacements", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_MoveVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::Element *)(arg1)->GetElement(arg2); + (arg1)->MoveVertices((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElement(int) const\n" - " mfem::Mesh::GetElement(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vert_coord", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetBdrElement(arg2); + ((mfem::Mesh const *)arg1)->GetVertices(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vert_coord", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::Element *)(arg1)->GetBdrElement(arg2); + (arg1)->SetVertices((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetBdrElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetBdrElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBdrElement(int) const\n" - " mfem::Mesh::GetBdrElement(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + double *arg3 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"coord", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetNode", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetNode" "', argument " "3"" of type '" "double *""'"); } + arg3 = reinterpret_cast< double * >(argp3); { try { - result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetFace(arg2); + ((mfem::Mesh const *)arg1)->GetNode(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + double *arg3 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"coord", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceBaseGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_SetNode", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNode" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + { + int i; + if (!PyList_Check(obj2)) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(obj2); + arg3 = (double *) malloc((l)*sizeof(double)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(obj2,i); + if (PyInt_Check(s)) { + arg3[i] = (double)PyFloat_AsDouble(s); + } else if (PyFloat_Check(s)) { + arg3[i] = (double)PyFloat_AsDouble(s); + } else { + free(arg3); + PyErr_SetString(PyExc_ValueError, "List items must be integer/float"); + return NULL; + } + } } { try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceBaseGeometry(arg2); + (arg1)->SetNode(arg2,(double const *)arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_MoveNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"displacements", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementBaseGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_MoveNodes", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetElementBaseGeometry(arg2); + (arg1)->MoveNodes((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementBaseGeometry", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetBdrElementBaseGeometry(arg2); + ((mfem::Mesh const *)arg1)->GetNodes(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_HasGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Geometry::Type arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - bool result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"node_coord", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_HasGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetNodes", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_HasGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_HasGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (bool)((mfem::Mesh const *)arg1)->HasGeometry(arg2); + (arg1)->SetNodes((mfem::Vector const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNumGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + mfem::GridFunction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNumGeometries", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNumGeometries(arg2); + result = (mfem::GridFunction *)(arg1)->GetNodes(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< mfem::Geometry::Type > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + mfem::GridFunction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetGeometries", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< mfem::Geometry::Type > * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetGeometries(arg2,*arg3); + result = (mfem::GridFunction *)((mfem::Mesh const *)arg1)->GetNodes(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_OwnsNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVertices", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_OwnsNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetElementVertices(arg2,*arg3); + result = (bool)((mfem::Mesh const *)arg1)->OwnsNodes(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetNodesOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes_owner", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementVertices", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetNodesOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodesOwner" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_SetNodesOwner" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementVertices(arg2,*arg3); + (arg1)->SetNodesOwner(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12002,51 +11020,48 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementVertices(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_GetElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_NewNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + mfem::GridFunction *arg2 = 0 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes", (char *)"make_owner", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementEdges", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_NewNodes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_NewNodes" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetElementEdges(arg2,*arg3,*arg4); + (arg1)->NewNodes(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12059,154 +11074,89 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementEdges(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SwapNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + mfem::GridFunction **arg2 = 0 ; + int *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + mfem::GridFunction *Pnodes2 ; + int own_nodes3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes", (char *)"own_nodes_", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementEdges", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_SwapNodes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SwapNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + int res2 = 0; + res2 = SWIG_ConvertPtr(obj1, (void **) &Pnodes2, SWIGTYPE_p_mfem__GridFunction, 0); + if (!SWIG_IsOK(res2)){ + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SwapNodes" "', argument " "2"" of type '" "*mfem::GridFunction""'"); + } + arg2 = &Pnodes2; } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + { + own_nodes3 = (int)PyInt_AsLong(obj2); + arg3 = &own_nodes3; } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementEdges(arg2,*arg3,*arg4); + (arg1)->SwapNodes(*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceEdges", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + Py_XDECREF(resultobj); + resultobj = PyList_New(0); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_mfem__GridFunction, 0 | 0 )); } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { - try { - ((mfem::Mesh const *)arg1)->GetFaceEdges(arg2,*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + resultobj = SWIG_Python_AppendOutput(resultobj, PyLong_FromLong((long)*arg3)); } - resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceVertices", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - ((mfem::Mesh const *)arg1)->GetFaceVertices(arg2,*arg3); + ((mfem::Mesh const *)arg1)->GetNodes(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12219,40 +11169,100 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; +SWIGINTERN PyObject *_wrap_Mesh_GetNodes(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetEdgeVertices", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetNodes", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetNodes__SWIG_1(self, argc, argv); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetNodes__SWIG_2(self, argc, argv); + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetNodes__SWIG_3(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetNodes__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetNodes'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetNodes(mfem::Vector &) const\n" + " mfem::Mesh::GetNodes()\n" + " mfem::Mesh::GetNodes() const\n" + " mfem::Mesh::GetNodes(mfem::GridFunction &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_SetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nfes", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetNodalFESpace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalFESpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - ((mfem::Mesh const *)arg1)->GetEdgeVertices(arg2,*arg3); + (arg1)->SetNodalFESpace(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12265,111 +11275,104 @@ SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes", (char *)"make_owner", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_SetNodalGridFunction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetNodalGridFunction" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } { try { - result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceEdgeTable(); + (arg1)->SetNodalGridFunction(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertexTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; + mfem::FiniteElementSpace *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertexTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetEdgeVertexTable(); + result = (mfem::FiniteElementSpace *)((mfem::Mesh const *)arg1)->GetNodalFESpace(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_EnsureNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementFaces", 4, 4, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetElementFaces(arg2,*arg3,*arg4); + (arg1)->EnsureNodes(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12382,44 +11385,64 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementFaces(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SetCurvature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int *arg3 = (int *) 0 ; - int *arg4 = (int *) 0 ; + bool arg3 = (bool) false ; + int arg4 = (int) -1 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"order", (char *)"discont", (char *)"space_dim", (char *)"ordering", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Mesh_SetCurvature", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementFace" "', argument " "3"" of type '" "int *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementFace" "', argument " "4"" of type '" "int *""'"); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } - arg4 = reinterpret_cast< int * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementFace(arg2,arg3,arg4); + (arg1)->SetCurvature(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12432,87 +11455,91 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdgeIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ref_algo", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementEdgeIndex", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_UniformRefinement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdgeIndex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_UniformRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { - result = (int)((mfem::Mesh const *)arg1)->GetBdrElementEdgeIndex(arg2); + (arg1)->UniformRefinement(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementAdjacentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int *arg3 = 0 ; - int *arg4 = 0 ; + mfem::Array< mfem::Refinement > *arg2 = 0 ; + int arg3 = (int) -1 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementAdjacentElement", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); + arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - arg4 = reinterpret_cast< int * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementAdjacentElement(arg2,*arg3,*arg4); + (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12525,112 +11552,207 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementAdjacentElement(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 = (int) -1 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element::Type result; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementType", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetElementType(arg2); + (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element::Type result; +SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GeneralRefinement", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); + } + { + _v = PyInt_Check(argv[2]) ? 1 : 0; + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); + } + } + } + } } - { - try { - result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetBdrElementType(arg2); + if ((argc >= 2) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); + } + { + _v = PyInt_Check(argv[2]) ? 1 : 0; + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GeneralRefinement'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &,int,int)\n" + " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &,int,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; + double arg2 ; + bool arg3 = (bool) false ; + int arg4 = (int) -1 ; + int arg5 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + double val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"prob", (char *)"aniso", (char *)"nonconforming", (char *)"nc_limit", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetPointMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Mesh_RandomRefinement", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetPointMatrix(arg2,*arg3); + (arg1)->RandomRefinement(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12643,286 +11765,283 @@ SWIGINTERN PyObject *_wrap_Mesh_GetPointMatrix(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; + mfem::Vertex *arg2 = 0 ; + double arg3 = (double) 0.0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vert", (char *)"eps", (char *)"nonconforming", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrPointMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:Mesh_RefineAtVertex", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + arg2 = reinterpret_cast< mfem::Vertex * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineAtVertex" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - ((mfem::Mesh const *)arg1)->GetBdrPointMatrix(arg2,*arg3); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetTransformationFEforElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Element::Type arg1 ; - int val1 ; - int ecode1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElement *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Mesh_GetTransformationFEforElementType" "', argument " "1"" of type '" "mfem::Element::Type""'"); - } - arg1 = static_cast< mfem::Element::Type >(val1); { try { - result = (mfem::FiniteElement *)mfem::Mesh::GetTransformationFEforElementType(arg1); + (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + mfem::Array< double > *arg2 = 0 ; + double arg3 ; + int arg4 = (int) -1 ; + int arg5 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - (arg1)->GetElementTransformation(arg2,arg3); + result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; + double arg3 ; + int arg4 = (int) -1 ; + int arg5 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::ElementTransformation *)(arg1)->GetElementTransformation(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::IsoparametricTransformation *arg4 = (mfem::IsoparametricTransformation *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation *""'"); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); { try { - (arg1)->GetElementTransformation(arg2,(mfem::Vector const &)*arg3,arg4); + result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RefineByError(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementTransformation", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RefineByError", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetElementTransformation__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetElementTransformation__SWIG_0(self, argc, argv); + if (argc <= 3) { + return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); + } + { + _v = PyInt_Check(argv[3]) ? 1 : 0; + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); + } + } } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + { + int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); + } + { + _v = PyInt_Check(argv[3]) ? 1 : 0; + } if (_v) { - return _wrap_Mesh_GetElementTransformation__SWIG_2(self, argc, argv); + if (argc <= 4) { + return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); + } } } } @@ -12930,183 +12049,279 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation(PyObject *self, PyObjec } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementTransformation'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RefineByError'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementTransformation(int,mfem::IsoparametricTransformation *)\n" - " mfem::Mesh::GetElementTransformation(int)\n" - " mfem::Mesh::GetElementTransformation(int,mfem::Vector const &,mfem::IsoparametricTransformation *)\n"); + " mfem::Mesh::RefineByError(mfem::Array< double > const &,double,int,int)\n" + " mfem::Mesh::RefineByError(mfem::Vector const &,double,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Array< double > *arg2 = 0 ; + double arg3 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { - result = (mfem::ElementTransformation *)(arg1)->GetBdrElementTransformation(arg2); + result = (bool)(arg1)->DerefineByError(*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + mfem::Vector *arg2 = 0 ; + double arg3 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); - { - try { - (arg1)->GetBdrElementTransformation(arg2,arg3); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - catch (Swig::DirectorException &e) { + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + { + try { + result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); + } + catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_DerefineByError(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementTransformation", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DerefineByError", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetBdrElementTransformation__SWIG_0(self, argc, argv); + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); + } + } + } } } } - if (argc == 3) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - return _wrap_Mesh_GetBdrElementTransformation__SWIG_1(self, argc, argv); + if (argc <= 3) { + return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); + } + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementTransformation'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_DerefineByError'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBdrElementTransformation(int)\n" - " mfem::Mesh::GetBdrElementTransformation(int,mfem::IsoparametricTransformation *)\n"); + " mfem::Mesh::DerefineByError(mfem::Array< double > &,double,int,int)\n" + " mfem::Mesh::DerefineByError(mfem::Vector const &,double,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + mfem::Array< mfem::KnotVector * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); + arg2 = reinterpret_cast< mfem::Array< mfem::KnotVector * > * >(argp2); { try { - (arg1)->GetFaceTransformation(arg2,arg3); + (arg1)->KnotInsert(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13119,54 +12334,32 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Mesh_GetLocalFaceTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - mfem::IsoparametricTransformation *arg4 = 0 ; - int arg5 ; + mfem::Array< mfem::Vector * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[5] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetLocalFaceTransformation", 5, 5, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IsoparametricTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); } - arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); } + arg2 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp2); { try { - (arg1)->GetLocalFaceTransformation(arg2,arg3,*arg4,arg5); + (arg1)->KnotInsert(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13179,581 +12372,688 @@ SWIGINTERN PyObject *_wrap_Mesh_GetLocalFaceTransformation(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_KnotInsert'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::KnotVector * > &)\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::Vector * > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + int arg3 = (int) 16 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rel_degree", (char *)"degree", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_DegreeElevate", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - result = (mfem::ElementTransformation *)(arg1)->GetFaceTransformation(arg2); + (arg1)->DegreeElevate(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 = (bool) false ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"simplices_nonconforming", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetFaceTransformation", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetFaceTransformation__SWIG_1(self, argc, argv); - } - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_EnsureNCMesh", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNCMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetFaceTransformation__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_EnsureNCMesh" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } + { + try { + (arg1)->EnsureNCMesh(arg2); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetFaceTransformation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetFaceTransformation(int,mfem::IsoparametricTransformation *)\n" - " mfem::Mesh::GetFaceTransformation(int)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Conforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; + bool result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Conforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); - } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - (arg1)->GetEdgeTransformation(arg2,arg3); + result = (bool)((mfem::Mesh const *)arg1)->Conforming(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Nonconforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; + PyObject *swig_obj[1] ; + bool result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Nonconforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::ElementTransformation *)(arg1)->GetEdgeTransformation(arg2); + result = (bool)((mfem::Mesh const *)arg1)->Nonconforming(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_GetRefinementTransforms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::CoarseFineTransformations *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetEdgeTransformation", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetEdgeTransformation__SWIG_1(self, argc, argv); - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetRefinementTransforms" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetEdgeTransformation__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (mfem::CoarseFineTransformations *) &(arg1)->GetRefinementTransforms(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetEdgeTransformation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetEdgeTransformation(int,mfem::IsoparametricTransformation *)\n" - " mfem::Mesh::GetEdgeTransformation(int)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetLastOperation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::FaceElementTransformations *result = 0 ; + PyObject *swig_obj[1] ; + mfem::Mesh::Operation result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLastOperation" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetFaceElementTransformations(arg2,arg3); + result = (mfem::Mesh::Operation)((mfem::Mesh const *)arg1)->GetLastOperation(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::FaceElementTransformations *result = 0 ; + PyObject *swig_obj[1] ; + long result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetSequence" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetFaceElementTransformations(arg2); + result = (long)((mfem::Mesh const *)arg1)->GetSequence(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetFaceElementTransformations", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetFaceElementTransformations__SWIG_1(self, argc, argv); - } - } + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetFaceElementTransformations__SWIG_0(self, argc, argv); - } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; } } } - + { + try { + ((mfem::Mesh const *)arg1)->PrintXG(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetFaceElementTransformations'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetFaceElementTransformations(int,int)\n" - " mfem::Mesh::GetFaceElementTransformations(int)\n"); - return 0; + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetInteriorFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FaceElementTransformations *result = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetInteriorFaceTransformations", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetInteriorFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } } { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetInteriorFaceTransformations(arg2); + ((mfem::Mesh const *)arg1)->Print(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FaceElementTransformations *result = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrFaceTransformations", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetBdrFaceTransformations(arg2); + (arg1)->PrintVTK(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FaceIsInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + std::ostream *arg2 = 0 ; + int arg3 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - bool result; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_FaceIsInterior", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FaceIsInterior" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - result = (bool)((mfem::Mesh const *)arg1)->FaceIsInterior(arg2); + (arg1)->PrintVTK(*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int *arg3 = (int *) 0 ; - int *arg4 = (int *) 0 ; + std::ostream *arg2 = 0 ; + int arg3 = (int) 1 ; + mfem::VTKFormat arg4 = (mfem::VTKFormat) mfem::VTKFormat::ASCII ; + bool arg5 = (bool) false ; + int arg6 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceElements", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElements" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceElements" "', argument " "3"" of type '" "int *""'"); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceElements" "', argument " "4"" of type '" "int *""'"); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } } - arg4 = reinterpret_cast< int * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetFaceElements(arg2,arg3,arg4); + (arg1)->PrintVTU(*arg2,arg3,arg4,arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceInfos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int *arg3 = (int *) 0 ; - int *arg4 = (int *) 0 ; + std::string arg2 ; + mfem::VTKFormat arg3 = (mfem::VTKFormat) mfem::VTKFormat::ASCII ; + bool arg4 = (bool) false ; + int arg5 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceInfos", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceInfos" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceInfos" "', argument " "3"" of type '" "int *""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); + } + arg3 = static_cast< mfem::VTKFormat >(val3); } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceInfos" "', argument " "4"" of type '" "int *""'"); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg4 = reinterpret_cast< int * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetFaceInfos(arg2,arg3,arg4); + (arg1)->PrintVTU(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13766,263 +13066,587 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceInfos(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceGeometryType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometryType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTU", 0, 6, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + } + } + } + } } - { - try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceGeometryType(arg2); + if ((argc >= 2) && (argc <= 6)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 5) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + } + } + } + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTU'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool,int)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element::Type result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"colors", (char *)"el0", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceElementType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_GetElementColoring", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetFaceElementType(arg2); + (arg1)->GetElementColoring(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"partitioning", (char *)"out", (char *)"elem_attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_PrintWithPartitioning", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckElementOrientation" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); + { + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } { try { - result = (int)(arg1)->CheckElementOrientation(arg2); + ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"partitioning", (char *)"out", (char *)"interior_faces", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_PrintElementsWithPartitioning", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); { - try { - result = (int)(arg1)->CheckElementOrientation(); - } + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } + { + try { + (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); + } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Table *arg2 = 0 ; + std::ostream *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Aface_face", (char *)"out", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_CheckElementOrientation", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_CheckElementOrientation__SWIG_1(self, argc, argv); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_PrintSurfaces", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + arg2 = reinterpret_cast< mfem::Table * >(argp2); + { + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; } } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_CheckElementOrientation__SWIG_0(self, argc, argv); - } + { + try { + ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } + return resultobj; +fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); } } + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sf", NULL + }; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_ScaleSubdomains", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + (arg1)->ScaleSubdomains(arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_CheckElementOrientation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::CheckElementOrientation(bool)\n" - " mfem::Mesh::CheckElementOrientation()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; + double val2 ; int ecode2 = 0 ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sf", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_ScaleElements", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "2"" of type '" "bool""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); } - arg2 = static_cast< bool >(val2); + arg2 = static_cast< double >(val2); { try { - result = (int)(arg1)->CheckBdrElementOrientation(arg2); + (arg1)->ScaleElements(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); + } + } { try { - result = (int)(arg1)->CheckBdrElementOrientation(); + (arg1)->Transform(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + { + try { + (arg1)->Transform(*arg2); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_CheckBdrElementOrientation", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_CheckBdrElementOrientation__SWIG_1(self, argc, argv); + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); + } } } if (argc == 2) { @@ -14031,91 +13655,70 @@ SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation(PyObject *self, PyObj int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_CheckBdrElementOrientation__SWIG_0(self, argc, argv); + return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_CheckBdrElementOrientation'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::CheckBdrElementOrientation(bool)\n" - " mfem::Mesh::CheckBdrElementOrientation()\n"); + " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" + " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetAttribute", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (int)((mfem::Mesh const *)arg1)->GetAttribute(arg2); + (arg1)->RemoveUnusedVertices(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetAttribute", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttribute" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - (arg1)->SetAttribute(arg2,arg3); + (arg1)->RemoveInternalBoundaries(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14128,19 +13731,19 @@ SWIGINTERN PyObject *_wrap_Mesh_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + double result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrAttribute", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -14149,8983 +13752,889 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetBdrAttribute(arg2); + result = (double)(arg1)->GetElementSize(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ElementToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::Table *) &(arg1)->ElementToElementTable(); + result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ElementToFaceTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetElementSize(int,int)\n" + " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetElementVolume", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToFaceTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToFaceTable(); + result = (double)(arg1)->GetElementVolume(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ElementToEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 = (int) 2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"min", (char *)"max", (char *)"ref", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_GetBoundingBox", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } { try { - result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToEdgeTable(); + (arg1)->GetBoundingBox(*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertexToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + mfem::Vector *arg6 = (mfem::Vector *) NULL ; + mfem::Vector *arg7 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_min", (char *)"h_max", (char *)"kappa_min", (char *)"kappa_max", (char *)"Vh", (char *)"Vk", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OO:Mesh_GetCharacteristics", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); + if (obj5) { + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + } + if (obj6) { + res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); + } { try { - result = (mfem::Table *)(arg1)->GetVertexToElementTable(); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceToElementTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + int arg1 ; + mfem::Array< int > *arg2 = 0 ; + std::ostream *arg3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"num_elems_by_geom", (char *)"out", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_PrintElementsByGeometry", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceToElementTable(); + mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ReorientTetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) NULL ; + mfem::Vector *arg3 = (mfem::Vector *) NULL ; + std::ostream &arg4_defvalue = mfem::out ; + std::ostream *arg4 = (std::ostream *) &arg4_defvalue ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyMFEM::wFILE *temp4 = 0 ; + std::ofstream out4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Vh", (char *)"Vk", (char *)"out", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_PrintCharacteristics", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorientTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + } + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + } + if (obj3) { + { + if (SWIG_ConvertPtr(obj3, (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp4->isSTDOUT() == 1) { + arg4 = &std::cout; + } + else { + out4.open(temp4->getFilename()); + out4.precision(temp4->getPrecision()); + arg4 = &out4; + } + } + } { try { - (arg1)->ReorientTetMesh(); + (arg1)->PrintCharacteristics(arg2,arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp4->isSTDOUT() != 1) { + out4.close(); + } + } return resultobj; fail: + { + if (temp4->isSTDOUT() != 1) { + out4.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CartesianPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - int *result = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_CartesianPartitioning", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CartesianPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CartesianPartitioning" "', argument " "2"" of type '" "int []""'"); - } - arg2 = reinterpret_cast< int * >(argp2); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - result = (int *)(arg1)->CartesianPartitioning(arg2); + (arg1)->PrintInfo(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + bool arg5 = (bool) true ; + mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) NULL ; void *argp1 = 0 ; int res1 = 0 ; - int *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"point_mat", (char *)"elem_ids", (char *)"ips", (char *)"warn", (char *)"inv_trans", NULL + }; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OO:Mesh_FindPoints", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneratePartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } + if (obj5) { + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); + } + arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); } { try { - result = (int *)(arg1)->GeneratePartitioning(arg2,arg3); + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - int *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneratePartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + delete arg1; + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + char *arg4 = (char *) 0 ; + int arg5 = (int) 0 ; + double arg6 = (double) 1.0 ; + double arg7 = (double) 1.0 ; + double arg8 = (double) 1.0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + mfem::Mesh *result = 0 ; + + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + } { try { - result = (int *)(arg1)->GeneratePartitioning(arg2); + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_12(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return resultobj; fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GeneratePartitioning", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneratePartitioning__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneratePartitioning__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GeneratePartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GeneratePartitioning(int,int)\n" - " mfem::Mesh::GeneratePartitioning(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_CheckPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_CheckPartitioning", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - try { - (arg1)->CheckPartitioning(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_CheckDisplacements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_CheckDisplacements", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckDisplacements" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - { - try { - (arg1)->CheckDisplacements((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_MoveVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_MoveVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->MoveVertices((mfem::Vector const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - ((mfem::Mesh const *)arg1)->GetVertices(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + int arg1 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 = (int) 0 ; + double arg5 = (double) 1.0 ; + double arg6 = (double) 1.0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + mfem::Mesh *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if ((nobjs < 3) || (nobjs > 6)) SWIG_fail; { - try { - (arg1)->SetVertices((mfem::Vector const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - double *arg3 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNode", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetNode" "', argument " "3"" of type '" "double *""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - { - try { - ((mfem::Mesh const *)arg1)->GetNode(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - double *arg3 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNode", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNode" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - int i; - if (!PyList_Check(swig_obj[2])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[2]); - arg3 = (double *) malloc((l)*sizeof(double)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[2],i); - if (PyInt_Check(s)) { - arg3[i] = (double)PyFloat_AsDouble(s); - } else if (PyFloat_Check(s)) { - arg3[i] = (double)PyFloat_AsDouble(s); - } else { - free(arg3); - PyErr_SetString(PyExc_ValueError, "List items must be integer/float"); - return NULL; - } - } - } - { - try { - (arg1)->SetNode(arg2,(double const *)arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_MoveNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_MoveNodes", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->MoveNodes((mfem::Vector const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - ((mfem::Mesh const *)arg1)->GetNodes(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNodes", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->SetNodes((mfem::Vector const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::GridFunction *)(arg1)->GetNodes(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::GridFunction *)((mfem::Mesh const *)arg1)->GetNodes(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_OwnsNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_OwnsNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (bool)((mfem::Mesh const *)arg1)->OwnsNodes(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodesOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNodesOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodesOwner" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_SetNodesOwner" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetNodesOwner(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_NewNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_NewNodes" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->NewNodes(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_NewNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - (arg1)->NewNodes(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_NewNodes(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_NewNodes", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_NewNodes__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_NewNodes__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_NewNodes'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::NewNodes(mfem::GridFunction &,bool)\n" - " mfem::Mesh::NewNodes(mfem::GridFunction &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SwapNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction **arg2 = 0 ; - int *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunction *Pnodes2 ; - int own_nodes3 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SwapNodes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SwapNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int res2 = 0; - res2 = SWIG_ConvertPtr(swig_obj[1], (void **) &Pnodes2, SWIGTYPE_p_mfem__GridFunction, 0); - if (!SWIG_IsOK(res2)){ - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SwapNodes" "', argument " "2"" of type '" "*mfem::GridFunction""'"); - } - arg2 = &Pnodes2; - } - { - own_nodes3 = (int)PyInt_AsLong(swig_obj[2]); - arg3 = &own_nodes3; - } - { - try { - (arg1)->SwapNodes(*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - Py_XDECREF(resultobj); - resultobj = PyList_New(0); - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_mfem__GridFunction, 0 | 0 )); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyLong_FromLong((long)*arg3)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - ((mfem::Mesh const *)arg1)->GetNodes(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetNodes", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetNodes'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetNodes(mfem::Vector &) const\n" - " mfem::Mesh::GetNodes()\n" - " mfem::Mesh::GetNodes() const\n" - " mfem::Mesh::GetNodes(mfem::GridFunction &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNodalFESpace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalFESpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - { - try { - (arg1)->SetNodalFESpace(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetNodalGridFunction" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetNodalGridFunction(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - (arg1)->SetNodalGridFunction(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_SetNodalGridFunction", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_SetNodalGridFunction__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_SetNodalGridFunction__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_SetNodalGridFunction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::SetNodalGridFunction(mfem::GridFunction *,bool)\n" - " mfem::Mesh::SetNodalGridFunction(mfem::GridFunction *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElementSpace *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)((mfem::Mesh const *)arg1)->GetNodalFESpace(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->EnsureNodes(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - bool arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->SetCurvature(arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - bool arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->SetCurvature(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetCurvature(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetCurvature(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_SetCurvature", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_SetCurvature'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::SetCurvature(int,bool,int,int)\n" - " mfem::Mesh::SetCurvature(int,bool,int)\n" - " mfem::Mesh::SetCurvature(int,bool)\n" - " mfem::Mesh::SetCurvature(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_UniformRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->UniformRefinement(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_UniformRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->UniformRefinement(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_UniformRefinement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_UniformRefinement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_UniformRefinement__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_UniformRefinement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::UniformRefinement(int)\n" - " mfem::Mesh::UniformRefinement()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Refinement > *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Refinement > *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Refinement > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); - { - try { - (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GeneralRefinement", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_3(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GeneralRefinement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &,int,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &,int,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - bool arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->RandomRefinement(arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - bool arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->RandomRefinement(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->RandomRefinement(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->RandomRefinement(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RandomRefinement", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RandomRefinement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::RandomRefinement(double,bool,int,int)\n" - " mfem::Mesh::RandomRefinement(double,bool,int)\n" - " mfem::Mesh::RandomRefinement(double,bool)\n" - " mfem::Mesh::RandomRefinement(double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vertex *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - arg2 = reinterpret_cast< mfem::Vertex * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineAtVertex" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vertex *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - arg2 = reinterpret_cast< mfem::Vertex * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineAtVertex" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vertex *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - arg2 = reinterpret_cast< mfem::Vertex * >(argp2); - { - try { - (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RefineAtVertex", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vertex, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_RefineAtVertex__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vertex, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_RefineAtVertex__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vertex, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RefineAtVertex__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RefineAtVertex'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::RefineAtVertex(mfem::Vertex const &,double,int)\n" - " mfem::Mesh::RefineAtVertex(mfem::Vertex const &,double)\n" - " mfem::Mesh::RefineAtVertex(mfem::Vertex const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RefineByError", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_3(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RefineByError'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::RefineByError(mfem::Array< double > const &,double,int,int)\n" - " mfem::Mesh::RefineByError(mfem::Array< double > const &,double,int)\n" - " mfem::Mesh::RefineByError(mfem::Array< double > const &,double)\n" - " mfem::Mesh::RefineByError(mfem::Vector const &,double,int,int)\n" - " mfem::Mesh::RefineByError(mfem::Vector const &,double,int)\n" - " mfem::Mesh::RefineByError(mfem::Vector const &,double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->DerefineByError(*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->DerefineByError(*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->DerefineByError(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DerefineByError", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_3(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_DerefineByError'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::DerefineByError(mfem::Array< double > &,double,int,int)\n" - " mfem::Mesh::DerefineByError(mfem::Array< double > &,double,int)\n" - " mfem::Mesh::DerefineByError(mfem::Array< double > &,double)\n" - " mfem::Mesh::DerefineByError(mfem::Vector const &,double,int,int)\n" - " mfem::Mesh::DerefineByError(mfem::Vector const &,double,int)\n" - " mfem::Mesh::DerefineByError(mfem::Vector const &,double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::KnotVector * > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::KnotVector * > * >(argp2); - { - try { - (arg1)->KnotInsert(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Vector * > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp2); - { - try { - (arg1)->KnotInsert(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_KnotInsert__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_KnotInsert__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_KnotInsert'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::KnotInsert(mfem::Array< mfem::KnotVector * > &)\n" - " mfem::Mesh::KnotInsert(mfem::Array< mfem::Vector * > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->DegreeElevate(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->DegreeElevate(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DegreeElevate", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DegreeElevate__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DegreeElevate__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_DegreeElevate'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::DegreeElevate(int,int)\n" - " mfem::Mesh::DegreeElevate(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNCMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_EnsureNCMesh" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->EnsureNCMesh(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNCMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->EnsureNCMesh(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_EnsureNCMesh", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_EnsureNCMesh__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_EnsureNCMesh__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_EnsureNCMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::EnsureNCMesh(bool)\n" - " mfem::Mesh::EnsureNCMesh()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Conforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Conforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (bool)((mfem::Mesh const *)arg1)->Conforming(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Nonconforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Nonconforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (bool)((mfem::Mesh const *)arg1)->Nonconforming(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetRefinementTransforms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::CoarseFineTransformations *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetRefinementTransforms" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::CoarseFineTransformations *) &(arg1)->GetRefinementTransforms(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetLastOperation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Mesh::Operation result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLastOperation" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Mesh::Operation)((mfem::Mesh const *)arg1)->GetLastOperation(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - long result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetSequence" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (long)((mfem::Mesh const *)arg1)->GetSequence(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_long(static_cast< long >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::Mesh const *)arg1)->PrintXG(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - ((mfem::Mesh const *)arg1)->PrintXG(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::Mesh const *)arg1)->Print(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - ((mfem::Mesh const *)arg1)->Print(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->PrintVTK(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->PrintVTK(*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->PrintVTK(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - mfem::VTKFormat arg4 ; - bool arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); - } - arg4 = static_cast< mfem::VTKFormat >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - (arg1)->PrintVTU(*arg2,arg3,arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - mfem::VTKFormat arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); - } - arg4 = static_cast< mfem::VTKFormat >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - (arg1)->PrintVTU(*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - mfem::VTKFormat arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); - } - arg4 = static_cast< mfem::VTKFormat >(val4); - { - try { - (arg1)->PrintVTU(*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->PrintVTU(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->PrintVTU(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - mfem::VTKFormat arg3 ; - bool arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); - } - arg3 = static_cast< mfem::VTKFormat >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->PrintVTU(arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - mfem::VTKFormat arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); - } - arg3 = static_cast< mfem::VTKFormat >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - (arg1)->PrintVTU(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - mfem::VTKFormat arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); - } - arg3 = static_cast< mfem::VTKFormat >(val3); - { - try { - (arg1)->PrintVTU(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - { - try { - (arg1)->PrintVTU(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTU", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_8(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_7(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_6(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_5(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTU'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool,int)\n" - " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool)\n" - " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat)\n" - " mfem::Mesh::PrintVTU(std::ostream &,int)\n" - " mfem::Mesh::PrintVTU(std::ostream &)\n" - " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool,int)\n" - " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool)\n" - " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat)\n" - " mfem::Mesh::PrintVTU(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->GetElementColoring(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->GetElementColoring(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementColoring", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementColoring'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &,int)\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &,int) const\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintElementsWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &,int)\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Table *arg2 = 0 ; - std::ostream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintSurfaces", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleSubdomains", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->ScaleSubdomains(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->ScaleElements(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); - } - } - { - try { - (arg1)->Transform(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - (arg1)->Transform(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" - " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveUnusedVertices(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveInternalBoundaries(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (double)(arg1)->GetElementSize(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double)(arg1)->GetElementSize(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementSize(int,int)\n" - " mfem::Mesh::GetElementSize(int)\n" - " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVolume", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double)(arg1)->GetElementVolume(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->GetBoundingBox(*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - (arg1)->GetBoundingBox(*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBoundingBox", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBoundingBox'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - mfem::Vector *arg7 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetCharacteristics", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetCharacteristics'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Array< int > *arg2 = 0 ; - std::ostream *arg3 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsByGeometry", 3, 3, swig_obj)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - std::ostream *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyMFEM::wFILE *temp4 = 0 ; - std::ofstream out4 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if (SWIG_ConvertPtr(swig_obj[3], (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp4->isSTDOUT() == 1) { - arg4 = &std::cout; - } - else { - out4.open(temp4->getFilename()); - out4.precision(temp4->getPrecision()); - arg4 = &out4; - } - } - { - try { - (arg1)->PrintCharacteristics(arg2,arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } - return resultobj; -fail: - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - (arg1)->PrintCharacteristics(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->PrintCharacteristics(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->PrintCharacteristics(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintCharacteristics", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[3], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintCharacteristics'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *,std::ostream &)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->PrintInfo(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->PrintInfo(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); - } - arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - int result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FindPoints", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__InverseElementTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FindPoints'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool,mfem::InverseElementTransformation *)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_32(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_33(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_34(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_35(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_36(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_37(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - double arg6 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_38(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_39(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_40(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[13] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_Mesh__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_3(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_29(self, argc, argv); - } - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_21(self, argc, argv); - } - } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_25(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_28(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_30(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_20(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_24(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_27(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_31(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_8(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_40(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_23(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - return _wrap_new_Mesh__SWIG_19(self, argc, argv); - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_26(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_7(self, argc, argv); - } - } - } - } + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - if (argc == 4) { - int _v; + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); + } + arg3 = reinterpret_cast< char * >(buf3); + if (swig_obj[3]) { { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_36(self, argc, argv); - } - } - } + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + { + try { + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_13(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } } - if (argc == 4) { + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return resultobj; +fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[13] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_Mesh__SWIG_1(self, argc, argv); + } + if ((argc >= 1) && (argc <= 2)) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_2(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); } if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_39(self, argc, argv); - } - } + return _wrap_new_Mesh__SWIG_2(self, argc, argv); } } } - if (argc == 4) { + if ((argc >= 1) && (argc <= 4)) { int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23135,6 +14644,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23144,42 +14656,21 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Mesh__SWIG_22(self, argc, argv); + return _wrap_new_Mesh__SWIG_9(self, argc, argv); } } } } } - if (argc == 4) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - return _wrap_new_Mesh__SWIG_14(self, argc, argv); - } - } - if (argc == 4) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_18(self, argc, argv); - } - } - } - if (argc == 5) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -23190,60 +14681,26 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_7(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_double(argv[1], NULL); + _v = SWIG_CheckState(res); } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_6(self, argc, argv); - } - } - } + return _wrap_new_Mesh__SWIG_7(self, argc, argv); } } } - if (argc == 5) { + if ((argc >= 1) && (argc <= 4)) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_8(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23253,6 +14710,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_Mesh__SWIG_8(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23262,106 +14722,69 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_35(self, argc, argv); - } + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_8(self, argc, argv); } - } - } - } - } - if (argc == 5) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_38(self, argc, argv); - } + return _wrap_new_Mesh__SWIG_8(self, argc, argv); } } } } } - if (argc == 5) { + if (argc == 2) { int _v; - { - _v = 0; // ignore this pattern - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_new_Mesh__SWIG_13(self, argc, argv); + return _wrap_new_Mesh__SWIG_10(self, argc, argv); } } } - if (argc == 5) { + if (argc == 3) { int _v; - { - _v = 0; // ignore this pattern - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_new_Mesh__SWIG_17(self, argc, argv); + return _wrap_new_Mesh__SWIG_11(self, argc, argv); } } } } - if (argc == 6) { + if ((argc >= 3) && (argc <= 5)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -23390,9 +14813,21 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_4(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_4(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23402,20 +14837,14 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_34(self, argc, argv); - } + return _wrap_new_Mesh__SWIG_4(self, argc, argv); } } } } } } - if (argc == 6) { + if ((argc >= 3) && (argc <= 6)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -23438,6 +14867,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_13(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23447,125 +14879,23 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_13(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_37(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 6) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_16(self, argc, argv); - } - } - } - } - } - if (argc == 6) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_12(self, argc, argv); - } - } - } - } - if (argc == 7) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_13(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[5], NULL); _v = SWIG_CheckState(res); } if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_33(self, argc, argv); - } + return _wrap_new_Mesh__SWIG_13(self, argc, argv); } } } @@ -23573,67 +14903,52 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 7) { + if ((argc >= 3) && (argc <= 7)) { int _v; { _v = 0; // ignore this pattern } if (_v) { + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[5], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 6) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[6], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Mesh__SWIG_15(self, argc, argv); + return _wrap_new_Mesh__SWIG_6(self, argc, argv); } } } } } } - if (argc == 7) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_11(self, argc, argv); - } - } - } - } - } - if (argc == 8) { + if ((argc >= 4) && (argc <= 8)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -23665,6 +14980,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23674,22 +14992,31 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[5], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 6) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[6], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 7) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[7], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Mesh__SWIG_32(self, argc, argv); + return _wrap_new_Mesh__SWIG_12(self, argc, argv); } } } @@ -23699,152 +15026,53 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 8) { + if ((argc >= 4) && (argc <= 9)) { int _v; { _v = 0; // ignore this pattern } if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_10(self, argc, argv); - } - } - } + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); } - } - } - if (argc == 9) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { { int res = SWIG_AsVal_bool(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[5], NULL); _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[8], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_9(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 11) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); + } if (_v) { + if (argc <= 6) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } { - int res = SWIG_AsVal_int(argv[3], NULL); + int res = SWIG_AsVal_double(argv[6], NULL); _v = SWIG_CheckState(res); } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); + if (argc <= 7) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } if (_v) { + if (argc <= 8) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[8], NULL); + _v = SWIG_CheckState(res); } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_5(self, argc, argv); - } - } - } - } - } + return _wrap_new_Mesh__SWIG_5(self, argc, argv); } } } @@ -23852,7 +15080,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 12) { + if ((argc >= 11) && (argc <= 12)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); @@ -23920,6 +15148,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 11) { + return _wrap_new_Mesh__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[11]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -23929,7 +15160,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Mesh__SWIG_4(self, argc, argv); + return _wrap_new_Mesh__SWIG_3(self, argc, argv); } } } @@ -23949,49 +15180,22 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::Mesh::Mesh()\n" " mfem::Mesh::Mesh(mfem::Mesh const &,bool)\n" - " mfem::Mesh::Mesh(mfem::Mesh const &)\n" " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int,int)\n" - " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int)\n" " mfem::Mesh::Mesh(int,int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int)\n" " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type)\n" " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type)\n" " mfem::Mesh::Mesh(int,double)\n" - " mfem::Mesh::Mesh(int)\n" " mfem::Mesh::Mesh(char const *,int,int,bool)\n" - " mfem::Mesh::Mesh(char const *,int,int)\n" - " mfem::Mesh::Mesh(char const *,int)\n" - " mfem::Mesh::Mesh(char const *)\n" " mfem::Mesh::Mesh(std::istream &,int,int,bool)\n" - " mfem::Mesh::Mesh(std::istream &,int,int)\n" - " mfem::Mesh::Mesh(std::istream &,int)\n" - " mfem::Mesh::Mesh(std::istream &)\n" " mfem::Mesh::Mesh(mfem::Mesh *[],int)\n" " mfem::Mesh::Mesh(mfem::Mesh *,int,int)\n" " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,int,char const *)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,char const *)\n"); + " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; @@ -24001,24 +15205,29 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mesh_file", (char *)"precision", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintToFile", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_PrintToFile", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintToFile" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintToFile" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -24067,26 +15276,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetAttributeArray(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertexArray", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetVertexArray", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -24234,26 +15447,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttributeArray(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrArray", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrArray", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -24270,26 +15487,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetDomainArray", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetDomainArray", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetDomainArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -24306,18 +15527,18 @@ SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -24328,53 +15549,17 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2); + mfem_Mesh_PrintInfo__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24397,34 +15582,15 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintInfo", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_Mesh_PrintInfo__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -24439,7 +15605,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -24448,6 +15614,9 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -24457,7 +15626,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_2(self, argc, argv); + return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); } } } @@ -24467,25 +15636,23 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintInfo'.\n" " Possible C/C++ prototypes are:\n" " mfem::Mesh::PrintInfo(std::ostream &)\n" - " mfem::Mesh::PrintInfo()\n" - " mfem::Mesh::PrintInfo(char const *,int)\n" - " mfem::Mesh::PrintInfo(char const *)\n"); + " mfem::Mesh::PrintInfo(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -24496,53 +15663,17 @@ SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2); + mfem_Mesh_Print__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24565,34 +15696,15 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_Mesh_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -24607,7 +15719,7 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -24616,6 +15728,9 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Mesh_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -24625,7 +15740,7 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_Print__SWIG_2(self, argc, argv); + return _wrap_Mesh_Print__SWIG_1(self, argc, argv); } } } @@ -24635,25 +15750,23 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Mesh::Print(std::ostream &) const\n" - " mfem::Mesh::Print() const\n" - " mfem::Mesh::Print(char const *,int)\n" - " mfem::Mesh::Print(char const *)\n"); + " mfem::Mesh::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -24664,53 +15777,17 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2); + mfem_Mesh_PrintXG__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24733,34 +15810,15 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintXG", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -24775,7 +15833,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -24784,6 +15842,9 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -24793,7 +15854,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_PrintXG__SWIG_2(self, argc, argv); + return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); } } } @@ -24803,25 +15864,23 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintXG'.\n" " Possible C/C++ prototypes are:\n" " mfem::Mesh::PrintXG(std::ostream &) const\n" - " mfem::Mesh::PrintXG() const\n" - " mfem::Mesh::PrintXG(char const *,int)\n" - " mfem::Mesh::PrintXG(char const *)\n"); + " mfem::Mesh::PrintXG(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -24832,53 +15891,17 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2); + mfem_Mesh_PrintVTK__SWIG_2(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -24901,7 +15924,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTK", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -24910,39 +15933,9 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -24952,12 +15945,12 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_3(self, argc, argv); + return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); } } } } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -24973,21 +15966,11 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); - } + return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -25012,6 +15995,9 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 3) { + return _wrap_Mesh_PrintVTK__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -25033,9 +16019,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::Mesh::PrintVTK(std::ostream &)\n" " mfem::Mesh::PrintVTK(std::ostream &,int,int)\n" - " mfem::Mesh::PrintVTK(std::ostream &,int)\n" - " mfem::Mesh::PrintVTK(char const *,int)\n" - " mfem::Mesh::PrintVTK(char const *)\n"); + " mfem::Mesh::PrintVTK(char const *,int)\n"); return 0; } @@ -25301,7 +16285,7 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -25310,16 +16294,21 @@ SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"ir", (char *)"flags", NULL + }; mfem::GeometricFactors *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_GeometricFactors", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_GeometricFactors", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -25328,10 +16317,10 @@ SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -25751,7 +16740,7 @@ SWIGINTERN PyObject *_wrap_FaceGeometricFactors_type_get(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -25763,16 +16752,22 @@ SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"ir", (char *)"flags", (char *)"type", NULL + }; mfem::FaceGeometricFactors *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_FaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_FaceGeometricFactors", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -25781,12 +16776,12 @@ SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); } @@ -26054,25 +17049,29 @@ SWIGINTERN PyObject *FaceGeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_NodeExtrudeCoefficient_SetLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodeExtrudeCoefficient_SetLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodeExtrudeCoefficient *arg1 = (mfem::NodeExtrudeCoefficient *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"l", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodeExtrudeCoefficient_SetLayer", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodeExtrudeCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NodeExtrudeCoefficient_SetLayer", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodeExtrudeCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeExtrudeCoefficient_SetLayer" "', argument " "1"" of type '" "mfem::NodeExtrudeCoefficient *""'"); } arg1 = reinterpret_cast< mfem::NodeExtrudeCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -26403,42 +17402,51 @@ SWIGINTERN PyObject *NodeExtrudeCoefficient_swigregister(PyObject *SWIGUNUSEDPAR return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Extrude1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; double arg3 ; - bool arg4 ; + bool arg4 = (bool) (bool)false ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"ny", (char *)"sy", (char *)"closed", NULL + }; mfem::Mesh *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Extrude1D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude1D" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Extrude1D" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Extrude1D" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Extrude1D" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { result = (mfem::Mesh *)mfem::Extrude1D(arg1,arg2,arg3,arg4); @@ -26454,7 +17462,7 @@ SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; @@ -26463,139 +17471,27 @@ SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ int res1 = 0 ; double val3 ; int ecode3 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude1D" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Extrude1D" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::Mesh *)mfem::Extrude1D(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Extrude1D(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"nz", (char *)"sz", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Extrude1D", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Extrude1D__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Extrude1D__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Extrude1D'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Extrude1D(mfem::Mesh *,int const,double const,bool const)\n" - " mfem::Extrude1D(mfem::Mesh *,int const,double const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; mfem::Mesh *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Extrude2D", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Extrude2D", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude2D" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Extrude2D" "', argument " "3"" of type '" "double""'"); } @@ -26615,7 +17511,7 @@ SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -26626,10 +17522,15 @@ SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ShiftRight", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ShiftRight", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } @@ -26637,7 +17538,7 @@ SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } @@ -26645,7 +17546,7 @@ SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShiftRight" "', argument " "3"" of type '" "int &""'"); } @@ -26683,36 +17584,36 @@ static PyMethodDef SwigMethods[] = { { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, - { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "Mesh_NewElement(Mesh self, int geom) -> Element"}, - { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "Mesh_AddVertex(Mesh self, double const * arg2)"}, - { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "Mesh_AddSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "Mesh_AddTri(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "Mesh_AddTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "Mesh_AddQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTet", _wrap_Mesh_AddTet, METH_VARARGS, "Mesh_AddTet(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddWedge", _wrap_Mesh_AddWedge, METH_VARARGS, "Mesh_AddWedge(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHex", _wrap_Mesh_AddHex, METH_VARARGS, "Mesh_AddHex(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsTets", _wrap_Mesh_AddHexAsTets, METH_VARARGS, "Mesh_AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsWedges", _wrap_Mesh_AddHexAsWedges, METH_VARARGS, "Mesh_AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddElement", _wrap_Mesh_AddElement, METH_VARARGS, "Mesh_AddElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrElement", _wrap_Mesh_AddBdrElement, METH_VARARGS, "Mesh_AddBdrElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrSegment", _wrap_Mesh_AddBdrSegment, METH_VARARGS, "Mesh_AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrTriangle", _wrap_Mesh_AddBdrTriangle, METH_VARARGS, "Mesh_AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuad", _wrap_Mesh_AddBdrQuad, METH_VARARGS, "Mesh_AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuadAsTriangles", _wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS, "Mesh_AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_NewElement", (PyCFunction)(void(*)(void))_wrap_Mesh_NewElement, METH_VARARGS|METH_KEYWORDS, "Mesh_NewElement(Mesh self, int geom) -> Element"}, + { "Mesh_AddVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddVertex, METH_VARARGS|METH_KEYWORDS, "Mesh_AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddSegment, METH_VARARGS|METH_KEYWORDS, "Mesh_AddSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTri", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTri, METH_VARARGS|METH_KEYWORDS, "Mesh_AddTri(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTriangle, METH_VARARGS|METH_KEYWORDS, "Mesh_AddTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddQuad, METH_VARARGS|METH_KEYWORDS, "Mesh_AddQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTet", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTet, METH_VARARGS|METH_KEYWORDS, "Mesh_AddTet(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddWedge", (PyCFunction)(void(*)(void))_wrap_Mesh_AddWedge, METH_VARARGS|METH_KEYWORDS, "Mesh_AddWedge(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHex, METH_VARARGS|METH_KEYWORDS, "Mesh_AddHex(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsTets", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsTets, METH_VARARGS|METH_KEYWORDS, "Mesh_AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsWedges", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsWedges, METH_VARARGS|METH_KEYWORDS, "Mesh_AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddElement, METH_VARARGS|METH_KEYWORDS, "Mesh_AddElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrElement, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrSegment, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrTriangle, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuad, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuadAsTriangles", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, { "Mesh_GenerateBoundaryElements", _wrap_Mesh_GenerateBoundaryElements, METH_O, "Mesh_GenerateBoundaryElements(Mesh self)"}, - { "Mesh_FinalizeTriMesh", _wrap_Mesh_FinalizeTriMesh, METH_VARARGS, "Mesh_FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeQuadMesh", _wrap_Mesh_FinalizeQuadMesh, METH_VARARGS, "Mesh_FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTetMesh", _wrap_Mesh_FinalizeTetMesh, METH_VARARGS, "Mesh_FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "Mesh_FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "Mesh_FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "Mesh_FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "Mesh_FinalizeTopology(Mesh self, bool generate_bdr=True)"}, - { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Mesh_Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, + { "Mesh_FinalizeTriMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTriMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeQuadMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeQuadMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTetMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTetMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeWedgeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeHexMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeHexMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTopology", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTopology, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeTopology(Mesh self, bool generate_bdr=True)"}, + { "Mesh_Finalize", (PyCFunction)(void(*)(void))_wrap_Mesh_Finalize, METH_VARARGS|METH_KEYWORDS, "Mesh_Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "Mesh_SetAttributes(Mesh self)"}, - { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "Mesh_GetHilbertElementOrdering(Mesh self, intArray ordering)"}, - { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "Mesh_ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, - { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Mesh_Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "Mesh_GetHilbertElementOrdering", (PyCFunction)(void(*)(void))_wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS|METH_KEYWORDS, "Mesh_GetHilbertElementOrdering(Mesh self, intArray ordering)"}, + { "Mesh_ReorderElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ReorderElements, METH_VARARGS|METH_KEYWORDS, "Mesh_ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, + { "Mesh_Load", (PyCFunction)(void(*)(void))_wrap_Mesh_Load, METH_VARARGS|METH_KEYWORDS, "Mesh_Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Mesh_Clear(Mesh self)"}, { "Mesh_MeshGenerator", _wrap_Mesh_MeshGenerator, METH_O, "Mesh_MeshGenerator(Mesh self) -> int"}, { "Mesh_GetNV", _wrap_Mesh_GetNV, METH_O, "Mesh_GetNV(Mesh self) -> int"}, @@ -26721,11 +17622,11 @@ static PyMethodDef SwigMethods[] = { { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "Mesh_GetNEdges(Mesh self) -> int"}, { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "Mesh_GetNFaces(Mesh self) -> int"}, { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "Mesh_GetNumFaces(Mesh self) -> int"}, - { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "Mesh_GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, - { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "Mesh_ReduceInt(Mesh self, int value) -> long"}, + { "Mesh_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, + { "Mesh_ReduceInt", (PyCFunction)(void(*)(void))_wrap_Mesh_ReduceInt, METH_VARARGS|METH_KEYWORDS, "Mesh_ReduceInt(Mesh self, int value) -> long"}, { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "Mesh_GetGlobalNE(Mesh self) -> long"}, - { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "Mesh_GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, - { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "Mesh_GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "Mesh_GetGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometricFactors, METH_VARARGS|METH_KEYWORDS, "Mesh_GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "Mesh_DeleteGeometricFactors(Mesh self)"}, { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "Mesh_EulerNumber(Mesh self) -> int"}, { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "Mesh_EulerNumber2D(Mesh self) -> int"}, @@ -26735,9 +17636,9 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetVertex(Mesh self, int i) -> double const\n" "Mesh_GetVertex(Mesh self, int i) -> double *\n" ""}, - { "Mesh_GetElementData", _wrap_Mesh_GetElementData, METH_VARARGS, "Mesh_GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, - { "Mesh_GetBdrElementData", _wrap_Mesh_GetBdrElementData, METH_VARARGS, "Mesh_GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, - { "Mesh_ChangeVertexDataOwnership", _wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS, "Mesh_ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, + { "Mesh_GetElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementData, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, + { "Mesh_GetBdrElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementData, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, + { "Mesh_ChangeVertexDataOwnership", (PyCFunction)(void(*)(void))_wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS|METH_KEYWORDS, "Mesh_ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, { "Mesh_GetElementsArray", _wrap_Mesh_GetElementsArray, METH_O, "Mesh_GetElementsArray(Mesh self) -> mfem::Element const *const *"}, { "Mesh_GetElement", _wrap_Mesh_GetElement, METH_VARARGS, "\n" "Mesh_GetElement(Mesh self, int i) -> Element\n" @@ -26747,30 +17648,30 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetBdrElement(Mesh self, int i) -> Element\n" "Mesh_GetBdrElement(Mesh self, int i) -> Element\n" ""}, - { "Mesh_GetFace", _wrap_Mesh_GetFace, METH_VARARGS, "Mesh_GetFace(Mesh self, int i) -> Element"}, - { "Mesh_GetFaceBaseGeometry", _wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS, "Mesh_GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetElementBaseGeometry", _wrap_Mesh_GetElementBaseGeometry, METH_VARARGS, "Mesh_GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetBdrElementBaseGeometry", _wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS, "Mesh_GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_HasGeometry", _wrap_Mesh_HasGeometry, METH_VARARGS, "Mesh_HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, - { "Mesh_GetNumGeometries", _wrap_Mesh_GetNumGeometries, METH_VARARGS, "Mesh_GetNumGeometries(Mesh self, int dim) -> int"}, - { "Mesh_GetGeometries", _wrap_Mesh_GetGeometries, METH_VARARGS, "Mesh_GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, - { "Mesh_GetElementVertices", _wrap_Mesh_GetElementVertices, METH_VARARGS, "Mesh_GetElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetBdrElementVertices", _wrap_Mesh_GetBdrElementVertices, METH_VARARGS, "Mesh_GetBdrElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetElementEdges", _wrap_Mesh_GetElementEdges, METH_VARARGS, "Mesh_GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetBdrElementEdges", _wrap_Mesh_GetBdrElementEdges, METH_VARARGS, "Mesh_GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetFaceEdges", _wrap_Mesh_GetFaceEdges, METH_VARARGS, "Mesh_GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetFaceVertices", _wrap_Mesh_GetFaceVertices, METH_VARARGS, "Mesh_GetFaceVertices(Mesh self, int i, intArray vert)"}, - { "Mesh_GetEdgeVertices", _wrap_Mesh_GetEdgeVertices, METH_VARARGS, "Mesh_GetEdgeVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetFace", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFace, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFace(Mesh self, int i) -> Element"}, + { "Mesh_GetFaceBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetBdrElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_HasGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_HasGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, + { "Mesh_GetNumGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNumGeometries, METH_VARARGS|METH_KEYWORDS, "Mesh_GetNumGeometries(Mesh self, int dim) -> int"}, + { "Mesh_GetGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometries, METH_VARARGS|METH_KEYWORDS, "Mesh_GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, + { "Mesh_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetBdrElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementEdges, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetBdrElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdges, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetFaceEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceEdges, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetEdgeVertices(Mesh self, int i, intArray vert)"}, { "Mesh_GetFaceEdgeTable", _wrap_Mesh_GetFaceEdgeTable, METH_O, "Mesh_GetFaceEdgeTable(Mesh self) -> Table"}, { "Mesh_GetEdgeVertexTable", _wrap_Mesh_GetEdgeVertexTable, METH_O, "Mesh_GetEdgeVertexTable(Mesh self) -> Table"}, - { "Mesh_GetElementFaces", _wrap_Mesh_GetElementFaces, METH_VARARGS, "Mesh_GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetBdrElementEdgeIndex", _wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS, "Mesh_GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, - { "Mesh_GetBdrElementAdjacentElement", _wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS, "Mesh_GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, - { "Mesh_GetElementType", _wrap_Mesh_GetElementType, METH_VARARGS, "Mesh_GetElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetBdrElementType", _wrap_Mesh_GetBdrElementType, METH_VARARGS, "Mesh_GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetPointMatrix", _wrap_Mesh_GetPointMatrix, METH_VARARGS, "Mesh_GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetBdrPointMatrix", _wrap_Mesh_GetBdrPointMatrix, METH_VARARGS, "Mesh_GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetTransformationFEforElementType", _wrap_Mesh_GetTransformationFEforElementType, METH_O, "Mesh_GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, + { "Mesh_GetElementFaces", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementFaces, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetBdrElementEdgeIndex", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, + { "Mesh_GetBdrElementAdjacentElement", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, + { "Mesh_GetElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetPointMatrix, METH_VARARGS|METH_KEYWORDS, "Mesh_GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetBdrPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrPointMatrix, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetTransformationFEforElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetTransformationFEforElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, { "Mesh_GetElementTransformation", _wrap_Mesh_GetElementTransformation, METH_VARARGS, "\n" "Mesh_GetElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" "Mesh_GetElementTransformation(Mesh self, int i) -> ElementTransformation\n" @@ -26780,7 +17681,7 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetBdrElementTransformation(Mesh self, int i) -> ElementTransformation\n" "Mesh_GetBdrElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "Mesh_GetLocalFaceTransformation", _wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS, "Mesh_GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, + { "Mesh_GetLocalFaceTransformation", (PyCFunction)(void(*)(void))_wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS|METH_KEYWORDS, "Mesh_GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, { "Mesh_GetFaceTransformation", _wrap_Mesh_GetFaceTransformation, METH_VARARGS, "\n" "Mesh_GetFaceTransformation(Mesh self, int i, IsoparametricTransformation FTr)\n" "Mesh_GetFaceTransformation(Mesh self, int FaceNo) -> ElementTransformation\n" @@ -26789,58 +17690,58 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetEdgeTransformation(Mesh self, int i, IsoparametricTransformation EdTr)\n" "Mesh_GetEdgeTransformation(Mesh self, int EdgeNo) -> ElementTransformation\n" ""}, - { "Mesh_GetFaceElementTransformations", _wrap_Mesh_GetFaceElementTransformations, METH_VARARGS, "Mesh_GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, - { "Mesh_GetInteriorFaceTransformations", _wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS, "Mesh_GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, - { "Mesh_GetBdrFaceTransformations", _wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS, "Mesh_GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, - { "Mesh_FaceIsInterior", _wrap_Mesh_FaceIsInterior, METH_VARARGS, "Mesh_FaceIsInterior(Mesh self, int FaceNo) -> bool"}, - { "Mesh_GetFaceElements", _wrap_Mesh_GetFaceElements, METH_VARARGS, "Mesh_GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, - { "Mesh_GetFaceInfos", _wrap_Mesh_GetFaceInfos, METH_VARARGS, "Mesh_GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, - { "Mesh_GetFaceGeometryType", _wrap_Mesh_GetFaceGeometryType, METH_VARARGS, "Mesh_GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, - { "Mesh_GetFaceElementType", _wrap_Mesh_GetFaceElementType, METH_VARARGS, "Mesh_GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, - { "Mesh_CheckElementOrientation", _wrap_Mesh_CheckElementOrientation, METH_VARARGS, "Mesh_CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_CheckBdrElementOrientation", _wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS, "Mesh_CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_GetAttribute", _wrap_Mesh_GetAttribute, METH_VARARGS, "Mesh_GetAttribute(Mesh self, int i) -> int"}, - { "Mesh_SetAttribute", _wrap_Mesh_SetAttribute, METH_VARARGS, "Mesh_SetAttribute(Mesh self, int i, int attr)"}, - { "Mesh_GetBdrAttribute", _wrap_Mesh_GetBdrAttribute, METH_VARARGS, "Mesh_GetBdrAttribute(Mesh self, int i) -> int"}, + { "Mesh_GetFaceElementTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementTransformations, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, + { "Mesh_GetInteriorFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS|METH_KEYWORDS, "Mesh_GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, + { "Mesh_GetBdrFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, + { "Mesh_FaceIsInterior", (PyCFunction)(void(*)(void))_wrap_Mesh_FaceIsInterior, METH_VARARGS|METH_KEYWORDS, "Mesh_FaceIsInterior(Mesh self, int FaceNo) -> bool"}, + { "Mesh_GetFaceElements", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElements, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, + { "Mesh_GetFaceInfos", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceInfos, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, + { "Mesh_GetFaceGeometryType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometryType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, + { "Mesh_GetFaceElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, + { "Mesh_CheckElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckElementOrientation, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_CheckBdrElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_GetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetAttribute, METH_VARARGS|METH_KEYWORDS, "Mesh_GetAttribute(Mesh self, int i) -> int"}, + { "Mesh_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_SetAttribute, METH_VARARGS|METH_KEYWORDS, "Mesh_SetAttribute(Mesh self, int i, int attr)"}, + { "Mesh_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrAttribute(Mesh self, int i) -> int"}, { "Mesh_ElementToElementTable", _wrap_Mesh_ElementToElementTable, METH_O, "Mesh_ElementToElementTable(Mesh self) -> Table"}, { "Mesh_ElementToFaceTable", _wrap_Mesh_ElementToFaceTable, METH_O, "Mesh_ElementToFaceTable(Mesh self) -> Table"}, { "Mesh_ElementToEdgeTable", _wrap_Mesh_ElementToEdgeTable, METH_O, "Mesh_ElementToEdgeTable(Mesh self) -> Table"}, { "Mesh_GetVertexToElementTable", _wrap_Mesh_GetVertexToElementTable, METH_O, "Mesh_GetVertexToElementTable(Mesh self) -> Table"}, { "Mesh_GetFaceToElementTable", _wrap_Mesh_GetFaceToElementTable, METH_O, "Mesh_GetFaceToElementTable(Mesh self) -> Table"}, { "Mesh_ReorientTetMesh", _wrap_Mesh_ReorientTetMesh, METH_O, "Mesh_ReorientTetMesh(Mesh self)"}, - { "Mesh_CartesianPartitioning", _wrap_Mesh_CartesianPartitioning, METH_VARARGS, "Mesh_CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, - { "Mesh_GeneratePartitioning", _wrap_Mesh_GeneratePartitioning, METH_VARARGS, "Mesh_GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int"}, - { "Mesh_CheckPartitioning", _wrap_Mesh_CheckPartitioning, METH_VARARGS, "Mesh_CheckPartitioning(Mesh self, int * partitioning)"}, - { "Mesh_CheckDisplacements", _wrap_Mesh_CheckDisplacements, METH_VARARGS, "Mesh_CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, - { "Mesh_MoveVertices", _wrap_Mesh_MoveVertices, METH_VARARGS, "Mesh_MoveVertices(Mesh self, Vector displacements)"}, - { "Mesh_GetVertices", _wrap_Mesh_GetVertices, METH_VARARGS, "Mesh_GetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_SetVertices", _wrap_Mesh_SetVertices, METH_VARARGS, "Mesh_SetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_GetNode", _wrap_Mesh_GetNode, METH_VARARGS, "Mesh_GetNode(Mesh self, int i, double * coord)"}, - { "Mesh_SetNode", _wrap_Mesh_SetNode, METH_VARARGS, "Mesh_SetNode(Mesh self, int i, double const * coord)"}, - { "Mesh_MoveNodes", _wrap_Mesh_MoveNodes, METH_VARARGS, "Mesh_MoveNodes(Mesh self, Vector displacements)"}, - { "Mesh_SetNodes", _wrap_Mesh_SetNodes, METH_VARARGS, "Mesh_SetNodes(Mesh self, Vector node_coord)"}, + { "Mesh_CartesianPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CartesianPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, + { "Mesh_GeneratePartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_GeneratePartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int *"}, + { "Mesh_CheckPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckPartitioning(Mesh self, int * partitioning)"}, + { "Mesh_CheckDisplacements", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckDisplacements, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, + { "Mesh_MoveVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_MoveVertices(Mesh self, Vector displacements)"}, + { "Mesh_GetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_SetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_SetVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_SetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_GetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNode, METH_VARARGS|METH_KEYWORDS, "Mesh_GetNode(Mesh self, int i, double * coord)"}, + { "Mesh_SetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNode, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNode(Mesh self, int i, double const * coord)"}, + { "Mesh_MoveNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_MoveNodes(Mesh self, Vector displacements)"}, + { "Mesh_SetNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodes(Mesh self, Vector node_coord)"}, { "Mesh_OwnsNodes", _wrap_Mesh_OwnsNodes, METH_O, "Mesh_OwnsNodes(Mesh self) -> bool"}, - { "Mesh_SetNodesOwner", _wrap_Mesh_SetNodesOwner, METH_VARARGS, "Mesh_SetNodesOwner(Mesh self, bool nodes_owner)"}, - { "Mesh_NewNodes", _wrap_Mesh_NewNodes, METH_VARARGS, "Mesh_NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, - { "Mesh_SwapNodes", _wrap_Mesh_SwapNodes, METH_VARARGS, "Mesh_SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, + { "Mesh_SetNodesOwner", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodesOwner, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodesOwner(Mesh self, bool nodes_owner)"}, + { "Mesh_NewNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_NewNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SwapNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SwapNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, { "Mesh_GetNodes", _wrap_Mesh_GetNodes, METH_VARARGS, "\n" "Mesh_GetNodes(Mesh self, Vector node_coord)\n" "Mesh_GetNodes(Mesh self) -> GridFunction\n" "Mesh_GetNodes(Mesh self) -> GridFunction\n" "Mesh_GetNodes(Mesh self, GridFunction nodes)\n" ""}, - { "Mesh_SetNodalFESpace", _wrap_Mesh_SetNodalFESpace, METH_VARARGS, "Mesh_SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, - { "Mesh_SetNodalGridFunction", _wrap_Mesh_SetNodalGridFunction, METH_VARARGS, "Mesh_SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SetNodalFESpace", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalFESpace, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, + { "Mesh_SetNodalGridFunction", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalGridFunction, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, { "Mesh_GetNodalFESpace", _wrap_Mesh_GetNodalFESpace, METH_O, "Mesh_GetNodalFESpace(Mesh self) -> FiniteElementSpace"}, { "Mesh_EnsureNodes", _wrap_Mesh_EnsureNodes, METH_O, "Mesh_EnsureNodes(Mesh self)"}, - { "Mesh_SetCurvature", _wrap_Mesh_SetCurvature, METH_VARARGS, "Mesh_SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, - { "Mesh_UniformRefinement", _wrap_Mesh_UniformRefinement, METH_VARARGS, "Mesh_UniformRefinement(Mesh self, int ref_algo=0)"}, + { "Mesh_SetCurvature", (PyCFunction)(void(*)(void))_wrap_Mesh_SetCurvature, METH_VARARGS|METH_KEYWORDS, "Mesh_SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "Mesh_UniformRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_UniformRefinement, METH_VARARGS|METH_KEYWORDS, "Mesh_UniformRefinement(Mesh self, int ref_algo=0)"}, { "Mesh_GeneralRefinement", _wrap_Mesh_GeneralRefinement, METH_VARARGS, "\n" "Mesh_GeneralRefinement(Mesh self, mfem::Array< mfem::Refinement > const & refinements, int nonconforming=-1, int nc_limit=0)\n" "Mesh_GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0)\n" ""}, - { "Mesh_RandomRefinement", _wrap_Mesh_RandomRefinement, METH_VARARGS, "Mesh_RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, - { "Mesh_RefineAtVertex", _wrap_Mesh_RefineAtVertex, METH_VARARGS, "Mesh_RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, + { "Mesh_RandomRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_RandomRefinement, METH_VARARGS|METH_KEYWORDS, "Mesh_RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, + { "Mesh_RefineAtVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_RefineAtVertex, METH_VARARGS|METH_KEYWORDS, "Mesh_RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, { "Mesh_RefineByError", _wrap_Mesh_RefineByError, METH_VARARGS, "\n" "Mesh_RefineByError(Mesh self, doubleArray elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" "Mesh_RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" @@ -26853,8 +17754,8 @@ static PyMethodDef SwigMethods[] = { "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" ""}, - { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "Mesh_DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, - { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "Mesh_EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, + { "Mesh_DegreeElevate", (PyCFunction)(void(*)(void))_wrap_Mesh_DegreeElevate, METH_VARARGS|METH_KEYWORDS, "Mesh_DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, + { "Mesh_EnsureNCMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_EnsureNCMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Mesh_Conforming(Mesh self) -> bool"}, { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Mesh_Nonconforming(Mesh self) -> bool"}, { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "Mesh_GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, @@ -26864,12 +17765,12 @@ static PyMethodDef SwigMethods[] = { "Mesh_PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" "Mesh_PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" ""}, - { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "Mesh_GetElementColoring(Mesh self, intArray colors, int el0=0)"}, - { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "Mesh_PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, - { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "Mesh_PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, - { "Mesh_PrintSurfaces", _wrap_Mesh_PrintSurfaces, METH_VARARGS, "Mesh_PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, - { "Mesh_ScaleSubdomains", _wrap_Mesh_ScaleSubdomains, METH_VARARGS, "Mesh_ScaleSubdomains(Mesh self, double sf)"}, - { "Mesh_ScaleElements", _wrap_Mesh_ScaleElements, METH_VARARGS, "Mesh_ScaleElements(Mesh self, double sf)"}, + { "Mesh_GetElementColoring", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementColoring, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementColoring(Mesh self, intArray colors, int el0=0)"}, + { "Mesh_PrintWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintWithPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, + { "Mesh_PrintElementsWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, + { "Mesh_PrintSurfaces", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintSurfaces, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, + { "Mesh_ScaleSubdomains", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleSubdomains, METH_VARARGS|METH_KEYWORDS, "Mesh_ScaleSubdomains(Mesh self, double sf)"}, + { "Mesh_ScaleElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleElements, METH_VARARGS|METH_KEYWORDS, "Mesh_ScaleElements(Mesh self, double sf)"}, { "Mesh_Transform", _wrap_Mesh_Transform, METH_VARARGS, "\n" "Mesh_Transform(Mesh self, void (*)(mfem::Vector const &,mfem::Vector &) f)\n" "Mesh_Transform(Mesh self, VectorCoefficient deformation)\n" @@ -26880,12 +17781,12 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetElementSize(Mesh self, int i, int type=0) -> double\n" "Mesh_GetElementSize(Mesh self, int i, Vector dir) -> double\n" ""}, - { "Mesh_GetElementVolume", _wrap_Mesh_GetElementVolume, METH_VARARGS, "Mesh_GetElementVolume(Mesh self, int i) -> double"}, - { "Mesh_GetBoundingBox", _wrap_Mesh_GetBoundingBox, METH_VARARGS, "Mesh_GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, - { "Mesh_GetCharacteristics", _wrap_Mesh_GetCharacteristics, METH_VARARGS, "Mesh_GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, - { "Mesh_PrintElementsByGeometry", _wrap_Mesh_PrintElementsByGeometry, METH_VARARGS, "Mesh_PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, - { "Mesh_PrintCharacteristics", _wrap_Mesh_PrintCharacteristics, METH_VARARGS, "Mesh_PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, - { "Mesh_FindPoints", _wrap_Mesh_FindPoints, METH_VARARGS, "Mesh_FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "Mesh_GetElementVolume", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVolume, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementVolume(Mesh self, int i) -> double"}, + { "Mesh_GetBoundingBox", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBoundingBox, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, + { "Mesh_GetCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_GetCharacteristics, METH_VARARGS|METH_KEYWORDS, "Mesh_GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, + { "Mesh_PrintElementsByGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsByGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, + { "Mesh_PrintCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintCharacteristics, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, + { "Mesh_FindPoints", (PyCFunction)(void(*)(void))_wrap_Mesh_FindPoints, METH_VARARGS|METH_KEYWORDS, "Mesh_FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, { "delete_Mesh", _wrap_delete_Mesh, METH_O, "delete_Mesh(Mesh self)"}, { "new_Mesh", _wrap_new_Mesh, METH_VARARGS, "\n" "Mesh()\n" @@ -26900,18 +17801,18 @@ static PyMethodDef SwigMethods[] = { "Mesh(mfem::Mesh *[] mesh_array, int num_pieces)\n" "Mesh(Mesh orig_mesh, int ref_factor, int ref_type)\n" "Mesh(int nx, int ny, int nz, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0, double sz=1.0)\n" - "Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0)\n" + "new_Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0) -> Mesh\n" ""}, - { "Mesh_PrintToFile", _wrap_Mesh_PrintToFile, METH_VARARGS, "Mesh_PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, + { "Mesh_PrintToFile", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintToFile, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, { "Mesh_GetAttributeArray", _wrap_Mesh_GetAttributeArray, METH_O, "Mesh_GetAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetVertexArray", _wrap_Mesh_GetVertexArray, METH_VARARGS, "Mesh_GetVertexArray(Mesh self, int i) -> PyObject *"}, + { "Mesh_GetVertexArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertexArray, METH_VARARGS|METH_KEYWORDS, "Mesh_GetVertexArray(Mesh self, int i) -> PyObject *"}, { "Mesh_GetBdrElementFace", _wrap_Mesh_GetBdrElementFace, METH_VARARGS, "\n" "Mesh_GetBdrElementFace(Mesh self, int i, int * arg3, int * arg4)\n" "Mesh_GetBdrElementFace(Mesh self, int i) -> PyObject *\n" ""}, { "Mesh_GetBdrAttributeArray", _wrap_Mesh_GetBdrAttributeArray, METH_O, "Mesh_GetBdrAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetBdrArray", _wrap_Mesh_GetBdrArray, METH_VARARGS, "Mesh_GetBdrArray(Mesh self, int idx) -> PyObject *"}, - { "Mesh_GetDomainArray", _wrap_Mesh_GetDomainArray, METH_VARARGS, "Mesh_GetDomainArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetBdrArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrArray, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetDomainArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetDomainArray, METH_VARARGS|METH_KEYWORDS, "Mesh_GetDomainArray(Mesh self, int idx) -> PyObject *"}, { "Mesh_PrintInfo", _wrap_Mesh_PrintInfo, METH_VARARGS, "\n" "Mesh_PrintInfo(Mesh self, std::ostream & out=mfem::out)\n" "Mesh_PrintInfo(Mesh self, char const * file, int precision=8)\n" @@ -26942,7 +17843,7 @@ static PyMethodDef SwigMethods[] = { { "GeometricFactors_IntRule_get", _wrap_GeometricFactors_IntRule_get, METH_O, "GeometricFactors_IntRule_get(GeometricFactors self) -> IntegrationRule"}, { "GeometricFactors_computed_factors_set", _wrap_GeometricFactors_computed_factors_set, METH_VARARGS, "GeometricFactors_computed_factors_set(GeometricFactors self, int computed_factors)"}, { "GeometricFactors_computed_factors_get", _wrap_GeometricFactors_computed_factors_get, METH_O, "GeometricFactors_computed_factors_get(GeometricFactors self) -> int"}, - { "new_GeometricFactors", _wrap_new_GeometricFactors, METH_VARARGS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, + { "new_GeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_GeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, { "GeometricFactors_X_set", _wrap_GeometricFactors_X_set, METH_VARARGS, "GeometricFactors_X_set(GeometricFactors self, Vector X)"}, { "GeometricFactors_X_get", _wrap_GeometricFactors_X_get, METH_O, "GeometricFactors_X_get(GeometricFactors self) -> Vector"}, { "GeometricFactors_J_set", _wrap_GeometricFactors_J_set, METH_VARARGS, "GeometricFactors_J_set(GeometricFactors self, Vector J)"}, @@ -26960,7 +17861,7 @@ static PyMethodDef SwigMethods[] = { { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, - { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "new_FaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_FaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, @@ -26972,7 +17873,7 @@ static PyMethodDef SwigMethods[] = { { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, - { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "NodeExtrudeCoefficient_SetLayer(NodeExtrudeCoefficient self, int const l)"}, + { "NodeExtrudeCoefficient_SetLayer", (PyCFunction)(void(*)(void))_wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS|METH_KEYWORDS, "NodeExtrudeCoefficient_SetLayer(NodeExtrudeCoefficient self, int const l)"}, { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" "NodeExtrudeCoefficient_Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "NodeExtrudeCoefficient_Eval(NodeExtrudeCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -26980,9 +17881,9 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_NodeExtrudeCoefficient", _wrap_delete_NodeExtrudeCoefficient, METH_O, "delete_NodeExtrudeCoefficient(NodeExtrudeCoefficient self)"}, { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, - { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, - { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, - { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, + { "Extrude1D", (PyCFunction)(void(*)(void))_wrap_Extrude1D, METH_VARARGS|METH_KEYWORDS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, + { "Extrude2D", (PyCFunction)(void(*)(void))_wrap_Extrude2D, METH_VARARGS|METH_KEYWORDS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, + { "ShiftRight", (PyCFunction)(void(*)(void))_wrap_ShiftRight, METH_VARARGS|METH_KEYWORDS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; @@ -27001,36 +17902,36 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, - { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "NewElement(Mesh self, int geom) -> Element"}, - { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "AddVertex(Mesh self, double const * arg2)"}, - { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "AddSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "AddTri(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "AddTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "AddQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTet", _wrap_Mesh_AddTet, METH_VARARGS, "AddTet(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddWedge", _wrap_Mesh_AddWedge, METH_VARARGS, "AddWedge(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHex", _wrap_Mesh_AddHex, METH_VARARGS, "AddHex(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsTets", _wrap_Mesh_AddHexAsTets, METH_VARARGS, "AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsWedges", _wrap_Mesh_AddHexAsWedges, METH_VARARGS, "AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddElement", _wrap_Mesh_AddElement, METH_VARARGS, "AddElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrElement", _wrap_Mesh_AddBdrElement, METH_VARARGS, "AddBdrElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrSegment", _wrap_Mesh_AddBdrSegment, METH_VARARGS, "AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrTriangle", _wrap_Mesh_AddBdrTriangle, METH_VARARGS, "AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuad", _wrap_Mesh_AddBdrQuad, METH_VARARGS, "AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuadAsTriangles", _wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS, "AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_NewElement", (PyCFunction)(void(*)(void))_wrap_Mesh_NewElement, METH_VARARGS|METH_KEYWORDS, "NewElement(Mesh self, int geom) -> Element"}, + { "Mesh_AddVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddVertex, METH_VARARGS|METH_KEYWORDS, "AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddSegment, METH_VARARGS|METH_KEYWORDS, "AddSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTri", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTri, METH_VARARGS|METH_KEYWORDS, "AddTri(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTriangle, METH_VARARGS|METH_KEYWORDS, "AddTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddQuad, METH_VARARGS|METH_KEYWORDS, "AddQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTet", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTet, METH_VARARGS|METH_KEYWORDS, "AddTet(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddWedge", (PyCFunction)(void(*)(void))_wrap_Mesh_AddWedge, METH_VARARGS|METH_KEYWORDS, "AddWedge(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHex, METH_VARARGS|METH_KEYWORDS, "AddHex(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsTets", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsTets, METH_VARARGS|METH_KEYWORDS, "AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsWedges", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsWedges, METH_VARARGS|METH_KEYWORDS, "AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddElement, METH_VARARGS|METH_KEYWORDS, "AddElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrElement, METH_VARARGS|METH_KEYWORDS, "AddBdrElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrSegment, METH_VARARGS|METH_KEYWORDS, "AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrTriangle, METH_VARARGS|METH_KEYWORDS, "AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuad, METH_VARARGS|METH_KEYWORDS, "AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuadAsTriangles", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS|METH_KEYWORDS, "AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, { "Mesh_GenerateBoundaryElements", _wrap_Mesh_GenerateBoundaryElements, METH_O, "GenerateBoundaryElements(Mesh self)"}, - { "Mesh_FinalizeTriMesh", _wrap_Mesh_FinalizeTriMesh, METH_VARARGS, "FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeQuadMesh", _wrap_Mesh_FinalizeQuadMesh, METH_VARARGS, "FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTetMesh", _wrap_Mesh_FinalizeTetMesh, METH_VARARGS, "FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "FinalizeTopology(Mesh self, bool generate_bdr=True)"}, - { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, + { "Mesh_FinalizeTriMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTriMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeQuadMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeQuadMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTetMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTetMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeWedgeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeHexMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeHexMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTopology", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTopology, METH_VARARGS|METH_KEYWORDS, "FinalizeTopology(Mesh self, bool generate_bdr=True)"}, + { "Mesh_Finalize", (PyCFunction)(void(*)(void))_wrap_Mesh_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "SetAttributes(Mesh self)"}, - { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "GetHilbertElementOrdering(Mesh self, intArray ordering)"}, - { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, - { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "Mesh_GetHilbertElementOrdering", (PyCFunction)(void(*)(void))_wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS|METH_KEYWORDS, "GetHilbertElementOrdering(Mesh self, intArray ordering)"}, + { "Mesh_ReorderElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ReorderElements, METH_VARARGS|METH_KEYWORDS, "ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, + { "Mesh_Load", (PyCFunction)(void(*)(void))_wrap_Mesh_Load, METH_VARARGS|METH_KEYWORDS, "Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Clear(Mesh self)"}, { "Mesh_MeshGenerator", _wrap_Mesh_MeshGenerator, METH_O, "MeshGenerator(Mesh self) -> int"}, { "Mesh_GetNV", _wrap_Mesh_GetNV, METH_O, "GetNV(Mesh self) -> int"}, @@ -27039,11 +17940,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "GetNEdges(Mesh self) -> int"}, { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "GetNFaces(Mesh self) -> int"}, { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "GetNumFaces(Mesh self) -> int"}, - { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, - { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "ReduceInt(Mesh self, int value) -> long"}, + { "Mesh_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, + { "Mesh_ReduceInt", (PyCFunction)(void(*)(void))_wrap_Mesh_ReduceInt, METH_VARARGS|METH_KEYWORDS, "ReduceInt(Mesh self, int value) -> long"}, { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "GetGlobalNE(Mesh self) -> long"}, - { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, - { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "Mesh_GetGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometricFactors, METH_VARARGS|METH_KEYWORDS, "GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "DeleteGeometricFactors(Mesh self)"}, { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "EulerNumber(Mesh self) -> int"}, { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "EulerNumber2D(Mesh self) -> int"}, @@ -27053,9 +17954,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetVertex(Mesh self, int i) -> double const\n" "GetVertex(Mesh self, int i) -> double *\n" ""}, - { "Mesh_GetElementData", _wrap_Mesh_GetElementData, METH_VARARGS, "GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, - { "Mesh_GetBdrElementData", _wrap_Mesh_GetBdrElementData, METH_VARARGS, "GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, - { "Mesh_ChangeVertexDataOwnership", _wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS, "ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, + { "Mesh_GetElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementData, METH_VARARGS|METH_KEYWORDS, "GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, + { "Mesh_GetBdrElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementData, METH_VARARGS|METH_KEYWORDS, "GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, + { "Mesh_ChangeVertexDataOwnership", (PyCFunction)(void(*)(void))_wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS|METH_KEYWORDS, "ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, { "Mesh_GetElementsArray", _wrap_Mesh_GetElementsArray, METH_O, "GetElementsArray(Mesh self) -> mfem::Element const *const *"}, { "Mesh_GetElement", _wrap_Mesh_GetElement, METH_VARARGS, "\n" "GetElement(Mesh self, int i) -> Element\n" @@ -27065,30 +17966,30 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetBdrElement(Mesh self, int i) -> Element\n" "GetBdrElement(Mesh self, int i) -> Element\n" ""}, - { "Mesh_GetFace", _wrap_Mesh_GetFace, METH_VARARGS, "GetFace(Mesh self, int i) -> Element"}, - { "Mesh_GetFaceBaseGeometry", _wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS, "GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetElementBaseGeometry", _wrap_Mesh_GetElementBaseGeometry, METH_VARARGS, "GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetBdrElementBaseGeometry", _wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS, "GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_HasGeometry", _wrap_Mesh_HasGeometry, METH_VARARGS, "HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, - { "Mesh_GetNumGeometries", _wrap_Mesh_GetNumGeometries, METH_VARARGS, "GetNumGeometries(Mesh self, int dim) -> int"}, - { "Mesh_GetGeometries", _wrap_Mesh_GetGeometries, METH_VARARGS, "GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, - { "Mesh_GetElementVertices", _wrap_Mesh_GetElementVertices, METH_VARARGS, "GetElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetBdrElementVertices", _wrap_Mesh_GetBdrElementVertices, METH_VARARGS, "GetBdrElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetElementEdges", _wrap_Mesh_GetElementEdges, METH_VARARGS, "GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetBdrElementEdges", _wrap_Mesh_GetBdrElementEdges, METH_VARARGS, "GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetFaceEdges", _wrap_Mesh_GetFaceEdges, METH_VARARGS, "GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetFaceVertices", _wrap_Mesh_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Mesh self, int i, intArray vert)"}, - { "Mesh_GetEdgeVertices", _wrap_Mesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetFace", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFace, METH_VARARGS|METH_KEYWORDS, "GetFace(Mesh self, int i) -> Element"}, + { "Mesh_GetFaceBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS|METH_KEYWORDS, "GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetBdrElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_HasGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_HasGeometry, METH_VARARGS|METH_KEYWORDS, "HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, + { "Mesh_GetNumGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNumGeometries, METH_VARARGS|METH_KEYWORDS, "GetNumGeometries(Mesh self, int dim) -> int"}, + { "Mesh_GetGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometries, METH_VARARGS|METH_KEYWORDS, "GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, + { "Mesh_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "GetElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetBdrElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementVertices, METH_VARARGS|METH_KEYWORDS, "GetBdrElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementEdges, METH_VARARGS|METH_KEYWORDS, "GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetBdrElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdges, METH_VARARGS|METH_KEYWORDS, "GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetFaceEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceEdges, METH_VARARGS|METH_KEYWORDS, "GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Mesh self, int i, intArray vert)"}, { "Mesh_GetFaceEdgeTable", _wrap_Mesh_GetFaceEdgeTable, METH_O, "GetFaceEdgeTable(Mesh self) -> Table"}, { "Mesh_GetEdgeVertexTable", _wrap_Mesh_GetEdgeVertexTable, METH_O, "GetEdgeVertexTable(Mesh self) -> Table"}, - { "Mesh_GetElementFaces", _wrap_Mesh_GetElementFaces, METH_VARARGS, "GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetBdrElementEdgeIndex", _wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS, "GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, - { "Mesh_GetBdrElementAdjacentElement", _wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS, "GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, - { "Mesh_GetElementType", _wrap_Mesh_GetElementType, METH_VARARGS, "GetElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetBdrElementType", _wrap_Mesh_GetBdrElementType, METH_VARARGS, "GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetPointMatrix", _wrap_Mesh_GetPointMatrix, METH_VARARGS, "GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetBdrPointMatrix", _wrap_Mesh_GetBdrPointMatrix, METH_VARARGS, "GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetTransformationFEforElementType", _wrap_Mesh_GetTransformationFEforElementType, METH_O, "GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, + { "Mesh_GetElementFaces", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementFaces, METH_VARARGS|METH_KEYWORDS, "GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetBdrElementEdgeIndex", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS|METH_KEYWORDS, "GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, + { "Mesh_GetBdrElementAdjacentElement", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS|METH_KEYWORDS, "GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, + { "Mesh_GetElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementType, METH_VARARGS|METH_KEYWORDS, "GetElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetPointMatrix, METH_VARARGS|METH_KEYWORDS, "GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetBdrPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrPointMatrix, METH_VARARGS|METH_KEYWORDS, "GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetTransformationFEforElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetTransformationFEforElementType, METH_VARARGS|METH_KEYWORDS, "GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, { "Mesh_GetElementTransformation", _wrap_Mesh_GetElementTransformation, METH_VARARGS, "\n" "GetElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" "GetElementTransformation(Mesh self, int i) -> ElementTransformation\n" @@ -27098,7 +17999,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetBdrElementTransformation(Mesh self, int i) -> ElementTransformation\n" "GetBdrElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "Mesh_GetLocalFaceTransformation", _wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS, "GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, + { "Mesh_GetLocalFaceTransformation", (PyCFunction)(void(*)(void))_wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS|METH_KEYWORDS, "GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, { "Mesh_GetFaceTransformation", _wrap_Mesh_GetFaceTransformation, METH_VARARGS, "\n" "GetFaceTransformation(Mesh self, int i, IsoparametricTransformation FTr)\n" "GetFaceTransformation(Mesh self, int FaceNo) -> ElementTransformation\n" @@ -27107,58 +18008,58 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetEdgeTransformation(Mesh self, int i, IsoparametricTransformation EdTr)\n" "GetEdgeTransformation(Mesh self, int EdgeNo) -> ElementTransformation\n" ""}, - { "Mesh_GetFaceElementTransformations", _wrap_Mesh_GetFaceElementTransformations, METH_VARARGS, "GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, - { "Mesh_GetInteriorFaceTransformations", _wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS, "GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, - { "Mesh_GetBdrFaceTransformations", _wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS, "GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, - { "Mesh_FaceIsInterior", _wrap_Mesh_FaceIsInterior, METH_VARARGS, "FaceIsInterior(Mesh self, int FaceNo) -> bool"}, - { "Mesh_GetFaceElements", _wrap_Mesh_GetFaceElements, METH_VARARGS, "GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, - { "Mesh_GetFaceInfos", _wrap_Mesh_GetFaceInfos, METH_VARARGS, "GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, - { "Mesh_GetFaceGeometryType", _wrap_Mesh_GetFaceGeometryType, METH_VARARGS, "GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, - { "Mesh_GetFaceElementType", _wrap_Mesh_GetFaceElementType, METH_VARARGS, "GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, - { "Mesh_CheckElementOrientation", _wrap_Mesh_CheckElementOrientation, METH_VARARGS, "CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_CheckBdrElementOrientation", _wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS, "CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_GetAttribute", _wrap_Mesh_GetAttribute, METH_VARARGS, "GetAttribute(Mesh self, int i) -> int"}, - { "Mesh_SetAttribute", _wrap_Mesh_SetAttribute, METH_VARARGS, "SetAttribute(Mesh self, int i, int attr)"}, - { "Mesh_GetBdrAttribute", _wrap_Mesh_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(Mesh self, int i) -> int"}, + { "Mesh_GetFaceElementTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementTransformations, METH_VARARGS|METH_KEYWORDS, "GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, + { "Mesh_GetInteriorFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS|METH_KEYWORDS, "GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, + { "Mesh_GetBdrFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS|METH_KEYWORDS, "GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, + { "Mesh_FaceIsInterior", (PyCFunction)(void(*)(void))_wrap_Mesh_FaceIsInterior, METH_VARARGS|METH_KEYWORDS, "FaceIsInterior(Mesh self, int FaceNo) -> bool"}, + { "Mesh_GetFaceElements", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElements, METH_VARARGS|METH_KEYWORDS, "GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, + { "Mesh_GetFaceInfos", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceInfos, METH_VARARGS|METH_KEYWORDS, "GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, + { "Mesh_GetFaceGeometryType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometryType, METH_VARARGS|METH_KEYWORDS, "GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, + { "Mesh_GetFaceElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementType, METH_VARARGS|METH_KEYWORDS, "GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, + { "Mesh_CheckElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckElementOrientation, METH_VARARGS|METH_KEYWORDS, "CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_CheckBdrElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS|METH_KEYWORDS, "CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_GetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetAttribute, METH_VARARGS|METH_KEYWORDS, "GetAttribute(Mesh self, int i) -> int"}, + { "Mesh_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_SetAttribute, METH_VARARGS|METH_KEYWORDS, "SetAttribute(Mesh self, int i, int attr)"}, + { "Mesh_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "GetBdrAttribute(Mesh self, int i) -> int"}, { "Mesh_ElementToElementTable", _wrap_Mesh_ElementToElementTable, METH_O, "ElementToElementTable(Mesh self) -> Table"}, { "Mesh_ElementToFaceTable", _wrap_Mesh_ElementToFaceTable, METH_O, "ElementToFaceTable(Mesh self) -> Table"}, { "Mesh_ElementToEdgeTable", _wrap_Mesh_ElementToEdgeTable, METH_O, "ElementToEdgeTable(Mesh self) -> Table"}, { "Mesh_GetVertexToElementTable", _wrap_Mesh_GetVertexToElementTable, METH_O, "GetVertexToElementTable(Mesh self) -> Table"}, { "Mesh_GetFaceToElementTable", _wrap_Mesh_GetFaceToElementTable, METH_O, "GetFaceToElementTable(Mesh self) -> Table"}, { "Mesh_ReorientTetMesh", _wrap_Mesh_ReorientTetMesh, METH_O, "ReorientTetMesh(Mesh self)"}, - { "Mesh_CartesianPartitioning", _wrap_Mesh_CartesianPartitioning, METH_VARARGS, "CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, - { "Mesh_GeneratePartitioning", _wrap_Mesh_GeneratePartitioning, METH_VARARGS, "GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int"}, - { "Mesh_CheckPartitioning", _wrap_Mesh_CheckPartitioning, METH_VARARGS, "CheckPartitioning(Mesh self, int * partitioning)"}, - { "Mesh_CheckDisplacements", _wrap_Mesh_CheckDisplacements, METH_VARARGS, "CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, - { "Mesh_MoveVertices", _wrap_Mesh_MoveVertices, METH_VARARGS, "MoveVertices(Mesh self, Vector displacements)"}, - { "Mesh_GetVertices", _wrap_Mesh_GetVertices, METH_VARARGS, "GetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_SetVertices", _wrap_Mesh_SetVertices, METH_VARARGS, "SetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_GetNode", _wrap_Mesh_GetNode, METH_VARARGS, "GetNode(Mesh self, int i, double * coord)"}, - { "Mesh_SetNode", _wrap_Mesh_SetNode, METH_VARARGS, "SetNode(Mesh self, int i, double const * coord)"}, - { "Mesh_MoveNodes", _wrap_Mesh_MoveNodes, METH_VARARGS, "MoveNodes(Mesh self, Vector displacements)"}, - { "Mesh_SetNodes", _wrap_Mesh_SetNodes, METH_VARARGS, "SetNodes(Mesh self, Vector node_coord)"}, + { "Mesh_CartesianPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CartesianPartitioning, METH_VARARGS|METH_KEYWORDS, "CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, + { "Mesh_GeneratePartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_GeneratePartitioning, METH_VARARGS|METH_KEYWORDS, "GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int *"}, + { "Mesh_CheckPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckPartitioning, METH_VARARGS|METH_KEYWORDS, "CheckPartitioning(Mesh self, int * partitioning)"}, + { "Mesh_CheckDisplacements", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckDisplacements, METH_VARARGS|METH_KEYWORDS, "CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, + { "Mesh_MoveVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveVertices, METH_VARARGS|METH_KEYWORDS, "MoveVertices(Mesh self, Vector displacements)"}, + { "Mesh_GetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertices, METH_VARARGS|METH_KEYWORDS, "GetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_SetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_SetVertices, METH_VARARGS|METH_KEYWORDS, "SetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_GetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNode, METH_VARARGS|METH_KEYWORDS, "GetNode(Mesh self, int i, double * coord)"}, + { "Mesh_SetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNode, METH_VARARGS|METH_KEYWORDS, "SetNode(Mesh self, int i, double const * coord)"}, + { "Mesh_MoveNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveNodes, METH_VARARGS|METH_KEYWORDS, "MoveNodes(Mesh self, Vector displacements)"}, + { "Mesh_SetNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodes, METH_VARARGS|METH_KEYWORDS, "SetNodes(Mesh self, Vector node_coord)"}, { "Mesh_OwnsNodes", _wrap_Mesh_OwnsNodes, METH_O, "OwnsNodes(Mesh self) -> bool"}, - { "Mesh_SetNodesOwner", _wrap_Mesh_SetNodesOwner, METH_VARARGS, "SetNodesOwner(Mesh self, bool nodes_owner)"}, - { "Mesh_NewNodes", _wrap_Mesh_NewNodes, METH_VARARGS, "NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, - { "Mesh_SwapNodes", _wrap_Mesh_SwapNodes, METH_VARARGS, "SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, + { "Mesh_SetNodesOwner", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodesOwner, METH_VARARGS|METH_KEYWORDS, "SetNodesOwner(Mesh self, bool nodes_owner)"}, + { "Mesh_NewNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_NewNodes, METH_VARARGS|METH_KEYWORDS, "NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SwapNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SwapNodes, METH_VARARGS|METH_KEYWORDS, "SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, { "Mesh_GetNodes", _wrap_Mesh_GetNodes, METH_VARARGS, "\n" "GetNodes(Mesh self, Vector node_coord)\n" "GetNodes(Mesh self) -> GridFunction\n" "GetNodes(Mesh self) -> GridFunction\n" "GetNodes(Mesh self, GridFunction nodes)\n" ""}, - { "Mesh_SetNodalFESpace", _wrap_Mesh_SetNodalFESpace, METH_VARARGS, "SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, - { "Mesh_SetNodalGridFunction", _wrap_Mesh_SetNodalGridFunction, METH_VARARGS, "SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SetNodalFESpace", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalFESpace, METH_VARARGS|METH_KEYWORDS, "SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, + { "Mesh_SetNodalGridFunction", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalGridFunction, METH_VARARGS|METH_KEYWORDS, "SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, { "Mesh_GetNodalFESpace", _wrap_Mesh_GetNodalFESpace, METH_O, "GetNodalFESpace(Mesh self) -> FiniteElementSpace"}, { "Mesh_EnsureNodes", _wrap_Mesh_EnsureNodes, METH_O, "EnsureNodes(Mesh self)"}, - { "Mesh_SetCurvature", _wrap_Mesh_SetCurvature, METH_VARARGS, "SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, - { "Mesh_UniformRefinement", _wrap_Mesh_UniformRefinement, METH_VARARGS, "UniformRefinement(Mesh self, int ref_algo=0)"}, + { "Mesh_SetCurvature", (PyCFunction)(void(*)(void))_wrap_Mesh_SetCurvature, METH_VARARGS|METH_KEYWORDS, "SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "Mesh_UniformRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_UniformRefinement, METH_VARARGS|METH_KEYWORDS, "UniformRefinement(Mesh self, int ref_algo=0)"}, { "Mesh_GeneralRefinement", _wrap_Mesh_GeneralRefinement, METH_VARARGS, "\n" "GeneralRefinement(Mesh self, mfem::Array< mfem::Refinement > const & refinements, int nonconforming=-1, int nc_limit=0)\n" "GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0)\n" ""}, - { "Mesh_RandomRefinement", _wrap_Mesh_RandomRefinement, METH_VARARGS, "RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, - { "Mesh_RefineAtVertex", _wrap_Mesh_RefineAtVertex, METH_VARARGS, "RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, + { "Mesh_RandomRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_RandomRefinement, METH_VARARGS|METH_KEYWORDS, "RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, + { "Mesh_RefineAtVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_RefineAtVertex, METH_VARARGS|METH_KEYWORDS, "RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, { "Mesh_RefineByError", _wrap_Mesh_RefineByError, METH_VARARGS, "\n" "RefineByError(Mesh self, doubleArray elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" "RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" @@ -27171,8 +18072,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" "KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" ""}, - { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, - { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, + { "Mesh_DegreeElevate", (PyCFunction)(void(*)(void))_wrap_Mesh_DegreeElevate, METH_VARARGS|METH_KEYWORDS, "DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, + { "Mesh_EnsureNCMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_EnsureNCMesh, METH_VARARGS|METH_KEYWORDS, "EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Conforming(Mesh self) -> bool"}, { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Nonconforming(Mesh self) -> bool"}, { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, @@ -27182,12 +18083,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { "PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" "PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" ""}, - { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "GetElementColoring(Mesh self, intArray colors, int el0=0)"}, - { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, - { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, - { "Mesh_PrintSurfaces", _wrap_Mesh_PrintSurfaces, METH_VARARGS, "PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, - { "Mesh_ScaleSubdomains", _wrap_Mesh_ScaleSubdomains, METH_VARARGS, "ScaleSubdomains(Mesh self, double sf)"}, - { "Mesh_ScaleElements", _wrap_Mesh_ScaleElements, METH_VARARGS, "ScaleElements(Mesh self, double sf)"}, + { "Mesh_GetElementColoring", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementColoring, METH_VARARGS|METH_KEYWORDS, "GetElementColoring(Mesh self, intArray colors, int el0=0)"}, + { "Mesh_PrintWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintWithPartitioning, METH_VARARGS|METH_KEYWORDS, "PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, + { "Mesh_PrintElementsWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS|METH_KEYWORDS, "PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, + { "Mesh_PrintSurfaces", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintSurfaces, METH_VARARGS|METH_KEYWORDS, "PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, + { "Mesh_ScaleSubdomains", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleSubdomains, METH_VARARGS|METH_KEYWORDS, "ScaleSubdomains(Mesh self, double sf)"}, + { "Mesh_ScaleElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleElements, METH_VARARGS|METH_KEYWORDS, "ScaleElements(Mesh self, double sf)"}, { "Mesh_Transform", _wrap_Mesh_Transform, METH_VARARGS, "\n" "Transform(Mesh self, void (*)(mfem::Vector const &,mfem::Vector &) f)\n" "Transform(Mesh self, VectorCoefficient deformation)\n" @@ -27198,12 +18099,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetElementSize(Mesh self, int i, int type=0) -> double\n" "GetElementSize(Mesh self, int i, Vector dir) -> double\n" ""}, - { "Mesh_GetElementVolume", _wrap_Mesh_GetElementVolume, METH_VARARGS, "GetElementVolume(Mesh self, int i) -> double"}, - { "Mesh_GetBoundingBox", _wrap_Mesh_GetBoundingBox, METH_VARARGS, "GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, - { "Mesh_GetCharacteristics", _wrap_Mesh_GetCharacteristics, METH_VARARGS, "GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, - { "Mesh_PrintElementsByGeometry", _wrap_Mesh_PrintElementsByGeometry, METH_VARARGS, "PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, - { "Mesh_PrintCharacteristics", _wrap_Mesh_PrintCharacteristics, METH_VARARGS, "PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, - { "Mesh_FindPoints", _wrap_Mesh_FindPoints, METH_VARARGS, "FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "Mesh_GetElementVolume", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVolume, METH_VARARGS|METH_KEYWORDS, "GetElementVolume(Mesh self, int i) -> double"}, + { "Mesh_GetBoundingBox", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBoundingBox, METH_VARARGS|METH_KEYWORDS, "GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, + { "Mesh_GetCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_GetCharacteristics, METH_VARARGS|METH_KEYWORDS, "GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, + { "Mesh_PrintElementsByGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsByGeometry, METH_VARARGS|METH_KEYWORDS, "PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, + { "Mesh_PrintCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintCharacteristics, METH_VARARGS|METH_KEYWORDS, "PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, + { "Mesh_FindPoints", (PyCFunction)(void(*)(void))_wrap_Mesh_FindPoints, METH_VARARGS|METH_KEYWORDS, "FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, { "delete_Mesh", _wrap_delete_Mesh, METH_O, "delete_Mesh(Mesh self)"}, { "new_Mesh", _wrap_new_Mesh, METH_VARARGS, "\n" "Mesh()\n" @@ -27218,18 +18119,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Mesh(mfem::Mesh *[] mesh_array, int num_pieces)\n" "Mesh(Mesh orig_mesh, int ref_factor, int ref_type)\n" "Mesh(int nx, int ny, int nz, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0, double sz=1.0)\n" - "Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0)\n" + "new_Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0) -> Mesh\n" ""}, - { "Mesh_PrintToFile", _wrap_Mesh_PrintToFile, METH_VARARGS, "PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, + { "Mesh_PrintToFile", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintToFile, METH_VARARGS|METH_KEYWORDS, "PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, { "Mesh_GetAttributeArray", _wrap_Mesh_GetAttributeArray, METH_O, "GetAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetVertexArray", _wrap_Mesh_GetVertexArray, METH_VARARGS, "GetVertexArray(Mesh self, int i) -> PyObject *"}, + { "Mesh_GetVertexArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertexArray, METH_VARARGS|METH_KEYWORDS, "GetVertexArray(Mesh self, int i) -> PyObject *"}, { "Mesh_GetBdrElementFace", _wrap_Mesh_GetBdrElementFace, METH_VARARGS, "\n" "GetBdrElementFace(Mesh self, int i, int * arg3, int * arg4)\n" "GetBdrElementFace(Mesh self, int i) -> PyObject *\n" ""}, { "Mesh_GetBdrAttributeArray", _wrap_Mesh_GetBdrAttributeArray, METH_O, "GetBdrAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetBdrArray", _wrap_Mesh_GetBdrArray, METH_VARARGS, "GetBdrArray(Mesh self, int idx) -> PyObject *"}, - { "Mesh_GetDomainArray", _wrap_Mesh_GetDomainArray, METH_VARARGS, "GetDomainArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetBdrArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrArray, METH_VARARGS|METH_KEYWORDS, "GetBdrArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetDomainArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetDomainArray, METH_VARARGS|METH_KEYWORDS, "GetDomainArray(Mesh self, int idx) -> PyObject *"}, { "Mesh_PrintInfo", _wrap_Mesh_PrintInfo, METH_VARARGS, "\n" "PrintInfo(Mesh self, std::ostream & out=mfem::out)\n" "PrintInfo(Mesh self, char const * file, int precision=8)\n" @@ -27260,7 +18161,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "GeometricFactors_IntRule_get", _wrap_GeometricFactors_IntRule_get, METH_O, "GeometricFactors_IntRule_get(GeometricFactors self) -> IntegrationRule"}, { "GeometricFactors_computed_factors_set", _wrap_GeometricFactors_computed_factors_set, METH_VARARGS, "GeometricFactors_computed_factors_set(GeometricFactors self, int computed_factors)"}, { "GeometricFactors_computed_factors_get", _wrap_GeometricFactors_computed_factors_get, METH_O, "GeometricFactors_computed_factors_get(GeometricFactors self) -> int"}, - { "new_GeometricFactors", _wrap_new_GeometricFactors, METH_VARARGS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, + { "new_GeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_GeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, { "GeometricFactors_X_set", _wrap_GeometricFactors_X_set, METH_VARARGS, "GeometricFactors_X_set(GeometricFactors self, Vector X)"}, { "GeometricFactors_X_get", _wrap_GeometricFactors_X_get, METH_O, "GeometricFactors_X_get(GeometricFactors self) -> Vector"}, { "GeometricFactors_J_set", _wrap_GeometricFactors_J_set, METH_VARARGS, "GeometricFactors_J_set(GeometricFactors self, Vector J)"}, @@ -27278,7 +18179,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, - { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "new_FaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_FaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, @@ -27290,7 +18191,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, - { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "SetLayer(NodeExtrudeCoefficient self, int const l)"}, + { "NodeExtrudeCoefficient_SetLayer", (PyCFunction)(void(*)(void))_wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS|METH_KEYWORDS, "SetLayer(NodeExtrudeCoefficient self, int const l)"}, { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" "Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(NodeExtrudeCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -27298,9 +18199,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_NodeExtrudeCoefficient", _wrap_delete_NodeExtrudeCoefficient, METH_O, "delete_NodeExtrudeCoefficient(NodeExtrudeCoefficient self)"}, { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, - { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, - { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, - { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, + { "Extrude1D", (PyCFunction)(void(*)(void))_wrap_Extrude1D, METH_VARARGS|METH_KEYWORDS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, + { "Extrude2D", (PyCFunction)(void(*)(void))_wrap_Extrude2D, METH_VARARGS|METH_KEYWORDS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, + { "ShiftRight", (PyCFunction)(void(*)(void))_wrap_ShiftRight, METH_VARARGS|METH_KEYWORDS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/ncmesh_wrap.cxx b/mfem/_par/ncmesh_wrap.cxx index 21f56cb5..a248ae7e 100644 --- a/mfem/_par/ncmesh_wrap.cxx +++ b/mfem/_par/ncmesh_wrap.cxx @@ -3585,7 +3585,7 @@ SWIGINTERN void mfem_NCMesh_PrintVertexParents__SWIG_1(mfem::NCMesh *self,char c self -> PrintVertexParents(ofile); ofile.close(); } -SWIGINTERN void mfem_NCMesh_PrintVertexParents__SWIG_3(mfem::NCMesh *self){ +SWIGINTERN void mfem_NCMesh_PrintVertexParents__SWIG_2(mfem::NCMesh *self){ self -> PrintVertexParents(std::cout); } SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_1(mfem::NCMesh *self,char const *file,int precision=8){ @@ -3599,10 +3599,10 @@ SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_1(mfem::NCMesh *self,char self -> PrintCoarseElements(ofile); ofile.close(); } -SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_3(mfem::NCMesh *self){ +SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_2(mfem::NCMesh *self){ self -> PrintCoarseElements(std::cout); } -SWIGINTERN void mfem_NCMesh_PrintStats__SWIG_2(mfem::NCMesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_NCMesh_PrintStats__SWIG_1(mfem::NCMesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3750,52 +3750,27 @@ SWIGINTERN PyObject *_wrap_new_Refinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self) SWIGINTERN PyObject *_wrap_new_Refinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 7 ; mfem::Refinement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::Refinement *)new mfem::Refinement(arg1,arg2); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Refinement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Refinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Refinement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::Refinement *)new mfem::Refinement(arg1); + result = (mfem::Refinement *)new mfem::Refinement(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3819,7 +3794,7 @@ SWIGINTERN PyObject *_wrap_new_Refinement(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Refinement__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -3830,20 +3805,9 @@ SWIGINTERN PyObject *_wrap_new_Refinement(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Refinement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_Refinement__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3862,8 +3826,7 @@ SWIGINTERN PyObject *_wrap_new_Refinement(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Refinement'.\n" " Possible C/C++ prototypes are:\n" " mfem::Refinement::Refinement()\n" - " mfem::Refinement::Refinement(int,int)\n" - " mfem::Refinement::Refinement(int)\n"); + " mfem::Refinement::Refinement(int,int)\n"); return 0; } @@ -4033,52 +3996,27 @@ SWIGINTERN PyObject *_wrap_new_Embedding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_Embedding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 0 ; mfem::Embedding *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::Embedding *)new mfem::Embedding(arg1,arg2); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Embedding, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Embedding__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Embedding *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::Embedding *)new mfem::Embedding(arg1); + result = (mfem::Embedding *)new mfem::Embedding(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4102,7 +4040,7 @@ SWIGINTERN PyObject *_wrap_new_Embedding(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Embedding__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -4113,20 +4051,9 @@ SWIGINTERN PyObject *_wrap_new_Embedding(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Embedding__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_Embedding__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4145,8 +4072,7 @@ SWIGINTERN PyObject *_wrap_new_Embedding(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Embedding'.\n" " Possible C/C++ prototypes are:\n" " mfem::Embedding::Embedding()\n" - " mfem::Embedding::Embedding(int,int)\n" - " mfem::Embedding::Embedding(int)\n"); + " mfem::Embedding::Embedding(int,int)\n"); return 0; } @@ -4273,7 +4199,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_embeddings_get(PyObject *SW } -SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; mfem::Mesh *arg2 = 0 ; @@ -4293,15 +4219,23 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fine_mesh", (char *)"coarse_to_fine", (char *)"coarse_to_ref_type", (char *)"ref_type_to_matrix", (char *)"ref_type_to_geom", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CoarseFineTransformations_GetCoarseToFineMap", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:CoarseFineTransformations_GetCoarseToFineMap", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "1"" of type '" "mfem::CoarseFineTransformations const *""'"); } arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } @@ -4309,7 +4243,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Table, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "3"" of type '" "mfem::Table &""'"); } @@ -4317,7 +4251,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "3"" of type '" "mfem::Table &""'"); } arg3 = reinterpret_cast< mfem::Table * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -4325,7 +4259,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Table, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "5"" of type '" "mfem::Table &""'"); } @@ -4333,7 +4267,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "5"" of type '" "mfem::Table &""'"); } arg5 = reinterpret_cast< mfem::Table * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "6"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); } @@ -4508,24 +4442,26 @@ SWIGINTERN PyObject *CoarseFineTransformations_swiginit(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = (std::istream *) 0 ; + std::istream *arg2 = (std::istream *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; mfem::NCMesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NCMesh" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__istream, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NCMesh" "', argument " "2"" of type '" "std::istream *""'"); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__istream, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NCMesh" "', argument " "2"" of type '" "std::istream *""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); } - arg2 = reinterpret_cast< std::istream * >(argp2); { try { result = (mfem::NCMesh *)new mfem::NCMesh((mfem::Mesh const *)arg1,arg2); @@ -4542,34 +4478,6 @@ SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::NCMesh *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NCMesh" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::NCMesh *)new mfem::NCMesh((mfem::Mesh const *)arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NCMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = 0 ; void *argp1 = 0 ; @@ -4608,13 +4516,21 @@ SWIGINTERN PyObject *_wrap_new_NCMesh(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_NCMesh", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_NCMesh__SWIG_1(self, argc, argv); + if (argc <= 1) { + return _wrap_new_NCMesh__SWIG_0(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_NCMesh__SWIG_0(self, argc, argv); + } } } if (argc == 1) { @@ -4622,21 +4538,7 @@ SWIGINTERN PyObject *_wrap_new_NCMesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__NCMesh, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_NCMesh__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_NCMesh__SWIG_0(self, argc, argv); - } + return _wrap_new_NCMesh__SWIG_1(self, argc, argv); } } @@ -4644,7 +4546,6 @@ SWIGINTERN PyObject *_wrap_new_NCMesh(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NCMesh'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::NCMesh(mfem::Mesh const *,std::istream *)\n" - " mfem::NCMesh::NCMesh(mfem::Mesh const *)\n" " mfem::NCMesh::NCMesh(mfem::NCMesh const &)\n"); return 0; } @@ -4829,7 +4730,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< mfem::Refinement > *arg2 = 0 ; @@ -4837,15 +4738,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refinements", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_Refine", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_Refine", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_Refine" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_Refine" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); } @@ -4868,25 +4773,29 @@ SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_NCMesh_LimitNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_LimitNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_nc_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_LimitNCLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_LimitNCLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_LimitNCLevel" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4933,7 +4842,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetDerefinementTable(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Table *arg2 = 0 ; @@ -4945,15 +4854,21 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"deref_table", (char *)"level_ok", (char *)"max_nc_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_CheckDerefinementNCLevel", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_CheckDerefinementNCLevel", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "2"" of type '" "mfem::Table const &""'"); } @@ -4961,7 +4876,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "2"" of type '" "mfem::Table const &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -4970,10 +4885,10 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -4990,7 +4905,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4998,15 +4913,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"derefs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_Derefine", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_Derefine", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_Derefine" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_Derefine" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5119,26 +5038,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetVertexList(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NCMesh_GetNCList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetNCList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"entity", NULL + }; mfem::NCMesh::NCList *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetNCList", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetNCList", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetNCList" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5273,29 +5196,34 @@ SWIGINTERN PyObject *_wrap_NCMesh_ClearTransforms(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; mfem::Array< int > *arg3 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"width", (char *)"height", (char *)"coords", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GridSfcOrdering2D", 3, 3, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NCMesh_GridSfcOrdering2D", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GridSfcOrdering2D" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5318,7 +5246,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering2D(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -5326,28 +5254,34 @@ SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(sel mfem::Array< int > *arg4 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"width", (char *)"height", (char *)"depth", (char *)"coords", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GridSfcOrdering3D", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_GridSfcOrdering3D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GridSfcOrdering3D" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -5370,12 +5304,12 @@ SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; int *arg3 ; - bool arg4 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5384,14 +5318,21 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPA int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"edge_id", (char *)"vert_index", (char *)"oriented", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:NCMesh_GetEdgeVertices", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -5399,16 +5340,18 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetEdgeVertices" "', argument " "3"" of type '" "int [2]""'"); } arg3 = reinterpret_cast< int * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NCMesh_GetEdgeVertices" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NCMesh_GetEdgeVertices" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { ((mfem::NCMesh const *)arg1)->GetEdgeVertices((mfem::NCMesh::MeshId const &)*arg2,arg3,arg4); @@ -5424,179 +5367,84 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeNCOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; - int *arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"edge_id", NULL + }; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetEdgeNCOrientation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetEdgeVertices" "', argument " "3"" of type '" "int [2]""'"); - } - arg3 = reinterpret_cast< int * >(argp3); { try { - ((mfem::NCMesh const *)arg1)->GetEdgeVertices((mfem::NCMesh::MeshId const &)*arg2,arg3); + result = (int)((mfem::NCMesh const *)arg1)->GetEdgeNCOrientation((mfem::NCMesh::MeshId const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "NCMesh_GetEdgeVertices", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__NCMesh__MeshId, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NCMesh_GetEdgeVertices__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__NCMesh__MeshId, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_NCMesh_GetEdgeVertices__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_GetEdgeVertices'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NCMesh::GetEdgeVertices(mfem::NCMesh::MeshId const &,int [2],bool) const\n" - " mfem::NCMesh::GetEdgeVertices(mfem::NCMesh::MeshId const &,int [2]) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeNCOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; + int *arg3 ; + int *arg4 ; + int *arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face_id", (char *)"vert_index", (char *)"edge_index", (char *)"edge_orientation", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetEdgeNCOrientation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); - } - arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - { - try { - result = (int)((mfem::NCMesh const *)arg1)->GetEdgeNCOrientation((mfem::NCMesh::MeshId const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - mfem::NCMesh::MeshId *arg2 = 0 ; - int *arg3 ; - int *arg4 ; - int *arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - PyObject *swig_obj[5] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceVerticesEdges", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NCMesh_GetFaceVerticesEdges", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -5604,17 +5452,17 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "3"" of type '" "int [4]""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "4"" of type '" "int [4]""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "5"" of type '" "int [4]""'"); } @@ -5634,33 +5482,38 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v1", (char *)"v2", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetEdgeMaster", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NCMesh_GetEdgeMaster", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeMaster" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5677,7 +5530,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeMaster(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5691,15 +5544,21 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"bdr_vertices", (char *)"bdr_edges", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetBoundaryClosure", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_GetBoundaryClosure", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5707,7 +5566,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetBoundaryClosure" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5715,7 +5574,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetBoundaryClosure" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -5738,26 +5597,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"index", NULL + }; mfem::Geometry::Type result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetElementGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5774,26 +5637,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_GetFaceGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetFaceGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"index", NULL + }; mfem::Geometry::Type result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetFaceGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5840,26 +5707,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetNumRootElements(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementDepth", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetElementDepth", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementDepth" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5876,26 +5747,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementSizeReduction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetElementSizeReduction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementSizeReduction" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5912,7 +5787,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; @@ -5924,21 +5799,27 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"faces", (char *)"fattr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementFacesAttributes", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_GetElementFacesAttributes", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5946,7 +5827,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -6079,7 +5960,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; std::istream *arg2 = 0 ; @@ -6087,15 +5968,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"input", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_LoadVertexParents", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_LoadVertexParents", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_LoadVertexParents" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_LoadVertexParents" "', argument " "2"" of type '" "std::istream &""'"); } @@ -6118,7 +6003,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; std::istream *arg2 = 0 ; @@ -6126,15 +6011,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"input", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_LoadCoarseElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_LoadCoarseElements", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_LoadCoarseElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_LoadCoarseElements" "', argument " "2"" of type '" "std::istream &""'"); } @@ -6157,7 +6046,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_SetVertexPositions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_SetVertexPositions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< mfem::Vertex > *arg2 = 0 ; @@ -6165,15 +6054,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_SetVertexPositions(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertices", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_SetVertexPositions", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_SetVertexPositions", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_SetVertexPositions" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_SetVertexPositions" "', argument " "2"" of type '" "mfem::Array< mfem::Vertex > const &""'"); } @@ -6288,31 +6181,34 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintMemoryDetail(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -6340,45 +6236,18 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - { - try { - ((mfem::NCMesh const *)arg1)->PrintStats(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintVertexParents" "', argument " "1"" of type '" "mfem::NCMesh *""'"); @@ -6389,11 +6258,13 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintVertexParents" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -6413,44 +6284,6 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_1(PyObject *SWIGUNUSE SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintVertexParents" "', argument " "1"" of type '" "mfem::NCMesh *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintVertexParents" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_NCMesh_PrintVertexParents__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; void *argp1 = 0 ; @@ -6464,7 +6297,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_3(PyObject *SWIGUNUSE arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { try { - mfem_NCMesh_PrintVertexParents__SWIG_3(arg1); + mfem_NCMesh_PrintVertexParents__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6491,10 +6324,10 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintVertexParents__SWIG_3(self, argc, argv); + return _wrap_NCMesh_PrintVertexParents__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); @@ -6503,7 +6336,20 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents(PyObject *self, PyObject *a int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintVertexParents__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_NCMesh_PrintVertexParents__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_NCMesh_PrintVertexParents__SWIG_1(self, argc, argv); + } } } } @@ -6527,36 +6373,12 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents(PyObject *self, PyObject *a } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_NCMesh_PrintVertexParents__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_PrintVertexParents'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::PrintVertexParents(std::ostream &) const\n" " mfem::NCMesh::PrintVertexParents(char const *,int)\n" - " mfem::NCMesh::PrintVertexParents(char const *)\n" " mfem::NCMesh::PrintVertexParents()\n"); return 0; } @@ -6566,14 +6388,14 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_1(PyObject *SWIGUNUS PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintCoarseElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); @@ -6584,11 +6406,13 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_1(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintCoarseElements" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -6608,44 +6432,6 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_1(PyObject *SWIGUNUS SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintCoarseElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintCoarseElements" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_NCMesh_PrintCoarseElements__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; void *argp1 = 0 ; @@ -6659,7 +6445,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_3(PyObject *SWIGUNUS arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { try { - mfem_NCMesh_PrintCoarseElements__SWIG_3(arg1); + mfem_NCMesh_PrintCoarseElements__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6686,10 +6472,10 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintCoarseElements__SWIG_3(self, argc, argv); + return _wrap_NCMesh_PrintCoarseElements__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); @@ -6698,7 +6484,20 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements(PyObject *self, PyObject * int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintCoarseElements__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_NCMesh_PrintCoarseElements__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_NCMesh_PrintCoarseElements__SWIG_1(self, argc, argv); + } } } } @@ -6722,53 +6521,29 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements(PyObject *self, PyObject * } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_NCMesh_PrintCoarseElements__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_PrintCoarseElements'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::PrintCoarseElements(std::ostream &) const\n" " mfem::NCMesh::PrintCoarseElements(char const *,int)\n" - " mfem::NCMesh::PrintCoarseElements(char const *)\n" " mfem::NCMesh::PrintCoarseElements()\n"); return 0; } -SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh *""'"); @@ -6779,53 +6554,17 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_2(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintStats" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_NCMesh_PrintStats__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintStats" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_NCMesh_PrintStats__SWIG_2(arg1,(char const *)arg2); + mfem_NCMesh_PrintStats__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6848,34 +6587,15 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "NCMesh_PrintStats", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintStats__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NCMesh_PrintStats__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_NCMesh_PrintStats__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -6890,7 +6610,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); @@ -6899,6 +6619,9 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_NCMesh_PrintStats__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6908,7 +6631,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_NCMesh_PrintStats__SWIG_2(self, argc, argv); + return _wrap_NCMesh_PrintStats__SWIG_1(self, argc, argv); } } } @@ -6918,9 +6641,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_PrintStats'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::PrintStats(std::ostream &) const\n" - " mfem::NCMesh::PrintStats() const\n" - " mfem::NCMesh::PrintStats(char const *,int)\n" - " mfem::NCMesh::PrintStats(char const *)\n"); + " mfem::NCMesh::PrintStats(char const *,int)\n"); return 0; } @@ -6945,7 +6666,7 @@ static PyMethodDef SwigMethods[] = { { "Refinement_ref_type_get", _wrap_Refinement_ref_type_get, METH_O, "Refinement_ref_type_get(Refinement self) -> char"}, { "new_Refinement", _wrap_new_Refinement, METH_VARARGS, "\n" "Refinement()\n" - "Refinement(int index, int type=7)\n" + "new_Refinement(int index, int type=7) -> Refinement\n" ""}, { "delete_Refinement", _wrap_delete_Refinement, METH_O, "delete_Refinement(Refinement self)"}, { "Refinement_swigregister", Refinement_swigregister, METH_O, NULL}, @@ -6956,7 +6677,7 @@ static PyMethodDef SwigMethods[] = { { "Embedding_matrix_get", _wrap_Embedding_matrix_get, METH_O, "Embedding_matrix_get(Embedding self) -> int"}, { "new_Embedding", _wrap_new_Embedding, METH_VARARGS, "\n" "Embedding()\n" - "Embedding(int elem, int matrix=0)\n" + "new_Embedding(int elem, int matrix=0) -> Embedding\n" ""}, { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, @@ -6964,7 +6685,7 @@ static PyMethodDef SwigMethods[] = { { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, - { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "CoarseFineTransformations_GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, + { "CoarseFineTransformations_GetCoarseToFineMap", (PyCFunction)(void(*)(void))_wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS|METH_KEYWORDS, "CoarseFineTransformations_GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "CoarseFineTransformations_Clear(CoarseFineTransformations self)"}, { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "CoarseFineTransformations_IsInitialized(CoarseFineTransformations self) -> bool"}, { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "CoarseFineTransformations_MemoryUsage(CoarseFineTransformations self) -> long"}, @@ -6982,35 +6703,35 @@ static PyMethodDef SwigMethods[] = { { "NCMesh_GetNVertices", _wrap_NCMesh_GetNVertices, METH_O, "NCMesh_GetNVertices(NCMesh self) -> int"}, { "NCMesh_GetNEdges", _wrap_NCMesh_GetNEdges, METH_O, "NCMesh_GetNEdges(NCMesh self) -> int"}, { "NCMesh_GetNFaces", _wrap_NCMesh_GetNFaces, METH_O, "NCMesh_GetNFaces(NCMesh self) -> int"}, - { "NCMesh_Refine", _wrap_NCMesh_Refine, METH_VARARGS, "NCMesh_Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, - { "NCMesh_LimitNCLevel", _wrap_NCMesh_LimitNCLevel, METH_VARARGS, "NCMesh_LimitNCLevel(NCMesh self, int max_nc_level)"}, + { "NCMesh_Refine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Refine, METH_VARARGS|METH_KEYWORDS, "NCMesh_Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "NCMesh_LimitNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_LimitNCLevel, METH_VARARGS|METH_KEYWORDS, "NCMesh_LimitNCLevel(NCMesh self, int max_nc_level)"}, { "NCMesh_GetDerefinementTable", _wrap_NCMesh_GetDerefinementTable, METH_O, "NCMesh_GetDerefinementTable(NCMesh self) -> Table"}, - { "NCMesh_CheckDerefinementNCLevel", _wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS, "NCMesh_CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, - { "NCMesh_Derefine", _wrap_NCMesh_Derefine, METH_VARARGS, "NCMesh_Derefine(NCMesh self, intArray derefs)"}, + { "NCMesh_CheckDerefinementNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS|METH_KEYWORDS, "NCMesh_CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "NCMesh_Derefine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Derefine, METH_VARARGS|METH_KEYWORDS, "NCMesh_Derefine(NCMesh self, intArray derefs)"}, { "NCMesh_GetFaceList", _wrap_NCMesh_GetFaceList, METH_O, "NCMesh_GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetEdgeList", _wrap_NCMesh_GetEdgeList, METH_O, "NCMesh_GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetVertexList", _wrap_NCMesh_GetVertexList, METH_O, "NCMesh_GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &"}, - { "NCMesh_GetNCList", _wrap_NCMesh_GetNCList, METH_VARARGS, "NCMesh_GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetNCList", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetNCList, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, { "NCMesh_MarkCoarseLevel", _wrap_NCMesh_MarkCoarseLevel, METH_O, "NCMesh_MarkCoarseLevel(NCMesh self)"}, { "NCMesh_GetRefinementTransforms", _wrap_NCMesh_GetRefinementTransforms, METH_O, "NCMesh_GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_GetDerefinementTransforms", _wrap_NCMesh_GetDerefinementTransforms, METH_O, "NCMesh_GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_ClearTransforms", _wrap_NCMesh_ClearTransforms, METH_O, "NCMesh_ClearTransforms(NCMesh self)"}, - { "NCMesh_GridSfcOrdering2D", _wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS, "NCMesh_GridSfcOrdering2D(int width, int height, intArray coords)"}, - { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, - { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "NCMesh_GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, - { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "NCMesh_GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, - { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, - { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "NCMesh_GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, - { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "NCMesh_GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, - { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "NCMesh_GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, - { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "NCMesh_GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GridSfcOrdering2D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS|METH_KEYWORDS, "NCMesh_GridSfcOrdering2D(int width, int height, intArray coords)"}, + { "NCMesh_GridSfcOrdering3D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS|METH_KEYWORDS, "NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, + { "NCMesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, + { "NCMesh_GetEdgeNCOrientation", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, + { "NCMesh_GetFaceVerticesEdges", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, + { "NCMesh_GetEdgeMaster", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeMaster, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, + { "NCMesh_GetBoundaryClosure", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetBoundaryClosure, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "NCMesh_GetElementGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementGeometry, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceGeometry, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "NCMesh_GetNumRootElements(NCMesh self) -> int"}, - { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "NCMesh_GetElementDepth(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "NCMesh_GetElementSizeReduction(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "NCMesh_GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, - { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "NCMesh_LoadVertexParents(NCMesh self, std::istream & input)"}, - { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "NCMesh_LoadCoarseElements(NCMesh self, std::istream & input)"}, - { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "NCMesh_SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, + { "NCMesh_GetElementDepth", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementDepth, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementSizeReduction, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, + { "NCMesh_LoadVertexParents", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadVertexParents, METH_VARARGS|METH_KEYWORDS, "NCMesh_LoadVertexParents(NCMesh self, std::istream & input)"}, + { "NCMesh_LoadCoarseElements", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadCoarseElements, METH_VARARGS|METH_KEYWORDS, "NCMesh_LoadCoarseElements(NCMesh self, std::istream & input)"}, + { "NCMesh_SetVertexPositions", (PyCFunction)(void(*)(void))_wrap_NCMesh_SetVertexPositions, METH_VARARGS|METH_KEYWORDS, "NCMesh_SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, { "NCMesh_Trim", _wrap_NCMesh_Trim, METH_O, "NCMesh_Trim(NCMesh self)"}, { "NCMesh_MemoryUsage", _wrap_NCMesh_MemoryUsage, METH_O, "NCMesh_MemoryUsage(NCMesh self) -> long"}, { "NCMesh_PrintMemoryDetail", _wrap_NCMesh_PrintMemoryDetail, METH_O, "NCMesh_PrintMemoryDetail(NCMesh self) -> int"}, @@ -7042,7 +6763,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Refinement_ref_type_get", _wrap_Refinement_ref_type_get, METH_O, "Refinement_ref_type_get(Refinement self) -> char"}, { "new_Refinement", _wrap_new_Refinement, METH_VARARGS, "\n" "Refinement()\n" - "Refinement(int index, int type=7)\n" + "new_Refinement(int index, int type=7) -> Refinement\n" ""}, { "delete_Refinement", _wrap_delete_Refinement, METH_O, "delete_Refinement(Refinement self)"}, { "Refinement_swigregister", Refinement_swigregister, METH_O, NULL}, @@ -7053,7 +6774,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Embedding_matrix_get", _wrap_Embedding_matrix_get, METH_O, "Embedding_matrix_get(Embedding self) -> int"}, { "new_Embedding", _wrap_new_Embedding, METH_VARARGS, "\n" "Embedding()\n" - "Embedding(int elem, int matrix=0)\n" + "new_Embedding(int elem, int matrix=0) -> Embedding\n" ""}, { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, @@ -7061,7 +6782,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, - { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, + { "CoarseFineTransformations_GetCoarseToFineMap", (PyCFunction)(void(*)(void))_wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS|METH_KEYWORDS, "GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "Clear(CoarseFineTransformations self)"}, { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "IsInitialized(CoarseFineTransformations self) -> bool"}, { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "MemoryUsage(CoarseFineTransformations self) -> long"}, @@ -7079,35 +6800,35 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "NCMesh_GetNVertices", _wrap_NCMesh_GetNVertices, METH_O, "GetNVertices(NCMesh self) -> int"}, { "NCMesh_GetNEdges", _wrap_NCMesh_GetNEdges, METH_O, "GetNEdges(NCMesh self) -> int"}, { "NCMesh_GetNFaces", _wrap_NCMesh_GetNFaces, METH_O, "GetNFaces(NCMesh self) -> int"}, - { "NCMesh_Refine", _wrap_NCMesh_Refine, METH_VARARGS, "Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, - { "NCMesh_LimitNCLevel", _wrap_NCMesh_LimitNCLevel, METH_VARARGS, "LimitNCLevel(NCMesh self, int max_nc_level)"}, + { "NCMesh_Refine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Refine, METH_VARARGS|METH_KEYWORDS, "Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "NCMesh_LimitNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_LimitNCLevel, METH_VARARGS|METH_KEYWORDS, "LimitNCLevel(NCMesh self, int max_nc_level)"}, { "NCMesh_GetDerefinementTable", _wrap_NCMesh_GetDerefinementTable, METH_O, "GetDerefinementTable(NCMesh self) -> Table"}, - { "NCMesh_CheckDerefinementNCLevel", _wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS, "CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, - { "NCMesh_Derefine", _wrap_NCMesh_Derefine, METH_VARARGS, "Derefine(NCMesh self, intArray derefs)"}, + { "NCMesh_CheckDerefinementNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS|METH_KEYWORDS, "CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "NCMesh_Derefine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Derefine, METH_VARARGS|METH_KEYWORDS, "Derefine(NCMesh self, intArray derefs)"}, { "NCMesh_GetFaceList", _wrap_NCMesh_GetFaceList, METH_O, "GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetEdgeList", _wrap_NCMesh_GetEdgeList, METH_O, "GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetVertexList", _wrap_NCMesh_GetVertexList, METH_O, "GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &"}, - { "NCMesh_GetNCList", _wrap_NCMesh_GetNCList, METH_VARARGS, "GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetNCList", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetNCList, METH_VARARGS|METH_KEYWORDS, "GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, { "NCMesh_MarkCoarseLevel", _wrap_NCMesh_MarkCoarseLevel, METH_O, "MarkCoarseLevel(NCMesh self)"}, { "NCMesh_GetRefinementTransforms", _wrap_NCMesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_GetDerefinementTransforms", _wrap_NCMesh_GetDerefinementTransforms, METH_O, "GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_ClearTransforms", _wrap_NCMesh_ClearTransforms, METH_O, "ClearTransforms(NCMesh self)"}, - { "NCMesh_GridSfcOrdering2D", _wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS, "GridSfcOrdering2D(int width, int height, intArray coords)"}, - { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, - { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, - { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, - { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, - { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, - { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, - { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, - { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GridSfcOrdering2D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS|METH_KEYWORDS, "GridSfcOrdering2D(int width, int height, intArray coords)"}, + { "NCMesh_GridSfcOrdering3D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS|METH_KEYWORDS, "GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, + { "NCMesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, + { "NCMesh_GetEdgeNCOrientation", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS|METH_KEYWORDS, "GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, + { "NCMesh_GetFaceVerticesEdges", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS|METH_KEYWORDS, "GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, + { "NCMesh_GetEdgeMaster", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeMaster, METH_VARARGS|METH_KEYWORDS, "GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, + { "NCMesh_GetBoundaryClosure", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetBoundaryClosure, METH_VARARGS|METH_KEYWORDS, "GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "NCMesh_GetElementGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementGeometry, METH_VARARGS|METH_KEYWORDS, "GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceGeometry, METH_VARARGS|METH_KEYWORDS, "GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "GetNumRootElements(NCMesh self) -> int"}, - { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "GetElementDepth(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "GetElementSizeReduction(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, - { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "LoadVertexParents(NCMesh self, std::istream & input)"}, - { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "LoadCoarseElements(NCMesh self, std::istream & input)"}, - { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, + { "NCMesh_GetElementDepth", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementDepth, METH_VARARGS|METH_KEYWORDS, "GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementSizeReduction, METH_VARARGS|METH_KEYWORDS, "GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS|METH_KEYWORDS, "GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, + { "NCMesh_LoadVertexParents", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadVertexParents, METH_VARARGS|METH_KEYWORDS, "LoadVertexParents(NCMesh self, std::istream & input)"}, + { "NCMesh_LoadCoarseElements", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadCoarseElements, METH_VARARGS|METH_KEYWORDS, "LoadCoarseElements(NCMesh self, std::istream & input)"}, + { "NCMesh_SetVertexPositions", (PyCFunction)(void(*)(void))_wrap_NCMesh_SetVertexPositions, METH_VARARGS|METH_KEYWORDS, "SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, { "NCMesh_Trim", _wrap_NCMesh_Trim, METH_O, "Trim(NCMesh self)"}, { "NCMesh_MemoryUsage", _wrap_NCMesh_MemoryUsage, METH_O, "MemoryUsage(NCMesh self) -> long"}, { "NCMesh_PrintMemoryDetail", _wrap_NCMesh_PrintMemoryDetail, METH_O, "PrintMemoryDetail(NCMesh self) -> int"}, diff --git a/mfem/_par/nonlinearform_wrap.cxx b/mfem/_par/nonlinearform_wrap.cxx index 6d367b17..4e209351 100644 --- a/mfem/_par/nonlinearform_wrap.cxx +++ b/mfem/_par/nonlinearform_wrap.cxx @@ -3414,17 +3414,19 @@ SWIGINTERN mfem::SparseMatrix *mfem_NonlinearForm_GetGradientMatrix(mfem::Nonlin #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"f", NULL + }; mfem::NonlinearForm *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_NonlinearForm", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonlinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -3449,7 +3451,7 @@ SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::AssemblyLevel arg2 ; @@ -3457,15 +3459,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"assembly_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_SetAssemblyLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); } @@ -3592,7 +3598,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_FESpace(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::NonlinearFormIntegrator *arg2 = (mfem::NonlinearFormIntegrator *) 0 ; @@ -3600,15 +3606,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::NonlinearFormIntegrator *""'"); } @@ -3668,7 +3678,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetDNFI(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::NonlinearFormIntegrator *arg2 = (mfem::NonlinearFormIntegrator *) 0 ; @@ -3676,15 +3686,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_AddInteriorFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_AddInteriorFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_AddInteriorFaceIntegrator" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_AddInteriorFaceIntegrator" "', argument " "2"" of type '" "mfem::NonlinearFormIntegrator *""'"); } @@ -3851,25 +3865,31 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddBdrFaceIntegrator(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"rhs", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:NonlinearForm_SetEssentialBC", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -3877,11 +3897,13 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "3"" of type '" "mfem::Vector *""'"); + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "3"" of type '" "mfem::Vector *""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { (arg1)->SetEssentialBC((mfem::Array< int > const &)*arg2,arg3); @@ -3902,7 +3924,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -3910,107 +3932,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_1(PyObject *SWIGUN int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->SetEssentialBC((mfem::Array< int > const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_vdofs_list", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "NonlinearForm_SetEssentialBC", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NonlinearForm_SetEssentialBC__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NonlinearForm_SetEssentialBC__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NonlinearForm_SetEssentialBC'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NonlinearForm::SetEssentialBC(mfem::Array< int > const &,mfem::Vector *)\n" - " mfem::NonlinearForm::SetEssentialBC(mfem::Array< int > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetEssentialVDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_SetEssentialVDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialVDofs" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -4038,7 +3972,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialVDofs(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4046,15 +3980,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialTrueDofs(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetEssentialTrueDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_SetEssentialTrueDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -4117,7 +4055,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetEssentialTrueDofs(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4125,16 +4063,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetGridFunctionEnergy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetGridFunctionEnergy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetGridFunctionEnergy" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetGridFunctionEnergy" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4162,7 +4104,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4170,16 +4112,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetEnergy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetEnergy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetEnergy" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetEnergy" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4207,7 +4153,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4218,15 +4164,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NonlinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_Mult" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4234,7 +4185,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4262,7 +4213,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4270,16 +4221,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetGradient" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4479,7 +4434,7 @@ SWIGINTERN PyObject *_wrap_delete_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradientMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradientMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4487,16 +4442,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradientMatrix(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetGradientMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetGradientMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetGradientMatrix" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetGradientMatrix" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4813,16 +4772,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_FESpace(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Array< mfem::FiniteElementSpace * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_SetSpaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_SetSpaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_SetSpaces" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } @@ -4830,12 +4793,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM { // List/Tuple -> mfem::FiniteElementSpace * int res = 0; - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); arg2 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::FiniteElementSpace * ttt; - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -4848,12 +4811,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM } arg2[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); arg2 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::FiniteElementSpace * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -4972,7 +4935,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetBlockTrueOffsets(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::BlockNonlinearFormIntegrator *arg2 = (mfem::BlockNonlinearFormIntegrator *) 0 ; @@ -4980,15 +4943,19 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } @@ -5013,7 +4980,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::BlockNonlinearFormIntegrator *arg2 = (mfem::BlockNonlinearFormIntegrator *) 0 ; @@ -5021,15 +4988,19 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_AddInteriorFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_AddInteriorFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_AddInteriorFaceIntegrator" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_AddInteriorFaceIntegrator" "', argument " "2"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } @@ -5196,17 +5167,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddBdrFaceIntegrator(PyObject *sel } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Array< mfem::Array< int > * > *arg2 = 0 ; mfem::Array< mfem::Vector * > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"rhs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_SetEssentialBC", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockNonlinearForm_SetEssentialBC", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_SetEssentialBC" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } @@ -5214,12 +5190,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE { // List/Tuple -> mfem::Array * int res = 0; - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); arg2 = new mfem::Array *>(ll); for (int i = 0; i < ll; i++) { mfem::Array * ttt; - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -5232,12 +5208,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE } arg2[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); arg2 = new mfem::Array *>(ll); for (int i = 0; i < ll; i++) { mfem::Array * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -5259,12 +5235,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE { // List/Tuple -> mfem::Vector * int res = 0; - if (PyList_Check(swig_obj[2])) { - int ll = PyList_Size(swig_obj[2]); + if (PyList_Check(obj2)) { + int ll = PyList_Size(obj2); arg3 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::Vector * ttt; - PyObject *s = PyList_GetItem(swig_obj[2],i); + PyObject *s = PyList_GetItem(obj2,i); if (s == Py_None){ ttt = NULL; } else { @@ -5277,12 +5253,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE } arg3[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[2])) { - int ll = PyTuple_Size(swig_obj[2]); + } else if (PyTuple_Check(obj2)) { + int ll = PyTuple_Size(obj2); arg3 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::Vector * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[2],i); + PyObject *s = PyTuple_GetItem(obj2,i); if (s == Py_None){ ttt = NULL; } else { @@ -5341,7 +5317,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5349,16 +5325,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_GetEnergy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_GetEnergy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_GetEnergy" "', argument " "1"" of type '" "mfem::BlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_GetEnergy" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5386,7 +5366,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5397,15 +5377,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockNonlinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_Mult" "', argument " "1"" of type '" "mfem::BlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5413,7 +5398,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5441,7 +5426,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5449,16 +5434,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_GetGradient" "', argument " "1"" of type '" "mfem::BlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5534,33 +5523,33 @@ SWIGINTERN PyObject *BlockNonlinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, - { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "NonlinearForm_SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "new_NonlinearForm", (PyCFunction)(void(*)(void))_wrap_new_NonlinearForm, METH_VARARGS|METH_KEYWORDS, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" ""}, - { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "NonlinearForm_AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "NonlinearForm_GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, - { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "NonlinearForm_AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "NonlinearForm_AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" "NonlinearForm_AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nfi, intArray bdr_marker)\n" ""}, - { "NonlinearForm_SetEssentialBC", _wrap_NonlinearForm_SetEssentialBC, METH_VARARGS, "NonlinearForm_SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, - { "NonlinearForm_SetEssentialVDofs", _wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS, "NonlinearForm_SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, - { "NonlinearForm_SetEssentialTrueDofs", _wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS, "NonlinearForm_SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, + { "NonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, + { "NonlinearForm_SetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, + { "NonlinearForm_SetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, { "NonlinearForm_GetEssentialTrueDofs", _wrap_NonlinearForm_GetEssentialTrueDofs, METH_O, "NonlinearForm_GetEssentialTrueDofs(NonlinearForm self) -> intArray"}, - { "NonlinearForm_GetGridFunctionEnergy", _wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS, "NonlinearForm_GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_GetEnergy", _wrap_NonlinearForm_GetEnergy, METH_VARARGS, "NonlinearForm_GetEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "NonlinearForm_Mult(NonlinearForm self, Vector x, Vector y)"}, - { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "NonlinearForm_GetGradient(NonlinearForm self, Vector x) -> Operator"}, + { "NonlinearForm_GetGridFunctionEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_Mult(NonlinearForm self, Vector x, Vector y)"}, + { "NonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetGradient(NonlinearForm self, Vector x) -> Operator"}, { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "NonlinearForm_Update(NonlinearForm self)"}, { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "NonlinearForm_Setup(NonlinearForm self)"}, { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "NonlinearForm_GetProlongation(NonlinearForm self) -> Operator"}, { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "NonlinearForm_GetRestriction(NonlinearForm self) -> Operator"}, { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, - { "NonlinearForm_GetGradientMatrix", _wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS, "NonlinearForm_GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, + { "NonlinearForm_GetGradientMatrix", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, { "NonlinearForm_swigregister", NonlinearForm_swigregister, METH_O, NULL}, { "NonlinearForm_swiginit", NonlinearForm_swiginit, METH_VARARGS, NULL}, { "new_BlockNonlinearForm", _wrap_new_BlockNonlinearForm, METH_VARARGS, "\n" @@ -5571,19 +5560,19 @@ static PyMethodDef SwigMethods[] = { "BlockNonlinearForm_FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" "BlockNonlinearForm_FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" ""}, - { "BlockNonlinearForm_SetSpaces", _wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS, "BlockNonlinearForm_SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, + { "BlockNonlinearForm_SetSpaces", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, { "BlockNonlinearForm_GetBlockOffsets", _wrap_BlockNonlinearForm_GetBlockOffsets, METH_O, "BlockNonlinearForm_GetBlockOffsets(BlockNonlinearForm self) -> intArray"}, { "BlockNonlinearForm_GetBlockTrueOffsets", _wrap_BlockNonlinearForm_GetBlockTrueOffsets, METH_O, "BlockNonlinearForm_GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray"}, - { "BlockNonlinearForm_AddDomainIntegrator", _wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS, "BlockNonlinearForm_AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, - { "BlockNonlinearForm_AddInteriorFaceIntegrator", _wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "BlockNonlinearForm_AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, { "BlockNonlinearForm_AddBdrFaceIntegrator", _wrap_BlockNonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "BlockNonlinearForm_AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)\n" "BlockNonlinearForm_AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi, intArray bdr_marker)\n" ""}, - { "BlockNonlinearForm_SetEssentialBC", _wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS, "BlockNonlinearForm_SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, - { "BlockNonlinearForm_GetEnergy", _wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS, "BlockNonlinearForm_GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, - { "BlockNonlinearForm_Mult", _wrap_BlockNonlinearForm_Mult, METH_VARARGS, "BlockNonlinearForm_Mult(BlockNonlinearForm self, Vector x, Vector y)"}, - { "BlockNonlinearForm_GetGradient", _wrap_BlockNonlinearForm_GetGradient, METH_VARARGS, "BlockNonlinearForm_GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, + { "BlockNonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "BlockNonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, + { "BlockNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_Mult(BlockNonlinearForm self, Vector x, Vector y)"}, + { "BlockNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, { "delete_BlockNonlinearForm", _wrap_delete_BlockNonlinearForm, METH_O, "delete_BlockNonlinearForm(BlockNonlinearForm self)"}, { "BlockNonlinearForm_swigregister", BlockNonlinearForm_swigregister, METH_O, NULL}, { "BlockNonlinearForm_swiginit", BlockNonlinearForm_swiginit, METH_VARARGS, NULL}, @@ -5593,33 +5582,33 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, - { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "new_NonlinearForm", (PyCFunction)(void(*)(void))_wrap_new_NonlinearForm, METH_VARARGS|METH_KEYWORDS, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" "FESpace(NonlinearForm self) -> FiniteElementSpace\n" "FESpace(NonlinearForm self) -> FiniteElementSpace\n" ""}, - { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, - { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nfi, intArray bdr_marker)\n" ""}, - { "NonlinearForm_SetEssentialBC", _wrap_NonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, - { "NonlinearForm_SetEssentialVDofs", _wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS, "SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, - { "NonlinearForm_SetEssentialTrueDofs", _wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS, "SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, + { "NonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, + { "NonlinearForm_SetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, + { "NonlinearForm_SetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, { "NonlinearForm_GetEssentialTrueDofs", _wrap_NonlinearForm_GetEssentialTrueDofs, METH_O, "GetEssentialTrueDofs(NonlinearForm self) -> intArray"}, - { "NonlinearForm_GetGridFunctionEnergy", _wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS, "GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_GetEnergy", _wrap_NonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "Mult(NonlinearForm self, Vector x, Vector y)"}, - { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "GetGradient(NonlinearForm self, Vector x) -> Operator"}, + { "NonlinearForm_GetGridFunctionEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS|METH_KEYWORDS, "GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "GetEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(NonlinearForm self, Vector x, Vector y)"}, + { "NonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(NonlinearForm self, Vector x) -> Operator"}, { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "Update(NonlinearForm self)"}, { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "Setup(NonlinearForm self)"}, { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "GetProlongation(NonlinearForm self) -> Operator"}, { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "GetRestriction(NonlinearForm self) -> Operator"}, { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, - { "NonlinearForm_GetGradientMatrix", _wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS, "GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, + { "NonlinearForm_GetGradientMatrix", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS|METH_KEYWORDS, "GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, { "NonlinearForm_swigregister", NonlinearForm_swigregister, METH_O, NULL}, { "NonlinearForm_swiginit", NonlinearForm_swiginit, METH_VARARGS, NULL}, { "new_BlockNonlinearForm", _wrap_new_BlockNonlinearForm, METH_VARARGS, "\n" @@ -5630,19 +5619,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" ""}, - { "BlockNonlinearForm_SetSpaces", _wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS, "SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, + { "BlockNonlinearForm_SetSpaces", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS|METH_KEYWORDS, "SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, { "BlockNonlinearForm_GetBlockOffsets", _wrap_BlockNonlinearForm_GetBlockOffsets, METH_O, "GetBlockOffsets(BlockNonlinearForm self) -> intArray"}, { "BlockNonlinearForm_GetBlockTrueOffsets", _wrap_BlockNonlinearForm_GetBlockTrueOffsets, METH_O, "GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray"}, - { "BlockNonlinearForm_AddDomainIntegrator", _wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, - { "BlockNonlinearForm_AddInteriorFaceIntegrator", _wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, { "BlockNonlinearForm_AddBdrFaceIntegrator", _wrap_BlockNonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)\n" "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi, intArray bdr_marker)\n" ""}, - { "BlockNonlinearForm_SetEssentialBC", _wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, - { "BlockNonlinearForm_GetEnergy", _wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, - { "BlockNonlinearForm_Mult", _wrap_BlockNonlinearForm_Mult, METH_VARARGS, "Mult(BlockNonlinearForm self, Vector x, Vector y)"}, - { "BlockNonlinearForm_GetGradient", _wrap_BlockNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, + { "BlockNonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "BlockNonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, + { "BlockNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockNonlinearForm self, Vector x, Vector y)"}, + { "BlockNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, { "delete_BlockNonlinearForm", _wrap_delete_BlockNonlinearForm, METH_O, "delete_BlockNonlinearForm(BlockNonlinearForm self)"}, { "BlockNonlinearForm_swigregister", BlockNonlinearForm_swigregister, METH_O, NULL}, { "BlockNonlinearForm_swiginit", BlockNonlinearForm_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/nonlininteg_wrap.cxx b/mfem/_par/nonlininteg_wrap.cxx index 2d0578c8..b90c8f74 100644 --- a/mfem/_par/nonlininteg_wrap.cxx +++ b/mfem/_par/nonlininteg_wrap.cxx @@ -3648,54 +3648,33 @@ SwigDirector_NonlinearFormIntegrator::~SwigDirector_NonlinearFormIntegrator() { #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) NULL ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"ir", NULL + }; mfem::NonlinearFormIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonlinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::NonlinearFormIntegrator *)new SwigDirector_NonlinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_NonlinearFormIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + arg1 = obj0; + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonlinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NonlinearFormIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::NonlinearFormIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::NonlinearFormIntegrator *)new SwigDirector_NonlinearFormIntegrator(arg1); + result = (mfem::NonlinearFormIntegrator *)new SwigDirector_NonlinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -3712,44 +3691,7 @@ SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_NonlinearFormIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_NonlinearFormIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - _v = (argv[0] != 0); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_NonlinearFormIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NonlinearFormIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NonlinearFormIntegrator::NonlinearFormIntegrator(mfem::IntegrationRule const *)\n" - " mfem::NonlinearFormIntegrator::NonlinearFormIntegrator(PyObject *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -3757,15 +3699,19 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_SetIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearFormIntegrator_SetIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_SetIntRule" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_SetIntRule" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } @@ -3785,7 +3731,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -3793,15 +3739,19 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"irule", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_SetIntegrationRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearFormIntegrator_SetIntegrationRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_SetIntegrationRule" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_SetIntegrationRule" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -3824,7 +3774,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject * } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -3841,17 +3791,24 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NonlinearFormIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -3859,7 +3816,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -3867,7 +3824,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -3875,7 +3832,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -3884,7 +3841,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec } arg5 = reinterpret_cast< mfem::Vector * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -3908,7 +3865,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -3928,17 +3885,25 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleFaceVector", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:NonlinearFormIntegrator_AssembleFaceVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -3946,7 +3911,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -3954,7 +3919,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -3962,7 +3927,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Vector const &""'"); } @@ -3970,7 +3935,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Vector const &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -3979,7 +3944,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * } arg6 = reinterpret_cast< mfem::Vector * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4003,7 +3968,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4020,17 +3985,24 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NonlinearFormIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4038,7 +4010,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4046,7 +4018,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -4054,7 +4026,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -4063,7 +4035,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4087,7 +4059,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4107,17 +4079,25 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:NonlinearFormIntegrator_AssembleFaceGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4125,7 +4105,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -4133,7 +4113,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -4141,7 +4121,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } @@ -4149,7 +4129,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } @@ -4158,7 +4138,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW } arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4182,7 +4162,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4196,18 +4176,24 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NonlinearFormIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4215,7 +4201,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4223,7 +4209,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -4232,7 +4218,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4415,7 +4401,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4426,17 +4412,22 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NonlinearFormIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4444,7 +4435,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4453,7 +4444,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSE } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4506,16 +4497,18 @@ SWIGINTERN PyObject *_wrap_delete_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_disown_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_NonlinearFormIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_NonlinearFormIntegrator" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } @@ -4543,7 +4536,7 @@ SWIGINTERN PyObject *NonlinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4557,16 +4550,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockNonlinearFormIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4574,7 +4573,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4582,7 +4581,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4605,7 +4604,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4622,15 +4621,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BlockNonlinearFormIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4638,7 +4644,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4646,7 +4652,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4654,7 +4660,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); } @@ -4677,7 +4683,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4697,15 +4703,23 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleFaceVector", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:BlockNonlinearFormIntegrator_AssembleFaceVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4713,7 +4727,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4721,7 +4735,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg3 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -4729,7 +4743,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4737,7 +4751,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg5 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "6"" of type '" "mfem::Array< mfem::Vector * > const &""'"); } @@ -4760,7 +4774,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4777,15 +4791,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmats", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BlockNonlinearFormIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4793,7 +4814,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4801,7 +4822,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4809,7 +4830,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); } @@ -4832,7 +4853,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4852,15 +4873,23 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elmats", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:BlockNonlinearFormIntegrator_AssembleFaceGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4868,7 +4897,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4876,7 +4905,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg3 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -4884,7 +4913,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4892,7 +4921,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg5 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); } @@ -5004,7 +5033,7 @@ SWIGINTERN PyObject *_wrap_delete_HyperelasticModel(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5012,15 +5041,19 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_Ttr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_SetTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyperelasticModel_SetTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_SetTransformation" "', argument " "1"" of type '" "mfem::HyperelasticModel *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_SetTransformation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5043,7 +5076,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5051,16 +5084,20 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Jpt", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_EvalW", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyperelasticModel_EvalW", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_EvalW" "', argument " "1"" of type '" "mfem::HyperelasticModel const *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_EvalW" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5083,7 +5120,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5094,15 +5131,20 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Jpt", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_EvalP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HyperelasticModel_EvalP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_EvalP" "', argument " "1"" of type '" "mfem::HyperelasticModel const *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5110,7 +5152,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticModel_EvalP" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5133,7 +5175,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5150,15 +5192,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM( int ecode4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Jpt", (char *)"DS", (char *)"weight", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_AssembleH", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HyperelasticModel_AssembleH", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_AssembleH" "', argument " "1"" of type '" "mfem::HyperelasticModel const *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5166,7 +5215,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5174,12 +5223,12 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HyperelasticModel_AssembleH" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HyperelasticModel_AssembleH" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -5209,7 +5258,7 @@ SWIGINTERN PyObject *HyperelasticModel_swigregister(PyObject *SWIGUNUSEDPARM(sel return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseHarmonicModel *arg1 = (mfem::InverseHarmonicModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5217,16 +5266,20 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "InverseHarmonicModel_EvalW", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseHarmonicModel_EvalW", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseHarmonicModel_EvalW" "', argument " "1"" of type '" "mfem::InverseHarmonicModel const *""'"); } arg1 = reinterpret_cast< mfem::InverseHarmonicModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseHarmonicModel_EvalW" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5249,7 +5302,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseHarmonicModel *arg1 = (mfem::InverseHarmonicModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5260,15 +5313,20 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseHarmonicModel_EvalP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseHarmonicModel_EvalP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseHarmonicModel_EvalP" "', argument " "1"" of type '" "mfem::InverseHarmonicModel const *""'"); } arg1 = reinterpret_cast< mfem::InverseHarmonicModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseHarmonicModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5276,7 +5334,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseHarmonicModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseHarmonicModel_EvalP" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5299,7 +5357,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseHarmonicModel *arg1 = (mfem::InverseHarmonicModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5316,15 +5374,22 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPA int ecode4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"DS", (char *)"weight", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseHarmonicModel_AssembleH", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:InverseHarmonicModel_AssembleH", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "1"" of type '" "mfem::InverseHarmonicModel const *""'"); } arg1 = reinterpret_cast< mfem::InverseHarmonicModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5332,7 +5397,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseHarmonicModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5340,12 +5405,12 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseHarmonicModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -5432,7 +5497,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( PyObject *resultobj = 0; double arg1 ; double arg2 ; - double arg3 ; + double arg3 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; double val2 ; @@ -5441,7 +5506,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( int ecode3 = 0 ; mfem::NeoHookeanModel *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "double""'"); @@ -5452,11 +5517,13 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } { try { result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(arg1,arg2,arg3); @@ -5473,46 +5540,10 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - double arg1 ; - double arg2 ; - double val1 ; - int ecode1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::NeoHookeanModel *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NeoHookeanModel, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5521,7 +5552,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_2(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; mfem::NeoHookeanModel *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -5538,56 +5569,16 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_2(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "mfem::Coefficient *""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(*arg1,*arg2,arg3); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NeoHookeanModel, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::NeoHookeanModel *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(*arg1,*arg2); + result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(*arg1,*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5608,37 +5599,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_NeoHookeanModel", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_NeoHookeanModel__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_NeoHookeanModel__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); @@ -5648,16 +5609,19 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_NeoHookeanModel__SWIG_1(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_NeoHookeanModel__SWIG_2(self, argc, argv); + return _wrap_new_NeoHookeanModel__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; { int res = SWIG_AsVal_double(argv[0], NULL); @@ -5669,6 +5633,9 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 2) { + return _wrap_new_NeoHookeanModel__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); @@ -5684,14 +5651,12 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NeoHookeanModel'.\n" " Possible C/C++ prototypes are:\n" " mfem::NeoHookeanModel::NeoHookeanModel(double,double,double)\n" - " mfem::NeoHookeanModel::NeoHookeanModel(double,double)\n" - " mfem::NeoHookeanModel::NeoHookeanModel(mfem::Coefficient &,mfem::Coefficient &,mfem::Coefficient *)\n" - " mfem::NeoHookeanModel::NeoHookeanModel(mfem::Coefficient &,mfem::Coefficient &)\n"); + " mfem::NeoHookeanModel::NeoHookeanModel(mfem::Coefficient &,mfem::Coefficient &,mfem::Coefficient *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NeoHookeanModel *arg1 = (mfem::NeoHookeanModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5699,16 +5664,20 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NeoHookeanModel_EvalW", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NeoHookeanModel_EvalW", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NeoHookeanModel_EvalW" "', argument " "1"" of type '" "mfem::NeoHookeanModel const *""'"); } arg1 = reinterpret_cast< mfem::NeoHookeanModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NeoHookeanModel_EvalW" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5731,7 +5700,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NeoHookeanModel *arg1 = (mfem::NeoHookeanModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5742,15 +5711,20 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NeoHookeanModel_EvalP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NeoHookeanModel_EvalP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NeoHookeanModel_EvalP" "', argument " "1"" of type '" "mfem::NeoHookeanModel const *""'"); } arg1 = reinterpret_cast< mfem::NeoHookeanModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NeoHookeanModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5758,7 +5732,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NeoHookeanModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NeoHookeanModel_EvalP" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5781,7 +5755,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NeoHookeanModel *arg1 = (mfem::NeoHookeanModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5798,15 +5772,22 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(se int ecode4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"DS", (char *)"weight", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NeoHookeanModel_AssembleH", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NeoHookeanModel_AssembleH", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NeoHookeanModel_AssembleH" "', argument " "1"" of type '" "mfem::NeoHookeanModel const *""'"); } arg1 = reinterpret_cast< mfem::NeoHookeanModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NeoHookeanModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5814,7 +5795,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NeoHookeanModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NeoHookeanModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5822,12 +5803,12 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NeoHookeanModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NeoHookeanModel_AssembleH" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NeoHookeanModel_AssembleH" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -5890,17 +5871,19 @@ SWIGINTERN PyObject *NeoHookeanModel_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HyperelasticNLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HyperelasticNLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"m", NULL + }; mfem::HyperelasticNLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_HyperelasticNLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HyperelasticNLFIntegrator" "', argument " "1"" of type '" "mfem::HyperelasticModel *""'"); } @@ -5920,7 +5903,7 @@ SWIGINTERN PyObject *_wrap_new_HyperelasticNLFIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticNLFIntegrator *arg1 = (mfem::HyperelasticNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5934,16 +5917,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Ttr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticNLFIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:HyperelasticNLFIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::HyperelasticNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5951,7 +5940,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5959,7 +5948,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -5982,7 +5971,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * } -SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticNLFIntegrator *arg1 = (mfem::HyperelasticNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5999,15 +5988,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Ttr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticNLFIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HyperelasticNLFIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::HyperelasticNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6015,7 +6011,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6023,7 +6019,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -6031,7 +6027,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -6054,7 +6050,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj } -SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticNLFIntegrator *arg1 = (mfem::HyperelasticNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6071,15 +6067,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Ttr", (char *)"elfun", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticNLFIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HyperelasticNLFIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::HyperelasticNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6087,7 +6090,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6095,7 +6098,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -6103,7 +6106,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -6166,17 +6169,19 @@ SWIGINTERN PyObject *HyperelasticNLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_mu", NULL + }; mfem::IncompressibleNeoHookeanIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_IncompressibleNeoHookeanIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -6199,7 +6204,7 @@ SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -6213,16 +6218,22 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IncompressibleNeoHookeanIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); } arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -6230,7 +6241,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6238,7 +6249,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -6261,7 +6272,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -6278,15 +6289,22 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:IncompressibleNeoHookeanIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); } arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -6294,7 +6312,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6302,7 +6320,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -6310,7 +6328,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); } @@ -6333,7 +6351,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -6350,15 +6368,22 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmats", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:IncompressibleNeoHookeanIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); } arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -6366,7 +6391,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6374,7 +6399,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -6382,7 +6407,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); } @@ -6526,7 +6551,7 @@ SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6534,11 +6559,15 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"fe", (char *)"T", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorConvectionNLFIntegrator_GetRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } @@ -6546,7 +6575,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6569,7 +6598,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6586,15 +6615,22 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"trans", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorConvectionNLFIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6602,7 +6638,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6610,7 +6646,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -6618,7 +6654,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -6641,7 +6677,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6658,15 +6694,22 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"trans", (char *)"elfun", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorConvectionNLFIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6674,7 +6717,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6682,7 +6725,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -6690,7 +6733,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -6900,7 +6943,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA(PyObject *se } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6911,15 +6954,20 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorConvectionNLFIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6927,7 +6975,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6993,66 +7041,66 @@ SWIGINTERN PyObject *VectorConvectionNLFIntegrator_swiginit(PyObject *SWIGUNUSED static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, - { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, - { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, - { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "NonlinearFormIntegrator_GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "new_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_NonlinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> NonlinearFormIntegrator"}, + { "NonlinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, + { "NonlinearFormIntegrator_SetIntegrationRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, + { "NonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "NonlinearFormIntegrator_AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, + { "NonlinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, - { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, + { "disown_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "BlockNonlinearFormIntegrator_GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, - { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "BlockNonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, + { "BlockNonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, - { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "HyperelasticModel_SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, - { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "HyperelasticModel_EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, - { "HyperelasticModel_EvalP", _wrap_HyperelasticModel_EvalP, METH_VARARGS, "HyperelasticModel_EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, - { "HyperelasticModel_AssembleH", _wrap_HyperelasticModel_AssembleH, METH_VARARGS, "HyperelasticModel_AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "HyperelasticModel_SetTransformation", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_SetTransformation, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, + { "HyperelasticModel_EvalW", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalW, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, + { "HyperelasticModel_EvalP", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalP, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, + { "HyperelasticModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "HyperelasticModel_swigregister", HyperelasticModel_swigregister, METH_O, NULL}, - { "InverseHarmonicModel_EvalW", _wrap_InverseHarmonicModel_EvalW, METH_VARARGS, "InverseHarmonicModel_EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, - { "InverseHarmonicModel_EvalP", _wrap_InverseHarmonicModel_EvalP, METH_VARARGS, "InverseHarmonicModel_EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, - { "InverseHarmonicModel_AssembleH", _wrap_InverseHarmonicModel_AssembleH, METH_VARARGS, "InverseHarmonicModel_AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "InverseHarmonicModel_EvalW", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalW, METH_VARARGS|METH_KEYWORDS, "InverseHarmonicModel_EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, + { "InverseHarmonicModel_EvalP", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalP, METH_VARARGS|METH_KEYWORDS, "InverseHarmonicModel_EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, + { "InverseHarmonicModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "InverseHarmonicModel_AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "new_InverseHarmonicModel", _wrap_new_InverseHarmonicModel, METH_NOARGS, "new_InverseHarmonicModel() -> InverseHarmonicModel"}, { "delete_InverseHarmonicModel", _wrap_delete_InverseHarmonicModel, METH_O, "delete_InverseHarmonicModel(InverseHarmonicModel self)"}, { "InverseHarmonicModel_swigregister", InverseHarmonicModel_swigregister, METH_O, NULL}, { "InverseHarmonicModel_swiginit", InverseHarmonicModel_swiginit, METH_VARARGS, NULL}, { "new_NeoHookeanModel", _wrap_new_NeoHookeanModel, METH_VARARGS, "\n" "NeoHookeanModel(double _mu, double _K, double _g=1.0)\n" - "NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None)\n" + "new_NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None) -> NeoHookeanModel\n" ""}, - { "NeoHookeanModel_EvalW", _wrap_NeoHookeanModel_EvalW, METH_VARARGS, "NeoHookeanModel_EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, - { "NeoHookeanModel_EvalP", _wrap_NeoHookeanModel_EvalP, METH_VARARGS, "NeoHookeanModel_EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, - { "NeoHookeanModel_AssembleH", _wrap_NeoHookeanModel_AssembleH, METH_VARARGS, "NeoHookeanModel_AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "NeoHookeanModel_EvalW", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalW, METH_VARARGS|METH_KEYWORDS, "NeoHookeanModel_EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, + { "NeoHookeanModel_EvalP", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalP, METH_VARARGS|METH_KEYWORDS, "NeoHookeanModel_EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, + { "NeoHookeanModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "NeoHookeanModel_AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "delete_NeoHookeanModel", _wrap_delete_NeoHookeanModel, METH_O, "delete_NeoHookeanModel(NeoHookeanModel self)"}, { "NeoHookeanModel_swigregister", NeoHookeanModel_swigregister, METH_O, NULL}, { "NeoHookeanModel_swiginit", NeoHookeanModel_swiginit, METH_VARARGS, NULL}, - { "new_HyperelasticNLFIntegrator", _wrap_new_HyperelasticNLFIntegrator, METH_O, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, - { "HyperelasticNLFIntegrator_GetElementEnergy", _wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS, "HyperelasticNLFIntegrator_GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, - { "HyperelasticNLFIntegrator_AssembleElementVector", _wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS, "HyperelasticNLFIntegrator_AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, - { "HyperelasticNLFIntegrator_AssembleElementGrad", _wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS, "HyperelasticNLFIntegrator_AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, + { "new_HyperelasticNLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_HyperelasticNLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, + { "HyperelasticNLFIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "HyperelasticNLFIntegrator_GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, + { "HyperelasticNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "HyperelasticNLFIntegrator_AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, + { "HyperelasticNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "HyperelasticNLFIntegrator_AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, { "delete_HyperelasticNLFIntegrator", _wrap_delete_HyperelasticNLFIntegrator, METH_O, "delete_HyperelasticNLFIntegrator(HyperelasticNLFIntegrator self)"}, { "HyperelasticNLFIntegrator_swigregister", HyperelasticNLFIntegrator_swigregister, METH_O, NULL}, { "HyperelasticNLFIntegrator_swiginit", HyperelasticNLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_IncompressibleNeoHookeanIntegrator", _wrap_new_IncompressibleNeoHookeanIntegrator, METH_O, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, - { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", _wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS, "IncompressibleNeoHookeanIntegrator_GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS, "IncompressibleNeoHookeanIntegrator_AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "new_IncompressibleNeoHookeanIntegrator", (PyCFunction)(void(*)(void))_wrap_new_IncompressibleNeoHookeanIntegrator, METH_VARARGS|METH_KEYWORDS, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, + { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "IncompressibleNeoHookeanIntegrator_GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "IncompressibleNeoHookeanIntegrator_AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, @@ -7060,15 +7108,15 @@ static PyMethodDef SwigMethods[] = { "VectorConvectionNLFIntegrator(Coefficient q)\n" "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" ""}, - { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, - { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, - { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" ""}, - { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "VectorConvectionNLFIntegrator_AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "VectorConvectionNLFIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, @@ -7078,66 +7126,66 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, - { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, - { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, - { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "new_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_NonlinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> NonlinearFormIntegrator"}, + { "NonlinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, + { "NonlinearFormIntegrator_SetIntegrationRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS|METH_KEYWORDS, "SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, + { "NonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, + { "NonlinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, - { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, + { "disown_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, - { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "BlockNonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, + { "BlockNonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, - { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, - { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, - { "HyperelasticModel_EvalP", _wrap_HyperelasticModel_EvalP, METH_VARARGS, "EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, - { "HyperelasticModel_AssembleH", _wrap_HyperelasticModel_AssembleH, METH_VARARGS, "AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "HyperelasticModel_SetTransformation", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_SetTransformation, METH_VARARGS|METH_KEYWORDS, "SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, + { "HyperelasticModel_EvalW", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalW, METH_VARARGS|METH_KEYWORDS, "EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, + { "HyperelasticModel_EvalP", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalP, METH_VARARGS|METH_KEYWORDS, "EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, + { "HyperelasticModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "HyperelasticModel_swigregister", HyperelasticModel_swigregister, METH_O, NULL}, - { "InverseHarmonicModel_EvalW", _wrap_InverseHarmonicModel_EvalW, METH_VARARGS, "EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, - { "InverseHarmonicModel_EvalP", _wrap_InverseHarmonicModel_EvalP, METH_VARARGS, "EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, - { "InverseHarmonicModel_AssembleH", _wrap_InverseHarmonicModel_AssembleH, METH_VARARGS, "AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "InverseHarmonicModel_EvalW", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalW, METH_VARARGS|METH_KEYWORDS, "EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, + { "InverseHarmonicModel_EvalP", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalP, METH_VARARGS|METH_KEYWORDS, "EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, + { "InverseHarmonicModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "new_InverseHarmonicModel", _wrap_new_InverseHarmonicModel, METH_NOARGS, "new_InverseHarmonicModel() -> InverseHarmonicModel"}, { "delete_InverseHarmonicModel", _wrap_delete_InverseHarmonicModel, METH_O, "delete_InverseHarmonicModel(InverseHarmonicModel self)"}, { "InverseHarmonicModel_swigregister", InverseHarmonicModel_swigregister, METH_O, NULL}, { "InverseHarmonicModel_swiginit", InverseHarmonicModel_swiginit, METH_VARARGS, NULL}, { "new_NeoHookeanModel", _wrap_new_NeoHookeanModel, METH_VARARGS, "\n" "NeoHookeanModel(double _mu, double _K, double _g=1.0)\n" - "NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None)\n" + "new_NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None) -> NeoHookeanModel\n" ""}, - { "NeoHookeanModel_EvalW", _wrap_NeoHookeanModel_EvalW, METH_VARARGS, "EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, - { "NeoHookeanModel_EvalP", _wrap_NeoHookeanModel_EvalP, METH_VARARGS, "EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, - { "NeoHookeanModel_AssembleH", _wrap_NeoHookeanModel_AssembleH, METH_VARARGS, "AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "NeoHookeanModel_EvalW", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalW, METH_VARARGS|METH_KEYWORDS, "EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, + { "NeoHookeanModel_EvalP", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalP, METH_VARARGS|METH_KEYWORDS, "EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, + { "NeoHookeanModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "delete_NeoHookeanModel", _wrap_delete_NeoHookeanModel, METH_O, "delete_NeoHookeanModel(NeoHookeanModel self)"}, { "NeoHookeanModel_swigregister", NeoHookeanModel_swigregister, METH_O, NULL}, { "NeoHookeanModel_swiginit", NeoHookeanModel_swiginit, METH_VARARGS, NULL}, - { "new_HyperelasticNLFIntegrator", _wrap_new_HyperelasticNLFIntegrator, METH_O, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, - { "HyperelasticNLFIntegrator_GetElementEnergy", _wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, - { "HyperelasticNLFIntegrator_AssembleElementVector", _wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, - { "HyperelasticNLFIntegrator_AssembleElementGrad", _wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, + { "new_HyperelasticNLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_HyperelasticNLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, + { "HyperelasticNLFIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, + { "HyperelasticNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, + { "HyperelasticNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, { "delete_HyperelasticNLFIntegrator", _wrap_delete_HyperelasticNLFIntegrator, METH_O, "delete_HyperelasticNLFIntegrator(HyperelasticNLFIntegrator self)"}, { "HyperelasticNLFIntegrator_swigregister", HyperelasticNLFIntegrator_swigregister, METH_O, NULL}, { "HyperelasticNLFIntegrator_swiginit", HyperelasticNLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_IncompressibleNeoHookeanIntegrator", _wrap_new_IncompressibleNeoHookeanIntegrator, METH_O, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, - { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", _wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "new_IncompressibleNeoHookeanIntegrator", (PyCFunction)(void(*)(void))_wrap_new_IncompressibleNeoHookeanIntegrator, METH_VARARGS|METH_KEYWORDS, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, + { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, @@ -7145,15 +7193,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorConvectionNLFIntegrator(Coefficient q)\n" "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" ""}, - { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, - { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, - { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" ""}, - { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "VectorConvectionNLFIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/ode.py b/mfem/_par/ode.py index d9116287..d913ad7b 100644 --- a/mfem/_par/ode.py +++ b/mfem/_par/ode.py @@ -128,9 +128,9 @@ class RK2Solver(ODESolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RK2Solver self, double const _a=2./3.) -> RK2Solver""" - _ode.RK2Solver_swiginit(self, _ode.new_RK2Solver(*args)) + _ode.RK2Solver_swiginit(self, _ode.new_RK2Solver(*args, **kwargs)) def Init(self, _f): r"""Init(RK2Solver self, TimeDependentOperator _f)""" @@ -701,9 +701,9 @@ def __init__(self, beta_=0.25, gamma_=0.5): r"""__init__(NewmarkSolver self, double beta_=0.25, double gamma_=0.5) -> NewmarkSolver""" _ode.NewmarkSolver_swiginit(self, _ode.new_NewmarkSolver(beta_, gamma_)) - def PrintProperties(self, *args): + def PrintProperties(self, *args, **kwargs): r"""PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)""" - return _ode.NewmarkSolver_PrintProperties(self, *args) + return _ode.NewmarkSolver_PrintProperties(self, *args, **kwargs) PrintProperties = _swig_new_instance_method(_ode.NewmarkSolver_PrintProperties) def Init(self, _f): @@ -772,9 +772,9 @@ def __init__(self, rho_inf=1.0): r"""__init__(GeneralizedAlpha2Solver self, double rho_inf=1.0) -> GeneralizedAlpha2Solver""" _ode.GeneralizedAlpha2Solver_swiginit(self, _ode.new_GeneralizedAlpha2Solver(rho_inf)) - def PrintProperties(self, *args): + def PrintProperties(self, *args, **kwargs): r"""PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)""" - return _ode.GeneralizedAlpha2Solver_PrintProperties(self, *args) + return _ode.GeneralizedAlpha2Solver_PrintProperties(self, *args, **kwargs) PrintProperties = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_PrintProperties) def Init(self, _f): diff --git a/mfem/_par/ode_wrap.cxx b/mfem/_par/ode_wrap.cxx index b79f50f8..3bcf0acb 100644 --- a/mfem/_par/ode_wrap.cxx +++ b/mfem/_par/ode_wrap.cxx @@ -3290,7 +3290,7 @@ SWIG_AsVal_double (PyObject *obj, double *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ODESolver *arg1 = (mfem::ODESolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -3298,15 +3298,19 @@ SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ODESolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ODESolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ODESolver_Init" "', argument " "1"" of type '" "mfem::ODESolver *""'"); } arg1 = reinterpret_cast< mfem::ODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ODESolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -3334,7 +3338,7 @@ SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ODESolver *arg1 = (mfem::ODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3346,15 +3350,21 @@ SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ODESolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ODESolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ODESolver_Step" "', argument " "1"" of type '" "mfem::ODESolver *""'"); } arg1 = reinterpret_cast< mfem::ODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3363,11 +3373,11 @@ SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -3396,7 +3406,7 @@ SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ODESolver *arg1 = (mfem::ODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3411,15 +3421,22 @@ SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec double dtemp4 ; double val5 ; int ecode5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", (char *)"tf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ODESolver_Run", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ODESolver_Run", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ODESolver_Run" "', argument " "1"" of type '" "mfem::ODESolver *""'"); } arg1 = reinterpret_cast< mfem::ODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3428,14 +3445,14 @@ SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_double(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ODESolver_Run" "', argument " "5"" of type '" "double""'"); } @@ -3507,7 +3524,7 @@ SWIGINTERN PyObject *ODESolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ForwardEulerSolver *arg1 = (mfem::ForwardEulerSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -3515,15 +3532,19 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ForwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ForwardEulerSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::ForwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::ForwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -3551,7 +3572,7 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ForwardEulerSolver *arg1 = (mfem::ForwardEulerSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3563,15 +3584,21 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ForwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ForwardEulerSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::ForwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::ForwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3580,11 +3607,11 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -3683,47 +3710,28 @@ SWIGINTERN PyObject *ForwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RK2Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RK2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) (double)2./3. ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_a", NULL + }; mfem::RK2Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RK2Solver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::RK2Solver *)new mfem::RK2Solver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_RK2Solver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RK2Solver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RK2Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RK2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::RK2Solver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::RK2Solver *)new mfem::RK2Solver(); + result = (mfem::RK2Solver *)new mfem::RK2Solver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3741,38 +3749,7 @@ SWIGINTERN PyObject *_wrap_new_RK2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_RK2Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RK2Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_RK2Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_RK2Solver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RK2Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RK2Solver::RK2Solver(double const)\n" - " mfem::RK2Solver::RK2Solver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK2Solver *arg1 = (mfem::RK2Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -3780,15 +3757,19 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK2Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RK2Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK2Solver_Init" "', argument " "1"" of type '" "mfem::RK2Solver *""'"); } arg1 = reinterpret_cast< mfem::RK2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK2Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -3816,7 +3797,7 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK2Solver *arg1 = (mfem::RK2Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3828,15 +3809,21 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK2Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RK2Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK2Solver_Step" "', argument " "1"" of type '" "mfem::RK2Solver *""'"); } arg1 = reinterpret_cast< mfem::RK2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3845,11 +3832,11 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -3923,7 +3910,7 @@ SWIGINTERN PyObject *RK2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK3SSPSolver *arg1 = (mfem::RK3SSPSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -3931,15 +3918,19 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK3SSPSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RK3SSPSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK3SSPSolver_Init" "', argument " "1"" of type '" "mfem::RK3SSPSolver *""'"); } arg1 = reinterpret_cast< mfem::RK3SSPSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK3SSPSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -3967,7 +3958,7 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK3SSPSolver *arg1 = (mfem::RK3SSPSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3979,15 +3970,21 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK3SSPSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RK3SSPSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK3SSPSolver_Step" "', argument " "1"" of type '" "mfem::RK3SSPSolver *""'"); } arg1 = reinterpret_cast< mfem::RK3SSPSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK3SSPSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3996,11 +3993,11 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyO } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -4099,7 +4096,7 @@ SWIGINTERN PyObject *RK3SSPSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK4Solver *arg1 = (mfem::RK4Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -4107,15 +4104,19 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK4Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RK4Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK4Solver_Init" "', argument " "1"" of type '" "mfem::RK4Solver *""'"); } arg1 = reinterpret_cast< mfem::RK4Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK4Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -4143,7 +4144,7 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK4Solver *arg1 = (mfem::RK4Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4155,15 +4156,21 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK4Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RK4Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK4Solver_Step" "', argument " "1"" of type '" "mfem::RK4Solver *""'"); } arg1 = reinterpret_cast< mfem::RK4Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK4Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4172,11 +4179,11 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -4275,7 +4282,7 @@ SWIGINTERN PyObject *RK4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; @@ -4287,27 +4294,33 @@ SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"_s", (char *)"_a", (char *)"_b", (char *)"_c", NULL + }; mfem::ExplicitRKSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ExplicitRKSolver", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_ExplicitRKSolver", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExplicitRKSolver" "', argument " "2"" of type '" "double const *""'"); } arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ExplicitRKSolver" "', argument " "3"" of type '" "double const *""'"); } arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ExplicitRKSolver" "', argument " "4"" of type '" "double const *""'"); } @@ -4332,7 +4345,7 @@ SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ExplicitRKSolver *arg1 = (mfem::ExplicitRKSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -4340,15 +4353,19 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ExplicitRKSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ExplicitRKSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExplicitRKSolver_Init" "', argument " "1"" of type '" "mfem::ExplicitRKSolver *""'"); } arg1 = reinterpret_cast< mfem::ExplicitRKSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExplicitRKSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -4376,7 +4393,7 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ExplicitRKSolver *arg1 = (mfem::ExplicitRKSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4388,15 +4405,21 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ExplicitRKSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ExplicitRKSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExplicitRKSolver_Step" "', argument " "1"" of type '" "mfem::ExplicitRKSolver *""'"); } arg1 = reinterpret_cast< mfem::ExplicitRKSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExplicitRKSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4405,11 +4428,11 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -4623,23 +4646,27 @@ SWIGINTERN PyObject *RK8Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_s", (char *)"_a", NULL + }; mfem::AdamsBashforthSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_AdamsBashforthSolver", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_AdamsBashforthSolver", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsBashforthSolver" "', argument " "2"" of type '" "double const *""'"); } @@ -4664,7 +4691,7 @@ SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -4672,15 +4699,19 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:AdamsBashforthSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Init" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -4708,7 +4739,7 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4720,15 +4751,21 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AdamsBashforthSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Step" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4737,11 +4774,11 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(se } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -5165,23 +5202,27 @@ SWIGINTERN PyObject *AB5Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_s", (char *)"_a", NULL + }; mfem::AdamsMoultonSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_AdamsMoultonSolver", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_AdamsMoultonSolver", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsMoultonSolver" "', argument " "2"" of type '" "double const *""'"); } @@ -5206,7 +5247,7 @@ SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -5214,15 +5255,19 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:AdamsMoultonSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Init" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -5250,7 +5295,7 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5262,15 +5307,21 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AdamsMoultonSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Step" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -5279,11 +5330,11 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -5707,7 +5758,7 @@ SWIGINTERN PyObject *AM4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -5715,15 +5766,19 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BackwardEulerSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -5751,7 +5806,7 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5763,15 +5818,21 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BackwardEulerSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -5780,11 +5841,11 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -5883,7 +5944,7 @@ SWIGINTERN PyObject *BackwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self) return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -5891,15 +5952,19 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ImplicitMidpointSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Init" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -5927,7 +5992,7 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5939,15 +6004,21 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ImplicitMidpointSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Step" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -5956,11 +6027,11 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM( } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6059,46 +6130,27 @@ SWIGINTERN PyObject *ImplicitMidpointSolver_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 1 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"gamma_opt", NULL + }; mfem::SDIRK23Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_SDIRK23Solver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::SDIRK23Solver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(); + result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6116,42 +6168,7 @@ SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SDIRK23Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SDIRK23Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SDIRK23Solver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SDIRK23Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SDIRK23Solver::SDIRK23Solver(int)\n" - " mfem::SDIRK23Solver::SDIRK23Solver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6159,15 +6176,19 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SDIRK23Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6195,7 +6216,7 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6207,15 +6228,21 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SDIRK23Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6224,11 +6251,11 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6302,7 +6329,7 @@ SWIGINTERN PyObject *SDIRK23Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6310,15 +6337,19 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SDIRK34Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6346,7 +6377,7 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6358,15 +6389,21 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SDIRK34Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6375,11 +6412,11 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6478,7 +6515,7 @@ SWIGINTERN PyObject *SDIRK34Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6486,15 +6523,19 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SDIRK33Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6522,7 +6563,7 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6534,15 +6575,21 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SDIRK33Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6551,11 +6598,11 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6654,47 +6701,28 @@ SWIGINTERN PyObject *SDIRK33Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"rho", NULL + }; mfem::GeneralizedAlphaSolver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_GeneralizedAlphaSolver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(); + result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6712,38 +6740,7 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver(double)\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6751,15 +6748,19 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeneralizedAlphaSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6787,7 +6788,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6799,15 +6800,21 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GeneralizedAlphaSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6816,11 +6823,11 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6894,7 +6901,7 @@ SWIGINTERN PyObject *GeneralizedAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -6905,15 +6912,20 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"P", (char *)"F", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Init", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SIASolver_Init", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Init" "', argument " "1"" of type '" "mfem::SIASolver *""'"); } arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); } @@ -6921,7 +6933,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6949,7 +6961,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6964,15 +6976,22 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIASolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Step" "', argument " "1"" of type '" "mfem::SIASolver *""'"); } arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6980,7 +6999,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6989,11 +7008,11 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7022,7 +7041,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7040,15 +7059,23 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec double dtemp5 ; double val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", (char *)"tf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Run", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:SIASolver_Run", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Run" "', argument " "1"" of type '" "mfem::SIASolver *""'"); } arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7056,7 +7083,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7065,14 +7092,14 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_double(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SIASolver_Run" "', argument " "6"" of type '" "double""'"); } @@ -7169,7 +7196,7 @@ SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7184,15 +7211,22 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIA1Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIA1Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA1Solver_Step" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); } arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7200,7 +7234,7 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7209,11 +7243,11 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7312,7 +7346,7 @@ SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7327,15 +7361,22 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIA2Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIA2Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA2Solver_Step" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); } arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7343,7 +7384,7 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7352,11 +7393,11 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7430,19 +7471,21 @@ SWIGINTERN PyObject *SIA2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"order", NULL + }; mfem::SIAVSolver *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_SIAVSolver", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -7464,7 +7507,7 @@ SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7479,15 +7522,22 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIAVSolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIAVSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIAVSolver_Step" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); } arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7495,7 +7545,7 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7504,11 +7554,11 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7582,7 +7632,7 @@ SWIGINTERN PyObject *SIAVSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; @@ -7590,15 +7640,19 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SecondOrderODESolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Init" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); } arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); } @@ -7626,7 +7680,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7641,15 +7695,22 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SecondOrderODESolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Step" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); } arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7657,7 +7718,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7666,11 +7727,11 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7699,7 +7760,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7717,15 +7778,23 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(sel double dtemp5 ; double val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", (char *)"tf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Run", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:SecondOrderODESolver_Run", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Run" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); } arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7733,7 +7802,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7742,14 +7811,14 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(sel } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_double(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SecondOrderODESolver_Run" "', argument " "6"" of type '" "double""'"); } @@ -7821,88 +7890,39 @@ SWIGINTERN PyObject *SecondOrderODESolver_swigregister(PyObject *SWIGUNUSEDPARM( return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_NewmarkSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; - double arg2 ; + double arg1 = (double) 0.25 ; + double arg2 = (double) 0.5 ; double val1 ; int ecode1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"beta_", (char *)"gamma_", NULL + }; mfem::NewmarkSolver *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewmarkSolver" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_NewmarkSolver", kwnames, &obj0, &obj1)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - double arg1 ; - double val1 ; - int ecode1 = 0 ; - mfem::NewmarkSolver *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewmarkSolver" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::NewmarkSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(); + result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7920,82 +7940,42 @@ SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_2(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_new_NewmarkSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_NewmarkSolver", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_NewmarkSolver__SWIG_2(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_NewmarkSolver__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_NewmarkSolver__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NewmarkSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NewmarkSolver::NewmarkSolver(double,double)\n" - " mfem::NewmarkSolver::NewmarkSolver(double)\n" - " mfem::NewmarkSolver::NewmarkSolver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:NewmarkSolver_PrintProperties", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); } arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (obj1) { + { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -8028,86 +8008,7 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_0(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); - } - arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - { - try { - (arg1)->PrintProperties(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "NewmarkSolver_PrintProperties", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NewmarkSolver_PrintProperties__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_NewmarkSolver_PrintProperties__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NewmarkSolver_PrintProperties'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NewmarkSolver::PrintProperties(std::ostream &)\n" - " mfem::NewmarkSolver::PrintProperties()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; @@ -8115,15 +8016,19 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewmarkSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Init" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); } arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); } @@ -8151,7 +8056,7 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8166,15 +8071,22 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NewmarkSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Step" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); } arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8182,7 +8094,7 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewmarkSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8191,11 +8103,11 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -8479,19 +8391,25 @@ SWIGINTERN PyObject *FoxGoodwinSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"rho_inf", NULL + }; mfem::GeneralizedAlpha2Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_GeneralizedAlpha2Solver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + } { try { result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(arg1); @@ -8512,90 +8430,42 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::GeneralizedAlpha2Solver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlpha2Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GeneralizedAlpha2Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GeneralizedAlpha2Solver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlpha2Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver(double)\n" - " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:GeneralizedAlpha2Solver_PrintProperties", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (obj1) { + { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -8628,86 +8498,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); - } - arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - { - try { - (arg1)->PrintProperties(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_PrintProperties", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GeneralizedAlpha2Solver_PrintProperties'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlpha2Solver::PrintProperties(std::ostream &)\n" - " mfem::GeneralizedAlpha2Solver::PrintProperties()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; @@ -8715,15 +8506,19 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeneralizedAlpha2Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); } @@ -8751,7 +8546,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8766,15 +8561,22 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:GeneralizedAlpha2Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8782,7 +8584,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8791,11 +8593,11 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -8939,47 +8741,28 @@ SWIGINTERN PyObject *AverageAccelerationSolver_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"alpha", NULL + }; mfem::HHTAlphaSolver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HHTAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_HHTAlphaSolver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HHTAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::HHTAlphaSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(); + result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8997,37 +8780,6 @@ SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_HHTAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_HHTAlphaSolver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_HHTAlphaSolver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HHTAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HHTAlphaSolver::HHTAlphaSolver(double)\n" - " mfem::HHTAlphaSolver::HHTAlphaSolver()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_HHTAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HHTAlphaSolver *arg1 = (mfem::HHTAlphaSolver *) 0 ; @@ -9073,47 +8825,28 @@ SWIGINTERN PyObject *HHTAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"rho_inf", NULL + }; mfem::WBZAlphaSolver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WBZAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_WBZAlphaSolver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WBZAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::WBZAlphaSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(); + result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9131,37 +8864,6 @@ SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_WBZAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_WBZAlphaSolver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_WBZAlphaSolver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WBZAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::WBZAlphaSolver::WBZAlphaSolver(double)\n" - " mfem::WBZAlphaSolver::WBZAlphaSolver()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_WBZAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::WBZAlphaSolver *arg1 = (mfem::WBZAlphaSolver *) 0 ; @@ -9210,38 +8912,38 @@ SWIGINTERN PyObject *WBZAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "ODESolver_Init(ODESolver self, TimeDependentOperator f)"}, - { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "ODESolver_Step(ODESolver self, Vector x, double & t, double & dt)"}, - { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "ODESolver_Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, + { "ODESolver_Init", (PyCFunction)(void(*)(void))_wrap_ODESolver_Init, METH_VARARGS|METH_KEYWORDS, "ODESolver_Init(ODESolver self, TimeDependentOperator f)"}, + { "ODESolver_Step", (PyCFunction)(void(*)(void))_wrap_ODESolver_Step, METH_VARARGS|METH_KEYWORDS, "ODESolver_Step(ODESolver self, Vector x, double & t, double & dt)"}, + { "ODESolver_Run", (PyCFunction)(void(*)(void))_wrap_ODESolver_Run, METH_VARARGS|METH_KEYWORDS, "ODESolver_Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, { "delete_ODESolver", _wrap_delete_ODESolver, METH_O, "delete_ODESolver(ODESolver self)"}, { "ODESolver_swigregister", ODESolver_swigregister, METH_O, NULL}, - { "ForwardEulerSolver_Init", _wrap_ForwardEulerSolver_Init, METH_VARARGS, "ForwardEulerSolver_Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, - { "ForwardEulerSolver_Step", _wrap_ForwardEulerSolver_Step, METH_VARARGS, "ForwardEulerSolver_Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "ForwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "ForwardEulerSolver_Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, + { "ForwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "ForwardEulerSolver_Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_ForwardEulerSolver", _wrap_new_ForwardEulerSolver, METH_NOARGS, "new_ForwardEulerSolver() -> ForwardEulerSolver"}, { "delete_ForwardEulerSolver", _wrap_delete_ForwardEulerSolver, METH_O, "delete_ForwardEulerSolver(ForwardEulerSolver self)"}, { "ForwardEulerSolver_swigregister", ForwardEulerSolver_swigregister, METH_O, NULL}, { "ForwardEulerSolver_swiginit", ForwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "new_RK2Solver", _wrap_new_RK2Solver, METH_VARARGS, "RK2Solver(double const _a=2./3.)"}, - { "RK2Solver_Init", _wrap_RK2Solver_Init, METH_VARARGS, "RK2Solver_Init(RK2Solver self, TimeDependentOperator _f)"}, - { "RK2Solver_Step", _wrap_RK2Solver_Step, METH_VARARGS, "RK2Solver_Step(RK2Solver self, Vector x, double & t, double & dt)"}, + { "new_RK2Solver", (PyCFunction)(void(*)(void))_wrap_new_RK2Solver, METH_VARARGS|METH_KEYWORDS, "new_RK2Solver(double const _a=2./3.) -> RK2Solver"}, + { "RK2Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Init, METH_VARARGS|METH_KEYWORDS, "RK2Solver_Init(RK2Solver self, TimeDependentOperator _f)"}, + { "RK2Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Step, METH_VARARGS|METH_KEYWORDS, "RK2Solver_Step(RK2Solver self, Vector x, double & t, double & dt)"}, { "delete_RK2Solver", _wrap_delete_RK2Solver, METH_O, "delete_RK2Solver(RK2Solver self)"}, { "RK2Solver_swigregister", RK2Solver_swigregister, METH_O, NULL}, { "RK2Solver_swiginit", RK2Solver_swiginit, METH_VARARGS, NULL}, - { "RK3SSPSolver_Init", _wrap_RK3SSPSolver_Init, METH_VARARGS, "RK3SSPSolver_Init(RK3SSPSolver self, TimeDependentOperator _f)"}, - { "RK3SSPSolver_Step", _wrap_RK3SSPSolver_Step, METH_VARARGS, "RK3SSPSolver_Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, + { "RK3SSPSolver_Init", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Init, METH_VARARGS|METH_KEYWORDS, "RK3SSPSolver_Init(RK3SSPSolver self, TimeDependentOperator _f)"}, + { "RK3SSPSolver_Step", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Step, METH_VARARGS|METH_KEYWORDS, "RK3SSPSolver_Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, { "new_RK3SSPSolver", _wrap_new_RK3SSPSolver, METH_NOARGS, "new_RK3SSPSolver() -> RK3SSPSolver"}, { "delete_RK3SSPSolver", _wrap_delete_RK3SSPSolver, METH_O, "delete_RK3SSPSolver(RK3SSPSolver self)"}, { "RK3SSPSolver_swigregister", RK3SSPSolver_swigregister, METH_O, NULL}, { "RK3SSPSolver_swiginit", RK3SSPSolver_swiginit, METH_VARARGS, NULL}, - { "RK4Solver_Init", _wrap_RK4Solver_Init, METH_VARARGS, "RK4Solver_Init(RK4Solver self, TimeDependentOperator _f)"}, - { "RK4Solver_Step", _wrap_RK4Solver_Step, METH_VARARGS, "RK4Solver_Step(RK4Solver self, Vector x, double & t, double & dt)"}, + { "RK4Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Init, METH_VARARGS|METH_KEYWORDS, "RK4Solver_Init(RK4Solver self, TimeDependentOperator _f)"}, + { "RK4Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Step, METH_VARARGS|METH_KEYWORDS, "RK4Solver_Step(RK4Solver self, Vector x, double & t, double & dt)"}, { "new_RK4Solver", _wrap_new_RK4Solver, METH_NOARGS, "new_RK4Solver() -> RK4Solver"}, { "delete_RK4Solver", _wrap_delete_RK4Solver, METH_O, "delete_RK4Solver(RK4Solver self)"}, { "RK4Solver_swigregister", RK4Solver_swigregister, METH_O, NULL}, { "RK4Solver_swiginit", RK4Solver_swiginit, METH_VARARGS, NULL}, - { "new_ExplicitRKSolver", _wrap_new_ExplicitRKSolver, METH_VARARGS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, - { "ExplicitRKSolver_Init", _wrap_ExplicitRKSolver_Init, METH_VARARGS, "ExplicitRKSolver_Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, - { "ExplicitRKSolver_Step", _wrap_ExplicitRKSolver_Step, METH_VARARGS, "ExplicitRKSolver_Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, + { "new_ExplicitRKSolver", (PyCFunction)(void(*)(void))_wrap_new_ExplicitRKSolver, METH_VARARGS|METH_KEYWORDS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, + { "ExplicitRKSolver_Init", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Init, METH_VARARGS|METH_KEYWORDS, "ExplicitRKSolver_Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, + { "ExplicitRKSolver_Step", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Step, METH_VARARGS|METH_KEYWORDS, "ExplicitRKSolver_Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, { "delete_ExplicitRKSolver", _wrap_delete_ExplicitRKSolver, METH_O, "delete_ExplicitRKSolver(ExplicitRKSolver self)"}, { "ExplicitRKSolver_swigregister", ExplicitRKSolver_swigregister, METH_O, NULL}, { "ExplicitRKSolver_swiginit", ExplicitRKSolver_swiginit, METH_VARARGS, NULL}, @@ -9253,9 +8955,9 @@ static PyMethodDef SwigMethods[] = { { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, - { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "AdamsBashforthSolver_Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, - { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "AdamsBashforthSolver_Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsBashforthSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsBashforthSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Init, METH_VARARGS|METH_KEYWORDS, "AdamsBashforthSolver_Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Step, METH_VARARGS|METH_KEYWORDS, "AdamsBashforthSolver_Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, @@ -9279,9 +8981,9 @@ static PyMethodDef SwigMethods[] = { { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, - { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "AdamsMoultonSolver_Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, - { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "AdamsMoultonSolver_Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsMoultonSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsMoultonSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Init, METH_VARARGS|METH_KEYWORDS, "AdamsMoultonSolver_Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Step, METH_VARARGS|METH_KEYWORDS, "AdamsMoultonSolver_Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, @@ -9305,71 +9007,71 @@ static PyMethodDef SwigMethods[] = { { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, - { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "BackwardEulerSolver_Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, - { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "BackwardEulerSolver_Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "BackwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "BackwardEulerSolver_Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, + { "BackwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "BackwardEulerSolver_Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, { "delete_BackwardEulerSolver", _wrap_delete_BackwardEulerSolver, METH_O, "delete_BackwardEulerSolver(BackwardEulerSolver self)"}, { "BackwardEulerSolver_swigregister", BackwardEulerSolver_swigregister, METH_O, NULL}, { "BackwardEulerSolver_swiginit", BackwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "ImplicitMidpointSolver_Init", _wrap_ImplicitMidpointSolver_Init, METH_VARARGS, "ImplicitMidpointSolver_Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, - { "ImplicitMidpointSolver_Step", _wrap_ImplicitMidpointSolver_Step, METH_VARARGS, "ImplicitMidpointSolver_Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, + { "ImplicitMidpointSolver_Init", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Init, METH_VARARGS|METH_KEYWORDS, "ImplicitMidpointSolver_Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, + { "ImplicitMidpointSolver_Step", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Step, METH_VARARGS|METH_KEYWORDS, "ImplicitMidpointSolver_Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, { "new_ImplicitMidpointSolver", _wrap_new_ImplicitMidpointSolver, METH_NOARGS, "new_ImplicitMidpointSolver() -> ImplicitMidpointSolver"}, { "delete_ImplicitMidpointSolver", _wrap_delete_ImplicitMidpointSolver, METH_O, "delete_ImplicitMidpointSolver(ImplicitMidpointSolver self)"}, { "ImplicitMidpointSolver_swigregister", ImplicitMidpointSolver_swigregister, METH_O, NULL}, { "ImplicitMidpointSolver_swiginit", ImplicitMidpointSolver_swiginit, METH_VARARGS, NULL}, - { "new_SDIRK23Solver", _wrap_new_SDIRK23Solver, METH_VARARGS, "SDIRK23Solver(int gamma_opt=1)"}, - { "SDIRK23Solver_Init", _wrap_SDIRK23Solver_Init, METH_VARARGS, "SDIRK23Solver_Init(SDIRK23Solver self, TimeDependentOperator _f)"}, - { "SDIRK23Solver_Step", _wrap_SDIRK23Solver_Step, METH_VARARGS, "SDIRK23Solver_Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK23Solver", (PyCFunction)(void(*)(void))_wrap_new_SDIRK23Solver, METH_VARARGS|METH_KEYWORDS, "new_SDIRK23Solver(int gamma_opt=1) -> SDIRK23Solver"}, + { "SDIRK23Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Init, METH_VARARGS|METH_KEYWORDS, "SDIRK23Solver_Init(SDIRK23Solver self, TimeDependentOperator _f)"}, + { "SDIRK23Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Step, METH_VARARGS|METH_KEYWORDS, "SDIRK23Solver_Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, { "delete_SDIRK23Solver", _wrap_delete_SDIRK23Solver, METH_O, "delete_SDIRK23Solver(SDIRK23Solver self)"}, { "SDIRK23Solver_swigregister", SDIRK23Solver_swigregister, METH_O, NULL}, { "SDIRK23Solver_swiginit", SDIRK23Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK34Solver_Init", _wrap_SDIRK34Solver_Init, METH_VARARGS, "SDIRK34Solver_Init(SDIRK34Solver self, TimeDependentOperator _f)"}, - { "SDIRK34Solver_Step", _wrap_SDIRK34Solver_Step, METH_VARARGS, "SDIRK34Solver_Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK34Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Init, METH_VARARGS|METH_KEYWORDS, "SDIRK34Solver_Init(SDIRK34Solver self, TimeDependentOperator _f)"}, + { "SDIRK34Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Step, METH_VARARGS|METH_KEYWORDS, "SDIRK34Solver_Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK34Solver", _wrap_new_SDIRK34Solver, METH_NOARGS, "new_SDIRK34Solver() -> SDIRK34Solver"}, { "delete_SDIRK34Solver", _wrap_delete_SDIRK34Solver, METH_O, "delete_SDIRK34Solver(SDIRK34Solver self)"}, { "SDIRK34Solver_swigregister", SDIRK34Solver_swigregister, METH_O, NULL}, { "SDIRK34Solver_swiginit", SDIRK34Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK33Solver_Init", _wrap_SDIRK33Solver_Init, METH_VARARGS, "SDIRK33Solver_Init(SDIRK33Solver self, TimeDependentOperator _f)"}, - { "SDIRK33Solver_Step", _wrap_SDIRK33Solver_Step, METH_VARARGS, "SDIRK33Solver_Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK33Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Init, METH_VARARGS|METH_KEYWORDS, "SDIRK33Solver_Init(SDIRK33Solver self, TimeDependentOperator _f)"}, + { "SDIRK33Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Step, METH_VARARGS|METH_KEYWORDS, "SDIRK33Solver_Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK33Solver", _wrap_new_SDIRK33Solver, METH_NOARGS, "new_SDIRK33Solver() -> SDIRK33Solver"}, { "delete_SDIRK33Solver", _wrap_delete_SDIRK33Solver, METH_O, "delete_SDIRK33Solver(SDIRK33Solver self)"}, { "SDIRK33Solver_swigregister", SDIRK33Solver_swigregister, METH_O, NULL}, { "SDIRK33Solver_swiginit", SDIRK33Solver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlphaSolver", _wrap_new_GeneralizedAlphaSolver, METH_VARARGS, "GeneralizedAlphaSolver(double rho=1.0)"}, - { "GeneralizedAlphaSolver_Init", _wrap_GeneralizedAlphaSolver_Init, METH_VARARGS, "GeneralizedAlphaSolver_Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, - { "GeneralizedAlphaSolver_Step", _wrap_GeneralizedAlphaSolver_Step, METH_VARARGS, "GeneralizedAlphaSolver_Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, + { "new_GeneralizedAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlphaSolver(double rho=1.0) -> GeneralizedAlphaSolver"}, + { "GeneralizedAlphaSolver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Init, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlphaSolver_Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, + { "GeneralizedAlphaSolver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Step, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlphaSolver_Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, { "delete_GeneralizedAlphaSolver", _wrap_delete_GeneralizedAlphaSolver, METH_O, "delete_GeneralizedAlphaSolver(GeneralizedAlphaSolver self)"}, { "GeneralizedAlphaSolver_swigregister", GeneralizedAlphaSolver_swigregister, METH_O, NULL}, { "GeneralizedAlphaSolver_swiginit", GeneralizedAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "SIASolver_Init", _wrap_SIASolver_Init, METH_VARARGS, "SIASolver_Init(SIASolver self, Operator P, TimeDependentOperator F)"}, - { "SIASolver_Step", _wrap_SIASolver_Step, METH_VARARGS, "SIASolver_Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, - { "SIASolver_Run", _wrap_SIASolver_Run, METH_VARARGS, "SIASolver_Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, + { "SIASolver_Init", (PyCFunction)(void(*)(void))_wrap_SIASolver_Init, METH_VARARGS|METH_KEYWORDS, "SIASolver_Init(SIASolver self, Operator P, TimeDependentOperator F)"}, + { "SIASolver_Step", (PyCFunction)(void(*)(void))_wrap_SIASolver_Step, METH_VARARGS|METH_KEYWORDS, "SIASolver_Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIASolver_Run", (PyCFunction)(void(*)(void))_wrap_SIASolver_Run, METH_VARARGS|METH_KEYWORDS, "SIASolver_Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, { "delete_SIASolver", _wrap_delete_SIASolver, METH_O, "delete_SIASolver(SIASolver self)"}, { "SIASolver_swigregister", SIASolver_swigregister, METH_O, NULL}, { "new_SIA1Solver", _wrap_new_SIA1Solver, METH_NOARGS, "new_SIA1Solver() -> SIA1Solver"}, - { "SIA1Solver_Step", _wrap_SIA1Solver_Step, METH_VARARGS, "SIA1Solver_Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA1Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA1Solver_Step, METH_VARARGS|METH_KEYWORDS, "SIA1Solver_Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA1Solver", _wrap_delete_SIA1Solver, METH_O, "delete_SIA1Solver(SIA1Solver self)"}, { "SIA1Solver_swigregister", SIA1Solver_swigregister, METH_O, NULL}, { "SIA1Solver_swiginit", SIA1Solver_swiginit, METH_VARARGS, NULL}, { "new_SIA2Solver", _wrap_new_SIA2Solver, METH_NOARGS, "new_SIA2Solver() -> SIA2Solver"}, - { "SIA2Solver_Step", _wrap_SIA2Solver_Step, METH_VARARGS, "SIA2Solver_Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA2Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA2Solver_Step, METH_VARARGS|METH_KEYWORDS, "SIA2Solver_Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA2Solver", _wrap_delete_SIA2Solver, METH_O, "delete_SIA2Solver(SIA2Solver self)"}, { "SIA2Solver_swigregister", SIA2Solver_swigregister, METH_O, NULL}, { "SIA2Solver_swiginit", SIA2Solver_swiginit, METH_VARARGS, NULL}, - { "new_SIAVSolver", _wrap_new_SIAVSolver, METH_O, "new_SIAVSolver(int order) -> SIAVSolver"}, - { "SIAVSolver_Step", _wrap_SIAVSolver_Step, METH_VARARGS, "SIAVSolver_Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, + { "new_SIAVSolver", (PyCFunction)(void(*)(void))_wrap_new_SIAVSolver, METH_VARARGS|METH_KEYWORDS, "new_SIAVSolver(int order) -> SIAVSolver"}, + { "SIAVSolver_Step", (PyCFunction)(void(*)(void))_wrap_SIAVSolver_Step, METH_VARARGS|METH_KEYWORDS, "SIAVSolver_Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, - { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "SecondOrderODESolver_Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, - { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "SecondOrderODESolver_Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, - { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "SecondOrderODESolver_Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "SecondOrderODESolver_Init", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Init, METH_VARARGS|METH_KEYWORDS, "SecondOrderODESolver_Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Step, METH_VARARGS|METH_KEYWORDS, "SecondOrderODESolver_Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Run, METH_VARARGS|METH_KEYWORDS, "SecondOrderODESolver_Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, - { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, - { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "NewmarkSolver_PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, - { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "NewmarkSolver_Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, - { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "NewmarkSolver_Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_NewmarkSolver", (PyCFunction)(void(*)(void))_wrap_new_NewmarkSolver, METH_VARARGS|METH_KEYWORDS, "new_NewmarkSolver(double beta_=0.25, double gamma_=0.5) -> NewmarkSolver"}, + { "NewmarkSolver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "NewmarkSolver_PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Init, METH_VARARGS|METH_KEYWORDS, "NewmarkSolver_Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Step, METH_VARARGS|METH_KEYWORDS, "NewmarkSolver_Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, @@ -9385,10 +9087,10 @@ static PyMethodDef SwigMethods[] = { { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, - { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "GeneralizedAlpha2Solver_PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, - { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "GeneralizedAlpha2Solver_Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, - { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "GeneralizedAlpha2Solver_Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_GeneralizedAlpha2Solver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlpha2Solver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlpha2Solver(double rho_inf=1.0) -> GeneralizedAlpha2Solver"}, + { "GeneralizedAlpha2Solver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlpha2Solver_PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlpha2Solver_Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlpha2Solver_Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, @@ -9396,11 +9098,11 @@ static PyMethodDef SwigMethods[] = { { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, - { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "new_HHTAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_HHTAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_HHTAlphaSolver(double alpha=1.0) -> HHTAlphaSolver"}, { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "new_WBZAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_WBZAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_WBZAlphaSolver(double rho_inf=1.0) -> WBZAlphaSolver"}, { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, @@ -9410,38 +9112,38 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "Init(ODESolver self, TimeDependentOperator f)"}, - { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "Step(ODESolver self, Vector x, double & t, double & dt)"}, - { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, + { "ODESolver_Init", (PyCFunction)(void(*)(void))_wrap_ODESolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ODESolver self, TimeDependentOperator f)"}, + { "ODESolver_Step", (PyCFunction)(void(*)(void))_wrap_ODESolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ODESolver self, Vector x, double & t, double & dt)"}, + { "ODESolver_Run", (PyCFunction)(void(*)(void))_wrap_ODESolver_Run, METH_VARARGS|METH_KEYWORDS, "Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, { "delete_ODESolver", _wrap_delete_ODESolver, METH_O, "delete_ODESolver(ODESolver self)"}, { "ODESolver_swigregister", ODESolver_swigregister, METH_O, NULL}, - { "ForwardEulerSolver_Init", _wrap_ForwardEulerSolver_Init, METH_VARARGS, "Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, - { "ForwardEulerSolver_Step", _wrap_ForwardEulerSolver_Step, METH_VARARGS, "Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "ForwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, + { "ForwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_ForwardEulerSolver", _wrap_new_ForwardEulerSolver, METH_NOARGS, "new_ForwardEulerSolver() -> ForwardEulerSolver"}, { "delete_ForwardEulerSolver", _wrap_delete_ForwardEulerSolver, METH_O, "delete_ForwardEulerSolver(ForwardEulerSolver self)"}, { "ForwardEulerSolver_swigregister", ForwardEulerSolver_swigregister, METH_O, NULL}, { "ForwardEulerSolver_swiginit", ForwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "new_RK2Solver", _wrap_new_RK2Solver, METH_VARARGS, "RK2Solver(double const _a=2./3.)"}, - { "RK2Solver_Init", _wrap_RK2Solver_Init, METH_VARARGS, "Init(RK2Solver self, TimeDependentOperator _f)"}, - { "RK2Solver_Step", _wrap_RK2Solver_Step, METH_VARARGS, "Step(RK2Solver self, Vector x, double & t, double & dt)"}, + { "new_RK2Solver", (PyCFunction)(void(*)(void))_wrap_new_RK2Solver, METH_VARARGS|METH_KEYWORDS, "new_RK2Solver(double const _a=2./3.) -> RK2Solver"}, + { "RK2Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(RK2Solver self, TimeDependentOperator _f)"}, + { "RK2Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(RK2Solver self, Vector x, double & t, double & dt)"}, { "delete_RK2Solver", _wrap_delete_RK2Solver, METH_O, "delete_RK2Solver(RK2Solver self)"}, { "RK2Solver_swigregister", RK2Solver_swigregister, METH_O, NULL}, { "RK2Solver_swiginit", RK2Solver_swiginit, METH_VARARGS, NULL}, - { "RK3SSPSolver_Init", _wrap_RK3SSPSolver_Init, METH_VARARGS, "Init(RK3SSPSolver self, TimeDependentOperator _f)"}, - { "RK3SSPSolver_Step", _wrap_RK3SSPSolver_Step, METH_VARARGS, "Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, + { "RK3SSPSolver_Init", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(RK3SSPSolver self, TimeDependentOperator _f)"}, + { "RK3SSPSolver_Step", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, { "new_RK3SSPSolver", _wrap_new_RK3SSPSolver, METH_NOARGS, "new_RK3SSPSolver() -> RK3SSPSolver"}, { "delete_RK3SSPSolver", _wrap_delete_RK3SSPSolver, METH_O, "delete_RK3SSPSolver(RK3SSPSolver self)"}, { "RK3SSPSolver_swigregister", RK3SSPSolver_swigregister, METH_O, NULL}, { "RK3SSPSolver_swiginit", RK3SSPSolver_swiginit, METH_VARARGS, NULL}, - { "RK4Solver_Init", _wrap_RK4Solver_Init, METH_VARARGS, "Init(RK4Solver self, TimeDependentOperator _f)"}, - { "RK4Solver_Step", _wrap_RK4Solver_Step, METH_VARARGS, "Step(RK4Solver self, Vector x, double & t, double & dt)"}, + { "RK4Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(RK4Solver self, TimeDependentOperator _f)"}, + { "RK4Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(RK4Solver self, Vector x, double & t, double & dt)"}, { "new_RK4Solver", _wrap_new_RK4Solver, METH_NOARGS, "new_RK4Solver() -> RK4Solver"}, { "delete_RK4Solver", _wrap_delete_RK4Solver, METH_O, "delete_RK4Solver(RK4Solver self)"}, { "RK4Solver_swigregister", RK4Solver_swigregister, METH_O, NULL}, { "RK4Solver_swiginit", RK4Solver_swiginit, METH_VARARGS, NULL}, - { "new_ExplicitRKSolver", _wrap_new_ExplicitRKSolver, METH_VARARGS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, - { "ExplicitRKSolver_Init", _wrap_ExplicitRKSolver_Init, METH_VARARGS, "Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, - { "ExplicitRKSolver_Step", _wrap_ExplicitRKSolver_Step, METH_VARARGS, "Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, + { "new_ExplicitRKSolver", (PyCFunction)(void(*)(void))_wrap_new_ExplicitRKSolver, METH_VARARGS|METH_KEYWORDS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, + { "ExplicitRKSolver_Init", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, + { "ExplicitRKSolver_Step", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, { "delete_ExplicitRKSolver", _wrap_delete_ExplicitRKSolver, METH_O, "delete_ExplicitRKSolver(ExplicitRKSolver self)"}, { "ExplicitRKSolver_swigregister", ExplicitRKSolver_swigregister, METH_O, NULL}, { "ExplicitRKSolver_swiginit", ExplicitRKSolver_swiginit, METH_VARARGS, NULL}, @@ -9453,9 +9155,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, - { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, - { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsBashforthSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsBashforthSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, @@ -9479,9 +9181,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, - { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, - { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsMoultonSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsMoultonSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, @@ -9505,71 +9207,71 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, - { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, - { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "BackwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, + { "BackwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, { "delete_BackwardEulerSolver", _wrap_delete_BackwardEulerSolver, METH_O, "delete_BackwardEulerSolver(BackwardEulerSolver self)"}, { "BackwardEulerSolver_swigregister", BackwardEulerSolver_swigregister, METH_O, NULL}, { "BackwardEulerSolver_swiginit", BackwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "ImplicitMidpointSolver_Init", _wrap_ImplicitMidpointSolver_Init, METH_VARARGS, "Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, - { "ImplicitMidpointSolver_Step", _wrap_ImplicitMidpointSolver_Step, METH_VARARGS, "Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, + { "ImplicitMidpointSolver_Init", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, + { "ImplicitMidpointSolver_Step", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, { "new_ImplicitMidpointSolver", _wrap_new_ImplicitMidpointSolver, METH_NOARGS, "new_ImplicitMidpointSolver() -> ImplicitMidpointSolver"}, { "delete_ImplicitMidpointSolver", _wrap_delete_ImplicitMidpointSolver, METH_O, "delete_ImplicitMidpointSolver(ImplicitMidpointSolver self)"}, { "ImplicitMidpointSolver_swigregister", ImplicitMidpointSolver_swigregister, METH_O, NULL}, { "ImplicitMidpointSolver_swiginit", ImplicitMidpointSolver_swiginit, METH_VARARGS, NULL}, - { "new_SDIRK23Solver", _wrap_new_SDIRK23Solver, METH_VARARGS, "SDIRK23Solver(int gamma_opt=1)"}, - { "SDIRK23Solver_Init", _wrap_SDIRK23Solver_Init, METH_VARARGS, "Init(SDIRK23Solver self, TimeDependentOperator _f)"}, - { "SDIRK23Solver_Step", _wrap_SDIRK23Solver_Step, METH_VARARGS, "Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK23Solver", (PyCFunction)(void(*)(void))_wrap_new_SDIRK23Solver, METH_VARARGS|METH_KEYWORDS, "new_SDIRK23Solver(int gamma_opt=1) -> SDIRK23Solver"}, + { "SDIRK23Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SDIRK23Solver self, TimeDependentOperator _f)"}, + { "SDIRK23Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, { "delete_SDIRK23Solver", _wrap_delete_SDIRK23Solver, METH_O, "delete_SDIRK23Solver(SDIRK23Solver self)"}, { "SDIRK23Solver_swigregister", SDIRK23Solver_swigregister, METH_O, NULL}, { "SDIRK23Solver_swiginit", SDIRK23Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK34Solver_Init", _wrap_SDIRK34Solver_Init, METH_VARARGS, "Init(SDIRK34Solver self, TimeDependentOperator _f)"}, - { "SDIRK34Solver_Step", _wrap_SDIRK34Solver_Step, METH_VARARGS, "Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK34Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SDIRK34Solver self, TimeDependentOperator _f)"}, + { "SDIRK34Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK34Solver", _wrap_new_SDIRK34Solver, METH_NOARGS, "new_SDIRK34Solver() -> SDIRK34Solver"}, { "delete_SDIRK34Solver", _wrap_delete_SDIRK34Solver, METH_O, "delete_SDIRK34Solver(SDIRK34Solver self)"}, { "SDIRK34Solver_swigregister", SDIRK34Solver_swigregister, METH_O, NULL}, { "SDIRK34Solver_swiginit", SDIRK34Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK33Solver_Init", _wrap_SDIRK33Solver_Init, METH_VARARGS, "Init(SDIRK33Solver self, TimeDependentOperator _f)"}, - { "SDIRK33Solver_Step", _wrap_SDIRK33Solver_Step, METH_VARARGS, "Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK33Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SDIRK33Solver self, TimeDependentOperator _f)"}, + { "SDIRK33Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK33Solver", _wrap_new_SDIRK33Solver, METH_NOARGS, "new_SDIRK33Solver() -> SDIRK33Solver"}, { "delete_SDIRK33Solver", _wrap_delete_SDIRK33Solver, METH_O, "delete_SDIRK33Solver(SDIRK33Solver self)"}, { "SDIRK33Solver_swigregister", SDIRK33Solver_swigregister, METH_O, NULL}, { "SDIRK33Solver_swiginit", SDIRK33Solver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlphaSolver", _wrap_new_GeneralizedAlphaSolver, METH_VARARGS, "GeneralizedAlphaSolver(double rho=1.0)"}, - { "GeneralizedAlphaSolver_Init", _wrap_GeneralizedAlphaSolver_Init, METH_VARARGS, "Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, - { "GeneralizedAlphaSolver_Step", _wrap_GeneralizedAlphaSolver_Step, METH_VARARGS, "Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, + { "new_GeneralizedAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlphaSolver(double rho=1.0) -> GeneralizedAlphaSolver"}, + { "GeneralizedAlphaSolver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, + { "GeneralizedAlphaSolver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, { "delete_GeneralizedAlphaSolver", _wrap_delete_GeneralizedAlphaSolver, METH_O, "delete_GeneralizedAlphaSolver(GeneralizedAlphaSolver self)"}, { "GeneralizedAlphaSolver_swigregister", GeneralizedAlphaSolver_swigregister, METH_O, NULL}, { "GeneralizedAlphaSolver_swiginit", GeneralizedAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "SIASolver_Init", _wrap_SIASolver_Init, METH_VARARGS, "Init(SIASolver self, Operator P, TimeDependentOperator F)"}, - { "SIASolver_Step", _wrap_SIASolver_Step, METH_VARARGS, "Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, - { "SIASolver_Run", _wrap_SIASolver_Run, METH_VARARGS, "Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, + { "SIASolver_Init", (PyCFunction)(void(*)(void))_wrap_SIASolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SIASolver self, Operator P, TimeDependentOperator F)"}, + { "SIASolver_Step", (PyCFunction)(void(*)(void))_wrap_SIASolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIASolver_Run", (PyCFunction)(void(*)(void))_wrap_SIASolver_Run, METH_VARARGS|METH_KEYWORDS, "Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, { "delete_SIASolver", _wrap_delete_SIASolver, METH_O, "delete_SIASolver(SIASolver self)"}, { "SIASolver_swigregister", SIASolver_swigregister, METH_O, NULL}, { "new_SIA1Solver", _wrap_new_SIA1Solver, METH_NOARGS, "new_SIA1Solver() -> SIA1Solver"}, - { "SIA1Solver_Step", _wrap_SIA1Solver_Step, METH_VARARGS, "Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA1Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA1Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA1Solver", _wrap_delete_SIA1Solver, METH_O, "delete_SIA1Solver(SIA1Solver self)"}, { "SIA1Solver_swigregister", SIA1Solver_swigregister, METH_O, NULL}, { "SIA1Solver_swiginit", SIA1Solver_swiginit, METH_VARARGS, NULL}, { "new_SIA2Solver", _wrap_new_SIA2Solver, METH_NOARGS, "new_SIA2Solver() -> SIA2Solver"}, - { "SIA2Solver_Step", _wrap_SIA2Solver_Step, METH_VARARGS, "Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA2Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA2Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA2Solver", _wrap_delete_SIA2Solver, METH_O, "delete_SIA2Solver(SIA2Solver self)"}, { "SIA2Solver_swigregister", SIA2Solver_swigregister, METH_O, NULL}, { "SIA2Solver_swiginit", SIA2Solver_swiginit, METH_VARARGS, NULL}, - { "new_SIAVSolver", _wrap_new_SIAVSolver, METH_O, "new_SIAVSolver(int order) -> SIAVSolver"}, - { "SIAVSolver_Step", _wrap_SIAVSolver_Step, METH_VARARGS, "Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, + { "new_SIAVSolver", (PyCFunction)(void(*)(void))_wrap_new_SIAVSolver, METH_VARARGS|METH_KEYWORDS, "new_SIAVSolver(int order) -> SIAVSolver"}, + { "SIAVSolver_Step", (PyCFunction)(void(*)(void))_wrap_SIAVSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, - { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, - { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, - { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "SecondOrderODESolver_Init", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Run, METH_VARARGS|METH_KEYWORDS, "Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, - { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, - { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, - { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, - { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_NewmarkSolver", (PyCFunction)(void(*)(void))_wrap_new_NewmarkSolver, METH_VARARGS|METH_KEYWORDS, "new_NewmarkSolver(double beta_=0.25, double gamma_=0.5) -> NewmarkSolver"}, + { "NewmarkSolver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, @@ -9585,10 +9287,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, - { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, - { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, - { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_GeneralizedAlpha2Solver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlpha2Solver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlpha2Solver(double rho_inf=1.0) -> GeneralizedAlpha2Solver"}, + { "GeneralizedAlpha2Solver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, @@ -9596,11 +9298,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, - { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "new_HHTAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_HHTAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_HHTAlphaSolver(double alpha=1.0) -> HHTAlphaSolver"}, { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "new_WBZAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_WBZAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_WBZAlphaSolver(double rho_inf=1.0) -> WBZAlphaSolver"}, { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/operators_wrap.cxx b/mfem/_par/operators_wrap.cxx index f853d94c..01554c3c 100644 --- a/mfem/_par/operators_wrap.cxx +++ b/mfem/_par/operators_wrap.cxx @@ -3502,7 +3502,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Operator_PrintMatlab__SWIG_3(mfem::Operator *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Operator_PrintMatlab__SWIG_1(mfem::Operator *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -6190,7 +6190,7 @@ mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector c #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -6216,30 +6216,40 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Po", (char *)"Ri", (char *)"Pi", (char *)"x", (char *)"b", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_InitTVectors", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:Operator_InitTVectors", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_InitTVectors" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -6247,7 +6257,7 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -6255,7 +6265,7 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -6263,7 +6273,7 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -6294,16 +6304,18 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; + int arg2 = (int) 0 ; mfem::Operator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -6332,39 +6344,6 @@ SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_Operator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::Operator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Operator *)new SwigDirector_Operator(arg1); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Operator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; @@ -6419,17 +6398,13 @@ SWIGINTERN PyObject *_wrap_new_Operator(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_Operator", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_Operator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; _v = (argv[0] != 0); if (_v) { + if (argc <= 1) { + return _wrap_new_Operator__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6465,7 +6440,7 @@ SWIGINTERN PyObject *_wrap_new_Operator(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Operator__SWIG_2(self, argc, argv); + return _wrap_new_Operator__SWIG_1(self, argc, argv); } } } @@ -6475,7 +6450,6 @@ SWIGINTERN PyObject *_wrap_new_Operator(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Operator'.\n" " Possible C/C++ prototypes are:\n" " mfem::Operator::Operator(int)\n" - " mfem::Operator::Operator()\n" " mfem::Operator::Operator(PyObject *,int,int)\n"); return 0; } @@ -6668,7 +6642,7 @@ SWIGINTERN PyObject *_wrap_Operator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6679,17 +6653,22 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Operator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Operator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_Mult" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6697,7 +6676,7 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6706,7 +6685,7 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6735,7 +6714,7 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6746,17 +6725,22 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Operator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Operator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_MultTranspose" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6764,7 +6748,7 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6773,7 +6757,7 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6802,7 +6786,7 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6810,18 +6794,22 @@ SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Operator_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Operator_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_GetGradient" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6830,7 +6818,7 @@ SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -7092,7 +7080,7 @@ SWIGINTERN PyObject *_wrap_Operator_GetOutputRestriction(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7101,7 +7089,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE mfem::Operator **arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7116,14 +7104,25 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", (char *)"copy_interior", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO|O:Operator_FormLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7131,7 +7130,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7139,7 +7138,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7147,7 +7146,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } @@ -7155,7 +7154,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -7163,7 +7162,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -7171,113 +7170,17 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + if (obj7) { + { + if ((PyArray_PyIntAsInt(obj7) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(obj7); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Operator **arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); - } - arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7295,111 +7198,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Operator_FormLinearSystem", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Operator_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Operator_FormLinearSystem__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Operator_FormLinearSystem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7425,15 +7224,25 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:Operator_FormRectangularLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7441,7 +7250,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -7449,7 +7258,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7457,7 +7266,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -7465,7 +7274,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } @@ -7473,7 +7282,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } arg6 = reinterpret_cast< mfem::Operator ** >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -7481,7 +7290,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -7509,7 +7318,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7523,17 +7332,23 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"X", (char *)"b", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Operator_RecoverFEMSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Operator_RecoverFEMSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_RecoverFEMSolution" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7541,7 +7356,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -7549,7 +7364,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_RecoverFEMSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7558,7 +7373,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -7587,7 +7402,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7598,15 +7413,20 @@ SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Operator_FormSystemOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7614,7 +7434,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); } @@ -7642,7 +7462,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7656,15 +7476,21 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Operator_FormRectangularSystemOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7672,7 +7498,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -7680,7 +7506,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); } @@ -7708,7 +7534,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator **arg2 = 0 ; @@ -7716,15 +7542,19 @@ SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Operator_FormDiscreteOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); } @@ -7756,14 +7586,14 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; + int arg3 = (int) 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); @@ -7784,148 +7614,25 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM arg2 = &out2; } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } } { try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2); + ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8022,18 +7729,18 @@ SWIGINTERN PyObject *_wrap_Operator_GetType(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator *""'"); @@ -8044,58 +7751,17 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Operator_PrintMatlab__SWIG_3(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Operator_PrintMatlab__SWIG_3(arg1,(char const *)arg2); + mfem_Operator_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8123,40 +7789,7 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "Operator_PrintMatlab", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Operator_PrintMatlab__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Operator_PrintMatlab__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -8165,36 +7798,9 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Operator_PrintMatlab__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_Operator_PrintMatlab__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8209,7 +7815,7 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -8225,6 +7831,9 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) } } if (_v) { + if (argc <= 2) { + return _wrap_Operator_PrintMatlab__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8234,6 +7843,9 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) } } if (_v) { + if (argc <= 3) { + return _wrap_Operator_PrintMatlab__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8254,24 +7866,23 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Operator_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::Operator::PrintMatlab(std::ostream &,int,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &) const\n" - " mfem::Operator::PrintMatlab(char const *,int)\n" - " mfem::Operator::PrintMatlab(char const *)\n"); + " mfem::Operator::PrintMatlab(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_disown_Operator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_Operator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_Operator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Operator" "', argument " "1"" of type '" "mfem::Operator *""'"); } @@ -8302,158 +7913,46 @@ SWIGINTERN PyObject *Operator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - double arg3 ; - mfem::TimeDependentOperator::Type arg4 ; + int arg2 = (int) 0 ; + double arg3 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg4 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; double val3 ; int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; mfem::TimeDependentOperator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - double arg3 ; - double val3 ; - int ecode3 = 0 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3); - } + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1); + result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4); } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(); + result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4); } } catch (Swig::DirectorException &e) { @@ -8472,20 +7971,20 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_3(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; - double arg4 ; - mfem::TimeDependentOperator::Type arg5 ; + double arg4 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg5 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; double val4 ; int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; mfem::TimeDependentOperator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; arg1 = swig_obj[0]; { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { @@ -8499,123 +7998,27 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_4(PyObject *SWIGUNUSE }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDependentOperator" "', argument " "5"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg5 = static_cast< mfem::TimeDependentOperator::Type >(val5); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4,arg5); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4,arg5); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - double val4 ; - int ecode4 = 0 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4); - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDependentOperator" "', argument " "5"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg5 = static_cast< mfem::TimeDependentOperator::Type >(val5); } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3); + result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4,arg5); } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3); + result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4,arg5); } } catch (Swig::DirectorException &e) { @@ -8642,34 +8045,13 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a if (!(argc = SWIG_Python_UnpackTuple(args, "new_TimeDependentOperator", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (argc <= 1) { + return _wrap_new_TimeDependentOperator__SWIG_0(self, argc, argv); } - if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8679,94 +8061,17 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_6(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_TimeDependentOperator__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_5(self, argc, argv); + if (argc <= 3) { + return _wrap_new_TimeDependentOperator__SWIG_0(self, argc, argv); } - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { { int res = SWIG_AsVal_int(argv[3], NULL); _v = SWIG_CheckState(res); @@ -8778,7 +8083,7 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a } } } - if (argc == 5) { + if ((argc >= 3) && (argc <= 5)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -8800,17 +8105,23 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a } } if (_v) { + if (argc <= 3) { + return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 4) { + return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_4(self, argc, argv); + return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); } } } @@ -8822,12 +8133,7 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TimeDependentOperator'.\n" " Possible C/C++ prototypes are:\n" " mfem::TimeDependentOperator::TimeDependentOperator(int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int,double)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int)\n" - " mfem::TimeDependentOperator::TimeDependentOperator()\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int,int,double)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(PyObject *,int,int)\n"); + " mfem::TimeDependentOperator::TimeDependentOperator(PyObject *,int,int,double,mfem::TimeDependentOperator::Type)\n"); return 0; } @@ -8879,7 +8185,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetTime(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; double arg2 ; @@ -8887,23 +8193,27 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetTime(PyObject *SWIGUNUSEDPAR int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_t", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TimeDependentOperator_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SetTime" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_SetTime" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9072,7 +8382,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetEvalMode(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::TimeDependentOperator::EvalMode arg2 ; @@ -9080,23 +8390,27 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"new_eval_mode", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SetEvalMode", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TimeDependentOperator_SetEvalMode", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "2"" of type '" "mfem::TimeDependentOperator::EvalMode""'"); } arg2 = static_cast< mfem::TimeDependentOperator::EvalMode >(val2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9125,7 +8439,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9136,17 +8450,22 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ExplicitMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TimeDependentOperator_ExplicitMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9154,7 +8473,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9163,7 +8482,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9192,7 +8511,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9206,17 +8525,23 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"k", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ImplicitMult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_ImplicitMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9224,7 +8549,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9232,7 +8557,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9241,7 +8566,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9270,7 +8595,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9281,17 +8606,22 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TimeDependentOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_Mult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9299,7 +8629,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9308,7 +8638,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9337,7 +8667,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; double arg2 ; @@ -9351,22 +8681,28 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dt", (char *)"x", (char *)"k", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ImplicitSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_ImplicitSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9374,7 +8710,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9383,7 +8719,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9412,7 +8748,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9426,18 +8762,24 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S int res3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"k", (char *)"shift", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_GetImplicitGradient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_GetImplicitGradient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9445,7 +8787,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9453,13 +8795,13 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9497,7 +8839,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9505,18 +8847,22 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_GetExplicitGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TimeDependentOperator_GetExplicitGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_GetExplicitGradient" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_GetExplicitGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9525,7 +8871,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9563,7 +8909,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9581,18 +8927,26 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG int res5 = 0 ; double val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"fx", (char *)"jok", (char *)"jcur", (char *)"gamma", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSetup", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:TimeDependentOperator_SUNImplicitSetup", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9600,7 +8954,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9609,23 +8963,23 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "5"" of type '" "int *""'"); } arg5 = reinterpret_cast< int * >(argp5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_double(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "6"" of type '" "double""'"); } arg6 = static_cast< double >(val6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9654,7 +9008,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9668,18 +9022,24 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIG int res3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", (char *)"tol", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_SUNImplicitSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9687,7 +9047,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9695,13 +9055,13 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9777,7 +9137,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSetup(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9791,18 +9151,24 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS int res3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", (char *)"tol", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_SUNMassSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9810,7 +9176,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9818,13 +9184,13 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9853,7 +9219,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9864,18 +9230,23 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"v", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TimeDependentOperator_SUNMassMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9883,7 +9254,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9892,7 +9263,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSE } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9955,16 +9326,18 @@ SWIGINTERN PyObject *_wrap_delete_TimeDependentOperator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_TimeDependentOperator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } @@ -9974,251 +9347,58 @@ SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM if (director) director->swig_disown(); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - mfem::TimeDependentOperator::Type arg3 ; - double val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg3 = static_cast< mfem::TimeDependentOperator::Type >(val3); - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - double val2 ; - int ecode2 = 0 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - double arg3 ; - mfem::TimeDependentOperator::Type arg4 ; - double val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - double arg3 ; - double val3 ; + int arg1 = (int) 0 ; + double arg2 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg3 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; + double val2 ; + int ecode2 = 0 ; + int val3 ; int ecode3 = 0 ; mfem::SecondOrderTimeDependentOperator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 0) || (nobjs > 3)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg3 = static_cast< mfem::TimeDependentOperator::Type >(val3); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); @@ -10239,13 +9419,19 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_5(PyObject } -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; + double arg3 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg4 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; + double val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; mfem::SecondOrderTimeDependentOperator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -10258,9 +9444,23 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_6(PyObject }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); + } { try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10286,25 +9486,11 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, if (!(argc = SWIG_Python_UnpackTuple(args, "new_SecondOrderTimeDependentOperator", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_3(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 3)) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_2(self, argc, argv); + if (argc <= 0) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); } - } - if (argc == 2) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10314,85 +9500,17 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_6(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_5(self, argc, argv); + if (argc <= 2) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -10403,7 +9521,7 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -10423,17 +9541,23 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, } } if (_v) { + if (argc <= 2) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 3) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_4(self, argc, argv); + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); } } } @@ -10444,12 +9568,7 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SecondOrderTimeDependentOperator'.\n" " Possible C/C++ prototypes are:\n" " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator()\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int)\n"); + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n"); return 0; } @@ -10902,206 +10021,82 @@ SWIGINTERN PyObject *_wrap_Solver_iterative_mode_set(PyObject *SWIGUNUSEDPARM(se void *argp1 = 0 ; int res1 = 0 ; bool val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Solver_iterative_mode_set", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_set" "', argument " "1"" of type '" "mfem::Solver *""'"); - } - arg1 = reinterpret_cast< mfem::Solver * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Solver_iterative_mode_set" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - if (arg1) (arg1)->iterative_mode = arg2; - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Solver_iterative_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Solver *arg1 = (mfem::Solver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_get" "', argument " "1"" of type '" "mfem::Solver *""'"); - } - arg1 = reinterpret_cast< mfem::Solver * >(argp1); - result = (bool) ((arg1)->iterative_mode); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - bool arg3 ; - bool val3 ; - int ecode3 = 0 ; - mfem::Solver *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Solver" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::Solver *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + int ecode2 = 0 ; + PyObject *swig_obj[2] ; + + if (!SWIG_Python_UnpackTuple(args, "Solver_iterative_mode_set", 2, 2, swig_obj)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_set" "', argument " "1"" of type '" "mfem::Solver *""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NEW | 0 ); + arg1 = reinterpret_cast< mfem::Solver * >(argp1); + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Solver_iterative_mode_set" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + if (arg1) (arg1)->iterative_mode = arg2; + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Solver_iterative_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::Solver *result = 0 ; + mfem::Solver *arg1 = (mfem::Solver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_get" "', argument " "1"" of type '" "mfem::Solver *""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NEW | 0 ); + arg1 = reinterpret_cast< mfem::Solver * >(argp1); + result = (bool) ((arg1)->iterative_mode); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - bool val4 ; - int ecode4 = 0 ; + int arg2 = (int) 0 ; + bool arg3 = (bool) false ; + bool val3 ; + int ecode3 = 0 ; mfem::Solver *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Solver" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Solver" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3,arg4); + result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -11123,14 +10118,17 @@ SWIGINTERN PyObject *_wrap_new_Solver__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; + bool arg4 = (bool) false ; + bool val4 ; + int ecode4 = 0 ; mfem::Solver *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { @@ -11144,11 +10142,18 @@ SWIGINTERN PyObject *_wrap_new_Solver__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Solver" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3); + result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3,arg4); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -11178,34 +10183,13 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_Solver", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 3)) { int _v; _v = (argv[0] != 0); if (_v) { - return _wrap_new_Solver__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (argc <= 1) { + return _wrap_new_Solver__SWIG_0(self, argc, argv); } - if (_v) { - return _wrap_new_Solver__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11215,6 +10199,9 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_Solver__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); @@ -11225,7 +10212,7 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 3) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -11247,39 +10234,15 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Solver__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 3) { + return _wrap_new_Solver__SWIG_1(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_bool(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Solver__SWIG_3(self, argc, argv); + return _wrap_new_Solver__SWIG_1(self, argc, argv); } } } @@ -11290,15 +10253,12 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Solver'.\n" " Possible C/C++ prototypes are:\n" " mfem::Solver::Solver(int,bool)\n" - " mfem::Solver::Solver(int)\n" - " mfem::Solver::Solver()\n" - " mfem::Solver::Solver(int,int,bool)\n" - " mfem::Solver::Solver(PyObject *,int,int)\n"); + " mfem::Solver::Solver(PyObject *,int,int,bool)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Solver *arg1 = (mfem::Solver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -11306,17 +10266,21 @@ SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Solver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Solver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_SetOperator" "', argument " "1"" of type '" "mfem::Solver *""'"); } arg1 = reinterpret_cast< mfem::Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Solver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -11325,7 +10289,7 @@ SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Operator * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -11388,16 +10352,18 @@ SWIGINTERN PyObject *_wrap_delete_Solver(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_disown_Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Solver *arg1 = (mfem::Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_Solver", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Solver" "', argument " "1"" of type '" "mfem::Solver *""'"); } @@ -11425,19 +10391,21 @@ SWIGINTERN PyObject *Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"n", NULL + }; mfem::IdentityOperator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_IdentityOperator", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -11459,7 +10427,7 @@ SWIGINTERN PyObject *_wrap_new_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11470,15 +10438,20 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IdentityOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityOperator_Mult" "', argument " "1"" of type '" "mfem::IdentityOperator const *""'"); } arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11486,7 +10459,7 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11514,7 +10487,7 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11525,15 +10498,20 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IdentityOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityOperator_MultTranspose" "', argument " "1"" of type '" "mfem::IdentityOperator const *""'"); } arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11541,7 +10519,7 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11614,17 +10592,19 @@ SWIGINTERN PyObject *IdentityOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"P", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsIdentityProlongation", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsIdentityProlongation" "', argument " "1"" of type '" "mfem::Operator const *""'"); } @@ -11649,7 +10629,7 @@ SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; double arg2 ; @@ -11657,16 +10637,20 @@ SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"a", NULL + }; mfem::ScaledOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ScaledOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ScaledOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScaledOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScaledOperator" "', argument " "2"" of type '" "double""'"); } @@ -11691,7 +10675,7 @@ SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScaledOperator *arg1 = (mfem::ScaledOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11702,15 +10686,20 @@ SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScaledOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScaledOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ScaledOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScaledOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScaledOperator_Mult" "', argument " "1"" of type '" "mfem::ScaledOperator const *""'"); } arg1 = reinterpret_cast< mfem::ScaledOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11718,7 +10707,7 @@ SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScaledOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11895,7 +10884,7 @@ SWIGINTERN PyObject *_wrap_new_TransposeOperator(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11906,15 +10895,20 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeOperator_Mult" "', argument " "1"" of type '" "mfem::TransposeOperator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11922,7 +10916,7 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11950,7 +10944,7 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11961,15 +10955,20 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TransposeOperator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11977,7 +10976,7 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12050,7 +11049,7 @@ SWIGINTERN PyObject *TransposeOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -12064,26 +11063,32 @@ SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), P int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"ownA", (char *)"ownB", NULL + }; mfem::ProductOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ProductOperator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_ProductOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_bool(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProductOperator" "', argument " "3"" of type '" "bool""'"); } arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ProductOperator" "', argument " "4"" of type '" "bool""'"); } @@ -12108,7 +11113,7 @@ SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12119,15 +11124,20 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ProductOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_Mult" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12135,7 +11145,7 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12163,7 +11173,7 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12174,15 +11184,20 @@ SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ProductOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12190,7 +11205,7 @@ SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12263,7 +11278,7 @@ SWIGINTERN PyObject *ProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Operator *arg2 = 0 ; @@ -12274,11 +11289,16 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"Rt_", (char *)"A_", (char *)"P_", NULL + }; mfem::RAPOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_RAPOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_RAPOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); } @@ -12286,7 +11306,7 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -12294,7 +11314,7 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Operator, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RAPOperator" "', argument " "3"" of type '" "mfem::Operator const &""'"); } @@ -12357,7 +11377,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12368,15 +11388,20 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAPOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_Mult" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); } arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12384,7 +11409,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12412,7 +11437,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12423,15 +11448,20 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAPOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_MultTranspose" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); } arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12439,7 +11469,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12512,7 +11542,7 @@ SWIGINTERN PyObject *RAPOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -12532,36 +11562,44 @@ SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(se int ecode5 = 0 ; bool val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"C", (char *)"ownA", (char *)"ownB", (char *)"ownC", NULL + }; mfem::TripleProductOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_TripleProductOperator", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:new_TripleProductOperator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TripleProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TripleProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TripleProductOperator" "', argument " "3"" of type '" "mfem::Operator const *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TripleProductOperator" "', argument " "4"" of type '" "bool""'"); } arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_bool(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TripleProductOperator" "', argument " "5"" of type '" "bool""'"); } arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_bool(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TripleProductOperator" "', argument " "6"" of type '" "bool""'"); } @@ -12621,7 +11659,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12632,15 +11670,20 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TripleProductOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_Mult" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12648,7 +11691,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12676,7 +11719,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12687,15 +11730,20 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TripleProductOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12703,7 +11751,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12737,80 +11785,17 @@ SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); - } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - mfem::ConstrainedOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12821,30 +11806,50 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"list", (char *)"own_A", NULL + }; mfem::ConstrainedOperator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:new_ConstrainedOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -12852,9 +11857,16 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2); + result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12872,56 +11884,6 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstrainedOperator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstrainedOperator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,bool)\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; @@ -12957,7 +11919,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12968,15 +11930,20 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"b", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstrainedOperator_EliminateRHS", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12984,7 +11951,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13012,7 +11979,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13023,15 +11990,20 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstrainedOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13039,7 +12011,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13112,12 +12084,12 @@ SWIGINTERN PyObject *ConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self) return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; - bool arg4 ; + bool arg4 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13126,15 +12098,22 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject * int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"trial_list", (char *)"test_list", (char *)"own_A", NULL + }; mfem::RectangularConstrainedOperator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_RectangularConstrainedOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13142,7 +12121,7 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -13150,69 +12129,16 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RectangularConstrainedOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::RectangularConstrainedOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RectangularConstrainedOperator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3); + result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13230,64 +12156,6 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RectangularConstrainedOperator", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_RectangularConstrainedOperator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_RectangularConstrainedOperator__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RectangularConstrainedOperator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &,bool)\n" - " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; @@ -13323,7 +12191,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_GetMemoryClass(PyObjec } -SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13334,15 +12202,20 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"b", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RectangularConstrainedOperator_EliminateRHS", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13350,7 +12223,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13378,7 +12251,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject } -SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13389,15 +12262,20 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RectangularConstrainedOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13405,7 +12283,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13437,70 +12315,19 @@ SWIGINTERN PyObject *_wrap_delete_RectangularConstrainedOperator(PyObject *SWIGU PyObject *resultobj = 0; mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator *""'"); - } - arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *RectangularConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *RectangularConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::PyOperatorBase *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator *""'"); } + arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); { try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyOperatorBase *)new SwigDirector_PyOperatorBase(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13511,25 +12338,45 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyOperatorBase, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *RectangularConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *RectangularConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; + int arg2 = (int) 0 ; mfem::PyOperatorBase *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; arg1 = swig_obj[0]; + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::PyOperatorBase *)new SwigDirector_PyOperatorBase(arg1); + result = (mfem::PyOperatorBase *)new SwigDirector_PyOperatorBase(arg1,arg2); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -13551,7 +12398,7 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; @@ -13606,17 +12453,13 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_PyOperatorBase", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_PyOperatorBase__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; _v = (argv[0] != 0); if (_v) { + if (argc <= 1) { + return _wrap_new_PyOperatorBase__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -13652,7 +12495,7 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_PyOperatorBase__SWIG_2(self, argc, argv); + return _wrap_new_PyOperatorBase__SWIG_1(self, argc, argv); } } } @@ -13662,13 +12505,12 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PyOperatorBase'.\n" " Possible C/C++ prototypes are:\n" " mfem::PyOperatorBase::PyOperatorBase(int)\n" - " mfem::PyOperatorBase::PyOperatorBase()\n" " mfem::PyOperatorBase::PyOperatorBase(PyObject *,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyOperatorBase *arg1 = (mfem::PyOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13679,17 +12521,22 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "PyOperatorBase_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyOperatorBase_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOperatorBase_Mult" "', argument " "1"" of type '" "mfem::PyOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13697,7 +12544,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyOperatorBase_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13706,7 +12553,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -13735,7 +12582,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyOperatorBase *arg1 = (mfem::PyOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13743,18 +12590,22 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PyOperatorBase__EvalMult", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PyOperatorBase__EvalMult", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOperatorBase__EvalMult" "', argument " "1"" of type '" "mfem::PyOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOperatorBase__EvalMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13763,7 +12614,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -13829,16 +12680,18 @@ SWIGINTERN PyObject *_wrap_delete_PyOperatorBase(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_disown_PyOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_PyOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyOperatorBase *arg1 = (mfem::PyOperatorBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_PyOperatorBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PyOperatorBase" "', argument " "1"" of type '" "mfem::PyOperatorBase *""'"); } @@ -13869,103 +12722,34 @@ SWIGINTERN PyObject *PyOperatorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - double arg3 ; + int arg2 = (int) 0 ; + double arg3 = (double) 0.0 ; double val3 ; int ecode3 = 0 ; mfem::PyTimeDependentOperatorBase *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::PyTimeDependentOperatorBase *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::PyTimeDependentOperatorBase *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1); + result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -13987,17 +12771,17 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_2(PyObject *SWI } -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; - double arg4 ; + double arg4 = (double) 0.0 ; double val4 ; int ecode4 = 0 ; mfem::PyTimeDependentOperatorBase *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { @@ -14011,63 +12795,18 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_3(PyObject *SWI }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3,arg4); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - mfem::PyTimeDependentOperatorBase *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3); + result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3,arg4); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -14097,34 +12836,13 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj if (!(argc = SWIG_Python_UnpackTuple(args, "new_PyTimeDependentOperatorBase", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; _v = (argv[0] != 0); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (argc <= 1) { + return _wrap_new_PyTimeDependentOperatorBase__SWIG_0(self, argc, argv); } - if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -14134,33 +12852,9 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_PyTimeDependentOperatorBase__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); @@ -14171,7 +12865,7 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -14193,12 +12887,15 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj } } if (_v) { + if (argc <= 3) { + return _wrap_new_PyTimeDependentOperatorBase__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_3(self, argc, argv); + return _wrap_new_PyTimeDependentOperatorBase__SWIG_1(self, argc, argv); } } } @@ -14209,15 +12906,12 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PyTimeDependentOperatorBase'.\n" " Possible C/C++ prototypes are:\n" " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(int,double)\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(int)\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase()\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(int,int,double)\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(PyObject *,int,int)\n"); + " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(PyObject *,int,int,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyTimeDependentOperatorBase *arg1 = (mfem::PyTimeDependentOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14228,17 +12922,22 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "PyTimeDependentOperatorBase_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyTimeDependentOperatorBase_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "1"" of type '" "mfem::PyTimeDependentOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyTimeDependentOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14246,7 +12945,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14255,7 +12954,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -14284,7 +12983,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyTimeDependentOperatorBase *arg1 = (mfem::PyTimeDependentOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14292,18 +12991,22 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PyTimeDependentOperatorBase__EvalMult", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PyTimeDependentOperatorBase__EvalMult", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTimeDependentOperatorBase__EvalMult" "', argument " "1"" of type '" "mfem::PyTimeDependentOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyTimeDependentOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyTimeDependentOperatorBase__EvalMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14312,7 +13015,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGU } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -14378,16 +13081,18 @@ SWIGINTERN PyObject *_wrap_delete_PyTimeDependentOperatorBase(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_disown_PyTimeDependentOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_PyTimeDependentOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyTimeDependentOperatorBase *arg1 = (mfem::PyTimeDependentOperatorBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_PyTimeDependentOperatorBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PyTimeDependentOperatorBase" "', argument " "1"" of type '" "mfem::PyTimeDependentOperatorBase *""'"); } @@ -14418,7 +13123,7 @@ SWIGINTERN PyObject *PyTimeDependentOperatorBase_swiginit(PyObject *SWIGUNUSEDPA static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "Operator_InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "Operator_InitTVectors", (PyCFunction)(void(*)(void))_wrap_Operator_InitTVectors, METH_VARARGS|METH_KEYWORDS, "Operator_InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" "Operator(int s=0)\n" "new_Operator(PyObject * _self, int h, int w) -> Operator\n" @@ -14428,57 +13133,57 @@ static PyMethodDef SwigMethods[] = { { "Operator_Width", _wrap_Operator_Width, METH_O, "Operator_Width(Operator self) -> int"}, { "Operator_NumCols", _wrap_Operator_NumCols, METH_O, "Operator_NumCols(Operator self) -> int"}, { "Operator_GetMemoryClass", _wrap_Operator_GetMemoryClass, METH_O, "Operator_GetMemoryClass(Operator self) -> mfem::MemoryClass"}, - { "Operator_Mult", _wrap_Operator_Mult, METH_VARARGS, "Operator_Mult(Operator self, Vector x, Vector y)"}, - { "Operator_MultTranspose", _wrap_Operator_MultTranspose, METH_VARARGS, "Operator_MultTranspose(Operator self, Vector x, Vector y)"}, - { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "Operator_GetGradient(Operator self, Vector x) -> Operator"}, + { "Operator_Mult", (PyCFunction)(void(*)(void))_wrap_Operator_Mult, METH_VARARGS|METH_KEYWORDS, "Operator_Mult(Operator self, Vector x, Vector y)"}, + { "Operator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_Operator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "Operator_MultTranspose(Operator self, Vector x, Vector y)"}, + { "Operator_GetGradient", (PyCFunction)(void(*)(void))_wrap_Operator_GetGradient, METH_VARARGS|METH_KEYWORDS, "Operator_GetGradient(Operator self, Vector x) -> Operator"}, { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "Operator_GetProlongation(Operator self) -> Operator"}, { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "Operator_GetRestriction(Operator self) -> Operator"}, { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "Operator_GetOutputProlongation(Operator self) -> Operator"}, { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "Operator_GetOutputRestriction(Operator self) -> Operator"}, - { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "Operator_FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "Operator_FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "Operator_RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, - { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "Operator_FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "Operator_FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "Operator_FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, + { "Operator_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "Operator_FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "Operator_FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "Operator_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_Operator_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "Operator_RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "Operator_FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "Operator_FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "Operator_FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, { "Operator_GetType", _wrap_Operator_GetType, METH_O, "Operator_GetType(Operator self) -> mfem::Operator::Type"}, { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" "Operator_PrintMatlab(Operator self, std::ostream & out, int n=0, int m=0)\n" "Operator_PrintMatlab(Operator self, char const * file, int precision=8)\n" ""}, - { "disown_Operator", _wrap_disown_Operator, METH_O, NULL}, + { "disown_Operator", (PyCFunction)(void(*)(void))_wrap_disown_Operator, METH_VARARGS|METH_KEYWORDS, NULL}, { "Operator_swigregister", Operator_swigregister, METH_O, NULL}, { "Operator_swiginit", Operator_swiginit, METH_VARARGS, NULL}, { "new_TimeDependentOperator", _wrap_new_TimeDependentOperator, METH_VARARGS, "\n" "TimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "TimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_TimeDependentOperator(PyObject * _self, int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> TimeDependentOperator\n" ""}, { "TimeDependentOperator_GetTime", _wrap_TimeDependentOperator_GetTime, METH_O, "TimeDependentOperator_GetTime(TimeDependentOperator self) -> double"}, - { "TimeDependentOperator_SetTime", _wrap_TimeDependentOperator_SetTime, METH_VARARGS, "TimeDependentOperator_SetTime(TimeDependentOperator self, double const _t)"}, + { "TimeDependentOperator_SetTime", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetTime, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SetTime(TimeDependentOperator self, double const _t)"}, { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "TimeDependentOperator_isExplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "TimeDependentOperator_isImplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "TimeDependentOperator_isHomogeneous(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "TimeDependentOperator_GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, - { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "TimeDependentOperator_SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, - { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "TimeDependentOperator_ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "TimeDependentOperator_ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, - { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "TimeDependentOperator_Mult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "TimeDependentOperator_ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, - { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "TimeDependentOperator_GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, - { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "TimeDependentOperator_GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, - { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "TimeDependentOperator_SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, - { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "TimeDependentOperator_SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SetEvalMode", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, + { "TimeDependentOperator_ExplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, + { "TimeDependentOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_Mult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_Mult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, + { "TimeDependentOperator_GetImplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, + { "TimeDependentOperator_GetExplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "TimeDependentOperator_SUNMassSetup(TimeDependentOperator self) -> int"}, - { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "TimeDependentOperator_SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, - { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "TimeDependentOperator_SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, + { "TimeDependentOperator_SUNMassSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, - { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, + { "disown_TimeDependentOperator", (PyCFunction)(void(*)(void))_wrap_disown_TimeDependentOperator, METH_VARARGS|METH_KEYWORDS, NULL}, { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator\n" ""}, { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" "SecondOrderTimeDependentOperator_Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" @@ -14495,22 +13200,22 @@ static PyMethodDef SwigMethods[] = { { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" "Solver(int s=0, bool iter_mode=False)\n" - "Solver(int h, int w, bool iter_mode=False)\n" + "new_Solver(PyObject * _self, int h, int w, bool iter_mode=False) -> Solver\n" ""}, - { "Solver_SetOperator", _wrap_Solver_SetOperator, METH_VARARGS, "Solver_SetOperator(Solver self, Operator op)"}, + { "Solver_SetOperator", (PyCFunction)(void(*)(void))_wrap_Solver_SetOperator, METH_VARARGS|METH_KEYWORDS, "Solver_SetOperator(Solver self, Operator op)"}, { "delete_Solver", _wrap_delete_Solver, METH_O, "delete_Solver(Solver self)"}, - { "disown_Solver", _wrap_disown_Solver, METH_O, NULL}, + { "disown_Solver", (PyCFunction)(void(*)(void))_wrap_disown_Solver, METH_VARARGS|METH_KEYWORDS, NULL}, { "Solver_swigregister", Solver_swigregister, METH_O, NULL}, { "Solver_swiginit", Solver_swiginit, METH_VARARGS, NULL}, - { "new_IdentityOperator", _wrap_new_IdentityOperator, METH_O, "new_IdentityOperator(int n) -> IdentityOperator"}, - { "IdentityOperator_Mult", _wrap_IdentityOperator_Mult, METH_VARARGS, "IdentityOperator_Mult(IdentityOperator self, Vector x, Vector y)"}, - { "IdentityOperator_MultTranspose", _wrap_IdentityOperator_MultTranspose, METH_VARARGS, "IdentityOperator_MultTranspose(IdentityOperator self, Vector x, Vector y)"}, + { "new_IdentityOperator", (PyCFunction)(void(*)(void))_wrap_new_IdentityOperator, METH_VARARGS|METH_KEYWORDS, "new_IdentityOperator(int n) -> IdentityOperator"}, + { "IdentityOperator_Mult", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_Mult, METH_VARARGS|METH_KEYWORDS, "IdentityOperator_Mult(IdentityOperator self, Vector x, Vector y)"}, + { "IdentityOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "IdentityOperator_MultTranspose(IdentityOperator self, Vector x, Vector y)"}, { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, - { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, - { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, - { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "ScaledOperator_Mult(ScaledOperator self, Vector x, Vector y)"}, + { "IsIdentityProlongation", (PyCFunction)(void(*)(void))_wrap_IsIdentityProlongation, METH_VARARGS|METH_KEYWORDS, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", (PyCFunction)(void(*)(void))_wrap_new_ScaledOperator, METH_VARARGS|METH_KEYWORDS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ScaledOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ScaledOperator_Mult(ScaledOperator self, Vector x, Vector y)"}, { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, @@ -14518,42 +13223,42 @@ static PyMethodDef SwigMethods[] = { "TransposeOperator(Operator a)\n" "new_TransposeOperator(Operator a) -> TransposeOperator\n" ""}, - { "TransposeOperator_Mult", _wrap_TransposeOperator_Mult, METH_VARARGS, "TransposeOperator_Mult(TransposeOperator self, Vector x, Vector y)"}, - { "TransposeOperator_MultTranspose", _wrap_TransposeOperator_MultTranspose, METH_VARARGS, "TransposeOperator_MultTranspose(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_Mult, METH_VARARGS|METH_KEYWORDS, "TransposeOperator_Mult(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "TransposeOperator_MultTranspose(TransposeOperator self, Vector x, Vector y)"}, { "delete_TransposeOperator", _wrap_delete_TransposeOperator, METH_O, "delete_TransposeOperator(TransposeOperator self)"}, { "TransposeOperator_swigregister", TransposeOperator_swigregister, METH_O, NULL}, { "TransposeOperator_swiginit", TransposeOperator_swiginit, METH_VARARGS, NULL}, - { "new_ProductOperator", _wrap_new_ProductOperator, METH_VARARGS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, - { "ProductOperator_Mult", _wrap_ProductOperator_Mult, METH_VARARGS, "ProductOperator_Mult(ProductOperator self, Vector x, Vector y)"}, - { "ProductOperator_MultTranspose", _wrap_ProductOperator_MultTranspose, METH_VARARGS, "ProductOperator_MultTranspose(ProductOperator self, Vector x, Vector y)"}, + { "new_ProductOperator", (PyCFunction)(void(*)(void))_wrap_new_ProductOperator, METH_VARARGS|METH_KEYWORDS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, + { "ProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ProductOperator_Mult(ProductOperator self, Vector x, Vector y)"}, + { "ProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ProductOperator_MultTranspose(ProductOperator self, Vector x, Vector y)"}, { "delete_ProductOperator", _wrap_delete_ProductOperator, METH_O, "delete_ProductOperator(ProductOperator self)"}, { "ProductOperator_swigregister", ProductOperator_swigregister, METH_O, NULL}, { "ProductOperator_swiginit", ProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_RAPOperator", _wrap_new_RAPOperator, METH_VARARGS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, + { "new_RAPOperator", (PyCFunction)(void(*)(void))_wrap_new_RAPOperator, METH_VARARGS|METH_KEYWORDS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, { "RAPOperator_GetMemoryClass", _wrap_RAPOperator_GetMemoryClass, METH_O, "RAPOperator_GetMemoryClass(RAPOperator self) -> mfem::MemoryClass"}, - { "RAPOperator_Mult", _wrap_RAPOperator_Mult, METH_VARARGS, "RAPOperator_Mult(RAPOperator self, Vector x, Vector y)"}, - { "RAPOperator_MultTranspose", _wrap_RAPOperator_MultTranspose, METH_VARARGS, "RAPOperator_MultTranspose(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RAPOperator_Mult, METH_VARARGS|METH_KEYWORDS, "RAPOperator_Mult(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_RAPOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "RAPOperator_MultTranspose(RAPOperator self, Vector x, Vector y)"}, { "delete_RAPOperator", _wrap_delete_RAPOperator, METH_O, "delete_RAPOperator(RAPOperator self)"}, { "RAPOperator_swigregister", RAPOperator_swigregister, METH_O, NULL}, { "RAPOperator_swiginit", RAPOperator_swiginit, METH_VARARGS, NULL}, - { "new_TripleProductOperator", _wrap_new_TripleProductOperator, METH_VARARGS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, + { "new_TripleProductOperator", (PyCFunction)(void(*)(void))_wrap_new_TripleProductOperator, METH_VARARGS|METH_KEYWORDS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, { "TripleProductOperator_GetMemoryClass", _wrap_TripleProductOperator_GetMemoryClass, METH_O, "TripleProductOperator_GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass"}, - { "TripleProductOperator_Mult", _wrap_TripleProductOperator_Mult, METH_VARARGS, "TripleProductOperator_Mult(TripleProductOperator self, Vector x, Vector y)"}, - { "TripleProductOperator_MultTranspose", _wrap_TripleProductOperator_MultTranspose, METH_VARARGS, "TripleProductOperator_MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "TripleProductOperator_Mult(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "TripleProductOperator_MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, { "delete_TripleProductOperator", _wrap_delete_TripleProductOperator, METH_O, "delete_TripleProductOperator(TripleProductOperator self)"}, { "TripleProductOperator_swigregister", TripleProductOperator_swigregister, METH_O, NULL}, { "TripleProductOperator_swiginit", TripleProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_ConstrainedOperator", _wrap_new_ConstrainedOperator, METH_VARARGS, "ConstrainedOperator(Operator A, intArray list, bool own_A=False)"}, + { "new_ConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_ConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_ConstrainedOperator(Operator A, intArray list, bool own_A=False) -> ConstrainedOperator"}, { "ConstrainedOperator_GetMemoryClass", _wrap_ConstrainedOperator_GetMemoryClass, METH_O, "ConstrainedOperator_GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass"}, - { "ConstrainedOperator_EliminateRHS", _wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS, "ConstrainedOperator_EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, - { "ConstrainedOperator_Mult", _wrap_ConstrainedOperator_Mult, METH_VARARGS, "ConstrainedOperator_Mult(ConstrainedOperator self, Vector x, Vector y)"}, + { "ConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "ConstrainedOperator_EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, + { "ConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ConstrainedOperator_Mult(ConstrainedOperator self, Vector x, Vector y)"}, { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, - { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "new_RectangularConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_RectangularConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False) -> RectangularConstrainedOperator"}, { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "RectangularConstrainedOperator_GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, - { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "RectangularConstrainedOperator_EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, - { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "RectangularConstrainedOperator_Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "RectangularConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "RectangularConstrainedOperator_EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "RectangularConstrainedOperator_Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, @@ -14561,20 +13266,20 @@ static PyMethodDef SwigMethods[] = { "PyOperatorBase(int s=0)\n" "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" ""}, - { "PyOperatorBase_Mult", _wrap_PyOperatorBase_Mult, METH_VARARGS, "PyOperatorBase_Mult(PyOperatorBase self, Vector x, Vector y)"}, - { "PyOperatorBase__EvalMult", _wrap_PyOperatorBase__EvalMult, METH_VARARGS, "PyOperatorBase__EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, + { "PyOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "PyOperatorBase_Mult(PyOperatorBase self, Vector x, Vector y)"}, + { "PyOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "PyOperatorBase__EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyOperatorBase", _wrap_delete_PyOperatorBase, METH_O, "delete_PyOperatorBase(PyOperatorBase self)"}, - { "disown_PyOperatorBase", _wrap_disown_PyOperatorBase, METH_O, NULL}, + { "disown_PyOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyOperatorBase_swigregister", PyOperatorBase_swigregister, METH_O, NULL}, { "PyOperatorBase_swiginit", PyOperatorBase_swiginit, METH_VARARGS, NULL}, { "new_PyTimeDependentOperatorBase", _wrap_new_PyTimeDependentOperatorBase, METH_VARARGS, "\n" "PyTimeDependentOperatorBase(int n=0, double _t=0.0)\n" - "PyTimeDependentOperatorBase(int h, int w, double _t=0.0)\n" + "new_PyTimeDependentOperatorBase(PyObject * _self, int h, int w, double _t=0.0) -> PyTimeDependentOperatorBase\n" ""}, - { "PyTimeDependentOperatorBase_Mult", _wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS, "PyTimeDependentOperatorBase_Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, - { "PyTimeDependentOperatorBase__EvalMult", _wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS, "PyTimeDependentOperatorBase__EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, + { "PyTimeDependentOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "PyTimeDependentOperatorBase_Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, + { "PyTimeDependentOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "PyTimeDependentOperatorBase__EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyTimeDependentOperatorBase", _wrap_delete_PyTimeDependentOperatorBase, METH_O, "delete_PyTimeDependentOperatorBase(PyTimeDependentOperatorBase self)"}, - { "disown_PyTimeDependentOperatorBase", _wrap_disown_PyTimeDependentOperatorBase, METH_O, NULL}, + { "disown_PyTimeDependentOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyTimeDependentOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyTimeDependentOperatorBase_swigregister", PyTimeDependentOperatorBase_swigregister, METH_O, NULL}, { "PyTimeDependentOperatorBase_swiginit", PyTimeDependentOperatorBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -14583,7 +13288,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "Operator_InitTVectors", (PyCFunction)(void(*)(void))_wrap_Operator_InitTVectors, METH_VARARGS|METH_KEYWORDS, "InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" "Operator(int s=0)\n" "new_Operator(PyObject * _self, int h, int w) -> Operator\n" @@ -14593,57 +13298,57 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Operator_Width", _wrap_Operator_Width, METH_O, "Width(Operator self) -> int"}, { "Operator_NumCols", _wrap_Operator_NumCols, METH_O, "NumCols(Operator self) -> int"}, { "Operator_GetMemoryClass", _wrap_Operator_GetMemoryClass, METH_O, "GetMemoryClass(Operator self) -> mfem::MemoryClass"}, - { "Operator_Mult", _wrap_Operator_Mult, METH_VARARGS, "Mult(Operator self, Vector x, Vector y)"}, - { "Operator_MultTranspose", _wrap_Operator_MultTranspose, METH_VARARGS, "MultTranspose(Operator self, Vector x, Vector y)"}, - { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "GetGradient(Operator self, Vector x) -> Operator"}, + { "Operator_Mult", (PyCFunction)(void(*)(void))_wrap_Operator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(Operator self, Vector x, Vector y)"}, + { "Operator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_Operator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(Operator self, Vector x, Vector y)"}, + { "Operator_GetGradient", (PyCFunction)(void(*)(void))_wrap_Operator_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(Operator self, Vector x) -> Operator"}, { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "GetProlongation(Operator self) -> Operator"}, { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "GetRestriction(Operator self) -> Operator"}, { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "GetOutputProlongation(Operator self) -> Operator"}, { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "GetOutputRestriction(Operator self) -> Operator"}, - { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, - { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, + { "Operator_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "Operator_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_Operator_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, { "Operator_GetType", _wrap_Operator_GetType, METH_O, "GetType(Operator self) -> mfem::Operator::Type"}, { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" "PrintMatlab(Operator self, std::ostream & out, int n=0, int m=0)\n" "PrintMatlab(Operator self, char const * file, int precision=8)\n" ""}, - { "disown_Operator", _wrap_disown_Operator, METH_O, NULL}, + { "disown_Operator", (PyCFunction)(void(*)(void))_wrap_disown_Operator, METH_VARARGS|METH_KEYWORDS, NULL}, { "Operator_swigregister", Operator_swigregister, METH_O, NULL}, { "Operator_swiginit", Operator_swiginit, METH_VARARGS, NULL}, { "new_TimeDependentOperator", _wrap_new_TimeDependentOperator, METH_VARARGS, "\n" "TimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "TimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_TimeDependentOperator(PyObject * _self, int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> TimeDependentOperator\n" ""}, { "TimeDependentOperator_GetTime", _wrap_TimeDependentOperator_GetTime, METH_O, "GetTime(TimeDependentOperator self) -> double"}, - { "TimeDependentOperator_SetTime", _wrap_TimeDependentOperator_SetTime, METH_VARARGS, "SetTime(TimeDependentOperator self, double const _t)"}, + { "TimeDependentOperator_SetTime", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(TimeDependentOperator self, double const _t)"}, { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "isExplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "isImplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "isHomogeneous(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, - { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, - { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, - { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "Mult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, - { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, - { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, - { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, - { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SetEvalMode", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS|METH_KEYWORDS, "SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, + { "TimeDependentOperator_ExplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS|METH_KEYWORDS, "ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS|METH_KEYWORDS, "ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, + { "TimeDependentOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS|METH_KEYWORDS, "ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, + { "TimeDependentOperator_GetImplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS|METH_KEYWORDS, "GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, + { "TimeDependentOperator_GetExplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS|METH_KEYWORDS, "GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS|METH_KEYWORDS, "SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS|METH_KEYWORDS, "SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "SUNMassSetup(TimeDependentOperator self) -> int"}, - { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, - { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, + { "TimeDependentOperator_SUNMassSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS|METH_KEYWORDS, "SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS|METH_KEYWORDS, "SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, - { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, + { "disown_TimeDependentOperator", (PyCFunction)(void(*)(void))_wrap_disown_TimeDependentOperator, METH_VARARGS|METH_KEYWORDS, NULL}, { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator\n" ""}, { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" "Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" @@ -14660,22 +13365,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" "Solver(int s=0, bool iter_mode=False)\n" - "Solver(int h, int w, bool iter_mode=False)\n" + "new_Solver(PyObject * _self, int h, int w, bool iter_mode=False) -> Solver\n" ""}, - { "Solver_SetOperator", _wrap_Solver_SetOperator, METH_VARARGS, "SetOperator(Solver self, Operator op)"}, + { "Solver_SetOperator", (PyCFunction)(void(*)(void))_wrap_Solver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(Solver self, Operator op)"}, { "delete_Solver", _wrap_delete_Solver, METH_O, "delete_Solver(Solver self)"}, - { "disown_Solver", _wrap_disown_Solver, METH_O, NULL}, + { "disown_Solver", (PyCFunction)(void(*)(void))_wrap_disown_Solver, METH_VARARGS|METH_KEYWORDS, NULL}, { "Solver_swigregister", Solver_swigregister, METH_O, NULL}, { "Solver_swiginit", Solver_swiginit, METH_VARARGS, NULL}, - { "new_IdentityOperator", _wrap_new_IdentityOperator, METH_O, "new_IdentityOperator(int n) -> IdentityOperator"}, - { "IdentityOperator_Mult", _wrap_IdentityOperator_Mult, METH_VARARGS, "Mult(IdentityOperator self, Vector x, Vector y)"}, - { "IdentityOperator_MultTranspose", _wrap_IdentityOperator_MultTranspose, METH_VARARGS, "MultTranspose(IdentityOperator self, Vector x, Vector y)"}, + { "new_IdentityOperator", (PyCFunction)(void(*)(void))_wrap_new_IdentityOperator, METH_VARARGS|METH_KEYWORDS, "new_IdentityOperator(int n) -> IdentityOperator"}, + { "IdentityOperator_Mult", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(IdentityOperator self, Vector x, Vector y)"}, + { "IdentityOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(IdentityOperator self, Vector x, Vector y)"}, { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, - { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, - { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, - { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "Mult(ScaledOperator self, Vector x, Vector y)"}, + { "IsIdentityProlongation", (PyCFunction)(void(*)(void))_wrap_IsIdentityProlongation, METH_VARARGS|METH_KEYWORDS, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", (PyCFunction)(void(*)(void))_wrap_new_ScaledOperator, METH_VARARGS|METH_KEYWORDS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ScaledOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ScaledOperator self, Vector x, Vector y)"}, { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, @@ -14683,42 +13388,42 @@ static PyMethodDef SwigMethods_proxydocs[] = { "TransposeOperator(Operator a)\n" "new_TransposeOperator(Operator a) -> TransposeOperator\n" ""}, - { "TransposeOperator_Mult", _wrap_TransposeOperator_Mult, METH_VARARGS, "Mult(TransposeOperator self, Vector x, Vector y)"}, - { "TransposeOperator_MultTranspose", _wrap_TransposeOperator_MultTranspose, METH_VARARGS, "MultTranspose(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(TransposeOperator self, Vector x, Vector y)"}, { "delete_TransposeOperator", _wrap_delete_TransposeOperator, METH_O, "delete_TransposeOperator(TransposeOperator self)"}, { "TransposeOperator_swigregister", TransposeOperator_swigregister, METH_O, NULL}, { "TransposeOperator_swiginit", TransposeOperator_swiginit, METH_VARARGS, NULL}, - { "new_ProductOperator", _wrap_new_ProductOperator, METH_VARARGS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, - { "ProductOperator_Mult", _wrap_ProductOperator_Mult, METH_VARARGS, "Mult(ProductOperator self, Vector x, Vector y)"}, - { "ProductOperator_MultTranspose", _wrap_ProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(ProductOperator self, Vector x, Vector y)"}, + { "new_ProductOperator", (PyCFunction)(void(*)(void))_wrap_new_ProductOperator, METH_VARARGS|METH_KEYWORDS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, + { "ProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ProductOperator self, Vector x, Vector y)"}, + { "ProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ProductOperator self, Vector x, Vector y)"}, { "delete_ProductOperator", _wrap_delete_ProductOperator, METH_O, "delete_ProductOperator(ProductOperator self)"}, { "ProductOperator_swigregister", ProductOperator_swigregister, METH_O, NULL}, { "ProductOperator_swiginit", ProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_RAPOperator", _wrap_new_RAPOperator, METH_VARARGS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, + { "new_RAPOperator", (PyCFunction)(void(*)(void))_wrap_new_RAPOperator, METH_VARARGS|METH_KEYWORDS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, { "RAPOperator_GetMemoryClass", _wrap_RAPOperator_GetMemoryClass, METH_O, "GetMemoryClass(RAPOperator self) -> mfem::MemoryClass"}, - { "RAPOperator_Mult", _wrap_RAPOperator_Mult, METH_VARARGS, "Mult(RAPOperator self, Vector x, Vector y)"}, - { "RAPOperator_MultTranspose", _wrap_RAPOperator_MultTranspose, METH_VARARGS, "MultTranspose(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RAPOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_RAPOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(RAPOperator self, Vector x, Vector y)"}, { "delete_RAPOperator", _wrap_delete_RAPOperator, METH_O, "delete_RAPOperator(RAPOperator self)"}, { "RAPOperator_swigregister", RAPOperator_swigregister, METH_O, NULL}, { "RAPOperator_swiginit", RAPOperator_swiginit, METH_VARARGS, NULL}, - { "new_TripleProductOperator", _wrap_new_TripleProductOperator, METH_VARARGS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, + { "new_TripleProductOperator", (PyCFunction)(void(*)(void))_wrap_new_TripleProductOperator, METH_VARARGS|METH_KEYWORDS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, { "TripleProductOperator_GetMemoryClass", _wrap_TripleProductOperator_GetMemoryClass, METH_O, "GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass"}, - { "TripleProductOperator_Mult", _wrap_TripleProductOperator_Mult, METH_VARARGS, "Mult(TripleProductOperator self, Vector x, Vector y)"}, - { "TripleProductOperator_MultTranspose", _wrap_TripleProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, { "delete_TripleProductOperator", _wrap_delete_TripleProductOperator, METH_O, "delete_TripleProductOperator(TripleProductOperator self)"}, { "TripleProductOperator_swigregister", TripleProductOperator_swigregister, METH_O, NULL}, { "TripleProductOperator_swiginit", TripleProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_ConstrainedOperator", _wrap_new_ConstrainedOperator, METH_VARARGS, "ConstrainedOperator(Operator A, intArray list, bool own_A=False)"}, + { "new_ConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_ConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_ConstrainedOperator(Operator A, intArray list, bool own_A=False) -> ConstrainedOperator"}, { "ConstrainedOperator_GetMemoryClass", _wrap_ConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass"}, - { "ConstrainedOperator_EliminateRHS", _wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, - { "ConstrainedOperator_Mult", _wrap_ConstrainedOperator_Mult, METH_VARARGS, "Mult(ConstrainedOperator self, Vector x, Vector y)"}, + { "ConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, + { "ConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ConstrainedOperator self, Vector x, Vector y)"}, { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, - { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "new_RectangularConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_RectangularConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False) -> RectangularConstrainedOperator"}, { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, - { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, - { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "RectangularConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, @@ -14726,20 +13431,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "PyOperatorBase(int s=0)\n" "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" ""}, - { "PyOperatorBase_Mult", _wrap_PyOperatorBase_Mult, METH_VARARGS, "Mult(PyOperatorBase self, Vector x, Vector y)"}, - { "PyOperatorBase__EvalMult", _wrap_PyOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, + { "PyOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(PyOperatorBase self, Vector x, Vector y)"}, + { "PyOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "_EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyOperatorBase", _wrap_delete_PyOperatorBase, METH_O, "delete_PyOperatorBase(PyOperatorBase self)"}, - { "disown_PyOperatorBase", _wrap_disown_PyOperatorBase, METH_O, NULL}, + { "disown_PyOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyOperatorBase_swigregister", PyOperatorBase_swigregister, METH_O, NULL}, { "PyOperatorBase_swiginit", PyOperatorBase_swiginit, METH_VARARGS, NULL}, { "new_PyTimeDependentOperatorBase", _wrap_new_PyTimeDependentOperatorBase, METH_VARARGS, "\n" "PyTimeDependentOperatorBase(int n=0, double _t=0.0)\n" - "PyTimeDependentOperatorBase(int h, int w, double _t=0.0)\n" + "new_PyTimeDependentOperatorBase(PyObject * _self, int h, int w, double _t=0.0) -> PyTimeDependentOperatorBase\n" ""}, - { "PyTimeDependentOperatorBase_Mult", _wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS, "Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, - { "PyTimeDependentOperatorBase__EvalMult", _wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, + { "PyTimeDependentOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, + { "PyTimeDependentOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyTimeDependentOperatorBase", _wrap_delete_PyTimeDependentOperatorBase, METH_O, "delete_PyTimeDependentOperatorBase(PyTimeDependentOperatorBase self)"}, - { "disown_PyTimeDependentOperatorBase", _wrap_disown_PyTimeDependentOperatorBase, METH_O, NULL}, + { "disown_PyTimeDependentOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyTimeDependentOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyTimeDependentOperatorBase_swigregister", PyTimeDependentOperatorBase_swigregister, METH_O, NULL}, { "PyTimeDependentOperatorBase_swiginit", PyTimeDependentOperatorBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } diff --git a/mfem/_par/pbilinearform_wrap.cxx b/mfem/_par/pbilinearform_wrap.cxx index ba97e658..1662e2dc 100644 --- a/mfem/_par/pbilinearform_wrap.cxx +++ b/mfem/_par/pbilinearform_wrap.cxx @@ -3465,13 +3465,13 @@ SWIG_AsVal_int (PyObject * obj, int *val) return res; } -SWIGINTERN void mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_SparseMatrix_Sg___SWIG_5(mfem::ParBilinearForm *self,mfem::Array< int > const &ess_tdof_list,mfem::Vector &x,mfem::Vector &b,mfem::SparseMatrix &A,mfem::Vector &X,mfem::Vector &B,int copy_interior=0){ +SWIGINTERN void mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_SparseMatrix_Sg___SWIG_3(mfem::ParBilinearForm *self,mfem::Array< int > const &ess_tdof_list,mfem::Vector &x,mfem::Vector &b,mfem::SparseMatrix &A,mfem::Vector &X,mfem::Vector &B,int copy_interior=0){ return self->mfem::BilinearForm::FormLinearSystem(ess_tdof_list, x, b, A, X, B, copy_interior); } SWIGINTERN void mfem_ParBilinearForm_FormSystemMatrix_Sl_mfem_SparseMatrix_Sg___SWIG_3(mfem::ParBilinearForm *self,mfem::Array< int > const &ess_tdof_list,mfem::SparseMatrix &A){ return self->mfem::BilinearForm::FormSystemMatrix(ess_tdof_list, A); } -SWIGINTERN void mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_HypreParMatrix_Sg___SWIG_7(mfem::ParBilinearForm *self,mfem::Array< int > const &ess_tdof_list,mfem::Vector &x,mfem::Vector &b,mfem::HypreParMatrix &A,mfem::Vector &X,mfem::Vector &B,int copy_interior=0){ +SWIGINTERN void mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_HypreParMatrix_Sg___SWIG_4(mfem::ParBilinearForm *self,mfem::Array< int > const &ess_tdof_list,mfem::Vector &x,mfem::Vector &b,mfem::HypreParMatrix &A,mfem::Vector &X,mfem::Vector &B,int copy_interior=0){ return self->mfem::BilinearForm::FormLinearSystem(ess_tdof_list, x, b, A, X, B, copy_interior); } SWIGINTERN void mfem_ParBilinearForm_FormSystemMatrix_Sl_mfem_HypreParMatrix_Sg___SWIG_4(mfem::ParBilinearForm *self,mfem::Array< int > const &ess_tdof_list,mfem::HypreParMatrix &A){ @@ -3593,56 +3593,36 @@ SWIGINTERN PyObject *_wrap_new_ParBilinearForm(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_ParBilinearForm_KeepNbrBlock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_KeepNbrBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"knb", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ParBilinearForm_KeepNbrBlock", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_KeepNbrBlock" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParBilinearForm_KeepNbrBlock" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->KeepNbrBlock(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_KeepNbrBlock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_KeepNbrBlock" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParBilinearForm_KeepNbrBlock" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); { try { - (arg1)->KeepNbrBlock(); + (arg1)->KeepNbrBlock(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3655,49 +3635,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_KeepNbrBlock__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ParBilinearForm_KeepNbrBlock(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParBilinearForm_KeepNbrBlock", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_KeepNbrBlock__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParBilinearForm_KeepNbrBlock__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParBilinearForm_KeepNbrBlock'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParBilinearForm::KeepNbrBlock(bool)\n" - " mfem::ParBilinearForm::KeepNbrBlock()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; mfem::Operator::Type arg2 ; @@ -3705,15 +3643,19 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_SetOperatorType(PyObject *SWIGUNUSEDP int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParBilinearForm_SetOperatorType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParBilinearForm_SetOperatorType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_SetOperatorType" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParBilinearForm_SetOperatorType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -3733,55 +3675,35 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_SetOperatorType(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_ParBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_Assemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ParBilinearForm_Assemble", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Assemble(arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); { try { - (arg1)->Assemble(); + (arg1)->Assemble(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3794,52 +3716,6 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ParBilinearForm_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParBilinearForm_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParBilinearForm_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParBilinearForm_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParBilinearForm::Assemble(int)\n" - " mfem::ParBilinearForm::Assemble()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ParBilinearForm_ParallelAssemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; @@ -4355,7 +4231,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_ParallelEliminateEssentialBC(PyObject } -SWIGINTERN PyObject *_wrap_ParBilinearForm_ParallelEliminateTDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_ParallelEliminateTDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4366,16 +4242,21 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_ParallelEliminateTDofs(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tdofs_list", (char *)"A", NULL + }; mfem::HypreParMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParBilinearForm_ParallelEliminateTDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParBilinearForm_ParallelEliminateTDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_ParallelEliminateTDofs" "', argument " "1"" of type '" "mfem::ParBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_ParallelEliminateTDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -4383,7 +4264,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_ParallelEliminateTDofs(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_ParallelEliminateTDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_ParallelEliminateTDofs" "', argument " "3"" of type '" "mfem::HypreParMatrix &""'"); } @@ -4406,12 +4287,12 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_ParallelEliminateTDofs(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4420,14 +4301,21 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult__SWIG_0(PyObject *SWIGUNU int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:ParBilinearForm_TrueAddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "1"" of type '" "mfem::ParBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4435,7 +4323,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4443,63 +4331,16 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::ParBilinearForm const *)arg1)->TrueAddMult((mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "1"" of type '" "mfem::ParBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParBilinearForm_TrueAddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ParBilinearForm const *)arg1)->TrueAddMult((mfem::Vector const &)*arg2,*arg3); + ((mfem::ParBilinearForm const *)arg1)->TrueAddMult((mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4512,66 +4353,6 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ParBilinearForm_TrueAddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParBilinearForm_TrueAddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_TrueAddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParBilinearForm_TrueAddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParBilinearForm_TrueAddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParBilinearForm::TrueAddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::ParBilinearForm::TrueAddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ParBilinearForm_ParFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; @@ -4701,7 +4482,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_1(PyObject *SW mfem::OperatorHandle *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4717,7 +4498,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_1(PyObject *SW void *argp7 = 0 ; int res7 = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); @@ -4771,11 +4552,13 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_1(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + if (swig_obj[7]) { + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } } { try { @@ -4792,112 +4575,19 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_1(PyObject *SW } -SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_FormSystemMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::OperatorHandle *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; + mfem::OperatorHandle *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__OperatorHandle, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - arg5 = reinterpret_cast< mfem::OperatorHandle * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - try { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_FormSystemMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::OperatorHandle *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); @@ -4934,7 +4624,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormSystemMatrix__SWIG_1(PyObject *SW } -SWIGINTERN PyObject *_wrap_ParBilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4948,15 +4638,21 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_RecoverFEMSolution(PyObject *SWIGUNUS int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"X", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParBilinearForm_RecoverFEMSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParBilinearForm_RecoverFEMSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_RecoverFEMSolution" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4964,7 +4660,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_RecoverFEMSolution(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -4972,7 +4668,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_RecoverFEMSolution(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParBilinearForm_RecoverFEMSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -4995,56 +4691,36 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_RecoverFEMSolution(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ParBilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nfes", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ParBilinearForm_Update", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_Update" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - { - try { - (arg1)->Update(arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_Update" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); { try { - (arg1)->Update(); + (arg1)->Update(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5057,47 +4733,6 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_ParBilinearForm_Update(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParBilinearForm_Update", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_Update__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_Update__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParBilinearForm_Update'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParBilinearForm::Update(mfem::FiniteElementSpace *)\n" - " mfem::ParBilinearForm::Update()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_ParBilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; @@ -5127,7 +4762,7 @@ SWIGINTERN PyObject *_wrap_delete_ParBilinearForm(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5136,7 +4771,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_5(PyObject *SW mfem::SparseMatrix *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5152,7 +4787,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_5(PyObject *SW void *argp7 = 0 ; int res7 = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); @@ -5206,108 +4841,17 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_5(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_SparseMatrix_Sg___SWIG_5(arg1,(mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + if (swig_obj[7]) { + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::SparseMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_SparseMatrix_Sg___SWIG_5(arg1,(mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_SparseMatrix_Sg___SWIG_3(arg1,(mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5335,128 +4879,28 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormSystemMatrix__SWIG_3(PyObject *SW if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); - { - try { - mfem_ParBilinearForm_FormSystemMatrix_Sl_mfem_SparseMatrix_Sg___SWIG_3(arg1,(mfem::Array< int > const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::HypreParMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - int arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__HypreParMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::HypreParMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::HypreParMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + arg1 = reinterpret_cast< mfem::ParBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { - mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_HypreParMatrix_Sg___SWIG_7(arg1,(mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); + mfem_ParBilinearForm_FormSystemMatrix_Sl_mfem_SparseMatrix_Sg___SWIG_3(arg1,(mfem::Array< int > const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5469,7 +4913,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_7(PyObject *SW } -SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParBilinearForm *arg1 = (mfem::ParBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5478,6 +4922,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_8(PyObject *SW mfem::HypreParMatrix *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5493,7 +4938,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_8(PyObject *SW void *argp7 = 0 ; int res7 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::ParBilinearForm *""'"); @@ -5547,9 +4992,17 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem__SWIG_8(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); + if (swig_obj[7]) { + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } + } { try { - mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_HypreParMatrix_Sg___SWIG_7(arg1,(mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + mfem_ParBilinearForm_FormLinearSystem_Sl_mfem_HypreParMatrix_Sg___SWIG_4(arg1,(mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5570,121 +5023,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb if (!(argc = SWIG_Python_UnpackTuple(args, "ParBilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_FormLinearSystem__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_FormLinearSystem__SWIG_6(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParBilinearForm_FormLinearSystem__SWIG_8(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); @@ -5713,6 +5052,9 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 7) { + return _wrap_ParBilinearForm_FormLinearSystem__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5732,7 +5074,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb } } } - if (argc == 8) { + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); @@ -5750,7 +5092,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; @@ -5761,6 +5103,9 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 7) { + return _wrap_ParBilinearForm_FormLinearSystem__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5770,7 +5115,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb } } if (_v) { - return _wrap_ParBilinearForm_FormLinearSystem__SWIG_7(self, argc, argv); + return _wrap_ParBilinearForm_FormLinearSystem__SWIG_3(self, argc, argv); } } } @@ -5780,7 +5125,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb } } } - if (argc == 8) { + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParBilinearForm, 0); @@ -5798,7 +5143,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__HypreParMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; @@ -5809,6 +5154,9 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 7) { + return _wrap_ParBilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5818,7 +5166,7 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb } } if (_v) { - return _wrap_ParBilinearForm_FormLinearSystem__SWIG_5(self, argc, argv); + return _wrap_ParBilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); } } } @@ -5834,11 +5182,8 @@ SWIGINTERN PyObject *_wrap_ParBilinearForm_FormLinearSystem(PyObject *self, PyOb " Possible C/C++ prototypes are:\n" " mfem::ParBilinearForm::FormLinearSystem()\n" " mfem::ParBilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::ParBilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &)\n" " mfem::ParBilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::ParBilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &)\n" - " mfem::ParBilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::ParBilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &)\n"); + " mfem::ParBilinearForm::FormLinearSystem< mfem::HypreParMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::HypreParMatrix &,mfem::Vector &,mfem::Vector &,int)\n"); return 0; } @@ -6215,7 +5560,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_ParallelAssemble(PyObject *self, } -SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -6229,15 +5574,21 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMixedBilinearForm_FormRectangularSystemMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParMixedBilinearForm_FormRectangularSystemMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "1"" of type '" "mfem::ParMixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParMixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -6245,7 +5596,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -6253,7 +5604,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); } @@ -6276,7 +5627,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix(PyOb } -SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -6302,15 +5653,25 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMixedBilinearForm_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:ParMixedBilinearForm_FormRectangularLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::ParMixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParMixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -6318,7 +5679,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -6326,7 +5687,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -6334,7 +5695,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -6342,7 +5703,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); } @@ -6350,7 +5711,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); } arg6 = reinterpret_cast< mfem::OperatorHandle * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -6358,7 +5719,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ParMixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -6381,12 +5742,12 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_FormRectangularLinearSystem(PyOb } -SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6395,14 +5756,21 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult__SWIG_0(PyObject *SW int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:ParMixedBilinearForm_TrueAddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "1"" of type '" "mfem::ParMixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParMixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6410,7 +5778,7 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult__SWIG_0(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6418,63 +5786,16 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult__SWIG_0(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::ParMixedBilinearForm const *)arg1)->TrueAddMult((mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "1"" of type '" "mfem::ParMixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParMixedBilinearForm_TrueAddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::ParMixedBilinearForm const *)arg1)->TrueAddMult((mfem::Vector const &)*arg2,*arg3); + ((mfem::ParMixedBilinearForm const *)arg1)->TrueAddMult((mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6487,66 +5808,6 @@ SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult__SWIG_1(PyObject *SW } -SWIGINTERN PyObject *_wrap_ParMixedBilinearForm_TrueAddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParMixedBilinearForm_TrueAddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMixedBilinearForm_TrueAddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParMixedBilinearForm_TrueAddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMixedBilinearForm_TrueAddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMixedBilinearForm::TrueAddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::ParMixedBilinearForm::TrueAddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_ParMixedBilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMixedBilinearForm *arg1 = (mfem::ParMixedBilinearForm *) 0 ; @@ -6587,7 +5848,7 @@ SWIGINTERN PyObject *ParMixedBilinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ParDiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ParDiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; @@ -6595,16 +5856,20 @@ SWIGINTERN PyObject *_wrap_new_ParDiscreteLinearOperator(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"dfes", (char *)"rfes", NULL + }; mfem::ParDiscreteLinearOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ParDiscreteLinearOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ParDiscreteLinearOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParDiscreteLinearOperator" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParDiscreteLinearOperator" "', argument " "2"" of type '" "mfem::ParFiniteElementSpace *""'"); } @@ -6654,7 +5919,7 @@ SWIGINTERN PyObject *_wrap_ParDiscreteLinearOperator_ParallelAssemble(PyObject * } -SWIGINTERN PyObject *_wrap_ParDiscreteLinearOperator_GetParBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParDiscreteLinearOperator_GetParBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParDiscreteLinearOperator *arg1 = (mfem::ParDiscreteLinearOperator *) 0 ; mfem::Array2D< mfem::HypreParMatrix * > *arg2 = 0 ; @@ -6662,15 +5927,19 @@ SWIGINTERN PyObject *_wrap_ParDiscreteLinearOperator_GetParBlocks(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blocks", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParDiscreteLinearOperator_GetParBlocks", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParDiscreteLinearOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParDiscreteLinearOperator_GetParBlocks", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParDiscreteLinearOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParDiscreteLinearOperator_GetParBlocks" "', argument " "1"" of type '" "mfem::ParDiscreteLinearOperator const *""'"); } arg1 = reinterpret_cast< mfem::ParDiscreteLinearOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__HypreParMatrix_p_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParDiscreteLinearOperator_GetParBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::HypreParMatrix * > &""'"); } @@ -6740,9 +6009,9 @@ static PyMethodDef SwigMethods[] = { "ParBilinearForm(ParFiniteElementSpace pf)\n" "new_ParBilinearForm(ParFiniteElementSpace pf, ParBilinearForm bf) -> ParBilinearForm\n" ""}, - { "ParBilinearForm_KeepNbrBlock", _wrap_ParBilinearForm_KeepNbrBlock, METH_VARARGS, "ParBilinearForm_KeepNbrBlock(ParBilinearForm self, bool knb=True)"}, - { "ParBilinearForm_SetOperatorType", _wrap_ParBilinearForm_SetOperatorType, METH_VARARGS, "ParBilinearForm_SetOperatorType(ParBilinearForm self, mfem::Operator::Type tid)"}, - { "ParBilinearForm_Assemble", _wrap_ParBilinearForm_Assemble, METH_VARARGS, "ParBilinearForm_Assemble(ParBilinearForm self, int skip_zeros=1)"}, + { "ParBilinearForm_KeepNbrBlock", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_KeepNbrBlock, METH_VARARGS|METH_KEYWORDS, "ParBilinearForm_KeepNbrBlock(ParBilinearForm self, bool knb=True)"}, + { "ParBilinearForm_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "ParBilinearForm_SetOperatorType(ParBilinearForm self, mfem::Operator::Type tid)"}, + { "ParBilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "ParBilinearForm_Assemble(ParBilinearForm self, int skip_zeros=1)"}, { "ParBilinearForm_ParallelAssembleElim", _wrap_ParBilinearForm_ParallelAssembleElim, METH_VARARGS, "\n" "ParBilinearForm_ParallelAssembleElim(ParBilinearForm self) -> HypreParMatrix\n" "ParBilinearForm_ParallelAssembleElim(ParBilinearForm self, OperatorHandle A_elim)\n" @@ -6757,14 +6026,14 @@ static PyMethodDef SwigMethods[] = { "ParBilinearForm_ParallelEliminateEssentialBC(ParBilinearForm self, intArray bdr_attr_is_ess, HypreParMatrix A, HypreParVector X, HypreParVector B)\n" "ParBilinearForm_ParallelEliminateEssentialBC(ParBilinearForm self, intArray bdr_attr_is_ess, HypreParMatrix A) -> HypreParMatrix\n" ""}, - { "ParBilinearForm_ParallelEliminateTDofs", _wrap_ParBilinearForm_ParallelEliminateTDofs, METH_VARARGS, "ParBilinearForm_ParallelEliminateTDofs(ParBilinearForm self, intArray tdofs_list, HypreParMatrix A) -> HypreParMatrix"}, - { "ParBilinearForm_TrueAddMult", _wrap_ParBilinearForm_TrueAddMult, METH_VARARGS, "ParBilinearForm_TrueAddMult(ParBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "ParBilinearForm_ParallelEliminateTDofs", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_ParallelEliminateTDofs, METH_VARARGS|METH_KEYWORDS, "ParBilinearForm_ParallelEliminateTDofs(ParBilinearForm self, intArray tdofs_list, HypreParMatrix A) -> HypreParMatrix"}, + { "ParBilinearForm_TrueAddMult", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_TrueAddMult, METH_VARARGS|METH_KEYWORDS, "ParBilinearForm_TrueAddMult(ParBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "ParBilinearForm_ParFESpace", _wrap_ParBilinearForm_ParFESpace, METH_O, "ParBilinearForm_ParFESpace(ParBilinearForm self) -> ParFiniteElementSpace"}, { "ParBilinearForm_SCParFESpace", _wrap_ParBilinearForm_SCParFESpace, METH_O, "ParBilinearForm_SCParFESpace(ParBilinearForm self) -> ParFiniteElementSpace"}, { "ParBilinearForm_GetProlongation", _wrap_ParBilinearForm_GetProlongation, METH_O, "ParBilinearForm_GetProlongation(ParBilinearForm self) -> Operator"}, { "ParBilinearForm_GetRestriction", _wrap_ParBilinearForm_GetRestriction, METH_O, "ParBilinearForm_GetRestriction(ParBilinearForm self) -> Operator"}, - { "ParBilinearForm_RecoverFEMSolution", _wrap_ParBilinearForm_RecoverFEMSolution, METH_VARARGS, "ParBilinearForm_RecoverFEMSolution(ParBilinearForm self, Vector X, Vector b, Vector x)"}, - { "ParBilinearForm_Update", _wrap_ParBilinearForm_Update, METH_VARARGS, "ParBilinearForm_Update(ParBilinearForm self, FiniteElementSpace nfes=None)"}, + { "ParBilinearForm_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "ParBilinearForm_RecoverFEMSolution(ParBilinearForm self, Vector X, Vector b, Vector x)"}, + { "ParBilinearForm_Update", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_Update, METH_VARARGS|METH_KEYWORDS, "ParBilinearForm_Update(ParBilinearForm self, FiniteElementSpace nfes=None)"}, { "delete_ParBilinearForm", _wrap_delete_ParBilinearForm, METH_O, "delete_ParBilinearForm(ParBilinearForm self)"}, { "ParBilinearForm_FormLinearSystem", _wrap_ParBilinearForm_FormLinearSystem, METH_VARARGS, "\n" "FormLinearSystem(ParBilinearForm self)\n" @@ -6788,15 +6057,15 @@ static PyMethodDef SwigMethods[] = { "ParMixedBilinearForm_ParallelAssemble(ParMixedBilinearForm self) -> HypreParMatrix\n" "ParMixedBilinearForm_ParallelAssemble(ParMixedBilinearForm self, OperatorHandle A)\n" ""}, - { "ParMixedBilinearForm_FormRectangularSystemMatrix", _wrap_ParMixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "ParMixedBilinearForm_FormRectangularSystemMatrix(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, - { "ParMixedBilinearForm_FormRectangularLinearSystem", _wrap_ParMixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "ParMixedBilinearForm_FormRectangularLinearSystem(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, - { "ParMixedBilinearForm_TrueAddMult", _wrap_ParMixedBilinearForm_TrueAddMult, METH_VARARGS, "ParMixedBilinearForm_TrueAddMult(ParMixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "ParMixedBilinearForm_FormRectangularSystemMatrix", (PyCFunction)(void(*)(void))_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS|METH_KEYWORDS, "ParMixedBilinearForm_FormRectangularSystemMatrix(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "ParMixedBilinearForm_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_ParMixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "ParMixedBilinearForm_FormRectangularLinearSystem(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "ParMixedBilinearForm_TrueAddMult", (PyCFunction)(void(*)(void))_wrap_ParMixedBilinearForm_TrueAddMult, METH_VARARGS|METH_KEYWORDS, "ParMixedBilinearForm_TrueAddMult(ParMixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "delete_ParMixedBilinearForm", _wrap_delete_ParMixedBilinearForm, METH_O, "delete_ParMixedBilinearForm(ParMixedBilinearForm self)"}, { "ParMixedBilinearForm_swigregister", ParMixedBilinearForm_swigregister, METH_O, NULL}, { "ParMixedBilinearForm_swiginit", ParMixedBilinearForm_swiginit, METH_VARARGS, NULL}, - { "new_ParDiscreteLinearOperator", _wrap_new_ParDiscreteLinearOperator, METH_VARARGS, "new_ParDiscreteLinearOperator(ParFiniteElementSpace dfes, ParFiniteElementSpace rfes) -> ParDiscreteLinearOperator"}, + { "new_ParDiscreteLinearOperator", (PyCFunction)(void(*)(void))_wrap_new_ParDiscreteLinearOperator, METH_VARARGS|METH_KEYWORDS, "new_ParDiscreteLinearOperator(ParFiniteElementSpace dfes, ParFiniteElementSpace rfes) -> ParDiscreteLinearOperator"}, { "ParDiscreteLinearOperator_ParallelAssemble", _wrap_ParDiscreteLinearOperator_ParallelAssemble, METH_O, "ParDiscreteLinearOperator_ParallelAssemble(ParDiscreteLinearOperator self) -> HypreParMatrix"}, - { "ParDiscreteLinearOperator_GetParBlocks", _wrap_ParDiscreteLinearOperator_GetParBlocks, METH_VARARGS, "ParDiscreteLinearOperator_GetParBlocks(ParDiscreteLinearOperator self, mfem::Array2D< mfem::HypreParMatrix * > & blocks)"}, + { "ParDiscreteLinearOperator_GetParBlocks", (PyCFunction)(void(*)(void))_wrap_ParDiscreteLinearOperator_GetParBlocks, METH_VARARGS|METH_KEYWORDS, "ParDiscreteLinearOperator_GetParBlocks(ParDiscreteLinearOperator self, mfem::Array2D< mfem::HypreParMatrix * > & blocks)"}, { "delete_ParDiscreteLinearOperator", _wrap_delete_ParDiscreteLinearOperator, METH_O, "delete_ParDiscreteLinearOperator(ParDiscreteLinearOperator self)"}, { "ParDiscreteLinearOperator_swigregister", ParDiscreteLinearOperator_swigregister, METH_O, NULL}, { "ParDiscreteLinearOperator_swiginit", ParDiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, @@ -6810,9 +6079,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ParBilinearForm(ParFiniteElementSpace pf)\n" "new_ParBilinearForm(ParFiniteElementSpace pf, ParBilinearForm bf) -> ParBilinearForm\n" ""}, - { "ParBilinearForm_KeepNbrBlock", _wrap_ParBilinearForm_KeepNbrBlock, METH_VARARGS, "KeepNbrBlock(ParBilinearForm self, bool knb=True)"}, - { "ParBilinearForm_SetOperatorType", _wrap_ParBilinearForm_SetOperatorType, METH_VARARGS, "SetOperatorType(ParBilinearForm self, mfem::Operator::Type tid)"}, - { "ParBilinearForm_Assemble", _wrap_ParBilinearForm_Assemble, METH_VARARGS, "Assemble(ParBilinearForm self, int skip_zeros=1)"}, + { "ParBilinearForm_KeepNbrBlock", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_KeepNbrBlock, METH_VARARGS|METH_KEYWORDS, "KeepNbrBlock(ParBilinearForm self, bool knb=True)"}, + { "ParBilinearForm_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "SetOperatorType(ParBilinearForm self, mfem::Operator::Type tid)"}, + { "ParBilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "Assemble(ParBilinearForm self, int skip_zeros=1)"}, { "ParBilinearForm_ParallelAssembleElim", _wrap_ParBilinearForm_ParallelAssembleElim, METH_VARARGS, "\n" "ParallelAssembleElim(ParBilinearForm self) -> HypreParMatrix\n" "ParallelAssembleElim(ParBilinearForm self, OperatorHandle A_elim)\n" @@ -6827,14 +6096,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ParallelEliminateEssentialBC(ParBilinearForm self, intArray bdr_attr_is_ess, HypreParMatrix A, HypreParVector X, HypreParVector B)\n" "ParallelEliminateEssentialBC(ParBilinearForm self, intArray bdr_attr_is_ess, HypreParMatrix A) -> HypreParMatrix\n" ""}, - { "ParBilinearForm_ParallelEliminateTDofs", _wrap_ParBilinearForm_ParallelEliminateTDofs, METH_VARARGS, "ParallelEliminateTDofs(ParBilinearForm self, intArray tdofs_list, HypreParMatrix A) -> HypreParMatrix"}, - { "ParBilinearForm_TrueAddMult", _wrap_ParBilinearForm_TrueAddMult, METH_VARARGS, "TrueAddMult(ParBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "ParBilinearForm_ParallelEliminateTDofs", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_ParallelEliminateTDofs, METH_VARARGS|METH_KEYWORDS, "ParallelEliminateTDofs(ParBilinearForm self, intArray tdofs_list, HypreParMatrix A) -> HypreParMatrix"}, + { "ParBilinearForm_TrueAddMult", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_TrueAddMult, METH_VARARGS|METH_KEYWORDS, "TrueAddMult(ParBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "ParBilinearForm_ParFESpace", _wrap_ParBilinearForm_ParFESpace, METH_O, "ParFESpace(ParBilinearForm self) -> ParFiniteElementSpace"}, { "ParBilinearForm_SCParFESpace", _wrap_ParBilinearForm_SCParFESpace, METH_O, "SCParFESpace(ParBilinearForm self) -> ParFiniteElementSpace"}, { "ParBilinearForm_GetProlongation", _wrap_ParBilinearForm_GetProlongation, METH_O, "GetProlongation(ParBilinearForm self) -> Operator"}, { "ParBilinearForm_GetRestriction", _wrap_ParBilinearForm_GetRestriction, METH_O, "GetRestriction(ParBilinearForm self) -> Operator"}, - { "ParBilinearForm_RecoverFEMSolution", _wrap_ParBilinearForm_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(ParBilinearForm self, Vector X, Vector b, Vector x)"}, - { "ParBilinearForm_Update", _wrap_ParBilinearForm_Update, METH_VARARGS, "Update(ParBilinearForm self, FiniteElementSpace nfes=None)"}, + { "ParBilinearForm_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "RecoverFEMSolution(ParBilinearForm self, Vector X, Vector b, Vector x)"}, + { "ParBilinearForm_Update", (PyCFunction)(void(*)(void))_wrap_ParBilinearForm_Update, METH_VARARGS|METH_KEYWORDS, "Update(ParBilinearForm self, FiniteElementSpace nfes=None)"}, { "delete_ParBilinearForm", _wrap_delete_ParBilinearForm, METH_O, "delete_ParBilinearForm(ParBilinearForm self)"}, { "ParBilinearForm_FormLinearSystem", _wrap_ParBilinearForm_FormLinearSystem, METH_VARARGS, "\n" "FormLinearSystem(ParBilinearForm self)\n" @@ -6858,15 +6127,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ParallelAssemble(ParMixedBilinearForm self) -> HypreParMatrix\n" "ParallelAssemble(ParMixedBilinearForm self, OperatorHandle A)\n" ""}, - { "ParMixedBilinearForm_FormRectangularSystemMatrix", _wrap_ParMixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "FormRectangularSystemMatrix(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, - { "ParMixedBilinearForm_FormRectangularLinearSystem", _wrap_ParMixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, - { "ParMixedBilinearForm_TrueAddMult", _wrap_ParMixedBilinearForm_TrueAddMult, METH_VARARGS, "TrueAddMult(ParMixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "ParMixedBilinearForm_FormRectangularSystemMatrix", (PyCFunction)(void(*)(void))_wrap_ParMixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS|METH_KEYWORDS, "FormRectangularSystemMatrix(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "ParMixedBilinearForm_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_ParMixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormRectangularLinearSystem(ParMixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "ParMixedBilinearForm_TrueAddMult", (PyCFunction)(void(*)(void))_wrap_ParMixedBilinearForm_TrueAddMult, METH_VARARGS|METH_KEYWORDS, "TrueAddMult(ParMixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "delete_ParMixedBilinearForm", _wrap_delete_ParMixedBilinearForm, METH_O, "delete_ParMixedBilinearForm(ParMixedBilinearForm self)"}, { "ParMixedBilinearForm_swigregister", ParMixedBilinearForm_swigregister, METH_O, NULL}, { "ParMixedBilinearForm_swiginit", ParMixedBilinearForm_swiginit, METH_VARARGS, NULL}, - { "new_ParDiscreteLinearOperator", _wrap_new_ParDiscreteLinearOperator, METH_VARARGS, "new_ParDiscreteLinearOperator(ParFiniteElementSpace dfes, ParFiniteElementSpace rfes) -> ParDiscreteLinearOperator"}, + { "new_ParDiscreteLinearOperator", (PyCFunction)(void(*)(void))_wrap_new_ParDiscreteLinearOperator, METH_VARARGS|METH_KEYWORDS, "new_ParDiscreteLinearOperator(ParFiniteElementSpace dfes, ParFiniteElementSpace rfes) -> ParDiscreteLinearOperator"}, { "ParDiscreteLinearOperator_ParallelAssemble", _wrap_ParDiscreteLinearOperator_ParallelAssemble, METH_O, "ParallelAssemble(ParDiscreteLinearOperator self) -> HypreParMatrix"}, - { "ParDiscreteLinearOperator_GetParBlocks", _wrap_ParDiscreteLinearOperator_GetParBlocks, METH_VARARGS, "GetParBlocks(ParDiscreteLinearOperator self, mfem::Array2D< mfem::HypreParMatrix * > & blocks)"}, + { "ParDiscreteLinearOperator_GetParBlocks", (PyCFunction)(void(*)(void))_wrap_ParDiscreteLinearOperator_GetParBlocks, METH_VARARGS|METH_KEYWORDS, "GetParBlocks(ParDiscreteLinearOperator self, mfem::Array2D< mfem::HypreParMatrix * > & blocks)"}, { "delete_ParDiscreteLinearOperator", _wrap_delete_ParDiscreteLinearOperator, METH_O, "delete_ParDiscreteLinearOperator(ParDiscreteLinearOperator self)"}, { "ParDiscreteLinearOperator_swigregister", ParDiscreteLinearOperator_swigregister, METH_O, NULL}, { "ParDiscreteLinearOperator_swiginit", ParDiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, @@ -8081,10 +7350,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pfespace.py b/mfem/_par/pfespace.py index eeddf25d..7f4c679f 100644 --- a/mfem/_par/pfespace.py +++ b/mfem/_par/pfespace.py @@ -205,9 +205,9 @@ def GetFaceDofs(self, i): - def GetFaceRestriction(self, *args): + def GetFaceRestriction(self, *args, **kwargs): r"""GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator""" - return _pfespace.ParFiniteElementSpace_GetFaceRestriction(self, *args) + return _pfespace.ParFiniteElementSpace_GetFaceRestriction(self, *args, **kwargs) GetFaceRestriction = _swig_new_instance_method(_pfespace.ParFiniteElementSpace_GetFaceRestriction) def GetSharedEdgeDofs(self, group, ei): diff --git a/mfem/_par/pfespace_wrap.cxx b/mfem/_par/pfespace_wrap.cxx index 3ded0775..e57a22ed 100644 --- a/mfem/_par/pfespace_wrap.cxx +++ b/mfem/_par/pfespace_wrap.cxx @@ -3872,8 +3872,8 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_send_face_nbr_ldof_get(PyObject SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = 0 ; - mfem::ParMesh *arg2 = (mfem::ParMesh *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; + mfem::ParMesh *arg2 = (mfem::ParMesh *) NULL ; + mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3882,7 +3882,7 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_0(PyObject *SWIGUNUSE int res3 = 0 ; mfem::ParFiniteElementSpace *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); @@ -3891,89 +3891,23 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::ParMesh *""'"); - } - arg2 = reinterpret_cast< mfem::ParMesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace((mfem::ParFiniteElementSpace const &)*arg1,arg2,(mfem::FiniteElementCollection const *)arg3); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::ParMesh *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg2 = reinterpret_cast< mfem::ParMesh * >(argp2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParFiniteElementSpace *arg1 = 0 ; - mfem::ParMesh *arg2 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::ParMesh *""'"); - } - arg2 = reinterpret_cast< mfem::ParMesh * >(argp2); - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace((mfem::ParFiniteElementSpace const &)*arg1,arg2); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParFiniteElementSpace *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace((mfem::ParFiniteElementSpace const &)*arg1); + result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace((mfem::ParFiniteElementSpace const &)*arg1,arg2,(mfem::FiniteElementCollection const *)arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3986,11 +3920,11 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_2(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::ParMesh *arg2 = 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; + mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3999,7 +3933,7 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_3(PyObject *SWIGUNUSE int res3 = 0 ; mfem::ParFiniteElementSpace *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); @@ -4016,56 +3950,16 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_3(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::ParMesh &""'"); } arg2 = reinterpret_cast< mfem::ParMesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,*arg2,(mfem::FiniteElementCollection const *)arg3); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::ParMesh *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParMesh, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::ParMesh &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::ParMesh &""'"); - } - arg2 = reinterpret_cast< mfem::ParMesh * >(argp2); { try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,*arg2); + result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,*arg2,(mfem::FiniteElementCollection const *)arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4078,12 +3972,12 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_4(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; int *arg3 = (int *) 0 ; - mfem::FiniteElementCollection *arg4 = (mfem::FiniteElementCollection *) 0 ; + mfem::FiniteElementCollection *arg4 = (mfem::FiniteElementCollection *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4094,7 +3988,7 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_5(PyObject *SWIGUNUSE int res4 = 0 ; mfem::ParFiniteElementSpace *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -4110,58 +4004,16 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_5(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "int const *""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ParFiniteElementSpace" "', argument " "4"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg4 = reinterpret_cast< mfem::FiniteElementCollection * >(argp4); - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,(mfem::FiniteElementSpace const *)arg2,(int const *)arg3,(mfem::FiniteElementCollection const *)arg4); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ParFiniteElementSpace" "', argument " "4"" of type '" "mfem::FiniteElementCollection const *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg4 = reinterpret_cast< mfem::FiniteElementCollection * >(argp4); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - int *arg3 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "int const *""'"); - } - arg3 = reinterpret_cast< int * >(argp3); { try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,(mfem::FiniteElementSpace const *)arg2,(int const *)arg3); + result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,(mfem::FiniteElementSpace const *)arg2,(int const *)arg3,(mfem::FiniteElementCollection const *)arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4174,19 +4026,19 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_6(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - int arg3 ; - int arg4 ; + int arg3 = (int) 1 ; + int arg4 = (int) mfem::Ordering::byNODES ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; mfem::ParFiniteElementSpace *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -4197,100 +4049,25 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_7(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); } arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3,arg4); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); { try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2); + result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4303,13 +4080,13 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_9(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - int arg4 ; - int arg5 ; + int arg4 = (int) 1 ; + int arg5 = (int) mfem::Ordering::byNODES ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4318,7 +4095,7 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_10(PyObject *SWIGUNUS int res3 = 0 ; mfem::ParFiniteElementSpace *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -4334,116 +4111,25 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_10(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); } arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4,arg5); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); - } - arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::ParFiniteElementSpace *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParFiniteElementSpace" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParFiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); } - arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParFiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); { try { - result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3); + result = (mfem::ParFiniteElementSpace *)new mfem::ParFiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4464,153 +4150,52 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a if (!(argc = SWIG_Python_UnpackTuple(args, "new_ParFiniteElementSpace", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_1(self, argc, argv); + if (argc <= 1) { + return _wrap_new_ParFiniteElementSpace__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_9(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { return _wrap_new_ParFiniteElementSpace__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_6(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_8(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_3(self, argc, argv); + return _wrap_new_ParFiniteElementSpace__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_ParFiniteElementSpace__SWIG_1(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_12(self, argc, argv); + return _wrap_new_ParFiniteElementSpace__SWIG_1(self, argc, argv); } } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -4620,6 +4205,9 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_ParFiniteElementSpace__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4629,35 +4217,9 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_7(self, argc, argv); + if (argc <= 3) { + return _wrap_new_ParFiniteElementSpace__SWIG_3(self, argc, argv); } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4667,13 +4229,13 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a } } if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_11(self, argc, argv); + return _wrap_new_ParFiniteElementSpace__SWIG_3(self, argc, argv); } } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -4687,17 +4249,20 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_new_ParFiniteElementSpace__SWIG_2(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_5(self, argc, argv); + return _wrap_new_ParFiniteElementSpace__SWIG_2(self, argc, argv); } } } } } - if (argc == 5) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -4711,6 +4276,9 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_new_ParFiniteElementSpace__SWIG_4(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4720,6 +4288,9 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a } } if (_v) { + if (argc <= 4) { + return _wrap_new_ParFiniteElementSpace__SWIG_4(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4729,7 +4300,7 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a } } if (_v) { - return _wrap_new_ParFiniteElementSpace__SWIG_10(self, argc, argv); + return _wrap_new_ParFiniteElementSpace__SWIG_4(self, argc, argv); } } } @@ -4741,18 +4312,10 @@ SWIGINTERN PyObject *_wrap_new_ParFiniteElementSpace(PyObject *self, PyObject *a SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ParFiniteElementSpace'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParFiniteElementSpace const &,mfem::ParMesh *,mfem::FiniteElementCollection const *)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParFiniteElementSpace const &,mfem::ParMesh *)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParFiniteElementSpace const &)\n" " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::FiniteElementSpace const &,mfem::ParMesh &,mfem::FiniteElementCollection const *)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::FiniteElementSpace const &,mfem::ParMesh &)\n" " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::FiniteElementSpace const *,int const *,mfem::FiniteElementCollection const *)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::FiniteElementSpace const *,int const *)\n" " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::FiniteElementCollection const *,int,int)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::FiniteElementCollection const *,int)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::FiniteElementCollection const *)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int,int)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int)\n" - " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *)\n"); + " mfem::ParFiniteElementSpace::ParFiniteElementSpace(mfem::ParMesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int,int)\n"); return 0; } @@ -4877,26 +4440,30 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetParMesh(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetDofSign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetDofSign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetDofSign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_GetDofSign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetDofSign" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5063,7 +4630,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetTrueVSize(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -5072,21 +4639,26 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetElementDofs(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetElementDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParFiniteElementSpace_GetElementDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetElementDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetElementDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5109,7 +4681,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetElementDofs(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -5118,21 +4690,26 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetBdrElementDofs(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetBdrElementDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParFiniteElementSpace_GetBdrElementDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetBdrElementDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetBdrElementDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5155,7 +4732,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetBdrElementDofs(PyObject *SWI } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -5164,21 +4741,26 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetFaceDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParFiniteElementSpace_GetFaceDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetFaceDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5201,12 +4783,12 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::ElementDofOrdering arg2 ; mfem::FaceType arg3 ; - mfem::L2FaceValues arg4 ; + mfem::L2FaceValues arg4 = (mfem::L2FaceValues) mfem::L2FaceValues::DoubleValued ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -5215,76 +4797,41 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_0(PyOb int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"e_ordering", (char *)"type", (char *)"mul", NULL + }; mfem::Operator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:ParFiniteElementSpace_GetFaceRestriction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } arg3 = static_cast< mfem::FaceType >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); - } - arg4 = static_cast< mfem::L2FaceValues >(val4); - { - try { - result = (mfem::Operator *)((mfem::ParFiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; - mfem::ElementDofOrdering arg2 ; - mfem::FaceType arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::Operator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParFiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); - } - arg3 = static_cast< mfem::FaceType >(val3); { try { - result = (mfem::Operator *)((mfem::ParFiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3); + result = (mfem::Operator *)((mfem::ParFiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5297,73 +4844,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_1(PyOb } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceRestriction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetFaceRestriction", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParFiniteElementSpace_GetFaceRestriction__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParFiniteElementSpace_GetFaceRestriction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParFiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues) const\n" - " mfem::ParFiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedEdgeDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedEdgeDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -5373,27 +4854,33 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedEdgeDofs(PyObject *SWI int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", (char *)"ei", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetSharedEdgeDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParFiniteElementSpace_GetSharedEdgeDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetSharedEdgeDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParFiniteElementSpace_GetSharedEdgeDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -5416,7 +4903,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedEdgeDofs(PyObject *SWI } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedTriangleDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedTriangleDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -5426,27 +4913,33 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedTriangleDofs(PyObject int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", (char *)"fi", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetSharedTriangleDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParFiniteElementSpace_GetSharedTriangleDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetSharedTriangleDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParFiniteElementSpace_GetSharedTriangleDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -5469,7 +4962,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedTriangleDofs(PyObject } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -5479,27 +4972,33 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs(PyOb int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", (char *)"fi", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetSharedQuadrilateralDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParFiniteElementSpace_GetSharedQuadrilateralDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetSharedQuadrilateralDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParFiniteElementSpace_GetSharedQuadrilateralDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -5612,7 +5111,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_NewTrueDofVector(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_DivideByGroupSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_DivideByGroupSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; double *arg2 = (double *) 0 ; @@ -5620,15 +5119,19 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_DivideByGroupSize(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_DivideByGroupSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_DivideByGroupSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_DivideByGroupSize" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_DivideByGroupSize" "', argument " "2"" of type '" "double *""'"); } @@ -5749,163 +5252,58 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_ScalarGroupComm(PyObject *SWIGU mfem::GroupCommunicator *result = 0 ; if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_ScalarGroupComm" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); - } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - { - try { - result = (mfem::GroupCommunicator *)(arg1)->ScalarGroupComm(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Synchronize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_Synchronize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_Synchronize" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_Synchronize" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_Synchronize" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - ((mfem::ParFiniteElementSpace const *)arg1)->Synchronize(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if (PyInt_Check(swig_obj[3])) { - arg4 = PyInt_AsLong(swig_obj[3]); - } else if ((PyArray_PyIntAsInt(swig_obj[3]) != -1) || !PyErr_Occurred()) { - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; - } + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_ScalarGroupComm" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } + arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { try { - ((mfem::ParFiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); + result = (mfem::GroupCommunicator *)(arg1)->ScalarGroupComm(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupCommunicator, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Synchronize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ldof_marker", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_Synchronize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_Synchronize" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_Synchronize" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_Synchronize" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::ParFiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3); + ((mfem::ParFiniteElementSpace const *)arg1)->Synchronize(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5918,113 +5316,63 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialVDofs__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialVDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetEssentialVDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParFiniteElementSpace_GetEssentialVDofs__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_ParFiniteElementSpace_GetEssentialVDofs__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParFiniteElementSpace_GetEssentialVDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParFiniteElementSpace::GetEssentialVDofs(mfem::Array< int > const &,mfem::Array< int > &,int) const\n" - " mfem::ParFiniteElementSpace::GetEssentialVDofs(mfem::Array< int > const &,mfem::Array< int > &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; - int arg4 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"ess_dofs", (char *)"component", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:ParFiniteElementSpace_GetEssentialVDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if (PyInt_Check(swig_obj[3])) { - arg4 = PyInt_AsLong(swig_obj[3]); - } else if ((PyArray_PyIntAsInt(swig_obj[3]) != -1) || !PyErr_Occurred()) { - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; + if (obj3) { + { + if (PyInt_Check(obj3)) { + arg4 = PyInt_AsLong(obj3); + } else if ((PyArray_PyIntAsInt(obj3) != -1) || !PyErr_Occurred()) { + arg4 = PyArray_PyIntAsInt(obj3); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } } } { try { - (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); + ((mfem::ParFiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6037,25 +5385,33 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_0(Py } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"ess_tdof_list", (char *)"component", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:ParFiniteElementSpace_GetEssentialTrueDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -6063,7 +5419,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_1(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6071,9 +5427,21 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_1(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (obj3) { + { + if (PyInt_Check(obj3)) { + arg4 = PyInt_AsLong(obj3); + } else if ((PyArray_PyIntAsInt(obj3) != -1) || !PyErr_Occurred()) { + arg4 = PyArray_PyIntAsInt(obj3); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } + } + } { try { - (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3); + (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6086,85 +5454,30 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_1(Py } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetEssentialTrueDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetEssentialTrueDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_ParFiniteElementSpace_GetEssentialTrueDofs__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParFiniteElementSpace_GetEssentialTrueDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParFiniteElementSpace::GetEssentialTrueDofs(mfem::Array< int > const &,mfem::Array< int > &,int)\n" - " mfem::ParFiniteElementSpace::GetEssentialTrueDofs(mfem::Array< int > const &,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetLocalTDofNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetLocalTDofNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ldof", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetLocalTDofNumber", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_GetLocalTDofNumber", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetLocalTDofNumber" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6181,26 +5494,30 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetLocalTDofNumber(PyObject *SW } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetGlobalTDofNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetGlobalTDofNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ldof", NULL + }; HYPRE_Int result; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetGlobalTDofNumber", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_GetGlobalTDofNumber", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetGlobalTDofNumber" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6217,26 +5534,30 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetGlobalTDofNumber(PyObject *S } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sldof", NULL + }; HYPRE_Int result; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetGlobalScalarTDofNumber", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_GetGlobalScalarTDofNumber", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetGlobalScalarTDofNumber" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6432,7 +5753,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrVSize(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -6441,21 +5762,26 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs(PyObject int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetFaceNbrElementVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParFiniteElementSpace_GetFaceNbrElementVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceNbrElementVDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetFaceNbrElementVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6478,7 +5804,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs(PyObject } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; @@ -6487,21 +5813,26 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs(PyObject *S int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetFaceNbrFaceVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParFiniteElementSpace_GetFaceNbrFaceVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceNbrFaceVDofs" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetFaceNbrFaceVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6524,26 +5855,30 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs(PyObject *S } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetFaceNbrFE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_GetFaceNbrFE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceNbrFE" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6560,26 +5895,30 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFE(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFaceFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetFaceNbrFaceFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetFaceNbrFaceFE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParFiniteElementSpace_GetFaceNbrFaceFE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetFaceNbrFaceFE" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6773,7 +6112,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Nonconforming(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetTrueTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetTrueTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -6784,15 +6123,20 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetTrueTransferOperator(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"coarse_fes", (char *)"T", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_GetTrueTransferOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParFiniteElementSpace_GetTrueTransferOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_GetTrueTransferOperator" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParFiniteElementSpace_GetTrueTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -6800,7 +6144,7 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetTrueTransferOperator(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParFiniteElementSpace_GetTrueTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParFiniteElementSpace_GetTrueTransferOperator" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -6823,56 +6167,36 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_GetTrueTransferOperator(PyObjec } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"want_transform", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ParFiniteElementSpace_Update", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_Update" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParFiniteElementSpace_Update" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->Update(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParFiniteElementSpace_Update" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParFiniteElementSpace_Update" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); { try { - (arg1)->Update(); + (arg1)->Update(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6885,48 +6209,6 @@ SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Update__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_Update(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParFiniteElementSpace_Update", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParFiniteElementSpace_Update__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParFiniteElementSpace_Update__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParFiniteElementSpace_Update'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParFiniteElementSpace::Update(bool)\n" - " mfem::ParFiniteElementSpace::Update()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ParFiniteElementSpace_UpdatesFinished(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; @@ -7055,17 +6337,19 @@ SWIGINTERN PyObject *ParFiniteElementSpace_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ConformingProlongationOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ConformingProlongationOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"pfes", NULL + }; mfem::ConformingProlongationOperator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ConformingProlongationOperator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConformingProlongationOperator" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); } @@ -7088,7 +6372,7 @@ SWIGINTERN PyObject *_wrap_new_ConformingProlongationOperator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConformingProlongationOperator *arg1 = (mfem::ConformingProlongationOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7099,15 +6383,20 @@ SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_Mult(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConformingProlongationOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConformingProlongationOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConformingProlongationOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConformingProlongationOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConformingProlongationOperator_Mult" "', argument " "1"" of type '" "mfem::ConformingProlongationOperator const *""'"); } arg1 = reinterpret_cast< mfem::ConformingProlongationOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConformingProlongationOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7115,7 +6404,7 @@ SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_Mult(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConformingProlongationOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConformingProlongationOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7138,7 +6427,7 @@ SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_Mult(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConformingProlongationOperator *arg1 = (mfem::ConformingProlongationOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7149,15 +6438,20 @@ SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_MultTranspose(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConformingProlongationOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConformingProlongationOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConformingProlongationOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConformingProlongationOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConformingProlongationOperator_MultTranspose" "', argument " "1"" of type '" "mfem::ConformingProlongationOperator const *""'"); } arg1 = reinterpret_cast< mfem::ConformingProlongationOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConformingProlongationOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7165,7 +6459,7 @@ SWIGINTERN PyObject *_wrap_ConformingProlongationOperator_MultTranspose(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConformingProlongationOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConformingProlongationOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7228,17 +6522,19 @@ SWIGINTERN PyObject *ConformingProlongationOperator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DeviceConformingProlongationOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DeviceConformingProlongationOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"pfes", NULL + }; mfem::DeviceConformingProlongationOperator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_DeviceConformingProlongationOperator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeviceConformingProlongationOperator" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); } @@ -7290,7 +6586,7 @@ SWIGINTERN PyObject *_wrap_delete_DeviceConformingProlongationOperator(PyObject } -SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeviceConformingProlongationOperator *arg1 = (mfem::DeviceConformingProlongationOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7301,15 +6597,20 @@ SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_Mult(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeviceConformingProlongationOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeviceConformingProlongationOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "1"" of type '" "mfem::DeviceConformingProlongationOperator const *""'"); } arg1 = reinterpret_cast< mfem::DeviceConformingProlongationOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7317,7 +6618,7 @@ SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_Mult(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeviceConformingProlongationOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7340,7 +6641,7 @@ SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_Mult(PyObject *S } -SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeviceConformingProlongationOperator *arg1 = (mfem::DeviceConformingProlongationOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7351,15 +6652,20 @@ SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_MultTranspose(Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeviceConformingProlongationOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeviceConformingProlongationOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeviceConformingProlongationOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "1"" of type '" "mfem::DeviceConformingProlongationOperator const *""'"); } arg1 = reinterpret_cast< mfem::DeviceConformingProlongationOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7367,7 +6673,7 @@ SWIGINTERN PyObject *_wrap_DeviceConformingProlongationOperator_MultTranspose(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeviceConformingProlongationOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7418,74 +6724,74 @@ static PyMethodDef SwigMethods[] = { "ParFiniteElementSpace(FiniteElementSpace orig, ParMesh pmesh, FiniteElementCollection fec=None)\n" "ParFiniteElementSpace(ParMesh pm, FiniteElementSpace global_fes, int const * partitioning, FiniteElementCollection f=None)\n" "ParFiniteElementSpace(ParMesh pm, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" - "ParFiniteElementSpace(ParMesh pm, mfem::NURBSExtension * ext, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" + "new_ParFiniteElementSpace(ParMesh pm, mfem::NURBSExtension * ext, FiniteElementCollection f, int dim=1, int ordering=byNODES) -> ParFiniteElementSpace\n" ""}, { "ParFiniteElementSpace_GetComm", _wrap_ParFiniteElementSpace_GetComm, METH_O, "ParFiniteElementSpace_GetComm(ParFiniteElementSpace self) -> MPI_Comm"}, { "ParFiniteElementSpace_GetNRanks", _wrap_ParFiniteElementSpace_GetNRanks, METH_O, "ParFiniteElementSpace_GetNRanks(ParFiniteElementSpace self) -> int"}, { "ParFiniteElementSpace_GetMyRank", _wrap_ParFiniteElementSpace_GetMyRank, METH_O, "ParFiniteElementSpace_GetMyRank(ParFiniteElementSpace self) -> int"}, { "ParFiniteElementSpace_GetParMesh", _wrap_ParFiniteElementSpace_GetParMesh, METH_O, "ParFiniteElementSpace_GetParMesh(ParFiniteElementSpace self) -> ParMesh"}, - { "ParFiniteElementSpace_GetDofSign", _wrap_ParFiniteElementSpace_GetDofSign, METH_VARARGS, "ParFiniteElementSpace_GetDofSign(ParFiniteElementSpace self, int i) -> int"}, + { "ParFiniteElementSpace_GetDofSign", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetDofSign, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetDofSign(ParFiniteElementSpace self, int i) -> int"}, { "ParFiniteElementSpace_GetDofOffsets", _wrap_ParFiniteElementSpace_GetDofOffsets, METH_O, "ParFiniteElementSpace_GetDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, { "ParFiniteElementSpace_GetTrueDofOffsets", _wrap_ParFiniteElementSpace_GetTrueDofOffsets, METH_O, "ParFiniteElementSpace_GetTrueDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, { "ParFiniteElementSpace_GlobalVSize", _wrap_ParFiniteElementSpace_GlobalVSize, METH_O, "ParFiniteElementSpace_GlobalVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GlobalTrueVSize", _wrap_ParFiniteElementSpace_GlobalTrueVSize, METH_O, "ParFiniteElementSpace_GlobalTrueVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetTrueVSize", _wrap_ParFiniteElementSpace_GetTrueVSize, METH_O, "ParFiniteElementSpace_GetTrueVSize(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetElementDofs", _wrap_ParFiniteElementSpace_GetElementDofs, METH_VARARGS, "ParFiniteElementSpace_GetElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetBdrElementDofs", _wrap_ParFiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "ParFiniteElementSpace_GetBdrElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetFaceDofs", _wrap_ParFiniteElementSpace_GetFaceDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetFaceRestriction", _wrap_ParFiniteElementSpace_GetFaceRestriction, METH_VARARGS, "ParFiniteElementSpace_GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, - { "ParFiniteElementSpace_GetSharedEdgeDofs", _wrap_ParFiniteElementSpace_GetSharedEdgeDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedEdgeDofs(ParFiniteElementSpace self, int group, int ei, intArray dofs)"}, - { "ParFiniteElementSpace_GetSharedTriangleDofs", _wrap_ParFiniteElementSpace_GetSharedTriangleDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, - { "ParFiniteElementSpace_GetSharedQuadrilateralDofs", _wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs, METH_VARARGS, "ParFiniteElementSpace_GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_GetElementDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetElementDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetBdrElementDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetBdrElementDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetBdrElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetFaceDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceRestriction", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceRestriction, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "ParFiniteElementSpace_GetSharedEdgeDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetSharedEdgeDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetSharedEdgeDofs(ParFiniteElementSpace self, int group, int ei, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedTriangleDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetSharedTriangleDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedQuadrilateralDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, { "ParFiniteElementSpace_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Dof_TrueDof_Matrix, METH_O, "ParFiniteElementSpace_Dof_TrueDof_Matrix(ParFiniteElementSpace self) -> HypreParMatrix"}, { "ParFiniteElementSpace_GetPartialConformingInterpolation", _wrap_ParFiniteElementSpace_GetPartialConformingInterpolation, METH_O, "ParFiniteElementSpace_GetPartialConformingInterpolation(ParFiniteElementSpace self) -> HypreParMatrix"}, { "ParFiniteElementSpace_NewTrueDofVector", _wrap_ParFiniteElementSpace_NewTrueDofVector, METH_O, "ParFiniteElementSpace_NewTrueDofVector(ParFiniteElementSpace self) -> HypreParVector"}, - { "ParFiniteElementSpace_DivideByGroupSize", _wrap_ParFiniteElementSpace_DivideByGroupSize, METH_VARARGS, "ParFiniteElementSpace_DivideByGroupSize(ParFiniteElementSpace self, double * vec)"}, + { "ParFiniteElementSpace_DivideByGroupSize", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_DivideByGroupSize, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_DivideByGroupSize(ParFiniteElementSpace self, double * vec)"}, { "ParFiniteElementSpace_GroupComm", _wrap_ParFiniteElementSpace_GroupComm, METH_VARARGS, "\n" "ParFiniteElementSpace_GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" "ParFiniteElementSpace_GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" ""}, { "ParFiniteElementSpace_ScalarGroupComm", _wrap_ParFiniteElementSpace_ScalarGroupComm, METH_O, "ParFiniteElementSpace_ScalarGroupComm(ParFiniteElementSpace self) -> GroupCommunicator"}, - { "ParFiniteElementSpace_Synchronize", _wrap_ParFiniteElementSpace_Synchronize, METH_VARARGS, "ParFiniteElementSpace_Synchronize(ParFiniteElementSpace self, intArray ldof_marker)"}, - { "ParFiniteElementSpace_GetEssentialVDofs", _wrap_ParFiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "ParFiniteElementSpace_GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)"}, - { "ParFiniteElementSpace_GetEssentialTrueDofs", _wrap_ParFiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "ParFiniteElementSpace_GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, - { "ParFiniteElementSpace_GetLocalTDofNumber", _wrap_ParFiniteElementSpace_GetLocalTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int"}, - { "ParFiniteElementSpace_GetGlobalTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GetGlobalScalarTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber, METH_VARARGS, "ParFiniteElementSpace_GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_Synchronize", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_Synchronize, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_Synchronize(ParFiniteElementSpace self, intArray ldof_marker)"}, + { "ParFiniteElementSpace_GetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)"}, + { "ParFiniteElementSpace_GetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "ParFiniteElementSpace_GetLocalTDofNumber", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetLocalTDofNumber, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int"}, + { "ParFiniteElementSpace_GetGlobalTDofNumber", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetGlobalTDofNumber, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetGlobalScalarTDofNumber", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetMyDofOffset", _wrap_ParFiniteElementSpace_GetMyDofOffset, METH_O, "ParFiniteElementSpace_GetMyDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetMyTDofOffset", _wrap_ParFiniteElementSpace_GetMyTDofOffset, METH_O, "ParFiniteElementSpace_GetMyTDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetProlongationMatrix", _wrap_ParFiniteElementSpace_GetProlongationMatrix, METH_O, "ParFiniteElementSpace_GetProlongationMatrix(ParFiniteElementSpace self) -> Operator"}, { "ParFiniteElementSpace_GetRestrictionMatrix", _wrap_ParFiniteElementSpace_GetRestrictionMatrix, METH_O, "ParFiniteElementSpace_GetRestrictionMatrix(ParFiniteElementSpace self) -> SparseMatrix"}, { "ParFiniteElementSpace_ExchangeFaceNbrData", _wrap_ParFiniteElementSpace_ExchangeFaceNbrData, METH_O, "ParFiniteElementSpace_ExchangeFaceNbrData(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_GetFaceNbrVSize", _wrap_ParFiniteElementSpace_GetFaceNbrVSize, METH_O, "ParFiniteElementSpace_GetFaceNbrVSize(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetFaceNbrElementVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, - { "ParFiniteElementSpace_GetFaceNbrFaceVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, - { "ParFiniteElementSpace_GetFaceNbrFE", _wrap_ParFiniteElementSpace_GetFaceNbrFE, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, - { "ParFiniteElementSpace_GetFaceNbrFaceFE", _wrap_ParFiniteElementSpace_GetFaceNbrFaceFE, METH_VARARGS, "ParFiniteElementSpace_GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrElementVDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFaceVDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFE", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrFE, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrFaceFE", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrFaceFE, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, { "ParFiniteElementSpace_GetFaceNbrGlobalDofMap", _wrap_ParFiniteElementSpace_GetFaceNbrGlobalDofMap, METH_O, "ParFiniteElementSpace_GetFaceNbrGlobalDofMap(ParFiniteElementSpace self) -> HYPRE_Int const *"}, { "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix, METH_O, "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_LoseDofOffsets", _wrap_ParFiniteElementSpace_LoseDofOffsets, METH_O, "ParFiniteElementSpace_LoseDofOffsets(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_LoseTrueDofOffsets", _wrap_ParFiniteElementSpace_LoseTrueDofOffsets, METH_O, "ParFiniteElementSpace_LoseTrueDofOffsets(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_Conforming", _wrap_ParFiniteElementSpace_Conforming, METH_O, "ParFiniteElementSpace_Conforming(ParFiniteElementSpace self) -> bool"}, { "ParFiniteElementSpace_Nonconforming", _wrap_ParFiniteElementSpace_Nonconforming, METH_O, "ParFiniteElementSpace_Nonconforming(ParFiniteElementSpace self) -> bool"}, - { "ParFiniteElementSpace_GetTrueTransferOperator", _wrap_ParFiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "ParFiniteElementSpace_GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "ParFiniteElementSpace_Update", _wrap_ParFiniteElementSpace_Update, METH_VARARGS, "ParFiniteElementSpace_Update(ParFiniteElementSpace self, bool want_transform=True)"}, + { "ParFiniteElementSpace_GetTrueTransferOperator", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetTrueTransferOperator, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "ParFiniteElementSpace_Update", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_Update, METH_VARARGS|METH_KEYWORDS, "ParFiniteElementSpace_Update(ParFiniteElementSpace self, bool want_transform=True)"}, { "ParFiniteElementSpace_UpdatesFinished", _wrap_ParFiniteElementSpace_UpdatesFinished, METH_O, "ParFiniteElementSpace_UpdatesFinished(ParFiniteElementSpace self)"}, { "delete_ParFiniteElementSpace", _wrap_delete_ParFiniteElementSpace, METH_O, "delete_ParFiniteElementSpace(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_PrintPartitionStats", _wrap_ParFiniteElementSpace_PrintPartitionStats, METH_O, "ParFiniteElementSpace_PrintPartitionStats(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_TrueVSize", _wrap_ParFiniteElementSpace_TrueVSize, METH_O, "ParFiniteElementSpace_TrueVSize(ParFiniteElementSpace self) -> int"}, { "ParFiniteElementSpace_swigregister", ParFiniteElementSpace_swigregister, METH_O, NULL}, { "ParFiniteElementSpace_swiginit", ParFiniteElementSpace_swiginit, METH_VARARGS, NULL}, - { "new_ConformingProlongationOperator", _wrap_new_ConformingProlongationOperator, METH_O, "new_ConformingProlongationOperator(ParFiniteElementSpace pfes) -> ConformingProlongationOperator"}, - { "ConformingProlongationOperator_Mult", _wrap_ConformingProlongationOperator_Mult, METH_VARARGS, "ConformingProlongationOperator_Mult(ConformingProlongationOperator self, Vector x, Vector y)"}, - { "ConformingProlongationOperator_MultTranspose", _wrap_ConformingProlongationOperator_MultTranspose, METH_VARARGS, "ConformingProlongationOperator_MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "new_ConformingProlongationOperator", (PyCFunction)(void(*)(void))_wrap_new_ConformingProlongationOperator, METH_VARARGS|METH_KEYWORDS, "new_ConformingProlongationOperator(ParFiniteElementSpace pfes) -> ConformingProlongationOperator"}, + { "ConformingProlongationOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ConformingProlongationOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ConformingProlongationOperator_Mult(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "ConformingProlongationOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ConformingProlongationOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ConformingProlongationOperator_MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)"}, { "delete_ConformingProlongationOperator", _wrap_delete_ConformingProlongationOperator, METH_O, "delete_ConformingProlongationOperator(ConformingProlongationOperator self)"}, { "ConformingProlongationOperator_swigregister", ConformingProlongationOperator_swigregister, METH_O, NULL}, { "ConformingProlongationOperator_swiginit", ConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, - { "new_DeviceConformingProlongationOperator", _wrap_new_DeviceConformingProlongationOperator, METH_O, "new_DeviceConformingProlongationOperator(ParFiniteElementSpace pfes) -> DeviceConformingProlongationOperator"}, + { "new_DeviceConformingProlongationOperator", (PyCFunction)(void(*)(void))_wrap_new_DeviceConformingProlongationOperator, METH_VARARGS|METH_KEYWORDS, "new_DeviceConformingProlongationOperator(ParFiniteElementSpace pfes) -> DeviceConformingProlongationOperator"}, { "delete_DeviceConformingProlongationOperator", _wrap_delete_DeviceConformingProlongationOperator, METH_O, "delete_DeviceConformingProlongationOperator(DeviceConformingProlongationOperator self)"}, - { "DeviceConformingProlongationOperator_Mult", _wrap_DeviceConformingProlongationOperator_Mult, METH_VARARGS, "DeviceConformingProlongationOperator_Mult(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, - { "DeviceConformingProlongationOperator_MultTranspose", _wrap_DeviceConformingProlongationOperator_MultTranspose, METH_VARARGS, "DeviceConformingProlongationOperator_MultTranspose(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_Mult", (PyCFunction)(void(*)(void))_wrap_DeviceConformingProlongationOperator_Mult, METH_VARARGS|METH_KEYWORDS, "DeviceConformingProlongationOperator_Mult(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_DeviceConformingProlongationOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "DeviceConformingProlongationOperator_MultTranspose(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, { "DeviceConformingProlongationOperator_swigregister", DeviceConformingProlongationOperator_swigregister, METH_O, NULL}, { "DeviceConformingProlongationOperator_swiginit", DeviceConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -7508,74 +6814,74 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ParFiniteElementSpace(FiniteElementSpace orig, ParMesh pmesh, FiniteElementCollection fec=None)\n" "ParFiniteElementSpace(ParMesh pm, FiniteElementSpace global_fes, int const * partitioning, FiniteElementCollection f=None)\n" "ParFiniteElementSpace(ParMesh pm, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" - "ParFiniteElementSpace(ParMesh pm, mfem::NURBSExtension * ext, FiniteElementCollection f, int dim=1, int ordering=byNODES)\n" + "new_ParFiniteElementSpace(ParMesh pm, mfem::NURBSExtension * ext, FiniteElementCollection f, int dim=1, int ordering=byNODES) -> ParFiniteElementSpace\n" ""}, { "ParFiniteElementSpace_GetComm", _wrap_ParFiniteElementSpace_GetComm, METH_O, "GetComm(ParFiniteElementSpace self) -> MPI_Comm"}, { "ParFiniteElementSpace_GetNRanks", _wrap_ParFiniteElementSpace_GetNRanks, METH_O, "GetNRanks(ParFiniteElementSpace self) -> int"}, { "ParFiniteElementSpace_GetMyRank", _wrap_ParFiniteElementSpace_GetMyRank, METH_O, "GetMyRank(ParFiniteElementSpace self) -> int"}, { "ParFiniteElementSpace_GetParMesh", _wrap_ParFiniteElementSpace_GetParMesh, METH_O, "GetParMesh(ParFiniteElementSpace self) -> ParMesh"}, - { "ParFiniteElementSpace_GetDofSign", _wrap_ParFiniteElementSpace_GetDofSign, METH_VARARGS, "GetDofSign(ParFiniteElementSpace self, int i) -> int"}, + { "ParFiniteElementSpace_GetDofSign", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetDofSign, METH_VARARGS|METH_KEYWORDS, "GetDofSign(ParFiniteElementSpace self, int i) -> int"}, { "ParFiniteElementSpace_GetDofOffsets", _wrap_ParFiniteElementSpace_GetDofOffsets, METH_O, "GetDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, { "ParFiniteElementSpace_GetTrueDofOffsets", _wrap_ParFiniteElementSpace_GetTrueDofOffsets, METH_O, "GetTrueDofOffsets(ParFiniteElementSpace self) -> HYPRE_Int *"}, { "ParFiniteElementSpace_GlobalVSize", _wrap_ParFiniteElementSpace_GlobalVSize, METH_O, "GlobalVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GlobalTrueVSize", _wrap_ParFiniteElementSpace_GlobalTrueVSize, METH_O, "GlobalTrueVSize(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetTrueVSize", _wrap_ParFiniteElementSpace_GetTrueVSize, METH_O, "GetTrueVSize(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetElementDofs", _wrap_ParFiniteElementSpace_GetElementDofs, METH_VARARGS, "GetElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetBdrElementDofs", _wrap_ParFiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "GetBdrElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetFaceDofs", _wrap_ParFiniteElementSpace_GetFaceDofs, METH_VARARGS, "GetFaceDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, - { "ParFiniteElementSpace_GetFaceRestriction", _wrap_ParFiniteElementSpace_GetFaceRestriction, METH_VARARGS, "GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, - { "ParFiniteElementSpace_GetSharedEdgeDofs", _wrap_ParFiniteElementSpace_GetSharedEdgeDofs, METH_VARARGS, "GetSharedEdgeDofs(ParFiniteElementSpace self, int group, int ei, intArray dofs)"}, - { "ParFiniteElementSpace_GetSharedTriangleDofs", _wrap_ParFiniteElementSpace_GetSharedTriangleDofs, METH_VARARGS, "GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, - { "ParFiniteElementSpace_GetSharedQuadrilateralDofs", _wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs, METH_VARARGS, "GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_GetElementDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetElementDofs, METH_VARARGS|METH_KEYWORDS, "GetElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetBdrElementDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetBdrElementDofs, METH_VARARGS|METH_KEYWORDS, "GetBdrElementDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(ParFiniteElementSpace self, int i, intArray dofs)"}, + { "ParFiniteElementSpace_GetFaceRestriction", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceRestriction, METH_VARARGS|METH_KEYWORDS, "GetFaceRestriction(ParFiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType type, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "ParFiniteElementSpace_GetSharedEdgeDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetSharedEdgeDofs, METH_VARARGS|METH_KEYWORDS, "GetSharedEdgeDofs(ParFiniteElementSpace self, int group, int ei, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedTriangleDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetSharedTriangleDofs, METH_VARARGS|METH_KEYWORDS, "GetSharedTriangleDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, + { "ParFiniteElementSpace_GetSharedQuadrilateralDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetSharedQuadrilateralDofs, METH_VARARGS|METH_KEYWORDS, "GetSharedQuadrilateralDofs(ParFiniteElementSpace self, int group, int fi, intArray dofs)"}, { "ParFiniteElementSpace_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Dof_TrueDof_Matrix, METH_O, "Dof_TrueDof_Matrix(ParFiniteElementSpace self) -> HypreParMatrix"}, { "ParFiniteElementSpace_GetPartialConformingInterpolation", _wrap_ParFiniteElementSpace_GetPartialConformingInterpolation, METH_O, "GetPartialConformingInterpolation(ParFiniteElementSpace self) -> HypreParMatrix"}, { "ParFiniteElementSpace_NewTrueDofVector", _wrap_ParFiniteElementSpace_NewTrueDofVector, METH_O, "NewTrueDofVector(ParFiniteElementSpace self) -> HypreParVector"}, - { "ParFiniteElementSpace_DivideByGroupSize", _wrap_ParFiniteElementSpace_DivideByGroupSize, METH_VARARGS, "DivideByGroupSize(ParFiniteElementSpace self, double * vec)"}, + { "ParFiniteElementSpace_DivideByGroupSize", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_DivideByGroupSize, METH_VARARGS|METH_KEYWORDS, "DivideByGroupSize(ParFiniteElementSpace self, double * vec)"}, { "ParFiniteElementSpace_GroupComm", _wrap_ParFiniteElementSpace_GroupComm, METH_VARARGS, "\n" "GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" "GroupComm(ParFiniteElementSpace self) -> GroupCommunicator\n" ""}, { "ParFiniteElementSpace_ScalarGroupComm", _wrap_ParFiniteElementSpace_ScalarGroupComm, METH_O, "ScalarGroupComm(ParFiniteElementSpace self) -> GroupCommunicator"}, - { "ParFiniteElementSpace_Synchronize", _wrap_ParFiniteElementSpace_Synchronize, METH_VARARGS, "Synchronize(ParFiniteElementSpace self, intArray ldof_marker)"}, - { "ParFiniteElementSpace_GetEssentialVDofs", _wrap_ParFiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)"}, - { "ParFiniteElementSpace_GetEssentialTrueDofs", _wrap_ParFiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, - { "ParFiniteElementSpace_GetLocalTDofNumber", _wrap_ParFiniteElementSpace_GetLocalTDofNumber, METH_VARARGS, "GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int"}, - { "ParFiniteElementSpace_GetGlobalTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalTDofNumber, METH_VARARGS, "GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int"}, - { "ParFiniteElementSpace_GetGlobalScalarTDofNumber", _wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber, METH_VARARGS, "GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_Synchronize", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_Synchronize, METH_VARARGS|METH_KEYWORDS, "Synchronize(ParFiniteElementSpace self, intArray ldof_marker)"}, + { "ParFiniteElementSpace_GetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "GetEssentialVDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_dofs, int component=-1)"}, + { "ParFiniteElementSpace_GetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "GetEssentialTrueDofs(ParFiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "ParFiniteElementSpace_GetLocalTDofNumber", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetLocalTDofNumber, METH_VARARGS|METH_KEYWORDS, "GetLocalTDofNumber(ParFiniteElementSpace self, int ldof) -> int"}, + { "ParFiniteElementSpace_GetGlobalTDofNumber", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetGlobalTDofNumber, METH_VARARGS|METH_KEYWORDS, "GetGlobalTDofNumber(ParFiniteElementSpace self, int ldof) -> HYPRE_Int"}, + { "ParFiniteElementSpace_GetGlobalScalarTDofNumber", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetGlobalScalarTDofNumber, METH_VARARGS|METH_KEYWORDS, "GetGlobalScalarTDofNumber(ParFiniteElementSpace self, int sldof) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetMyDofOffset", _wrap_ParFiniteElementSpace_GetMyDofOffset, METH_O, "GetMyDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetMyTDofOffset", _wrap_ParFiniteElementSpace_GetMyTDofOffset, METH_O, "GetMyTDofOffset(ParFiniteElementSpace self) -> HYPRE_Int"}, { "ParFiniteElementSpace_GetProlongationMatrix", _wrap_ParFiniteElementSpace_GetProlongationMatrix, METH_O, "GetProlongationMatrix(ParFiniteElementSpace self) -> Operator"}, { "ParFiniteElementSpace_GetRestrictionMatrix", _wrap_ParFiniteElementSpace_GetRestrictionMatrix, METH_O, "GetRestrictionMatrix(ParFiniteElementSpace self) -> SparseMatrix"}, { "ParFiniteElementSpace_ExchangeFaceNbrData", _wrap_ParFiniteElementSpace_ExchangeFaceNbrData, METH_O, "ExchangeFaceNbrData(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_GetFaceNbrVSize", _wrap_ParFiniteElementSpace_GetFaceNbrVSize, METH_O, "GetFaceNbrVSize(ParFiniteElementSpace self) -> int"}, - { "ParFiniteElementSpace_GetFaceNbrElementVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs, METH_VARARGS, "GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, - { "ParFiniteElementSpace_GetFaceNbrFaceVDofs", _wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs, METH_VARARGS, "GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, - { "ParFiniteElementSpace_GetFaceNbrFE", _wrap_ParFiniteElementSpace_GetFaceNbrFE, METH_VARARGS, "GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, - { "ParFiniteElementSpace_GetFaceNbrFaceFE", _wrap_ParFiniteElementSpace_GetFaceNbrFaceFE, METH_VARARGS, "GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrElementVDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrElementVDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceNbrElementVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFaceVDofs", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrFaceVDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceNbrFaceVDofs(ParFiniteElementSpace self, int i, intArray vdofs)"}, + { "ParFiniteElementSpace_GetFaceNbrFE", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrFE, METH_VARARGS|METH_KEYWORDS, "GetFaceNbrFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, + { "ParFiniteElementSpace_GetFaceNbrFaceFE", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetFaceNbrFaceFE, METH_VARARGS|METH_KEYWORDS, "GetFaceNbrFaceFE(ParFiniteElementSpace self, int i) -> FiniteElement"}, { "ParFiniteElementSpace_GetFaceNbrGlobalDofMap", _wrap_ParFiniteElementSpace_GetFaceNbrGlobalDofMap, METH_O, "GetFaceNbrGlobalDofMap(ParFiniteElementSpace self) -> HYPRE_Int const *"}, { "ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix", _wrap_ParFiniteElementSpace_Lose_Dof_TrueDof_Matrix, METH_O, "Lose_Dof_TrueDof_Matrix(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_LoseDofOffsets", _wrap_ParFiniteElementSpace_LoseDofOffsets, METH_O, "LoseDofOffsets(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_LoseTrueDofOffsets", _wrap_ParFiniteElementSpace_LoseTrueDofOffsets, METH_O, "LoseTrueDofOffsets(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_Conforming", _wrap_ParFiniteElementSpace_Conforming, METH_O, "Conforming(ParFiniteElementSpace self) -> bool"}, { "ParFiniteElementSpace_Nonconforming", _wrap_ParFiniteElementSpace_Nonconforming, METH_O, "Nonconforming(ParFiniteElementSpace self) -> bool"}, - { "ParFiniteElementSpace_GetTrueTransferOperator", _wrap_ParFiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "ParFiniteElementSpace_Update", _wrap_ParFiniteElementSpace_Update, METH_VARARGS, "Update(ParFiniteElementSpace self, bool want_transform=True)"}, + { "ParFiniteElementSpace_GetTrueTransferOperator", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_GetTrueTransferOperator, METH_VARARGS|METH_KEYWORDS, "GetTrueTransferOperator(ParFiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "ParFiniteElementSpace_Update", (PyCFunction)(void(*)(void))_wrap_ParFiniteElementSpace_Update, METH_VARARGS|METH_KEYWORDS, "Update(ParFiniteElementSpace self, bool want_transform=True)"}, { "ParFiniteElementSpace_UpdatesFinished", _wrap_ParFiniteElementSpace_UpdatesFinished, METH_O, "UpdatesFinished(ParFiniteElementSpace self)"}, { "delete_ParFiniteElementSpace", _wrap_delete_ParFiniteElementSpace, METH_O, "delete_ParFiniteElementSpace(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_PrintPartitionStats", _wrap_ParFiniteElementSpace_PrintPartitionStats, METH_O, "PrintPartitionStats(ParFiniteElementSpace self)"}, { "ParFiniteElementSpace_TrueVSize", _wrap_ParFiniteElementSpace_TrueVSize, METH_O, "TrueVSize(ParFiniteElementSpace self) -> int"}, { "ParFiniteElementSpace_swigregister", ParFiniteElementSpace_swigregister, METH_O, NULL}, { "ParFiniteElementSpace_swiginit", ParFiniteElementSpace_swiginit, METH_VARARGS, NULL}, - { "new_ConformingProlongationOperator", _wrap_new_ConformingProlongationOperator, METH_O, "new_ConformingProlongationOperator(ParFiniteElementSpace pfes) -> ConformingProlongationOperator"}, - { "ConformingProlongationOperator_Mult", _wrap_ConformingProlongationOperator_Mult, METH_VARARGS, "Mult(ConformingProlongationOperator self, Vector x, Vector y)"}, - { "ConformingProlongationOperator_MultTranspose", _wrap_ConformingProlongationOperator_MultTranspose, METH_VARARGS, "MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "new_ConformingProlongationOperator", (PyCFunction)(void(*)(void))_wrap_new_ConformingProlongationOperator, METH_VARARGS|METH_KEYWORDS, "new_ConformingProlongationOperator(ParFiniteElementSpace pfes) -> ConformingProlongationOperator"}, + { "ConformingProlongationOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ConformingProlongationOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ConformingProlongationOperator self, Vector x, Vector y)"}, + { "ConformingProlongationOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ConformingProlongationOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ConformingProlongationOperator self, Vector x, Vector y)"}, { "delete_ConformingProlongationOperator", _wrap_delete_ConformingProlongationOperator, METH_O, "delete_ConformingProlongationOperator(ConformingProlongationOperator self)"}, { "ConformingProlongationOperator_swigregister", ConformingProlongationOperator_swigregister, METH_O, NULL}, { "ConformingProlongationOperator_swiginit", ConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, - { "new_DeviceConformingProlongationOperator", _wrap_new_DeviceConformingProlongationOperator, METH_O, "new_DeviceConformingProlongationOperator(ParFiniteElementSpace pfes) -> DeviceConformingProlongationOperator"}, + { "new_DeviceConformingProlongationOperator", (PyCFunction)(void(*)(void))_wrap_new_DeviceConformingProlongationOperator, METH_VARARGS|METH_KEYWORDS, "new_DeviceConformingProlongationOperator(ParFiniteElementSpace pfes) -> DeviceConformingProlongationOperator"}, { "delete_DeviceConformingProlongationOperator", _wrap_delete_DeviceConformingProlongationOperator, METH_O, "delete_DeviceConformingProlongationOperator(DeviceConformingProlongationOperator self)"}, - { "DeviceConformingProlongationOperator_Mult", _wrap_DeviceConformingProlongationOperator_Mult, METH_VARARGS, "Mult(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, - { "DeviceConformingProlongationOperator_MultTranspose", _wrap_DeviceConformingProlongationOperator_MultTranspose, METH_VARARGS, "MultTranspose(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_Mult", (PyCFunction)(void(*)(void))_wrap_DeviceConformingProlongationOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, + { "DeviceConformingProlongationOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_DeviceConformingProlongationOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(DeviceConformingProlongationOperator self, Vector x, Vector y)"}, { "DeviceConformingProlongationOperator_swigregister", DeviceConformingProlongationOperator_swigregister, METH_O, NULL}, { "DeviceConformingProlongationOperator_swiginit", DeviceConformingProlongationOperator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -9680,10 +8986,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pgridfunc.py b/mfem/_par/pgridfunc.py index 3614ca7e..6ed8b26d 100644 --- a/mfem/_par/pgridfunc.py +++ b/mfem/_par/pgridfunc.py @@ -255,7 +255,6 @@ def ProjectCoefficient(self, *args): r""" ProjectCoefficient(ParGridFunction self, Coefficient coeff) ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs, int vd=0) - ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs) ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff) ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray dofs) ProjectCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff) diff --git a/mfem/_par/pgridfunc_wrap.cxx b/mfem/_par/pgridfunc_wrap.cxx index b71518eb..4b2a2ac9 100644 --- a/mfem/_par/pgridfunc_wrap.cxx +++ b/mfem/_par/pgridfunc_wrap.cxx @@ -3586,7 +3586,7 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) return SWIG_OK; } -SWIGINTERN mfem::ParGridFunction *new_mfem_ParGridFunction__SWIG_9(mfem::ParFiniteElementSpace *fes,mfem::Vector const &v,int offset){ +SWIGINTERN mfem::ParGridFunction *new_mfem_ParGridFunction__SWIG_8(mfem::ParFiniteElementSpace *fes,mfem::Vector const &v,int offset){ mfem::ParGridFunction *gf; gf = new mfem::ParGridFunction(fes, v.GetData() + offset); return gf; @@ -3712,7 +3712,7 @@ SWIGINTERN void mfem_ParGridFunction_Save__SWIG_1(mfem::ParGridFunction *self,ch self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_ParGridFunction_SaveAsOne__SWIG_2(mfem::ParGridFunction *self,char const *file,int precision=8){ +SWIGINTERN void mfem_ParGridFunction_SaveAsOne__SWIG_1(mfem::ParGridFunction *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3734,7 +3734,7 @@ SWIGINTERN void mfem_ParGridFunction_SaveAsOne__SWIG_2(mfem::ParGridFunction *se #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_GlobalLpNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GlobalLpNorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; double arg2 ; @@ -3743,23 +3743,28 @@ SWIGINTERN PyObject *_wrap_GlobalLpNorm(PyObject *SWIGUNUSEDPARM(self), PyObject int ecode1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"loc_norm", (char *)"comm", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "GlobalLpNorm", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GlobalLpNorm", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GlobalLpNorm" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GlobalLpNorm" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[2], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj2, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "GlobalLpNorm" "', argument " "3"" of type '" "MPI_Comm""'"); } @@ -3972,7 +3977,7 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_6(PyObject *SWIGUNUSEDPARM( PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; - int *arg3 = (int *) 0 ; + int *arg3 = (int *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3981,7 +3986,7 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_6(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; mfem::ParGridFunction *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParGridFunction" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -3992,11 +3997,13 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_6(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const *""'"); } arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParGridFunction" "', argument " "3"" of type '" "int const *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParGridFunction" "', argument " "3"" of type '" "int const *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); } - arg3 = reinterpret_cast< int * >(argp3); { try { result = (mfem::ParGridFunction *)new mfem::ParGridFunction(arg1,(mfem::GridFunction const *)arg2,(int const *)arg3); @@ -4013,42 +4020,6 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_6(PyObject *SWIGUNUSEDPARM( SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ParGridFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParGridFunction" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const *""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - result = (mfem::ParGridFunction *)new mfem::ParGridFunction(arg1,(mfem::GridFunction const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParGridFunction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; std::istream *arg2 = 0 ; @@ -5121,7 +5092,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_AddDistribute(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_ParGridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParGridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5129,15 +5100,19 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParGridFunction_SetFromTrueDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParGridFunction_SetFromTrueDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_SetFromTrueDofs" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); } arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_SetFromTrueDofs" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5986,14 +5961,14 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue__SWIG_0(PyObject *SWIGUNUSED mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; int arg2 ; mfem::IntegrationPoint *arg3 = 0 ; - int arg4 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_GetValue" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -6013,11 +5988,13 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { @@ -6035,52 +6012,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue__SWIG_0(PyObject *SWIGUNUSED SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - int arg2 ; - mfem::IntegrationPoint *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_GetValue" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->GetValue(arg2,(mfem::IntegrationPoint const &)*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6137,34 +6068,11 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue(PyObject *self, PyObject *ar int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_GetValue__SWIG_2(self, argc, argv); + return _wrap_ParGridFunction_GetValue__SWIG_1(self, argc, argv); } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationPoint, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_GetValue__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -6182,6 +6090,9 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue(PyObject *self, PyObject *ar int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationPoint, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_ParGridFunction_GetValue__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6202,7 +6113,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_GetValue(PyObject *self, PyObject *ar SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_GetValue'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParGridFunction::GetValue(int,mfem::IntegrationPoint const &,int) const\n" - " mfem::ParGridFunction::GetValue(int,mfem::IntegrationPoint const &) const\n" " mfem::ParGridFunction::GetValue(mfem::ElementTransformation &)\n"); return 0; } @@ -6251,7 +6161,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_1(PyObject mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; - int arg4 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6259,7 +6169,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_1(PyObject void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); @@ -6281,11 +6191,13 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_1(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { @@ -6303,55 +6215,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_1(PyObject SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - (arg1)->ProjectCoefficient(*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -6389,7 +6252,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_3(PyObject } -SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -6438,7 +6301,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_4(PyObject } -SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient__SWIG_0_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Coefficient **arg2 ; @@ -6543,7 +6406,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient(PyObject *self, Py int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_3(self, argc, argv); + return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_2(self, argc, argv); } } } @@ -6557,7 +6420,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient(PyObject *self, Py int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_5(self, argc, argv); + return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_4(self, argc, argv); } } } @@ -6575,7 +6438,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient(PyObject *self, Py } } } - if (argc == 3) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -6589,7 +6452,20 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient(PyObject *self, Py int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_2(self, argc, argv); + if (argc <= 3) { + return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_1(self, argc, argv); + } } } } @@ -6608,36 +6484,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient(PyObject *self, Py int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_1(self, argc, argv); - } + return _wrap_ParGridFunction_ProjectCoefficient__SWIG_0_3(self, argc, argv); } } } @@ -6648,7 +6495,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectCoefficient(PyObject *self, Py " Possible C/C++ prototypes are:\n" " ProjectCoefficient(mfem::Coefficient &)\n" " ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &,int)\n" - " ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &)\n" " ProjectCoefficient(mfem::VectorCoefficient &)\n" " ProjectCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" " ProjectCoefficient(mfem::Coefficient *[])\n" @@ -7471,7 +7317,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectBdrCoefficient(PyObject *self, } -SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectBdrCoefficientTangent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectBdrCoefficientTangent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -7482,15 +7328,20 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectBdrCoefficientTangent(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vcoeff", (char *)"bdr_attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParGridFunction_ProjectBdrCoefficientTangent", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParGridFunction_ProjectBdrCoefficientTangent", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ProjectBdrCoefficientTangent" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); } arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -7498,7 +7349,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ProjectBdrCoefficientTangent(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7525,14 +7376,14 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_0(PyObject *SWIG PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Coefficient **arg2 ; - mfem::IntegrationRule **arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -7543,23 +7394,25 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_0(PyObject *SWIG SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); } arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -7580,81 +7433,47 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_0(PyObject *SWIG SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient **arg2 ; + mfem::Coefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); } arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL1Error(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -7672,57 +7491,18 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_2(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL1Error(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -7736,23 +7516,25 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_4(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -7770,45 +7552,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_4(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL1Error(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { @@ -7817,49 +7560,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error(PyObject *self, PyObje if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_ComputeL1Error", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeL1Error__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeL1Error__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeL1Error__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -7869,6 +7570,9 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error(PyObject *self, PyObje int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeL1Error__SWIG_0(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } @@ -7878,35 +7582,41 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error(PyObject *self, PyObje } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeL1Error__SWIG_1(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_ParGridFunction_ComputeL1Error__SWIG_4(self, argc, argv); + return _wrap_ParGridFunction_ComputeL1Error__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeL1Error__SWIG_2(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } @@ -7921,11 +7631,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL1Error(PyObject *self, PyObje SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_ComputeL1Error'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParGridFunction::ComputeL1Error(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeL1Error(mfem::Coefficient *[]) const\n" " mfem::ParGridFunction::ComputeL1Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeL1Error(mfem::Coefficient &) const\n" - " mfem::ParGridFunction::ComputeL1Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeL1Error(mfem::VectorCoefficient &) const\n"); + " mfem::ParGridFunction::ComputeL1Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n"); return 0; } @@ -7934,14 +7641,14 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_0(PyObject *SWIG PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Coefficient **arg2 ; - mfem::IntegrationRule **arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -7952,23 +7659,25 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_0(PyObject *SWIG SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); } arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -7987,53 +7696,17 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_0(PyObject *SWIG SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient **arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL2Error(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -8047,23 +7720,25 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_2(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -8081,33 +7756,65 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_2(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; + mfem::Array< int > *arg4 = (mfem::Array< int > *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); } arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "4"" of type '" "mfem::Array< int > *""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL2Error(*arg2); + result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8120,222 +7827,15 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_3(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - mfem::Array< int > *arg4 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "4"" of type '" "mfem::Array< int > *""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeL2Error(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_ComputeL2Error", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeL2Error__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeL2Error__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeL2Error__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -8345,35 +7845,19 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error(PyObject *self, PyObje int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { + if (argc <= 2) { return _wrap_ParGridFunction_ComputeL2Error__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_ParGridFunction_ComputeL2Error__SWIG_5(self, argc, argv); + return _wrap_ParGridFunction_ComputeL2Error__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -8383,16 +7867,19 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error(PyObject *self, PyObje int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeL2Error__SWIG_1(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_ParGridFunction_ComputeL2Error__SWIG_2(self, argc, argv); + return _wrap_ParGridFunction_ComputeL2Error__SWIG_1(self, argc, argv); } } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -8402,15 +7889,21 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error(PyObject *self, PyObje int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeL2Error__SWIG_2(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { + if (argc <= 3) { + return _wrap_ParGridFunction_ComputeL2Error__SWIG_2(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_ComputeL2Error__SWIG_4(self, argc, argv); + return _wrap_ParGridFunction_ComputeL2Error__SWIG_2(self, argc, argv); } } } @@ -8421,12 +7914,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeL2Error(PyObject *self, PyObje SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_ComputeL2Error'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParGridFunction::ComputeL2Error(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeL2Error(mfem::Coefficient *[]) const\n" " mfem::ParGridFunction::ComputeL2Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeL2Error(mfem::Coefficient &) const\n" - " mfem::ParGridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[],mfem::Array< int > *) const\n" - " mfem::ParGridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeL2Error(mfem::VectorCoefficient &) const\n"); + " mfem::ParGridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[],mfem::Array< int > *) const\n"); return 0; } @@ -8435,14 +7924,14 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_0(PyObject *SWI PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Coefficient **arg2 ; - mfem::IntegrationRule **arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -8453,23 +7942,25 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); } arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -8488,53 +7979,17 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_0(PyObject *SWI SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient **arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeMaxError(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -8548,23 +8003,25 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_2(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -8582,131 +8039,55 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_2(PyObject *SWI } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); } arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeMaxError(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeMaxError(*arg2); + result = (double)((mfem::ParGridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8727,49 +8108,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError(PyObject *self, PyObj if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_ComputeMaxError", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeMaxError__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeMaxError__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeMaxError__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -8779,6 +8118,9 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError(PyObject *self, PyObj int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeMaxError__SWIG_0(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } @@ -8788,35 +8130,41 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError(PyObject *self, PyObj } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeMaxError__SWIG_1(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_ParGridFunction_ComputeMaxError__SWIG_4(self, argc, argv); + return _wrap_ParGridFunction_ComputeMaxError__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_ComputeMaxError__SWIG_2(self, argc, argv); + } { _v = PyList_Check(argv[2]) ? 1 : 0; } @@ -8831,11 +8179,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeMaxError(PyObject *self, PyObj SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_ComputeMaxError'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParGridFunction::ComputeMaxError(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeMaxError(mfem::Coefficient *[]) const\n" " mfem::ParGridFunction::ComputeMaxError(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeMaxError(mfem::Coefficient &) const\n" - " mfem::ParGridFunction::ComputeMaxError(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeMaxError(mfem::VectorCoefficient &) const\n"); + " mfem::ParGridFunction::ComputeMaxError(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n"); return 0; } @@ -8845,8 +8190,8 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_0(PyObject *SWIG mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; double arg2 ; mfem::Coefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::IntegrationRule **arg5 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; + mfem::IntegrationRule **arg5 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; @@ -8857,7 +8202,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_0(PyObject *SWIG int res4 = 0 ; double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -8876,28 +8221,32 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_0(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - { - if (PyList_Check(swig_obj[4])) { - int size = PyList_Size(swig_obj[4]); - int i = 0; - arg5 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[4],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[4]) { + { + if (PyList_Check(swig_obj[4])) { + int size = PyList_Size(swig_obj[4]); + int i = 0; + arg5 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[4],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg5[i] = reinterpret_cast(temp); } - arg5[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -8916,115 +8265,13 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_0(PyObject *SWIG SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParGridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParGridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeLpError(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; double arg2 ; mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) 0 ; - mfem::IntegrationRule **arg6 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; + mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) NULL ; + mfem::IntegrationRule **arg6 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; @@ -9037,7 +8284,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_3(PyObject *SWIG int res5 = 0 ; double result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); @@ -9056,33 +8303,39 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_3(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); } arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParGridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); + if (swig_obj[4]) { + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParGridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); + } + arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); } - arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); - { - if (PyList_Check(swig_obj[5])) { - int size = PyList_Size(swig_obj[5]); - int i = 0; - arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[5],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[5]) { + { + if (PyList_Check(swig_obj[5])) { + int size = PyList_Size(swig_obj[5]); + int i = 0; + arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[5],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg6[i] = reinterpret_cast(temp); } - arg6[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { @@ -9100,171 +8353,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_3(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParGridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParGridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); - } - arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParGridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParGridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::ParGridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParGridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - { - try { - result = (double)((mfem::ParGridFunction const *)arg1)->ComputeLpError(arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { @@ -9273,72 +8361,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError(PyObject *self, PyObje if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_ComputeLpError", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeLpError__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeLpError__SWIG_6(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeLpError__SWIG_5(self, argc, argv); - } - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -9353,35 +8376,16 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError(PyObject *self, PyObje int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeLpError__SWIG_1(self, argc, argv); + if (argc <= 3) { + return _wrap_ParGridFunction_ComputeLpError__SWIG_0(self, argc, argv); } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_ParGridFunction_ComputeLpError__SWIG_0(self, argc, argv); + } { _v = PyList_Check(argv[4]) ? 1 : 0; } @@ -9393,7 +8397,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError(PyObject *self, PyObje } } } - if (argc == 5) { + if ((argc >= 3) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -9408,49 +8412,28 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError(PyObject *self, PyObje int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeLpError__SWIG_4(self, argc, argv); - } + if (argc <= 3) { + return _wrap_ParGridFunction_ComputeLpError__SWIG_1(self, argc, argv); } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_ParGridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 5) { + return _wrap_ParGridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } { _v = PyList_Check(argv[5]) ? 1 : 0; } if (_v) { - return _wrap_ParGridFunction_ComputeLpError__SWIG_3(self, argc, argv); + return _wrap_ParGridFunction_ComputeLpError__SWIG_1(self, argc, argv); } } } @@ -9463,23 +8446,18 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeLpError(PyObject *self, PyObje SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_ComputeLpError'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParGridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *) const\n" - " mfem::ParGridFunction::ComputeLpError(double const,mfem::Coefficient &) const\n" - " mfem::ParGridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::ParGridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *) const\n" - " mfem::ParGridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *) const\n" - " mfem::ParGridFunction::ComputeLpError(double const,mfem::VectorCoefficient &) const\n"); + " mfem::ParGridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - bool arg4 ; - int arg5 ; + bool arg4 = (bool) true ; + int arg5 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9488,14 +8466,22 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNU int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blfi", (char *)"flux", (char *)"wcoef", (char *)"subdomain", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:ParGridFunction_ComputeFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); } arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -9503,7 +8489,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } @@ -9511,126 +8497,24 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParGridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->ComputeFlux(*arg2,*arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::BilinearFormIntegrator *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParGridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParGridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - (arg1)->ComputeFlux(*arg2,*arg3,arg4); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - mfem::BilinearFormIntegrator *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParGridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); { try { - (arg1)->ComputeFlux(*arg2,*arg3); + (arg1)->ComputeFlux(*arg2,*arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9643,104 +8527,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ParGridFunction_ComputeFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_ComputeFlux", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_ComputeFlux__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParGridFunction_ComputeFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParGridFunction_ComputeFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_ComputeFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool,int)\n" - " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool)\n" - " mfem::ParGridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ParGridFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; @@ -9799,31 +8585,34 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_SaveAsOne" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); } arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -9851,33 +8640,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_SaveAsOne" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - { - try { - (arg1)->SaveAsOne(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_delete_ParGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; @@ -9907,7 +8669,7 @@ SWIGINTERN PyObject *_wrap_delete_ParGridFunction(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9940,7 +8702,7 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction__SWIG_9(PyObject *SWIGUNUSEDPARM( } { try { - result = (mfem::ParGridFunction *)new_mfem_ParGridFunction__SWIG_9(arg1,(mfem::Vector const &)*arg2,arg3); + result = (mfem::ParGridFunction *)new_mfem_ParGridFunction__SWIG_8(arg1,(mfem::Vector const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10023,7 +8785,7 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction(PyObject *self, PyObject *args) { } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -10033,7 +8795,15 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParGridFunction__SWIG_7(self, argc, argv); + if (argc <= 2) { + return _wrap_new_ParGridFunction__SWIG_6(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_ParGridFunction__SWIG_6(self, argc, argv); + } } } } @@ -10047,26 +8817,7 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParGridFunction__SWIG_8(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParGridFunction__SWIG_6(self, argc, argv); - } + return _wrap_new_ParGridFunction__SWIG_7(self, argc, argv); } } } @@ -10088,7 +8839,7 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_ParGridFunction__SWIG_9(self, argc, argv); + return _wrap_new_ParGridFunction__SWIG_8(self, argc, argv); } } } @@ -10104,7 +8855,6 @@ SWIGINTERN PyObject *_wrap_new_ParGridFunction(PyObject *self, PyObject *args) { " mfem::ParGridFunction::ParGridFunction(mfem::ParFiniteElementSpace *,mfem::GridFunction *)\n" " mfem::ParGridFunction::ParGridFunction(mfem::ParFiniteElementSpace *,mfem::HypreParVector *)\n" " mfem::ParGridFunction::ParGridFunction(mfem::ParMesh *,mfem::GridFunction const *,int const *)\n" - " mfem::ParGridFunction::ParGridFunction(mfem::ParMesh *,mfem::GridFunction const *)\n" " mfem::ParGridFunction::ParGridFunction(mfem::ParMesh *,std::istream &)\n" " mfem::ParGridFunction::ParGridFunction(mfem::ParFiniteElementSpace *,mfem::Vector const &,int)\n"); return 0; @@ -10115,14 +8865,14 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_Save" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); @@ -10133,11 +8883,13 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -10156,44 +8908,6 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ParGridFunction_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_Save" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_ParGridFunction_Save__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - SWIGINTERN PyObject *_wrap_ParGridFunction_Save(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { @@ -10202,7 +8916,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_Save(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_Save", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -10211,7 +8925,20 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_Save(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_ParGridFunction_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParGridFunction_Save__SWIG_1(self, argc, argv); + } } } } @@ -10235,52 +8962,28 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_Save(PyObject *self, PyObject *args) } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParGridFunction_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParGridFunction::Save(std::ostream &) const\n" - " mfem::ParGridFunction::Save(char const *,int)\n" - " mfem::ParGridFunction::Save(char const *)\n"); + " mfem::ParGridFunction::Save(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_SaveAsOne" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); @@ -10291,53 +8994,17 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne__SWIG_2(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_SaveAsOne" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_ParGridFunction_SaveAsOne__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParGridFunction *arg1 = (mfem::ParGridFunction *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParGridFunction_SaveAsOne" "', argument " "1"" of type '" "mfem::ParGridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::ParGridFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParGridFunction_SaveAsOne" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_ParGridFunction_SaveAsOne__SWIG_2(arg1,(char const *)arg2); + mfem_ParGridFunction_SaveAsOne__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10360,34 +9027,15 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne(PyObject *self, PyObject *a if (!(argc = SWIG_Python_UnpackTuple(args, "ParGridFunction_SaveAsOne", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParGridFunction_SaveAsOne__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParGridFunction_SaveAsOne__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_ParGridFunction_SaveAsOne__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -10402,7 +9050,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne(PyObject *self, PyObject *a } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParGridFunction, 0); @@ -10411,6 +9059,9 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne(PyObject *self, PyObject *a int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParGridFunction_SaveAsOne__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10420,7 +9071,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne(PyObject *self, PyObject *a } } if (_v) { - return _wrap_ParGridFunction_SaveAsOne__SWIG_2(self, argc, argv); + return _wrap_ParGridFunction_SaveAsOne__SWIG_1(self, argc, argv); } } } @@ -10430,9 +9081,7 @@ SWIGINTERN PyObject *_wrap_ParGridFunction_SaveAsOne(PyObject *self, PyObject *a SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParGridFunction_SaveAsOne'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParGridFunction::SaveAsOne(std::ostream &)\n" - " mfem::ParGridFunction::SaveAsOne()\n" - " mfem::ParGridFunction::SaveAsOne(char const *,int)\n" - " mfem::ParGridFunction::SaveAsOne(char const *)\n"); + " mfem::ParGridFunction::SaveAsOne(char const *,int)\n"); return 0; } @@ -10448,112 +9097,16 @@ SWIGINTERN PyObject *ParGridFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::ParGridFunction *arg2 = 0 ; mfem::ParFiniteElementSpace *arg3 = 0 ; mfem::ParFiniteElementSpace *arg4 = 0 ; mfem::Vector *arg5 = 0 ; - int arg6 ; - double arg7 ; - int arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double val7 ; - int ecode7 = 0 ; - double result; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::ParGridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - arg3 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - arg4 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "L2ZZErrorEstimator" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - result = (double)mfem::L2ZZErrorEstimator(*arg1,(mfem::ParGridFunction const &)*arg2,*arg3,*arg4,*arg5,arg6,arg7,arg8); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::ParGridFunction *arg2 = 0 ; - mfem::ParFiniteElementSpace *arg3 = 0 ; - mfem::ParFiniteElementSpace *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - int arg6 ; - double arg7 ; + int arg6 = (int) 2 ; + double arg7 = (double) 1e-12 ; + int arg8 = (int) 200 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10566,10 +9119,21 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(s int res5 = 0 ; double val7 ; int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"flux_integrator", (char *)"x", (char *)"smooth_flux_fes", (char *)"flux_fes", (char *)"errors", (char *)"norm_p", (char *)"solver_tol", (char *)"solver_max_it", NULL + }; double result; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OOO:L2ZZErrorEstimator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -10577,7 +9141,7 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); } @@ -10585,7 +9149,7 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); } arg2 = reinterpret_cast< mfem::ParGridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); } @@ -10593,7 +9157,7 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); } arg3 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); } @@ -10601,7 +9165,7 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); } arg4 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -10609,177 +9173,32 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "L2ZZErrorEstimator" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - result = (double)mfem::L2ZZErrorEstimator(*arg1,(mfem::ParGridFunction const &)*arg2,*arg3,*arg4,*arg5,arg6,arg7); + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::ParGridFunction *arg2 = 0 ; - mfem::ParFiniteElementSpace *arg3 = 0 ; - mfem::ParFiniteElementSpace *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::ParGridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - arg3 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - arg4 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (obj6) { + ecode7 = SWIG_AsVal_double(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "L2ZZErrorEstimator" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - { - try { - result = (double)mfem::L2ZZErrorEstimator(*arg1,(mfem::ParGridFunction const &)*arg2,*arg3,*arg4,*arg5,arg6); + if (obj7) { + { + if ((PyArray_PyIntAsInt(obj7) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(obj7); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::ParGridFunction *arg2 = 0 ; - mfem::ParFiniteElementSpace *arg3 = 0 ; - mfem::ParFiniteElementSpace *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::ParGridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "3"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - arg3 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "4"" of type '" "mfem::ParFiniteElementSpace &""'"); - } - arg4 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (double)mfem::L2ZZErrorEstimator(*arg1,(mfem::ParGridFunction const &)*arg2,*arg3,*arg4,*arg5); + result = (double)mfem::L2ZZErrorEstimator(*arg1,(mfem::ParGridFunction const &)*arg2,*arg3,*arg4,*arg5,arg6,arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10792,194 +9211,10 @@ SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_L2ZZErrorEstimator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "L2ZZErrorEstimator", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ParGridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_L2ZZErrorEstimator__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ParGridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_L2ZZErrorEstimator__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ParGridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_L2ZZErrorEstimator__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ParGridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_L2ZZErrorEstimator__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'L2ZZErrorEstimator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::ParGridFunction const &,mfem::ParFiniteElementSpace &,mfem::ParFiniteElementSpace &,mfem::Vector &,int,double,int)\n" - " mfem::L2ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::ParGridFunction const &,mfem::ParFiniteElementSpace &,mfem::ParFiniteElementSpace &,mfem::Vector &,int,double)\n" - " mfem::L2ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::ParGridFunction const &,mfem::ParFiniteElementSpace &,mfem::ParFiniteElementSpace &,mfem::Vector &,int)\n" - " mfem::L2ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::ParGridFunction const &,mfem::ParFiniteElementSpace &,mfem::ParFiniteElementSpace &,mfem::Vector &)\n"); - return 0; -} - - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "GlobalLpNorm", _wrap_GlobalLpNorm, METH_VARARGS, "GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double"}, + { "GlobalLpNorm", (PyCFunction)(void(*)(void))_wrap_GlobalLpNorm, METH_VARARGS|METH_KEYWORDS, "GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double"}, { "ParGridFunction_ParFESpace", _wrap_ParGridFunction_ParFESpace, METH_O, "ParGridFunction_ParFESpace(ParGridFunction self) -> ParFiniteElementSpace"}, { "ParGridFunction_Update", _wrap_ParGridFunction_Update, METH_O, "ParGridFunction_Update(ParGridFunction self)"}, { "ParGridFunction_SetSpace", _wrap_ParGridFunction_SetSpace, METH_VARARGS, "\n" @@ -11002,7 +9237,7 @@ static PyMethodDef SwigMethods[] = { "ParGridFunction_AddDistribute(ParGridFunction self, double a, Vector tv)\n" "ParGridFunction_AddDistribute(ParGridFunction self, double a, Vector tv)\n" ""}, - { "ParGridFunction_SetFromTrueDofs", _wrap_ParGridFunction_SetFromTrueDofs, METH_VARARGS, "ParGridFunction_SetFromTrueDofs(ParGridFunction self, Vector tv)"}, + { "ParGridFunction_SetFromTrueDofs", (PyCFunction)(void(*)(void))_wrap_ParGridFunction_SetFromTrueDofs, METH_VARARGS|METH_KEYWORDS, "ParGridFunction_SetFromTrueDofs(ParGridFunction self, Vector tv)"}, { "ParGridFunction_Assign", _wrap_ParGridFunction_Assign, METH_VARARGS, "\n" "ParGridFunction_Assign(ParGridFunction self, ParGridFunction rhs) -> ParGridFunction\n" "ParGridFunction_Assign(ParGridFunction self, double value) -> ParGridFunction\n" @@ -11040,7 +9275,6 @@ static PyMethodDef SwigMethods[] = { { "ParGridFunction_ProjectCoefficient", _wrap_ParGridFunction_ProjectCoefficient, METH_VARARGS, "\n" "ParGridFunction_ProjectCoefficient(ParGridFunction self, Coefficient coeff)\n" "ParGridFunction_ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" - "ParGridFunction_ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs)\n" "ParGridFunction_ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff)\n" "ParGridFunction_ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray dofs)\n" "ParGridFunction_ProjectCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff)\n" @@ -11062,7 +9296,7 @@ static PyMethodDef SwigMethods[] = { "ParGridFunction_ProjectBdrCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray attr)\n" "ParGridFunction_ProjectBdrCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" ""}, - { "ParGridFunction_ProjectBdrCoefficientTangent", _wrap_ParGridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "ParGridFunction_ProjectBdrCoefficientTangent(ParGridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "ParGridFunction_ProjectBdrCoefficientTangent", (PyCFunction)(void(*)(void))_wrap_ParGridFunction_ProjectBdrCoefficientTangent, METH_VARARGS|METH_KEYWORDS, "ParGridFunction_ProjectBdrCoefficientTangent(ParGridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, { "ParGridFunction_ComputeL1Error", _wrap_ParGridFunction_ComputeL1Error, METH_VARARGS, "\n" "ParGridFunction_ComputeL1Error(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ParGridFunction_ComputeL1Error(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" @@ -11082,7 +9316,7 @@ static PyMethodDef SwigMethods[] = { "ParGridFunction_ComputeLpError(ParGridFunction self, double const p, Coefficient exsol, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" "ParGridFunction_ComputeLpError(ParGridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" ""}, - { "ParGridFunction_ComputeFlux", _wrap_ParGridFunction_ComputeFlux, METH_VARARGS, "ParGridFunction_ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "ParGridFunction_ComputeFlux", (PyCFunction)(void(*)(void))_wrap_ParGridFunction_ComputeFlux, METH_VARARGS|METH_KEYWORDS, "ParGridFunction_ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "delete_ParGridFunction", _wrap_delete_ParGridFunction, METH_O, "delete_ParGridFunction(ParGridFunction self)"}, { "new_ParGridFunction", _wrap_new_ParGridFunction, METH_VARARGS, "\n" "ParGridFunction()\n" @@ -11105,14 +9339,14 @@ static PyMethodDef SwigMethods[] = { ""}, { "ParGridFunction_swigregister", ParGridFunction_swigregister, METH_O, NULL}, { "ParGridFunction_swiginit", ParGridFunction_swiginit, METH_VARARGS, NULL}, - { "L2ZZErrorEstimator", _wrap_L2ZZErrorEstimator, METH_VARARGS, "L2ZZErrorEstimator(BilinearFormIntegrator flux_integrator, ParGridFunction x, ParFiniteElementSpace smooth_flux_fes, ParFiniteElementSpace flux_fes, Vector errors, int norm_p=2, double solver_tol=1e-12, int solver_max_it=200) -> double"}, + { "L2ZZErrorEstimator", (PyCFunction)(void(*)(void))_wrap_L2ZZErrorEstimator, METH_VARARGS|METH_KEYWORDS, "L2ZZErrorEstimator(BilinearFormIntegrator flux_integrator, ParGridFunction x, ParFiniteElementSpace smooth_flux_fes, ParFiniteElementSpace flux_fes, Vector errors, int norm_p=2, double solver_tol=1e-12, int solver_max_it=200) -> double"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "GlobalLpNorm", _wrap_GlobalLpNorm, METH_VARARGS, "GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double"}, + { "GlobalLpNorm", (PyCFunction)(void(*)(void))_wrap_GlobalLpNorm, METH_VARARGS|METH_KEYWORDS, "GlobalLpNorm(double const p, double loc_norm, MPI_Comm comm) -> double"}, { "ParGridFunction_ParFESpace", _wrap_ParGridFunction_ParFESpace, METH_O, "ParFESpace(ParGridFunction self) -> ParFiniteElementSpace"}, { "ParGridFunction_Update", _wrap_ParGridFunction_Update, METH_O, "Update(ParGridFunction self)"}, { "ParGridFunction_SetSpace", _wrap_ParGridFunction_SetSpace, METH_VARARGS, "\n" @@ -11135,7 +9369,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AddDistribute(ParGridFunction self, double a, Vector tv)\n" "AddDistribute(ParGridFunction self, double a, Vector tv)\n" ""}, - { "ParGridFunction_SetFromTrueDofs", _wrap_ParGridFunction_SetFromTrueDofs, METH_VARARGS, "SetFromTrueDofs(ParGridFunction self, Vector tv)"}, + { "ParGridFunction_SetFromTrueDofs", (PyCFunction)(void(*)(void))_wrap_ParGridFunction_SetFromTrueDofs, METH_VARARGS|METH_KEYWORDS, "SetFromTrueDofs(ParGridFunction self, Vector tv)"}, { "ParGridFunction_Assign", _wrap_ParGridFunction_Assign, METH_VARARGS, "\n" "Assign(ParGridFunction self, ParGridFunction rhs) -> ParGridFunction\n" "Assign(ParGridFunction self, double value) -> ParGridFunction\n" @@ -11173,7 +9407,6 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "ParGridFunction_ProjectCoefficient", _wrap_ParGridFunction_ProjectCoefficient, METH_VARARGS, "\n" "ProjectCoefficient(ParGridFunction self, Coefficient coeff)\n" "ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" - "ProjectCoefficient(ParGridFunction self, Coefficient coeff, intArray dofs)\n" "ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff)\n" "ProjectCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray dofs)\n" "ProjectCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff)\n" @@ -11195,7 +9428,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ProjectBdrCoefficient(ParGridFunction self, VectorCoefficient vcoeff, intArray attr)\n" "ProjectBdrCoefficient(ParGridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" ""}, - { "ParGridFunction_ProjectBdrCoefficientTangent", _wrap_ParGridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "ProjectBdrCoefficientTangent(ParGridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "ParGridFunction_ProjectBdrCoefficientTangent", (PyCFunction)(void(*)(void))_wrap_ParGridFunction_ProjectBdrCoefficientTangent, METH_VARARGS|METH_KEYWORDS, "ProjectBdrCoefficientTangent(ParGridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, { "ParGridFunction_ComputeL1Error", _wrap_ParGridFunction_ComputeL1Error, METH_VARARGS, "\n" "ComputeL1Error(ParGridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeL1Error(ParGridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" @@ -11215,7 +9448,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ComputeLpError(ParGridFunction self, double const p, Coefficient exsol, Coefficient weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeLpError(ParGridFunction self, double const p, VectorCoefficient exsol, Coefficient weight=None, VectorCoefficient v_weight=None, mfem::IntegrationRule const *[] irs=0) -> double\n" ""}, - { "ParGridFunction_ComputeFlux", _wrap_ParGridFunction_ComputeFlux, METH_VARARGS, "ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "ParGridFunction_ComputeFlux", (PyCFunction)(void(*)(void))_wrap_ParGridFunction_ComputeFlux, METH_VARARGS|METH_KEYWORDS, "ComputeFlux(ParGridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "delete_ParGridFunction", _wrap_delete_ParGridFunction, METH_O, "delete_ParGridFunction(ParGridFunction self)"}, { "new_ParGridFunction", _wrap_new_ParGridFunction, METH_VARARGS, "\n" "ParGridFunction()\n" @@ -11238,7 +9471,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "ParGridFunction_swigregister", ParGridFunction_swigregister, METH_O, NULL}, { "ParGridFunction_swiginit", ParGridFunction_swiginit, METH_VARARGS, NULL}, - { "L2ZZErrorEstimator", _wrap_L2ZZErrorEstimator, METH_VARARGS, "L2ZZErrorEstimator(BilinearFormIntegrator flux_integrator, ParGridFunction x, ParFiniteElementSpace smooth_flux_fes, ParFiniteElementSpace flux_fes, Vector errors, int norm_p=2, double solver_tol=1e-12, int solver_max_it=200) -> double"}, + { "L2ZZErrorEstimator", (PyCFunction)(void(*)(void))_wrap_L2ZZErrorEstimator, METH_VARARGS|METH_KEYWORDS, "L2ZZErrorEstimator(BilinearFormIntegrator flux_integrator, ParGridFunction x, ParFiniteElementSpace smooth_flux_fes, ParFiniteElementSpace flux_fes, Vector errors, int norm_p=2, double solver_tol=1e-12, int solver_max_it=200) -> double"}, { NULL, NULL, 0, NULL } }; @@ -13013,10 +11246,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/plinearform_wrap.cxx b/mfem/_par/plinearform_wrap.cxx index edd70262..e88ddfae 100644 --- a/mfem/_par/plinearform_wrap.cxx +++ b/mfem/_par/plinearform_wrap.cxx @@ -3483,23 +3483,25 @@ SWIGINTERN PyObject *_wrap_ParLinearForm_ParFESpace(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_ParLinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParLinearForm *arg1 = (mfem::ParLinearForm *) 0 ; - mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; + mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParLinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParLinearForm_Update" "', argument " "1"" of type '" "mfem::ParLinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParLinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParLinearForm_Update" "', argument " "2"" of type '" "mfem::ParFiniteElementSpace *""'"); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParLinearForm_Update" "', argument " "2"" of type '" "mfem::ParFiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp2); } - arg2 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp2); { try { (arg1)->Update(arg2); @@ -3516,33 +3518,6 @@ SWIGINTERN PyObject *_wrap_ParLinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_ParLinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParLinearForm *arg1 = (mfem::ParLinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParLinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParLinearForm_Update" "', argument " "1"" of type '" "mfem::ParLinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::ParLinearForm * >(argp1); - { - try { - (arg1)->Update(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParLinearForm_Update__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParLinearForm *arg1 = (mfem::ParLinearForm *) 0 ; mfem::ParFiniteElementSpace *arg2 = (mfem::ParFiniteElementSpace *) 0 ; @@ -3603,21 +3578,15 @@ SWIGINTERN PyObject *_wrap_ParLinearForm_Update(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "ParLinearForm_Update", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParLinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParLinearForm_Update__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParLinearForm, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_ParLinearForm_Update__SWIG_0(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0); _v = SWIG_CheckState(res); @@ -3649,7 +3618,7 @@ SWIGINTERN PyObject *_wrap_ParLinearForm_Update(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_ParLinearForm_Update__SWIG_2(self, argc, argv); + return _wrap_ParLinearForm_Update__SWIG_1(self, argc, argv); } } } @@ -3660,7 +3629,6 @@ SWIGINTERN PyObject *_wrap_ParLinearForm_Update(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParLinearForm_Update'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParLinearForm::Update(mfem::ParFiniteElementSpace *)\n" - " mfem::ParLinearForm::Update()\n" " mfem::ParLinearForm::Update(mfem::ParFiniteElementSpace *,mfem::Vector &,int)\n"); return 0; } @@ -3773,7 +3741,7 @@ SWIGINTERN PyObject *_wrap_ParLinearForm_ParallelAssemble(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_ParLinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParLinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParLinearForm *arg1 = (mfem::ParLinearForm *) 0 ; mfem::ParGridFunction *arg2 = 0 ; @@ -3781,16 +3749,20 @@ SWIGINTERN PyObject *_wrap_ParLinearForm___call__(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ParLinearForm___call__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParLinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParLinearForm___call__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParLinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParLinearForm___call__" "', argument " "1"" of type '" "mfem::ParLinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParLinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ParGridFunction, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParLinearForm___call__" "', argument " "2"" of type '" "mfem::ParGridFunction const &""'"); } @@ -3871,7 +3843,7 @@ static PyMethodDef SwigMethods[] = { "ParLinearForm_ParallelAssemble(ParLinearForm self, Vector tv)\n" "ParLinearForm_ParallelAssemble(ParLinearForm self) -> HypreParVector\n" ""}, - { "ParLinearForm___call__", _wrap_ParLinearForm___call__, METH_VARARGS, "ParLinearForm___call__(ParLinearForm self, ParGridFunction gf) -> double"}, + { "ParLinearForm___call__", (PyCFunction)(void(*)(void))_wrap_ParLinearForm___call__, METH_VARARGS|METH_KEYWORDS, "ParLinearForm___call__(ParLinearForm self, ParGridFunction gf) -> double"}, { "delete_ParLinearForm", _wrap_delete_ParLinearForm, METH_O, "delete_ParLinearForm(ParLinearForm self)"}, { "ParLinearForm_swigregister", ParLinearForm_swigregister, METH_O, NULL}, { "ParLinearForm_swiginit", ParLinearForm_swiginit, METH_VARARGS, NULL}, @@ -3896,7 +3868,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ParallelAssemble(ParLinearForm self, Vector tv)\n" "ParallelAssemble(ParLinearForm self) -> HypreParVector\n" ""}, - { "ParLinearForm___call__", _wrap_ParLinearForm___call__, METH_VARARGS, "__call__(ParLinearForm self, ParGridFunction gf) -> double"}, + { "ParLinearForm___call__", (PyCFunction)(void(*)(void))_wrap_ParLinearForm___call__, METH_VARARGS|METH_KEYWORDS, "__call__(ParLinearForm self, ParGridFunction gf) -> double"}, { "delete_ParLinearForm", _wrap_delete_ParLinearForm, METH_O, "delete_ParLinearForm(ParLinearForm self)"}, { "ParLinearForm_swigregister", ParLinearForm_swigregister, METH_O, NULL}, { "ParLinearForm_swiginit", ParLinearForm_swiginit, METH_VARARGS, NULL}, @@ -4773,10 +4745,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pmesh.py b/mfem/_par/pmesh.py index 85dd8923..2307c3df 100644 --- a/mfem/_par/pmesh.py +++ b/mfem/_par/pmesh.py @@ -301,10 +301,21 @@ def GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max): return _pmesh.ParMesh_GetCharacteristics(self, h_min, h_max, kappa_min, kappa_max) GetCharacteristics = _swig_new_instance_method(_pmesh.ParMesh_GetCharacteristics) - def FindPoints(self, point_mat, elem_ids, ips, warn=True, inv_trans=None): - r"""FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int""" - return _pmesh.ParMesh_FindPoints(self, point_mat, elem_ids, ips, warn, inv_trans) - FindPoints = _swig_new_instance_method(_pmesh.ParMesh_FindPoints) + def FindPoints(self, pp): + r"""count, element_id, integration_points = FindPoints(points)""" + import numpy as np + import mfem.par as mfem + + pp = np.array(pp, copy=False, dtype=float).transpose() + M = mfem.DenseMatrix(pp.shape[0], pp.shape[1]) + M.Assign(pp) + elem_ids = mfem.intArray() + int_points = mfem.IntegrationPointArray() + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + elem_ids = elem_ids.ToList() + return count, elem_ids, int_points + + def PrintSharedEntities(self, fname_prefix): r"""PrintSharedEntities(ParMesh self, char const * fname_prefix)""" diff --git a/mfem/_par/pmesh_wrap.cxx b/mfem/_par/pmesh_wrap.cxx index 9e94af04..d8506f04 100644 --- a/mfem/_par/pmesh_wrap.cxx +++ b/mfem/_par/pmesh_wrap.cxx @@ -3561,7 +3561,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN mfem::ParMesh *new_mfem_ParMesh__SWIG_10(MPI_Comm comm,char const *mesh_file){ +SWIGINTERN mfem::ParMesh *new_mfem_ParMesh__SWIG_6(MPI_Comm comm,char const *mesh_file){ mfem::ParMesh *mesh; std::ifstream imesh(mesh_file); if (!imesh) @@ -3577,7 +3577,7 @@ SWIGINTERN void mfem_ParMesh_ParPrintToFile(mfem::ParMesh const *self,char const mesh_ofs.precision(precision); self->ParPrint(mesh_ofs); } -SWIGINTERN void mfem_ParMesh_Print__SWIG_2(mfem::ParMesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_ParMesh_Print__SWIG_1(mfem::ParMesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3588,7 +3588,7 @@ SWIGINTERN void mfem_ParMesh_Print__SWIG_2(mfem::ParMesh *self,char const *file, self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_ParMesh_PrintXG__SWIG_2(mfem::ParMesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_ParMesh_PrintXG__SWIG_1(mfem::ParMesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3599,7 +3599,7 @@ SWIGINTERN void mfem_ParMesh_PrintXG__SWIG_2(mfem::ParMesh *self,char const *fil self -> PrintXG(ofile); ofile.close(); } -SWIGINTERN void mfem_ParMesh_PrintAsOne__SWIG_2(mfem::ParMesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_ParMesh_PrintAsOne__SWIG_1(mfem::ParMesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3610,7 +3610,7 @@ SWIGINTERN void mfem_ParMesh_PrintAsOne__SWIG_2(mfem::ParMesh *self,char const * self -> PrintAsOne(ofile); ofile.close(); } -SWIGINTERN void mfem_ParMesh_PrintAsOneXG__SWIG_2(mfem::ParMesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_ParMesh_PrintAsOneXG__SWIG_1(mfem::ParMesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3621,7 +3621,7 @@ SWIGINTERN void mfem_ParMesh_PrintAsOneXG__SWIG_2(mfem::ParMesh *self,char const self -> PrintAsOneXG(ofile); ofile.close(); } -SWIGINTERN void mfem_ParMesh_PrintInfo__SWIG_2(mfem::ParMesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_ParMesh_PrintInfo__SWIG_1(mfem::ParMesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3643,7 +3643,7 @@ SWIGINTERN void mfem_ParMesh_ParPrint__SWIG_1(mfem::ParMesh *self,char const *fi self -> ParPrint(ofile); ofile.close(); } -SWIGINTERN void mfem_ParMesh_ParPrint__SWIG_3(mfem::ParMesh *self){ +SWIGINTERN void mfem_ParMesh_ParPrint__SWIG_2(mfem::ParMesh *self){ self -> ParPrint(std::cout); } @@ -3660,14 +3660,14 @@ extern "C" { SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; mfem::ParMesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParMesh, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParMesh" "', argument " "1"" of type '" "mfem::ParMesh const &""'"); @@ -3676,11 +3676,13 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "1"" of type '" "mfem::ParMesh const &""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ParMesh" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ParMesh" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (mfem::ParMesh *)new mfem::ParMesh((mfem::ParMesh const &)*arg1,arg2); @@ -3697,49 +3699,18 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), P SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::ParMesh *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParMesh, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParMesh" "', argument " "1"" of type '" "mfem::ParMesh const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "1"" of type '" "mfem::ParMesh const &""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - result = (mfem::ParMesh *)new mfem::ParMesh((mfem::ParMesh const &)*arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; mfem::Mesh *arg2 = 0 ; - int *arg3 = (int *) 0 ; - int arg4 ; + int *arg3 = (int *) NULL ; + int arg4 = (int) 1 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; mfem::ParMesh *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); @@ -3757,16 +3728,20 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "2"" of type '" "mfem::Mesh &""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParMesh" "', argument " "3"" of type '" "int *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParMesh" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); } - arg3 = reinterpret_cast< int * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { @@ -3783,18 +3758,18 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; - mfem::Mesh *arg2 = 0 ; - int *arg3 = (int *) 0 ; + std::istream *arg2 = 0 ; + bool arg3 = (bool) true ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + bool val3 ; + int ecode3 = 0 ; mfem::ParMesh *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); @@ -3804,19 +3779,21 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParMesh" "', argument " "2"" of type '" "mfem::Mesh &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParMesh" "', argument " "2"" of type '" "std::istream &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "2"" of type '" "mfem::Mesh &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "2"" of type '" "std::istream &""'"); } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParMesh" "', argument " "3"" of type '" "int *""'"); + arg2 = reinterpret_cast< std::istream * >(argp2); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParMesh" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg3 = reinterpret_cast< int * >(argp3); { try { result = (mfem::ParMesh *)new mfem::ParMesh(arg1,*arg2,arg3); @@ -3832,35 +3809,36 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::Mesh *arg2 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + int arg2 ; + int arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; mfem::ParMesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParMesh" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParMesh" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParMesh" "', argument " "2"" of type '" "mfem::Mesh &""'"); + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "2"" of type '" "mfem::Mesh &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); { try { - result = (mfem::ParMesh *)new mfem::ParMesh(arg1,*arg2); + result = (mfem::ParMesh *)new mfem::ParMesh(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3873,439 +3851,191 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - MPI_Comm arg1 ; - std::istream *arg2 = 0 ; - bool arg3 ; - void *argp2 = 0 ; - int res2 = 0 ; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + bool arg2 = (bool) false ; + bool arg3 = (bool) false ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ; - mfem::ParMesh *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParMesh" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:ParMesh_Finalize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Finalize" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParMesh" "', argument " "2"" of type '" "std::istream &""'"); + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParMesh_Finalize" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "2"" of type '" "std::istream &""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_Finalize" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< std::istream * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParMesh" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); { try { - result = (mfem::ParMesh *)new mfem::ParMesh(arg1,*arg2,arg3); + (arg1)->Finalize(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - MPI_Comm arg1 ; - std::istream *arg2 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ParMesh *result = 0 ; + mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParMesh" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParMesh" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParMesh" "', argument " "2"" of type '" "std::istream &""'"); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetAttributes" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } - arg2 = reinterpret_cast< std::istream * >(argp2); + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { try { - result = (mfem::ParMesh *)new mfem::ParMesh(arg1,*arg2); + (arg1)->SetAttributes(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_GetComm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ParMesh *result = 0 ; + PyObject *swig_obj[1] ; + MPI_Comm result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParMesh" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetComm" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (mfem::ParMesh *)new mfem::ParMesh(arg1,arg2,arg3); + result = ((mfem::ParMesh const *)arg1)->GetComm(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_MPI_Comm(static_cast< MPI_Comm >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ParMesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_GetNRanks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - bool arg2 ; - bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Finalize" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetNRanks" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParMesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_Finalize" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); { try { - (arg1)->Finalize(arg2,arg3); + result = (int)((mfem::ParMesh const *)arg1)->GetNRanks(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ParMesh_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_GetMyRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Finalize" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetMyRank" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParMesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { try { - (arg1)->Finalize(arg2); + result = (int)((mfem::ParMesh const *)arg1)->GetMyRank(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ParMesh_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_gtopo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::GroupTopology *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Finalize" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - (arg1)->Finalize(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_Finalize", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_Finalize__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParMesh_Finalize__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParMesh_Finalize__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMesh::Finalize(bool,bool)\n" - " mfem::ParMesh::Finalize(bool)\n" - " mfem::ParMesh::Finalize()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetAttributes" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - (arg1)->SetAttributes(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_GetComm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - MPI_Comm result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetComm" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - result = ((mfem::ParMesh const *)arg1)->GetComm(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_MPI_Comm(static_cast< MPI_Comm >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_GetNRanks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetNRanks" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - result = (int)((mfem::ParMesh const *)arg1)->GetNRanks(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_GetMyRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetMyRank" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - result = (int)((mfem::ParMesh const *)arg1)->GetMyRank(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_gtopo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::GroupTopology *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_gtopo_get" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_gtopo_get" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); result = (mfem::GroupTopology *)& ((arg1)->gtopo); @@ -4756,26 +4486,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetNGroups(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_ParMesh_GroupNVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupNVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupNVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_GroupNVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupNVertices" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4792,26 +4526,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupNVertices(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ParMesh_GroupNEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupNEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupNEdges", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_GroupNEdges", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupNEdges" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4828,26 +4566,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupNEdges(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_ParMesh_GroupNTriangles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupNTriangles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupNTriangles", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_GroupNTriangles", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupNTriangles" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4864,26 +4606,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupNTriangles(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ParMesh_GroupNQuadrilaterals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupNQuadrilaterals(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupNQuadrilaterals", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_GroupNQuadrilaterals", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupNQuadrilaterals" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4900,33 +4646,38 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupNQuadrilaterals(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ParMesh_GroupVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupVertex", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParMesh_GroupVertex", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupVertex" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4943,7 +4694,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupVertex(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_ParMesh_GroupEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; @@ -4956,27 +4707,34 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupEdge(PyObject *SWIGUNUSEDPARM(self), PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", (char *)"i", (char *)"edge", (char *)"o", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupEdge", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ParMesh_GroupEdge", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupEdge" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_GroupEdge" "', argument " "4"" of type '" "int &""'"); } @@ -4984,7 +4742,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupEdge(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GroupEdge" "', argument " "4"" of type '" "int &""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParMesh_GroupEdge" "', argument " "5"" of type '" "int &""'"); } @@ -5007,7 +4765,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupEdge(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_ParMesh_GroupTriangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupTriangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; @@ -5020,27 +4778,34 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupTriangle(PyObject *SWIGUNUSEDPARM(self), int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", (char *)"i", (char *)"face", (char *)"o", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupTriangle", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ParMesh_GroupTriangle", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupTriangle" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_GroupTriangle" "', argument " "4"" of type '" "int &""'"); } @@ -5048,7 +4813,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupTriangle(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GroupTriangle" "', argument " "4"" of type '" "int &""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParMesh_GroupTriangle" "', argument " "5"" of type '" "int &""'"); } @@ -5071,7 +4836,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupTriangle(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ParMesh_GroupQuadrilateral(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GroupQuadrilateral(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; @@ -5084,27 +4849,34 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupQuadrilateral(PyObject *SWIGUNUSEDPARM(s int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"group", (char *)"i", (char *)"face", (char *)"o", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GroupQuadrilateral", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ParMesh_GroupQuadrilateral", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GroupQuadrilateral" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_GroupQuadrilateral" "', argument " "4"" of type '" "int &""'"); } @@ -5112,7 +4884,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupQuadrilateral(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GroupQuadrilateral" "', argument " "4"" of type '" "int &""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParMesh_GroupQuadrilateral" "', argument " "5"" of type '" "int &""'"); } @@ -5135,7 +4907,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GroupQuadrilateral(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_ParMesh_GenerateOffsets(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GenerateOffsets(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; @@ -5147,26 +4919,32 @@ SWIGINTERN PyObject *_wrap_ParMesh_GenerateOffsets(PyObject *SWIGUNUSEDPARM(self int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"N", (char *)"loc_sizes", (char *)"offsets", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GenerateOffsets", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParMesh_GenerateOffsets", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GenerateOffsets" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMesh_GenerateOffsets" "', argument " "3"" of type '" "HYPRE_Int []""'"); } arg3 = reinterpret_cast< HYPRE_Int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_p_mfem__ArrayT_int_t, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_GenerateOffsets" "', argument " "4"" of type '" "mfem::Array< HYPRE_Int > *[]""'"); } @@ -5244,175 +5022,64 @@ SWIGINTERN PyObject *_wrap_ParMesh_ExchangeFaceNbrNodes(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; - bool arg3 ; - int arg4 ; - int arg5 ; + bool arg3 = (bool) false ; + int arg4 = (int) -1 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"order", (char *)"discont", (char *)"space_dim", (char *)"ordering", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:ParMesh_SetCurvature", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->SetCurvature(arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - int arg2 ; - bool arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - { - try { - (arg1)->SetCurvature(arg2,arg3,arg4); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - int arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetCurvature(arg2,arg3); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_SetCurvature" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - (arg1)->SetCurvature(arg2); + (arg1)->SetCurvature(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5425,150 +5092,6 @@ SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature__SWIG_3(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ParMesh_SetCurvature(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_SetCurvature", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParMesh_SetCurvature__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParMesh_SetCurvature__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParMesh_SetCurvature__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParMesh_SetCurvature__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_SetCurvature'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMesh::SetCurvature(int,bool,int,int)\n" - " mfem::ParMesh::SetCurvature(int,bool,int)\n" - " mfem::ParMesh::SetCurvature(int,bool)\n" - " mfem::ParMesh::SetCurvature(int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ParMesh_GetNFaceNeighbors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; @@ -5599,26 +5122,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetNFaceNeighbors(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_ParMesh_GetFaceNbrGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GetFaceNbrGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fn", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GetFaceNbrGroup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_GetFaceNbrGroup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetFaceNbrGroup" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5635,26 +5162,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetFaceNbrGroup(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ParMesh_GetFaceNbrRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GetFaceNbrRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fn", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GetFaceNbrRank", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_GetFaceNbrRank", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetFaceNbrRank" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5680,93 +5211,66 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetFaceToAllElementTable(PyObject *SWIGUNUSED mfem::Table *result = 0 ; if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetFaceToAllElementTable" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - result = (mfem::Table *)((mfem::ParMesh const *)arg1)->GetFaceToAllElementTable(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_GetSharedFaceTransformations__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - int arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - mfem::FaceElementTransformations *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetSharedFaceTransformations" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetFaceToAllElementTable" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_GetSharedFaceTransformations" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetSharedFaceTransformations(arg2,arg3); + result = (mfem::Table *)((mfem::ParMesh const *)arg1)->GetFaceToAllElementTable(); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ParMesh_GetSharedFaceTransformations__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_GetSharedFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sf", (char *)"fill2", NULL + }; mfem::FaceElementTransformations *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:ParMesh_GetSharedFaceTransformations", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetSharedFaceTransformations" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ParMesh_GetSharedFaceTransformations" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetSharedFaceTransformations(arg2); + result = (mfem::FaceElementTransformations *)(arg1)->GetSharedFaceTransformations(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5779,68 +5283,6 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetSharedFaceTransformations__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_ParMesh_GetSharedFaceTransformations(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_GetSharedFaceTransformations", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParMesh_GetSharedFaceTransformations__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParMesh_GetSharedFaceTransformations__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_GetSharedFaceTransformations'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMesh::GetSharedFaceTransformations(int,bool)\n" - " mfem::ParMesh::GetSharedFaceTransformations(int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ParMesh_GetNSharedFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; @@ -5871,26 +5313,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetNSharedFaces(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ParMesh_GetSharedFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GetSharedFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sface", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GetSharedFace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_GetSharedFace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetSharedFace" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5936,26 +5382,30 @@ SWIGINTERN PyObject *_wrap_ParMesh_ReorientTetMesh(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ParMesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; long result; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_ReduceInt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_ReduceInt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_ReduceInt" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6067,213 +5517,52 @@ SWIGINTERN PyObject *_wrap_ParMesh_Rebalance(PyObject *self, PyObject *args) { } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_Rebalance'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMesh::Rebalance()\n" - " mfem::ParMesh::Rebalance(mfem::Array< int > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Print" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::ParMesh const *)arg1)->Print(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Print" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - ((mfem::ParMesh const *)arg1)->Print(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintXG" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::ParMesh const *)arg1)->PrintXG(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintXG" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - ((mfem::ParMesh const *)arg1)->PrintXG(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_Rebalance'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParMesh::Rebalance()\n" + " mfem::ParMesh::Rebalance(mfem::Array< int > const &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOne" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Print" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { try { - (arg1)->PrintAsOne(*arg2); + ((mfem::ParMesh const *)arg1)->Print(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6296,66 +5585,100 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOne" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintXG" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - (arg1)->PrintAsOne(); + ((mfem::ParMesh const *)arg1)->PrintXG(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOneXG" "', argument " "1"" of type '" "mfem::ParMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOne" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { try { - (arg1)->PrintAsOneXG(*arg2); + (arg1)->PrintAsOne(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6378,108 +5701,91 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOneXG" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - (arg1)->PrintAsOneXG(); + (arg1)->PrintAsOneXG(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { - try { - (arg1)->GetBoundingBox(*arg2,*arg3,arg4); + if (temp2->isSTDOUT() != 1) { + out2.close(); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } } - resultobj = SWIG_Py_Void(); return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_ParMesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; + int arg4 = (int) 2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p_min", (char *)"p_max", (char *)"ref", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:ParMesh_GetBoundingBox", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6487,7 +5793,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6495,9 +5801,17 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } { try { - (arg1)->GetBoundingBox(*arg2,*arg3); + (arg1)->GetBoundingBox(*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6510,73 +5824,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_ParMesh_GetBoundingBox(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_GetBoundingBox", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_GetBoundingBox__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParMesh_GetBoundingBox__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_GetBoundingBox'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMesh::GetBoundingBox(mfem::Vector &,mfem::Vector &,int)\n" - " mfem::ParMesh::GetBoundingBox(mfem::Vector &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; double *arg2 = 0 ; @@ -6593,15 +5841,22 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(s int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_min", (char *)"h_max", (char *)"kappa_min", (char *)"kappa_max", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_GetCharacteristics", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ParMesh_GetCharacteristics", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } @@ -6609,7 +5864,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); } arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } @@ -6617,7 +5872,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); } arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } @@ -6625,107 +5880,83 @@ SWIGINTERN PyObject *_wrap_ParMesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); } arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParMesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintInfo" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); } + arg5 = reinterpret_cast< double * >(argp5); { try { - (arg1)->PrintInfo(*arg2); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintInfo" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - (arg1)->PrintInfo(); + (arg1)->PrintInfo(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } @@ -6785,14 +6016,14 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_FindPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; mfem::DenseMatrix *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) 0 ; + bool arg5 = (bool) true ; + mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6805,15 +6036,24 @@ SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(s int ecode5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"point_mat", (char *)"elem_ids", (char *)"ips", (char *)"warn", (char *)"inv_trans", NULL + }; int result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OO:ParMesh_FindPoints", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_FindPoints" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -6821,7 +6061,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6829,7 +6069,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); } @@ -6837,149 +6077,23 @@ SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParMesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParMesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); - } - arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - int result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_FindPoints" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParMesh_FindPoints" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ParMesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5); + if (obj5) { + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ParMesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_FindPoints" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParMesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParMesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParMesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); { try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4); + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6992,115 +6106,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_ParMesh_FindPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_FindPoints", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_FindPoints__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParMesh_FindPoints__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__InverseElementTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_FindPoints__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_FindPoints'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool,mfem::InverseElementTransformation *)\n" - " mfem::ParMesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool)\n" - " mfem::ParMesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintSharedEntities(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintSharedEntities(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; @@ -7109,15 +6115,19 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintSharedEntities(PyObject *SWIGUNUSEDPARM( int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fname_prefix", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_PrintSharedEntities", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParMesh_PrintSharedEntities", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintSharedEntities" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintSharedEntities" "', argument " "2"" of type '" "char const *""'"); } @@ -7168,7 +6178,7 @@ SWIGINTERN PyObject *_wrap_delete_ParMesh(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; char *arg2 = (char *) 0 ; @@ -7194,7 +6204,7 @@ SWIGINTERN PyObject *_wrap_new_ParMesh__SWIG_10(PyObject *SWIGUNUSEDPARM(self), arg2 = reinterpret_cast< char * >(buf2); { try { - result = (mfem::ParMesh *)new_mfem_ParMesh__SWIG_10(arg1,(char const *)arg2); + result = (mfem::ParMesh *)new_mfem_ParMesh__SWIG_6(arg1,(char const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7217,19 +6227,14 @@ SWIGINTERN PyObject *_wrap_new_ParMesh(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_ParMesh", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParMesh__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParMesh, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_ParMesh__SWIG_2(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[1], NULL); _v = SWIG_CheckState(res); @@ -7239,7 +6244,7 @@ SWIGINTERN PyObject *_wrap_new_ParMesh(PyObject *self, PyObject *args) { } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 4)) { int _v; int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); _v = SWIG_CheckState(res); @@ -7248,11 +6253,32 @@ SWIGINTERN PyObject *_wrap_new_ParMesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParMesh__SWIG_6(self, argc, argv); + if (argc <= 2) { + return _wrap_new_ParMesh__SWIG_3(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_new_ParMesh__SWIG_3(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_ParMesh__SWIG_3(self, argc, argv); + } + } } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); _v = SWIG_CheckState(res); @@ -7261,7 +6287,16 @@ SWIGINTERN PyObject *_wrap_new_ParMesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParMesh__SWIG_8(self, argc, argv); + if (argc <= 2) { + return _wrap_new_ParMesh__SWIG_4(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_ParMesh__SWIG_4(self, argc, argv); + } } } } @@ -7273,7 +6308,7 @@ SWIGINTERN PyObject *_wrap_new_ParMesh(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParMesh__SWIG_10(self, argc, argv); + return _wrap_new_ParMesh__SWIG_6(self, argc, argv); } } } @@ -7300,95 +6335,26 @@ SWIGINTERN PyObject *_wrap_new_ParMesh(PyObject *self, PyObject *args) { _v = 1; } } - if (_v) { - return _wrap_new_ParMesh__SWIG_9(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); if (_v) { return _wrap_new_ParMesh__SWIG_5(self, argc, argv); } } } } - if (argc == 3) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ParMesh__SWIG_7(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ParMesh__SWIG_4(self, argc, argv); - } - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ParMesh'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParMesh::ParMesh(mfem::ParMesh const &,bool)\n" - " mfem::ParMesh::ParMesh(mfem::ParMesh const &)\n" " mfem::ParMesh::ParMesh(MPI_Comm,mfem::Mesh &,int *,int)\n" - " mfem::ParMesh::ParMesh(MPI_Comm,mfem::Mesh &,int *)\n" - " mfem::ParMesh::ParMesh(MPI_Comm,mfem::Mesh &)\n" " mfem::ParMesh::ParMesh(MPI_Comm,std::istream &,bool)\n" - " mfem::ParMesh::ParMesh(MPI_Comm,std::istream &)\n" " mfem::ParMesh::ParMesh(mfem::ParMesh *,int,int)\n" " mfem::ParMesh::ParMesh(MPI_Comm,char const *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ParMesh_ParPrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh_ParPrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; @@ -7398,24 +6364,29 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrintToFile(PyObject *SWIGUNUSEDPARM(self) int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mesh_file", (char *)"precision", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParMesh_ParPrintToFile", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParMesh_ParPrintToFile", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_ParPrintToFile" "', argument " "1"" of type '" "mfem::ParMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_ParPrintToFile" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -7434,18 +6405,18 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrintToFile(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Print" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -7456,53 +6427,17 @@ SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_ParMesh_Print__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_Print" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_ParMesh_Print__SWIG_2(arg1,(char const *)arg2); + mfem_ParMesh_Print__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7525,34 +6460,15 @@ SWIGINTERN PyObject *_wrap_ParMesh_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_Print__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_ParMesh_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -7567,7 +6483,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_Print(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -7576,6 +6492,9 @@ SWIGINTERN PyObject *_wrap_ParMesh_Print(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParMesh_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -7585,7 +6504,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_ParMesh_Print__SWIG_2(self, argc, argv); + return _wrap_ParMesh_Print__SWIG_1(self, argc, argv); } } } @@ -7595,25 +6514,23 @@ SWIGINTERN PyObject *_wrap_ParMesh_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParMesh::Print(std::ostream &) const\n" - " mfem::ParMesh::Print() const\n" - " mfem::ParMesh::Print(char const *,int)\n" - " mfem::ParMesh::Print(char const *)\n"); + " mfem::ParMesh::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ParMesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintXG" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -7624,53 +6541,17 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_ParMesh_PrintXG__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintXG" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_ParMesh_PrintXG__SWIG_2(arg1,(char const *)arg2); + mfem_ParMesh_PrintXG__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7693,34 +6574,15 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintXG(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_PrintXG", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintXG__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintXG__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_ParMesh_PrintXG__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -7735,7 +6597,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintXG(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -7744,6 +6606,9 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintXG(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParMesh_PrintXG__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -7753,79 +6618,33 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintXG(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_ParMesh_PrintXG__SWIG_2(self, argc, argv); + return _wrap_ParMesh_PrintXG__SWIG_1(self, argc, argv); } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_PrintXG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParMesh::PrintXG(std::ostream &) const\n" - " mfem::ParMesh::PrintXG() const\n" - " mfem::ParMesh::PrintXG(char const *,int)\n" - " mfem::ParMesh::PrintXG(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOne" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintAsOne" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_ParMesh_PrintAsOne__SWIG_2(arg1,(char const *)arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + } + } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; + fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_PrintXG'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::ParMesh::PrintXG(std::ostream &) const\n" + " mfem::ParMesh::PrintXG(char const *,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOne" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -7836,9 +6655,17 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne__SWIG_3(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintAsOne" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_ParMesh_PrintAsOne__SWIG_2(arg1,(char const *)arg2); + mfem_ParMesh_PrintAsOne__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7861,34 +6688,15 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_PrintAsOne", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintAsOne__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintAsOne__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_ParMesh_PrintAsOne__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -7903,7 +6711,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -7912,6 +6720,9 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParMesh_PrintAsOne__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -7921,7 +6732,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_ParMesh_PrintAsOne__SWIG_2(self, argc, argv); + return _wrap_ParMesh_PrintAsOne__SWIG_1(self, argc, argv); } } } @@ -7931,25 +6742,23 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOne(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_PrintAsOne'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParMesh::PrintAsOne(std::ostream &)\n" - " mfem::ParMesh::PrintAsOne()\n" - " mfem::ParMesh::PrintAsOne(char const *,int)\n" - " mfem::ParMesh::PrintAsOne(char const *)\n"); + " mfem::ParMesh::PrintAsOne(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOneXG" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -7960,53 +6769,17 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_2(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintAsOneXG" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_ParMesh_PrintAsOneXG__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintAsOneXG" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintAsOneXG" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_ParMesh_PrintAsOneXG__SWIG_2(arg1,(char const *)arg2); + mfem_ParMesh_PrintAsOneXG__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8029,34 +6802,15 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_PrintAsOneXG", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintAsOneXG__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintAsOneXG__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_ParMesh_PrintAsOneXG__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -8071,7 +6825,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG(PyObject *self, PyObject *args) } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -8080,6 +6834,9 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParMesh_PrintAsOneXG__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8089,7 +6846,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_ParMesh_PrintAsOneXG__SWIG_2(self, argc, argv); + return _wrap_ParMesh_PrintAsOneXG__SWIG_1(self, argc, argv); } } } @@ -8099,25 +6856,23 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintAsOneXG(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_PrintAsOneXG'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParMesh::PrintAsOneXG(std::ostream &)\n" - " mfem::ParMesh::PrintAsOneXG()\n" - " mfem::ParMesh::PrintAsOneXG(char const *,int)\n" - " mfem::ParMesh::PrintAsOneXG(char const *)\n"); + " mfem::ParMesh::PrintAsOneXG(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintInfo" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -8128,53 +6883,17 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_ParMesh_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_PrintInfo" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_ParMesh_PrintInfo__SWIG_2(arg1,(char const *)arg2); + mfem_ParMesh_PrintInfo__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8197,34 +6916,15 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "ParMesh_PrintInfo", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintInfo__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParMesh_PrintInfo__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_ParMesh_PrintInfo__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -8239,7 +6939,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -8248,6 +6948,9 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_ParMesh_PrintInfo__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8257,7 +6960,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_ParMesh_PrintInfo__SWIG_2(self, argc, argv); + return _wrap_ParMesh_PrintInfo__SWIG_1(self, argc, argv); } } } @@ -8267,9 +6970,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_PrintInfo(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_PrintInfo'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParMesh::PrintInfo(std::ostream &)\n" - " mfem::ParMesh::PrintInfo()\n" - " mfem::ParMesh::PrintInfo(char const *,int)\n" - " mfem::ParMesh::PrintInfo(char const *)\n"); + " mfem::ParMesh::PrintInfo(char const *,int)\n"); return 0; } @@ -8278,14 +6979,14 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint__SWIG_1(PyObject *SWIGUNUSEDPARM(sel PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_ParPrint" "', argument " "1"" of type '" "mfem::ParMesh *""'"); @@ -8296,11 +6997,13 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint__SWIG_1(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_ParPrint" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -8320,44 +7023,6 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint__SWIG_1(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_ParMesh_ParPrint__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh_ParPrint" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParMesh_ParPrint" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_ParMesh_ParPrint__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParMesh_ParPrint__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; void *argp1 = 0 ; @@ -8371,7 +7036,7 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint__SWIG_3(PyObject *SWIGUNUSEDPARM(sel arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { try { - mfem_ParMesh_ParPrint__SWIG_3(arg1); + mfem_ParMesh_ParPrint__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8398,10 +7063,10 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParMesh_ParPrint__SWIG_3(self, argc, argv); + return _wrap_ParMesh_ParPrint__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); @@ -8410,7 +7075,20 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_ParMesh_ParPrint__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_ParMesh_ParPrint__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_ParMesh_ParPrint__SWIG_1(self, argc, argv); + } } } } @@ -8434,36 +7112,12 @@ SWIGINTERN PyObject *_wrap_ParMesh_ParPrint(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ParMesh_ParPrint__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParMesh_ParPrint'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParMesh::ParPrint(std::ostream &) const\n" " mfem::ParMesh::ParPrint(char const *,int)\n" - " mfem::ParMesh::ParPrint(char const *)\n" " mfem::ParMesh::ParPrint()\n"); return 0; } @@ -8483,7 +7137,7 @@ SWIGINTERN PyObject *ParMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "ParMesh_Finalize", _wrap_ParMesh_Finalize, METH_VARARGS, "ParMesh_Finalize(ParMesh self, bool refine=False, bool fix_orientation=False)"}, + { "ParMesh_Finalize", (PyCFunction)(void(*)(void))_wrap_ParMesh_Finalize, METH_VARARGS|METH_KEYWORDS, "ParMesh_Finalize(ParMesh self, bool refine=False, bool fix_orientation=False)"}, { "ParMesh_SetAttributes", _wrap_ParMesh_SetAttributes, METH_O, "ParMesh_SetAttributes(ParMesh self)"}, { "ParMesh_GetComm", _wrap_ParMesh_GetComm, METH_O, "ParMesh_GetComm(ParMesh self) -> MPI_Comm"}, { "ParMesh_GetNRanks", _wrap_ParMesh_GetNRanks, METH_O, "ParMesh_GetNRanks(ParMesh self) -> int"}, @@ -8506,35 +7160,35 @@ static PyMethodDef SwigMethods[] = { { "ParMesh_pncmesh_set", _wrap_ParMesh_pncmesh_set, METH_VARARGS, "ParMesh_pncmesh_set(ParMesh self, ParNCMesh pncmesh)"}, { "ParMesh_pncmesh_get", _wrap_ParMesh_pncmesh_get, METH_O, "ParMesh_pncmesh_get(ParMesh self) -> ParNCMesh"}, { "ParMesh_GetNGroups", _wrap_ParMesh_GetNGroups, METH_O, "ParMesh_GetNGroups(ParMesh self) -> int"}, - { "ParMesh_GroupNVertices", _wrap_ParMesh_GroupNVertices, METH_VARARGS, "ParMesh_GroupNVertices(ParMesh self, int group) -> int"}, - { "ParMesh_GroupNEdges", _wrap_ParMesh_GroupNEdges, METH_VARARGS, "ParMesh_GroupNEdges(ParMesh self, int group) -> int"}, - { "ParMesh_GroupNTriangles", _wrap_ParMesh_GroupNTriangles, METH_VARARGS, "ParMesh_GroupNTriangles(ParMesh self, int group) -> int"}, - { "ParMesh_GroupNQuadrilaterals", _wrap_ParMesh_GroupNQuadrilaterals, METH_VARARGS, "ParMesh_GroupNQuadrilaterals(ParMesh self, int group) -> int"}, - { "ParMesh_GroupVertex", _wrap_ParMesh_GroupVertex, METH_VARARGS, "ParMesh_GroupVertex(ParMesh self, int group, int i) -> int"}, - { "ParMesh_GroupEdge", _wrap_ParMesh_GroupEdge, METH_VARARGS, "ParMesh_GroupEdge(ParMesh self, int group, int i, int & edge, int & o)"}, - { "ParMesh_GroupTriangle", _wrap_ParMesh_GroupTriangle, METH_VARARGS, "ParMesh_GroupTriangle(ParMesh self, int group, int i, int & face, int & o)"}, - { "ParMesh_GroupQuadrilateral", _wrap_ParMesh_GroupQuadrilateral, METH_VARARGS, "ParMesh_GroupQuadrilateral(ParMesh self, int group, int i, int & face, int & o)"}, - { "ParMesh_GenerateOffsets", _wrap_ParMesh_GenerateOffsets, METH_VARARGS, "ParMesh_GenerateOffsets(ParMesh self, int N, HYPRE_Int [] loc_sizes, mfem::Array< HYPRE_Int > *[] offsets)"}, + { "ParMesh_GroupNVertices", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNVertices, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupNVertices(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNEdges", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNEdges, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupNEdges(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNTriangles", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNTriangles, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupNTriangles(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNQuadrilaterals", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNQuadrilaterals, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupNQuadrilaterals(ParMesh self, int group) -> int"}, + { "ParMesh_GroupVertex", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupVertex, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupVertex(ParMesh self, int group, int i) -> int"}, + { "ParMesh_GroupEdge", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupEdge, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupEdge(ParMesh self, int group, int i, int & edge, int & o)"}, + { "ParMesh_GroupTriangle", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupTriangle, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupTriangle(ParMesh self, int group, int i, int & face, int & o)"}, + { "ParMesh_GroupQuadrilateral", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupQuadrilateral, METH_VARARGS|METH_KEYWORDS, "ParMesh_GroupQuadrilateral(ParMesh self, int group, int i, int & face, int & o)"}, + { "ParMesh_GenerateOffsets", (PyCFunction)(void(*)(void))_wrap_ParMesh_GenerateOffsets, METH_VARARGS|METH_KEYWORDS, "ParMesh_GenerateOffsets(ParMesh self, int N, HYPRE_Int [] loc_sizes, mfem::Array< HYPRE_Int > *[] offsets)"}, { "ParMesh_ExchangeFaceNbrData", _wrap_ParMesh_ExchangeFaceNbrData, METH_O, "ParMesh_ExchangeFaceNbrData(ParMesh self)"}, { "ParMesh_ExchangeFaceNbrNodes", _wrap_ParMesh_ExchangeFaceNbrNodes, METH_O, "ParMesh_ExchangeFaceNbrNodes(ParMesh self)"}, - { "ParMesh_SetCurvature", _wrap_ParMesh_SetCurvature, METH_VARARGS, "ParMesh_SetCurvature(ParMesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "ParMesh_SetCurvature", (PyCFunction)(void(*)(void))_wrap_ParMesh_SetCurvature, METH_VARARGS|METH_KEYWORDS, "ParMesh_SetCurvature(ParMesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, { "ParMesh_GetNFaceNeighbors", _wrap_ParMesh_GetNFaceNeighbors, METH_O, "ParMesh_GetNFaceNeighbors(ParMesh self) -> int"}, - { "ParMesh_GetFaceNbrGroup", _wrap_ParMesh_GetFaceNbrGroup, METH_VARARGS, "ParMesh_GetFaceNbrGroup(ParMesh self, int fn) -> int"}, - { "ParMesh_GetFaceNbrRank", _wrap_ParMesh_GetFaceNbrRank, METH_VARARGS, "ParMesh_GetFaceNbrRank(ParMesh self, int fn) -> int"}, + { "ParMesh_GetFaceNbrGroup", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetFaceNbrGroup, METH_VARARGS|METH_KEYWORDS, "ParMesh_GetFaceNbrGroup(ParMesh self, int fn) -> int"}, + { "ParMesh_GetFaceNbrRank", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetFaceNbrRank, METH_VARARGS|METH_KEYWORDS, "ParMesh_GetFaceNbrRank(ParMesh self, int fn) -> int"}, { "ParMesh_GetFaceToAllElementTable", _wrap_ParMesh_GetFaceToAllElementTable, METH_O, "ParMesh_GetFaceToAllElementTable(ParMesh self) -> Table"}, - { "ParMesh_GetSharedFaceTransformations", _wrap_ParMesh_GetSharedFaceTransformations, METH_VARARGS, "ParMesh_GetSharedFaceTransformations(ParMesh self, int sf, bool fill2=True) -> FaceElementTransformations"}, + { "ParMesh_GetSharedFaceTransformations", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetSharedFaceTransformations, METH_VARARGS|METH_KEYWORDS, "ParMesh_GetSharedFaceTransformations(ParMesh self, int sf, bool fill2=True) -> FaceElementTransformations"}, { "ParMesh_GetNSharedFaces", _wrap_ParMesh_GetNSharedFaces, METH_O, "ParMesh_GetNSharedFaces(ParMesh self) -> int"}, - { "ParMesh_GetSharedFace", _wrap_ParMesh_GetSharedFace, METH_VARARGS, "ParMesh_GetSharedFace(ParMesh self, int sface) -> int"}, + { "ParMesh_GetSharedFace", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetSharedFace, METH_VARARGS|METH_KEYWORDS, "ParMesh_GetSharedFace(ParMesh self, int sface) -> int"}, { "ParMesh_ReorientTetMesh", _wrap_ParMesh_ReorientTetMesh, METH_O, "ParMesh_ReorientTetMesh(ParMesh self)"}, - { "ParMesh_ReduceInt", _wrap_ParMesh_ReduceInt, METH_VARARGS, "ParMesh_ReduceInt(ParMesh self, int value) -> long"}, + { "ParMesh_ReduceInt", (PyCFunction)(void(*)(void))_wrap_ParMesh_ReduceInt, METH_VARARGS|METH_KEYWORDS, "ParMesh_ReduceInt(ParMesh self, int value) -> long"}, { "ParMesh_Rebalance", _wrap_ParMesh_Rebalance, METH_VARARGS, "\n" "ParMesh_Rebalance(ParMesh self)\n" "ParMesh_Rebalance(ParMesh self, intArray partition)\n" ""}, - { "ParMesh_GetBoundingBox", _wrap_ParMesh_GetBoundingBox, METH_VARARGS, "ParMesh_GetBoundingBox(ParMesh self, Vector p_min, Vector p_max, int ref=2)"}, - { "ParMesh_GetCharacteristics", _wrap_ParMesh_GetCharacteristics, METH_VARARGS, "ParMesh_GetCharacteristics(ParMesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max)"}, - { "ParMesh_FindPoints", _wrap_ParMesh_FindPoints, METH_VARARGS, "ParMesh_FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, - { "ParMesh_PrintSharedEntities", _wrap_ParMesh_PrintSharedEntities, METH_VARARGS, "ParMesh_PrintSharedEntities(ParMesh self, char const * fname_prefix)"}, + { "ParMesh_GetBoundingBox", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetBoundingBox, METH_VARARGS|METH_KEYWORDS, "ParMesh_GetBoundingBox(ParMesh self, Vector p_min, Vector p_max, int ref=2)"}, + { "ParMesh_GetCharacteristics", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetCharacteristics, METH_VARARGS|METH_KEYWORDS, "ParMesh_GetCharacteristics(ParMesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max)"}, + { "ParMesh_FindPoints", (PyCFunction)(void(*)(void))_wrap_ParMesh_FindPoints, METH_VARARGS|METH_KEYWORDS, "ParMesh_FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "ParMesh_PrintSharedEntities", (PyCFunction)(void(*)(void))_wrap_ParMesh_PrintSharedEntities, METH_VARARGS|METH_KEYWORDS, "ParMesh_PrintSharedEntities(ParMesh self, char const * fname_prefix)"}, { "delete_ParMesh", _wrap_delete_ParMesh, METH_O, "delete_ParMesh(ParMesh self)"}, { "new_ParMesh", _wrap_new_ParMesh, METH_VARARGS, "\n" "ParMesh(ParMesh pmesh, bool copy_nodes=True)\n" @@ -8543,7 +7197,7 @@ static PyMethodDef SwigMethods[] = { "ParMesh(ParMesh orig_mesh, int ref_factor, int ref_type)\n" "new_ParMesh(MPI_Comm comm, char const * mesh_file) -> ParMesh\n" ""}, - { "ParMesh_ParPrintToFile", _wrap_ParMesh_ParPrintToFile, METH_VARARGS, "ParMesh_ParPrintToFile(ParMesh self, char const * mesh_file, int const precision)"}, + { "ParMesh_ParPrintToFile", (PyCFunction)(void(*)(void))_wrap_ParMesh_ParPrintToFile, METH_VARARGS|METH_KEYWORDS, "ParMesh_ParPrintToFile(ParMesh self, char const * mesh_file, int const precision)"}, { "ParMesh_Print", _wrap_ParMesh_Print, METH_VARARGS, "\n" "ParMesh_Print(ParMesh self, std::ostream & out=mfem::out)\n" "ParMesh_Print(ParMesh self, char const * file, int precision=8)\n" @@ -8577,7 +7231,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "ParMesh_Finalize", _wrap_ParMesh_Finalize, METH_VARARGS, "Finalize(ParMesh self, bool refine=False, bool fix_orientation=False)"}, + { "ParMesh_Finalize", (PyCFunction)(void(*)(void))_wrap_ParMesh_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(ParMesh self, bool refine=False, bool fix_orientation=False)"}, { "ParMesh_SetAttributes", _wrap_ParMesh_SetAttributes, METH_O, "SetAttributes(ParMesh self)"}, { "ParMesh_GetComm", _wrap_ParMesh_GetComm, METH_O, "GetComm(ParMesh self) -> MPI_Comm"}, { "ParMesh_GetNRanks", _wrap_ParMesh_GetNRanks, METH_O, "GetNRanks(ParMesh self) -> int"}, @@ -8600,35 +7254,35 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "ParMesh_pncmesh_set", _wrap_ParMesh_pncmesh_set, METH_VARARGS, "ParMesh_pncmesh_set(ParMesh self, ParNCMesh pncmesh)"}, { "ParMesh_pncmesh_get", _wrap_ParMesh_pncmesh_get, METH_O, "ParMesh_pncmesh_get(ParMesh self) -> ParNCMesh"}, { "ParMesh_GetNGroups", _wrap_ParMesh_GetNGroups, METH_O, "GetNGroups(ParMesh self) -> int"}, - { "ParMesh_GroupNVertices", _wrap_ParMesh_GroupNVertices, METH_VARARGS, "GroupNVertices(ParMesh self, int group) -> int"}, - { "ParMesh_GroupNEdges", _wrap_ParMesh_GroupNEdges, METH_VARARGS, "GroupNEdges(ParMesh self, int group) -> int"}, - { "ParMesh_GroupNTriangles", _wrap_ParMesh_GroupNTriangles, METH_VARARGS, "GroupNTriangles(ParMesh self, int group) -> int"}, - { "ParMesh_GroupNQuadrilaterals", _wrap_ParMesh_GroupNQuadrilaterals, METH_VARARGS, "GroupNQuadrilaterals(ParMesh self, int group) -> int"}, - { "ParMesh_GroupVertex", _wrap_ParMesh_GroupVertex, METH_VARARGS, "GroupVertex(ParMesh self, int group, int i) -> int"}, - { "ParMesh_GroupEdge", _wrap_ParMesh_GroupEdge, METH_VARARGS, "GroupEdge(ParMesh self, int group, int i, int & edge, int & o)"}, - { "ParMesh_GroupTriangle", _wrap_ParMesh_GroupTriangle, METH_VARARGS, "GroupTriangle(ParMesh self, int group, int i, int & face, int & o)"}, - { "ParMesh_GroupQuadrilateral", _wrap_ParMesh_GroupQuadrilateral, METH_VARARGS, "GroupQuadrilateral(ParMesh self, int group, int i, int & face, int & o)"}, - { "ParMesh_GenerateOffsets", _wrap_ParMesh_GenerateOffsets, METH_VARARGS, "GenerateOffsets(ParMesh self, int N, HYPRE_Int [] loc_sizes, mfem::Array< HYPRE_Int > *[] offsets)"}, + { "ParMesh_GroupNVertices", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNVertices, METH_VARARGS|METH_KEYWORDS, "GroupNVertices(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNEdges", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNEdges, METH_VARARGS|METH_KEYWORDS, "GroupNEdges(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNTriangles", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNTriangles, METH_VARARGS|METH_KEYWORDS, "GroupNTriangles(ParMesh self, int group) -> int"}, + { "ParMesh_GroupNQuadrilaterals", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupNQuadrilaterals, METH_VARARGS|METH_KEYWORDS, "GroupNQuadrilaterals(ParMesh self, int group) -> int"}, + { "ParMesh_GroupVertex", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupVertex, METH_VARARGS|METH_KEYWORDS, "GroupVertex(ParMesh self, int group, int i) -> int"}, + { "ParMesh_GroupEdge", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupEdge, METH_VARARGS|METH_KEYWORDS, "GroupEdge(ParMesh self, int group, int i, int & edge, int & o)"}, + { "ParMesh_GroupTriangle", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupTriangle, METH_VARARGS|METH_KEYWORDS, "GroupTriangle(ParMesh self, int group, int i, int & face, int & o)"}, + { "ParMesh_GroupQuadrilateral", (PyCFunction)(void(*)(void))_wrap_ParMesh_GroupQuadrilateral, METH_VARARGS|METH_KEYWORDS, "GroupQuadrilateral(ParMesh self, int group, int i, int & face, int & o)"}, + { "ParMesh_GenerateOffsets", (PyCFunction)(void(*)(void))_wrap_ParMesh_GenerateOffsets, METH_VARARGS|METH_KEYWORDS, "GenerateOffsets(ParMesh self, int N, HYPRE_Int [] loc_sizes, mfem::Array< HYPRE_Int > *[] offsets)"}, { "ParMesh_ExchangeFaceNbrData", _wrap_ParMesh_ExchangeFaceNbrData, METH_O, "ExchangeFaceNbrData(ParMesh self)"}, { "ParMesh_ExchangeFaceNbrNodes", _wrap_ParMesh_ExchangeFaceNbrNodes, METH_O, "ExchangeFaceNbrNodes(ParMesh self)"}, - { "ParMesh_SetCurvature", _wrap_ParMesh_SetCurvature, METH_VARARGS, "SetCurvature(ParMesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "ParMesh_SetCurvature", (PyCFunction)(void(*)(void))_wrap_ParMesh_SetCurvature, METH_VARARGS|METH_KEYWORDS, "SetCurvature(ParMesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, { "ParMesh_GetNFaceNeighbors", _wrap_ParMesh_GetNFaceNeighbors, METH_O, "GetNFaceNeighbors(ParMesh self) -> int"}, - { "ParMesh_GetFaceNbrGroup", _wrap_ParMesh_GetFaceNbrGroup, METH_VARARGS, "GetFaceNbrGroup(ParMesh self, int fn) -> int"}, - { "ParMesh_GetFaceNbrRank", _wrap_ParMesh_GetFaceNbrRank, METH_VARARGS, "GetFaceNbrRank(ParMesh self, int fn) -> int"}, + { "ParMesh_GetFaceNbrGroup", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetFaceNbrGroup, METH_VARARGS|METH_KEYWORDS, "GetFaceNbrGroup(ParMesh self, int fn) -> int"}, + { "ParMesh_GetFaceNbrRank", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetFaceNbrRank, METH_VARARGS|METH_KEYWORDS, "GetFaceNbrRank(ParMesh self, int fn) -> int"}, { "ParMesh_GetFaceToAllElementTable", _wrap_ParMesh_GetFaceToAllElementTable, METH_O, "GetFaceToAllElementTable(ParMesh self) -> Table"}, - { "ParMesh_GetSharedFaceTransformations", _wrap_ParMesh_GetSharedFaceTransformations, METH_VARARGS, "GetSharedFaceTransformations(ParMesh self, int sf, bool fill2=True) -> FaceElementTransformations"}, + { "ParMesh_GetSharedFaceTransformations", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetSharedFaceTransformations, METH_VARARGS|METH_KEYWORDS, "GetSharedFaceTransformations(ParMesh self, int sf, bool fill2=True) -> FaceElementTransformations"}, { "ParMesh_GetNSharedFaces", _wrap_ParMesh_GetNSharedFaces, METH_O, "GetNSharedFaces(ParMesh self) -> int"}, - { "ParMesh_GetSharedFace", _wrap_ParMesh_GetSharedFace, METH_VARARGS, "GetSharedFace(ParMesh self, int sface) -> int"}, + { "ParMesh_GetSharedFace", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetSharedFace, METH_VARARGS|METH_KEYWORDS, "GetSharedFace(ParMesh self, int sface) -> int"}, { "ParMesh_ReorientTetMesh", _wrap_ParMesh_ReorientTetMesh, METH_O, "ReorientTetMesh(ParMesh self)"}, - { "ParMesh_ReduceInt", _wrap_ParMesh_ReduceInt, METH_VARARGS, "ReduceInt(ParMesh self, int value) -> long"}, + { "ParMesh_ReduceInt", (PyCFunction)(void(*)(void))_wrap_ParMesh_ReduceInt, METH_VARARGS|METH_KEYWORDS, "ReduceInt(ParMesh self, int value) -> long"}, { "ParMesh_Rebalance", _wrap_ParMesh_Rebalance, METH_VARARGS, "\n" "Rebalance(ParMesh self)\n" "Rebalance(ParMesh self, intArray partition)\n" ""}, - { "ParMesh_GetBoundingBox", _wrap_ParMesh_GetBoundingBox, METH_VARARGS, "GetBoundingBox(ParMesh self, Vector p_min, Vector p_max, int ref=2)"}, - { "ParMesh_GetCharacteristics", _wrap_ParMesh_GetCharacteristics, METH_VARARGS, "GetCharacteristics(ParMesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max)"}, - { "ParMesh_FindPoints", _wrap_ParMesh_FindPoints, METH_VARARGS, "FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, - { "ParMesh_PrintSharedEntities", _wrap_ParMesh_PrintSharedEntities, METH_VARARGS, "PrintSharedEntities(ParMesh self, char const * fname_prefix)"}, + { "ParMesh_GetBoundingBox", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetBoundingBox, METH_VARARGS|METH_KEYWORDS, "GetBoundingBox(ParMesh self, Vector p_min, Vector p_max, int ref=2)"}, + { "ParMesh_GetCharacteristics", (PyCFunction)(void(*)(void))_wrap_ParMesh_GetCharacteristics, METH_VARARGS|METH_KEYWORDS, "GetCharacteristics(ParMesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max)"}, + { "ParMesh_FindPoints", (PyCFunction)(void(*)(void))_wrap_ParMesh_FindPoints, METH_VARARGS|METH_KEYWORDS, "FindPoints(ParMesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "ParMesh_PrintSharedEntities", (PyCFunction)(void(*)(void))_wrap_ParMesh_PrintSharedEntities, METH_VARARGS|METH_KEYWORDS, "PrintSharedEntities(ParMesh self, char const * fname_prefix)"}, { "delete_ParMesh", _wrap_delete_ParMesh, METH_O, "delete_ParMesh(ParMesh self)"}, { "new_ParMesh", _wrap_new_ParMesh, METH_VARARGS, "\n" "ParMesh(ParMesh pmesh, bool copy_nodes=True)\n" @@ -8637,7 +7291,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ParMesh(ParMesh orig_mesh, int ref_factor, int ref_type)\n" "new_ParMesh(MPI_Comm comm, char const * mesh_file) -> ParMesh\n" ""}, - { "ParMesh_ParPrintToFile", _wrap_ParMesh_ParPrintToFile, METH_VARARGS, "ParPrintToFile(ParMesh self, char const * mesh_file, int const precision)"}, + { "ParMesh_ParPrintToFile", (PyCFunction)(void(*)(void))_wrap_ParMesh_ParPrintToFile, METH_VARARGS|METH_KEYWORDS, "ParPrintToFile(ParMesh self, char const * mesh_file, int const precision)"}, { "ParMesh_Print", _wrap_ParMesh_Print, METH_VARARGS, "\n" "Print(ParMesh self, std::ostream & out=mfem::out)\n" "Print(ParMesh self, char const * file, int precision=8)\n" @@ -9587,10 +8241,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); import_array(); diff --git a/mfem/_par/pncmesh_wrap.cxx b/mfem/_par/pncmesh_wrap.cxx index be73d2ba..641e01d4 100644 --- a/mfem/_par/pncmesh_wrap.cxx +++ b/mfem/_par/pncmesh_wrap.cxx @@ -3478,14 +3478,14 @@ SWIGINTERN PyObject *_wrap_new_ParNCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *resultobj = 0; MPI_Comm arg1 ; mfem::NCMesh *arg2 = 0 ; - int *arg3 = (int *) 0 ; + int *arg3 = (int *) NULL ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; mfem::ParNCMesh *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); @@ -3503,11 +3503,13 @@ SWIGINTERN PyObject *_wrap_new_ParNCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParNCMesh" "', argument " "2"" of type '" "mfem::NCMesh const &""'"); } arg2 = reinterpret_cast< mfem::NCMesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParNCMesh" "', argument " "3"" of type '" "int *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ParNCMesh" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); } - arg3 = reinterpret_cast< int * >(argp3); { try { result = (mfem::ParNCMesh *)new mfem::ParNCMesh(arg1,(mfem::NCMesh const &)*arg2,arg3); @@ -3524,47 +3526,6 @@ SWIGINTERN PyObject *_wrap_new_ParNCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_ParNCMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::NCMesh *arg2 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ParNCMesh *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParNCMesh" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParNCMesh" "', argument " "2"" of type '" "mfem::NCMesh const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParNCMesh" "', argument " "2"" of type '" "mfem::NCMesh const &""'"); - } - arg2 = reinterpret_cast< mfem::NCMesh * >(argp2); - { - try { - result = (mfem::ParNCMesh *)new mfem::ParNCMesh(arg1,(mfem::NCMesh const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParNCMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParNCMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = 0 ; void *argp1 = 0 ; @@ -3608,22 +3569,10 @@ SWIGINTERN PyObject *_wrap_new_ParNCMesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParNCMesh, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_ParNCMesh__SWIG_2(self, argc, argv); + return _wrap_new_ParNCMesh__SWIG_1(self, argc, argv); } } - if (argc == 2) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__NCMesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ParNCMesh__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); _v = SWIG_CheckState(res); @@ -3631,6 +3580,9 @@ SWIGINTERN PyObject *_wrap_new_ParNCMesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__NCMesh, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_ParNCMesh__SWIG_0(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); @@ -3645,7 +3597,6 @@ SWIGINTERN PyObject *_wrap_new_ParNCMesh(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ParNCMesh'.\n" " Possible C/C++ prototypes are:\n" " mfem::ParNCMesh::ParNCMesh(MPI_Comm,mfem::NCMesh const &,int *)\n" - " mfem::ParNCMesh::ParNCMesh(MPI_Comm,mfem::NCMesh const &)\n" " mfem::ParNCMesh::ParNCMesh(mfem::ParNCMesh const &)\n"); return 0; } @@ -3680,7 +3631,7 @@ SWIGINTERN PyObject *_wrap_delete_ParNCMesh(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_ParNCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::Array< mfem::Refinement > *arg2 = 0 ; @@ -3688,15 +3639,19 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refinements", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_Refine", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_Refine", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_Refine" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_Refine" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); } @@ -3719,25 +3674,29 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_ParNCMesh_LimitNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_LimitNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_nc_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_LimitNCLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_LimitNCLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_LimitNCLevel" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3754,7 +3713,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_LimitNCLevel(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ParNCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::Table *arg2 = 0 ; @@ -3766,15 +3725,21 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"deref_table", (char *)"level_ok", (char *)"max_nc_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_CheckDerefinementNCLevel", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParNCMesh_CheckDerefinementNCLevel", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_CheckDerefinementNCLevel" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_CheckDerefinementNCLevel" "', argument " "2"" of type '" "mfem::Table const &""'"); } @@ -3782,7 +3747,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParNCMesh_CheckDerefinementNCLevel" "', argument " "2"" of type '" "mfem::Table const &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParNCMesh_CheckDerefinementNCLevel" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -3791,10 +3756,10 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUS } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3811,7 +3776,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ParNCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -3819,15 +3784,19 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"derefs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_Derefine", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_Derefine", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_Derefine" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_Derefine" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -3850,56 +3819,36 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; - mfem::Array< int > *arg2 = (mfem::Array< int > *) 0 ; + mfem::Array< int > *arg2 = (mfem::Array< int > *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"custom_partition", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ParNCMesh_Rebalance", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_Rebalance" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_Rebalance" "', argument " "2"" of type '" "mfem::Array< int > const *""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->Rebalance((mfem::Array< int > const *)arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_Rebalance" "', argument " "2"" of type '" "mfem::Array< int > const *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_Rebalance" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { try { - (arg1)->Rebalance(); + (arg1)->Rebalance((mfem::Array< int > const *)arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3912,47 +3861,6 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_ParNCMesh_Rebalance(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParNCMesh_Rebalance", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParNCMesh_Rebalance__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParNCMesh_Rebalance__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParNCMesh_Rebalance'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParNCMesh::Rebalance(mfem::Array< int > const *)\n" - " mfem::ParNCMesh::Rebalance()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ParNCMesh_GetNElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; @@ -4193,26 +4101,30 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetSharedFaces(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetSharedList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetSharedList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"entity", NULL + }; mfem::NCMesh::NCList *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetSharedList", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_GetSharedList", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetSharedList" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4229,26 +4141,30 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetSharedList(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetFaceOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetFaceOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"index", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetFaceOrientation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_GetFaceOrientation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetFaceOrientation" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4265,33 +4181,38 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetFaceOrientation(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetEntityOwnerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetEntityOwnerId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"entity", (char *)"index", NULL + }; mfem::ParNCMesh::GroupId result; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetEntityOwnerId", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParNCMesh_GetEntityOwnerId", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetEntityOwnerId" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4308,33 +4229,38 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetEntityOwnerId(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetEntityGroupId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetEntityGroupId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"entity", (char *)"index", NULL + }; mfem::ParNCMesh::GroupId result; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetEntityGroupId", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParNCMesh_GetEntityGroupId", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetEntityGroupId" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4351,7 +4277,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetEntityGroupId(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::ParNCMesh::GroupId arg2 ; @@ -4359,16 +4285,20 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetGroup(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; short val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"id", NULL + }; mfem::ParNCMesh::CommGroup *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetGroup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_GetGroup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetGroup" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - ecode2 = SWIG_AsVal_short(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_short(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNCMesh_GetGroup" "', argument " "2"" of type '" "mfem::ParNCMesh::GroupId""'"); } @@ -4388,7 +4318,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetGroup(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_ParNCMesh_GroupContains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GroupContains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::ParNCMesh::GroupId arg2 ; @@ -4397,25 +4327,30 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GroupContains(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; short val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"id", (char *)"rank", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GroupContains", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParNCMesh_GroupContains", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GroupContains" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - ecode2 = SWIG_AsVal_short(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_short(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNCMesh_GroupContains" "', argument " "2"" of type '" "mfem::ParNCMesh::GroupId""'"); } arg2 = static_cast< mfem::ParNCMesh::GroupId >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4432,33 +4367,38 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GroupContains(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ParNCMesh_IsGhost(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_IsGhost(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"entity", (char *)"index", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_IsGhost", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParNCMesh_IsGhost", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_IsGhost" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4475,26 +4415,30 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_IsGhost(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_ParNCMesh_ElementRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_ElementRank(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"index", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_ElementRank", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_ElementRank", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_ElementRank" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4541,7 +4485,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetMyRank(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_ParNCMesh_SendRebalanceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_SendRebalanceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; int arg2 ; @@ -4556,21 +4500,28 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_SendRebalanceDofs(PyObject *SWIGUNUSEDPARM( int ecode4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"old_ndofs", (char *)"old_element_dofs", (char *)"old_global_offset", (char *)"space", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_SendRebalanceDofs", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ParNCMesh_SendRebalanceDofs", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_SendRebalanceDofs" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Table, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParNCMesh_SendRebalanceDofs" "', argument " "3"" of type '" "mfem::Table const &""'"); } @@ -4578,12 +4529,12 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_SendRebalanceDofs(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParNCMesh_SendRebalanceDofs" "', argument " "3"" of type '" "mfem::Table const &""'"); } arg3 = reinterpret_cast< mfem::Table * >(argp3); - ecode4 = SWIG_AsVal_long(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_long(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ParNCMesh_SendRebalanceDofs" "', argument " "4"" of type '" "long""'"); } arg4 = static_cast< long >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParNCMesh_SendRebalanceDofs" "', argument " "5"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -4603,7 +4554,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_SendRebalanceDofs(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_ParNCMesh_RecvRebalanceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_RecvRebalanceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4614,15 +4565,20 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_RecvRebalanceDofs(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"elements", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_RecvRebalanceDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParNCMesh_RecvRebalanceDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_RecvRebalanceDofs" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_RecvRebalanceDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -4630,7 +4586,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_RecvRebalanceDofs(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParNCMesh_RecvRebalanceDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_long_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_long_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParNCMesh_RecvRebalanceDofs" "', argument " "3"" of type '" "mfem::Array< long > &""'"); } @@ -4713,7 +4669,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetDerefineOldRanks(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_ParNCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4727,15 +4683,21 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"bdr_vertices", (char *)"bdr_edges", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetBoundaryClosure", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParNCMesh_GetBoundaryClosure", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetBoundaryClosure" "', argument " "1"" of type '" "mfem::ParNCMesh *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_GetBoundaryClosure" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -4743,7 +4705,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParNCMesh_GetBoundaryClosure" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParNCMesh_GetBoundaryClosure" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -4751,7 +4713,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParNCMesh_GetBoundaryClosure" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParNCMesh_GetBoundaryClosure" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -4803,27 +4765,34 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_Trim(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_ParNCMesh_MemoryUsage__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParNCMesh_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"with_base", NULL + }; long result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ParNCMesh_MemoryUsage", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_MemoryUsage" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNCMesh_MemoryUsage" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNCMesh_MemoryUsage" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (long)((mfem::ParNCMesh const *)arg1)->MemoryUsage(arg2); @@ -4839,128 +4808,37 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_MemoryUsage__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_ParNCMesh_MemoryUsage__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ParNCMesh_PrintMemoryDetail(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - long result; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_MemoryUsage" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - { - try { - result = (long)((mfem::ParNCMesh const *)arg1)->MemoryUsage(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_long(static_cast< long >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParNCMesh_MemoryUsage(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParNCMesh_MemoryUsage", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParNCMesh_MemoryUsage__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParNCMesh_MemoryUsage__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParNCMesh_MemoryUsage'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParNCMesh::MemoryUsage(bool) const\n" - " mfem::ParNCMesh::MemoryUsage() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParNCMesh_PrintMemoryDetail__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"with_base", NULL + }; int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ParNCMesh_PrintMemoryDetail", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_PrintMemoryDetail" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNCMesh_PrintMemoryDetail" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int)((mfem::ParNCMesh const *)arg1)->PrintMemoryDetail(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ParNCMesh_PrintMemoryDetail__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int result; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_PrintMemoryDetail" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNCMesh_PrintMemoryDetail" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); { try { - result = (int)((mfem::ParNCMesh const *)arg1)->PrintMemoryDetail(); + result = (int)((mfem::ParNCMesh const *)arg1)->PrintMemoryDetail(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4973,49 +4851,7 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_PrintMemoryDetail__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ParNCMesh_PrintMemoryDetail(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ParNCMesh_PrintMemoryDetail", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ParNCMesh_PrintMemoryDetail__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ParNCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ParNCMesh_PrintMemoryDetail__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ParNCMesh_PrintMemoryDetail'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParNCMesh::PrintMemoryDetail(bool) const\n" - " mfem::ParNCMesh::PrintMemoryDetail() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParNCMesh_GetDebugMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNCMesh_GetDebugMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNCMesh *arg1 = (mfem::ParNCMesh *) 0 ; mfem::Mesh *arg2 = 0 ; @@ -5023,15 +4859,19 @@ SWIGINTERN PyObject *_wrap_ParNCMesh_GetDebugMesh(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"debug_mesh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNCMesh_GetDebugMesh", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNCMesh_GetDebugMesh", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNCMesh_GetDebugMesh" "', argument " "1"" of type '" "mfem::ParNCMesh const *""'"); } arg1 = reinterpret_cast< mfem::ParNCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNCMesh_GetDebugMesh" "', argument " "2"" of type '" "mfem::Mesh &""'"); } @@ -5065,7 +4905,7 @@ SWIGINTERN PyObject *ParNCMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh::MeshId *arg1 = 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; @@ -5073,11 +4913,15 @@ SWIGINTERN PyObject *_wrap___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "__lt__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:__lt__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__lt__" "', argument " "1"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -5085,7 +4929,7 @@ SWIGINTERN PyObject *_wrap___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lt__" "', argument " "1"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg1 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lt__" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -5110,7 +4954,7 @@ SWIGINTERN PyObject *_wrap___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args } -SWIGINTERN PyObject *_wrap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh::MeshId *arg1 = 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; @@ -5118,11 +4962,15 @@ SWIGINTERN PyObject *_wrap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "__eq__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:__eq__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "__eq__" "', argument " "1"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -5130,7 +4978,7 @@ SWIGINTERN PyObject *_wrap___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__eq__" "', argument " "1"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg1 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__eq__" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -5163,11 +5011,11 @@ static PyMethodDef SwigMethods[] = { "new_ParNCMesh(ParNCMesh other) -> ParNCMesh\n" ""}, { "delete_ParNCMesh", _wrap_delete_ParNCMesh, METH_O, "delete_ParNCMesh(ParNCMesh self)"}, - { "ParNCMesh_Refine", _wrap_ParNCMesh_Refine, METH_VARARGS, "ParNCMesh_Refine(ParNCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, - { "ParNCMesh_LimitNCLevel", _wrap_ParNCMesh_LimitNCLevel, METH_VARARGS, "ParNCMesh_LimitNCLevel(ParNCMesh self, int max_nc_level)"}, - { "ParNCMesh_CheckDerefinementNCLevel", _wrap_ParNCMesh_CheckDerefinementNCLevel, METH_VARARGS, "ParNCMesh_CheckDerefinementNCLevel(ParNCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, - { "ParNCMesh_Derefine", _wrap_ParNCMesh_Derefine, METH_VARARGS, "ParNCMesh_Derefine(ParNCMesh self, intArray derefs)"}, - { "ParNCMesh_Rebalance", _wrap_ParNCMesh_Rebalance, METH_VARARGS, "ParNCMesh_Rebalance(ParNCMesh self, intArray custom_partition=None)"}, + { "ParNCMesh_Refine", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_Refine, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_Refine(ParNCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "ParNCMesh_LimitNCLevel", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_LimitNCLevel, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_LimitNCLevel(ParNCMesh self, int max_nc_level)"}, + { "ParNCMesh_CheckDerefinementNCLevel", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_CheckDerefinementNCLevel, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_CheckDerefinementNCLevel(ParNCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "ParNCMesh_Derefine", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_Derefine, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_Derefine(ParNCMesh self, intArray derefs)"}, + { "ParNCMesh_Rebalance", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_Rebalance, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_Rebalance(ParNCMesh self, intArray custom_partition=None)"}, { "ParNCMesh_GetNElements", _wrap_ParNCMesh_GetNElements, METH_O, "ParNCMesh_GetNElements(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostVertices", _wrap_ParNCMesh_GetNGhostVertices, METH_O, "ParNCMesh_GetNGhostVertices(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostEdges", _wrap_ParNCMesh_GetNGhostEdges, METH_O, "ParNCMesh_GetNGhostEdges(ParNCMesh self) -> int"}, @@ -5176,28 +5024,28 @@ static PyMethodDef SwigMethods[] = { { "ParNCMesh_GetSharedVertices", _wrap_ParNCMesh_GetSharedVertices, METH_O, "ParNCMesh_GetSharedVertices(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, { "ParNCMesh_GetSharedEdges", _wrap_ParNCMesh_GetSharedEdges, METH_O, "ParNCMesh_GetSharedEdges(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, { "ParNCMesh_GetSharedFaces", _wrap_ParNCMesh_GetSharedFaces, METH_O, "ParNCMesh_GetSharedFaces(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, - { "ParNCMesh_GetSharedList", _wrap_ParNCMesh_GetSharedList, METH_VARARGS, "ParNCMesh_GetSharedList(ParNCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, - { "ParNCMesh_GetFaceOrientation", _wrap_ParNCMesh_GetFaceOrientation, METH_VARARGS, "ParNCMesh_GetFaceOrientation(ParNCMesh self, int index) -> int"}, - { "ParNCMesh_GetEntityOwnerId", _wrap_ParNCMesh_GetEntityOwnerId, METH_VARARGS, "ParNCMesh_GetEntityOwnerId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, - { "ParNCMesh_GetEntityGroupId", _wrap_ParNCMesh_GetEntityGroupId, METH_VARARGS, "ParNCMesh_GetEntityGroupId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, - { "ParNCMesh_GetGroup", _wrap_ParNCMesh_GetGroup, METH_VARARGS, "ParNCMesh_GetGroup(ParNCMesh self, mfem::ParNCMesh::GroupId id) -> mfem::ParNCMesh::CommGroup const &"}, - { "ParNCMesh_GroupContains", _wrap_ParNCMesh_GroupContains, METH_VARARGS, "ParNCMesh_GroupContains(ParNCMesh self, mfem::ParNCMesh::GroupId id, int rank) -> bool"}, - { "ParNCMesh_IsGhost", _wrap_ParNCMesh_IsGhost, METH_VARARGS, "ParNCMesh_IsGhost(ParNCMesh self, int entity, int index) -> bool"}, - { "ParNCMesh_ElementRank", _wrap_ParNCMesh_ElementRank, METH_VARARGS, "ParNCMesh_ElementRank(ParNCMesh self, int index) -> int"}, + { "ParNCMesh_GetSharedList", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetSharedList, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GetSharedList(ParNCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "ParNCMesh_GetFaceOrientation", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetFaceOrientation, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GetFaceOrientation(ParNCMesh self, int index) -> int"}, + { "ParNCMesh_GetEntityOwnerId", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetEntityOwnerId, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GetEntityOwnerId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, + { "ParNCMesh_GetEntityGroupId", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetEntityGroupId, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GetEntityGroupId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, + { "ParNCMesh_GetGroup", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetGroup, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GetGroup(ParNCMesh self, mfem::ParNCMesh::GroupId id) -> mfem::ParNCMesh::CommGroup const &"}, + { "ParNCMesh_GroupContains", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GroupContains, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GroupContains(ParNCMesh self, mfem::ParNCMesh::GroupId id, int rank) -> bool"}, + { "ParNCMesh_IsGhost", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_IsGhost, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_IsGhost(ParNCMesh self, int entity, int index) -> bool"}, + { "ParNCMesh_ElementRank", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_ElementRank, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_ElementRank(ParNCMesh self, int index) -> int"}, { "ParNCMesh_GetMyRank", _wrap_ParNCMesh_GetMyRank, METH_O, "ParNCMesh_GetMyRank(ParNCMesh self) -> int"}, - { "ParNCMesh_SendRebalanceDofs", _wrap_ParNCMesh_SendRebalanceDofs, METH_VARARGS, "ParNCMesh_SendRebalanceDofs(ParNCMesh self, int old_ndofs, Table old_element_dofs, long old_global_offset, FiniteElementSpace space)"}, - { "ParNCMesh_RecvRebalanceDofs", _wrap_ParNCMesh_RecvRebalanceDofs, METH_VARARGS, "ParNCMesh_RecvRebalanceDofs(ParNCMesh self, intArray elements, mfem::Array< long > & dofs)"}, + { "ParNCMesh_SendRebalanceDofs", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_SendRebalanceDofs, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_SendRebalanceDofs(ParNCMesh self, int old_ndofs, Table old_element_dofs, long old_global_offset, FiniteElementSpace space)"}, + { "ParNCMesh_RecvRebalanceDofs", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_RecvRebalanceDofs, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_RecvRebalanceDofs(ParNCMesh self, intArray elements, mfem::Array< long > & dofs)"}, { "ParNCMesh_GetRebalanceOldIndex", _wrap_ParNCMesh_GetRebalanceOldIndex, METH_O, "ParNCMesh_GetRebalanceOldIndex(ParNCMesh self) -> intArray"}, { "ParNCMesh_GetDerefineOldRanks", _wrap_ParNCMesh_GetDerefineOldRanks, METH_O, "ParNCMesh_GetDerefineOldRanks(ParNCMesh self) -> intArray"}, - { "ParNCMesh_GetBoundaryClosure", _wrap_ParNCMesh_GetBoundaryClosure, METH_VARARGS, "ParNCMesh_GetBoundaryClosure(ParNCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "ParNCMesh_GetBoundaryClosure", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetBoundaryClosure, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GetBoundaryClosure(ParNCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, { "ParNCMesh_Trim", _wrap_ParNCMesh_Trim, METH_O, "ParNCMesh_Trim(ParNCMesh self)"}, - { "ParNCMesh_MemoryUsage", _wrap_ParNCMesh_MemoryUsage, METH_VARARGS, "ParNCMesh_MemoryUsage(ParNCMesh self, bool with_base=True) -> long"}, - { "ParNCMesh_PrintMemoryDetail", _wrap_ParNCMesh_PrintMemoryDetail, METH_VARARGS, "ParNCMesh_PrintMemoryDetail(ParNCMesh self, bool with_base=True) -> int"}, - { "ParNCMesh_GetDebugMesh", _wrap_ParNCMesh_GetDebugMesh, METH_VARARGS, "ParNCMesh_GetDebugMesh(ParNCMesh self, Mesh debug_mesh)"}, + { "ParNCMesh_MemoryUsage", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_MemoryUsage, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_MemoryUsage(ParNCMesh self, bool with_base=True) -> long"}, + { "ParNCMesh_PrintMemoryDetail", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_PrintMemoryDetail, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_PrintMemoryDetail(ParNCMesh self, bool with_base=True) -> int"}, + { "ParNCMesh_GetDebugMesh", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetDebugMesh, METH_VARARGS|METH_KEYWORDS, "ParNCMesh_GetDebugMesh(ParNCMesh self, Mesh debug_mesh)"}, { "ParNCMesh_swigregister", ParNCMesh_swigregister, METH_O, NULL}, { "ParNCMesh_swiginit", ParNCMesh_swiginit, METH_VARARGS, NULL}, - { "__lt__", _wrap___lt__, METH_VARARGS, "__lt__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, - { "__eq__", _wrap___eq__, METH_VARARGS, "__eq__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, + { "__lt__", (PyCFunction)(void(*)(void))_wrap___lt__, METH_VARARGS|METH_KEYWORDS, "__lt__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, + { "__eq__", (PyCFunction)(void(*)(void))_wrap___eq__, METH_VARARGS|METH_KEYWORDS, "__eq__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, { NULL, NULL, 0, NULL } }; @@ -5209,11 +5057,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_ParNCMesh(ParNCMesh other) -> ParNCMesh\n" ""}, { "delete_ParNCMesh", _wrap_delete_ParNCMesh, METH_O, "delete_ParNCMesh(ParNCMesh self)"}, - { "ParNCMesh_Refine", _wrap_ParNCMesh_Refine, METH_VARARGS, "Refine(ParNCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, - { "ParNCMesh_LimitNCLevel", _wrap_ParNCMesh_LimitNCLevel, METH_VARARGS, "LimitNCLevel(ParNCMesh self, int max_nc_level)"}, - { "ParNCMesh_CheckDerefinementNCLevel", _wrap_ParNCMesh_CheckDerefinementNCLevel, METH_VARARGS, "CheckDerefinementNCLevel(ParNCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, - { "ParNCMesh_Derefine", _wrap_ParNCMesh_Derefine, METH_VARARGS, "Derefine(ParNCMesh self, intArray derefs)"}, - { "ParNCMesh_Rebalance", _wrap_ParNCMesh_Rebalance, METH_VARARGS, "Rebalance(ParNCMesh self, intArray custom_partition=None)"}, + { "ParNCMesh_Refine", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_Refine, METH_VARARGS|METH_KEYWORDS, "Refine(ParNCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "ParNCMesh_LimitNCLevel", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_LimitNCLevel, METH_VARARGS|METH_KEYWORDS, "LimitNCLevel(ParNCMesh self, int max_nc_level)"}, + { "ParNCMesh_CheckDerefinementNCLevel", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_CheckDerefinementNCLevel, METH_VARARGS|METH_KEYWORDS, "CheckDerefinementNCLevel(ParNCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "ParNCMesh_Derefine", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_Derefine, METH_VARARGS|METH_KEYWORDS, "Derefine(ParNCMesh self, intArray derefs)"}, + { "ParNCMesh_Rebalance", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_Rebalance, METH_VARARGS|METH_KEYWORDS, "Rebalance(ParNCMesh self, intArray custom_partition=None)"}, { "ParNCMesh_GetNElements", _wrap_ParNCMesh_GetNElements, METH_O, "GetNElements(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostVertices", _wrap_ParNCMesh_GetNGhostVertices, METH_O, "GetNGhostVertices(ParNCMesh self) -> int"}, { "ParNCMesh_GetNGhostEdges", _wrap_ParNCMesh_GetNGhostEdges, METH_O, "GetNGhostEdges(ParNCMesh self) -> int"}, @@ -5222,28 +5070,28 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "ParNCMesh_GetSharedVertices", _wrap_ParNCMesh_GetSharedVertices, METH_O, "GetSharedVertices(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, { "ParNCMesh_GetSharedEdges", _wrap_ParNCMesh_GetSharedEdges, METH_O, "GetSharedEdges(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, { "ParNCMesh_GetSharedFaces", _wrap_ParNCMesh_GetSharedFaces, METH_O, "GetSharedFaces(ParNCMesh self) -> mfem::NCMesh::NCList const &"}, - { "ParNCMesh_GetSharedList", _wrap_ParNCMesh_GetSharedList, METH_VARARGS, "GetSharedList(ParNCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, - { "ParNCMesh_GetFaceOrientation", _wrap_ParNCMesh_GetFaceOrientation, METH_VARARGS, "GetFaceOrientation(ParNCMesh self, int index) -> int"}, - { "ParNCMesh_GetEntityOwnerId", _wrap_ParNCMesh_GetEntityOwnerId, METH_VARARGS, "GetEntityOwnerId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, - { "ParNCMesh_GetEntityGroupId", _wrap_ParNCMesh_GetEntityGroupId, METH_VARARGS, "GetEntityGroupId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, - { "ParNCMesh_GetGroup", _wrap_ParNCMesh_GetGroup, METH_VARARGS, "GetGroup(ParNCMesh self, mfem::ParNCMesh::GroupId id) -> mfem::ParNCMesh::CommGroup const &"}, - { "ParNCMesh_GroupContains", _wrap_ParNCMesh_GroupContains, METH_VARARGS, "GroupContains(ParNCMesh self, mfem::ParNCMesh::GroupId id, int rank) -> bool"}, - { "ParNCMesh_IsGhost", _wrap_ParNCMesh_IsGhost, METH_VARARGS, "IsGhost(ParNCMesh self, int entity, int index) -> bool"}, - { "ParNCMesh_ElementRank", _wrap_ParNCMesh_ElementRank, METH_VARARGS, "ElementRank(ParNCMesh self, int index) -> int"}, + { "ParNCMesh_GetSharedList", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetSharedList, METH_VARARGS|METH_KEYWORDS, "GetSharedList(ParNCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "ParNCMesh_GetFaceOrientation", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetFaceOrientation, METH_VARARGS|METH_KEYWORDS, "GetFaceOrientation(ParNCMesh self, int index) -> int"}, + { "ParNCMesh_GetEntityOwnerId", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetEntityOwnerId, METH_VARARGS|METH_KEYWORDS, "GetEntityOwnerId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, + { "ParNCMesh_GetEntityGroupId", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetEntityGroupId, METH_VARARGS|METH_KEYWORDS, "GetEntityGroupId(ParNCMesh self, int entity, int index) -> mfem::ParNCMesh::GroupId"}, + { "ParNCMesh_GetGroup", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetGroup, METH_VARARGS|METH_KEYWORDS, "GetGroup(ParNCMesh self, mfem::ParNCMesh::GroupId id) -> mfem::ParNCMesh::CommGroup const &"}, + { "ParNCMesh_GroupContains", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GroupContains, METH_VARARGS|METH_KEYWORDS, "GroupContains(ParNCMesh self, mfem::ParNCMesh::GroupId id, int rank) -> bool"}, + { "ParNCMesh_IsGhost", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_IsGhost, METH_VARARGS|METH_KEYWORDS, "IsGhost(ParNCMesh self, int entity, int index) -> bool"}, + { "ParNCMesh_ElementRank", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_ElementRank, METH_VARARGS|METH_KEYWORDS, "ElementRank(ParNCMesh self, int index) -> int"}, { "ParNCMesh_GetMyRank", _wrap_ParNCMesh_GetMyRank, METH_O, "GetMyRank(ParNCMesh self) -> int"}, - { "ParNCMesh_SendRebalanceDofs", _wrap_ParNCMesh_SendRebalanceDofs, METH_VARARGS, "SendRebalanceDofs(ParNCMesh self, int old_ndofs, Table old_element_dofs, long old_global_offset, FiniteElementSpace space)"}, - { "ParNCMesh_RecvRebalanceDofs", _wrap_ParNCMesh_RecvRebalanceDofs, METH_VARARGS, "RecvRebalanceDofs(ParNCMesh self, intArray elements, mfem::Array< long > & dofs)"}, + { "ParNCMesh_SendRebalanceDofs", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_SendRebalanceDofs, METH_VARARGS|METH_KEYWORDS, "SendRebalanceDofs(ParNCMesh self, int old_ndofs, Table old_element_dofs, long old_global_offset, FiniteElementSpace space)"}, + { "ParNCMesh_RecvRebalanceDofs", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_RecvRebalanceDofs, METH_VARARGS|METH_KEYWORDS, "RecvRebalanceDofs(ParNCMesh self, intArray elements, mfem::Array< long > & dofs)"}, { "ParNCMesh_GetRebalanceOldIndex", _wrap_ParNCMesh_GetRebalanceOldIndex, METH_O, "GetRebalanceOldIndex(ParNCMesh self) -> intArray"}, { "ParNCMesh_GetDerefineOldRanks", _wrap_ParNCMesh_GetDerefineOldRanks, METH_O, "GetDerefineOldRanks(ParNCMesh self) -> intArray"}, - { "ParNCMesh_GetBoundaryClosure", _wrap_ParNCMesh_GetBoundaryClosure, METH_VARARGS, "GetBoundaryClosure(ParNCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "ParNCMesh_GetBoundaryClosure", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetBoundaryClosure, METH_VARARGS|METH_KEYWORDS, "GetBoundaryClosure(ParNCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, { "ParNCMesh_Trim", _wrap_ParNCMesh_Trim, METH_O, "Trim(ParNCMesh self)"}, - { "ParNCMesh_MemoryUsage", _wrap_ParNCMesh_MemoryUsage, METH_VARARGS, "MemoryUsage(ParNCMesh self, bool with_base=True) -> long"}, - { "ParNCMesh_PrintMemoryDetail", _wrap_ParNCMesh_PrintMemoryDetail, METH_VARARGS, "PrintMemoryDetail(ParNCMesh self, bool with_base=True) -> int"}, - { "ParNCMesh_GetDebugMesh", _wrap_ParNCMesh_GetDebugMesh, METH_VARARGS, "GetDebugMesh(ParNCMesh self, Mesh debug_mesh)"}, + { "ParNCMesh_MemoryUsage", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_MemoryUsage, METH_VARARGS|METH_KEYWORDS, "MemoryUsage(ParNCMesh self, bool with_base=True) -> long"}, + { "ParNCMesh_PrintMemoryDetail", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_PrintMemoryDetail, METH_VARARGS|METH_KEYWORDS, "PrintMemoryDetail(ParNCMesh self, bool with_base=True) -> int"}, + { "ParNCMesh_GetDebugMesh", (PyCFunction)(void(*)(void))_wrap_ParNCMesh_GetDebugMesh, METH_VARARGS|METH_KEYWORDS, "GetDebugMesh(ParNCMesh self, Mesh debug_mesh)"}, { "ParNCMesh_swigregister", ParNCMesh_swigregister, METH_O, NULL}, { "ParNCMesh_swiginit", ParNCMesh_swiginit, METH_VARARGS, NULL}, - { "__lt__", _wrap___lt__, METH_VARARGS, "__lt__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, - { "__eq__", _wrap___eq__, METH_VARARGS, "__eq__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, + { "__lt__", (PyCFunction)(void(*)(void))_wrap___lt__, METH_VARARGS|METH_KEYWORDS, "__lt__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, + { "__eq__", (PyCFunction)(void(*)(void))_wrap___eq__, METH_VARARGS|METH_KEYWORDS, "__eq__(mfem::NCMesh::MeshId const & a, mfem::NCMesh::MeshId const & b) -> bool"}, { NULL, NULL, 0, NULL } }; @@ -6115,10 +5963,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/pnonlinearform_wrap.cxx b/mfem/_par/pnonlinearform_wrap.cxx index 6b737c1d..f7916180 100644 --- a/mfem/_par/pnonlinearform_wrap.cxx +++ b/mfem/_par/pnonlinearform_wrap.cxx @@ -3470,17 +3470,19 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_ParNonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ParNonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = (mfem::ParFiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"pf", NULL + }; mfem::ParNonlinearForm *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ParNonlinearForm", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParNonlinearForm" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace *""'"); } @@ -3540,7 +3542,7 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_ParFESpace(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetParGridFunctionEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetParGridFunctionEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNonlinearForm *arg1 = (mfem::ParNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3548,16 +3550,20 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetParGridFunctionEnergy(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ParNonlinearForm_GetParGridFunctionEnergy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNonlinearForm_GetParGridFunctionEnergy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNonlinearForm_GetParGridFunctionEnergy" "', argument " "1"" of type '" "mfem::ParNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNonlinearForm_GetParGridFunctionEnergy" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3717,7 +3723,7 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetEnergy(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_ParNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNonlinearForm *arg1 = (mfem::ParNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3728,15 +3734,20 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNonlinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParNonlinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNonlinearForm_Mult" "', argument " "1"" of type '" "mfem::ParNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3744,7 +3755,7 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParNonlinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3772,7 +3783,7 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetLocalGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetLocalGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNonlinearForm *arg1 = (mfem::ParNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3780,16 +3791,20 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetLocalGradient(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParNonlinearForm_GetLocalGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNonlinearForm_GetLocalGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNonlinearForm_GetLocalGradient" "', argument " "1"" of type '" "mfem::ParNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNonlinearForm_GetLocalGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3817,7 +3832,7 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetLocalGradient(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNonlinearForm *arg1 = (mfem::ParNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3825,16 +3840,20 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParNonlinearForm_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNonlinearForm_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNonlinearForm_GetGradient" "', argument " "1"" of type '" "mfem::ParNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParNonlinearForm_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3862,7 +3881,7 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ParNonlinearForm_SetGradientType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParNonlinearForm_SetGradientType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParNonlinearForm *arg1 = (mfem::ParNonlinearForm *) 0 ; mfem::Operator::Type arg2 ; @@ -3870,15 +3889,19 @@ SWIGINTERN PyObject *_wrap_ParNonlinearForm_SetGradientType(PyObject *SWIGUNUSED int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParNonlinearForm_SetGradientType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParNonlinearForm_SetGradientType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParNonlinearForm_SetGradientType" "', argument " "1"" of type '" "mfem::ParNonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParNonlinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParNonlinearForm_SetGradientType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -4260,16 +4283,20 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_ParFESpace(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetParSpaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetParSpaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBlockNonlinearForm *arg1 = (mfem::ParBlockNonlinearForm *) 0 ; mfem::Array< mfem::ParFiniteElementSpace * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParBlockNonlinearForm_SetParSpaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParBlockNonlinearForm_SetParSpaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBlockNonlinearForm_SetParSpaces" "', argument " "1"" of type '" "mfem::ParBlockNonlinearForm *""'"); } @@ -4277,12 +4304,12 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetParSpaces(PyObject *SWIGUNUS { // List/Tuple -> mfem::ParFiniteElementSpace * int res = 0; - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); arg2 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::ParFiniteElementSpace * ttt; - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -4295,12 +4322,12 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetParSpaces(PyObject *SWIGUNUS } arg2[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); arg2 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::ParFiniteElementSpace * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -4349,17 +4376,22 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetParSpaces(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBlockNonlinearForm *arg1 = (mfem::ParBlockNonlinearForm *) 0 ; mfem::Array< mfem::Array< int > * > *arg2 = 0 ; mfem::Array< mfem::Vector * > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"rhs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParBlockNonlinearForm_SetEssentialBC", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParBlockNonlinearForm_SetEssentialBC", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBlockNonlinearForm_SetEssentialBC" "', argument " "1"" of type '" "mfem::ParBlockNonlinearForm *""'"); } @@ -4367,12 +4399,12 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetEssentialBC(PyObject *SWIGUN { // List/Tuple -> mfem::Array * int res = 0; - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); arg2 = new mfem::Array *>(ll); for (int i = 0; i < ll; i++) { mfem::Array * ttt; - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -4385,12 +4417,12 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetEssentialBC(PyObject *SWIGUN } arg2[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); arg2 = new mfem::Array *>(ll); for (int i = 0; i < ll; i++) { mfem::Array * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -4412,12 +4444,12 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetEssentialBC(PyObject *SWIGUN { // List/Tuple -> mfem::Vector * int res = 0; - if (PyList_Check(swig_obj[2])) { - int ll = PyList_Size(swig_obj[2]); + if (PyList_Check(obj2)) { + int ll = PyList_Size(obj2); arg3 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::Vector * ttt; - PyObject *s = PyList_GetItem(swig_obj[2],i); + PyObject *s = PyList_GetItem(obj2,i); if (s == Py_None){ ttt = NULL; } else { @@ -4430,12 +4462,12 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetEssentialBC(PyObject *SWIGUN } arg3[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[2])) { - int ll = PyTuple_Size(swig_obj[2]); + } else if (PyTuple_Check(obj2)) { + int ll = PyTuple_Size(obj2); arg3 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::Vector * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[2],i); + PyObject *s = PyTuple_GetItem(obj2,i); if (s == Py_None){ ttt = NULL; } else { @@ -4494,7 +4526,7 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetEssentialBC(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBlockNonlinearForm *arg1 = (mfem::ParBlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4505,15 +4537,20 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParBlockNonlinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParBlockNonlinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBlockNonlinearForm_Mult" "', argument " "1"" of type '" "mfem::ParBlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParBlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBlockNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4521,7 +4558,7 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParBlockNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParBlockNonlinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4549,7 +4586,7 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetLocalGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetLocalGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBlockNonlinearForm *arg1 = (mfem::ParBlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4557,16 +4594,20 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetLocalGradient(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::BlockOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParBlockNonlinearForm_GetLocalGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParBlockNonlinearForm_GetLocalGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBlockNonlinearForm_GetLocalGradient" "', argument " "1"" of type '" "mfem::ParBlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParBlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBlockNonlinearForm_GetLocalGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4594,7 +4635,7 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetLocalGradient(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBlockNonlinearForm *arg1 = (mfem::ParBlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4602,16 +4643,20 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetGradient(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::BlockOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ParBlockNonlinearForm_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParBlockNonlinearForm_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBlockNonlinearForm_GetGradient" "', argument " "1"" of type '" "mfem::ParBlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::ParBlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParBlockNonlinearForm_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4639,7 +4684,7 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_GetGradient(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetGradientType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetGradientType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParBlockNonlinearForm *arg1 = (mfem::ParBlockNonlinearForm *) 0 ; mfem::Operator::Type arg2 ; @@ -4647,15 +4692,19 @@ SWIGINTERN PyObject *_wrap_ParBlockNonlinearForm_SetGradientType(PyObject *SWIGU int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParBlockNonlinearForm_SetGradientType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParBlockNonlinearForm_SetGradientType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParBlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParBlockNonlinearForm_SetGradientType" "', argument " "1"" of type '" "mfem::ParBlockNonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::ParBlockNonlinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ParBlockNonlinearForm_SetGradientType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -4728,17 +4777,17 @@ SWIGINTERN PyObject *ParBlockNonlinearForm_swiginit(PyObject *SWIGUNUSEDPARM(sel static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ParNonlinearForm", _wrap_new_ParNonlinearForm, METH_O, "new_ParNonlinearForm(ParFiniteElementSpace pf) -> ParNonlinearForm"}, + { "new_ParNonlinearForm", (PyCFunction)(void(*)(void))_wrap_new_ParNonlinearForm, METH_VARARGS|METH_KEYWORDS, "new_ParNonlinearForm(ParFiniteElementSpace pf) -> ParNonlinearForm"}, { "ParNonlinearForm_ParFESpace", _wrap_ParNonlinearForm_ParFESpace, METH_O, "ParNonlinearForm_ParFESpace(ParNonlinearForm self) -> ParFiniteElementSpace"}, - { "ParNonlinearForm_GetParGridFunctionEnergy", _wrap_ParNonlinearForm_GetParGridFunctionEnergy, METH_VARARGS, "ParNonlinearForm_GetParGridFunctionEnergy(ParNonlinearForm self, Vector x) -> double"}, + { "ParNonlinearForm_GetParGridFunctionEnergy", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_GetParGridFunctionEnergy, METH_VARARGS|METH_KEYWORDS, "ParNonlinearForm_GetParGridFunctionEnergy(ParNonlinearForm self, Vector x) -> double"}, { "ParNonlinearForm_GetEnergy", _wrap_ParNonlinearForm_GetEnergy, METH_VARARGS, "\n" "ParNonlinearForm_GetEnergy(ParNonlinearForm self, ParGridFunction x) -> double\n" "ParNonlinearForm_GetEnergy(ParNonlinearForm self, Vector x) -> double\n" ""}, - { "ParNonlinearForm_Mult", _wrap_ParNonlinearForm_Mult, METH_VARARGS, "ParNonlinearForm_Mult(ParNonlinearForm self, Vector x, Vector y)"}, - { "ParNonlinearForm_GetLocalGradient", _wrap_ParNonlinearForm_GetLocalGradient, METH_VARARGS, "ParNonlinearForm_GetLocalGradient(ParNonlinearForm self, Vector x) -> SparseMatrix"}, - { "ParNonlinearForm_GetGradient", _wrap_ParNonlinearForm_GetGradient, METH_VARARGS, "ParNonlinearForm_GetGradient(ParNonlinearForm self, Vector x) -> Operator"}, - { "ParNonlinearForm_SetGradientType", _wrap_ParNonlinearForm_SetGradientType, METH_VARARGS, "ParNonlinearForm_SetGradientType(ParNonlinearForm self, mfem::Operator::Type tid)"}, + { "ParNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "ParNonlinearForm_Mult(ParNonlinearForm self, Vector x, Vector y)"}, + { "ParNonlinearForm_GetLocalGradient", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_GetLocalGradient, METH_VARARGS|METH_KEYWORDS, "ParNonlinearForm_GetLocalGradient(ParNonlinearForm self, Vector x) -> SparseMatrix"}, + { "ParNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "ParNonlinearForm_GetGradient(ParNonlinearForm self, Vector x) -> Operator"}, + { "ParNonlinearForm_SetGradientType", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_SetGradientType, METH_VARARGS|METH_KEYWORDS, "ParNonlinearForm_SetGradientType(ParNonlinearForm self, mfem::Operator::Type tid)"}, { "ParNonlinearForm_Update", _wrap_ParNonlinearForm_Update, METH_O, "ParNonlinearForm_Update(ParNonlinearForm self)"}, { "delete_ParNonlinearForm", _wrap_delete_ParNonlinearForm, METH_O, "delete_ParNonlinearForm(ParNonlinearForm self)"}, { "ParNonlinearForm_swigregister", ParNonlinearForm_swigregister, METH_O, NULL}, @@ -4751,12 +4800,12 @@ static PyMethodDef SwigMethods[] = { "ParBlockNonlinearForm_ParFESpace(ParBlockNonlinearForm self, int k) -> ParFiniteElementSpace\n" "ParBlockNonlinearForm_ParFESpace(ParBlockNonlinearForm self, int k) -> ParFiniteElementSpace\n" ""}, - { "ParBlockNonlinearForm_SetParSpaces", _wrap_ParBlockNonlinearForm_SetParSpaces, METH_VARARGS, "ParBlockNonlinearForm_SetParSpaces(ParBlockNonlinearForm self, mfem::Array< mfem::ParFiniteElementSpace * > & pf)"}, - { "ParBlockNonlinearForm_SetEssentialBC", _wrap_ParBlockNonlinearForm_SetEssentialBC, METH_VARARGS, "ParBlockNonlinearForm_SetEssentialBC(ParBlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, - { "ParBlockNonlinearForm_Mult", _wrap_ParBlockNonlinearForm_Mult, METH_VARARGS, "ParBlockNonlinearForm_Mult(ParBlockNonlinearForm self, Vector x, Vector y)"}, - { "ParBlockNonlinearForm_GetLocalGradient", _wrap_ParBlockNonlinearForm_GetLocalGradient, METH_VARARGS, "ParBlockNonlinearForm_GetLocalGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, - { "ParBlockNonlinearForm_GetGradient", _wrap_ParBlockNonlinearForm_GetGradient, METH_VARARGS, "ParBlockNonlinearForm_GetGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, - { "ParBlockNonlinearForm_SetGradientType", _wrap_ParBlockNonlinearForm_SetGradientType, METH_VARARGS, "ParBlockNonlinearForm_SetGradientType(ParBlockNonlinearForm self, mfem::Operator::Type tid)"}, + { "ParBlockNonlinearForm_SetParSpaces", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_SetParSpaces, METH_VARARGS|METH_KEYWORDS, "ParBlockNonlinearForm_SetParSpaces(ParBlockNonlinearForm self, mfem::Array< mfem::ParFiniteElementSpace * > & pf)"}, + { "ParBlockNonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "ParBlockNonlinearForm_SetEssentialBC(ParBlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "ParBlockNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "ParBlockNonlinearForm_Mult(ParBlockNonlinearForm self, Vector x, Vector y)"}, + { "ParBlockNonlinearForm_GetLocalGradient", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_GetLocalGradient, METH_VARARGS|METH_KEYWORDS, "ParBlockNonlinearForm_GetLocalGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, + { "ParBlockNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "ParBlockNonlinearForm_GetGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, + { "ParBlockNonlinearForm_SetGradientType", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_SetGradientType, METH_VARARGS|METH_KEYWORDS, "ParBlockNonlinearForm_SetGradientType(ParBlockNonlinearForm self, mfem::Operator::Type tid)"}, { "delete_ParBlockNonlinearForm", _wrap_delete_ParBlockNonlinearForm, METH_O, "delete_ParBlockNonlinearForm(ParBlockNonlinearForm self)"}, { "ParBlockNonlinearForm_swigregister", ParBlockNonlinearForm_swigregister, METH_O, NULL}, { "ParBlockNonlinearForm_swiginit", ParBlockNonlinearForm_swiginit, METH_VARARGS, NULL}, @@ -4766,17 +4815,17 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ParNonlinearForm", _wrap_new_ParNonlinearForm, METH_O, "new_ParNonlinearForm(ParFiniteElementSpace pf) -> ParNonlinearForm"}, + { "new_ParNonlinearForm", (PyCFunction)(void(*)(void))_wrap_new_ParNonlinearForm, METH_VARARGS|METH_KEYWORDS, "new_ParNonlinearForm(ParFiniteElementSpace pf) -> ParNonlinearForm"}, { "ParNonlinearForm_ParFESpace", _wrap_ParNonlinearForm_ParFESpace, METH_O, "ParFESpace(ParNonlinearForm self) -> ParFiniteElementSpace"}, - { "ParNonlinearForm_GetParGridFunctionEnergy", _wrap_ParNonlinearForm_GetParGridFunctionEnergy, METH_VARARGS, "GetParGridFunctionEnergy(ParNonlinearForm self, Vector x) -> double"}, + { "ParNonlinearForm_GetParGridFunctionEnergy", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_GetParGridFunctionEnergy, METH_VARARGS|METH_KEYWORDS, "GetParGridFunctionEnergy(ParNonlinearForm self, Vector x) -> double"}, { "ParNonlinearForm_GetEnergy", _wrap_ParNonlinearForm_GetEnergy, METH_VARARGS, "\n" "GetEnergy(ParNonlinearForm self, ParGridFunction x) -> double\n" "GetEnergy(ParNonlinearForm self, Vector x) -> double\n" ""}, - { "ParNonlinearForm_Mult", _wrap_ParNonlinearForm_Mult, METH_VARARGS, "Mult(ParNonlinearForm self, Vector x, Vector y)"}, - { "ParNonlinearForm_GetLocalGradient", _wrap_ParNonlinearForm_GetLocalGradient, METH_VARARGS, "GetLocalGradient(ParNonlinearForm self, Vector x) -> SparseMatrix"}, - { "ParNonlinearForm_GetGradient", _wrap_ParNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(ParNonlinearForm self, Vector x) -> Operator"}, - { "ParNonlinearForm_SetGradientType", _wrap_ParNonlinearForm_SetGradientType, METH_VARARGS, "SetGradientType(ParNonlinearForm self, mfem::Operator::Type tid)"}, + { "ParNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ParNonlinearForm self, Vector x, Vector y)"}, + { "ParNonlinearForm_GetLocalGradient", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_GetLocalGradient, METH_VARARGS|METH_KEYWORDS, "GetLocalGradient(ParNonlinearForm self, Vector x) -> SparseMatrix"}, + { "ParNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(ParNonlinearForm self, Vector x) -> Operator"}, + { "ParNonlinearForm_SetGradientType", (PyCFunction)(void(*)(void))_wrap_ParNonlinearForm_SetGradientType, METH_VARARGS|METH_KEYWORDS, "SetGradientType(ParNonlinearForm self, mfem::Operator::Type tid)"}, { "ParNonlinearForm_Update", _wrap_ParNonlinearForm_Update, METH_O, "Update(ParNonlinearForm self)"}, { "delete_ParNonlinearForm", _wrap_delete_ParNonlinearForm, METH_O, "delete_ParNonlinearForm(ParNonlinearForm self)"}, { "ParNonlinearForm_swigregister", ParNonlinearForm_swigregister, METH_O, NULL}, @@ -4789,12 +4838,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ParFESpace(ParBlockNonlinearForm self, int k) -> ParFiniteElementSpace\n" "ParFESpace(ParBlockNonlinearForm self, int k) -> ParFiniteElementSpace\n" ""}, - { "ParBlockNonlinearForm_SetParSpaces", _wrap_ParBlockNonlinearForm_SetParSpaces, METH_VARARGS, "SetParSpaces(ParBlockNonlinearForm self, mfem::Array< mfem::ParFiniteElementSpace * > & pf)"}, - { "ParBlockNonlinearForm_SetEssentialBC", _wrap_ParBlockNonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(ParBlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, - { "ParBlockNonlinearForm_Mult", _wrap_ParBlockNonlinearForm_Mult, METH_VARARGS, "Mult(ParBlockNonlinearForm self, Vector x, Vector y)"}, - { "ParBlockNonlinearForm_GetLocalGradient", _wrap_ParBlockNonlinearForm_GetLocalGradient, METH_VARARGS, "GetLocalGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, - { "ParBlockNonlinearForm_GetGradient", _wrap_ParBlockNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, - { "ParBlockNonlinearForm_SetGradientType", _wrap_ParBlockNonlinearForm_SetGradientType, METH_VARARGS, "SetGradientType(ParBlockNonlinearForm self, mfem::Operator::Type tid)"}, + { "ParBlockNonlinearForm_SetParSpaces", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_SetParSpaces, METH_VARARGS|METH_KEYWORDS, "SetParSpaces(ParBlockNonlinearForm self, mfem::Array< mfem::ParFiniteElementSpace * > & pf)"}, + { "ParBlockNonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "SetEssentialBC(ParBlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "ParBlockNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ParBlockNonlinearForm self, Vector x, Vector y)"}, + { "ParBlockNonlinearForm_GetLocalGradient", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_GetLocalGradient, METH_VARARGS|METH_KEYWORDS, "GetLocalGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, + { "ParBlockNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(ParBlockNonlinearForm self, Vector x) -> BlockOperator"}, + { "ParBlockNonlinearForm_SetGradientType", (PyCFunction)(void(*)(void))_wrap_ParBlockNonlinearForm_SetGradientType, METH_VARARGS|METH_KEYWORDS, "SetGradientType(ParBlockNonlinearForm self, mfem::Operator::Type tid)"}, { "delete_ParBlockNonlinearForm", _wrap_delete_ParBlockNonlinearForm, METH_O, "delete_ParBlockNonlinearForm(ParBlockNonlinearForm self)"}, { "ParBlockNonlinearForm_swigregister", ParBlockNonlinearForm_swigregister, METH_O, NULL}, { "ParBlockNonlinearForm_swiginit", ParBlockNonlinearForm_swiginit, METH_VARARGS, NULL}, @@ -6007,10 +6056,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/point_wrap.cxx b/mfem/_par/point_wrap.cxx index ab32885a..66f9de52 100644 --- a/mfem/_par/point_wrap.cxx +++ b/mfem/_par/point_wrap.cxx @@ -3229,11 +3229,11 @@ SWIGINTERN PyObject *_wrap_new_Point__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_Point__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; - int arg2 ; + int arg2 = (int) -1 ; int temp1 ; mfem::Point *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if (PyInt_Check(swig_obj[0])) { temp1 = PyInt_AsLong(swig_obj[0]); @@ -3245,14 +3245,16 @@ SWIGINTERN PyObject *_wrap_new_Point__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } arg1 = &temp1; } - { - if (PyInt_Check(swig_obj[1])) { - arg2 = PyInt_AsLong(swig_obj[1]); - } else if ((PyArray_PyIntAsInt(swig_obj[1]) != -1) || !PyErr_Occurred()) { - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; + if (swig_obj[1]) { + { + if (PyInt_Check(swig_obj[1])) { + arg2 = PyInt_AsLong(swig_obj[1]); + } else if ((PyArray_PyIntAsInt(swig_obj[1]) != -1) || !PyErr_Occurred()) { + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } } } { @@ -3275,44 +3277,6 @@ SWIGINTERN PyObject *_wrap_new_Point__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_new_Point__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int *arg1 = (int *) 0 ; - int temp1 ; - mfem::Point *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if (PyInt_Check(swig_obj[0])) { - temp1 = PyInt_AsLong(swig_obj[0]); - } else if ((PyArray_PyIntAsInt(swig_obj[0]) != -1) || !PyErr_Occurred()) { - temp1 = PyArray_PyIntAsInt(swig_obj[0]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; - } - arg1 = &temp1; - } - { - try { - result = (mfem::Point *)new mfem::Point((int const *)arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Point, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { @@ -3324,7 +3288,7 @@ SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Point__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if (PyInt_Check(argv[0])) { @@ -3336,21 +3300,9 @@ SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Point__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if (PyInt_Check(argv[0])) { - _v = 1; - } else if ((PyArray_PyIntAsInt(argv[0]) != -1) || !PyErr_Occurred()) { - _v = 1; - } else { - _v = 0; + if (argc <= 1) { + return _wrap_new_Point__SWIG_1(self, argc, argv); } - } - if (_v) { { if (PyInt_Check(argv[1])) { _v = 1; @@ -3370,8 +3322,7 @@ SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Point'.\n" " Possible C/C++ prototypes are:\n" " mfem::Point::Point()\n" - " mfem::Point::Point(int const *,int)\n" - " mfem::Point::Point(int const *)\n"); + " mfem::Point::Point(int const *,int)\n"); return 0; } @@ -3600,26 +3551,30 @@ SWIGINTERN PyObject *_wrap_Point_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Point_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ei", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Point_GetEdgeVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_GetEdgeVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3759,26 +3714,30 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Point_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_GetNFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3800,26 +3759,30 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Point_GetFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_GetFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetFaceVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3841,7 +3804,7 @@ SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Point_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -3849,16 +3812,20 @@ SWIGINTERN PyObject *_wrap_Point_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::Element *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Point_Duplicate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_Duplicate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Duplicate" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point_Duplicate" "', argument " "2"" of type '" "mfem::Mesh *""'"); } @@ -3963,7 +3930,7 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" "Point()\n" - "Point(int const * ind, int attr=-1)\n" + "new_Point(int const * ind, int attr=-1) -> Point\n" ""}, { "Point_GetType", _wrap_Point_GetType, METH_O, "Point_GetType(Point self) -> mfem::Element::Type"}, { "Point_GetVertices", _wrap_Point_GetVertices, METH_VARARGS, "\n" @@ -3972,14 +3939,14 @@ static PyMethodDef SwigMethods[] = { ""}, { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "Point_GetNVertices(Point self) -> int"}, { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "Point_GetNEdges(Point self) -> int"}, - { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "Point_GetEdgeVertices(Point self, int ei) -> int const *"}, + { "Point_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Point_GetEdgeVertices(Point self, int ei) -> int const *"}, { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" "Point_GetNFaces(Point self, int & nFaceVertices) -> int\n" "Point_GetNFaces(Point self) -> int\n" ""}, - { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "Point_GetNFaceVertices(Point self, int arg2) -> int"}, - { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "Point_GetFaceVertices(Point self, int fi) -> int const *"}, - { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Point_Duplicate(Point self, mfem::Mesh * m) -> Element"}, + { "Point_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "Point_GetNFaceVertices(Point self, int arg2) -> int"}, + { "Point_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Point_GetFaceVertices(Point self, int fi) -> int const *"}, + { "Point_Duplicate", (PyCFunction)(void(*)(void))_wrap_Point_Duplicate, METH_VARARGS|METH_KEYWORDS, "Point_Duplicate(Point self, mfem::Mesh * m) -> Element"}, { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, { "Point_swigregister", Point_swigregister, METH_O, NULL}, { "Point_swiginit", Point_swiginit, METH_VARARGS, NULL}, @@ -3991,7 +3958,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" "Point()\n" - "Point(int const * ind, int attr=-1)\n" + "new_Point(int const * ind, int attr=-1) -> Point\n" ""}, { "Point_GetType", _wrap_Point_GetType, METH_O, "GetType(Point self) -> mfem::Element::Type"}, { "Point_GetVertices", _wrap_Point_GetVertices, METH_VARARGS, "\n" @@ -4000,14 +3967,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "GetNVertices(Point self) -> int"}, { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "GetNEdges(Point self) -> int"}, - { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Point self, int ei) -> int const *"}, + { "Point_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Point self, int ei) -> int const *"}, { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" "GetNFaces(Point self, int & nFaceVertices) -> int\n" "GetNFaces(Point self) -> int\n" ""}, - { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Point self, int arg2) -> int"}, - { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Point self, int fi) -> int const *"}, - { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Duplicate(Point self, mfem::Mesh * m) -> Element"}, + { "Point_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetNFaceVertices(Point self, int arg2) -> int"}, + { "Point_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Point self, int fi) -> int const *"}, + { "Point_Duplicate", (PyCFunction)(void(*)(void))_wrap_Point_Duplicate, METH_VARARGS|METH_KEYWORDS, "Duplicate(Point self, mfem::Mesh * m) -> Element"}, { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, { "Point_swigregister", Point_swigregister, METH_O, NULL}, { "Point_swiginit", Point_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/prestriction.py b/mfem/_par/prestriction.py index 6c1787ff..62a32ea6 100644 --- a/mfem/_par/prestriction.py +++ b/mfem/_par/prestriction.py @@ -100,9 +100,9 @@ class ParL2FaceRestriction(mfem._par.operators.Operator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ParL2FaceRestriction self, mfem::ParFiniteElementSpace const & arg2, mfem::ElementDofOrdering arg3, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued) -> ParL2FaceRestriction""" - _prestriction.ParL2FaceRestriction_swiginit(self, _prestriction.new_ParL2FaceRestriction(*args)) + _prestriction.ParL2FaceRestriction_swiginit(self, _prestriction.new_ParL2FaceRestriction(*args, **kwargs)) def Mult(self, x, y): r"""Mult(ParL2FaceRestriction self, Vector x, Vector y)""" diff --git a/mfem/_par/prestriction_wrap.cxx b/mfem/_par/prestriction_wrap.cxx index 3692118f..1de63bf6 100644 --- a/mfem/_par/prestriction_wrap.cxx +++ b/mfem/_par/prestriction_wrap.cxx @@ -3394,12 +3394,12 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParFiniteElementSpace *arg1 = 0 ; mfem::ElementDofOrdering arg2 ; mfem::FaceType arg3 ; - mfem::L2FaceValues arg4 ; + mfem::L2FaceValues arg4 = (mfem::L2FaceValues) mfem::L2FaceValues::DoubleValued ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -3408,10 +3408,17 @@ SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction__SWIG_0(PyObject *SWIGUNUSED int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"arg1", (char *)"arg2", (char *)"type", (char *)"m", NULL + }; mfem::ParL2FaceRestriction *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_ParL2FaceRestriction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); } @@ -3419,71 +3426,26 @@ SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ParL2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParL2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } arg3 = static_cast< mfem::FaceType >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParL2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); - } - arg4 = static_cast< mfem::L2FaceValues >(val4); - { - try { - result = (mfem::ParL2FaceRestriction *)new mfem::ParL2FaceRestriction((mfem::ParFiniteElementSpace const &)*arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParL2FaceRestriction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ParFiniteElementSpace *arg1 = 0 ; - mfem::ElementDofOrdering arg2 ; - mfem::FaceType arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::ParL2FaceRestriction *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ParFiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ParL2FaceRestriction" "', argument " "1"" of type '" "mfem::ParFiniteElementSpace const &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ParL2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); } - arg1 = reinterpret_cast< mfem::ParFiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ParL2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ParL2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); - } - arg3 = static_cast< mfem::FaceType >(val3); { try { - result = (mfem::ParL2FaceRestriction *)new mfem::ParL2FaceRestriction((mfem::ParFiniteElementSpace const &)*arg1,arg2,arg3); + result = (mfem::ParL2FaceRestriction *)new mfem::ParL2FaceRestriction((mfem::ParFiniteElementSpace const &)*arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3496,71 +3458,7 @@ SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_ParL2FaceRestriction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ParL2FaceRestriction", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ParL2FaceRestriction__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ParFiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ParL2FaceRestriction__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ParL2FaceRestriction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ParL2FaceRestriction::ParL2FaceRestriction(mfem::ParFiniteElementSpace const &,mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues)\n" - " mfem::ParL2FaceRestriction::ParL2FaceRestriction(mfem::ParFiniteElementSpace const &,mfem::ElementDofOrdering,mfem::FaceType)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParL2FaceRestriction *arg1 = (mfem::ParL2FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3571,15 +3469,20 @@ SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParL2FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParL2FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParL2FaceRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParL2FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParL2FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::ParL2FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ParL2FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParL2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3587,7 +3490,7 @@ SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParL2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParL2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3610,7 +3513,7 @@ SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParL2FaceRestriction *arg1 = (mfem::ParL2FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3621,15 +3524,20 @@ SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_MultTranspose(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParL2FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParL2FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ParL2FaceRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParL2FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ParL2FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ParL2FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3637,7 +3545,7 @@ SWIGINTERN PyObject *_wrap_ParL2FaceRestriction_MultTranspose(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParL2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3703,9 +3611,9 @@ SWIGINTERN PyObject *ParL2FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ParL2FaceRestriction", _wrap_new_ParL2FaceRestriction, METH_VARARGS, "ParL2FaceRestriction(mfem::ParFiniteElementSpace const & arg1, mfem::ElementDofOrdering arg2, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued)"}, - { "ParL2FaceRestriction_Mult", _wrap_ParL2FaceRestriction_Mult, METH_VARARGS, "ParL2FaceRestriction_Mult(ParL2FaceRestriction self, Vector x, Vector y)"}, - { "ParL2FaceRestriction_MultTranspose", _wrap_ParL2FaceRestriction_MultTranspose, METH_VARARGS, "ParL2FaceRestriction_MultTranspose(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "new_ParL2FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_ParL2FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_ParL2FaceRestriction(mfem::ParFiniteElementSpace const & arg1, mfem::ElementDofOrdering arg2, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued) -> ParL2FaceRestriction"}, + { "ParL2FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_ParL2FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "ParL2FaceRestriction_Mult(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "ParL2FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ParL2FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ParL2FaceRestriction_MultTranspose(ParL2FaceRestriction self, Vector x, Vector y)"}, { "delete_ParL2FaceRestriction", _wrap_delete_ParL2FaceRestriction, METH_O, "delete_ParL2FaceRestriction(ParL2FaceRestriction self)"}, { "ParL2FaceRestriction_swigregister", ParL2FaceRestriction_swigregister, METH_O, NULL}, { "ParL2FaceRestriction_swiginit", ParL2FaceRestriction_swiginit, METH_VARARGS, NULL}, @@ -3715,9 +3623,9 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ParL2FaceRestriction", _wrap_new_ParL2FaceRestriction, METH_VARARGS, "ParL2FaceRestriction(mfem::ParFiniteElementSpace const & arg1, mfem::ElementDofOrdering arg2, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued)"}, - { "ParL2FaceRestriction_Mult", _wrap_ParL2FaceRestriction_Mult, METH_VARARGS, "Mult(ParL2FaceRestriction self, Vector x, Vector y)"}, - { "ParL2FaceRestriction_MultTranspose", _wrap_ParL2FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "new_ParL2FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_ParL2FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_ParL2FaceRestriction(mfem::ParFiniteElementSpace const & arg1, mfem::ElementDofOrdering arg2, mfem::FaceType type, mfem::L2FaceValues m=DoubleValued) -> ParL2FaceRestriction"}, + { "ParL2FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_ParL2FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ParL2FaceRestriction self, Vector x, Vector y)"}, + { "ParL2FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ParL2FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ParL2FaceRestriction self, Vector x, Vector y)"}, { "delete_ParL2FaceRestriction", _wrap_delete_ParL2FaceRestriction, METH_O, "delete_ParL2FaceRestriction(ParL2FaceRestriction self)"}, { "ParL2FaceRestriction_swigregister", ParL2FaceRestriction_swigregister, METH_O, NULL}, { "ParL2FaceRestriction_swiginit", ParL2FaceRestriction_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/pumi.py b/mfem/_par/pumi.py index ee270026..798c9b70 100644 --- a/mfem/_par/pumi.py +++ b/mfem/_par/pumi.py @@ -222,9 +222,6 @@ def __init__(self, apf_mesh, generate_edges=0, refine=1, fix_orientation=True): def Load(self, *args): r""" Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True) - Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1) - Load(PumiMesh self, std::istream & input, int generate_edges=0) - Load(PumiMesh self, std::istream & input) Load(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True) """ return _pumi.PumiMesh_Load(self, *args) diff --git a/mfem/_par/pumi_wrap.cxx b/mfem/_par/pumi_wrap.cxx index 33b63dec..306fdf95 100644 --- a/mfem/_par/pumi_wrap.cxx +++ b/mfem/_par/pumi_wrap.cxx @@ -3556,7 +3556,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -3564,15 +3564,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -3631,17 +3635,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -3700,7 +3706,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -3708,15 +3714,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -3775,17 +3785,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -3809,634 +3821,155 @@ SWIGINTERN PyObject *doublep_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ParMesh2ParPumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParMesh2ParPumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParMesh *arg1 = (mfem::ParMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::ParPumiMesh *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh2ParPumiMesh" "', argument " "1"" of type '" "mfem::ParMesh *""'"); - } - arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); - { - try { - result = (mfem::ParPumiMesh *)ParMesh2ParPumiMesh(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::PumiMesh *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); - } - arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PumiMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::PumiMesh *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); - } - arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::PumiMesh *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); - } - arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PumiMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::PumiMesh *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); - } - arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); - { - try { - result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PumiMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_PumiMesh", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_PumiMesh__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_PumiMesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_PumiMesh__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_PumiMesh__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PumiMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::PumiMesh::PumiMesh(apf::Mesh2 *,int,int,bool)\n" - " mfem::PumiMesh::PumiMesh(apf::Mesh2 *,int,int)\n" - " mfem::PumiMesh::PumiMesh(apf::Mesh2 *,int)\n" - " mfem::PumiMesh::PumiMesh(apf::Mesh2 *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; - int arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val5 ; - int ecode5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); - } - arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PumiMesh_Load" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - (arg1)->Load(*arg2,arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); - } - arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->Load(*arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); - } - arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->Load(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); - } - arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - try { - (arg1)->Load(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; - apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; - int arg3 ; - int arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val5 ; - int ecode5 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"pmesh", NULL + }; + mfem::ParPumiMesh *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:ParMesh2ParPumiMesh", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); - } - arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); - } - arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParMesh2ParPumiMesh" "', argument " "1"" of type '" "mfem::ParMesh *""'"); } - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PumiMesh_Load" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); + arg1 = reinterpret_cast< mfem::ParMesh * >(argp1); { try { - (arg1)->Load(arg2,arg3,arg4,arg5); + result = (mfem::ParPumiMesh *)ParMesh2ParPumiMesh(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; - apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; - int arg3 ; - int arg4 ; + apf::Mesh2 *arg1 = (apf::Mesh2 *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 1 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"apf_mesh", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; + mfem::PumiMesh *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:new_PumiMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PumiMesh" "', argument " "1"" of type '" "apf::Mesh2 *""'"); } - arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + arg1 = reinterpret_cast< apf::Mesh2 * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } - arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PumiMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->Load(arg2,arg3,arg4); + result = (mfem::PumiMesh *)new mfem::PumiMesh(arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PumiMesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_0_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; - apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; - int arg3 ; + std::istream *arg2 = 0 ; + int arg3 = (int) 0 ; + int arg4 = (int) 1 ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); } arg1 = reinterpret_cast< mfem::PumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); } - arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PumiMesh_Load" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); } { try { - (arg1)->Load(arg2,arg3); + (arg1)->Load(*arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4449,16 +3982,21 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::PumiMesh *arg1 = (mfem::PumiMesh *) 0 ; apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; + int arg3 = (int) 0 ; + int arg4 = (int) 1 ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PumiMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PumiMesh_Load" "', argument " "1"" of type '" "mfem::PumiMesh *""'"); @@ -4469,9 +4007,32 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load__SWIG_4(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PumiMesh_Load" "', argument " "2"" of type '" "apf::Mesh2 *""'"); } arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "PumiMesh_Load" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } { try { - (arg1)->Load(arg2); + (arg1)->Load(arg2,arg3,arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4492,59 +4053,7 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "PumiMesh_Load", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_PumiMesh_Load__SWIG_0_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_PumiMesh_Load__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PumiMesh_Load__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); @@ -4554,30 +4063,9 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PumiMesh_Load__SWIG_0_2(self, argc, argv); + if (argc <= 2) { + return _wrap_PumiMesh_Load__SWIG_0_0(self, argc, argv); } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4587,40 +4075,9 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PumiMesh_Load__SWIG_0_1(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 3) { + return _wrap_PumiMesh_Load__SWIG_0_0(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4630,62 +4087,34 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_PumiMesh_Load__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 4) { + return _wrap_PumiMesh_Load__SWIG_0_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_bool(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_PumiMesh_Load__SWIG_1(self, argc, argv); + return _wrap_PumiMesh_Load__SWIG_0_0(self, argc, argv); } } } } } } - if (argc == 5) { + if ((argc >= 2) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__PumiMesh, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_apf__Mesh2, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_PumiMesh_Load__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4695,6 +4124,9 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 3) { + return _wrap_PumiMesh_Load__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4704,12 +4136,15 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 4) { + return _wrap_PumiMesh_Load__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_PumiMesh_Load__SWIG_0_0(self, argc, argv); + return _wrap_PumiMesh_Load__SWIG_1(self, argc, argv); } } } @@ -4721,13 +4156,7 @@ SWIGINTERN PyObject *_wrap_PumiMesh_Load(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PumiMesh_Load'.\n" " Possible C/C++ prototypes are:\n" " Load(std::istream &,int,int,bool)\n" - " Load(std::istream &,int,int)\n" - " Load(std::istream &,int)\n" - " Load(std::istream &)\n" - " mfem::PumiMesh::Load(apf::Mesh2 *,int,int,bool)\n" - " mfem::PumiMesh::Load(apf::Mesh2 *,int,int)\n" - " mfem::PumiMesh::Load(apf::Mesh2 *,int)\n" - " mfem::PumiMesh::Load(apf::Mesh2 *)\n"); + " mfem::PumiMesh::Load(apf::Mesh2 *,int,int,bool)\n"); return 0; } @@ -4772,26 +4201,30 @@ SWIGINTERN PyObject *PumiMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ParPumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ParPumiMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; MPI_Comm arg1 ; apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"comm", (char *)"apf_mesh", NULL + }; mfem::ParPumiMesh *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ParPumiMesh", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ParPumiMesh", kwnames, &obj0, &obj1)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + int res = SWIG_AsPtr_MPI_Comm(obj0, &ptr); if (!SWIG_IsOK(res) || !ptr) { SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_ParPumiMesh" "', argument " "1"" of type '" "MPI_Comm""'"); } arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ParPumiMesh" "', argument " "2"" of type '" "apf::Mesh2 *""'"); } @@ -5031,7 +4464,7 @@ SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldMFEMtoPUMI(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_ParPumiMesh_VectorFieldMFEMtoPUMI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParPumiMesh_VectorFieldMFEMtoPUMI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; @@ -5048,30 +4481,37 @@ SWIGINTERN PyObject *_wrap_ParPumiMesh_VectorFieldMFEMtoPUMI(PyObject *SWIGUNUSE int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"apf_mesh", (char *)"Vel", (char *)"VelField", (char *)"VelMagField", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParPumiMesh_VectorFieldMFEMtoPUMI", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ParPumiMesh_VectorFieldMFEMtoPUMI", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); } arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "2"" of type '" "apf::Mesh2 *""'"); } arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "3"" of type '" "mfem::ParGridFunction *""'"); } arg3 = reinterpret_cast< mfem::ParGridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_apf__Field, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_apf__Field, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "4"" of type '" "apf::Field *""'"); } arg4 = reinterpret_cast< apf::Field * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_apf__Field, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_apf__Field, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ParPumiMesh_VectorFieldMFEMtoPUMI" "', argument " "5"" of type '" "apf::Field *""'"); } @@ -5091,7 +4531,7 @@ SWIGINTERN PyObject *_wrap_ParPumiMesh_VectorFieldMFEMtoPUMI(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ParPumiMesh_UpdateMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParPumiMesh_UpdateMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; mfem::ParMesh *arg2 = (mfem::ParMesh *) 0 ; @@ -5099,15 +4539,19 @@ SWIGINTERN PyObject *_wrap_ParPumiMesh_UpdateMesh(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"AdaptedpMesh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParPumiMesh_UpdateMesh", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ParPumiMesh_UpdateMesh", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_UpdateMesh" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); } arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__ParMesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_UpdateMesh" "', argument " "2"" of type '" "mfem::ParMesh const *""'"); } @@ -5127,7 +4571,7 @@ SWIGINTERN PyObject *_wrap_ParPumiMesh_UpdateMesh(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldPUMItoMFEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldPUMItoMFEM(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ParPumiMesh *arg1 = (mfem::ParPumiMesh *) 0 ; apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; @@ -5141,25 +4585,31 @@ SWIGINTERN PyObject *_wrap_ParPumiMesh_FieldPUMItoMFEM(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"apf_mesh", (char *)"ScalarField", (char *)"Pr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ParPumiMesh_FieldPUMItoMFEM", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ParPumiMesh_FieldPUMItoMFEM", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ParPumiMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "1"" of type '" "mfem::ParPumiMesh *""'"); } arg1 = reinterpret_cast< mfem::ParPumiMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "2"" of type '" "apf::Mesh2 *""'"); } arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_apf__Field, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_apf__Field, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "3"" of type '" "apf::Field *""'"); } arg3 = reinterpret_cast< apf::Field * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__ParGridFunction, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ParPumiMesh_FieldPUMItoMFEM" "', argument " "4"" of type '" "mfem::ParGridFunction *""'"); } @@ -5219,7 +4669,7 @@ SWIGINTERN PyObject *ParPumiMesh_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GridFunctionPumi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GridFunctionPumi(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; apf::Mesh2 *arg2 = (apf::Mesh2 *) 0 ; @@ -5231,30 +4681,36 @@ SWIGINTERN PyObject *_wrap_new_GridFunctionPumi(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"m", (char *)"PumiM", (char *)"v_num_loc", (char *)"mesh_order", NULL + }; mfem::GridFunctionPumi *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_GridFunctionPumi", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_GridFunctionPumi", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunctionPumi" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_apf__Mesh2, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GridFunctionPumi" "', argument " "2"" of type '" "apf::Mesh2 *""'"); } arg2 = reinterpret_cast< apf::Mesh2 * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_apf__Numbering, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_apf__Numbering, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_GridFunctionPumi" "', argument " "3"" of type '" "apf::Numbering *""'"); } arg3 = reinterpret_cast< apf::Numbering * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -5316,44 +4772,41 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, "intp_assign(intp self, int value)"}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, "intp_assign(intp self, int value)"}, { "intp_value", _wrap_intp_value, METH_O, "intp_value(intp self) -> int"}, { "intp_cast", _wrap_intp_cast, METH_O, "intp_cast(intp self) -> int *"}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, "intp_frompointer(int * t) -> intp"}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, "intp_frompointer(int * t) -> intp"}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "doublep_assign(doublep self, double value)"}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, "doublep_assign(doublep self, double value)"}, { "doublep_value", _wrap_doublep_value, METH_O, "doublep_value(doublep self) -> double"}, { "doublep_cast", _wrap_doublep_cast, METH_O, "doublep_cast(doublep self) -> double *"}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "doublep_frompointer(double * t) -> doublep"}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, "doublep_frompointer(double * t) -> doublep"}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, - { "ParMesh2ParPumiMesh", _wrap_ParMesh2ParPumiMesh, METH_O, "ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh"}, - { "new_PumiMesh", _wrap_new_PumiMesh, METH_VARARGS, "PumiMesh(apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "ParMesh2ParPumiMesh", (PyCFunction)(void(*)(void))_wrap_ParMesh2ParPumiMesh, METH_VARARGS|METH_KEYWORDS, "ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh"}, + { "new_PumiMesh", (PyCFunction)(void(*)(void))_wrap_new_PumiMesh, METH_VARARGS|METH_KEYWORDS, "new_PumiMesh(apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True) -> PumiMesh"}, { "PumiMesh_Load", _wrap_PumiMesh_Load, METH_VARARGS, "\n" "PumiMesh_Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" - "PumiMesh_Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1)\n" - "PumiMesh_Load(PumiMesh self, std::istream & input, int generate_edges=0)\n" - "PumiMesh_Load(PumiMesh self, std::istream & input)\n" "PumiMesh_Load(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" ""}, { "delete_PumiMesh", _wrap_delete_PumiMesh, METH_O, "delete_PumiMesh(PumiMesh self)"}, { "PumiMesh_swigregister", PumiMesh_swigregister, METH_O, NULL}, { "PumiMesh_swiginit", PumiMesh_swiginit, METH_VARARGS, NULL}, - { "new_ParPumiMesh", _wrap_new_ParPumiMesh, METH_VARARGS, "new_ParPumiMesh(MPI_Comm comm, apf::Mesh2 * apf_mesh) -> ParPumiMesh"}, + { "new_ParPumiMesh", (PyCFunction)(void(*)(void))_wrap_new_ParPumiMesh, METH_VARARGS|METH_KEYWORDS, "new_ParPumiMesh(MPI_Comm comm, apf::Mesh2 * apf_mesh) -> ParPumiMesh"}, { "ParPumiMesh_FieldMFEMtoPUMI", _wrap_ParPumiMesh_FieldMFEMtoPUMI, METH_VARARGS, "\n" "ParPumiMesh_FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, ParGridFunction Pr, apf::Field * VelField, apf::Field * PrField, apf::Field * VelMagField)\n" "ParPumiMesh_FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Pr, apf::Field * PrField, apf::Field * PrMagField)\n" ""}, - { "ParPumiMesh_VectorFieldMFEMtoPUMI", _wrap_ParPumiMesh_VectorFieldMFEMtoPUMI, METH_VARARGS, "ParPumiMesh_VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)"}, - { "ParPumiMesh_UpdateMesh", _wrap_ParPumiMesh_UpdateMesh, METH_VARARGS, "ParPumiMesh_UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)"}, - { "ParPumiMesh_FieldPUMItoMFEM", _wrap_ParPumiMesh_FieldPUMItoMFEM, METH_VARARGS, "ParPumiMesh_FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)"}, + { "ParPumiMesh_VectorFieldMFEMtoPUMI", (PyCFunction)(void(*)(void))_wrap_ParPumiMesh_VectorFieldMFEMtoPUMI, METH_VARARGS|METH_KEYWORDS, "ParPumiMesh_VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)"}, + { "ParPumiMesh_UpdateMesh", (PyCFunction)(void(*)(void))_wrap_ParPumiMesh_UpdateMesh, METH_VARARGS|METH_KEYWORDS, "ParPumiMesh_UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)"}, + { "ParPumiMesh_FieldPUMItoMFEM", (PyCFunction)(void(*)(void))_wrap_ParPumiMesh_FieldPUMItoMFEM, METH_VARARGS|METH_KEYWORDS, "ParPumiMesh_FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)"}, { "delete_ParPumiMesh", _wrap_delete_ParPumiMesh, METH_O, "delete_ParPumiMesh(ParPumiMesh self)"}, { "ParPumiMesh_swigregister", ParPumiMesh_swigregister, METH_O, NULL}, { "ParPumiMesh_swiginit", ParPumiMesh_swiginit, METH_VARARGS, NULL}, - { "new_GridFunctionPumi", _wrap_new_GridFunctionPumi, METH_VARARGS, "new_GridFunctionPumi(Mesh m, apf::Mesh2 * PumiM, apf::Numbering * v_num_loc, int const mesh_order) -> GridFunctionPumi"}, + { "new_GridFunctionPumi", (PyCFunction)(void(*)(void))_wrap_new_GridFunctionPumi, METH_VARARGS|METH_KEYWORDS, "new_GridFunctionPumi(Mesh m, apf::Mesh2 * PumiM, apf::Numbering * v_num_loc, int const mesh_order) -> GridFunctionPumi"}, { "delete_GridFunctionPumi", _wrap_delete_GridFunctionPumi, METH_O, "delete_GridFunctionPumi(GridFunctionPumi self)"}, { "GridFunctionPumi_swigregister", GridFunctionPumi_swigregister, METH_O, NULL}, { "GridFunctionPumi_swiginit", GridFunctionPumi_swiginit, METH_VARARGS, NULL}, @@ -5365,44 +4818,41 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, "assign(intp self, int value)"}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, "assign(intp self, int value)"}, { "intp_value", _wrap_intp_value, METH_O, "value(intp self) -> int"}, { "intp_cast", _wrap_intp_cast, METH_O, "cast(intp self) -> int *"}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, "frompointer(int * t) -> intp"}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, "frompointer(int * t) -> intp"}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "assign(doublep self, double value)"}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, "assign(doublep self, double value)"}, { "doublep_value", _wrap_doublep_value, METH_O, "value(doublep self) -> double"}, { "doublep_cast", _wrap_doublep_cast, METH_O, "cast(doublep self) -> double *"}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "frompointer(double * t) -> doublep"}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, "frompointer(double * t) -> doublep"}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, - { "ParMesh2ParPumiMesh", _wrap_ParMesh2ParPumiMesh, METH_O, "ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh"}, - { "new_PumiMesh", _wrap_new_PumiMesh, METH_VARARGS, "PumiMesh(apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "ParMesh2ParPumiMesh", (PyCFunction)(void(*)(void))_wrap_ParMesh2ParPumiMesh, METH_VARARGS|METH_KEYWORDS, "ParMesh2ParPumiMesh(ParMesh pmesh) -> ParPumiMesh"}, + { "new_PumiMesh", (PyCFunction)(void(*)(void))_wrap_new_PumiMesh, METH_VARARGS|METH_KEYWORDS, "new_PumiMesh(apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True) -> PumiMesh"}, { "PumiMesh_Load", _wrap_PumiMesh_Load, METH_VARARGS, "\n" "Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" - "Load(PumiMesh self, std::istream & input, int generate_edges=0, int refine=1)\n" - "Load(PumiMesh self, std::istream & input, int generate_edges=0)\n" - "Load(PumiMesh self, std::istream & input)\n" "Load(PumiMesh self, apf::Mesh2 * apf_mesh, int generate_edges=0, int refine=1, bool fix_orientation=True)\n" ""}, { "delete_PumiMesh", _wrap_delete_PumiMesh, METH_O, "delete_PumiMesh(PumiMesh self)"}, { "PumiMesh_swigregister", PumiMesh_swigregister, METH_O, NULL}, { "PumiMesh_swiginit", PumiMesh_swiginit, METH_VARARGS, NULL}, - { "new_ParPumiMesh", _wrap_new_ParPumiMesh, METH_VARARGS, "new_ParPumiMesh(MPI_Comm comm, apf::Mesh2 * apf_mesh) -> ParPumiMesh"}, + { "new_ParPumiMesh", (PyCFunction)(void(*)(void))_wrap_new_ParPumiMesh, METH_VARARGS|METH_KEYWORDS, "new_ParPumiMesh(MPI_Comm comm, apf::Mesh2 * apf_mesh) -> ParPumiMesh"}, { "ParPumiMesh_FieldMFEMtoPUMI", _wrap_ParPumiMesh_FieldMFEMtoPUMI, METH_VARARGS, "\n" "FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, ParGridFunction Pr, apf::Field * VelField, apf::Field * PrField, apf::Field * VelMagField)\n" "FieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Pr, apf::Field * PrField, apf::Field * PrMagField)\n" ""}, - { "ParPumiMesh_VectorFieldMFEMtoPUMI", _wrap_ParPumiMesh_VectorFieldMFEMtoPUMI, METH_VARARGS, "VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)"}, - { "ParPumiMesh_UpdateMesh", _wrap_ParPumiMesh_UpdateMesh, METH_VARARGS, "UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)"}, - { "ParPumiMesh_FieldPUMItoMFEM", _wrap_ParPumiMesh_FieldPUMItoMFEM, METH_VARARGS, "FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)"}, + { "ParPumiMesh_VectorFieldMFEMtoPUMI", (PyCFunction)(void(*)(void))_wrap_ParPumiMesh_VectorFieldMFEMtoPUMI, METH_VARARGS|METH_KEYWORDS, "VectorFieldMFEMtoPUMI(ParPumiMesh self, apf::Mesh2 * apf_mesh, ParGridFunction Vel, apf::Field * VelField, apf::Field * VelMagField)"}, + { "ParPumiMesh_UpdateMesh", (PyCFunction)(void(*)(void))_wrap_ParPumiMesh_UpdateMesh, METH_VARARGS|METH_KEYWORDS, "UpdateMesh(ParPumiMesh self, ParMesh AdaptedpMesh)"}, + { "ParPumiMesh_FieldPUMItoMFEM", (PyCFunction)(void(*)(void))_wrap_ParPumiMesh_FieldPUMItoMFEM, METH_VARARGS|METH_KEYWORDS, "FieldPUMItoMFEM(ParPumiMesh self, apf::Mesh2 * apf_mesh, apf::Field * ScalarField, ParGridFunction Pr)"}, { "delete_ParPumiMesh", _wrap_delete_ParPumiMesh, METH_O, "delete_ParPumiMesh(ParPumiMesh self)"}, { "ParPumiMesh_swigregister", ParPumiMesh_swigregister, METH_O, NULL}, { "ParPumiMesh_swiginit", ParPumiMesh_swiginit, METH_VARARGS, NULL}, - { "new_GridFunctionPumi", _wrap_new_GridFunctionPumi, METH_VARARGS, "new_GridFunctionPumi(Mesh m, apf::Mesh2 * PumiM, apf::Numbering * v_num_loc, int const mesh_order) -> GridFunctionPumi"}, + { "new_GridFunctionPumi", (PyCFunction)(void(*)(void))_wrap_new_GridFunctionPumi, METH_VARARGS|METH_KEYWORDS, "new_GridFunctionPumi(Mesh m, apf::Mesh2 * PumiM, apf::Numbering * v_num_loc, int const mesh_order) -> GridFunctionPumi"}, { "delete_GridFunctionPumi", _wrap_delete_GridFunctionPumi, METH_O, "delete_GridFunctionPumi(GridFunctionPumi self)"}, { "GridFunctionPumi_swigregister", GridFunctionPumi_swigregister, METH_O, NULL}, { "GridFunctionPumi_swiginit", GridFunctionPumi_swiginit, METH_VARARGS, NULL}, @@ -6333,10 +5783,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/restriction.py b/mfem/_par/restriction.py index 2f2f39c7..5cf5d001 100644 --- a/mfem/_par/restriction.py +++ b/mfem/_par/restriction.py @@ -180,9 +180,9 @@ class L2FaceRestriction(mfem._par.operators.Operator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2FaceRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering const arg3, mfem::FaceType const arg4, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction""" - _restriction.L2FaceRestriction_swiginit(self, _restriction.new_L2FaceRestriction(*args)) + _restriction.L2FaceRestriction_swiginit(self, _restriction.new_L2FaceRestriction(*args, **kwargs)) def Mult(self, x, y): r"""Mult(L2FaceRestriction self, Vector x, Vector y)""" diff --git a/mfem/_par/restriction_wrap.cxx b/mfem/_par/restriction_wrap.cxx index b3ce894b..2fa5c505 100644 --- a/mfem/_par/restriction_wrap.cxx +++ b/mfem/_par/restriction_wrap.cxx @@ -3401,7 +3401,7 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::ElementDofOrdering arg2 ; @@ -3409,11 +3409,15 @@ SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"arg1", (char *)"arg2", NULL + }; mfem::ElementRestriction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ElementRestriction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ElementRestriction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -3421,7 +3425,7 @@ SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } @@ -3441,7 +3445,7 @@ SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3452,15 +3456,20 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3468,7 +3477,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3491,7 +3500,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3502,15 +3511,20 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3518,7 +3532,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3541,7 +3555,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3552,15 +3566,20 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTransposeUnsigned", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementRestriction_MultTransposeUnsigned", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3568,7 +3587,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3631,17 +3650,19 @@ SWIGINTERN PyObject *ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"arg1", NULL + }; mfem::L2ElementRestriction *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2ElementRestriction", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -3664,7 +3685,7 @@ SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3675,15 +3696,20 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2ElementRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3691,7 +3717,7 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3714,7 +3740,7 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3725,15 +3751,20 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2ElementRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3741,7 +3772,7 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3804,7 +3835,7 @@ SWIGINTERN PyObject *L2ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::ElementDofOrdering arg2 ; @@ -3815,11 +3846,16 @@ SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"arg1", (char *)"arg2", (char *)"arg3", NULL + }; mfem::H1FaceRestriction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_H1FaceRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_H1FaceRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -3827,12 +3863,12 @@ SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_H1FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_H1FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } @@ -3852,7 +3888,7 @@ SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3863,15 +3899,20 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1FaceRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3879,7 +3920,7 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3902,7 +3943,7 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3913,15 +3954,20 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1FaceRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3929,7 +3975,7 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3992,12 +4038,12 @@ SWIGINTERN PyObject *H1FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::ElementDofOrdering arg2 ; mfem::FaceType arg3 ; - mfem::L2FaceValues arg4 ; + mfem::L2FaceValues arg4 = (mfem::L2FaceValues) (mfem::L2FaceValues)mfem::L2FaceValues::DoubleValued ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -4006,10 +4052,17 @@ SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPAR int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"arg1", (char *)"arg2", (char *)"arg3", (char *)"m", NULL + }; mfem::L2FaceRestriction *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_L2FaceRestriction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -4017,71 +4070,26 @@ SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } arg3 = static_cast< mfem::FaceType >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); - } - arg4 = static_cast< mfem::L2FaceValues >(val4); - { - try { - result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::ElementDofOrdering arg2 ; - mfem::FaceType arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::L2FaceRestriction *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); - } - arg3 = static_cast< mfem::FaceType >(val3); { try { - result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3); + result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4094,71 +4102,7 @@ SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_L2FaceRestriction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2FaceRestriction", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_L2FaceRestriction__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_L2FaceRestriction__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2FaceRestriction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const,mfem::L2FaceValues const)\n" - " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4169,15 +4113,20 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2FaceRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4185,7 +4134,7 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4208,7 +4157,7 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4219,15 +4168,20 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2FaceRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4235,7 +4189,7 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4298,7 +4252,7 @@ SWIGINTERN PyObject *L2FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -4306,28 +4260,34 @@ SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject mfem::Array< int > *arg4 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"face_id", (char *)"dof1d", (char *)"faceMap", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GetFaceDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetFaceDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -4350,39 +4310,45 @@ SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"face_id", (char *)"size1d", (char *)"index", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ToLexOrdering", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ToLexOrdering", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -4399,7 +4365,7 @@ SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -4407,45 +4373,53 @@ SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObjec int arg4 ; int arg5 ; int arg6 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"face_id1", (char *)"face_id2", (char *)"orientation", (char *)"size1d", (char *)"index", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "PermuteFaceL2", 6, 6, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:PermuteFaceL2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg6 = PyArray_PyIntAsInt(obj5); } { try { @@ -4465,68 +4439,68 @@ SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, - { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "ElementRestriction_MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "new_ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS|METH_KEYWORDS, "ElementRestriction_MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, - { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "L2ElementRestriction_Mult(L2ElementRestriction self, Vector x, Vector y)"}, - { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "L2ElementRestriction_MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "new_L2ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "L2ElementRestriction_Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "L2ElementRestriction_MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, - { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "H1FaceRestriction_Mult(H1FaceRestriction self, Vector x, Vector y)"}, - { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "H1FaceRestriction_MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "new_H1FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_H1FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "H1FaceRestriction_Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "H1FaceRestriction_MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, - { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "L2FaceRestriction_Mult(L2FaceRestriction self, Vector x, Vector y)"}, - { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "L2FaceRestriction_MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "new_L2FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction"}, + { "L2FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "L2FaceRestriction_Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "L2FaceRestriction_MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, - { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, - { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { "GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", (PyCFunction)(void(*)(void))_wrap_ToLexOrdering, METH_VARARGS|METH_KEYWORDS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", (PyCFunction)(void(*)(void))_wrap_PermuteFaceL2, METH_VARARGS|METH_KEYWORDS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, - { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "Mult(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "new_ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS|METH_KEYWORDS, "MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, - { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "Mult(L2ElementRestriction self, Vector x, Vector y)"}, - { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "new_L2ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, - { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "Mult(H1FaceRestriction self, Vector x, Vector y)"}, - { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "new_H1FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_H1FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, - { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "Mult(L2FaceRestriction self, Vector x, Vector y)"}, - { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "new_L2FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction"}, + { "L2FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, - { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, - { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { "GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", (PyCFunction)(void(*)(void))_wrap_ToLexOrdering, METH_VARARGS|METH_KEYWORDS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", (PyCFunction)(void(*)(void))_wrap_PermuteFaceL2, METH_VARARGS|METH_KEYWORDS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/segment_wrap.cxx b/mfem/_par/segment_wrap.cxx index b744082e..49202761 100644 --- a/mfem/_par/segment_wrap.cxx +++ b/mfem/_par/segment_wrap.cxx @@ -3229,11 +3229,11 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P SWIGINTERN PyObject *_wrap_new_Segment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; int temp1[2] ; mfem::Segment *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if (PyList_Check(swig_obj[0])) { int ll = PyList_Size(swig_obj[0]); @@ -3254,11 +3254,13 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P arg1 = temp1; } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -3281,60 +3283,13 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P SWIGINTERN PyObject *_wrap_new_Segment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int *arg1 = (int *) 0 ; - int temp1[2] ; - mfem::Segment *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if (PyList_Check(swig_obj[0])) { - int ll = PyList_Size(swig_obj[0]); - for (int i = 0; i < ll; i++) { - PyObject *s = PyList_GetItem(swig_obj[0],i); - temp1[i] = (int)PyInt_AsLong(s); - } - } else if (PyTuple_Check(swig_obj[0])) { - int ll = PyTuple_Size(swig_obj[0]); - for (int i = 0; i < ll; i++) { - PyObject *s = PyTuple_GetItem(swig_obj[0],i); - temp1[i] = (int)PyInt_AsLong(s); - } - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a list/tuple"); - return NULL; - } - - arg1 = temp1; - } - { - try { - result = (mfem::Segment *)new mfem::Segment((int const *)arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Segment, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Segment__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; + int arg3 = (int) 1 ; mfem::Segment *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -3347,54 +3302,17 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::Segment *)new mfem::Segment(arg1,arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Segment, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Segment__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::Segment *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - result = (mfem::Segment *)new mfem::Segment(arg1,arg2); + result = (mfem::Segment *)new mfem::Segment(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3423,7 +3341,7 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Segment__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { _v = 0; @@ -3440,26 +3358,9 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } if (_v) { - return _wrap_new_Segment__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - _v = 0; - if (PyList_Check(argv[0])){ - if (PyList_Size(argv[0]) == 2){ - _v = 1; - } - } - if (PyTuple_Check(argv[0])){ - if (PyTuple_Size(argv[0]) == 2){ - _v = 1; - } + if (argc <= 1) { + return _wrap_new_Segment__SWIG_1(self, argc, argv); } - - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3473,7 +3374,7 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -3493,30 +3394,9 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Segment__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_Segment__SWIG_2(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3526,7 +3406,7 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Segment__SWIG_3(self, argc, argv); + return _wrap_new_Segment__SWIG_2(self, argc, argv); } } } @@ -3537,39 +3417,41 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::Segment::Segment()\n" " mfem::Segment::Segment(int const *,int)\n" - " mfem::Segment::Segment(int const *)\n" - " mfem::Segment::Segment(int,int,int)\n" - " mfem::Segment::Segment(int,int)\n"); + " mfem::Segment::Segment(int,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Segment_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int *arg2 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int temp2[2] ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ind", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Segment_SetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_SetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_SetVertices" "', argument " "1"" of type '" "mfem::Segment *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); for (int i = 0; i < ll; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); temp2[i] = (int)PyInt_AsLong(s); } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); for (int i = 0; i < ll; i++) { - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); temp2[i] = (int)PyInt_AsLong(s); } } else { @@ -3826,26 +3708,30 @@ SWIGINTERN PyObject *_wrap_Segment_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Segment_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ei", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetEdgeVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_GetEdgeVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3985,26 +3871,30 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_GetNFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4026,26 +3916,30 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_GetFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetFaceVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4067,7 +3961,7 @@ SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Segment_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -4075,16 +3969,20 @@ SWIGINTERN PyObject *_wrap_Segment_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::Element *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Segment_Duplicate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_Duplicate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_Duplicate" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Segment_Duplicate" "', argument " "2"" of type '" "mfem::Mesh *""'"); } @@ -4190,9 +4088,9 @@ static PyMethodDef SwigMethods[] = { { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" "Segment()\n" "Segment(int const * ind, int attr=1)\n" - "Segment(int ind1, int ind2, int attr=1)\n" + "new_Segment(int ind1, int ind2, int attr=1) -> Segment\n" ""}, - { "Segment_SetVertices", _wrap_Segment_SetVertices, METH_VARARGS, "Segment_SetVertices(Segment self, int const * ind)"}, + { "Segment_SetVertices", (PyCFunction)(void(*)(void))_wrap_Segment_SetVertices, METH_VARARGS|METH_KEYWORDS, "Segment_SetVertices(Segment self, int const * ind)"}, { "Segment_GetType", _wrap_Segment_GetType, METH_O, "Segment_GetType(Segment self) -> mfem::Element::Type"}, { "Segment_GetVertices", _wrap_Segment_GetVertices, METH_VARARGS, "\n" "Segment_GetVertices(Segment self, intArray v)\n" @@ -4200,14 +4098,14 @@ static PyMethodDef SwigMethods[] = { ""}, { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "Segment_GetNVertices(Segment self) -> int"}, { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "Segment_GetNEdges(Segment self) -> int"}, - { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "Segment_GetEdgeVertices(Segment self, int ei) -> int const *"}, + { "Segment_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Segment_GetEdgeVertices(Segment self, int ei) -> int const *"}, { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" "Segment_GetNFaces(Segment self, int & nFaceVertices) -> int\n" "Segment_GetNFaces(Segment self) -> int\n" ""}, - { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "Segment_GetNFaceVertices(Segment self, int arg2) -> int"}, - { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "Segment_GetFaceVertices(Segment self, int fi) -> int const *"}, - { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Segment_Duplicate(Segment self, mfem::Mesh * m) -> Element"}, + { "Segment_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "Segment_GetNFaceVertices(Segment self, int arg2) -> int"}, + { "Segment_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Segment_GetFaceVertices(Segment self, int fi) -> int const *"}, + { "Segment_Duplicate", (PyCFunction)(void(*)(void))_wrap_Segment_Duplicate, METH_VARARGS|METH_KEYWORDS, "Segment_Duplicate(Segment self, mfem::Mesh * m) -> Element"}, { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, { "Segment_swigregister", Segment_swigregister, METH_O, NULL}, { "Segment_swiginit", Segment_swiginit, METH_VARARGS, NULL}, @@ -4220,9 +4118,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" "Segment()\n" "Segment(int const * ind, int attr=1)\n" - "Segment(int ind1, int ind2, int attr=1)\n" + "new_Segment(int ind1, int ind2, int attr=1) -> Segment\n" ""}, - { "Segment_SetVertices", _wrap_Segment_SetVertices, METH_VARARGS, "SetVertices(Segment self, int const * ind)"}, + { "Segment_SetVertices", (PyCFunction)(void(*)(void))_wrap_Segment_SetVertices, METH_VARARGS|METH_KEYWORDS, "SetVertices(Segment self, int const * ind)"}, { "Segment_GetType", _wrap_Segment_GetType, METH_O, "GetType(Segment self) -> mfem::Element::Type"}, { "Segment_GetVertices", _wrap_Segment_GetVertices, METH_VARARGS, "\n" "GetVertices(Segment self, intArray v)\n" @@ -4230,14 +4128,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "GetNVertices(Segment self) -> int"}, { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "GetNEdges(Segment self) -> int"}, - { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Segment self, int ei) -> int const *"}, + { "Segment_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Segment self, int ei) -> int const *"}, { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" "GetNFaces(Segment self, int & nFaceVertices) -> int\n" "GetNFaces(Segment self) -> int\n" ""}, - { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Segment self, int arg2) -> int"}, - { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Segment self, int fi) -> int const *"}, - { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Duplicate(Segment self, mfem::Mesh * m) -> Element"}, + { "Segment_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetNFaceVertices(Segment self, int arg2) -> int"}, + { "Segment_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Segment self, int fi) -> int const *"}, + { "Segment_Duplicate", (PyCFunction)(void(*)(void))_wrap_Segment_Duplicate, METH_VARARGS|METH_KEYWORDS, "Duplicate(Segment self, mfem::Mesh * m) -> Element"}, { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, { "Segment_swigregister", Segment_swigregister, METH_O, NULL}, { "Segment_swiginit", Segment_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/sets_wrap.cxx b/mfem/_par/sets_wrap.cxx index 1bcdcb19..70703326 100644 --- a/mfem/_par/sets_wrap.cxx +++ b/mfem/_par/sets_wrap.cxx @@ -3060,7 +3060,7 @@ SWIGINTERN PyObject *_wrap_IntegerSet_PickRandomElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegerSet *arg1 = (mfem::IntegerSet *) 0 ; mfem::IntegerSet *arg2 = 0 ; @@ -3068,16 +3068,20 @@ SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IntegerSet___eq__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegerSet___eq__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerSet___eq__" "', argument " "1"" of type '" "mfem::IntegerSet *""'"); } arg1 = reinterpret_cast< mfem::IntegerSet * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegerSet___eq__" "', argument " "2"" of type '" "mfem::IntegerSet &""'"); } @@ -3110,7 +3114,7 @@ SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_IntegerSet_Recreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegerSet_Recreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegerSet *arg1 = (mfem::IntegerSet *) 0 ; int arg2 ; @@ -3119,21 +3123,26 @@ SWIGINTERN PyObject *_wrap_IntegerSet_Recreate(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"n", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegerSet_Recreate", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegerSet_Recreate", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerSet_Recreate" "', argument " "1"" of type '" "mfem::IntegerSet *""'"); } arg1 = reinterpret_cast< mfem::IntegerSet * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntegerSet_Recreate" "', argument " "3"" of type '" "int const *""'"); } @@ -3247,26 +3256,30 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Size(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_PickElementInSet", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_PickElementInSet", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_PickElementInSet" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3291,26 +3304,30 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickElementInSet(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickRandomElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickRandomElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_PickRandomElementInSet", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_PickRandomElementInSet", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_PickRandomElementInSet" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3335,7 +3352,7 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickRandomElementInSet(PyObject *SW } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; mfem::IntegerSet *arg2 = 0 ; @@ -3343,16 +3360,20 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_Insert", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_Insert", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_Insert" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfIntegerSets_Insert" "', argument " "2"" of type '" "mfem::IntegerSet &""'"); } @@ -3383,7 +3404,7 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; mfem::IntegerSet *arg2 = 0 ; @@ -3391,16 +3412,20 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_Lookup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_Lookup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_Lookup" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfIntegerSets_Lookup" "', argument " "2"" of type '" "mfem::IntegerSet &""'"); } @@ -3431,7 +3456,7 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_AsTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_AsTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; mfem::Table *arg2 = 0 ; @@ -3439,15 +3464,19 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_AsTable(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_AsTable", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_AsTable", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_AsTable" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfIntegerSets_AsTable" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -3565,17 +3594,17 @@ static PyMethodDef SwigMethods[] = { { "IntegerSet_Size", _wrap_IntegerSet_Size, METH_O, "IntegerSet_Size(IntegerSet self) -> int"}, { "IntegerSet_PickElement", _wrap_IntegerSet_PickElement, METH_O, "IntegerSet_PickElement(IntegerSet self) -> int"}, { "IntegerSet_PickRandomElement", _wrap_IntegerSet_PickRandomElement, METH_O, "IntegerSet_PickRandomElement(IntegerSet self) -> int"}, - { "IntegerSet___eq__", _wrap_IntegerSet___eq__, METH_VARARGS, "IntegerSet___eq__(IntegerSet self, IntegerSet s) -> int"}, - { "IntegerSet_Recreate", _wrap_IntegerSet_Recreate, METH_VARARGS, "IntegerSet_Recreate(IntegerSet self, int const n, int const * p)"}, + { "IntegerSet___eq__", (PyCFunction)(void(*)(void))_wrap_IntegerSet___eq__, METH_VARARGS|METH_KEYWORDS, "IntegerSet___eq__(IntegerSet self, IntegerSet s) -> int"}, + { "IntegerSet_Recreate", (PyCFunction)(void(*)(void))_wrap_IntegerSet_Recreate, METH_VARARGS|METH_KEYWORDS, "IntegerSet_Recreate(IntegerSet self, int const n, int const * p)"}, { "delete_IntegerSet", _wrap_delete_IntegerSet, METH_O, "delete_IntegerSet(IntegerSet self)"}, { "IntegerSet_swigregister", IntegerSet_swigregister, METH_O, NULL}, { "IntegerSet_swiginit", IntegerSet_swiginit, METH_VARARGS, NULL}, { "ListOfIntegerSets_Size", _wrap_ListOfIntegerSets_Size, METH_O, "ListOfIntegerSets_Size(ListOfIntegerSets self) -> int"}, - { "ListOfIntegerSets_PickElementInSet", _wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS, "ListOfIntegerSets_PickElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_PickRandomElementInSet", _wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS, "ListOfIntegerSets_PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_Insert", _wrap_ListOfIntegerSets_Insert, METH_VARARGS, "ListOfIntegerSets_Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_Lookup", _wrap_ListOfIntegerSets_Lookup, METH_VARARGS, "ListOfIntegerSets_Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_AsTable", _wrap_ListOfIntegerSets_AsTable, METH_VARARGS, "ListOfIntegerSets_AsTable(ListOfIntegerSets self, Table t)"}, + { "ListOfIntegerSets_PickElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_PickElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_PickRandomElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_Insert", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Insert, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_Lookup", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Lookup, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_AsTable", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_AsTable, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_AsTable(ListOfIntegerSets self, Table t)"}, { "delete_ListOfIntegerSets", _wrap_delete_ListOfIntegerSets, METH_O, "delete_ListOfIntegerSets(ListOfIntegerSets self)"}, { "new_ListOfIntegerSets", _wrap_new_ListOfIntegerSets, METH_NOARGS, "new_ListOfIntegerSets() -> ListOfIntegerSets"}, { "ListOfIntegerSets_swigregister", ListOfIntegerSets_swigregister, METH_O, NULL}, @@ -3594,17 +3623,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "IntegerSet_Size", _wrap_IntegerSet_Size, METH_O, "Size(IntegerSet self) -> int"}, { "IntegerSet_PickElement", _wrap_IntegerSet_PickElement, METH_O, "PickElement(IntegerSet self) -> int"}, { "IntegerSet_PickRandomElement", _wrap_IntegerSet_PickRandomElement, METH_O, "PickRandomElement(IntegerSet self) -> int"}, - { "IntegerSet___eq__", _wrap_IntegerSet___eq__, METH_VARARGS, "__eq__(IntegerSet self, IntegerSet s) -> int"}, - { "IntegerSet_Recreate", _wrap_IntegerSet_Recreate, METH_VARARGS, "Recreate(IntegerSet self, int const n, int const * p)"}, + { "IntegerSet___eq__", (PyCFunction)(void(*)(void))_wrap_IntegerSet___eq__, METH_VARARGS|METH_KEYWORDS, "__eq__(IntegerSet self, IntegerSet s) -> int"}, + { "IntegerSet_Recreate", (PyCFunction)(void(*)(void))_wrap_IntegerSet_Recreate, METH_VARARGS|METH_KEYWORDS, "Recreate(IntegerSet self, int const n, int const * p)"}, { "delete_IntegerSet", _wrap_delete_IntegerSet, METH_O, "delete_IntegerSet(IntegerSet self)"}, { "IntegerSet_swigregister", IntegerSet_swigregister, METH_O, NULL}, { "IntegerSet_swiginit", IntegerSet_swiginit, METH_VARARGS, NULL}, { "ListOfIntegerSets_Size", _wrap_ListOfIntegerSets_Size, METH_O, "Size(ListOfIntegerSets self) -> int"}, - { "ListOfIntegerSets_PickElementInSet", _wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS, "PickElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_PickRandomElementInSet", _wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS, "PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_Insert", _wrap_ListOfIntegerSets_Insert, METH_VARARGS, "Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_Lookup", _wrap_ListOfIntegerSets_Lookup, METH_VARARGS, "Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_AsTable", _wrap_ListOfIntegerSets_AsTable, METH_VARARGS, "AsTable(ListOfIntegerSets self, Table t)"}, + { "ListOfIntegerSets_PickElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS|METH_KEYWORDS, "PickElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_PickRandomElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS|METH_KEYWORDS, "PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_Insert", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Insert, METH_VARARGS|METH_KEYWORDS, "Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_Lookup", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Lookup, METH_VARARGS|METH_KEYWORDS, "Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_AsTable", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_AsTable, METH_VARARGS|METH_KEYWORDS, "AsTable(ListOfIntegerSets self, Table t)"}, { "delete_ListOfIntegerSets", _wrap_delete_ListOfIntegerSets, METH_O, "delete_ListOfIntegerSets(ListOfIntegerSets self)"}, { "new_ListOfIntegerSets", _wrap_new_ListOfIntegerSets, METH_NOARGS, "new_ListOfIntegerSets() -> ListOfIntegerSets"}, { "ListOfIntegerSets_swigregister", ListOfIntegerSets_swigregister, METH_O, NULL}, diff --git a/mfem/_par/socketstream_wrap.cxx b/mfem/_par/socketstream_wrap.cxx index f3407b3f..4e2e3309 100644 --- a/mfem/_par/socketstream_wrap.cxx +++ b/mfem/_par/socketstream_wrap.cxx @@ -3657,26 +3657,30 @@ SWIGINTERN PyObject *_wrap_new_socketbuf(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_socketbuf_attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketbuf_attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketbuf *arg1 = (mfem::socketbuf *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sd", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "socketbuf_attach", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:socketbuf_attach", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketbuf_attach" "', argument " "1"" of type '" "mfem::socketbuf *""'"); } arg1 = reinterpret_cast< mfem::socketbuf * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3723,7 +3727,7 @@ SWIGINTERN PyObject *_wrap_socketbuf_detach(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_socketbuf_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketbuf_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketbuf *arg1 = (mfem::socketbuf *) 0 ; char *arg2 ; @@ -3733,25 +3737,30 @@ SWIGINTERN PyObject *_wrap_socketbuf_open(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"hostname", (char *)"port", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "socketbuf_open", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:socketbuf_open", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketbuf_open" "', argument " "1"" of type '" "mfem::socketbuf *""'"); } arg1 = reinterpret_cast< mfem::socketbuf * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketbuf_open" "', argument " "2"" of type '" "char const []""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3902,40 +3911,22 @@ SWIGINTERN PyObject *socketbuf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - bool arg1 ; + bool arg1 = (bool) mfem::socketstream::secure_default ; bool val1 ; int ecode1 = 0 ; mfem::socketstream *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_socketstream" "', argument " "1"" of type '" "bool""'"); - } - arg1 = static_cast< bool >(val1); - { - try { - result = (mfem::socketstream *)new mfem::socketstream(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } + if ((nobjs < 0) || (nobjs > 1)) SWIG_fail; + if (swig_obj[0]) { + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_socketstream" "', argument " "1"" of type '" "bool""'"); + } + arg1 = static_cast< bool >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketstream, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::socketstream *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::socketstream *)new mfem::socketstream(); + result = (mfem::socketstream *)new mfem::socketstream(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3948,7 +3939,7 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::socketbuf *arg1 = (mfem::socketbuf *) 0 ; void *argp1 = 0 ; @@ -3976,56 +3967,31 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_2(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - bool arg2 ; + bool arg2 = (bool) mfem::socketstream::secure_default ; bool val2 ; int ecode2 = 0 ; mfem::socketstream *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_socketstream" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::socketstream *)new mfem::socketstream(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketstream, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::socketstream *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_socketstream" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } { try { - result = (mfem::socketstream *)new mfem::socketstream(arg1); + result = (mfem::socketstream *)new mfem::socketstream(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4038,11 +4004,11 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_4(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; char *arg1 ; int arg2 ; - bool arg3 ; + bool arg3 = (bool) mfem::socketstream::secure_default ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -4050,7 +4016,7 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_5(PyObject *SWIGUNUSEDPARM(sel int ecode3 = 0 ; mfem::socketstream *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_socketstream" "', argument " "1"" of type '" "char const []""'"); @@ -4062,52 +4028,16 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_5(PyObject *SWIGUNUSEDPARM(sel }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_socketstream" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - result = (mfem::socketstream *)new mfem::socketstream((char const (*))arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketstream, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return resultobj; -fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - char *arg1 ; - int arg2 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::socketstream *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_socketstream" "', argument " "1"" of type '" "char const []""'"); - } - arg1 = reinterpret_cast< char * >(buf1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_socketstream" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } { try { - result = (mfem::socketstream *)new mfem::socketstream((char const (*))arg1,arg2); + result = (mfem::socketstream *)new mfem::socketstream((char const (*))arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4130,20 +4060,11 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_socketstream", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_socketstream__SWIG_1(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 1)) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__socketbuf, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_socketstream__SWIG_2(self, argc, argv); + if (argc <= 0) { + return _wrap_new_socketstream__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { int res = SWIG_AsVal_bool(argv[0], NULL); _v = SWIG_CheckState(res); @@ -4154,19 +4075,14 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { } if (argc == 1) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__socketbuf, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_socketstream__SWIG_4(self, argc, argv); + return _wrap_new_socketstream__SWIG_1(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -4177,16 +4093,19 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 1) { + return _wrap_new_socketstream__SWIG_2(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_socketstream__SWIG_3(self, argc, argv); + return _wrap_new_socketstream__SWIG_2(self, argc, argv); } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); _v = SWIG_CheckState(res); @@ -4200,30 +4119,15 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_socketstream__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_socketstream__SWIG_3(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_socketstream__SWIG_5(self, argc, argv); + return _wrap_new_socketstream__SWIG_3(self, argc, argv); } } } @@ -4233,12 +4137,9 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_socketstream'.\n" " Possible C/C++ prototypes are:\n" " mfem::socketstream::socketstream(bool)\n" - " mfem::socketstream::socketstream()\n" " mfem::socketstream::socketstream(mfem::socketbuf *)\n" " mfem::socketstream::socketstream(int,bool)\n" - " mfem::socketstream::socketstream(int)\n" - " mfem::socketstream::socketstream(char const [],int,bool)\n" - " mfem::socketstream::socketstream(char const [],int)\n"); + " mfem::socketstream::socketstream(char const [],int,bool)\n"); return 0; } @@ -4273,7 +4174,7 @@ SWIGINTERN PyObject *_wrap_socketstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_socketstream_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketstream_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketstream *arg1 = (mfem::socketstream *) 0 ; char *arg2 ; @@ -4283,25 +4184,30 @@ SWIGINTERN PyObject *_wrap_socketstream_open(PyObject *SWIGUNUSEDPARM(self), PyO int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"hostname", (char *)"port", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "socketstream_open", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:socketstream_open", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketstream_open" "', argument " "1"" of type '" "mfem::socketstream *""'"); } arg1 = reinterpret_cast< mfem::socketstream * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketstream_open" "', argument " "2"" of type '" "char const []""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4518,7 +4424,7 @@ SWIGINTERN PyObject *_wrap_socketstream_precision(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketstream *arg1 = (mfem::socketstream *) 0 ; mfem::Mesh *arg2 = 0 ; @@ -4529,15 +4435,20 @@ SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mesh", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "socketstream_send_solution", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:socketstream_send_solution", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketstream_send_solution" "', argument " "1"" of type '" "mfem::socketstream *""'"); } arg1 = reinterpret_cast< mfem::socketstream * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketstream_send_solution" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } @@ -4545,7 +4456,7 @@ SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "socketstream_send_solution" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "socketstream_send_solution" "', argument " "3"" of type '" "mfem::GridFunction const &""'"); } @@ -4568,7 +4479,7 @@ SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_socketstream_send_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketstream_send_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketstream *arg1 = (mfem::socketstream *) 0 ; char *arg2 ; @@ -4577,15 +4488,19 @@ SWIGINTERN PyObject *_wrap_socketstream_send_text(PyObject *SWIGUNUSEDPARM(self) int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ostr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "socketstream_send_text", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:socketstream_send_text", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketstream_send_text" "', argument " "1"" of type '" "mfem::socketstream *""'"); } arg1 = reinterpret_cast< mfem::socketstream * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketstream_send_text" "', argument " "2"" of type '" "char const []""'"); } @@ -4910,55 +4825,35 @@ SWIGINTERN PyObject *socketstream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_socketserver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketserver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"port", (char *)"backlog", NULL + }; mfem::socketserver *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_socketserver", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::socketserver *)new mfem::socketserver(arg1,arg2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketserver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketserver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::socketserver *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::socketserver *)new mfem::socketserver(arg1); + result = (mfem::socketserver *)new mfem::socketserver(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4971,62 +4866,6 @@ SWIGINTERN PyObject *_wrap_new_socketserver__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketserver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_socketserver", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_socketserver__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_socketserver__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_socketserver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::socketserver::socketserver(int,int)\n" - " mfem::socketserver::socketserver(int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_socketserver_good(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::socketserver *arg1 = (mfem::socketserver *) 0 ; @@ -5243,9 +5082,9 @@ static PyMethodDef SwigMethods[] = { "socketbuf(int sd)\n" "new_socketbuf(char const [] hostname, int port) -> socketbuf\n" ""}, - { "socketbuf_attach", _wrap_socketbuf_attach, METH_VARARGS, "socketbuf_attach(socketbuf self, int sd) -> int"}, + { "socketbuf_attach", (PyCFunction)(void(*)(void))_wrap_socketbuf_attach, METH_VARARGS|METH_KEYWORDS, "socketbuf_attach(socketbuf self, int sd) -> int"}, { "socketbuf_detach", _wrap_socketbuf_detach, METH_O, "socketbuf_detach(socketbuf self) -> int"}, - { "socketbuf_open", _wrap_socketbuf_open, METH_VARARGS, "socketbuf_open(socketbuf self, char const [] hostname, int port) -> int"}, + { "socketbuf_open", (PyCFunction)(void(*)(void))_wrap_socketbuf_open, METH_VARARGS|METH_KEYWORDS, "socketbuf_open(socketbuf self, char const [] hostname, int port) -> int"}, { "socketbuf_close", _wrap_socketbuf_close, METH_O, "socketbuf_close(socketbuf self) -> int"}, { "socketbuf_getsocketdescriptor", _wrap_socketbuf_getsocketdescriptor, METH_O, "socketbuf_getsocketdescriptor(socketbuf self) -> int"}, { "socketbuf_is_open", _wrap_socketbuf_is_open, METH_O, "socketbuf_is_open(socketbuf self) -> bool"}, @@ -5256,10 +5095,10 @@ static PyMethodDef SwigMethods[] = { "socketstream(bool secure=secure_default)\n" "socketstream(socketbuf buf)\n" "socketstream(int s, bool secure=secure_default)\n" - "socketstream(char const [] hostname, int port, bool secure=secure_default)\n" + "new_socketstream(char const [] hostname, int port, bool secure=secure_default) -> socketstream\n" ""}, { "socketstream_rdbuf", _wrap_socketstream_rdbuf, METH_O, "socketstream_rdbuf(socketstream self) -> socketbuf"}, - { "socketstream_open", _wrap_socketstream_open, METH_VARARGS, "socketstream_open(socketstream self, char const [] hostname, int port) -> int"}, + { "socketstream_open", (PyCFunction)(void(*)(void))_wrap_socketstream_open, METH_VARARGS|METH_KEYWORDS, "socketstream_open(socketstream self, char const [] hostname, int port) -> int"}, { "socketstream_close", _wrap_socketstream_close, METH_O, "socketstream_close(socketstream self) -> int"}, { "socketstream_is_open", _wrap_socketstream_is_open, METH_O, "socketstream_is_open(socketstream self) -> bool"}, { "delete_socketstream", _wrap_delete_socketstream, METH_O, "delete_socketstream(socketstream self)"}, @@ -5267,8 +5106,8 @@ static PyMethodDef SwigMethods[] = { "socketstream_precision(socketstream self, int const p) -> int\n" "socketstream_precision(socketstream self) -> int\n" ""}, - { "socketstream_send_solution", _wrap_socketstream_send_solution, METH_VARARGS, "socketstream_send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, - { "socketstream_send_text", _wrap_socketstream_send_text, METH_VARARGS, "socketstream_send_text(socketstream self, char const [] ostr)"}, + { "socketstream_send_solution", (PyCFunction)(void(*)(void))_wrap_socketstream_send_solution, METH_VARARGS|METH_KEYWORDS, "socketstream_send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, + { "socketstream_send_text", (PyCFunction)(void(*)(void))_wrap_socketstream_send_text, METH_VARARGS|METH_KEYWORDS, "socketstream_send_text(socketstream self, char const [] ostr)"}, { "socketstream_flush", _wrap_socketstream_flush, METH_O, "socketstream_flush(socketstream self)"}, { "socketstream___lshift__", _wrap_socketstream___lshift__, METH_VARARGS, "\n" "socketstream___lshift__(socketstream self, char const [] ostr) -> socketstream\n" @@ -5279,7 +5118,7 @@ static PyMethodDef SwigMethods[] = { { "socketstream_endline", _wrap_socketstream_endline, METH_O, "socketstream_endline(socketstream self) -> socketstream"}, { "socketstream_swigregister", socketstream_swigregister, METH_O, NULL}, { "socketstream_swiginit", socketstream_swiginit, METH_VARARGS, NULL}, - { "new_socketserver", _wrap_new_socketserver, METH_VARARGS, "socketserver(int port, int backlog=4)"}, + { "new_socketserver", (PyCFunction)(void(*)(void))_wrap_new_socketserver, METH_VARARGS|METH_KEYWORDS, "new_socketserver(int port, int backlog=4) -> socketserver"}, { "socketserver_good", _wrap_socketserver_good, METH_O, "socketserver_good(socketserver self) -> bool"}, { "socketserver_close", _wrap_socketserver_close, METH_O, "socketserver_close(socketserver self) -> int"}, { "socketserver_accept", _wrap_socketserver_accept, METH_VARARGS, "\n" @@ -5300,9 +5139,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "socketbuf(int sd)\n" "new_socketbuf(char const [] hostname, int port) -> socketbuf\n" ""}, - { "socketbuf_attach", _wrap_socketbuf_attach, METH_VARARGS, "attach(socketbuf self, int sd) -> int"}, + { "socketbuf_attach", (PyCFunction)(void(*)(void))_wrap_socketbuf_attach, METH_VARARGS|METH_KEYWORDS, "attach(socketbuf self, int sd) -> int"}, { "socketbuf_detach", _wrap_socketbuf_detach, METH_O, "detach(socketbuf self) -> int"}, - { "socketbuf_open", _wrap_socketbuf_open, METH_VARARGS, "open(socketbuf self, char const [] hostname, int port) -> int"}, + { "socketbuf_open", (PyCFunction)(void(*)(void))_wrap_socketbuf_open, METH_VARARGS|METH_KEYWORDS, "open(socketbuf self, char const [] hostname, int port) -> int"}, { "socketbuf_close", _wrap_socketbuf_close, METH_O, "close(socketbuf self) -> int"}, { "socketbuf_getsocketdescriptor", _wrap_socketbuf_getsocketdescriptor, METH_O, "getsocketdescriptor(socketbuf self) -> int"}, { "socketbuf_is_open", _wrap_socketbuf_is_open, METH_O, "is_open(socketbuf self) -> bool"}, @@ -5313,10 +5152,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "socketstream(bool secure=secure_default)\n" "socketstream(socketbuf buf)\n" "socketstream(int s, bool secure=secure_default)\n" - "socketstream(char const [] hostname, int port, bool secure=secure_default)\n" + "new_socketstream(char const [] hostname, int port, bool secure=secure_default) -> socketstream\n" ""}, { "socketstream_rdbuf", _wrap_socketstream_rdbuf, METH_O, "rdbuf(socketstream self) -> socketbuf"}, - { "socketstream_open", _wrap_socketstream_open, METH_VARARGS, "open(socketstream self, char const [] hostname, int port) -> int"}, + { "socketstream_open", (PyCFunction)(void(*)(void))_wrap_socketstream_open, METH_VARARGS|METH_KEYWORDS, "open(socketstream self, char const [] hostname, int port) -> int"}, { "socketstream_close", _wrap_socketstream_close, METH_O, "close(socketstream self) -> int"}, { "socketstream_is_open", _wrap_socketstream_is_open, METH_O, "is_open(socketstream self) -> bool"}, { "delete_socketstream", _wrap_delete_socketstream, METH_O, "delete_socketstream(socketstream self)"}, @@ -5324,8 +5163,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "precision(socketstream self, int const p) -> int\n" "precision(socketstream self) -> int\n" ""}, - { "socketstream_send_solution", _wrap_socketstream_send_solution, METH_VARARGS, "send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, - { "socketstream_send_text", _wrap_socketstream_send_text, METH_VARARGS, "send_text(socketstream self, char const [] ostr)"}, + { "socketstream_send_solution", (PyCFunction)(void(*)(void))_wrap_socketstream_send_solution, METH_VARARGS|METH_KEYWORDS, "send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, + { "socketstream_send_text", (PyCFunction)(void(*)(void))_wrap_socketstream_send_text, METH_VARARGS|METH_KEYWORDS, "send_text(socketstream self, char const [] ostr)"}, { "socketstream_flush", _wrap_socketstream_flush, METH_O, "flush(socketstream self)"}, { "socketstream___lshift__", _wrap_socketstream___lshift__, METH_VARARGS, "\n" "__lshift__(socketstream self, char const [] ostr) -> socketstream\n" @@ -5336,7 +5175,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "socketstream_endline", _wrap_socketstream_endline, METH_O, "endline(socketstream self) -> socketstream"}, { "socketstream_swigregister", socketstream_swigregister, METH_O, NULL}, { "socketstream_swiginit", socketstream_swiginit, METH_VARARGS, NULL}, - { "new_socketserver", _wrap_new_socketserver, METH_VARARGS, "socketserver(int port, int backlog=4)"}, + { "new_socketserver", (PyCFunction)(void(*)(void))_wrap_new_socketserver, METH_VARARGS|METH_KEYWORDS, "new_socketserver(int port, int backlog=4) -> socketserver"}, { "socketserver_good", _wrap_socketserver_good, METH_O, "good(socketserver self) -> bool"}, { "socketserver_close", _wrap_socketserver_close, METH_O, "close(socketserver self) -> int"}, { "socketserver_accept", _wrap_socketserver_accept, METH_VARARGS, "\n" diff --git a/mfem/_par/solvers_wrap.cxx b/mfem/_par/solvers_wrap.cxx index 9a3ebbde..0dd46f64 100644 --- a/mfem/_par/solvers_wrap.cxx +++ b/mfem/_par/solvers_wrap.cxx @@ -3458,7 +3458,7 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; double arg2 ; @@ -3466,15 +3466,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rtol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetRelTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetRelTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetRelTol" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IterativeSolver_SetRelTol" "', argument " "2"" of type '" "double""'"); } @@ -3499,7 +3503,7 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; double arg2 ; @@ -3507,15 +3511,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"atol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetAbsTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetAbsTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetAbsTol" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IterativeSolver_SetAbsTol" "', argument " "2"" of type '" "double""'"); } @@ -3540,25 +3548,29 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_it", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetMaxIter" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3580,25 +3592,29 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetMaxIter(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"print_lvl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetPrintLevel" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3725,7 +3741,7 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_GetFinalNorm(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; mfem::Solver *arg2 = 0 ; @@ -3733,15 +3749,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IterativeSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } @@ -3769,7 +3789,7 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -3777,15 +3797,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetOperator(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetOperator" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IterativeSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -3858,7 +3882,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS PyObject *resultobj = 0; mfem::BilinearForm *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; - double arg3 ; + double arg3 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3867,7 +3891,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS int ecode3 = 0 ; mfem::OperatorJacobiSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); @@ -3884,11 +3908,13 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } { try { result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); @@ -3910,57 +3936,10 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::OperatorJacobiSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; - double arg3 ; + double arg3 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3969,7 +3948,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUS int ecode3 = 0 ; mfem::OperatorJacobiSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); @@ -3986,61 +3965,16 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::OperatorJacobiSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4066,7 +4000,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject * if (!(argc = SWIG_Python_UnpackTuple(args, "new_OperatorJacobiSmoother", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -4074,54 +4008,36 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_2(self, argc, argv); + return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); + return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); } } } @@ -4131,9 +4047,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject * SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OperatorJacobiSmoother'.\n" " Possible C/C++ prototypes are:\n" " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &,double const)\n" - " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &)\n" - " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &,double const)\n" - " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &)\n"); + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &,double const)\n"); return 0; } @@ -4172,7 +4086,7 @@ SWIGINTERN PyObject *_wrap_delete_OperatorJacobiSmoother(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4183,15 +4097,20 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorJacobiSmoother_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother const *""'"); } arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4199,7 +4118,7 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4227,7 +4146,7 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Operator *arg2 = 0 ; @@ -4235,15 +4154,19 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorJacobiSmoother_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -4271,7 +4194,7 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4279,15 +4202,19 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Setup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorJacobiSmoother_Setup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4415,7 +4342,7 @@ SWIGINTERN PyObject *_wrap_new_SLISolver(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -4423,15 +4350,19 @@ SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SLISolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_SetOperator" "', argument " "1"" of type '" "mfem::SLISolver *""'"); } arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -4459,7 +4390,7 @@ SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4470,15 +4401,20 @@ SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLISolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_Mult" "', argument " "1"" of type '" "mfem::SLISolver const *""'"); } arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4486,7 +4422,7 @@ SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4564,10 +4500,10 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ mfem::Operator *arg1 = 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1000 ; + double arg6 = (double) 1e-12 ; + double arg7 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4579,7 +4515,7 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ double val7 ; int ecode7 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -4604,28 +4540,36 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); @@ -4649,21 +4593,27 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; + mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -4672,42 +4622,63 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4725,60 +4696,194 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; +SWIGINTERN PyObject *_wrap_SLI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "SLI", 0, 8, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 7)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 5) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 6) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if ((argc >= 4) && (argc <= 8)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 5) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 6) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 7) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SLI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_CGSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::CGSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + try { + result = (mfem::CGSolver *)new mfem::CGSolver(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_CGSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + MPI_Comm arg1 ; + mfem::CGSolver *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CGSolver" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + result = (mfem::CGSolver *)new mfem::CGSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4789,60 +4894,73 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_CGSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_CGSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_CGSolver__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_CGSolver__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CGSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::CGSolver::CGSolver()\n" + " mfem::CGSolver::CGSolver(MPI_Comm)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_CGSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CGSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_SetOperator" "', argument " "1"" of type '" "mfem::CGSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4860,9 +4978,9 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CGSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -4871,35 +4989,38 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CGSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_Mult" "', argument " "1"" of type '" "mfem::CGSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + ((mfem::CGSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4917,87 +5038,23 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CGSolver" "', argument " "1"" of type '" "mfem::CGSolver *""'"); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5015,79 +5072,105 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *CGSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CGSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CGSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_CG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1000 ; + double arg6 = (double) 1e-12 ; + double arg7 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; double val7 ; int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"b", (char *)"x", (char *)"print_iter", (char *)"max_num_iter", (char *)"RTOLERANCE", (char *)"ATOLERANCE", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOO:CG", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (obj5) { + ecode6 = SWIG_AsVal_double(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (obj6) { + ecode7 = SWIG_AsVal_double(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CG" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5105,14 +5188,16 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PCG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5121,55 +5206,88 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"b", (char *)"x", (char *)"print_iter", (char *)"max_num_iter", (char *)"RTOLERANCE", (char *)"ATOLERANCE", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOO:PCG", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); + } + } + if (obj6) { + ecode7 = SWIG_AsVal_double(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (obj7) { + ecode8 = SWIG_AsVal_double(obj7, &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PCG" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); } { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5187,64 +5305,14 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GMRESSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + mfem::GMRESSolver *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + result = (mfem::GMRESSolver *)new mfem::GMRESSolver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5255,3376 +5323,31 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GMRESSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SLI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SLI", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SLI__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SLI__SWIG_9(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_8(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_7(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_6(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SLI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_CGSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::CGSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::CGSolver *)new mfem::CGSolver(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CGSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::CGSolver *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_CGSolver" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - { - try { - result = (mfem::CGSolver *)new mfem::CGSolver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_CGSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_CGSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_CGSolver__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_CGSolver__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CGSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CGSolver::CGSolver()\n" - " mfem::CGSolver::CGSolver(MPI_Comm)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_CGSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - mfem::Operator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "CGSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_SetOperator" "', argument " "1"" of type '" "mfem::CGSolver *""'"); - } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - { - try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CGSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "CGSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_Mult" "', argument " "1"" of type '" "mfem::CGSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::CGSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CGSolver" "', argument " "1"" of type '" "mfem::CGSolver *""'"); - } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *CGSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CGSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *CGSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_CG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "CG", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CG__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_CG__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_CG__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CG__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CG__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PCG" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "PCG", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_PCG__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PCG__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PCG__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PCG__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PCG__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PCG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_GMRESSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::GMRESSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::GMRESSolver *)new mfem::GMRESSolver(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GMRESSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::GMRESSolver *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GMRESSolver" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - { - try { - result = (mfem::GMRESSolver *)new mfem::GMRESSolver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GMRESSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GMRESSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GMRESSolver__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GMRESSolver__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GMRESSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GMRESSolver::GMRESSolver()\n" - " mfem::GMRESSolver::GMRESSolver(MPI_Comm)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetKDim(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_Mult" "', argument " "1"" of type '" "mfem::GMRESSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::GMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GMRESSolver" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *GMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GMRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *GMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_FGMRESSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FGMRESSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::FGMRESSolver *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - MPI_Comm *ptr = (MPI_Comm *)0; - int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); - if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FGMRESSolver" "', argument " "1"" of type '" "MPI_Comm""'"); - } - arg1 = *ptr; - if (SWIG_IsNewObj(res)) delete ptr; - } - { - try { - result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FGMRESSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_FGMRESSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_FGMRESSolver__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FGMRESSolver__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FGMRESSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FGMRESSolver::FGMRESSolver()\n" - " mfem::FGMRESSolver::FGMRESSolver(MPI_Comm)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FGMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetKDim(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FGMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_Mult" "', argument " "1"" of type '" "mfem::FGMRESSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::FGMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FGMRESSolver" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *FGMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FGMRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *FGMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Solver *arg4 = 0 ; - int *arg5 = 0 ; - int arg6 ; - double *arg7 = 0 ; - double arg8 ; - int arg9 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - double val8 ; - int ecode8 = 0 ; - int result; - - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - arg4 = reinterpret_cast< mfem::Solver * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); - } - arg5 = reinterpret_cast< int * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); - } - arg7 = reinterpret_cast< double * >(argp7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - if ((PyArray_PyIntAsInt(swig_obj[8]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg9 = PyArray_PyIntAsInt(swig_obj[8]); - } - { - try { - result = (int)mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,arg6,*arg7,arg8,arg9); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - int arg7 ; - double arg8 ; - double arg9 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val8 ; - int ecode8 = 0 ; - double val9 ; - int ecode9 = 0 ; - - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); - if (!SWIG_IsOK(ecode9)) { - SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GMRES" "', argument " "9"" of type '" "double""'"); - } - arg9 = static_cast< double >(val9); - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - int arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val8 ; - int ecode8 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - int arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[10] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES", 0, 9, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GMRES__SWIG_6(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_5(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_4(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_3(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GMRES__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - } - } - if (argc == 9) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[8], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GMRES__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - } - } - if (argc == 9) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[8]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GMRES(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,int,double &,double,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double,double)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::BiCGSTABSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - MPI_Comm arg1 ; - mfem::BiCGSTABSolver *result = 0 ; + MPI_Comm arg1 ; + mfem::GMRESSolver *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BiCGSTABSolver" "', argument " "1"" of type '" "MPI_Comm""'"); + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_GMRESSolver" "', argument " "1"" of type '" "MPI_Comm""'"); } arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } { try { - result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(arg1); + result = (mfem::GMRESSolver *)new mfem::GMRESSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8635,69 +5358,69 @@ SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GMRESSolver(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BiCGSTABSolver", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_GMRESSolver", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_BiCGSTABSolver__SWIG_0(self, argc, argv); + return _wrap_new_GMRESSolver__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_BiCGSTABSolver__SWIG_1(self, argc, argv); + return _wrap_new_GMRESSolver__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BiCGSTABSolver'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GMRESSolver'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BiCGSTABSolver::BiCGSTABSolver()\n" - " mfem::BiCGSTABSolver::BiCGSTABSolver(MPI_Comm)\n"); + " mfem::GMRESSolver::GMRESSolver()\n" + " mfem::GMRESSolver::GMRESSolver(MPI_Comm)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GMRESSolver_SetKDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); - } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + (arg1)->SetKDim(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8715,9 +5438,9 @@ SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -8726,33 +5449,38 @@ SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GMRESSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_Mult" "', argument " "1"" of type '" "mfem::BiCGSTABSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_Mult" "', argument " "1"" of type '" "mfem::GMRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::BiCGSTABSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::GMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8770,20 +5498,20 @@ SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCGSTABSolver" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GMRESSolver" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); { try { delete arg1; @@ -8791,119 +5519,38 @@ SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), catch (Swig::DirectorException &e) { SWIG_fail; } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *BiCGSTABSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BiCGSTABSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Solver *arg4 = 0 ; - int *arg5 = 0 ; - double *arg6 = 0 ; - double arg7 ; - int arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - double val7 ; - int ecode7 = 0 ; - int result; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - arg4 = reinterpret_cast< mfem::Solver * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); - } - arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); - } - arg6 = reinterpret_cast< double * >(argp6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *GMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GMRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_FGMRESSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::FGMRESSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (int)mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,*arg6,arg7,arg8); + result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -8914,94 +5561,31 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_FGMRESSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + MPI_Comm arg1 ; + mfem::FGMRESSolver *result = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FGMRESSolver" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BiCGSTAB" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9012,86 +5596,69 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_FGMRESSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_FGMRESSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_FGMRESSolver__SWIG_0(self, argc, argv); + } + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_FGMRESSolver__SWIG_1(self, argc, argv); + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FGMRESSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::FGMRESSolver::FGMRESSolver()\n" + " mfem::FGMRESSolver::FGMRESSolver(MPI_Comm)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_FGMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FGMRESSolver_SetKDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); } + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + (arg1)->SetKDim(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9109,71 +5676,83 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FGMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FGMRESSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_Mult" "', argument " "1"" of type '" "mfem::FGMRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + try { + ((mfem::FGMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FGMRESSolver" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); } + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9191,13 +5770,28 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *FGMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FGMRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *FGMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; + mfem::Solver *arg4 = 0 ; + int *arg5 = 0 ; + int arg6 ; + double *arg7 = 0 ; + double arg8 ; + int arg9 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9206,49 +5800,83 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + double val8 ; + int ecode8 = 0 ; + int result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::Solver * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); + } + arg7 = reinterpret_cast< double * >(argp7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[8]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg9 = PyArray_PyIntAsInt(swig_obj[8]); } { try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + result = (int)mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,arg6,*arg7,arg8,arg9); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9259,19 +5887,24 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + int arg7 = (int) 50 ; + double arg8 = (double) 1e-12 ; + double arg9 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9280,165 +5913,111 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_s int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val8 ; + int ecode8 = 0 ; + double val9 ; + int ecode9 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 9)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BiCGSTAB", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BiCGSTAB__SWIG_5(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_4(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_3(self, argc, argv); - } - } - } - } - } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } + if (swig_obj[6]) { + { + if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(swig_obj[6]); + } + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + } + if (swig_obj[8]) { + ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GMRES" "', argument " "9"" of type '" "double""'"); + } + arg9 = static_cast< double >(val9); + } + { + try { + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - if (argc == 7) { + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[10] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES", 0, 9, argv))) SWIG_fail; + --argc; + if ((argc >= 4) && (argc <= 9)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -9454,6 +6033,9 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -9463,6 +6045,9 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -9472,59 +6057,36 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } } if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); + if (argc <= 6) { + return _wrap_GMRES__SWIG_1(self, argc, argv); } - if (_v) { - return _wrap_BiCGSTAB__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { + if (argc <= 7) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BiCGSTAB__SWIG_0(self, argc, argv); + if (argc <= 8) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } } } } @@ -9534,30 +6096,25 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } } } - if (argc == 8) { + if (argc == 9) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { @@ -9568,17 +6125,26 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } } if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { { int res = SWIG_AsVal_double(argv[7], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[8]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GMRES__SWIG_0(self, argc, argv); + } } } } @@ -9590,26 +6156,22 @@ SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BiCGSTAB'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES'.\n" " Possible C/C++ prototypes are:\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,double &,double,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); + " mfem::GMRES(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,int,double &,double,int)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_new_MINRESSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { PyObject *resultobj = 0; - mfem::MINRESSolver *result = 0 ; + mfem::BiCGSTABSolver *result = 0 ; if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MINRESSolver *)new mfem::MINRESSolver(); + result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9620,31 +6182,31 @@ SWIGINTERN PyObject *_wrap_new_MINRESSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(sel // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MINRESSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; MPI_Comm arg1 ; - mfem::MINRESSolver *result = 0 ; + mfem::BiCGSTABSolver *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { MPI_Comm *ptr = (MPI_Comm *)0; int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); if (!SWIG_IsOK(res) || !ptr) { - SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MINRESSolver" "', argument " "1"" of type '" "MPI_Comm""'"); + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_BiCGSTABSolver" "', argument " "1"" of type '" "MPI_Comm""'"); } arg1 = *ptr; if (SWIG_IsNewObj(res)) delete ptr; } { try { - result = (mfem::MINRESSolver *)new mfem::MINRESSolver(arg1); + result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9655,108 +6217,68 @@ SWIGINTERN PyObject *_wrap_new_MINRESSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(sel // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MINRESSolver", 0, 1, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_BiCGSTABSolver", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { - return _wrap_new_MINRESSolver__SWIG_0(self, argc, argv); + return _wrap_new_BiCGSTABSolver__SWIG_0(self, argc, argv); } if (argc == 1) { int _v; int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MINRESSolver__SWIG_1(self, argc, argv); + return _wrap_new_BiCGSTABSolver__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MINRESSolver'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BiCGSTABSolver'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MINRESSolver::MINRESSolver()\n" - " mfem::MINRESSolver::MINRESSolver(MPI_Comm)\n"); + " mfem::BiCGSTABSolver::BiCGSTABSolver()\n" + " mfem::BiCGSTABSolver::BiCGSTABSolver(MPI_Comm)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; - mfem::Solver *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - { - try { - (arg1)->SetPreconditioner(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BiCGSTABSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetOperator" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); { @@ -9779,9 +6301,9 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -9790,33 +6312,38 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCGSTABSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_Mult" "', argument " "1"" of type '" "mfem::MINRESSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_Mult" "', argument " "1"" of type '" "mfem::BiCGSTABSolver const *""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MINRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + ((mfem::BiCGSTABSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9834,20 +6361,20 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MINRESSolver" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCGSTABSolver" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); { try { delete arg1; @@ -9868,87 +6395,106 @@ SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *MINRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BiCGSTABSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MINRESSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *MINRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *BiCGSTABSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; + mfem::Solver *arg4 = 0 ; + int *arg5 = 0 ; + double *arg6 = 0 ; double arg7 ; + int arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; double val7 ; int ecode7 = 0 ; + int result; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg4 = reinterpret_cast< mfem::Solver * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); + } + arg6 = reinterpret_cast< double * >(argp6); ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); } arg7 = static_cast< double >(val7); + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + result = (int)mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,*arg6,arg7,arg8); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9959,75 +6505,259 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssi // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; + mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BiCGSTAB" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + try { + mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BiCGSTAB", 0, 8, argv))) SWIG_fail; + --argc; + if ((argc >= 4) && (argc <= 8)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 5) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 6) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 7) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BiCGSTAB'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,double &,double,int)\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_MINRESSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { + PyObject *resultobj = 0; + mfem::MINRESSolver *result = 0 ; + + if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + result = (mfem::MINRESSolver *)new mfem::MINRESSolver(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10038,67 +6768,31 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssi // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MINRESSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + MPI_Comm arg1 ; + mfem::MINRESSolver *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + MPI_Comm *ptr = (MPI_Comm *)0; + int res = SWIG_AsPtr_MPI_Comm(swig_obj[0], &ptr); + if (!SWIG_IsOK(res) || !ptr) { + SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_MINRESSolver" "', argument " "1"" of type '" "MPI_Comm""'"); + } + arg1 = *ptr; + if (SWIG_IsNewObj(res)) delete ptr; } { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + result = (mfem::MINRESSolver *)new mfem::MINRESSolver(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10109,117 +6803,73 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssi // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; +SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!(argc = SWIG_Python_UnpackTuple(args, "new_MINRESSolver", 0, 1, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_MINRESSolver__SWIG_0(self, argc, argv); } - { - try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + if (argc == 1) { + int _v; + int res = SWIG_AsPtr_MPI_Comm(argv[0], (MPI_Comm**)(0)); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MINRESSolver__SWIG_1(self, argc, argv); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MINRESSolver'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MINRESSolver::MINRESSolver()\n" + " mfem::MINRESSolver::MINRESSolver(MPI_Comm)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Solver *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MINRESSolver_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + (arg1)->SetPreconditioner(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10237,87 +6887,37 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MINRESSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetOperator" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "MINRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10335,79 +6935,49 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MINRESSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_Mult" "', argument " "1"" of type '" "mfem::MINRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + ((mfem::MINRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10425,71 +6995,23 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MINRESSolver" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); } + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10507,23 +7029,38 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *MINRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MINRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MINRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1000 ; + double arg6 = (double) 1e-12 ; + double arg7 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -10532,39 +7069,55 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10582,12 +7135,16 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10596,8 +7153,12 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssi int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -10623,310 +7184,72 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssi } arg3 = reinterpret_cast< mfem::Vector * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MINRES", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MINRES__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_3(self, argc, argv); - } - } - } - } + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MINRES__SWIG_9(self, argc, argv); - } - } - } - } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_8(self, argc, argv); - } - } - } - } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_2(self, argc, argv); - } - } - } - } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_1(self, argc, argv); - } - } - } - } - } - } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_7(self, argc, argv); - } - } - } - } - } - } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "MINRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_6(self, argc, argv); - } - } - } - } - } - } + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - if (argc == 7) { + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MINRES", 0, 8, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 7)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -10938,6 +7261,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10947,6 +7273,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 4) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10956,11 +7285,17 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[5], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 6) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[6], NULL); _v = SWIG_CheckState(res); @@ -10975,7 +7310,7 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } } - if (argc == 8) { + if ((argc >= 4) && (argc <= 8)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -10991,6 +7326,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11000,6 +7338,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11009,17 +7350,23 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 6) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[6], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 7) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[7], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_MINRES__SWIG_5(self, argc, argv); + return _wrap_MINRES__SWIG_1(self, argc, argv); } } } @@ -11034,15 +7381,7 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MINRES'.\n" " Possible C/C++ prototypes are:\n" " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); + " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n"); return 0; } @@ -11136,7 +7475,7 @@ SWIGINTERN PyObject *_wrap_new_NewtonSolver(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -11144,15 +7483,19 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewtonSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetOperator" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -11180,7 +7523,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Solver *arg2 = 0 ; @@ -11188,15 +7531,19 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"solver", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetSolver", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewtonSolver_SetSolver", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetSolver" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetSolver" "', argument " "2"" of type '" "mfem::Solver &""'"); } @@ -11224,7 +7571,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11235,15 +7582,20 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NewtonSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_Mult" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11251,7 +7603,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11279,7 +7631,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11290,16 +7642,21 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"b", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ComputeScalingFactor", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NewtonSolver_ComputeScalingFactor", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11307,7 +7664,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -11335,7 +7692,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11343,15 +7700,19 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ProcessNewState", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewtonSolver_ProcessNewState", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ProcessNewState" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ProcessNewState" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11424,7 +7785,7 @@ SWIGINTERN PyObject *NewtonSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -11454,11 +7815,25 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res10 = 0 ; void *argp11 = 0 ; int res11 = 0 ; - PyObject *swig_obj[12] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + PyObject * obj8 = 0 ; + PyObject * obj9 = 0 ; + PyObject * obj10 = 0 ; + PyObject * obj11 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"x", (char *)"b", (char *)"M", (char *)"max_iter", (char *)"m_max", (char *)"m_min", (char *)"m_step", (char *)"cf", (char *)"tol", (char *)"atol", (char *)"printit", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "aGMRES", 12, 12, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOO:aGMRES", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } @@ -11466,7 +7841,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -11474,7 +7849,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -11482,7 +7857,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Operator, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); } @@ -11490,7 +7865,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "aGMRES" "', argument " "5"" of type '" "int &""'"); } @@ -11499,29 +7874,29 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args } arg5 = reinterpret_cast< int * >(argp5); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg6 = PyArray_PyIntAsInt(obj5); } { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj6) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + arg7 = PyArray_PyIntAsInt(obj6); } { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj7) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + arg8 = PyArray_PyIntAsInt(obj7); } - ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); + ecode9 = SWIG_AsVal_double(obj8, &val9); if (!SWIG_IsOK(ecode9)) { SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "aGMRES" "', argument " "9"" of type '" "double""'"); } arg9 = static_cast< double >(val9); - res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_double, 0 ); + res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res10)) { SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); } @@ -11529,7 +7904,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); } arg10 = reinterpret_cast< double * >(argp10); - res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_double, 0 ); + res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res11)) { SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "aGMRES" "', argument " "11"" of type '" "double &""'"); } @@ -11538,10 +7913,10 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args } arg11 = reinterpret_cast< double * >(argp11); { - if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj11) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg12 = PyArray_PyIntAsInt(swig_obj[11]); + arg12 = PyArray_PyIntAsInt(obj11); } { try { @@ -11586,7 +7961,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_input_size_get(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11594,16 +7969,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjective", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationProblem_CalcObjective", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjective" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjective" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11631,7 +8010,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11642,15 +8021,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjectiveGrad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationProblem_CalcObjectiveGrad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11658,7 +8042,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11686,7 +8070,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11694,15 +8078,19 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetEqualityConstraint", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationProblem_SetEqualityConstraint", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11730,7 +8118,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *S } -SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11741,15 +8129,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dl", (char *)"dh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetInequalityConstraint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationProblem_SetInequalityConstraint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11757,7 +8150,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -11785,7 +8178,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject } -SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11796,15 +8189,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"xl", (char *)"xh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetSolutionBounds", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationProblem_SetSolutionBounds", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11812,7 +8210,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -12195,7 +8593,7 @@ SWIGINTERN PyObject *_wrap_delete_OptimizationSolver(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; mfem::OptimizationProblem *arg2 = 0 ; @@ -12203,15 +8601,19 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"prob", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationSolver_SetOptimizationProblem", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); } @@ -12239,7 +8641,7 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *S } -SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12250,15 +8652,20 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"xt", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_Mult" "', argument " "1"" of type '" "mfem::OptimizationSolver const *""'"); } arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12266,7 +8673,7 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12294,7 +8701,7 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; mfem::Solver *arg2 = 0 ; @@ -12302,15 +8709,19 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUN int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationSolver_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } @@ -12338,7 +8749,7 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -12346,15 +8757,19 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOperator" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -12478,7 +8893,7 @@ SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; mfem::OptimizationProblem *arg2 = 0 ; @@ -12486,15 +8901,19 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"prob", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SLBQPOptimizer_SetOptimizationProblem", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); } @@ -12522,7 +8941,7 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12533,15 +8952,20 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_lo", (char *)"_hi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetBounds", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLBQPOptimizer_SetBounds", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12549,7 +8973,7 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -12577,260 +9001,46 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; mfem::Vector *arg2 = 0 ; double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetLinearConstraint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); - } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); - } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); - } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - { - try { - delete arg1; - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::BlockILU::Reordering arg2 ; - int arg3 ; - int val2 ; - int ecode2 = 0 ; - mfem::BlockILU *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg2 = static_cast< mfem::BlockILU::Reordering >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::BlockILU::Reordering arg2 ; - int val2 ; - int ecode2 = 0 ; - mfem::BlockILU *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg2 = static_cast< mfem::BlockILU::Reordering >(val2); - { - try { - result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::BlockILU *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_w", (char *)"_a", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLBQPOptimizer_SetLinearConstraint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(arg1); + (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12841,54 +9051,56 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - int arg2 ; - mfem::BlockILU::Reordering arg3 ; - int arg4 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::BlockILU *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"xt", (char *)"x", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLBQPOptimizer_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg3 = static_cast< mfem::BlockILU::Reordering >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3,arg4); + ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12899,47 +9111,30 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - int arg2 ; - mfem::BlockILU::Reordering arg3 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::BlockILU *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg3 = static_cast< mfem::BlockILU::Reordering >(val3); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3); + delete arg1; } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12950,39 +9145,58 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; + int arg1 ; + mfem::BlockILU::Reordering arg2 = (mfem::BlockILU::Reordering) mfem::BlockILU::Reordering::MINIMUM_DISCARDED_FILL ; + int arg3 = (int) 0 ; + int val2 ; + int ecode2 = 0 ; mfem::BlockILU *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg2 = static_cast< mfem::BlockILU::Reordering >(val2); + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2); + result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13000,14 +9214,19 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; + int arg2 = (int) 1 ; + mfem::BlockILU::Reordering arg3 = (mfem::BlockILU::Reordering) mfem::BlockILU::Reordering::MINIMUM_DISCARDED_FILL ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; mfem::BlockILU *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); @@ -13016,9 +9235,32 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg3 = static_cast< mfem::BlockILU::Reordering >(val3); + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1); + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13044,74 +9286,15 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlockILU", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BlockILU__SWIG_6(self, argc, argv); - } - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BlockILU__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BlockILU__SWIG_5(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { + if (argc <= 1) { return _wrap_new_BlockILU__SWIG_1(self, argc, argv); } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -13121,17 +9304,33 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_BlockILU__SWIG_4(self, argc, argv); + if (argc <= 3) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } } } } } - if (argc == 3) { + if ((argc >= 1) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -13142,11 +9341,17 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 1) { + return _wrap_new_BlockILU__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 2) { + return _wrap_new_BlockILU__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -13161,57 +9366,17 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { } } } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BlockILU__SWIG_3(self, argc, argv); - } - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlockILU'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering,int)\n" - " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering)\n" - " mfem::BlockILU::BlockILU(int)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering,int)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &,int)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &)\n"); + " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; mfem::Operator *arg2 = 0 ; @@ -13219,15 +9384,19 @@ SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockILU_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockILU_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_SetOperator" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -13255,7 +9424,7 @@ SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13266,15 +9435,20 @@ SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockILU_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockILU_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_Mult" "', argument " "1"" of type '" "mfem::BlockILU const *""'"); } arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13282,7 +9456,7 @@ SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockILU_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13463,33 +9637,33 @@ SWIGINTERN PyObject *BlockILU_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "IterativeSolver_SetRelTol(IterativeSolver self, double rtol)"}, - { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "IterativeSolver_SetAbsTol(IterativeSolver self, double atol)"}, - { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "IterativeSolver_SetMaxIter(IterativeSolver self, int max_it)"}, - { "IterativeSolver_SetPrintLevel", _wrap_IterativeSolver_SetPrintLevel, METH_VARARGS, "IterativeSolver_SetPrintLevel(IterativeSolver self, int print_lvl)"}, + { "IterativeSolver_SetRelTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetRelTol, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetRelTol(IterativeSolver self, double rtol)"}, + { "IterativeSolver_SetAbsTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetAbsTol, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetAbsTol(IterativeSolver self, double atol)"}, + { "IterativeSolver_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetMaxIter(IterativeSolver self, int max_it)"}, + { "IterativeSolver_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetPrintLevel(IterativeSolver self, int print_lvl)"}, { "IterativeSolver_GetNumIterations", _wrap_IterativeSolver_GetNumIterations, METH_O, "IterativeSolver_GetNumIterations(IterativeSolver self) -> int"}, { "IterativeSolver_GetConverged", _wrap_IterativeSolver_GetConverged, METH_O, "IterativeSolver_GetConverged(IterativeSolver self) -> int"}, { "IterativeSolver_GetFinalNorm", _wrap_IterativeSolver_GetFinalNorm, METH_O, "IterativeSolver_GetFinalNorm(IterativeSolver self) -> double"}, - { "IterativeSolver_SetPreconditioner", _wrap_IterativeSolver_SetPreconditioner, METH_VARARGS, "IterativeSolver_SetPreconditioner(IterativeSolver self, Solver pr)"}, - { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "IterativeSolver_SetOperator(IterativeSolver self, Operator op)"}, + { "IterativeSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetPreconditioner(IterativeSolver self, Solver pr)"}, + { "IterativeSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetOperator(IterativeSolver self, Operator op)"}, { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" - "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + "new_OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother\n" ""}, { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, - { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "OperatorJacobiSmoother_Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, - { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "OperatorJacobiSmoother_SetOperator(OperatorJacobiSmoother self, Operator op)"}, - { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "OperatorJacobiSmoother_Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "OperatorJacobiSmoother_Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "OperatorJacobiSmoother_SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Setup, METH_VARARGS|METH_KEYWORDS, "OperatorJacobiSmoother_Setup(OperatorJacobiSmoother self, Vector diag)"}, { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, { "new_SLISolver", _wrap_new_SLISolver, METH_VARARGS, "\n" "SLISolver()\n" "new_SLISolver(MPI_Comm _comm) -> SLISolver\n" ""}, - { "SLISolver_SetOperator", _wrap_SLISolver_SetOperator, METH_VARARGS, "SLISolver_SetOperator(SLISolver self, Operator op)"}, - { "SLISolver_Mult", _wrap_SLISolver_Mult, METH_VARARGS, "SLISolver_Mult(SLISolver self, Vector b, Vector x)"}, + { "SLISolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_SLISolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SLISolver_SetOperator(SLISolver self, Operator op)"}, + { "SLISolver_Mult", (PyCFunction)(void(*)(void))_wrap_SLISolver_Mult, METH_VARARGS|METH_KEYWORDS, "SLISolver_Mult(SLISolver self, Vector b, Vector x)"}, { "delete_SLISolver", _wrap_delete_SLISolver, METH_O, "delete_SLISolver(SLISolver self)"}, { "SLISolver_swigregister", SLISolver_swigregister, METH_O, NULL}, { "SLISolver_swiginit", SLISolver_swiginit, METH_VARARGS, NULL}, @@ -13501,19 +9675,19 @@ static PyMethodDef SwigMethods[] = { "CGSolver()\n" "new_CGSolver(MPI_Comm _comm) -> CGSolver\n" ""}, - { "CGSolver_SetOperator", _wrap_CGSolver_SetOperator, METH_VARARGS, "CGSolver_SetOperator(CGSolver self, Operator op)"}, - { "CGSolver_Mult", _wrap_CGSolver_Mult, METH_VARARGS, "CGSolver_Mult(CGSolver self, Vector b, Vector x)"}, + { "CGSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_CGSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "CGSolver_SetOperator(CGSolver self, Operator op)"}, + { "CGSolver_Mult", (PyCFunction)(void(*)(void))_wrap_CGSolver_Mult, METH_VARARGS|METH_KEYWORDS, "CGSolver_Mult(CGSolver self, Vector b, Vector x)"}, { "delete_CGSolver", _wrap_delete_CGSolver, METH_O, "delete_CGSolver(CGSolver self)"}, { "CGSolver_swigregister", CGSolver_swigregister, METH_O, NULL}, { "CGSolver_swiginit", CGSolver_swiginit, METH_VARARGS, NULL}, - { "CG", _wrap_CG, METH_VARARGS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, - { "PCG", _wrap_PCG, METH_VARARGS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "CG", (PyCFunction)(void(*)(void))_wrap_CG, METH_VARARGS|METH_KEYWORDS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "PCG", (PyCFunction)(void(*)(void))_wrap_PCG, METH_VARARGS|METH_KEYWORDS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, { "new_GMRESSolver", _wrap_new_GMRESSolver, METH_VARARGS, "\n" "GMRESSolver()\n" "new_GMRESSolver(MPI_Comm _comm) -> GMRESSolver\n" ""}, - { "GMRESSolver_SetKDim", _wrap_GMRESSolver_SetKDim, METH_VARARGS, "GMRESSolver_SetKDim(GMRESSolver self, int dim)"}, - { "GMRESSolver_Mult", _wrap_GMRESSolver_Mult, METH_VARARGS, "GMRESSolver_Mult(GMRESSolver self, Vector b, Vector x)"}, + { "GMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "GMRESSolver_SetKDim(GMRESSolver self, int dim)"}, + { "GMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "GMRESSolver_Mult(GMRESSolver self, Vector b, Vector x)"}, { "delete_GMRESSolver", _wrap_delete_GMRESSolver, METH_O, "delete_GMRESSolver(GMRESSolver self)"}, { "GMRESSolver_swigregister", GMRESSolver_swigregister, METH_O, NULL}, { "GMRESSolver_swiginit", GMRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13521,8 +9695,8 @@ static PyMethodDef SwigMethods[] = { "FGMRESSolver()\n" "new_FGMRESSolver(MPI_Comm _comm) -> FGMRESSolver\n" ""}, - { "FGMRESSolver_SetKDim", _wrap_FGMRESSolver_SetKDim, METH_VARARGS, "FGMRESSolver_SetKDim(FGMRESSolver self, int dim)"}, - { "FGMRESSolver_Mult", _wrap_FGMRESSolver_Mult, METH_VARARGS, "FGMRESSolver_Mult(FGMRESSolver self, Vector b, Vector x)"}, + { "FGMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "FGMRESSolver_SetKDim(FGMRESSolver self, int dim)"}, + { "FGMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "FGMRESSolver_Mult(FGMRESSolver self, Vector b, Vector x)"}, { "delete_FGMRESSolver", _wrap_delete_FGMRESSolver, METH_O, "delete_FGMRESSolver(FGMRESSolver self)"}, { "FGMRESSolver_swigregister", FGMRESSolver_swigregister, METH_O, NULL}, { "FGMRESSolver_swiginit", FGMRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13534,8 +9708,8 @@ static PyMethodDef SwigMethods[] = { "BiCGSTABSolver()\n" "new_BiCGSTABSolver(MPI_Comm _comm) -> BiCGSTABSolver\n" ""}, - { "BiCGSTABSolver_SetOperator", _wrap_BiCGSTABSolver_SetOperator, METH_VARARGS, "BiCGSTABSolver_SetOperator(BiCGSTABSolver self, Operator op)"}, - { "BiCGSTABSolver_Mult", _wrap_BiCGSTABSolver_Mult, METH_VARARGS, "BiCGSTABSolver_Mult(BiCGSTABSolver self, Vector b, Vector x)"}, + { "BiCGSTABSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "BiCGSTABSolver_SetOperator(BiCGSTABSolver self, Operator op)"}, + { "BiCGSTABSolver_Mult", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_Mult, METH_VARARGS|METH_KEYWORDS, "BiCGSTABSolver_Mult(BiCGSTABSolver self, Vector b, Vector x)"}, { "delete_BiCGSTABSolver", _wrap_delete_BiCGSTABSolver, METH_O, "delete_BiCGSTABSolver(BiCGSTABSolver self)"}, { "BiCGSTABSolver_swigregister", BiCGSTABSolver_swigregister, METH_O, NULL}, { "BiCGSTABSolver_swiginit", BiCGSTABSolver_swiginit, METH_VARARGS, NULL}, @@ -13547,9 +9721,9 @@ static PyMethodDef SwigMethods[] = { "MINRESSolver()\n" "new_MINRESSolver(MPI_Comm _comm) -> MINRESSolver\n" ""}, - { "MINRESSolver_SetPreconditioner", _wrap_MINRESSolver_SetPreconditioner, METH_VARARGS, "MINRESSolver_SetPreconditioner(MINRESSolver self, Solver pr)"}, - { "MINRESSolver_SetOperator", _wrap_MINRESSolver_SetOperator, METH_VARARGS, "MINRESSolver_SetOperator(MINRESSolver self, Operator op)"}, - { "MINRESSolver_Mult", _wrap_MINRESSolver_Mult, METH_VARARGS, "MINRESSolver_Mult(MINRESSolver self, Vector b, Vector x)"}, + { "MINRESSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "MINRESSolver_SetPreconditioner(MINRESSolver self, Solver pr)"}, + { "MINRESSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "MINRESSolver_SetOperator(MINRESSolver self, Operator op)"}, + { "MINRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "MINRESSolver_Mult(MINRESSolver self, Vector b, Vector x)"}, { "delete_MINRESSolver", _wrap_delete_MINRESSolver, METH_O, "delete_MINRESSolver(MINRESSolver self)"}, { "MINRESSolver_swigregister", MINRESSolver_swigregister, METH_O, NULL}, { "MINRESSolver_swiginit", MINRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13561,21 +9735,21 @@ static PyMethodDef SwigMethods[] = { "NewtonSolver()\n" "new_NewtonSolver(MPI_Comm _comm) -> NewtonSolver\n" ""}, - { "NewtonSolver_SetOperator", _wrap_NewtonSolver_SetOperator, METH_VARARGS, "NewtonSolver_SetOperator(NewtonSolver self, Operator op)"}, - { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "NewtonSolver_SetSolver(NewtonSolver self, Solver solver)"}, - { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "NewtonSolver_Mult(NewtonSolver self, Vector b, Vector x)"}, - { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "NewtonSolver_ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, - { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "NewtonSolver_ProcessNewState(NewtonSolver self, Vector x)"}, + { "NewtonSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_SetOperator(NewtonSolver self, Operator op)"}, + { "NewtonSolver_SetSolver", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetSolver, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_SetSolver(NewtonSolver self, Solver solver)"}, + { "NewtonSolver_Mult", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_Mult, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_Mult(NewtonSolver self, Vector b, Vector x)"}, + { "NewtonSolver_ComputeScalingFactor", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ProcessNewState, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_ProcessNewState(NewtonSolver self, Vector x)"}, { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, - { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "aGMRES", (PyCFunction)(void(*)(void))_wrap_aGMRES, METH_VARARGS|METH_KEYWORDS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, - { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "OptimizationProblem_CalcObjective(OptimizationProblem self, Vector x) -> double"}, - { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "OptimizationProblem_CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, - { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "OptimizationProblem_SetEqualityConstraint(OptimizationProblem self, Vector c)"}, - { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "OptimizationProblem_SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, - { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "OptimizationProblem_SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_CalcObjective", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjective, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "OptimizationProblem_GetC(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "OptimizationProblem_GetD(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "OptimizationProblem_GetEqualityVec(OptimizationProblem self) -> Vector"}, @@ -13587,28 +9761,28 @@ static PyMethodDef SwigMethods[] = { { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, - { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "OptimizationSolver_SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, - { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "OptimizationSolver_Mult(OptimizationSolver self, Vector xt, Vector x)"}, - { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "OptimizationSolver_SetPreconditioner(OptimizationSolver self, Solver pr)"}, - { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "OptimizationSolver_SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_Mult, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_SetOperator(OptimizationSolver self, Operator op)"}, { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_VARARGS, "\n" "SLBQPOptimizer()\n" "new_SLBQPOptimizer(MPI_Comm _comm) -> SLBQPOptimizer\n" ""}, - { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SLBQPOptimizer_SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, - { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SLBQPOptimizer_SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, - { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SLBQPOptimizer_SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, - { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "SLBQPOptimizer_Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, + { "SLBQPOptimizer_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, + { "SLBQPOptimizer_SetBounds", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetBounds, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, + { "SLBQPOptimizer_SetLinearConstraint", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, + { "SLBQPOptimizer_Mult", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_Mult, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" - "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "new_BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU\n" ""}, - { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "BlockILU_SetOperator(BlockILU self, Operator op)"}, - { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "BlockILU_Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockILU_SetOperator, METH_VARARGS|METH_KEYWORDS, "BlockILU_SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", (PyCFunction)(void(*)(void))_wrap_BlockILU_Mult, METH_VARARGS|METH_KEYWORDS, "BlockILU_Mult(BlockILU self, Vector b, Vector x)"}, { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "BlockILU_GetBlockI(BlockILU self) -> int *"}, { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "BlockILU_GetBlockJ(BlockILU self) -> int *"}, { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "BlockILU_GetBlockData(BlockILU self) -> double *"}, @@ -13621,33 +9795,33 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "SetRelTol(IterativeSolver self, double rtol)"}, - { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "SetAbsTol(IterativeSolver self, double atol)"}, - { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "SetMaxIter(IterativeSolver self, int max_it)"}, - { "IterativeSolver_SetPrintLevel", _wrap_IterativeSolver_SetPrintLevel, METH_VARARGS, "SetPrintLevel(IterativeSolver self, int print_lvl)"}, + { "IterativeSolver_SetRelTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetRelTol, METH_VARARGS|METH_KEYWORDS, "SetRelTol(IterativeSolver self, double rtol)"}, + { "IterativeSolver_SetAbsTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetAbsTol, METH_VARARGS|METH_KEYWORDS, "SetAbsTol(IterativeSolver self, double atol)"}, + { "IterativeSolver_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(IterativeSolver self, int max_it)"}, + { "IterativeSolver_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(IterativeSolver self, int print_lvl)"}, { "IterativeSolver_GetNumIterations", _wrap_IterativeSolver_GetNumIterations, METH_O, "GetNumIterations(IterativeSolver self) -> int"}, { "IterativeSolver_GetConverged", _wrap_IterativeSolver_GetConverged, METH_O, "GetConverged(IterativeSolver self) -> int"}, { "IterativeSolver_GetFinalNorm", _wrap_IterativeSolver_GetFinalNorm, METH_O, "GetFinalNorm(IterativeSolver self) -> double"}, - { "IterativeSolver_SetPreconditioner", _wrap_IterativeSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(IterativeSolver self, Solver pr)"}, - { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "SetOperator(IterativeSolver self, Operator op)"}, + { "IterativeSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(IterativeSolver self, Solver pr)"}, + { "IterativeSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(IterativeSolver self, Operator op)"}, { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" - "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + "new_OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother\n" ""}, { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, - { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, - { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "SetOperator(OperatorJacobiSmoother self, Operator op)"}, - { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Setup, METH_VARARGS|METH_KEYWORDS, "Setup(OperatorJacobiSmoother self, Vector diag)"}, { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, { "new_SLISolver", _wrap_new_SLISolver, METH_VARARGS, "\n" "SLISolver()\n" "new_SLISolver(MPI_Comm _comm) -> SLISolver\n" ""}, - { "SLISolver_SetOperator", _wrap_SLISolver_SetOperator, METH_VARARGS, "SetOperator(SLISolver self, Operator op)"}, - { "SLISolver_Mult", _wrap_SLISolver_Mult, METH_VARARGS, "Mult(SLISolver self, Vector b, Vector x)"}, + { "SLISolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_SLISolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(SLISolver self, Operator op)"}, + { "SLISolver_Mult", (PyCFunction)(void(*)(void))_wrap_SLISolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(SLISolver self, Vector b, Vector x)"}, { "delete_SLISolver", _wrap_delete_SLISolver, METH_O, "delete_SLISolver(SLISolver self)"}, { "SLISolver_swigregister", SLISolver_swigregister, METH_O, NULL}, { "SLISolver_swiginit", SLISolver_swiginit, METH_VARARGS, NULL}, @@ -13659,19 +9833,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CGSolver()\n" "new_CGSolver(MPI_Comm _comm) -> CGSolver\n" ""}, - { "CGSolver_SetOperator", _wrap_CGSolver_SetOperator, METH_VARARGS, "SetOperator(CGSolver self, Operator op)"}, - { "CGSolver_Mult", _wrap_CGSolver_Mult, METH_VARARGS, "Mult(CGSolver self, Vector b, Vector x)"}, + { "CGSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_CGSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(CGSolver self, Operator op)"}, + { "CGSolver_Mult", (PyCFunction)(void(*)(void))_wrap_CGSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(CGSolver self, Vector b, Vector x)"}, { "delete_CGSolver", _wrap_delete_CGSolver, METH_O, "delete_CGSolver(CGSolver self)"}, { "CGSolver_swigregister", CGSolver_swigregister, METH_O, NULL}, { "CGSolver_swiginit", CGSolver_swiginit, METH_VARARGS, NULL}, - { "CG", _wrap_CG, METH_VARARGS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, - { "PCG", _wrap_PCG, METH_VARARGS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "CG", (PyCFunction)(void(*)(void))_wrap_CG, METH_VARARGS|METH_KEYWORDS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "PCG", (PyCFunction)(void(*)(void))_wrap_PCG, METH_VARARGS|METH_KEYWORDS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, { "new_GMRESSolver", _wrap_new_GMRESSolver, METH_VARARGS, "\n" "GMRESSolver()\n" "new_GMRESSolver(MPI_Comm _comm) -> GMRESSolver\n" ""}, - { "GMRESSolver_SetKDim", _wrap_GMRESSolver_SetKDim, METH_VARARGS, "SetKDim(GMRESSolver self, int dim)"}, - { "GMRESSolver_Mult", _wrap_GMRESSolver_Mult, METH_VARARGS, "Mult(GMRESSolver self, Vector b, Vector x)"}, + { "GMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "SetKDim(GMRESSolver self, int dim)"}, + { "GMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(GMRESSolver self, Vector b, Vector x)"}, { "delete_GMRESSolver", _wrap_delete_GMRESSolver, METH_O, "delete_GMRESSolver(GMRESSolver self)"}, { "GMRESSolver_swigregister", GMRESSolver_swigregister, METH_O, NULL}, { "GMRESSolver_swiginit", GMRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13679,8 +9853,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FGMRESSolver()\n" "new_FGMRESSolver(MPI_Comm _comm) -> FGMRESSolver\n" ""}, - { "FGMRESSolver_SetKDim", _wrap_FGMRESSolver_SetKDim, METH_VARARGS, "SetKDim(FGMRESSolver self, int dim)"}, - { "FGMRESSolver_Mult", _wrap_FGMRESSolver_Mult, METH_VARARGS, "Mult(FGMRESSolver self, Vector b, Vector x)"}, + { "FGMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "SetKDim(FGMRESSolver self, int dim)"}, + { "FGMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(FGMRESSolver self, Vector b, Vector x)"}, { "delete_FGMRESSolver", _wrap_delete_FGMRESSolver, METH_O, "delete_FGMRESSolver(FGMRESSolver self)"}, { "FGMRESSolver_swigregister", FGMRESSolver_swigregister, METH_O, NULL}, { "FGMRESSolver_swiginit", FGMRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13692,8 +9866,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "BiCGSTABSolver()\n" "new_BiCGSTABSolver(MPI_Comm _comm) -> BiCGSTABSolver\n" ""}, - { "BiCGSTABSolver_SetOperator", _wrap_BiCGSTABSolver_SetOperator, METH_VARARGS, "SetOperator(BiCGSTABSolver self, Operator op)"}, - { "BiCGSTABSolver_Mult", _wrap_BiCGSTABSolver_Mult, METH_VARARGS, "Mult(BiCGSTABSolver self, Vector b, Vector x)"}, + { "BiCGSTABSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BiCGSTABSolver self, Operator op)"}, + { "BiCGSTABSolver_Mult", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BiCGSTABSolver self, Vector b, Vector x)"}, { "delete_BiCGSTABSolver", _wrap_delete_BiCGSTABSolver, METH_O, "delete_BiCGSTABSolver(BiCGSTABSolver self)"}, { "BiCGSTABSolver_swigregister", BiCGSTABSolver_swigregister, METH_O, NULL}, { "BiCGSTABSolver_swiginit", BiCGSTABSolver_swiginit, METH_VARARGS, NULL}, @@ -13705,9 +9879,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MINRESSolver()\n" "new_MINRESSolver(MPI_Comm _comm) -> MINRESSolver\n" ""}, - { "MINRESSolver_SetPreconditioner", _wrap_MINRESSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(MINRESSolver self, Solver pr)"}, - { "MINRESSolver_SetOperator", _wrap_MINRESSolver_SetOperator, METH_VARARGS, "SetOperator(MINRESSolver self, Operator op)"}, - { "MINRESSolver_Mult", _wrap_MINRESSolver_Mult, METH_VARARGS, "Mult(MINRESSolver self, Vector b, Vector x)"}, + { "MINRESSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(MINRESSolver self, Solver pr)"}, + { "MINRESSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(MINRESSolver self, Operator op)"}, + { "MINRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(MINRESSolver self, Vector b, Vector x)"}, { "delete_MINRESSolver", _wrap_delete_MINRESSolver, METH_O, "delete_MINRESSolver(MINRESSolver self)"}, { "MINRESSolver_swigregister", MINRESSolver_swigregister, METH_O, NULL}, { "MINRESSolver_swiginit", MINRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13719,21 +9893,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "NewtonSolver()\n" "new_NewtonSolver(MPI_Comm _comm) -> NewtonSolver\n" ""}, - { "NewtonSolver_SetOperator", _wrap_NewtonSolver_SetOperator, METH_VARARGS, "SetOperator(NewtonSolver self, Operator op)"}, - { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "SetSolver(NewtonSolver self, Solver solver)"}, - { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "Mult(NewtonSolver self, Vector b, Vector x)"}, - { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, - { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "ProcessNewState(NewtonSolver self, Vector x)"}, + { "NewtonSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(NewtonSolver self, Operator op)"}, + { "NewtonSolver_SetSolver", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetSolver, METH_VARARGS|METH_KEYWORDS, "SetSolver(NewtonSolver self, Solver solver)"}, + { "NewtonSolver_Mult", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(NewtonSolver self, Vector b, Vector x)"}, + { "NewtonSolver_ComputeScalingFactor", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS|METH_KEYWORDS, "ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ProcessNewState, METH_VARARGS|METH_KEYWORDS, "ProcessNewState(NewtonSolver self, Vector x)"}, { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, - { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "aGMRES", (PyCFunction)(void(*)(void))_wrap_aGMRES, METH_VARARGS|METH_KEYWORDS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, - { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "CalcObjective(OptimizationProblem self, Vector x) -> double"}, - { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, - { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "SetEqualityConstraint(OptimizationProblem self, Vector c)"}, - { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, - { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_CalcObjective", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjective, METH_VARARGS|METH_KEYWORDS, "CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS|METH_KEYWORDS, "CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS|METH_KEYWORDS, "SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS|METH_KEYWORDS, "SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS|METH_KEYWORDS, "SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "GetC(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "GetD(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "GetEqualityVec(OptimizationProblem self) -> Vector"}, @@ -13745,28 +9919,28 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, - { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, - { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "Mult(OptimizationSolver self, Vector xt, Vector x)"}, - { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(OptimizationSolver self, Solver pr)"}, - { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(OptimizationSolver self, Operator op)"}, { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_VARARGS, "\n" "SLBQPOptimizer()\n" "new_SLBQPOptimizer(MPI_Comm _comm) -> SLBQPOptimizer\n" ""}, - { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, - { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, - { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, - { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, + { "SLBQPOptimizer_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, + { "SLBQPOptimizer_SetBounds", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetBounds, METH_VARARGS|METH_KEYWORDS, "SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, + { "SLBQPOptimizer_SetLinearConstraint", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS|METH_KEYWORDS, "SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, + { "SLBQPOptimizer_Mult", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" - "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "new_BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU\n" ""}, - { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "SetOperator(BlockILU self, Operator op)"}, - { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockILU_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", (PyCFunction)(void(*)(void))_wrap_BlockILU_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockILU self, Vector b, Vector x)"}, { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "GetBlockI(BlockILU self) -> int *"}, { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "GetBlockJ(BlockILU self) -> int *"}, { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "GetBlockData(BlockILU self) -> double *"}, @@ -14854,10 +11028,10 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/par")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); - SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21802))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/par")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); + SWIG_Python_SetConstant(d, "MFEM_HYPRE_VERSION",SWIG_From_int(static_cast< int >(21600))); if (import_mpi4py() < 0) #if PY_MAJOR_VERSION >= 3 diff --git a/mfem/_par/sparsemat.py b/mfem/_par/sparsemat.py index ff641caa..0f3d6411 100644 --- a/mfem/_par/sparsemat.py +++ b/mfem/_par/sparsemat.py @@ -205,17 +205,17 @@ def GetMemoryI(self, *args): GetMemoryI = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryI) def ReadI(self, on_dev=True): - r"""ReadI(SparseMatrix self, bool on_dev=True) -> int const""" + r"""ReadI(SparseMatrix self, bool on_dev=True) -> int const *""" return _sparsemat.SparseMatrix_ReadI(self, on_dev) ReadI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadI) def WriteI(self, on_dev=True): - r"""WriteI(SparseMatrix self, bool on_dev=True) -> int""" + r"""WriteI(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_WriteI(self, on_dev) WriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteI) def ReadWriteI(self, on_dev=True): - r"""ReadWriteI(SparseMatrix self, bool on_dev=True) -> int""" + r"""ReadWriteI(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_ReadWriteI(self, on_dev) ReadWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteI) @@ -243,17 +243,17 @@ def GetMemoryJ(self, *args): GetMemoryJ = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryJ) def ReadJ(self, on_dev=True): - r"""ReadJ(SparseMatrix self, bool on_dev=True) -> int const""" + r"""ReadJ(SparseMatrix self, bool on_dev=True) -> int const *""" return _sparsemat.SparseMatrix_ReadJ(self, on_dev) ReadJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadJ) def WriteJ(self, on_dev=True): - r"""WriteJ(SparseMatrix self, bool on_dev=True) -> int""" + r"""WriteJ(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_WriteJ(self, on_dev) WriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteJ) def ReadWriteJ(self, on_dev=True): - r"""ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int""" + r"""ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_ReadWriteJ(self, on_dev) ReadWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteJ) @@ -281,17 +281,17 @@ def GetMemoryData(self, *args): GetMemoryData = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryData) def ReadData(self, on_dev=True): - r"""ReadData(SparseMatrix self, bool on_dev=True) -> double const""" + r"""ReadData(SparseMatrix self, bool on_dev=True) -> double const *""" return _sparsemat.SparseMatrix_ReadData(self, on_dev) ReadData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadData) def WriteData(self, on_dev=True): - r"""WriteData(SparseMatrix self, bool on_dev=True) -> double""" + r"""WriteData(SparseMatrix self, bool on_dev=True) -> double *""" return _sparsemat.SparseMatrix_WriteData(self, on_dev) WriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteData) def ReadWriteData(self, on_dev=True): - r"""ReadWriteData(SparseMatrix self, bool on_dev=True) -> double""" + r"""ReadWriteData(SparseMatrix self, bool on_dev=True) -> double *""" return _sparsemat.SparseMatrix_ReadWriteData(self, on_dev) ReadWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteData) @@ -468,9 +468,9 @@ def EliminateRow(self, *args): return _sparsemat.SparseMatrix_EliminateRow(self, *args) EliminateRow = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRow) - def EliminateCol(self, *args): + def EliminateCol(self, *args, **kwargs): r"""EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)""" - return _sparsemat.SparseMatrix_EliminateCol(self, *args) + return _sparsemat.SparseMatrix_EliminateCol(self, *args, **kwargs) EliminateCol = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCol) def EliminateCols(self, *args): @@ -481,9 +481,9 @@ def EliminateCols(self, *args): return _sparsemat.SparseMatrix_EliminateCols(self, *args) EliminateCols = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCols) - def EliminateRowColMultipleRHS(self, *args): + def EliminateRowColMultipleRHS(self, *args, **kwargs): r"""EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)""" - return _sparsemat.SparseMatrix_EliminateRowColMultipleRHS(self, *args) + return _sparsemat.SparseMatrix_EliminateRowColMultipleRHS(self, *args, **kwargs) EliminateRowColMultipleRHS = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowColMultipleRHS) def EliminateRowColDiag(self, rc, value): diff --git a/mfem/_par/sparsemat_wrap.cxx b/mfem/_par/sparsemat_wrap.cxx index 9c53ac93..b25f34f0 100644 --- a/mfem/_par/sparsemat_wrap.cxx +++ b/mfem/_par/sparsemat_wrap.cxx @@ -3562,7 +3562,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_SparseMatrix_Print__SWIG_3(mfem::SparseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_SparseMatrix_Print__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3573,7 +3573,7 @@ SWIGINTERN void mfem_SparseMatrix_Print__SWIG_3(mfem::SparseMatrix *self,char co self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintMatlab__SWIG_2(mfem::SparseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_SparseMatrix_PrintMatlab__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3584,7 +3584,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintMatlab__SWIG_2(mfem::SparseMatrix *self,c self -> PrintMatlab(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintMM__SWIG_2(mfem::SparseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_SparseMatrix_PrintMM__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3606,7 +3606,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintCSR__SWIG_1(mfem::SparseMatrix *self,char self -> PrintCSR(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintCSR__SWIG_3(mfem::SparseMatrix *self){ +SWIGINTERN void mfem_SparseMatrix_PrintCSR__SWIG_2(mfem::SparseMatrix *self){ self -> PrintCSR(std::cout); } SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ @@ -3620,7 +3620,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_1(mfem::SparseMatrix *self,cha self -> PrintCSR2(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_3(mfem::SparseMatrix *self){ +SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_2(mfem::SparseMatrix *self){ self -> PrintCSR2(std::cout); } SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ @@ -3634,7 +3634,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_1(mfem::SparseMatrix *self,cha self -> PrintInfo(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_3(mfem::SparseMatrix *self){ +SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_2(mfem::SparseMatrix *self){ self -> PrintInfo(std::cout); } @@ -3648,7 +3648,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_3(mfem::SparseMatrix *self){ #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -3659,11 +3659,16 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"R", (char *)"ORAP", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RAP_P", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAP_P", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP_P" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3671,7 +3676,7 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_P" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAP_P" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3679,7 +3684,7 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_P" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP_P" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); } @@ -3704,7 +3709,7 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -3715,11 +3720,16 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"Rt", (char *)"A", (char *)"P", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RAP_R", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAP_R", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP_R" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3727,7 +3737,7 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_R" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAP_R" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3735,7 +3745,7 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_R" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP_R" "', argument " "3"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3763,18 +3773,20 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_OperatorPtr2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorPtr2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorPtr arg1 ; void *argp1 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:OperatorPtr2SparseMatrix", kwnames, &obj0)) SWIG_fail; { - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__OperatorPtr, 0 | 0); + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__OperatorPtr, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorPtr2SparseMatrix" "', argument " "1"" of type '" "mfem::OperatorPtr""'"); } @@ -3806,18 +3818,20 @@ SWIGINTERN PyObject *_wrap_OperatorPtr2SparseMatrix(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_OperatorHandle2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle arg1 ; void *argp1 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:OperatorHandle2SparseMatrix", kwnames, &obj0)) SWIG_fail; { - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle2SparseMatrix" "', argument " "1"" of type '" "mfem::OperatorHandle""'"); } @@ -4102,21 +4116,23 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) -1 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -4139,38 +4155,6 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SparseMatrix *)new mfem::SparseMatrix(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; int *arg2 = (int *) 0 ; @@ -4232,7 +4216,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; int *arg2 = (int *) 0 ; @@ -4318,7 +4302,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -4364,17 +4348,17 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -4383,50 +4367,16 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrix" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::SparseMatrix *)new mfem::SparseMatrix((mfem::SparseMatrix const &)*arg1,arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrix" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::SparseMatrix *)new mfem::SparseMatrix((mfem::SparseMatrix const &)*arg1); + result = (mfem::SparseMatrix *)new mfem::SparseMatrix((mfem::SparseMatrix const &)*arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4444,7 +4394,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; @@ -4491,12 +4441,21 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_SparseMatrix__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_SparseMatrix__SWIG_7(self, argc, argv); + if (argc <= 1) { + return _wrap_new_SparseMatrix__SWIG_5(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SparseMatrix__SWIG_5(self, argc, argv); + } } } if (argc == 1) { @@ -4504,10 +4463,10 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_SparseMatrix__SWIG_8(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_6(self, argc, argv); } } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -4518,7 +4477,20 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); + if (argc <= 1) { + return _wrap_new_SparseMatrix__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SparseMatrix__SWIG_1(self, argc, argv); + } } } if (argc == 1) { @@ -4539,56 +4511,18 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { } if (_v) { if (argc <= 1) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } if (argc <= 2) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } if (argc <= 3) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } if (argc <= 4) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); - } - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SparseMatrix__SWIG_6(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SparseMatrix__SWIG_1(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } } if (argc == 3) { @@ -4620,7 +4554,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_SparseMatrix__SWIG_5(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_4(self, argc, argv); } } } @@ -4657,7 +4591,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_SparseMatrix__SWIG_4(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); } } } @@ -4669,18 +4603,16 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::SparseMatrix()\n" " mfem::SparseMatrix::SparseMatrix(int,int)\n" - " mfem::SparseMatrix::SparseMatrix(int)\n" " mfem::SparseMatrix::SparseMatrix(int *,int *,double *,int,int)\n" " mfem::SparseMatrix::SparseMatrix(int *,int *,double *,int,int,bool,bool,bool)\n" " mfem::SparseMatrix::SparseMatrix(int,int,int)\n" " mfem::SparseMatrix::SparseMatrix(mfem::SparseMatrix const &,bool)\n" - " mfem::SparseMatrix::SparseMatrix(mfem::SparseMatrix const &)\n" " mfem::SparseMatrix::SparseMatrix(mfem::Vector const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -4688,15 +4620,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"master", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_MakeRef", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_MakeRef", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MakeRef" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_MakeRef" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -5236,27 +5172,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadI" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(arg2); @@ -5277,22 +5220,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_WriteI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(); + result = (int *)(arg1)->WriteI(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5310,72 +5268,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadI", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadI__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadI__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadI(bool) const\n" - " mfem::SparseMatrix::ReadI() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadWriteI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteI" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)(arg1)->WriteI(arg2); + result = (int *)(arg1)->ReadWriteI(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5393,22 +5316,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int *)(arg1)->WriteI(); + result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadI(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5426,72 +5351,59 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteI", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_WriteI__SWIG_1(self, argc, argv); - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_WriteI__SWIG_0(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (int *)(arg1)->HostWriteI(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::WriteI(bool)\n" - " mfem::SparseMatrix::WriteI()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + PyObject *swig_obj[1] ; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteI" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { try { - result = (int *)(arg1)->ReadWriteI(arg2); + result = (int *)(arg1)->HostReadWriteI(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5509,22 +5421,55 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int *result = 0 ; + mfem::Memory< int > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< int > *) &(arg1)->GetMemoryJ(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< int > *result = 0 ; + + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int *)(arg1)->ReadWriteI(); + result = (mfem::Memory< int > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryJ(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5535,20 +5480,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_1(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[2] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteI", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryJ", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { int _v; @@ -5556,52 +5501,59 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_ReadWriteI__SWIG_1(self, argc, argv); + return _wrap_SparseMatrix_GetMemoryJ__SWIG_0(self, argc, argv); } } - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadWriteI__SWIG_0(self, argc, argv); - } + return _wrap_SparseMatrix_GetMemoryJ__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteI'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryJ'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadWriteI(bool)\n" - " mfem::SparseMatrix::ReadWriteI()\n"); + " mfem::SparseMatrix::GetMemoryJ()\n" + " mfem::SparseMatrix::GetMemoryJ() const\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadJ", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadI(); + result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5619,24 +5571,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadI(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_WriteJ", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)(arg1)->HostWriteI(); + result = (int *)(arg1)->WriteJ(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5654,24 +5619,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteI(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadWriteJ", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)(arg1)->HostReadWriteI(); + result = (int *)(arg1)->ReadWriteJ(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5689,22 +5667,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteI(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< int > *result = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::Memory< int > *) &(arg1)->GetMemoryJ(); + result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadJ(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5715,29 +5695,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_0(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< int > *result = 0 ; + PyObject *swig_obj[1] ; + int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::Memory< int > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryJ(); + result = (int *)(arg1)->HostWriteJ(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5748,73 +5730,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ__SWIG_1(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_int_t, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryJ", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_GetMemoryJ__SWIG_0(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_GetMemoryJ__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::GetMemoryJ()\n" - " mfem::SparseMatrix::GetMemoryJ() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + PyObject *swig_obj[1] ; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadJ" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(arg2); + result = (int *)(arg1)->HostReadWriteJ(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5832,22 +5772,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int *result = 0 ; + mfem::Memory< double > *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(); + result = (mfem::Memory< double > *) &(arg1)->GetMemoryData(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5858,79 +5798,113 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_1(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::Memory< double > *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadJ", 0, 2, argv))) SWIG_fail; - --argc; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::Memory< double > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryData(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[2] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryData", 0, 1, argv))) SWIG_fail; + --argc; if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_ReadJ__SWIG_1(self, argc, argv); + return _wrap_SparseMatrix_GetMemoryData__SWIG_0(self, argc, argv); } } - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadJ__SWIG_0(self, argc, argv); - } + return _wrap_SparseMatrix_GetMemoryData__SWIG_1(self, argc, argv); } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadJ'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryData'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadJ(bool) const\n" - " mfem::SparseMatrix::ReadJ() const\n"); + " mfem::SparseMatrix::GetMemoryData()\n" + " mfem::SparseMatrix::GetMemoryData() const\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - int *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteJ" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)(arg1)->WriteJ(arg2); + result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5941,29 +5915,44 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM( // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - int *result = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; + double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_WriteData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)(arg1)->WriteJ(); + result = (double *)(arg1)->WriteData(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -5974,79 +5963,44 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM( // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteJ", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_WriteJ__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_WriteJ__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::WriteJ(bool)\n" - " mfem::SparseMatrix::WriteJ()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - int *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadWriteData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)(arg1)->ReadWriteJ(arg2); + result = (double *)(arg1)->ReadWriteData(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6057,29 +6011,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_0(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int *result = 0 ; + PyObject *swig_obj[1] ; + double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int *)(arg1)->ReadWriteJ(); + result = (double *)((mfem::SparseMatrix const *)arg1)->HostReadData(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6090,73 +6046,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_1(PyObject *SWIGUNUSEDP // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteJ", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadWriteJ__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadWriteJ__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadWriteJ(bool)\n" - " mfem::SparseMatrix::ReadWriteJ()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int *result = 0 ; + double *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->HostReadJ(); + result = (double *)(arg1)->HostWriteData(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6167,31 +6081,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadJ(PyObject *SWIGUNUSEDPARM(self) // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int *result = 0 ; + double *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int *)(arg1)->HostWriteJ(); + result = (double *)(arg1)->HostReadWriteData(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6202,31 +6116,41 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteJ(PyObject *SWIGUNUSEDPARM(self // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_RowSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_RowSize" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (int *)(arg1)->HostReadWriteJ(); + result = (int)((mfem::SparseMatrix const *)arg1)->RowSize(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6237,29 +6161,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteJ(PyObject *SWIGUNUSEDPARM( // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_MaxRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< double > *result = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MaxRowSize" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::Memory< double > *) &(arg1)->GetMemoryData(); + result = (int)((mfem::SparseMatrix const *)arg1)->MaxRowSize(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6270,29 +6196,36 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_0(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Memory< double > *result = 0 ; + int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowColumns" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (mfem::Memory< double > *) &((mfem::SparseMatrix const *)arg1)->GetMemoryData(); + result = (int *)(arg1)->GetRowColumns(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6303,106 +6236,36 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData__SWIG_1(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetMemoryData", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_GetMemoryData__SWIG_0(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_GetMemoryData__SWIG_1(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetMemoryData'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::GetMemoryData()\n" - " mfem::SparseMatrix::GetMemoryData() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - double *result = 0 ; + int *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowColumns" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadData" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { - try { - result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(); + result = (int *)((mfem::SparseMatrix const *)arg1)->GetRowColumns(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6413,28 +6276,38 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_1(PyObject *SWIGUNUSEDPAR // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadData", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowColumns", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_ReadData__SWIG_1(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_GetRowColumns__SWIG_0(self, argc, argv); + } } } if (argc == 2) { @@ -6444,48 +6317,51 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_SparseMatrix_ReadData__SWIG_0(self, argc, argv); + return _wrap_SparseMatrix_GetRowColumns__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadData'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetRowColumns'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadData(bool) const\n" - " mfem::SparseMatrix::ReadData() const\n"); + " mfem::SparseMatrix::GetRowColumns(int const)\n" + " mfem::SparseMatrix::GetRowColumns(int const) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; double *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowEntries" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteData" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (double *)(arg1)->WriteData(arg2); + result = (double *)(arg1)->GetRowEntries(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6503,22 +6379,29 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowEntries" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - result = (double *)(arg1)->WriteData(); + result = (double *)((mfem::SparseMatrix const *)arg1)->GetRowEntries(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6536,21 +6419,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteData", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowEntries", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_WriteData__SWIG_1(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_GetRowEntries__SWIG_0(self, argc, argv); + } } } if (argc == 2) { @@ -6560,48 +6453,57 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_SparseMatrix_WriteData__SWIG_0(self, argc, argv); + return _wrap_SparseMatrix_GetRowEntries__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteData'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetRowEntries'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::WriteData(bool)\n" - " mfem::SparseMatrix::WriteData()\n"); + " mfem::SparseMatrix::GetRowEntries(int const)\n" + " mfem::SparseMatrix::GetRowEntries(int const) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + int arg2 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - double *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"width_", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_SetWidth", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetWidth" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteData" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } { try { - result = (double *)(arg1)->ReadWriteData(arg2); + (arg1)->SetWidth(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6612,29 +6514,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_0(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ActualWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ActualWidth" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (double *)(arg1)->ReadWriteData(); + result = (int)((mfem::SparseMatrix const *)arg1)->ActualWidth(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6645,73 +6549,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_1(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteData", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadWriteData__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadWriteData__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteData'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadWriteData(bool)\n" - " mfem::SparseMatrix::ReadWriteData()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SortColumnIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - double *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SortColumnIndices" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (double *)((mfem::SparseMatrix const *)arg1)->HostReadData(); + (arg1)->SortColumnIndices(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6722,31 +6583,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadData(PyObject *SWIGUNUSEDPARM(se // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_MoveDiagonalFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - double *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MoveDiagonalFirst" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (double *)(arg1)->HostWriteData(); + (arg1)->MoveDiagonalFirst(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6757,61 +6617,26 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostWriteData(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (double *)(arg1)->HostReadWriteData(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_RowSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_RowSize" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Elem" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -6821,43 +6646,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { - try { - result = (int)((mfem::SparseMatrix const *)arg1)->RowSize(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_MaxRowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MaxRowSize" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int)((mfem::SparseMatrix const *)arg1)->MaxRowSize(); + result = (double *) &(arg1)->Elem(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6868,25 +6664,26 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_MaxRowSize(PyObject *SWIGUNUSEDPARM(self // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int *result = 0 ; + double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowColumns" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Elem" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -6896,48 +6693,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns__SWIG_0(PyObject *SWIGUNUS arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { - try { - result = (int *)(arg1)->GetRowColumns(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowColumns" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->GetRowColumns(arg2); + result = (double *) &((mfem::SparseMatrix const *)arg1)->Elem(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -6948,22 +6711,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns__SWIG_1(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Elem(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowColumns", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Elem", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -6978,11 +6741,21 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns(PyObject *self, PyObject * } } if (_v) { - return _wrap_SparseMatrix_GetRowColumns__SWIG_0(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_Elem__SWIG_0(self, argc, argv); + } } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -6997,32 +6770,43 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowColumns(PyObject *self, PyObject * } } if (_v) { - return _wrap_SparseMatrix_GetRowColumns__SWIG_1(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_Elem__SWIG_1(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetRowColumns'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Elem'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::GetRowColumns(int const)\n" - " mfem::SparseMatrix::GetRowColumns(int const) const\n"); + " mfem::SparseMatrix::Elem(int,int)\n" + " mfem::SparseMatrix::Elem(int,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowEntries" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___call__" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -7031,9 +6815,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_0(PyObject *SWIGUNUS }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } { try { - result = (double *)(arg1)->GetRowEntries(arg2); + result = (double *) &(arg1)->operator ()(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7051,18 +6841,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowEntries" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___call__" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -7071,9 +6862,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_1(PyObject *SWIGUNUS }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } { try { - result = (double *)((mfem::SparseMatrix const *)arg1)->GetRowEntries(arg2); + result = (double *) &((mfem::SparseMatrix const *)arg1)->operator ()(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7084,22 +6881,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries__SWIG_1(PyObject *SWIGUNUS // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_From_double(static_cast< double >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix___call__(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[3] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowEntries", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix___call__", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -7114,11 +6911,21 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries(PyObject *self, PyObject * } } if (_v) { - return _wrap_SparseMatrix_GetRowEntries__SWIG_0(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix___call____SWIG_0(self, argc, argv); + } } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -7133,42 +6940,61 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries(PyObject *self, PyObject * } } if (_v) { - return _wrap_SparseMatrix_GetRowEntries__SWIG_1(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix___call____SWIG_1(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_GetRowEntries'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix___call__'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::GetRowEntries(int const)\n" - " mfem::SparseMatrix::GetRowEntries(int const) const\n"); + " mfem::SparseMatrix::operator ()(int,int)\n" + " mfem::SparseMatrix::operator ()(int,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetDiag", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetWidth" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetDiag" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetDiag" "', argument " "2"" of type '" "mfem::Vector &""'"); } - { - try { - (arg1)->SetWidth(arg2); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetDiag" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + { + try { + ((mfem::SparseMatrix const *)arg1)->GetDiag(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7186,21 +7012,65 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ToDenseMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::DenseMatrix *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetWidth" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::DenseMatrix *)((mfem::SparseMatrix const *)arg1)->ToDenseMatrix(); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_ToDenseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { try { - (arg1)->SetWidth(); + ((mfem::SparseMatrix const *)arg1)->ToDenseMatrix(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7218,13 +7088,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ToDenseMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SetWidth", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ToDenseMatrix", 0, 2, argv))) SWIG_fail; --argc; if (argc == 1) { int _v; @@ -7232,7 +7102,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_SetWidth__SWIG_1(self, argc, argv); + return _wrap_SparseMatrix_ToDenseMatrix__SWIG_0(self, argc, argv); } } if (argc == 2) { @@ -7241,47 +7111,42 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_SetWidth__SWIG_0(self, argc, argv); + return _wrap_SparseMatrix_ToDenseMatrix__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SetWidth'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ToDenseMatrix'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SetWidth(int)\n" - " mfem::SparseMatrix::SetWidth()\n"); + " mfem::SparseMatrix::ToDenseMatrix() const\n" + " mfem::SparseMatrix::ToDenseMatrix(mfem::DenseMatrix &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ActualWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int result; + mfem::MemoryClass result; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ActualWidth" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryClass" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (int)((mfem::SparseMatrix const *)arg1)->ActualWidth(); + result = (mfem::MemoryClass)((mfem::SparseMatrix const *)arg1)->GetMemoryClass(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7299,23 +7164,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ActualWidth(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SparseMatrix_SortColumnIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SortColumnIndices" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->SortColumnIndices(); + ((mfem::SparseMatrix const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7333,23 +7224,60 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SortColumnIndices(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_MoveDiagonalFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:SparseMatrix_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MoveDiagonalFirst" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { - (arg1)->MoveDiagonalFirst(); + ((mfem::SparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7367,36 +7295,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_MoveDiagonalFirst(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - int arg3 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Elem" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (double *) &(arg1)->Elem(arg2,arg3); + ((mfem::SparseMatrix const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7407,43 +7348,67 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(se // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - int arg3 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:SparseMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Elem" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } { try { - result = (double *) &((mfem::SparseMatrix const *)arg1)->Elem(arg2,arg3); + ((mfem::SparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -7454,1970 +7419,64 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(se // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(*result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_Elem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_SparseMatrix_BuildTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Elem", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_Elem__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_Elem__SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Elem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Elem(int,int)\n" - " mfem::SparseMatrix::Elem(int,int) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix___call____SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___call__" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (double *) &(arg1)->operator ()(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix___call____SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___call__" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (double *) &((mfem::SparseMatrix const *)arg1)->operator ()(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_double(static_cast< double >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix___call__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix___call__", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix___call____SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix___call____SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix___call__'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::operator ()(int,int)\n" - " mfem::SparseMatrix::operator ()(int,int) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetDiag", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetDiag" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetDiag" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetDiag" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - ((mfem::SparseMatrix const *)arg1)->GetDiag(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ToDenseMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DenseMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (mfem::DenseMatrix *)((mfem::SparseMatrix const *)arg1)->ToDenseMatrix(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ToDenseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_ToDenseMatrix" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - { - try { - ((mfem::SparseMatrix const *)arg1)->ToDenseMatrix(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ToDenseMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ToDenseMatrix", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ToDenseMatrix__SWIG_0(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ToDenseMatrix__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ToDenseMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ToDenseMatrix() const\n" - " mfem::SparseMatrix::ToDenseMatrix(mfem::DenseMatrix &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MemoryClass result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetMemoryClass" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (mfem::MemoryClass)((mfem::SparseMatrix const *)arg1)->GetMemoryClass(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::SparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::SparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::SparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::SparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_BuildTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BuildTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->BuildTranspose(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ResetTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ResetTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->ResetTranspose(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PartMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_PartMult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::SparseMatrix const *)arg1)->PartMult((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - double arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartAddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_PartAddMult" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - ((mfem::SparseMatrix const *)arg1)->PartAddMult((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartAddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::SparseMatrix const *)arg1)->PartAddMult((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_PartAddMult", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PartAddMult__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_PartAddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PartAddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::PartAddMult(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::SparseMatrix::PartAddMult(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_BooleanMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->BooleanMult((mfem::Array< int > const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_BooleanMultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->BooleanMultTranspose((mfem::Array< int > const &)*arg2,*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_InnerProduct", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_InnerProduct" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_InnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_InnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - result = (double)((mfem::SparseMatrix const *)arg1)->InnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowSums", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowSums" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetRowSums" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetRowSums" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - ((mfem::SparseMatrix const *)arg1)->GetRowSums(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowNorml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowNorml1", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowNorml1" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double)((mfem::SparseMatrix const *)arg1)->GetRowNorml1(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MatrixInverse *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Inverse" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (mfem::MatrixInverse *)((mfem::SparseMatrix const *)arg1)->Inverse(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - double arg3 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRow" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRow" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRow" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->EliminateRow(arg2,arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRow" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateRow(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->EliminateRow(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRow", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_EliminateRow__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRow__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateRow__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRow'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateRow(int,double const,mfem::Vector &)\n" - " mfem::SparseMatrix::EliminateRow(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRow(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateCol(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->EliminateCol(arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateCol", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_EliminateCol__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateCol__SWIG_0(self, argc, argv); - } - } + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BuildTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + ((mfem::SparseMatrix const *)arg1)->BuildTranspose(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateCol'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateCol(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateCol(int)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ResetTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - mfem::Vector *arg4 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ResetTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::Vector const *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateCols" "', argument " "4"" of type '" "mfem::Vector *""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,(mfem::Vector const *)arg3,arg4); + ((mfem::SparseMatrix const *)arg1)->ResetTranspose(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9435,40 +7494,61 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PartMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_PartMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,(mfem::Vector const *)arg3); + ((mfem::SparseMatrix const *)arg1)->PartMult((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9486,32 +7566,72 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + double arg5 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_PartAddMult", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartAddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_PartAddMult" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } { try { - (arg1)->EliminateCols((mfem::Array< int > const &)*arg2); + ((mfem::SparseMatrix const *)arg1)->PartAddMult((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9529,43 +7649,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_2(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::SparseMatrix *arg3 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_BooleanMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,*arg3); + ((mfem::SparseMatrix const *)arg1)->BooleanMult((mfem::Array< int > const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9583,147 +7709,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_3(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateCols", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateCols'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *,mfem::Vector *)\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *)\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &)\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::SparseMatrix &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - double arg3 ; - mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int val5 ; - int ecode5 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_BooleanMultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->EliminateRowCol(arg2,arg3,*arg4,arg5); + ((mfem::SparseMatrix const *)arg1)->BooleanMultTranspose((mfem::Array< int > const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9741,47 +7769,50 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - double arg3 ; - mfem::Vector *arg4 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; + double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_InnerProduct", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_InnerProduct" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_InnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_InnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->EliminateRowCol(arg2,arg3,*arg4); + result = (double)((mfem::SparseMatrix const *)arg1)->InnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9792,65 +7823,44 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUN // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int val5 ; - int ecode5 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetRowSums", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowSums" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetRowSums" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetRowSums" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->EliminateRowColMultipleRHS(arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + ((mfem::SparseMatrix const *)arg1)->GetRowSums(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9868,50 +7878,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowNorml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"irow", NULL + }; + double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetRowNorml1", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowNorml1" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->EliminateRowColMultipleRHS(arg2,(mfem::Vector const &)*arg3,*arg4); + result = (double)((mfem::SparseMatrix const *)arg1)->GetRowNorml1(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -9922,108 +7916,65 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_1(PyObj // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; +SWIGINTERN PyObject *_wrap_SparseMatrix_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MatrixInverse *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowColMultipleRHS", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_1(self, argc, argv); - } - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Inverse" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_0(self, argc, argv); - } - } - } - } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (mfem::MatrixInverse *)((mfem::SparseMatrix const *)arg1)->Inverse(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRowColMultipleRHS'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateRowColMultipleRHS(int,mfem::Vector const &,mfem::DenseMatrix &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowColMultipleRHS(int,mfem::Vector const &,mfem::DenseMatrix &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; double arg3 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowColDiag", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -10034,12 +7985,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColDiag(PyObject *SWIGUNUSED } ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "3"" of type '" "double""'"); + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRow" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRow" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRow" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateRowColDiag(arg2,arg3); + (arg1)->EliminateRow(arg2,arg3,*arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10057,20 +8016,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColDiag(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ZERO ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -10079,14 +8038,16 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUN }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRow" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); + } { try { - (arg1)->EliminateRowCol(arg2,arg3); + (arg1)->EliminateRow(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10104,28 +8065,120 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRow", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_EliminateRow__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_EliminateRow__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_EliminateRow__SWIG_0(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRow'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::EliminateRow(int,double const,mfem::Vector &)\n" + " mfem::SparseMatrix::EliminateRow(int,mfem::Matrix::DiagonalPolicy)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ZERO ; void *argp1 = 0 ; int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"col", (char *)"dpolicy", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:SparseMatrix_EliminateCol", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } { try { - (arg1)->EliminateRowCol(arg2); + (arg1)->EliminateCol(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10143,47 +8196,52 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_3(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - mfem::SparseMatrix *arg3 = 0 ; - mfem::Matrix::DiagonalPolicy arg4 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = (mfem::Vector *) NULL ; + mfem::Vector *arg4 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - int val4 ; - int ecode4 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::Vector const *""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + } + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateCols" "', argument " "4"" of type '" "mfem::Vector *""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg4 = static_cast< mfem::Matrix::DiagonalPolicy >(val4); { try { - (arg1)->EliminateRowCol(arg2,*arg3,arg4); + (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,(mfem::Vector const *)arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10201,39 +8259,43 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_4(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; + mfem::Array< int > *arg2 = 0 ; mfem::SparseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); } arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { - (arg1)->EliminateRowCol(arg2,*arg3); + (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10249,211 +8311,124 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_5(PyObject *SWIGUN fail: return NULL; } - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowCol", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 4) { + + +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateCols", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); + } void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_1(self, argc, argv); + return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); } } } } } - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_0(self, argc, argv); - } - } + return _wrap_SparseMatrix_EliminateCols__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRowCol'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateCols'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateRowCol(int,double const,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowCol(int,double const,mfem::Vector &)\n" - " mfem::SparseMatrix::EliminateRowCol(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowCol(int)\n" - " mfem::SparseMatrix::EliminateRowCol(int,mfem::SparseMatrix &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowCol(int,mfem::SparseMatrix &)\n"); + " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *,mfem::Vector *)\n" + " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::SparseMatrix &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetDiagIdentity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; + double arg3 ; + mfem::Vector *arg4 = 0 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + double val3 ; + int ecode3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetDiagIdentity" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { - (arg1)->SetDiagIdentity(); + (arg1)->EliminateRowCol(arg2,arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10471,29 +8446,68 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetDiagIdentity(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - double arg2 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rc", (char *)"sol", (char *)"rhs", (char *)"dpolicy", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_EliminateRowColMultipleRHS", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { - (arg1)->EliminateZeroRows(arg2); + (arg1)->EliminateRowColMultipleRHS(arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10511,21 +8525,42 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rc", (char *)"value", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_EliminateRowColDiag", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - (arg1)->EliminateZeroRows(); + (arg1)->EliminateRowColDiag(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10543,86 +8578,38 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateZeroRows", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateZeroRows__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateZeroRows__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateZeroRows'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateZeroRows(double const)\n" - " mfem::SparseMatrix::EliminateZeroRows()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_forw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int arg2 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Gauss_Seidel_forw", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_forw((mfem::Vector const &)*arg2,*arg3); + (arg1)->EliminateRowCol(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10640,44 +8627,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_forw(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int arg2 ; + mfem::SparseMatrix *arg3 = 0 ; + mfem::Matrix::DiagonalPolicy arg4 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + int val4 ; + int ecode4 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Gauss_Seidel_back", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg4 = static_cast< mfem::Matrix::DiagonalPolicy >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_back((mfem::Vector const &)*arg2,*arg3); + (arg1)->EliminateRowCol(arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10695,24 +8687,142 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_back(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetJacobiScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowCol", 0, 5, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_1(self, argc, argv); + } + } + } + } + if ((argc >= 3) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_2(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_2(self, argc, argv); + } + } + } + } + } + if ((argc >= 4) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_0(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRowCol'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::EliminateRowCol(int,double const,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::SparseMatrix::EliminateRowCol(int,mfem::Matrix::DiagonalPolicy)\n" + " mfem::SparseMatrix::EliminateRowCol(int,mfem::SparseMatrix &,mfem::Matrix::DiagonalPolicy)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_SetDiagIdentity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - double result; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetJacobiScaling" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetDiagIdentity" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (double)((mfem::SparseMatrix const *)arg1)->GetJacobiScaling(); + (arg1)->SetDiagIdentity(); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10723,70 +8833,43 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetJacobiScaling(PyObject *SWIGUNUSEDPAR // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - double arg5 ; + double arg2 = (double) (double)1e-12 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - PyObject *swig_obj[5] ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"threshold", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Jacobi", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_EliminateZeroRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); { try { - ((mfem::SparseMatrix const *)arg1)->Jacobi((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->EliminateZeroRows(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10804,51 +8887,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_forw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_Gauss_Seidel_forw", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_DiagScale" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_DiagScale" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - ((mfem::SparseMatrix const *)arg1)->DiagScale((mfem::Vector const &)*arg2,*arg3,arg4); + ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_forw((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10866,7 +8947,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10877,32 +8958,38 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale__SWIG_1(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_Gauss_Seidel_back", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_DiagScale" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::SparseMatrix const *)arg1)->DiagScale((mfem::Vector const &)*arg2,*arg3); + ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_back((mfem::Vector const &)*arg2,*arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -10920,67 +9007,42 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_DiagScale", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_DiagScale__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_DiagScale__SWIG_0(self, argc, argv); - } - } - } +SWIGINTERN PyObject *_wrap_SparseMatrix_GetJacobiScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetJacobiScaling" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + try { + result = (double)((mfem::SparseMatrix const *)arg1)->GetJacobiScaling(); } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_DiagScale'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::DiagScale(mfem::Vector const &,mfem::Vector &,double) const\n" - " mfem::SparseMatrix::DiagScale(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10997,45 +9059,53 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2__SWIG_0(PyObject *SWIGUNUSEDPARM int res4 = 0 ; double val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x0", (char *)"x1", (char *)"sc", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SparseMatrix_Jacobi", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi2" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_double(obj4, &val5); if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi2" "', argument " "5"" of type '" "double""'"); + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi" "', argument " "5"" of type '" "double""'"); } arg5 = static_cast< double >(val5); { try { - ((mfem::SparseMatrix const *)arg1)->Jacobi2((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + ((mfem::SparseMatrix const *)arg1)->Jacobi((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11053,54 +9123,60 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", (char *)"sc", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:SparseMatrix_DiagScale", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi2" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_DiagScale" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_DiagScale" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - ((mfem::SparseMatrix const *)arg1)->Jacobi2((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + ((mfem::SparseMatrix const *)arg1)->DiagScale((mfem::Vector const &)*arg2,*arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11118,81 +9194,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Jacobi2", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Jacobi2__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_Jacobi2__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Jacobi2'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Jacobi2(mfem::Vector const &,mfem::Vector const &,mfem::Vector &,double) const\n" - " mfem::SparseMatrix::Jacobi2(mfem::Vector const &,mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - double arg5 ; + double arg5 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -11203,45 +9211,55 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_0(PyObject *SWIGUNUSEDPARM int res4 = 0 ; double val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x0", (char *)"x1", (char *)"sc", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_Jacobi2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi3" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi2" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi3" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi2" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } { try { - ((mfem::SparseMatrix const *)arg1)->Jacobi3((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + ((mfem::SparseMatrix const *)arg1)->Jacobi2((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11259,12 +9277,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + double arg5 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -11273,14 +9292,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_1(PyObject *SWIGUNUSEDPARM int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x0", (char *)"x1", (char *)"sc", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_Jacobi3", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi3" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11288,7 +9317,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -11296,124 +9325,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::SparseMatrix const *)arg1)->Jacobi3((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Jacobi3", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Jacobi3__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_Jacobi3__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Jacobi3'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Jacobi3(mfem::Vector const &,mfem::Vector const &,mfem::Vector &,double) const\n" - " mfem::SparseMatrix::Jacobi3(mfem::Vector const &,mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalize" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi3" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } { try { - (arg1)->Finalize(arg2); + ((mfem::SparseMatrix const *)arg1)->Jacobi3((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11431,21 +9360,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalize" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } { try { - (arg1)->Finalize(); + (arg1)->Finalize(arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11463,7 +9401,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -11518,21 +9456,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Finalize", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Finalize__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_SparseMatrix_Finalize__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11566,7 +9498,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SparseMatrix_Finalize__SWIG_2(self, argc, argv); + return _wrap_SparseMatrix_Finalize__SWIG_1(self, argc, argv); } } } @@ -11576,7 +9508,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Finalize'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::Finalize(int)\n" - " mfem::SparseMatrix::Finalize()\n" " mfem::SparseMatrix::Finalize(int,bool)\n"); return 0; } @@ -11652,77 +9583,45 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ColumnsAreSorted(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; double arg2 ; - bool arg3 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", (char *)"fix_empty_rows", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:SparseMatrix_Threshold", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Threshold" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_Threshold" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_Threshold" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->Threshold(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Threshold" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_Threshold" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_Threshold" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); { try { - (arg1)->Threshold(arg2); + (arg1)->Threshold(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -11740,61 +9639,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Threshold", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_Threshold__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_Threshold__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Threshold'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Threshold(double,bool)\n" - " mfem::SparseMatrix::Threshold(double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; @@ -11802,15 +9647,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blocks", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetBlocks", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetBlocks", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetBlocks" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); } @@ -11838,7 +9687,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -11852,15 +9701,21 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetSubMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_GetSubMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -11868,7 +9723,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -11876,7 +9731,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11904,25 +9759,29 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetColPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetColPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetColPtr", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_SetColPtr", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetColPtr" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -12112,26 +9971,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix__Get_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Get_(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"col", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix__Get_", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix__Get_", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Get_" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -12159,128 +10022,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_1(PyObject *SWIGUNUSEDPA int arg2 ; int arg3 ; void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SearchRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (double *) &(arg1)->SearchRow(arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SearchRow", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SearchRow__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SearchRow__SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SearchRow'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SearchRow(int const)\n" - " mfem::SparseMatrix::SearchRow(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; + int res1 = 0 ; + double *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Add_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SearchRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -12295,14 +10043,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(s }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Add_" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - (arg1)->_Add_(arg2,arg3,arg4); + result = (double *) &(arg1)->SearchRow(arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12313,22 +10056,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(s // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix__Add_(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Add_", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SearchRow", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -12343,17 +10086,11 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Add_(PyObject *self, PyObject *args) { } } if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix__Add___SWIG_0(self, argc, argv); - } + return _wrap_SparseMatrix_SearchRow__SWIG_0(self, argc, argv); } } } - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -12377,28 +10114,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Add_(PyObject *self, PyObject *args) { } } if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix__Add___SWIG_1(self, argc, argv); - } + return _wrap_SparseMatrix_SearchRow__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Add_'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SearchRow'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::_Add_(int const,double const)\n" - " mfem::SparseMatrix::_Add_(int const,int const,double const)\n"); + " mfem::SparseMatrix::SearchRow(int const)\n" + " mfem::SparseMatrix::SearchRow(int const,int const)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -12412,7 +10143,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(s if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Set_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Add_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -12429,12 +10160,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(s } ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Set_" "', argument " "4"" of type '" "double""'"); + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Add_" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); { try { - (arg1)->_Set_(arg2,arg3,arg4); + (arg1)->_Add_(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12452,13 +10183,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix__Set_(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Add_(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Set_", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Add_", 0, 4, argv))) SWIG_fail; --argc; if (argc == 3) { int _v; @@ -12480,7 +10211,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set_(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SparseMatrix__Set___SWIG_0(self, argc, argv); + return _wrap_SparseMatrix__Add___SWIG_0(self, argc, argv); } } } @@ -12514,7 +10245,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set_(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SparseMatrix__Set___SWIG_1(self, argc, argv); + return _wrap_SparseMatrix__Add___SWIG_1(self, argc, argv); } } } @@ -12522,70 +10253,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set_(PyObject *self, PyObject *args) { } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Set_'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Add_'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::_Set_(int const,double const)\n" - " mfem::SparseMatrix::_Set_(int const,int const,double const)\n"); + " mfem::SparseMatrix::_Add_(int const,double const)\n" + " mfem::SparseMatrix::_Add_(int const,int const,double const)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Set", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Set" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Set" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - (arg1)->Set(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -12599,7 +10275,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(sel if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Add" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Set_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -12616,149 +10292,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Add" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - (arg1)->Add(arg2,arg3,arg4); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->SetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Set_" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); { try { - (arg1)->SetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4); + (arg1)->_Set_(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12776,61 +10315,69 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Set_(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[6] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SetSubMatrix", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Set_", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + { + int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_SetSubMatrix__SWIG_1(self, argc, argv); - } + } + if (_v) { + return _wrap_SparseMatrix__Set___SWIG_0(self, argc, argv); } } } } - if (argc == 5) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SetSubMatrix__SWIG_0(self, argc, argv); - } + return _wrap_SparseMatrix__Set___SWIG_1(self, argc, argv); } } } @@ -12838,69 +10385,112 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix(PyObject *self, PyObject *a } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SetSubMatrix'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Set_'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SetSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &,int)\n" - " mfem::SparseMatrix::SetSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &)\n"); + " mfem::SparseMatrix::_Set_(int const,double const)\n" + " mfem::SparseMatrix::_Set_(int const,int const,double const)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; + int arg2 ; + int arg3 ; + double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"a", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Set" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Set" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + (arg1)->Set(arg2,arg3,arg4); + } + catch (Swig::DirectorException &e) { + SWIG_fail; + } + //catch (...){ + // SWIG_fail; + //} + // catch (Swig::DirectorMethodException &e) { SWIG_fail; } + // catch (std::exception &e) { SWIG_fail; } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; + int arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Add" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Add" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); { try { - (arg1)->SetSubMatrixTranspose((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); + (arg1)->Add(arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12918,12 +10508,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -12932,40 +10523,56 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", (char *)"skip_zeros", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_SetSubMatrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } + } { try { - (arg1)->SetSubMatrixTranspose((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4); + (arg1)->SetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -12983,83 +10590,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SetSubMatrixTranspose", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SetSubMatrixTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SetSubMatrixTranspose(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &,int)\n" - " mfem::SparseMatrix::SetSubMatrixTranspose(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13068,46 +10605,56 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_0(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", (char *)"skip_zeros", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_SetSubMatrixTranspose", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } { try { - (arg1)->AddSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); + (arg1)->SetSubMatrixTranspose((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13125,12 +10672,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13139,14 +10687,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", (char *)"skip_zeros", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_AddSubMatrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13154,7 +10710,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -13162,7 +10718,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13170,9 +10726,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } + } { try { - (arg1)->AddSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4); + (arg1)->AddSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -13190,96 +10754,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_AddSubMatrix", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_AddSubMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_AddSubMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_AddSubMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::AddSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &,int)\n" - " mfem::SparseMatrix::AddSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_RowIsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_RowIsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_RowIsEmpty", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_RowIsEmpty", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_RowIsEmpty" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -13301,7 +10799,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_RowIsEmpty(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -13313,22 +10811,28 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_GetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRow" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -13336,7 +10840,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_GetRow" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -13364,7 +10868,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -13376,21 +10880,27 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_SetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -13398,7 +10908,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetRow" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -13426,7 +10936,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -13438,21 +10948,27 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_AddRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_AddRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -13460,7 +10976,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_AddRow" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -13488,7 +11004,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -13497,21 +11013,26 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"scale", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_ScaleRow", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_ScaleRow", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ScaleRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_ScaleRow" "', argument " "3"" of type '" "double""'"); } @@ -13536,7 +11057,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13544,15 +11065,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_ScaleRows", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_ScaleRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ScaleRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_ScaleRows" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13580,7 +11105,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13588,15 +11113,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_ScaleColumns", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_ScaleColumns", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ScaleColumns" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_ScaleColumns" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13624,7 +11153,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SparseMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -13632,16 +11161,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"B", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix___iadd__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix___iadd__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___iadd__" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix___iadd__" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -13792,7 +11325,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Add(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; double arg2 ; @@ -13800,16 +11333,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix___imul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix___imul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___imul__" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix___imul__" "', argument " "2"" of type '" "double""'"); } @@ -13827,205 +11364,58 @@ SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), // catch (Swig::DirectorMethodException &e) { SWIG_fail; } // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::SparseMatrix const *)arg1)->Print(*arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::SparseMatrix const *)arg1)->Print(*arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->Print(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } { try { - ((mfem::SparseMatrix const *)arg1)->PrintMatlab(*arg2); + ((mfem::SparseMatrix const *)arg1)->Print(*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14053,21 +11443,42 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - ((mfem::SparseMatrix const *)arg1)->PrintMatlab(); + ((mfem::SparseMatrix const *)arg1)->PrintMatlab(*arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -14079,8 +11490,18 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSED // catch (std::exception &e) { SWIG_fail; } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } @@ -14088,31 +11509,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSED SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -14145,38 +11569,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->PrintMM(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; @@ -14496,7 +11888,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_MaxNorm(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SparseMatrix_CountSmallElems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_CountSmallElems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; double arg2 ; @@ -14504,16 +11896,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_CountSmallElems(PyObject *SWIGUNUSEDPARM int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_CountSmallElems", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_CountSmallElems", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_CountSmallElems" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_CountSmallElems" "', argument " "2"" of type '" "double""'"); } @@ -14573,7 +11969,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_CheckFinite(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; bool arg2 ; @@ -14581,15 +11977,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ownij", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetGraphOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_SetGraphOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetGraphOwner" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_SetGraphOwner" "', argument " "2"" of type '" "bool""'"); } @@ -14614,7 +12014,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetDataOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetDataOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; bool arg2 ; @@ -14622,15 +12022,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetDataOwner(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"owna", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetDataOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_SetDataOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetDataOwner" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_SetDataOwner" "', argument " "2"" of type '" "bool""'"); } @@ -14759,7 +12163,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_LoseData(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SparseMatrix_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -14767,15 +12171,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Swap(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"other", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Swap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_Swap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Swap" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Swap" "', argument " "2"" of type '" "mfem::SparseMatrix &""'"); } @@ -14977,18 +12385,18 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -14999,58 +12407,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_Print__SWIG_3(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_SparseMatrix_Print__SWIG_3(arg1,(char const *)arg2); + mfem_SparseMatrix_Print__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15078,34 +12445,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -15116,19 +12464,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_SparseMatrix_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15138,27 +12476,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_SparseMatrix_Print__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15168,85 +12502,33 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); + return _wrap_SparseMatrix_Print__SWIG_1(self, argc, argv); } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Print'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Print(std::ostream &,int) const\n" - " mfem::SparseMatrix::Print(std::ostream &) const\n" - " mfem::SparseMatrix::Print() const\n" - " mfem::SparseMatrix::Print(char const *,int)\n" - " mfem::SparseMatrix::Print(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2,arg3); + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; + fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Print'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::Print(std::ostream &,int) const\n" + " mfem::SparseMatrix::Print(char const *,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -15257,9 +12539,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_3(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_SparseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2); + mfem_SparseMatrix_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15287,34 +12577,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMatlab__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMatlab__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_SparseMatrix_PrintMatlab__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -15329,7 +12600,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -15338,6 +12609,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_PrintMatlab__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15347,7 +12621,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar } } if (_v) { - return _wrap_SparseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_SparseMatrix_PrintMatlab__SWIG_1(self, argc, argv); } } } @@ -15357,25 +12631,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::SparseMatrix::PrintMatlab() const\n" - " mfem::SparseMatrix::PrintMatlab(char const *,int)\n" - " mfem::SparseMatrix::PrintMatlab(char const *)\n"); + " mfem::SparseMatrix::PrintMatlab(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -15386,58 +12658,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_2(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMM" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_PrintMM__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMM" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_SparseMatrix_PrintMM__SWIG_2(arg1,(char const *)arg2); + mfem_SparseMatrix_PrintMM__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15465,34 +12696,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_PrintMM", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMM__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMM__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_SparseMatrix_PrintMM__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -15507,7 +12719,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -15516,6 +12728,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_PrintMM__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -15525,7 +12740,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_SparseMatrix_PrintMM__SWIG_2(self, argc, argv); + return _wrap_SparseMatrix_PrintMM__SWIG_1(self, argc, argv); } } } @@ -15535,9 +12750,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintMM'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintMM(std::ostream &) const\n" - " mfem::SparseMatrix::PrintMM() const\n" - " mfem::SparseMatrix::PrintMM(char const *,int)\n" - " mfem::SparseMatrix::PrintMM(char const *)\n"); + " mfem::SparseMatrix::PrintMM(char const *,int)\n"); return 0; } @@ -15546,14 +12759,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_1(PyObject *SWIGUNUSEDPAR PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -15564,11 +12777,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -15593,49 +12808,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_1(PyObject *SWIGUNUSEDPAR SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_SparseMatrix_PrintCSR__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -15649,7 +12821,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_3(PyObject *SWIGUNUSEDPAR arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - mfem_SparseMatrix_PrintCSR__SWIG_3(arg1); + mfem_SparseMatrix_PrintCSR__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15681,10 +12853,10 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_PrintCSR__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -15693,7 +12865,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_SparseMatrix_PrintCSR__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_PrintCSR__SWIG_1(self, argc, argv); + } } } } @@ -15711,108 +12896,35 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR(PyObject *self, PyObject *args) } else { _v = 1; } - } - if (_v) { - return _wrap_SparseMatrix_PrintCSR__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_PrintCSR__SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintCSR'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::PrintCSR(std::ostream &) const\n" - " mfem::SparseMatrix::PrintCSR(char const *,int)\n" - " mfem::SparseMatrix::PrintCSR(char const *)\n" - " mfem::SparseMatrix::PrintCSR()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR2" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR2" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_PrintCSR2__SWIG_1(arg1,(char const *)arg2,arg3); + } + if (_v) { + return _wrap_SparseMatrix_PrintCSR__SWIG_0(self, argc, argv); + } } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; + fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintCSR'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::PrintCSR(std::ostream &) const\n" + " mfem::SparseMatrix::PrintCSR(char const *,int)\n" + " mfem::SparseMatrix::PrintCSR()\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR2" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -15823,9 +12935,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR2" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_SparseMatrix_PrintCSR2__SWIG_1(arg1,(char const *)arg2); + mfem_SparseMatrix_PrintCSR2__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15845,7 +12965,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -15859,7 +12979,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_3(PyObject *SWIGUNUSEDPA arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - mfem_SparseMatrix_PrintCSR2__SWIG_3(arg1); + mfem_SparseMatrix_PrintCSR2__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -15891,10 +13011,10 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR2__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_PrintCSR2__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -15903,7 +13023,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2(PyObject *self, PyObject *args int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR2__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_SparseMatrix_PrintCSR2__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_PrintCSR2__SWIG_1(self, argc, argv); + } } } } @@ -15927,36 +13060,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2(PyObject *self, PyObject *args } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_PrintCSR2__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintCSR2'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintCSR2(std::ostream &) const\n" " mfem::SparseMatrix::PrintCSR2(char const *,int)\n" - " mfem::SparseMatrix::PrintCSR2(char const *)\n" " mfem::SparseMatrix::PrintCSR2()\n"); return 0; } @@ -15966,14 +13075,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPA PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintInfo" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -15984,11 +13093,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -16013,49 +13124,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintInfo" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintInfo" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_SparseMatrix_PrintInfo__SWIG_1(arg1,(char const *)arg2); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -16069,7 +13137,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPA arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - mfem_SparseMatrix_PrintInfo__SWIG_3(arg1); + mfem_SparseMatrix_PrintInfo__SWIG_2(arg1); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16101,10 +13169,10 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintInfo__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_PrintInfo__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -16113,7 +13181,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo(PyObject *self, PyObject *args int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintInfo__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_SparseMatrix_PrintInfo__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_PrintInfo__SWIG_1(self, argc, argv); + } } } } @@ -16137,36 +13218,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo(PyObject *self, PyObject *args } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_PrintInfo__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintInfo'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintInfo(std::ostream &) const\n" " mfem::SparseMatrix::PrintInfo(char const *,int)\n" - " mfem::SparseMatrix::PrintInfo(char const *)\n" " mfem::SparseMatrix::PrintInfo()\n"); return 0; } @@ -16183,16 +13240,20 @@ SWIGINTERN PyObject *SparseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; double (*arg2)(double) = (double (*)(double)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"S", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrixFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrixFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixFunction" "', argument " "1"" of type '" "mfem::SparseMatrix &""'"); } @@ -16201,7 +13262,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_double__double); + int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double__double); if (!SWIG_IsOK(res)) { SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SparseMatrixFunction" "', argument " "2"" of type '" "double (*)(double)""'"); } @@ -16226,17 +13287,21 @@ SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"useActualWidth", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TransposeAbstractSparseMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeAbstractSparseMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeAbstractSparseMatrix" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const &""'"); } @@ -16245,10 +13310,10 @@ SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPAR } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16270,7 +13335,7 @@ SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -16278,11 +13343,15 @@ SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TransposeMult", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeMult", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeMult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -16290,7 +13359,7 @@ SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeMult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeMult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -16318,7 +13387,7 @@ SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = 0 ; mfem::AbstractSparseMatrix *arg2 = 0 ; @@ -16326,11 +13395,15 @@ SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MultAbstractSparseMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MultAbstractSparseMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultAbstractSparseMatrix" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const &""'"); } @@ -16338,7 +13411,7 @@ SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAbstractSparseMatrix" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultAbstractSparseMatrix" "', argument " "2"" of type '" "mfem::AbstractSparseMatrix const &""'"); } @@ -16366,21 +13439,27 @@ SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mult_AtDA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; - mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) 0 ; + mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"OAtDA", NULL + }; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mult_AtDA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -16388,7 +13467,7 @@ SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -16396,61 +13475,16 @@ SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult_AtDA" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); - } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); - { - try { - result = (mfem::SparseMatrix *)mfem::Mult_AtDA((mfem::SparseMatrix const &)*arg1,(mfem::Vector const &)*arg2,arg3); + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult_AtDA" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::SparseMatrix *)mfem::Mult_AtDA((mfem::SparseMatrix const &)*arg1,(mfem::Vector const &)*arg2); + result = (mfem::SparseMatrix *)mfem::Mult_AtDA((mfem::SparseMatrix const &)*arg1,(mfem::Vector const &)*arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -16468,53 +13502,6 @@ SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Mult_AtDA(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mult_AtDA", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mult_AtDA__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mult_AtDA__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mult_AtDA'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mult_AtDA(mfem::SparseMatrix const &,mfem::Vector const &,mfem::SparseMatrix *)\n" - " mfem::Mult_AtDA(mfem::SparseMatrix const &,mfem::Vector const &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OuterProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; @@ -16774,10 +13761,10 @@ SWIGINTERN PyObject *_wrap_OuterProduct(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, - { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, - { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, - { "OperatorHandle2SparseMatrix", _wrap_OperatorHandle2SparseMatrix, METH_O, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, + { "RAP_P", (PyCFunction)(void(*)(void))_wrap_RAP_P, METH_VARARGS|METH_KEYWORDS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, + { "RAP_R", (PyCFunction)(void(*)(void))_wrap_RAP_R, METH_VARARGS|METH_KEYWORDS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, + { "OperatorPtr2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorPtr2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, + { "OperatorHandle2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorHandle2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, { "RowNode_Value_set", _wrap_RowNode_Value_set, METH_VARARGS, "RowNode_Value_set(RowNode self, double Value)"}, { "RowNode_Value_get", _wrap_RowNode_Value_get, METH_O, "RowNode_Value_get(RowNode self) -> double"}, { "RowNode_Prev_set", _wrap_RowNode_Prev_set, METH_VARARGS, "RowNode_Prev_set(RowNode self, RowNode Prev)"}, @@ -16797,7 +13784,7 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix(SparseMatrix mat, bool copy_graph=True)\n" "new_SparseMatrix(Vector v) -> SparseMatrix\n" ""}, - { "SparseMatrix_MakeRef", _wrap_SparseMatrix_MakeRef, METH_VARARGS, "SparseMatrix_MakeRef(SparseMatrix self, SparseMatrix master)"}, + { "SparseMatrix_MakeRef", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MakeRef, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_MakeRef(SparseMatrix self, SparseMatrix master)"}, { "SparseMatrix_Size", _wrap_SparseMatrix_Size, METH_O, "SparseMatrix_Size(SparseMatrix self) -> int"}, { "SparseMatrix_Clear", _wrap_SparseMatrix_Clear, METH_O, "SparseMatrix_Clear(SparseMatrix self)"}, { "SparseMatrix_Empty", _wrap_SparseMatrix_Empty, METH_O, "SparseMatrix_Empty(SparseMatrix self) -> bool"}, @@ -16817,9 +13804,9 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "SparseMatrix_ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "SparseMatrix_WriteI(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "SparseMatrix_ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadI, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadI(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteI, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_WriteI(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteI, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadWriteI(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "SparseMatrix_HostReadI(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "SparseMatrix_HostWriteI(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "SparseMatrix_HostReadWriteI(SparseMatrix self) -> int *"}, @@ -16827,9 +13814,9 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "SparseMatrix_ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "SparseMatrix_WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "SparseMatrix_ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadJ, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadJ(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteJ, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_WriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteJ, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "SparseMatrix_HostReadJ(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "SparseMatrix_HostWriteJ(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "SparseMatrix_HostReadWriteJ(SparseMatrix self) -> int *"}, @@ -16837,13 +13824,13 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" ""}, - { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "SparseMatrix_ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, - { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "SparseMatrix_WriteData(SparseMatrix self, bool on_dev=True) -> double"}, - { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "SparseMatrix_ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadData, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadData(SparseMatrix self, bool on_dev=True) -> double const *"}, + { "SparseMatrix_WriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteData, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_WriteData(SparseMatrix self, bool on_dev=True) -> double *"}, + { "SparseMatrix_ReadWriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteData, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadWriteData(SparseMatrix self, bool on_dev=True) -> double *"}, { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "SparseMatrix_HostReadData(SparseMatrix self) -> double const *"}, { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "SparseMatrix_HostWriteData(SparseMatrix self) -> double *"}, { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "SparseMatrix_HostReadWriteData(SparseMatrix self) -> double *"}, - { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "SparseMatrix_RowSize(SparseMatrix self, int const i) -> int"}, + { "SparseMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_RowSize(SparseMatrix self, int const i) -> int"}, { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "SparseMatrix_MaxRowSize(SparseMatrix self) -> int"}, { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" "SparseMatrix_GetRowColumns(SparseMatrix self, int const row) -> int\n" @@ -16853,7 +13840,7 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetRowEntries(SparseMatrix self, int const row) -> double\n" "SparseMatrix_GetRowEntries(SparseMatrix self, int const row) -> double const *\n" ""}, - { "SparseMatrix_SetWidth", _wrap_SparseMatrix_SetWidth, METH_VARARGS, "SparseMatrix_SetWidth(SparseMatrix self, int width_=-1)"}, + { "SparseMatrix_SetWidth", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetWidth, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetWidth(SparseMatrix self, int width_=-1)"}, { "SparseMatrix_ActualWidth", _wrap_SparseMatrix_ActualWidth, METH_O, "SparseMatrix_ActualWidth(SparseMatrix self) -> int"}, { "SparseMatrix_SortColumnIndices", _wrap_SparseMatrix_SortColumnIndices, METH_O, "SparseMatrix_SortColumnIndices(SparseMatrix self)"}, { "SparseMatrix_MoveDiagonalFirst", _wrap_SparseMatrix_MoveDiagonalFirst, METH_O, "SparseMatrix_MoveDiagonalFirst(SparseMatrix self)"}, @@ -16865,63 +13852,63 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix___call__(SparseMatrix self, int i, int j) -> double\n" "SparseMatrix___call__(SparseMatrix self, int i, int j) -> double const &\n" ""}, - { "SparseMatrix_GetDiag", _wrap_SparseMatrix_GetDiag, METH_VARARGS, "SparseMatrix_GetDiag(SparseMatrix self, Vector d)"}, + { "SparseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetDiag(SparseMatrix self, Vector d)"}, { "SparseMatrix_ToDenseMatrix", _wrap_SparseMatrix_ToDenseMatrix, METH_VARARGS, "\n" "SparseMatrix_ToDenseMatrix(SparseMatrix self) -> DenseMatrix\n" "SparseMatrix_ToDenseMatrix(SparseMatrix self, DenseMatrix B)\n" ""}, { "SparseMatrix_GetMemoryClass", _wrap_SparseMatrix_GetMemoryClass, METH_O, "SparseMatrix_GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass"}, - { "SparseMatrix_Mult", _wrap_SparseMatrix_Mult, METH_VARARGS, "SparseMatrix_Mult(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMult", _wrap_SparseMatrix_AddMult, METH_VARARGS, "SparseMatrix_AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_MultTranspose", _wrap_SparseMatrix_MultTranspose, METH_VARARGS, "SparseMatrix_MultTranspose(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMultTranspose", _wrap_SparseMatrix_AddMultTranspose, METH_VARARGS, "SparseMatrix_AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Mult(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_MultTranspose(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, { "SparseMatrix_BuildTranspose", _wrap_SparseMatrix_BuildTranspose, METH_O, "SparseMatrix_BuildTranspose(SparseMatrix self)"}, { "SparseMatrix_ResetTranspose", _wrap_SparseMatrix_ResetTranspose, METH_O, "SparseMatrix_ResetTranspose(SparseMatrix self)"}, - { "SparseMatrix_PartMult", _wrap_SparseMatrix_PartMult, METH_VARARGS, "SparseMatrix_PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, - { "SparseMatrix_PartAddMult", _wrap_SparseMatrix_PartAddMult, METH_VARARGS, "SparseMatrix_PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_BooleanMult", _wrap_SparseMatrix_BooleanMult, METH_VARARGS, "SparseMatrix_BooleanMult(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_BooleanMultTranspose", _wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS, "SparseMatrix_BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_InnerProduct", _wrap_SparseMatrix_InnerProduct, METH_VARARGS, "SparseMatrix_InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, - { "SparseMatrix_GetRowSums", _wrap_SparseMatrix_GetRowSums, METH_VARARGS, "SparseMatrix_GetRowSums(SparseMatrix self, Vector x)"}, - { "SparseMatrix_GetRowNorml1", _wrap_SparseMatrix_GetRowNorml1, METH_VARARGS, "SparseMatrix_GetRowNorml1(SparseMatrix self, int irow) -> double"}, + { "SparseMatrix_PartMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, + { "SparseMatrix_PartAddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartAddMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BooleanMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_BooleanMult(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_BooleanMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_InnerProduct", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_InnerProduct, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, + { "SparseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetRowSums(SparseMatrix self, Vector x)"}, + { "SparseMatrix_GetRowNorml1", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowNorml1, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetRowNorml1(SparseMatrix self, int irow) -> double"}, { "SparseMatrix_Inverse", _wrap_SparseMatrix_Inverse, METH_O, "SparseMatrix_Inverse(SparseMatrix self) -> MatrixInverse"}, { "SparseMatrix_EliminateRow", _wrap_SparseMatrix_EliminateRow, METH_VARARGS, "\n" "SparseMatrix_EliminateRow(SparseMatrix self, int row, double const sol, Vector rhs)\n" "SparseMatrix_EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" ""}, - { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "SparseMatrix_EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, + { "SparseMatrix_EliminateCol", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateCol, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" "SparseMatrix_EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" "SparseMatrix_EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" ""}, - { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "SparseMatrix_EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, - { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "SparseMatrix_EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, + { "SparseMatrix_EliminateRowColMultipleRHS", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, + { "SparseMatrix_EliminateRowColDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" "SparseMatrix_EliminateRowCol(SparseMatrix self, int rc, double const sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "SparseMatrix_EliminateRowCol(SparseMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "SparseMatrix_EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, { "SparseMatrix_SetDiagIdentity", _wrap_SparseMatrix_SetDiagIdentity, METH_O, "SparseMatrix_SetDiagIdentity(SparseMatrix self)"}, - { "SparseMatrix_EliminateZeroRows", _wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS, "SparseMatrix_EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, - { "SparseMatrix_Gauss_Seidel_forw", _wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS, "SparseMatrix_Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_Gauss_Seidel_back", _wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS, "SparseMatrix_Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, + { "SparseMatrix_Gauss_Seidel_forw", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_Gauss_Seidel_back", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, { "SparseMatrix_GetJacobiScaling", _wrap_SparseMatrix_GetJacobiScaling, METH_O, "SparseMatrix_GetJacobiScaling(SparseMatrix self) -> double"}, - { "SparseMatrix_Jacobi", _wrap_SparseMatrix_Jacobi, METH_VARARGS, "SparseMatrix_Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, - { "SparseMatrix_DiagScale", _wrap_SparseMatrix_DiagScale, METH_VARARGS, "SparseMatrix_DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, - { "SparseMatrix_Jacobi2", _wrap_SparseMatrix_Jacobi2, METH_VARARGS, "SparseMatrix_Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, - { "SparseMatrix_Jacobi3", _wrap_SparseMatrix_Jacobi3, METH_VARARGS, "SparseMatrix_Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, + { "SparseMatrix_DiagScale", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_DiagScale, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, + { "SparseMatrix_Jacobi2", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi2, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi3", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi3, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, { "SparseMatrix_Finalize", _wrap_SparseMatrix_Finalize, METH_VARARGS, "\n" "SparseMatrix_Finalize(SparseMatrix self, int skip_zeros=1)\n" "SparseMatrix_Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" ""}, { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "SparseMatrix_Finalized(SparseMatrix self) -> bool"}, { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "SparseMatrix_ColumnsAreSorted(SparseMatrix self) -> bool"}, - { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "SparseMatrix_Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, - { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "SparseMatrix_GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, - { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "SparseMatrix_GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, - { "SparseMatrix_SetColPtr", _wrap_SparseMatrix_SetColPtr, METH_VARARGS, "SparseMatrix_SetColPtr(SparseMatrix self, int const row)"}, + { "SparseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, + { "SparseMatrix_GetBlocks", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetBlocks, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "SparseMatrix_GetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetSubMatrix, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, + { "SparseMatrix_SetColPtr", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetColPtr, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetColPtr(SparseMatrix self, int const row)"}, { "SparseMatrix_ClearColPtr", _wrap_SparseMatrix_ClearColPtr, METH_O, "SparseMatrix_ClearColPtr(SparseMatrix self)"}, - { "SparseMatrix__Get_", _wrap_SparseMatrix__Get_, METH_VARARGS, "SparseMatrix__Get_(SparseMatrix self, int const col) -> double"}, + { "SparseMatrix__Get_", (PyCFunction)(void(*)(void))_wrap_SparseMatrix__Get_, METH_VARARGS|METH_KEYWORDS, "SparseMatrix__Get_(SparseMatrix self, int const col) -> double"}, { "SparseMatrix_SearchRow", _wrap_SparseMatrix_SearchRow, METH_VARARGS, "\n" "SparseMatrix_SearchRow(SparseMatrix self, int const col) -> double\n" "SparseMatrix_SearchRow(SparseMatrix self, int const row, int const col) -> double &\n" @@ -16934,35 +13921,35 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix__Set_(SparseMatrix self, int const col, double const a)\n" "SparseMatrix__Set_(SparseMatrix self, int const row, int const col, double const a)\n" ""}, - { "SparseMatrix_Set", _wrap_SparseMatrix_Set, METH_VARARGS, "SparseMatrix_Set(SparseMatrix self, int const i, int const j, double const a)"}, - { "SparseMatrix_SetSubMatrix", _wrap_SparseMatrix_SetSubMatrix, METH_VARARGS, "SparseMatrix_SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_SetSubMatrixTranspose", _wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS, "SparseMatrix_SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_AddSubMatrix", _wrap_SparseMatrix_AddSubMatrix, METH_VARARGS, "SparseMatrix_AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_RowIsEmpty", _wrap_SparseMatrix_RowIsEmpty, METH_VARARGS, "SparseMatrix_RowIsEmpty(SparseMatrix self, int const row) -> bool"}, - { "SparseMatrix_GetRow", _wrap_SparseMatrix_GetRow, METH_VARARGS, "SparseMatrix_GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "SparseMatrix_SetRow", _wrap_SparseMatrix_SetRow, METH_VARARGS, "SparseMatrix_SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_AddRow", _wrap_SparseMatrix_AddRow, METH_VARARGS, "SparseMatrix_AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_ScaleRow", _wrap_SparseMatrix_ScaleRow, METH_VARARGS, "SparseMatrix_ScaleRow(SparseMatrix self, int const row, double const scale)"}, - { "SparseMatrix_ScaleRows", _wrap_SparseMatrix_ScaleRows, METH_VARARGS, "SparseMatrix_ScaleRows(SparseMatrix self, Vector sl)"}, - { "SparseMatrix_ScaleColumns", _wrap_SparseMatrix_ScaleColumns, METH_VARARGS, "SparseMatrix_ScaleColumns(SparseMatrix self, Vector sr)"}, - { "SparseMatrix___iadd__", _wrap_SparseMatrix___iadd__, METH_VARARGS, "SparseMatrix___iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, + { "SparseMatrix_Set", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Set, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Set(SparseMatrix self, int const i, int const j, double const a)"}, + { "SparseMatrix_SetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrix, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_SetSubMatrixTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_AddSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddSubMatrix, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_RowIsEmpty", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowIsEmpty, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_RowIsEmpty(SparseMatrix self, int const row) -> bool"}, + { "SparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "SparseMatrix_SetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_AddRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_ScaleRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ScaleRow(SparseMatrix self, int const row, double const scale)"}, + { "SparseMatrix_ScaleRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRows, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ScaleRows(SparseMatrix self, Vector sl)"}, + { "SparseMatrix_ScaleColumns", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleColumns, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ScaleColumns(SparseMatrix self, Vector sr)"}, + { "SparseMatrix___iadd__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___iadd__, METH_VARARGS|METH_KEYWORDS, "SparseMatrix___iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, { "SparseMatrix_Add", _wrap_SparseMatrix_Add, METH_VARARGS, "\n" "SparseMatrix_Add(SparseMatrix self, int const i, int const j, double const a)\n" "SparseMatrix_Add(SparseMatrix self, double const a, SparseMatrix B)\n" ""}, - { "SparseMatrix___imul__", _wrap_SparseMatrix___imul__, METH_VARARGS, "SparseMatrix___imul__(SparseMatrix self, double a) -> SparseMatrix"}, + { "SparseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "SparseMatrix___imul__(SparseMatrix self, double a) -> SparseMatrix"}, { "SparseMatrix_IsSymmetric", _wrap_SparseMatrix_IsSymmetric, METH_O, "SparseMatrix_IsSymmetric(SparseMatrix self) -> double"}, { "SparseMatrix_Symmetrize", _wrap_SparseMatrix_Symmetrize, METH_O, "SparseMatrix_Symmetrize(SparseMatrix self)"}, { "SparseMatrix_NumNonZeroElems", _wrap_SparseMatrix_NumNonZeroElems, METH_O, "SparseMatrix_NumNonZeroElems(SparseMatrix self) -> int"}, { "SparseMatrix_MaxNorm", _wrap_SparseMatrix_MaxNorm, METH_O, "SparseMatrix_MaxNorm(SparseMatrix self) -> double"}, - { "SparseMatrix_CountSmallElems", _wrap_SparseMatrix_CountSmallElems, METH_VARARGS, "SparseMatrix_CountSmallElems(SparseMatrix self, double tol) -> int"}, + { "SparseMatrix_CountSmallElems", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_CountSmallElems, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_CountSmallElems(SparseMatrix self, double tol) -> int"}, { "SparseMatrix_CheckFinite", _wrap_SparseMatrix_CheckFinite, METH_O, "SparseMatrix_CheckFinite(SparseMatrix self) -> int"}, - { "SparseMatrix_SetGraphOwner", _wrap_SparseMatrix_SetGraphOwner, METH_VARARGS, "SparseMatrix_SetGraphOwner(SparseMatrix self, bool ownij)"}, - { "SparseMatrix_SetDataOwner", _wrap_SparseMatrix_SetDataOwner, METH_VARARGS, "SparseMatrix_SetDataOwner(SparseMatrix self, bool owna)"}, + { "SparseMatrix_SetGraphOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetGraphOwner, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetGraphOwner(SparseMatrix self, bool ownij)"}, + { "SparseMatrix_SetDataOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetDataOwner, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetDataOwner(SparseMatrix self, bool owna)"}, { "SparseMatrix_OwnsGraph", _wrap_SparseMatrix_OwnsGraph, METH_O, "SparseMatrix_OwnsGraph(SparseMatrix self) -> bool"}, { "SparseMatrix_OwnsData", _wrap_SparseMatrix_OwnsData, METH_O, "SparseMatrix_OwnsData(SparseMatrix self) -> bool"}, { "SparseMatrix_LoseData", _wrap_SparseMatrix_LoseData, METH_O, "SparseMatrix_LoseData(SparseMatrix self)"}, - { "SparseMatrix_Swap", _wrap_SparseMatrix_Swap, METH_VARARGS, "SparseMatrix_Swap(SparseMatrix self, SparseMatrix other)"}, + { "SparseMatrix_Swap", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Swap, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Swap(SparseMatrix self, SparseMatrix other)"}, { "delete_SparseMatrix", _wrap_delete_SparseMatrix, METH_O, "delete_SparseMatrix(SparseMatrix self)"}, { "SparseMatrix_GetType", _wrap_SparseMatrix_GetType, METH_O, "SparseMatrix_GetType(SparseMatrix self) -> mfem::Operator::Type"}, { "SparseMatrix_GetIArray", _wrap_SparseMatrix_GetIArray, METH_O, "SparseMatrix_GetIArray(SparseMatrix self) -> PyObject *"}, @@ -16997,11 +13984,11 @@ static PyMethodDef SwigMethods[] = { ""}, { "SparseMatrix_swigregister", SparseMatrix_swigregister, METH_O, NULL}, { "SparseMatrix_swiginit", SparseMatrix_swiginit, METH_VARARGS, NULL}, - { "SparseMatrixFunction", _wrap_SparseMatrixFunction, METH_VARARGS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, - { "TransposeAbstractSparseMatrix", _wrap_TransposeAbstractSparseMatrix, METH_VARARGS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, - { "TransposeMult", _wrap_TransposeMult, METH_VARARGS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, - { "MultAbstractSparseMatrix", _wrap_MultAbstractSparseMatrix, METH_VARARGS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, - { "Mult_AtDA", _wrap_Mult_AtDA, METH_VARARGS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, + { "SparseMatrixFunction", (PyCFunction)(void(*)(void))_wrap_SparseMatrixFunction, METH_VARARGS|METH_KEYWORDS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, + { "TransposeAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, + { "TransposeMult", (PyCFunction)(void(*)(void))_wrap_TransposeMult, METH_VARARGS|METH_KEYWORDS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, + { "MultAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_MultAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, + { "Mult_AtDA", (PyCFunction)(void(*)(void))_wrap_Mult_AtDA, METH_VARARGS|METH_KEYWORDS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, { "OuterProduct", _wrap_OuterProduct, METH_VARARGS, "\n" "OuterProduct(DenseMatrix A, DenseMatrix B) -> DenseMatrix\n" "OuterProduct(DenseMatrix A, SparseMatrix B) -> SparseMatrix\n" @@ -17014,10 +14001,10 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, - { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, - { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, - { "OperatorHandle2SparseMatrix", _wrap_OperatorHandle2SparseMatrix, METH_O, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, + { "RAP_P", (PyCFunction)(void(*)(void))_wrap_RAP_P, METH_VARARGS|METH_KEYWORDS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, + { "RAP_R", (PyCFunction)(void(*)(void))_wrap_RAP_R, METH_VARARGS|METH_KEYWORDS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, + { "OperatorPtr2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorPtr2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, + { "OperatorHandle2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorHandle2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, { "RowNode_Value_set", _wrap_RowNode_Value_set, METH_VARARGS, "RowNode_Value_set(RowNode self, double Value)"}, { "RowNode_Value_get", _wrap_RowNode_Value_get, METH_O, "RowNode_Value_get(RowNode self) -> double"}, { "RowNode_Prev_set", _wrap_RowNode_Prev_set, METH_VARARGS, "RowNode_Prev_set(RowNode self, RowNode Prev)"}, @@ -17037,7 +14024,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SparseMatrix(SparseMatrix mat, bool copy_graph=True)\n" "new_SparseMatrix(Vector v) -> SparseMatrix\n" ""}, - { "SparseMatrix_MakeRef", _wrap_SparseMatrix_MakeRef, METH_VARARGS, "MakeRef(SparseMatrix self, SparseMatrix master)"}, + { "SparseMatrix_MakeRef", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MakeRef, METH_VARARGS|METH_KEYWORDS, "MakeRef(SparseMatrix self, SparseMatrix master)"}, { "SparseMatrix_Size", _wrap_SparseMatrix_Size, METH_O, "Size(SparseMatrix self) -> int"}, { "SparseMatrix_Clear", _wrap_SparseMatrix_Clear, METH_O, "Clear(SparseMatrix self)"}, { "SparseMatrix_Empty", _wrap_SparseMatrix_Empty, METH_O, "Empty(SparseMatrix self) -> bool"}, @@ -17057,9 +14044,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" "GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "WriteI(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadI, METH_VARARGS|METH_KEYWORDS, "ReadI(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteI, METH_VARARGS|METH_KEYWORDS, "WriteI(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteI, METH_VARARGS|METH_KEYWORDS, "ReadWriteI(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "HostReadI(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "HostWriteI(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "HostReadWriteI(SparseMatrix self) -> int *"}, @@ -17067,9 +14054,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadJ, METH_VARARGS|METH_KEYWORDS, "ReadJ(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteJ, METH_VARARGS|METH_KEYWORDS, "WriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteJ, METH_VARARGS|METH_KEYWORDS, "ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "HostReadJ(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "HostWriteJ(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "HostReadWriteJ(SparseMatrix self) -> int *"}, @@ -17077,13 +14064,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" "GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" ""}, - { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, - { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "WriteData(SparseMatrix self, bool on_dev=True) -> double"}, - { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadData, METH_VARARGS|METH_KEYWORDS, "ReadData(SparseMatrix self, bool on_dev=True) -> double const *"}, + { "SparseMatrix_WriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteData, METH_VARARGS|METH_KEYWORDS, "WriteData(SparseMatrix self, bool on_dev=True) -> double *"}, + { "SparseMatrix_ReadWriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteData, METH_VARARGS|METH_KEYWORDS, "ReadWriteData(SparseMatrix self, bool on_dev=True) -> double *"}, { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "HostReadData(SparseMatrix self) -> double const *"}, { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "HostWriteData(SparseMatrix self) -> double *"}, { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "HostReadWriteData(SparseMatrix self) -> double *"}, - { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "RowSize(SparseMatrix self, int const i) -> int"}, + { "SparseMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "RowSize(SparseMatrix self, int const i) -> int"}, { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "MaxRowSize(SparseMatrix self) -> int"}, { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" "GetRowColumns(SparseMatrix self, int const row) -> int\n" @@ -17093,7 +14080,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetRowEntries(SparseMatrix self, int const row) -> double\n" "GetRowEntries(SparseMatrix self, int const row) -> double const *\n" ""}, - { "SparseMatrix_SetWidth", _wrap_SparseMatrix_SetWidth, METH_VARARGS, "SetWidth(SparseMatrix self, int width_=-1)"}, + { "SparseMatrix_SetWidth", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetWidth, METH_VARARGS|METH_KEYWORDS, "SetWidth(SparseMatrix self, int width_=-1)"}, { "SparseMatrix_ActualWidth", _wrap_SparseMatrix_ActualWidth, METH_O, "ActualWidth(SparseMatrix self) -> int"}, { "SparseMatrix_SortColumnIndices", _wrap_SparseMatrix_SortColumnIndices, METH_O, "SortColumnIndices(SparseMatrix self)"}, { "SparseMatrix_MoveDiagonalFirst", _wrap_SparseMatrix_MoveDiagonalFirst, METH_O, "MoveDiagonalFirst(SparseMatrix self)"}, @@ -17105,63 +14092,63 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__call__(SparseMatrix self, int i, int j) -> double\n" "__call__(SparseMatrix self, int i, int j) -> double const &\n" ""}, - { "SparseMatrix_GetDiag", _wrap_SparseMatrix_GetDiag, METH_VARARGS, "GetDiag(SparseMatrix self, Vector d)"}, + { "SparseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "GetDiag(SparseMatrix self, Vector d)"}, { "SparseMatrix_ToDenseMatrix", _wrap_SparseMatrix_ToDenseMatrix, METH_VARARGS, "\n" "ToDenseMatrix(SparseMatrix self) -> DenseMatrix\n" "ToDenseMatrix(SparseMatrix self, DenseMatrix B)\n" ""}, { "SparseMatrix_GetMemoryClass", _wrap_SparseMatrix_GetMemoryClass, METH_O, "GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass"}, - { "SparseMatrix_Mult", _wrap_SparseMatrix_Mult, METH_VARARGS, "Mult(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMult", _wrap_SparseMatrix_AddMult, METH_VARARGS, "AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_MultTranspose", _wrap_SparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMultTranspose", _wrap_SparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, { "SparseMatrix_BuildTranspose", _wrap_SparseMatrix_BuildTranspose, METH_O, "BuildTranspose(SparseMatrix self)"}, { "SparseMatrix_ResetTranspose", _wrap_SparseMatrix_ResetTranspose, METH_O, "ResetTranspose(SparseMatrix self)"}, - { "SparseMatrix_PartMult", _wrap_SparseMatrix_PartMult, METH_VARARGS, "PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, - { "SparseMatrix_PartAddMult", _wrap_SparseMatrix_PartAddMult, METH_VARARGS, "PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_BooleanMult", _wrap_SparseMatrix_BooleanMult, METH_VARARGS, "BooleanMult(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_BooleanMultTranspose", _wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS, "BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_InnerProduct", _wrap_SparseMatrix_InnerProduct, METH_VARARGS, "InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, - { "SparseMatrix_GetRowSums", _wrap_SparseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(SparseMatrix self, Vector x)"}, - { "SparseMatrix_GetRowNorml1", _wrap_SparseMatrix_GetRowNorml1, METH_VARARGS, "GetRowNorml1(SparseMatrix self, int irow) -> double"}, + { "SparseMatrix_PartMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartMult, METH_VARARGS|METH_KEYWORDS, "PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, + { "SparseMatrix_PartAddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartAddMult, METH_VARARGS|METH_KEYWORDS, "PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BooleanMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMult, METH_VARARGS|METH_KEYWORDS, "BooleanMult(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_BooleanMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS|METH_KEYWORDS, "BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_InnerProduct", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_InnerProduct, METH_VARARGS|METH_KEYWORDS, "InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, + { "SparseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "GetRowSums(SparseMatrix self, Vector x)"}, + { "SparseMatrix_GetRowNorml1", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowNorml1, METH_VARARGS|METH_KEYWORDS, "GetRowNorml1(SparseMatrix self, int irow) -> double"}, { "SparseMatrix_Inverse", _wrap_SparseMatrix_Inverse, METH_O, "Inverse(SparseMatrix self) -> MatrixInverse"}, { "SparseMatrix_EliminateRow", _wrap_SparseMatrix_EliminateRow, METH_VARARGS, "\n" "EliminateRow(SparseMatrix self, int row, double const sol, Vector rhs)\n" "EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" ""}, - { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, + { "SparseMatrix_EliminateCol", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateCol, METH_VARARGS|METH_KEYWORDS, "EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" "EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" "EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" ""}, - { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, - { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, + { "SparseMatrix_EliminateRowColMultipleRHS", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS|METH_KEYWORDS, "EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, + { "SparseMatrix_EliminateRowColDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS|METH_KEYWORDS, "EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" "EliminateRowCol(SparseMatrix self, int rc, double const sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateRowCol(SparseMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, { "SparseMatrix_SetDiagIdentity", _wrap_SparseMatrix_SetDiagIdentity, METH_O, "SetDiagIdentity(SparseMatrix self)"}, - { "SparseMatrix_EliminateZeroRows", _wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, - { "SparseMatrix_Gauss_Seidel_forw", _wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS, "Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_Gauss_Seidel_back", _wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS, "Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, + { "SparseMatrix_Gauss_Seidel_forw", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS|METH_KEYWORDS, "Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_Gauss_Seidel_back", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS|METH_KEYWORDS, "Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, { "SparseMatrix_GetJacobiScaling", _wrap_SparseMatrix_GetJacobiScaling, METH_O, "GetJacobiScaling(SparseMatrix self) -> double"}, - { "SparseMatrix_Jacobi", _wrap_SparseMatrix_Jacobi, METH_VARARGS, "Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, - { "SparseMatrix_DiagScale", _wrap_SparseMatrix_DiagScale, METH_VARARGS, "DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, - { "SparseMatrix_Jacobi2", _wrap_SparseMatrix_Jacobi2, METH_VARARGS, "Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, - { "SparseMatrix_Jacobi3", _wrap_SparseMatrix_Jacobi3, METH_VARARGS, "Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi, METH_VARARGS|METH_KEYWORDS, "Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, + { "SparseMatrix_DiagScale", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_DiagScale, METH_VARARGS|METH_KEYWORDS, "DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, + { "SparseMatrix_Jacobi2", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi2, METH_VARARGS|METH_KEYWORDS, "Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi3", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi3, METH_VARARGS|METH_KEYWORDS, "Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, { "SparseMatrix_Finalize", _wrap_SparseMatrix_Finalize, METH_VARARGS, "\n" "Finalize(SparseMatrix self, int skip_zeros=1)\n" "Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" ""}, { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "Finalized(SparseMatrix self) -> bool"}, { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "ColumnsAreSorted(SparseMatrix self) -> bool"}, - { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, - { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, - { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, - { "SparseMatrix_SetColPtr", _wrap_SparseMatrix_SetColPtr, METH_VARARGS, "SetColPtr(SparseMatrix self, int const row)"}, + { "SparseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, + { "SparseMatrix_GetBlocks", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetBlocks, METH_VARARGS|METH_KEYWORDS, "GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "SparseMatrix_GetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetSubMatrix, METH_VARARGS|METH_KEYWORDS, "GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, + { "SparseMatrix_SetColPtr", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetColPtr, METH_VARARGS|METH_KEYWORDS, "SetColPtr(SparseMatrix self, int const row)"}, { "SparseMatrix_ClearColPtr", _wrap_SparseMatrix_ClearColPtr, METH_O, "ClearColPtr(SparseMatrix self)"}, - { "SparseMatrix__Get_", _wrap_SparseMatrix__Get_, METH_VARARGS, "_Get_(SparseMatrix self, int const col) -> double"}, + { "SparseMatrix__Get_", (PyCFunction)(void(*)(void))_wrap_SparseMatrix__Get_, METH_VARARGS|METH_KEYWORDS, "_Get_(SparseMatrix self, int const col) -> double"}, { "SparseMatrix_SearchRow", _wrap_SparseMatrix_SearchRow, METH_VARARGS, "\n" "SearchRow(SparseMatrix self, int const col) -> double\n" "SearchRow(SparseMatrix self, int const row, int const col) -> double &\n" @@ -17174,35 +14161,35 @@ static PyMethodDef SwigMethods_proxydocs[] = { "_Set_(SparseMatrix self, int const col, double const a)\n" "_Set_(SparseMatrix self, int const row, int const col, double const a)\n" ""}, - { "SparseMatrix_Set", _wrap_SparseMatrix_Set, METH_VARARGS, "Set(SparseMatrix self, int const i, int const j, double const a)"}, - { "SparseMatrix_SetSubMatrix", _wrap_SparseMatrix_SetSubMatrix, METH_VARARGS, "SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_SetSubMatrixTranspose", _wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS, "SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_AddSubMatrix", _wrap_SparseMatrix_AddSubMatrix, METH_VARARGS, "AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_RowIsEmpty", _wrap_SparseMatrix_RowIsEmpty, METH_VARARGS, "RowIsEmpty(SparseMatrix self, int const row) -> bool"}, - { "SparseMatrix_GetRow", _wrap_SparseMatrix_GetRow, METH_VARARGS, "GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "SparseMatrix_SetRow", _wrap_SparseMatrix_SetRow, METH_VARARGS, "SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_AddRow", _wrap_SparseMatrix_AddRow, METH_VARARGS, "AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_ScaleRow", _wrap_SparseMatrix_ScaleRow, METH_VARARGS, "ScaleRow(SparseMatrix self, int const row, double const scale)"}, - { "SparseMatrix_ScaleRows", _wrap_SparseMatrix_ScaleRows, METH_VARARGS, "ScaleRows(SparseMatrix self, Vector sl)"}, - { "SparseMatrix_ScaleColumns", _wrap_SparseMatrix_ScaleColumns, METH_VARARGS, "ScaleColumns(SparseMatrix self, Vector sr)"}, - { "SparseMatrix___iadd__", _wrap_SparseMatrix___iadd__, METH_VARARGS, "__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, + { "SparseMatrix_Set", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Set, METH_VARARGS|METH_KEYWORDS, "Set(SparseMatrix self, int const i, int const j, double const a)"}, + { "SparseMatrix_SetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrix, METH_VARARGS|METH_KEYWORDS, "SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_SetSubMatrixTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS|METH_KEYWORDS, "SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_AddSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddSubMatrix, METH_VARARGS|METH_KEYWORDS, "AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_RowIsEmpty", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowIsEmpty, METH_VARARGS|METH_KEYWORDS, "RowIsEmpty(SparseMatrix self, int const row) -> bool"}, + { "SparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "SparseMatrix_SetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetRow, METH_VARARGS|METH_KEYWORDS, "SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_AddRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddRow, METH_VARARGS|METH_KEYWORDS, "AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_ScaleRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRow, METH_VARARGS|METH_KEYWORDS, "ScaleRow(SparseMatrix self, int const row, double const scale)"}, + { "SparseMatrix_ScaleRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRows, METH_VARARGS|METH_KEYWORDS, "ScaleRows(SparseMatrix self, Vector sl)"}, + { "SparseMatrix_ScaleColumns", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleColumns, METH_VARARGS|METH_KEYWORDS, "ScaleColumns(SparseMatrix self, Vector sr)"}, + { "SparseMatrix___iadd__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___iadd__, METH_VARARGS|METH_KEYWORDS, "__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, { "SparseMatrix_Add", _wrap_SparseMatrix_Add, METH_VARARGS, "\n" "Add(SparseMatrix self, int const i, int const j, double const a)\n" "Add(SparseMatrix self, double const a, SparseMatrix B)\n" ""}, - { "SparseMatrix___imul__", _wrap_SparseMatrix___imul__, METH_VARARGS, "__imul__(SparseMatrix self, double a) -> SparseMatrix"}, + { "SparseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "__imul__(SparseMatrix self, double a) -> SparseMatrix"}, { "SparseMatrix_IsSymmetric", _wrap_SparseMatrix_IsSymmetric, METH_O, "IsSymmetric(SparseMatrix self) -> double"}, { "SparseMatrix_Symmetrize", _wrap_SparseMatrix_Symmetrize, METH_O, "Symmetrize(SparseMatrix self)"}, { "SparseMatrix_NumNonZeroElems", _wrap_SparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(SparseMatrix self) -> int"}, { "SparseMatrix_MaxNorm", _wrap_SparseMatrix_MaxNorm, METH_O, "MaxNorm(SparseMatrix self) -> double"}, - { "SparseMatrix_CountSmallElems", _wrap_SparseMatrix_CountSmallElems, METH_VARARGS, "CountSmallElems(SparseMatrix self, double tol) -> int"}, + { "SparseMatrix_CountSmallElems", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_CountSmallElems, METH_VARARGS|METH_KEYWORDS, "CountSmallElems(SparseMatrix self, double tol) -> int"}, { "SparseMatrix_CheckFinite", _wrap_SparseMatrix_CheckFinite, METH_O, "CheckFinite(SparseMatrix self) -> int"}, - { "SparseMatrix_SetGraphOwner", _wrap_SparseMatrix_SetGraphOwner, METH_VARARGS, "SetGraphOwner(SparseMatrix self, bool ownij)"}, - { "SparseMatrix_SetDataOwner", _wrap_SparseMatrix_SetDataOwner, METH_VARARGS, "SetDataOwner(SparseMatrix self, bool owna)"}, + { "SparseMatrix_SetGraphOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetGraphOwner, METH_VARARGS|METH_KEYWORDS, "SetGraphOwner(SparseMatrix self, bool ownij)"}, + { "SparseMatrix_SetDataOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetDataOwner, METH_VARARGS|METH_KEYWORDS, "SetDataOwner(SparseMatrix self, bool owna)"}, { "SparseMatrix_OwnsGraph", _wrap_SparseMatrix_OwnsGraph, METH_O, "OwnsGraph(SparseMatrix self) -> bool"}, { "SparseMatrix_OwnsData", _wrap_SparseMatrix_OwnsData, METH_O, "OwnsData(SparseMatrix self) -> bool"}, { "SparseMatrix_LoseData", _wrap_SparseMatrix_LoseData, METH_O, "LoseData(SparseMatrix self)"}, - { "SparseMatrix_Swap", _wrap_SparseMatrix_Swap, METH_VARARGS, "Swap(SparseMatrix self, SparseMatrix other)"}, + { "SparseMatrix_Swap", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Swap, METH_VARARGS|METH_KEYWORDS, "Swap(SparseMatrix self, SparseMatrix other)"}, { "delete_SparseMatrix", _wrap_delete_SparseMatrix, METH_O, "delete_SparseMatrix(SparseMatrix self)"}, { "SparseMatrix_GetType", _wrap_SparseMatrix_GetType, METH_O, "GetType(SparseMatrix self) -> mfem::Operator::Type"}, { "SparseMatrix_GetIArray", _wrap_SparseMatrix_GetIArray, METH_O, "GetIArray(SparseMatrix self) -> PyObject *"}, @@ -17237,11 +14224,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "SparseMatrix_swigregister", SparseMatrix_swigregister, METH_O, NULL}, { "SparseMatrix_swiginit", SparseMatrix_swiginit, METH_VARARGS, NULL}, - { "SparseMatrixFunction", _wrap_SparseMatrixFunction, METH_VARARGS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, - { "TransposeAbstractSparseMatrix", _wrap_TransposeAbstractSparseMatrix, METH_VARARGS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, - { "TransposeMult", _wrap_TransposeMult, METH_VARARGS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, - { "MultAbstractSparseMatrix", _wrap_MultAbstractSparseMatrix, METH_VARARGS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, - { "Mult_AtDA", _wrap_Mult_AtDA, METH_VARARGS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, + { "SparseMatrixFunction", (PyCFunction)(void(*)(void))_wrap_SparseMatrixFunction, METH_VARARGS|METH_KEYWORDS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, + { "TransposeAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, + { "TransposeMult", (PyCFunction)(void(*)(void))_wrap_TransposeMult, METH_VARARGS|METH_KEYWORDS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, + { "MultAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_MultAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, + { "Mult_AtDA", (PyCFunction)(void(*)(void))_wrap_Mult_AtDA, METH_VARARGS|METH_KEYWORDS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, { "OuterProduct", _wrap_OuterProduct, METH_VARARGS, "\n" "OuterProduct(DenseMatrix A, DenseMatrix B) -> DenseMatrix\n" "OuterProduct(DenseMatrix A, SparseMatrix B) -> SparseMatrix\n" diff --git a/mfem/_par/sparsesmoothers_wrap.cxx b/mfem/_par/sparsesmoothers_wrap.cxx index 7cd99343..1919f59b 100644 --- a/mfem/_par/sparsesmoothers_wrap.cxx +++ b/mfem/_par/sparsesmoothers_wrap.cxx @@ -3257,7 +3257,7 @@ SWIG_AsVal_double (PyObject *obj, double *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_SparseSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseSmoother *arg1 = (mfem::SparseSmoother *) 0 ; mfem::Operator *arg2 = 0 ; @@ -3265,15 +3265,19 @@ SWIGINTERN PyObject *_wrap_SparseSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseSmoother_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseSmoother_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseSmoother_SetOperator" "', argument " "1"" of type '" "mfem::SparseSmoother *""'"); } arg1 = reinterpret_cast< mfem::SparseSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -3344,83 +3348,30 @@ SWIGINTERN PyObject *SparseSmoother_swigregister(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + int arg1 = (int) 0 ; + int arg2 = (int) 1 ; mfem::GSSmoother *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother(arg1,arg2); + if ((nobjs < 0) || (nobjs > 2)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother(arg1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::GSSmoother *)new mfem::GSSmoother(); + result = (mfem::GSSmoother *)new mfem::GSSmoother(arg1,arg2); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3438,16 +3389,16 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; mfem::GSSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -3456,100 +3407,25 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1,arg2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1); + result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3575,19 +3451,11 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_GSSmoother", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_GSSmoother__SWIG_2(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 2)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GSSmoother__SWIG_5(self, argc, argv); + if (argc <= 0) { + return _wrap_new_GSSmoother__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3597,38 +3465,9 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_GSSmoother__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_GSSmoother__SWIG_0(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3642,11 +3481,14 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 1) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3656,6 +3498,9 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3665,7 +3510,7 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_GSSmoother__SWIG_3(self, argc, argv); + return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); } } } @@ -3675,16 +3520,12 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GSSmoother'.\n" " Possible C/C++ prototypes are:\n" " mfem::GSSmoother::GSSmoother(int,int)\n" - " mfem::GSSmoother::GSSmoother(int)\n" - " mfem::GSSmoother::GSSmoother()\n" - " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &,int,int)\n" - " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &,int)\n" - " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &)\n"); + " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GSSmoother *arg1 = (mfem::GSSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3695,15 +3536,20 @@ SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GSSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GSSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GSSmoother_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GSSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSSmoother_Mult" "', argument " "1"" of type '" "mfem::GSSmoother const *""'"); } arg1 = reinterpret_cast< mfem::GSSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GSSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3711,7 +3557,7 @@ SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GSSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GSSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3786,189 +3632,40 @@ SWIGINTERN PyObject *GSSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - int arg3 ; + int arg1 = (int) 0 ; + double arg2 = (double) 1. ; + int arg3 = (int) 1 ; double val2 ; int ecode2 = 0 ; mfem::DSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DSmoother" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(arg1,arg2,arg3); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - double val2 ; - int ecode2 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DSmoother" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(arg1,arg2); + if ((nobjs < 0) || (nobjs > 3)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(arg1); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DSmoother" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); } { try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3,arg4); + result = (mfem::DSmoother *)new mfem::DSmoother(arg1,arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -3986,18 +3683,19 @@ SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_4(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - double arg3 ; + int arg2 = (int) 0 ; + double arg3 = (double) 1. ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; int ecode3 = 0 ; mfem::DSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -4006,99 +3704,32 @@ SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_5(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1); + result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3,arg4); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4124,19 +3755,11 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_DSmoother", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_DSmoother__SWIG_3(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 3)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_DSmoother__SWIG_7(self, argc, argv); + if (argc <= 0) { + return _wrap_new_DSmoother__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4146,87 +3769,17 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_DSmoother__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_DSmoother__SWIG_6(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_DSmoother__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_DSmoother__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DSmoother__SWIG_5(self, argc, argv); + if (argc <= 2) { + return _wrap_new_DSmoother__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4241,11 +3794,14 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } } - if (argc == 4) { + if ((argc >= 1) && (argc <= 4)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4255,11 +3811,17 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 3) { + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4269,7 +3831,7 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_DSmoother__SWIG_4(self, argc, argv); + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); } } } @@ -4280,18 +3842,12 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DSmoother'.\n" " Possible C/C++ prototypes are:\n" " mfem::DSmoother::DSmoother(int,double,int)\n" - " mfem::DSmoother::DSmoother(int,double)\n" - " mfem::DSmoother::DSmoother(int)\n" - " mfem::DSmoother::DSmoother()\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int,double,int)\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int,double)\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int)\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &)\n"); + " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int,double,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DSmoother *arg1 = (mfem::DSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4302,15 +3858,20 @@ SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DSmoother_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DSmoother_Mult" "', argument " "1"" of type '" "mfem::DSmoother const *""'"); } arg1 = reinterpret_cast< mfem::DSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4318,7 +3879,7 @@ SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4394,22 +3955,22 @@ SWIGINTERN PyObject *DSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SparseSmoother_SetOperator(SparseSmoother self, Operator a)"}, + { "SparseSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_SparseSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "SparseSmoother_SetOperator(SparseSmoother self, Operator a)"}, { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, { "new_GSSmoother", _wrap_new_GSSmoother, METH_VARARGS, "\n" "GSSmoother(int t=0, int it=1)\n" - "GSSmoother(SparseMatrix a, int t=0, int it=1)\n" + "new_GSSmoother(SparseMatrix a, int t=0, int it=1) -> GSSmoother\n" ""}, - { "GSSmoother_Mult", _wrap_GSSmoother_Mult, METH_VARARGS, "GSSmoother_Mult(GSSmoother self, Vector x, Vector y)"}, + { "GSSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_GSSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "GSSmoother_Mult(GSSmoother self, Vector x, Vector y)"}, { "delete_GSSmoother", _wrap_delete_GSSmoother, METH_O, "delete_GSSmoother(GSSmoother self)"}, { "GSSmoother_swigregister", GSSmoother_swigregister, METH_O, NULL}, { "GSSmoother_swiginit", GSSmoother_swiginit, METH_VARARGS, NULL}, { "new_DSmoother", _wrap_new_DSmoother, METH_VARARGS, "\n" "DSmoother(int t=0, double s=1., int it=1)\n" - "DSmoother(SparseMatrix a, int t=0, double s=1., int it=1)\n" + "new_DSmoother(SparseMatrix a, int t=0, double s=1., int it=1) -> DSmoother\n" ""}, - { "DSmoother_Mult", _wrap_DSmoother_Mult, METH_VARARGS, "DSmoother_Mult(DSmoother self, Vector x, Vector y)"}, + { "DSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_DSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "DSmoother_Mult(DSmoother self, Vector x, Vector y)"}, { "delete_DSmoother", _wrap_delete_DSmoother, METH_O, "delete_DSmoother(DSmoother self)"}, { "DSmoother_swigregister", DSmoother_swigregister, METH_O, NULL}, { "DSmoother_swiginit", DSmoother_swiginit, METH_VARARGS, NULL}, @@ -4419,22 +3980,22 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SetOperator(SparseSmoother self, Operator a)"}, + { "SparseSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_SparseSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(SparseSmoother self, Operator a)"}, { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, { "new_GSSmoother", _wrap_new_GSSmoother, METH_VARARGS, "\n" "GSSmoother(int t=0, int it=1)\n" - "GSSmoother(SparseMatrix a, int t=0, int it=1)\n" + "new_GSSmoother(SparseMatrix a, int t=0, int it=1) -> GSSmoother\n" ""}, - { "GSSmoother_Mult", _wrap_GSSmoother_Mult, METH_VARARGS, "Mult(GSSmoother self, Vector x, Vector y)"}, + { "GSSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_GSSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(GSSmoother self, Vector x, Vector y)"}, { "delete_GSSmoother", _wrap_delete_GSSmoother, METH_O, "delete_GSSmoother(GSSmoother self)"}, { "GSSmoother_swigregister", GSSmoother_swigregister, METH_O, NULL}, { "GSSmoother_swiginit", GSSmoother_swiginit, METH_VARARGS, NULL}, { "new_DSmoother", _wrap_new_DSmoother, METH_VARARGS, "\n" "DSmoother(int t=0, double s=1., int it=1)\n" - "DSmoother(SparseMatrix a, int t=0, double s=1., int it=1)\n" + "new_DSmoother(SparseMatrix a, int t=0, double s=1., int it=1) -> DSmoother\n" ""}, - { "DSmoother_Mult", _wrap_DSmoother_Mult, METH_VARARGS, "Mult(DSmoother self, Vector x, Vector y)"}, + { "DSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_DSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(DSmoother self, Vector x, Vector y)"}, { "delete_DSmoother", _wrap_delete_DSmoother, METH_O, "delete_DSmoother(DSmoother self)"}, { "DSmoother_swigregister", DSmoother_swigregister, METH_O, NULL}, { "DSmoother_swiginit", DSmoother_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/stable3d_wrap.cxx b/mfem/_par/stable3d_wrap.cxx index 72c2ca0b..4bb40e5c 100644 --- a/mfem/_par/stable3d_wrap.cxx +++ b/mfem/_par/stable3d_wrap.cxx @@ -3310,7 +3310,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_STable3D_Print__SWIG_2(mfem::STable3D *self,char const *file,int precision=8){ +SWIGINTERN void mfem_STable3D_Print__SWIG_1(mfem::STable3D *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3607,19 +3607,21 @@ SWIGINTERN PyObject *STable3DNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"nr", NULL + }; mfem::STable3D *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_STable3D", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3641,7 +3643,7 @@ SWIGINTERN PyObject *_wrap_new_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_STable3D_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable3D_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; int arg2 ; @@ -3649,32 +3651,38 @@ SWIGINTERN PyObject *_wrap_STable3D_Push(PyObject *SWIGUNUSEDPARM(self), PyObjec int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"f", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable3D_Push", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:STable3D_Push", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Push" "', argument " "1"" of type '" "mfem::STable3D *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3750,7 +3758,7 @@ SWIGINTERN PyObject *_wrap_STable3D___call____SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; int arg2 ; @@ -3758,32 +3766,38 @@ SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObje int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"f", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable3D_Index", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:STable3D_Index", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Index" "', argument " "1"" of type '" "mfem::STable3D const *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3805,7 +3819,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_STable3D_Push4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable3D_Push4(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; int arg2 ; @@ -3814,38 +3828,45 @@ SWIGINTERN PyObject *_wrap_STable3D_Push4(PyObject *SWIGUNUSEDPARM(self), PyObje int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"f", (char *)"t", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable3D_Push4", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:STable3D_Push4", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Push4" "', argument " "1"" of type '" "mfem::STable3D *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { try { @@ -4072,31 +4093,34 @@ SWIGINTERN PyObject *_wrap_STable3D_NumberOfElements(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D const *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -4129,38 +4153,6 @@ SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D const *""'"); - } - arg1 = reinterpret_cast< mfem::STable3D * >(argp1); - { - try { - ((mfem::STable3D const *)arg1)->Print(); - } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_delete_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; @@ -4195,18 +4187,18 @@ SWIGINTERN PyObject *_wrap_delete_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D *""'"); @@ -4217,58 +4209,17 @@ SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STable3D_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_STable3D_Print__SWIG_2(arg1,(char const *)arg2,arg3); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - catch (Swig::DirectorException &e) { - SWIG_fail; - } - //catch (...){ - // SWIG_fail; - //} - // catch (Swig::DirectorMethodException &e) { SWIG_fail; } - // catch (std::exception &e) { SWIG_fail; } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D *""'"); - } - arg1 = reinterpret_cast< mfem::STable3D * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STable3D_Print" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_STable3D_Print__SWIG_2(arg1,(char const *)arg2); + mfem_STable3D_Print__SWIG_1(arg1,(char const *)arg2,arg3); } catch (Swig::DirectorException &e) { SWIG_fail; @@ -4296,34 +4247,15 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "STable3D_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_STable3D_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_STable3D_Print__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_STable3D_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -4338,7 +4270,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); @@ -4347,6 +4279,9 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_STable3D_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4356,7 +4291,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_STable3D_Print__SWIG_2(self, argc, argv); + return _wrap_STable3D_Print__SWIG_1(self, argc, argv); } } } @@ -4366,9 +4301,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'STable3D_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::STable3D::Print(std::ostream &) const\n" - " mfem::STable3D::Print() const\n" - " mfem::STable3D::Print(char const *,int)\n" - " mfem::STable3D::Print(char const *)\n"); + " mfem::STable3D::Print(char const *,int)\n"); return 0; } @@ -4399,10 +4332,10 @@ static PyMethodDef SwigMethods[] = { { "delete_STable3DNode", _wrap_delete_STable3DNode, METH_O, "delete_STable3DNode(STable3DNode self)"}, { "STable3DNode_swigregister", STable3DNode_swigregister, METH_O, NULL}, { "STable3DNode_swiginit", STable3DNode_swiginit, METH_VARARGS, NULL}, - { "new_STable3D", _wrap_new_STable3D, METH_O, "new_STable3D(int nr) -> STable3D"}, - { "STable3D_Push", _wrap_STable3D_Push, METH_VARARGS, "STable3D_Push(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Index", _wrap_STable3D_Index, METH_VARARGS, "STable3D_Index(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Push4", _wrap_STable3D_Push4, METH_VARARGS, "STable3D_Push4(STable3D self, int r, int c, int f, int t) -> int"}, + { "new_STable3D", (PyCFunction)(void(*)(void))_wrap_new_STable3D, METH_VARARGS|METH_KEYWORDS, "new_STable3D(int nr) -> STable3D"}, + { "STable3D_Push", (PyCFunction)(void(*)(void))_wrap_STable3D_Push, METH_VARARGS|METH_KEYWORDS, "STable3D_Push(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Index", (PyCFunction)(void(*)(void))_wrap_STable3D_Index, METH_VARARGS|METH_KEYWORDS, "STable3D_Index(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Push4", (PyCFunction)(void(*)(void))_wrap_STable3D_Push4, METH_VARARGS|METH_KEYWORDS, "STable3D_Push4(STable3D self, int r, int c, int f, int t) -> int"}, { "STable3D___call__", _wrap_STable3D___call__, METH_VARARGS, "\n" "STable3D___call__(STable3D self, int r, int c, int f) -> int\n" "STable3D___call__(STable3D self, int r, int c, int f, int t) -> int\n" @@ -4433,10 +4366,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_STable3DNode", _wrap_delete_STable3DNode, METH_O, "delete_STable3DNode(STable3DNode self)"}, { "STable3DNode_swigregister", STable3DNode_swigregister, METH_O, NULL}, { "STable3DNode_swiginit", STable3DNode_swiginit, METH_VARARGS, NULL}, - { "new_STable3D", _wrap_new_STable3D, METH_O, "new_STable3D(int nr) -> STable3D"}, - { "STable3D_Push", _wrap_STable3D_Push, METH_VARARGS, "Push(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Index", _wrap_STable3D_Index, METH_VARARGS, "Index(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Push4", _wrap_STable3D_Push4, METH_VARARGS, "Push4(STable3D self, int r, int c, int f, int t) -> int"}, + { "new_STable3D", (PyCFunction)(void(*)(void))_wrap_new_STable3D, METH_VARARGS|METH_KEYWORDS, "new_STable3D(int nr) -> STable3D"}, + { "STable3D_Push", (PyCFunction)(void(*)(void))_wrap_STable3D_Push, METH_VARARGS|METH_KEYWORDS, "Push(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Index", (PyCFunction)(void(*)(void))_wrap_STable3D_Index, METH_VARARGS|METH_KEYWORDS, "Index(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Push4", (PyCFunction)(void(*)(void))_wrap_STable3D_Push4, METH_VARARGS|METH_KEYWORDS, "Push4(STable3D self, int r, int c, int f, int t) -> int"}, { "STable3D___call__", _wrap_STable3D___call__, METH_VARARGS, "\n" "__call__(STable3D self, int r, int c, int f) -> int\n" "__call__(STable3D self, int r, int c, int f, int t) -> int\n" diff --git a/mfem/_par/table_wrap.cxx b/mfem/_par/table_wrap.cxx index f7eba450..0dfaf9fa 100644 --- a/mfem/_par/table_wrap.cxx +++ b/mfem/_par/table_wrap.cxx @@ -2934,7 +2934,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Table_Print__SWIG_3(mfem::Table *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Table_Print__SWIG_1(mfem::Table *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -2967,7 +2967,7 @@ SWIGINTERN void mfem_Table_Save__SWIG_1(mfem::Table *self,char const *file,int p self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_Table_Save__SWIG_3(mfem::Table *self){ +SWIGINTERN void mfem_Table_Save__SWIG_2(mfem::Table *self){ self -> Save(std::cout); } #ifdef __cplusplus @@ -3190,7 +3190,7 @@ SWIGINTERN PyObject *_wrap_new_Connection(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Connection *arg1 = (mfem::Connection *) 0 ; mfem::Connection *arg2 = 0 ; @@ -3198,16 +3198,20 @@ SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rhs", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "Connection___eq__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Connection___eq__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Connection___eq__" "', argument " "1"" of type '" "mfem::Connection const *""'"); } arg1 = reinterpret_cast< mfem::Connection * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Connection___eq__" "', argument " "2"" of type '" "mfem::Connection const &""'"); } @@ -3240,7 +3244,7 @@ SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Connection___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Connection___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Connection *arg1 = (mfem::Connection *) 0 ; mfem::Connection *arg2 = 0 ; @@ -3248,16 +3252,20 @@ SWIGINTERN PyObject *_wrap_Connection___lt__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rhs", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "Connection___lt__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Connection___lt__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Connection___lt__" "', argument " "1"" of type '" "mfem::Connection const *""'"); } arg1 = reinterpret_cast< mfem::Connection * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Connection___lt__" "', argument " "2"" of type '" "mfem::Connection const &""'"); } @@ -3408,21 +3416,23 @@ SWIGINTERN PyObject *_wrap_new_Table__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_Table__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 3 ; mfem::Table *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -3448,41 +3458,6 @@ SWIGINTERN PyObject *_wrap_new_Table__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_Table__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Table *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::Table *)new mfem::Table(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; mfem::Array< mfem::Connection > *arg2 = 0 ; @@ -3528,7 +3503,7 @@ SWIGINTERN PyObject *_wrap_new_Table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_new_Table__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int *arg2 = (int *) 0 ; @@ -3590,7 +3565,7 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { return _wrap_new_Table__SWIG_1(self, argc, argv); } } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -3601,7 +3576,20 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Table__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_new_Table__SWIG_2(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Table__SWIG_2(self, argc, argv); + } } } if (argc == 2) { @@ -3619,7 +3607,7 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Connection_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Table__SWIG_4(self, argc, argv); + return _wrap_new_Table__SWIG_3(self, argc, argv); } } } @@ -3638,31 +3626,7 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Table__SWIG_5(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Table__SWIG_2(self, argc, argv); + return _wrap_new_Table__SWIG_4(self, argc, argv); } } } @@ -3673,32 +3637,35 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { " mfem::Table::Table()\n" " mfem::Table::Table(mfem::Table const &)\n" " mfem::Table::Table(int,int)\n" - " mfem::Table::Table(int)\n" " mfem::Table::Table(int,mfem::Array< mfem::Connection > &)\n" " mfem::Table::Table(int,int *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Table_MakeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_MakeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nrows", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_MakeI", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_MakeI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_MakeI" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3723,25 +3690,29 @@ SWIGINTERN PyObject *_wrap_Table_MakeI(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Table_AddAColumnInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddAColumnInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddAColumnInRow", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_AddAColumnInRow", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddAColumnInRow" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3766,32 +3737,37 @@ SWIGINTERN PyObject *_wrap_Table_AddAColumnInRow(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Table_AddColumnsInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddColumnsInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"ncol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddColumnsInRow", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_AddColumnsInRow", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddColumnsInRow" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3853,32 +3829,37 @@ SWIGINTERN PyObject *_wrap_Table_MakeJ(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Table_AddConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddConnection", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_AddConnection", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddConnection" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3903,7 +3884,7 @@ SWIGINTERN PyObject *_wrap_Table_AddConnection(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Table_AddConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; @@ -3913,30 +3894,36 @@ SWIGINTERN PyObject *_wrap_Table_AddConnections(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"nc", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddConnections", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Table_AddConnections", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddConnections" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_AddConnections" "', argument " "3"" of type '" "int const *""'"); } arg3 = reinterpret_cast< int * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3998,32 +3985,37 @@ SWIGINTERN PyObject *_wrap_Table_ShiftUpI(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Table_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", (char *)"connections_per_row", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_SetSize", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_SetSize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetSize" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4048,32 +4040,37 @@ SWIGINTERN PyObject *_wrap_Table_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Table_SetDims(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_SetDims(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"nnz", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_SetDims", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_SetDims", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetDims" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4174,33 +4171,38 @@ SWIGINTERN PyObject *_wrap_Table_Size_of_connections(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Table___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Table___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table___call__" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4278,26 +4280,30 @@ SWIGINTERN PyObject *_wrap_Table_GetRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Table_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Table_RowSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_RowSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_RowSize" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4958,95 +4964,53 @@ SWIGINTERN PyObject *_wrap_Table_SortRows(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Table_SetIJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Table_SetIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int *arg2 = (int *) 0 ; int *arg3 = (int *) 0 ; - int arg4 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"newI", (char *)"newJ", (char *)"newsize", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Table_SetIJ", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetIJ" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_SetIJ" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_SetIJ" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->SetIJ(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_SetIJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - int *arg2 = (int *) 0 ; - int *arg3 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetIJ" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_SetIJ" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_SetIJ" "', argument " "3"" of type '" "int *""'"); } - arg3 = reinterpret_cast< int * >(argp3); { try { - (arg1)->SetIJ(arg2,arg3); + (arg1)->SetIJ(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5067,99 +5031,38 @@ SWIGINTERN PyObject *_wrap_Table_SetIJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Table_SetIJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Table_SetIJ", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Table_SetIJ__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Table_SetIJ__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_SetIJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Table::SetIJ(int *,int *,int)\n" - " mfem::Table::SetIJ(int *,int *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Table_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Table_Push", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_Push", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Push" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5221,7 +5124,7 @@ SWIGINTERN PyObject *_wrap_Table_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Table_MakeFromList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_MakeFromList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; @@ -5230,21 +5133,26 @@ SWIGINTERN PyObject *_wrap_Table_MakeFromList(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nrows", (char *)"list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_MakeFromList", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_MakeFromList", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_MakeFromList" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Connection_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Connection_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_MakeFromList" "', argument " "3"" of type '" "mfem::Array< mfem::Connection > const &""'"); } @@ -5353,40 +5261,45 @@ SWIGINTERN PyObject *_wrap_Table_LoseData(PyObject *SWIGUNUSEDPARM(self), PyObje SWIGINTERN PyObject *_wrap_Table_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { ((mfem::Table const *)arg1)->Print(*arg2,arg3); @@ -5420,104 +5333,6 @@ SWIGINTERN PyObject *_wrap_Table_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table const *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::Table const *)arg1)->Print(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table const *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - { - try { - ((mfem::Table const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; @@ -5644,7 +5459,7 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; std::istream *arg2 = 0 ; @@ -5652,15 +5467,19 @@ SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_in", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_Load", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_Load", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Load" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Load" "', argument " "2"" of type '" "std::istream &""'"); } @@ -5691,7 +5510,7 @@ SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; mfem::Table *arg2 = 0 ; @@ -5699,15 +5518,19 @@ SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Copy" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Copy" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -5738,7 +5561,7 @@ SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Table_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; mfem::Table *arg2 = 0 ; @@ -5746,15 +5569,19 @@ SWIGINTERN PyObject *_wrap_Table_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"other", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_Swap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_Swap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Swap" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Swap" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -5897,26 +5724,30 @@ SWIGINTERN PyObject *_wrap_delete_Table(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Table_GetRowList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_GetRowList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Table_GetRowList", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_GetRowList", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_GetRowList" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5941,18 +5772,18 @@ SWIGINTERN PyObject *_wrap_Table_GetRowList(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Table_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table *""'"); @@ -5963,61 +5794,17 @@ SWIGINTERN PyObject *_wrap_Table_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Table_Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Table_Print__SWIG_3(arg1,(char const *)arg2); + mfem_Table_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6048,34 +5835,15 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Table_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Table_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Table_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_Table_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -6086,19 +5854,9 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Table_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Table_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6108,27 +5866,23 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Table_Print__SWIG_3(self, argc, argv); + return _wrap_Table_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Table_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6138,7 +5892,7 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Table_Print__SWIG_0(self, argc, argv); + return _wrap_Table_Print__SWIG_1(self, argc, argv); } } } @@ -6148,10 +5902,7 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Table::Print(std::ostream &,int) const\n" - " mfem::Table::Print(std::ostream &) const\n" - " mfem::Table::Print() const\n" - " mfem::Table::Print(char const *,int)\n" - " mfem::Table::Print(char const *)\n"); + " mfem::Table::Print(char const *,int)\n"); return 0; } @@ -6160,14 +5911,14 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(se PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_PrintMatlab" "', argument " "1"" of type '" "mfem::Table *""'"); @@ -6178,11 +5929,13 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -6209,61 +5962,15 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_PrintMatlab" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Table_PrintMatlab__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; if (!(argc = SWIG_Python_UnpackTuple(args, "Table_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); @@ -6272,7 +5979,20 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Table_PrintMatlab__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_Table_PrintMatlab__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Table_PrintMatlab__SWIG_1(self, argc, argv); + } } } } @@ -6296,36 +6016,12 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Table_PrintMatlab__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::Table::PrintMatlab(std::ostream &) const\n" - " mfem::Table::PrintMatlab(char const *,int)\n" - " mfem::Table::PrintMatlab(char const *)\n"); + " mfem::Table::PrintMatlab(char const *,int)\n"); return 0; } @@ -6334,14 +6030,14 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Save" "', argument " "1"" of type '" "mfem::Table *""'"); @@ -6352,11 +6048,13 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -6384,52 +6082,6 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py SWIGINTERN PyObject *_wrap_Table_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Save" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Table_Save__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; void *argp1 = 0 ; @@ -6443,7 +6095,7 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py arg1 = reinterpret_cast< mfem::Table * >(argp1); { try { - mfem_Table_Save__SWIG_3(arg1); + mfem_Table_Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6478,10 +6130,10 @@ SWIGINTERN PyObject *_wrap_Table_Save(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Table_Save__SWIG_3(self, argc, argv); + return _wrap_Table_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); @@ -6490,7 +6142,20 @@ SWIGINTERN PyObject *_wrap_Table_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Table_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_Table_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Table_Save__SWIG_1(self, argc, argv); + } } } } @@ -6514,36 +6179,12 @@ SWIGINTERN PyObject *_wrap_Table_Save(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Table_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::Table::Save(std::ostream &) const\n" " mfem::Table::Save(char const *,int)\n" - " mfem::Table::Save(char const *)\n" " mfem::Table::Save()\n"); return 0; } @@ -6560,63 +6201,35 @@ SWIGINTERN PyObject *Table_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *ar return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_STable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_STable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"connections_per_row", NULL + }; mfem::STable *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_STable", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::STable *)new mfem::STable(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__STable, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_STable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::STable *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::STable *)new mfem::STable(arg1); + result = (mfem::STable *)new mfem::STable(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6637,89 +6250,38 @@ SWIGINTERN PyObject *_wrap_new_STable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_STable(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_STable", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_STable__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_STable__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_STable'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::STable::STable(int,int)\n" - " mfem::STable::STable(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_STable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable *arg1 = (mfem::STable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:STable___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable___call__" "', argument " "1"" of type '" "mfem::STable const *""'"); } arg1 = reinterpret_cast< mfem::STable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -6744,33 +6306,38 @@ SWIGINTERN PyObject *_wrap_STable___call__(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_STable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable *arg1 = (mfem::STable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable_Push", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:STable_Push", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable_Push" "', argument " "1"" of type '" "mfem::STable *""'"); } arg1 = reinterpret_cast< mfem::STable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -6843,19 +6410,21 @@ SWIGINTERN PyObject *STable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DSTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DSTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"nrows", NULL + }; mfem::DSTable *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_DSTable", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -6956,33 +6525,38 @@ SWIGINTERN PyObject *_wrap_DSTable_NumberOfEntries(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DSTable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DSTable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DSTable *arg1 = (mfem::DSTable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"b", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "DSTable_Push", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DSTable_Push", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DSTable_Push" "', argument " "1"" of type '" "mfem::DSTable *""'"); } arg1 = reinterpret_cast< mfem::DSTable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -7007,33 +6581,38 @@ SWIGINTERN PyObject *_wrap_DSTable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_DSTable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DSTable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DSTable *arg1 = (mfem::DSTable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"b", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "DSTable___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DSTable___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DSTable___call__" "', argument " "1"" of type '" "mfem::DSTable const *""'"); } arg1 = reinterpret_cast< mfem::DSTable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -7117,8 +6696,8 @@ static PyMethodDef SwigMethods[] = { "Connection()\n" "new_Connection(int _from, int to) -> Connection\n" ""}, - { "Connection___eq__", _wrap_Connection___eq__, METH_VARARGS, "Connection___eq__(Connection self, Connection rhs) -> bool"}, - { "Connection___lt__", _wrap_Connection___lt__, METH_VARARGS, "Connection___lt__(Connection self, Connection rhs) -> bool"}, + { "Connection___eq__", (PyCFunction)(void(*)(void))_wrap_Connection___eq__, METH_VARARGS|METH_KEYWORDS, "Connection___eq__(Connection self, Connection rhs) -> bool"}, + { "Connection___lt__", (PyCFunction)(void(*)(void))_wrap_Connection___lt__, METH_VARARGS|METH_KEYWORDS, "Connection___lt__(Connection self, Connection rhs) -> bool"}, { "delete_Connection", _wrap_delete_Connection, METH_O, "delete_Connection(Connection self)"}, { "Connection_swigregister", Connection_swigregister, METH_O, NULL}, { "Connection_swiginit", Connection_swiginit, METH_VARARGS, NULL}, @@ -7129,19 +6708,19 @@ static PyMethodDef SwigMethods[] = { "Table(int nrows, mfem::Array< mfem::Connection > & list)\n" "new_Table(int nrows, int * partitioning) -> Table\n" ""}, - { "Table_MakeI", _wrap_Table_MakeI, METH_VARARGS, "Table_MakeI(Table self, int nrows)"}, - { "Table_AddAColumnInRow", _wrap_Table_AddAColumnInRow, METH_VARARGS, "Table_AddAColumnInRow(Table self, int r)"}, - { "Table_AddColumnsInRow", _wrap_Table_AddColumnsInRow, METH_VARARGS, "Table_AddColumnsInRow(Table self, int r, int ncol)"}, + { "Table_MakeI", (PyCFunction)(void(*)(void))_wrap_Table_MakeI, METH_VARARGS|METH_KEYWORDS, "Table_MakeI(Table self, int nrows)"}, + { "Table_AddAColumnInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddAColumnInRow, METH_VARARGS|METH_KEYWORDS, "Table_AddAColumnInRow(Table self, int r)"}, + { "Table_AddColumnsInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddColumnsInRow, METH_VARARGS|METH_KEYWORDS, "Table_AddColumnsInRow(Table self, int r, int ncol)"}, { "Table_MakeJ", _wrap_Table_MakeJ, METH_O, "Table_MakeJ(Table self)"}, - { "Table_AddConnection", _wrap_Table_AddConnection, METH_VARARGS, "Table_AddConnection(Table self, int r, int c)"}, - { "Table_AddConnections", _wrap_Table_AddConnections, METH_VARARGS, "Table_AddConnections(Table self, int r, int const * c, int nc)"}, + { "Table_AddConnection", (PyCFunction)(void(*)(void))_wrap_Table_AddConnection, METH_VARARGS|METH_KEYWORDS, "Table_AddConnection(Table self, int r, int c)"}, + { "Table_AddConnections", (PyCFunction)(void(*)(void))_wrap_Table_AddConnections, METH_VARARGS|METH_KEYWORDS, "Table_AddConnections(Table self, int r, int const * c, int nc)"}, { "Table_ShiftUpI", _wrap_Table_ShiftUpI, METH_O, "Table_ShiftUpI(Table self)"}, - { "Table_SetSize", _wrap_Table_SetSize, METH_VARARGS, "Table_SetSize(Table self, int dim, int connections_per_row)"}, - { "Table_SetDims", _wrap_Table_SetDims, METH_VARARGS, "Table_SetDims(Table self, int rows, int nnz)"}, + { "Table_SetSize", (PyCFunction)(void(*)(void))_wrap_Table_SetSize, METH_VARARGS|METH_KEYWORDS, "Table_SetSize(Table self, int dim, int connections_per_row)"}, + { "Table_SetDims", (PyCFunction)(void(*)(void))_wrap_Table_SetDims, METH_VARARGS|METH_KEYWORDS, "Table_SetDims(Table self, int rows, int nnz)"}, { "Table_Size", _wrap_Table_Size, METH_O, "Table_Size(Table self) -> int"}, { "Table_Size_of_connections", _wrap_Table_Size_of_connections, METH_O, "Table_Size_of_connections(Table self) -> int"}, - { "Table___call__", _wrap_Table___call__, METH_VARARGS, "Table___call__(Table self, int i, int j) -> int"}, - { "Table_RowSize", _wrap_Table_RowSize, METH_VARARGS, "Table_RowSize(Table self, int i) -> int"}, + { "Table___call__", (PyCFunction)(void(*)(void))_wrap_Table___call__, METH_VARARGS|METH_KEYWORDS, "Table___call__(Table self, int i, int j) -> int"}, + { "Table_RowSize", (PyCFunction)(void(*)(void))_wrap_Table_RowSize, METH_VARARGS|METH_KEYWORDS, "Table_RowSize(Table self, int i) -> int"}, { "Table_GetRow", _wrap_Table_GetRow, METH_VARARGS, "\n" "Table_GetRow(Table self, int i, intArray row)\n" "Table_GetRow(Table self, int i) -> int const\n" @@ -7164,19 +6743,19 @@ static PyMethodDef SwigMethods[] = { "Table_GetJMemory(Table self) -> mfem::Memory< int > const &\n" ""}, { "Table_SortRows", _wrap_Table_SortRows, METH_O, "Table_SortRows(Table self)"}, - { "Table_SetIJ", _wrap_Table_SetIJ, METH_VARARGS, "Table_SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, - { "Table_Push", _wrap_Table_Push, METH_VARARGS, "Table_Push(Table self, int i, int j) -> int"}, + { "Table_SetIJ", (PyCFunction)(void(*)(void))_wrap_Table_SetIJ, METH_VARARGS|METH_KEYWORDS, "Table_SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, + { "Table_Push", (PyCFunction)(void(*)(void))_wrap_Table_Push, METH_VARARGS|METH_KEYWORDS, "Table_Push(Table self, int i, int j) -> int"}, { "Table_Finalize", _wrap_Table_Finalize, METH_O, "Table_Finalize(Table self)"}, - { "Table_MakeFromList", _wrap_Table_MakeFromList, METH_VARARGS, "Table_MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, + { "Table_MakeFromList", (PyCFunction)(void(*)(void))_wrap_Table_MakeFromList, METH_VARARGS|METH_KEYWORDS, "Table_MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, { "Table_Width", _wrap_Table_Width, METH_O, "Table_Width(Table self) -> int"}, { "Table_LoseData", _wrap_Table_LoseData, METH_O, "Table_LoseData(Table self)"}, - { "Table_Load", _wrap_Table_Load, METH_VARARGS, "Table_Load(Table self, std::istream & _in)"}, - { "Table_Copy", _wrap_Table_Copy, METH_VARARGS, "Table_Copy(Table self, Table copy)"}, - { "Table_Swap", _wrap_Table_Swap, METH_VARARGS, "Table_Swap(Table self, Table other)"}, + { "Table_Load", (PyCFunction)(void(*)(void))_wrap_Table_Load, METH_VARARGS|METH_KEYWORDS, "Table_Load(Table self, std::istream & _in)"}, + { "Table_Copy", (PyCFunction)(void(*)(void))_wrap_Table_Copy, METH_VARARGS|METH_KEYWORDS, "Table_Copy(Table self, Table copy)"}, + { "Table_Swap", (PyCFunction)(void(*)(void))_wrap_Table_Swap, METH_VARARGS|METH_KEYWORDS, "Table_Swap(Table self, Table other)"}, { "Table_Clear", _wrap_Table_Clear, METH_O, "Table_Clear(Table self)"}, { "Table_MemoryUsage", _wrap_Table_MemoryUsage, METH_O, "Table_MemoryUsage(Table self) -> long"}, { "delete_Table", _wrap_delete_Table, METH_O, "delete_Table(Table self)"}, - { "Table_GetRowList", _wrap_Table_GetRowList, METH_VARARGS, "Table_GetRowList(Table self, int i) -> PyObject *"}, + { "Table_GetRowList", (PyCFunction)(void(*)(void))_wrap_Table_GetRowList, METH_VARARGS|METH_KEYWORDS, "Table_GetRowList(Table self, int i) -> PyObject *"}, { "Table_Print", _wrap_Table_Print, METH_VARARGS, "\n" "Table_Print(Table self, std::ostream & out=mfem::out, int width=4)\n" "Table_Print(Table self, char const * file, int precision=8)\n" @@ -7192,17 +6771,17 @@ static PyMethodDef SwigMethods[] = { ""}, { "Table_swigregister", Table_swigregister, METH_O, NULL}, { "Table_swiginit", Table_swiginit, METH_VARARGS, NULL}, - { "new_STable", _wrap_new_STable, METH_VARARGS, "STable(int dim, int connections_per_row=3)"}, - { "STable___call__", _wrap_STable___call__, METH_VARARGS, "STable___call__(STable self, int i, int j) -> int"}, - { "STable_Push", _wrap_STable_Push, METH_VARARGS, "STable_Push(STable self, int i, int j) -> int"}, + { "new_STable", (PyCFunction)(void(*)(void))_wrap_new_STable, METH_VARARGS|METH_KEYWORDS, "new_STable(int dim, int connections_per_row=3) -> STable"}, + { "STable___call__", (PyCFunction)(void(*)(void))_wrap_STable___call__, METH_VARARGS|METH_KEYWORDS, "STable___call__(STable self, int i, int j) -> int"}, + { "STable_Push", (PyCFunction)(void(*)(void))_wrap_STable_Push, METH_VARARGS|METH_KEYWORDS, "STable_Push(STable self, int i, int j) -> int"}, { "delete_STable", _wrap_delete_STable, METH_O, "delete_STable(STable self)"}, { "STable_swigregister", STable_swigregister, METH_O, NULL}, { "STable_swiginit", STable_swiginit, METH_VARARGS, NULL}, - { "new_DSTable", _wrap_new_DSTable, METH_O, "new_DSTable(int nrows) -> DSTable"}, + { "new_DSTable", (PyCFunction)(void(*)(void))_wrap_new_DSTable, METH_VARARGS|METH_KEYWORDS, "new_DSTable(int nrows) -> DSTable"}, { "DSTable_NumberOfRows", _wrap_DSTable_NumberOfRows, METH_O, "DSTable_NumberOfRows(DSTable self) -> int"}, { "DSTable_NumberOfEntries", _wrap_DSTable_NumberOfEntries, METH_O, "DSTable_NumberOfEntries(DSTable self) -> int"}, - { "DSTable_Push", _wrap_DSTable_Push, METH_VARARGS, "DSTable_Push(DSTable self, int a, int b) -> int"}, - { "DSTable___call__", _wrap_DSTable___call__, METH_VARARGS, "DSTable___call__(DSTable self, int a, int b) -> int"}, + { "DSTable_Push", (PyCFunction)(void(*)(void))_wrap_DSTable_Push, METH_VARARGS|METH_KEYWORDS, "DSTable_Push(DSTable self, int a, int b) -> int"}, + { "DSTable___call__", (PyCFunction)(void(*)(void))_wrap_DSTable___call__, METH_VARARGS|METH_KEYWORDS, "DSTable___call__(DSTable self, int a, int b) -> int"}, { "delete_DSTable", _wrap_delete_DSTable, METH_O, "delete_DSTable(DSTable self)"}, { "DSTable_swigregister", DSTable_swigregister, METH_O, NULL}, { "DSTable_swiginit", DSTable_swiginit, METH_VARARGS, NULL}, @@ -7220,8 +6799,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Connection()\n" "new_Connection(int _from, int to) -> Connection\n" ""}, - { "Connection___eq__", _wrap_Connection___eq__, METH_VARARGS, "__eq__(Connection self, Connection rhs) -> bool"}, - { "Connection___lt__", _wrap_Connection___lt__, METH_VARARGS, "__lt__(Connection self, Connection rhs) -> bool"}, + { "Connection___eq__", (PyCFunction)(void(*)(void))_wrap_Connection___eq__, METH_VARARGS|METH_KEYWORDS, "__eq__(Connection self, Connection rhs) -> bool"}, + { "Connection___lt__", (PyCFunction)(void(*)(void))_wrap_Connection___lt__, METH_VARARGS|METH_KEYWORDS, "__lt__(Connection self, Connection rhs) -> bool"}, { "delete_Connection", _wrap_delete_Connection, METH_O, "delete_Connection(Connection self)"}, { "Connection_swigregister", Connection_swigregister, METH_O, NULL}, { "Connection_swiginit", Connection_swiginit, METH_VARARGS, NULL}, @@ -7232,19 +6811,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Table(int nrows, mfem::Array< mfem::Connection > & list)\n" "new_Table(int nrows, int * partitioning) -> Table\n" ""}, - { "Table_MakeI", _wrap_Table_MakeI, METH_VARARGS, "MakeI(Table self, int nrows)"}, - { "Table_AddAColumnInRow", _wrap_Table_AddAColumnInRow, METH_VARARGS, "AddAColumnInRow(Table self, int r)"}, - { "Table_AddColumnsInRow", _wrap_Table_AddColumnsInRow, METH_VARARGS, "AddColumnsInRow(Table self, int r, int ncol)"}, + { "Table_MakeI", (PyCFunction)(void(*)(void))_wrap_Table_MakeI, METH_VARARGS|METH_KEYWORDS, "MakeI(Table self, int nrows)"}, + { "Table_AddAColumnInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddAColumnInRow, METH_VARARGS|METH_KEYWORDS, "AddAColumnInRow(Table self, int r)"}, + { "Table_AddColumnsInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddColumnsInRow, METH_VARARGS|METH_KEYWORDS, "AddColumnsInRow(Table self, int r, int ncol)"}, { "Table_MakeJ", _wrap_Table_MakeJ, METH_O, "MakeJ(Table self)"}, - { "Table_AddConnection", _wrap_Table_AddConnection, METH_VARARGS, "AddConnection(Table self, int r, int c)"}, - { "Table_AddConnections", _wrap_Table_AddConnections, METH_VARARGS, "AddConnections(Table self, int r, int const * c, int nc)"}, + { "Table_AddConnection", (PyCFunction)(void(*)(void))_wrap_Table_AddConnection, METH_VARARGS|METH_KEYWORDS, "AddConnection(Table self, int r, int c)"}, + { "Table_AddConnections", (PyCFunction)(void(*)(void))_wrap_Table_AddConnections, METH_VARARGS|METH_KEYWORDS, "AddConnections(Table self, int r, int const * c, int nc)"}, { "Table_ShiftUpI", _wrap_Table_ShiftUpI, METH_O, "ShiftUpI(Table self)"}, - { "Table_SetSize", _wrap_Table_SetSize, METH_VARARGS, "SetSize(Table self, int dim, int connections_per_row)"}, - { "Table_SetDims", _wrap_Table_SetDims, METH_VARARGS, "SetDims(Table self, int rows, int nnz)"}, + { "Table_SetSize", (PyCFunction)(void(*)(void))_wrap_Table_SetSize, METH_VARARGS|METH_KEYWORDS, "SetSize(Table self, int dim, int connections_per_row)"}, + { "Table_SetDims", (PyCFunction)(void(*)(void))_wrap_Table_SetDims, METH_VARARGS|METH_KEYWORDS, "SetDims(Table self, int rows, int nnz)"}, { "Table_Size", _wrap_Table_Size, METH_O, "Size(Table self) -> int"}, { "Table_Size_of_connections", _wrap_Table_Size_of_connections, METH_O, "Size_of_connections(Table self) -> int"}, - { "Table___call__", _wrap_Table___call__, METH_VARARGS, "__call__(Table self, int i, int j) -> int"}, - { "Table_RowSize", _wrap_Table_RowSize, METH_VARARGS, "RowSize(Table self, int i) -> int"}, + { "Table___call__", (PyCFunction)(void(*)(void))_wrap_Table___call__, METH_VARARGS|METH_KEYWORDS, "__call__(Table self, int i, int j) -> int"}, + { "Table_RowSize", (PyCFunction)(void(*)(void))_wrap_Table_RowSize, METH_VARARGS|METH_KEYWORDS, "RowSize(Table self, int i) -> int"}, { "Table_GetRow", _wrap_Table_GetRow, METH_VARARGS, "\n" "GetRow(Table self, int i, intArray row)\n" "GetRow(Table self, int i) -> int const\n" @@ -7267,19 +6846,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetJMemory(Table self) -> mfem::Memory< int > const &\n" ""}, { "Table_SortRows", _wrap_Table_SortRows, METH_O, "SortRows(Table self)"}, - { "Table_SetIJ", _wrap_Table_SetIJ, METH_VARARGS, "SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, - { "Table_Push", _wrap_Table_Push, METH_VARARGS, "Push(Table self, int i, int j) -> int"}, + { "Table_SetIJ", (PyCFunction)(void(*)(void))_wrap_Table_SetIJ, METH_VARARGS|METH_KEYWORDS, "SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, + { "Table_Push", (PyCFunction)(void(*)(void))_wrap_Table_Push, METH_VARARGS|METH_KEYWORDS, "Push(Table self, int i, int j) -> int"}, { "Table_Finalize", _wrap_Table_Finalize, METH_O, "Finalize(Table self)"}, - { "Table_MakeFromList", _wrap_Table_MakeFromList, METH_VARARGS, "MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, + { "Table_MakeFromList", (PyCFunction)(void(*)(void))_wrap_Table_MakeFromList, METH_VARARGS|METH_KEYWORDS, "MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, { "Table_Width", _wrap_Table_Width, METH_O, "Width(Table self) -> int"}, { "Table_LoseData", _wrap_Table_LoseData, METH_O, "LoseData(Table self)"}, - { "Table_Load", _wrap_Table_Load, METH_VARARGS, "Load(Table self, std::istream & _in)"}, - { "Table_Copy", _wrap_Table_Copy, METH_VARARGS, "Copy(Table self, Table copy)"}, - { "Table_Swap", _wrap_Table_Swap, METH_VARARGS, "Swap(Table self, Table other)"}, + { "Table_Load", (PyCFunction)(void(*)(void))_wrap_Table_Load, METH_VARARGS|METH_KEYWORDS, "Load(Table self, std::istream & _in)"}, + { "Table_Copy", (PyCFunction)(void(*)(void))_wrap_Table_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(Table self, Table copy)"}, + { "Table_Swap", (PyCFunction)(void(*)(void))_wrap_Table_Swap, METH_VARARGS|METH_KEYWORDS, "Swap(Table self, Table other)"}, { "Table_Clear", _wrap_Table_Clear, METH_O, "Clear(Table self)"}, { "Table_MemoryUsage", _wrap_Table_MemoryUsage, METH_O, "MemoryUsage(Table self) -> long"}, { "delete_Table", _wrap_delete_Table, METH_O, "delete_Table(Table self)"}, - { "Table_GetRowList", _wrap_Table_GetRowList, METH_VARARGS, "GetRowList(Table self, int i) -> PyObject *"}, + { "Table_GetRowList", (PyCFunction)(void(*)(void))_wrap_Table_GetRowList, METH_VARARGS|METH_KEYWORDS, "GetRowList(Table self, int i) -> PyObject *"}, { "Table_Print", _wrap_Table_Print, METH_VARARGS, "\n" "Print(Table self, std::ostream & out=mfem::out, int width=4)\n" "Print(Table self, char const * file, int precision=8)\n" @@ -7295,17 +6874,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Table_swigregister", Table_swigregister, METH_O, NULL}, { "Table_swiginit", Table_swiginit, METH_VARARGS, NULL}, - { "new_STable", _wrap_new_STable, METH_VARARGS, "STable(int dim, int connections_per_row=3)"}, - { "STable___call__", _wrap_STable___call__, METH_VARARGS, "__call__(STable self, int i, int j) -> int"}, - { "STable_Push", _wrap_STable_Push, METH_VARARGS, "Push(STable self, int i, int j) -> int"}, + { "new_STable", (PyCFunction)(void(*)(void))_wrap_new_STable, METH_VARARGS|METH_KEYWORDS, "new_STable(int dim, int connections_per_row=3) -> STable"}, + { "STable___call__", (PyCFunction)(void(*)(void))_wrap_STable___call__, METH_VARARGS|METH_KEYWORDS, "__call__(STable self, int i, int j) -> int"}, + { "STable_Push", (PyCFunction)(void(*)(void))_wrap_STable_Push, METH_VARARGS|METH_KEYWORDS, "Push(STable self, int i, int j) -> int"}, { "delete_STable", _wrap_delete_STable, METH_O, "delete_STable(STable self)"}, { "STable_swigregister", STable_swigregister, METH_O, NULL}, { "STable_swiginit", STable_swiginit, METH_VARARGS, NULL}, - { "new_DSTable", _wrap_new_DSTable, METH_O, "new_DSTable(int nrows) -> DSTable"}, + { "new_DSTable", (PyCFunction)(void(*)(void))_wrap_new_DSTable, METH_VARARGS|METH_KEYWORDS, "new_DSTable(int nrows) -> DSTable"}, { "DSTable_NumberOfRows", _wrap_DSTable_NumberOfRows, METH_O, "NumberOfRows(DSTable self) -> int"}, { "DSTable_NumberOfEntries", _wrap_DSTable_NumberOfEntries, METH_O, "NumberOfEntries(DSTable self) -> int"}, - { "DSTable_Push", _wrap_DSTable_Push, METH_VARARGS, "Push(DSTable self, int a, int b) -> int"}, - { "DSTable___call__", _wrap_DSTable___call__, METH_VARARGS, "__call__(DSTable self, int a, int b) -> int"}, + { "DSTable_Push", (PyCFunction)(void(*)(void))_wrap_DSTable_Push, METH_VARARGS|METH_KEYWORDS, "Push(DSTable self, int a, int b) -> int"}, + { "DSTable___call__", (PyCFunction)(void(*)(void))_wrap_DSTable___call__, METH_VARARGS|METH_KEYWORDS, "__call__(DSTable self, int a, int b) -> int"}, { "delete_DSTable", _wrap_delete_DSTable, METH_O, "delete_DSTable(DSTable self)"}, { "DSTable_swigregister", DSTable_swigregister, METH_O, NULL}, { "DSTable_swiginit", DSTable_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_par/vector.py b/mfem/_par/vector.py index 14057254..9f4bb6cb 100644 --- a/mfem/_par/vector.py +++ b/mfem/_par/vector.py @@ -384,7 +384,7 @@ def CheckFinite(self): __swig_destroy__ = _vector.delete_Vector def Read(self, on_dev=True): - r"""Read(Vector self, bool on_dev=True) -> double const""" + r"""Read(Vector self, bool on_dev=True) -> double const *""" return _vector.Vector_Read(self, on_dev) Read = _swig_new_instance_method(_vector.Vector_Read) @@ -394,7 +394,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_vector.Vector_HostRead) def Write(self, on_dev=True): - r"""Write(Vector self, bool on_dev=True) -> double""" + r"""Write(Vector self, bool on_dev=True) -> double *""" return _vector.Vector_Write(self, on_dev) Write = _swig_new_instance_method(_vector.Vector_Write) @@ -404,7 +404,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_vector.Vector_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(Vector self, bool on_dev=True) -> double""" + r"""ReadWrite(Vector self, bool on_dev=True) -> double *""" return _vector.Vector_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_vector.Vector_ReadWrite) diff --git a/mfem/_par/vector_wrap.cxx b/mfem/_par/vector_wrap.cxx index 20de6ecc..863286fe 100644 --- a/mfem/_par/vector_wrap.cxx +++ b/mfem/_par/vector_wrap.cxx @@ -3213,7 +3213,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Vector_Print__SWIG_3(mfem::Vector *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Vector_Print__SWIG_1(mfem::Vector *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3235,7 +3235,7 @@ SWIGINTERN void mfem_Vector_Print_HYPRE__SWIG_1(mfem::Vector *self,char const *f self -> Print_HYPRE(ofile); ofile.close(); } -SWIGINTERN void mfem_Vector_Print_HYPRE__SWIG_3(mfem::Vector *self){ +SWIGINTERN void mfem_Vector_Print_HYPRE__SWIG_2(mfem::Vector *self){ self -> Print_HYPRE(std::cout); } #ifdef __cplusplus @@ -3811,26 +3811,30 @@ SWIGINTERN PyObject *_wrap_subtract_vector(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_CheckFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CheckFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"n", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CheckFinite", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CheckFinite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckFinite" "', argument " "1"" of type '" "double const *""'"); } arg1 = reinterpret_cast< double * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4690,7 +4694,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetSize(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -4698,15 +4702,19 @@ SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_SetData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetData" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetData" "', argument " "2"" of type '" "double *""'"); } @@ -4734,7 +4742,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -4743,24 +4751,29 @@ SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetDataAndSize", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_SetDataAndSize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetDataAndSize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetDataAndSize" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4785,7 +4798,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -4794,24 +4807,29 @@ SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_NewDataAndSize", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_NewDataAndSize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_NewDataAndSize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_NewDataAndSize" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4836,7 +4854,7 @@ SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Memory< double > *arg2 = 0 ; @@ -4848,15 +4866,21 @@ SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; bool val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mem", (char *)"s", (char *)"own_mem", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_NewMemoryAndSize", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Vector_NewMemoryAndSize", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_NewMemoryAndSize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_NewMemoryAndSize" "', argument " "2"" of type '" "mfem::Memory< double > const &""'"); } @@ -4865,12 +4889,12 @@ SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self } arg2 = reinterpret_cast< mfem::Memory< double > * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vector_NewMemoryAndSize" "', argument " "4"" of type '" "bool""'"); } @@ -5383,7 +5407,7 @@ SWIGINTERN PyObject *_wrap_Vector_GetMemory(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5391,15 +5415,19 @@ SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SyncMemory", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_SyncMemory", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SyncMemory" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SyncMemory" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5430,7 +5458,7 @@ SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Vector_SyncAliasMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SyncAliasMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5438,15 +5466,19 @@ SWIGINTERN PyObject *_wrap_Vector_SyncAliasMemory(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SyncAliasMemory", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_SyncAliasMemory", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SyncAliasMemory" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SyncAliasMemory" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6056,7 +6088,7 @@ SWIGINTERN PyObject *_wrap_Vector___mul__(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6064,16 +6096,20 @@ SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___imul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___imul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___imul__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___imul__" "', argument " "2"" of type '" "double""'"); } @@ -6101,7 +6137,7 @@ SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector___itruediv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___itruediv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6109,16 +6145,20 @@ SWIGINTERN PyObject *_wrap_Vector___itruediv__(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___itruediv__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___itruediv__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___itruediv__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___itruediv__" "', argument " "2"" of type '" "double""'"); } @@ -6283,7 +6323,7 @@ SWIGINTERN PyObject *_wrap_Vector___isub__(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6291,16 +6331,20 @@ SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___iadd__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___iadd__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___iadd__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector___iadd__" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6331,7 +6375,7 @@ SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6342,21 +6386,26 @@ SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject * int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"Va", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector_Add", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_Add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Add" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Add" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_Add" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -6387,7 +6436,7 @@ SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6398,21 +6447,26 @@ SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject * int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"x", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector_Set", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Set" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Set" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_Set" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -6443,7 +6497,7 @@ SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6452,15 +6506,20 @@ SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", (char *)"offset", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetVector", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_SetVector", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetVector" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetVector" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6469,10 +6528,10 @@ SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyOb } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -6534,7 +6593,7 @@ SWIGINTERN PyObject *_wrap_Vector_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6542,15 +6601,19 @@ SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"other", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_Swap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_Swap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Swap" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Swap" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6581,7 +6644,7 @@ SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6592,15 +6655,20 @@ SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"lo", (char *)"hi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_median", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_median", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_median" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_median" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6608,7 +6676,7 @@ SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_median" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_median" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -7295,7 +7363,7 @@ SWIGINTERN PyObject *_wrap_Vector_AddElementVector(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7306,15 +7374,20 @@ SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPAR int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dofs", (char *)"val", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetSubVectorComplement", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_SetSubVectorComplement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetSubVectorComplement" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetSubVectorComplement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7322,7 +7395,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_SetSubVectorComplement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_SetSubVectorComplement" "', argument " "3"" of type '" "double""'"); } @@ -7353,39 +7426,44 @@ SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPAR SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -7420,7 +7498,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; std::ostream *arg2 = 0 ; @@ -7432,7 +7510,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { @@ -7452,7 +7530,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } { try { - ((mfem::Vector const *)arg1)->Print(*arg2); + ((mfem::Vector const *)arg1)->Print_HYPRE(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7483,21 +7561,35 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Randomize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"seed", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_Randomize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Randomize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } { try { - ((mfem::Vector const *)arg1)->Print(); + (arg1)->Randomize(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7518,39 +7610,24 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + PyObject *swig_obj[1] ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml2" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } { try { - ((mfem::Vector const *)arg1)->Print_HYPRE(*arg2); + result = (double)((mfem::Vector const *)arg1)->Norml2(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7564,45 +7641,31 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Randomize" "', argument " "1"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlinf" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - (arg1)->Randomize(arg2); + result = (double)((mfem::Vector const *)arg1)->Normlinf(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7616,28 +7679,31 @@ SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Randomize" "', argument " "1"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml1" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - (arg1)->Randomize(); + result = (double)((mfem::Vector const *)arg1)->Norml1(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7651,60 +7717,63 @@ SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_1(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Randomize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 +SWIGINTERN PyObject *_wrap_Vector_Normlp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Vector *arg1 = (mfem::Vector *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL }; + double result; - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Randomize", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Randomize__SWIG_1(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_Normlp", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlp" "', argument " "1"" of type '" "mfem::Vector const *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Vector_Randomize__SWIG_0(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Normlp" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (double)((mfem::Vector const *)arg1)->Normlp(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Randomize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::Randomize(int)\n" - " mfem::Vector::Randomize()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -7716,12 +7785,12 @@ SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObjec swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml2" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Max" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double)((mfem::Vector const *)arg1)->Norml2(); + result = (double)((mfem::Vector const *)arg1)->Max(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7742,7 +7811,7 @@ SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -7754,12 +7823,12 @@ SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObj swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlinf" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Min" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double)((mfem::Vector const *)arg1)->Normlinf(); + result = (double)((mfem::Vector const *)arg1)->Min(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7780,7 +7849,7 @@ SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -7792,12 +7861,12 @@ SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObjec swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml1" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Sum" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double)((mfem::Vector const *)arg1)->Norml1(); + result = (double)((mfem::Vector const *)arg1)->Sum(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7818,183 +7887,28 @@ SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Vector_Normlp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_DistanceSquaredTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "Vector_Normlp", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlp" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Normlp" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (double)((mfem::Vector const *)arg1)->Normlp(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Max" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - try { - result = (double)((mfem::Vector const *)arg1)->Max(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Min" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - try { - result = (double)((mfem::Vector const *)arg1)->Min(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Sum" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - try { - result = (double)((mfem::Vector const *)arg1)->Sum(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_DistanceSquaredTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - double *arg2 = (double *) 0 ; + double *arg2 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Vector_DistanceSquaredTo", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_DistanceSquaredTo", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_DistanceSquaredTo" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_DistanceSquaredTo" "', argument " "2"" of type '" "double const *""'"); } @@ -8022,7 +7936,7 @@ SWIGINTERN PyObject *_wrap_Vector_DistanceSquaredTo(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Vector_DistanceTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_DistanceTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -8030,16 +7944,20 @@ SWIGINTERN PyObject *_wrap_Vector_DistanceTo(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Vector_DistanceTo", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_DistanceTo", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_DistanceTo" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_DistanceTo" "', argument " "2"" of type '" "double const *""'"); } @@ -8142,66 +8060,37 @@ SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Vector_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Read" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::Vector const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Read" "', argument " "1"" of type '" "mfem::Vector const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double *)((mfem::Vector const *)arg1)->Read(); + result = (double *)((mfem::Vector const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8222,48 +8111,6 @@ SWIGINTERN PyObject *_wrap_Vector_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Vector_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Vector_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::Read(bool) const\n" - " mfem::Vector::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Vector_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -8302,66 +8149,37 @@ SWIGINTERN PyObject *_wrap_Vector_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Write" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Write" "', argument " "1"" of type '" "mfem::Vector *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double *)(arg1)->Write(); + result = (double *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8382,48 +8200,6 @@ SWIGINTERN PyObject *_wrap_Vector_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Vector_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::Write(bool)\n" - " mfem::Vector::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Vector_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -8441,51 +8217,7 @@ SWIGINTERN PyObject *_wrap_Vector_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyOb arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double *)(arg1)->HostWrite(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_ReadWrite" "', argument " "1"" of type '" "mfem::Vector *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->ReadWrite(arg2); + result = (double *)(arg1)->HostWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8506,22 +8238,37 @@ SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_ReadWrite" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8542,48 +8289,6 @@ SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Vector_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Vector_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::ReadWrite(bool)\n" - " mfem::Vector::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Vector_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -8925,7 +8630,7 @@ SWIGINTERN PyObject *_wrap_Vector_Assign(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; int arg2 ; @@ -8934,21 +8639,26 @@ SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___setitem__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector___setitem__" "', argument " "3"" of type '" "double""'"); } @@ -8976,22 +8686,26 @@ SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Vector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; PyObject *arg2 = (PyObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"param", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___getitem__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - arg2 = swig_obj[1]; + arg2 = obj1; { try { result = (PyObject *)mfem_Vector___getitem__(arg1,arg2); @@ -9053,18 +8767,18 @@ SWIGINTERN PyObject *_wrap_Vector_GetDataArray(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector *""'"); @@ -9075,61 +8789,17 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Vector_Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Vector_Print__SWIG_3(arg1,(char const *)arg2); + mfem_Vector_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9160,34 +8830,15 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_Vector_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -9198,19 +8849,9 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Vector_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Vector_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -9220,27 +8861,23 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Vector_Print__SWIG_3(self, argc, argv); + return _wrap_Vector_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Vector_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -9250,7 +8887,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Vector_Print__SWIG_0(self, argc, argv); + return _wrap_Vector_Print__SWIG_1(self, argc, argv); } } } @@ -9260,10 +8897,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Vector::Print(std::ostream &,int) const\n" - " mfem::Vector::Print(std::ostream &) const\n" - " mfem::Vector::Print() const\n" - " mfem::Vector::Print(char const *,int)\n" - " mfem::Vector::Print(char const *)\n"); + " mfem::Vector::Print(char const *,int)\n"); return 0; } @@ -9272,14 +8906,14 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_1(PyObject *SWIGUNUSEDPARM(s PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector *""'"); @@ -9290,11 +8924,13 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print_HYPRE" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -9322,52 +8958,6 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print_HYPRE" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Vector_Print_HYPRE__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -9381,7 +8971,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_3(PyObject *SWIGUNUSEDPARM(s arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - mfem_Vector_Print_HYPRE__SWIG_3(arg1); + mfem_Vector_Print_HYPRE__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9416,10 +9006,10 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Vector_Print_HYPRE__SWIG_3(self, argc, argv); + return _wrap_Vector_Print_HYPRE__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); @@ -9428,7 +9018,20 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Vector_Print_HYPRE__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_Vector_Print_HYPRE__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Vector_Print_HYPRE__SWIG_1(self, argc, argv); + } } } } @@ -9452,36 +9055,12 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Vector_Print_HYPRE__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Print_HYPRE'.\n" " Possible C/C++ prototypes are:\n" " mfem::Vector::Print_HYPRE(std::ostream &) const\n" " mfem::Vector::Print_HYPRE(char const *,int)\n" - " mfem::Vector::Print_HYPRE(char const *)\n" " mfem::Vector::Print_HYPRE()\n"); return 0; } @@ -9498,18 +9077,20 @@ SWIGINTERN PyObject *Vector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IsFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = 0 ; double temp1 ; double val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"val", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsFinite", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsFinite" "', argument " "1"" of type '" "double""'"); } @@ -9538,7 +9119,7 @@ SWIGINTERN PyObject *_wrap_IsFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; @@ -9547,25 +9128,30 @@ SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"y", (char *)"n", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DistanceSquared", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DistanceSquared", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistanceSquared" "', argument " "1"" of type '" "double const *""'"); } arg1 = reinterpret_cast< double * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DistanceSquared" "', argument " "2"" of type '" "double const *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9590,7 +9176,7 @@ SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; @@ -9599,25 +9185,30 @@ SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"y", (char *)"n", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Distance", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Distance", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Distance" "', argument " "1"" of type '" "double const *""'"); } arg1 = reinterpret_cast< double * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Distance" "', argument " "2"" of type '" "double const *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9655,7 +9246,7 @@ static PyMethodDef SwigMethods[] = { "subtract_vector(Vector v1, Vector v2, Vector v)\n" "subtract_vector(double const a, Vector x, Vector y, Vector z)\n" ""}, - { "CheckFinite", _wrap_CheckFinite, METH_VARARGS, "CheckFinite(double const * v, int const n) -> int"}, + { "CheckFinite", (PyCFunction)(void(*)(void))_wrap_CheckFinite, METH_VARARGS|METH_KEYWORDS, "CheckFinite(double const * v, int const n) -> int"}, { "infinity", _wrap_infinity, METH_NOARGS, "infinity() -> double"}, { "Vector_UseDevice", _wrap_Vector_UseDevice, METH_VARARGS, "\n" "Vector_UseDevice(Vector self, bool use_dev)\n" @@ -9671,10 +9262,10 @@ static PyMethodDef SwigMethods[] = { "Vector_SetSize(Vector self, int s, mfem::MemoryType mt)\n" "Vector_SetSize(Vector self, int s, Vector v)\n" ""}, - { "Vector_SetData", _wrap_Vector_SetData, METH_VARARGS, "Vector_SetData(Vector self, double * d)"}, - { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "Vector_SetDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "Vector_NewDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "Vector_NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_SetData", (PyCFunction)(void(*)(void))_wrap_Vector_SetData, METH_VARARGS|METH_KEYWORDS, "Vector_SetData(Vector self, double * d)"}, + { "Vector_SetDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_SetDataAndSize, METH_VARARGS|METH_KEYWORDS, "Vector_SetDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewDataAndSize, METH_VARARGS|METH_KEYWORDS, "Vector_NewDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewMemoryAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewMemoryAndSize, METH_VARARGS|METH_KEYWORDS, "Vector_NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" "Vector_MakeRef(Vector self, Vector base, int offset, int size)\n" "Vector_MakeRef(Vector self, Vector base, int offset)\n" @@ -9688,8 +9279,8 @@ static PyMethodDef SwigMethods[] = { "Vector_GetMemory(Vector self) -> mfem::Memory< double >\n" "Vector_GetMemory(Vector self) -> mfem::Memory< double > const &\n" ""}, - { "Vector_SyncMemory", _wrap_Vector_SyncMemory, METH_VARARGS, "Vector_SyncMemory(Vector self, Vector v)"}, - { "Vector_SyncAliasMemory", _wrap_Vector_SyncAliasMemory, METH_VARARGS, "Vector_SyncAliasMemory(Vector self, Vector v)"}, + { "Vector_SyncMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncMemory, METH_VARARGS|METH_KEYWORDS, "Vector_SyncMemory(Vector self, Vector v)"}, + { "Vector_SyncAliasMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncAliasMemory, METH_VARARGS|METH_KEYWORDS, "Vector_SyncAliasMemory(Vector self, Vector v)"}, { "Vector_OwnsData", _wrap_Vector_OwnsData, METH_O, "Vector_OwnsData(Vector self) -> bool"}, { "Vector_StealData", _wrap_Vector_StealData, METH_VARARGS, "\n" "Vector_StealData(Vector self, double ** p)\n" @@ -9707,19 +9298,19 @@ static PyMethodDef SwigMethods[] = { "Vector___mul__(Vector self, double const * arg2) -> double\n" "Vector___mul__(Vector self, Vector v) -> double\n" ""}, - { "Vector___imul__", _wrap_Vector___imul__, METH_VARARGS, "Vector___imul__(Vector self, double c) -> Vector"}, - { "Vector___itruediv__", _wrap_Vector___itruediv__, METH_VARARGS, "Vector___itruediv__(Vector self, double c) -> Vector"}, + { "Vector___imul__", (PyCFunction)(void(*)(void))_wrap_Vector___imul__, METH_VARARGS|METH_KEYWORDS, "Vector___imul__(Vector self, double c) -> Vector"}, + { "Vector___itruediv__", (PyCFunction)(void(*)(void))_wrap_Vector___itruediv__, METH_VARARGS|METH_KEYWORDS, "Vector___itruediv__(Vector self, double c) -> Vector"}, { "Vector___isub__", _wrap_Vector___isub__, METH_VARARGS, "\n" "Vector___isub__(Vector self, double c) -> Vector\n" "Vector___isub__(Vector self, Vector v) -> Vector\n" ""}, - { "Vector___iadd__", _wrap_Vector___iadd__, METH_VARARGS, "Vector___iadd__(Vector self, Vector v) -> Vector"}, - { "Vector_Add", _wrap_Vector_Add, METH_VARARGS, "Vector_Add(Vector self, double const a, Vector Va) -> Vector"}, - { "Vector_Set", _wrap_Vector_Set, METH_VARARGS, "Vector_Set(Vector self, double const a, Vector x) -> Vector"}, - { "Vector_SetVector", _wrap_Vector_SetVector, METH_VARARGS, "Vector_SetVector(Vector self, Vector v, int offset)"}, + { "Vector___iadd__", (PyCFunction)(void(*)(void))_wrap_Vector___iadd__, METH_VARARGS|METH_KEYWORDS, "Vector___iadd__(Vector self, Vector v) -> Vector"}, + { "Vector_Add", (PyCFunction)(void(*)(void))_wrap_Vector_Add, METH_VARARGS|METH_KEYWORDS, "Vector_Add(Vector self, double const a, Vector Va) -> Vector"}, + { "Vector_Set", (PyCFunction)(void(*)(void))_wrap_Vector_Set, METH_VARARGS|METH_KEYWORDS, "Vector_Set(Vector self, double const a, Vector x) -> Vector"}, + { "Vector_SetVector", (PyCFunction)(void(*)(void))_wrap_Vector_SetVector, METH_VARARGS|METH_KEYWORDS, "Vector_SetVector(Vector self, Vector v, int offset)"}, { "Vector_Neg", _wrap_Vector_Neg, METH_O, "Vector_Neg(Vector self)"}, - { "Vector_Swap", _wrap_Vector_Swap, METH_VARARGS, "Vector_Swap(Vector self, Vector other)"}, - { "Vector_median", _wrap_Vector_median, METH_VARARGS, "Vector_median(Vector self, Vector lo, Vector hi)"}, + { "Vector_Swap", (PyCFunction)(void(*)(void))_wrap_Vector_Swap, METH_VARARGS|METH_KEYWORDS, "Vector_Swap(Vector self, Vector other)"}, + { "Vector_median", (PyCFunction)(void(*)(void))_wrap_Vector_median, METH_VARARGS|METH_KEYWORDS, "Vector_median(Vector self, Vector lo, Vector hi)"}, { "Vector_GetSubVector", _wrap_Vector_GetSubVector, METH_VARARGS, "\n" "Vector_GetSubVector(Vector self, intArray dofs, Vector elemvect)\n" "Vector_GetSubVector(Vector self, intArray dofs, double * elem_data)\n" @@ -9734,24 +9325,24 @@ static PyMethodDef SwigMethods[] = { "Vector_AddElementVector(Vector self, intArray dofs, double * elem_data)\n" "Vector_AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect)\n" ""}, - { "Vector_SetSubVectorComplement", _wrap_Vector_SetSubVectorComplement, METH_VARARGS, "Vector_SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, - { "Vector_Randomize", _wrap_Vector_Randomize, METH_VARARGS, "Vector_Randomize(Vector self, int seed=0)"}, + { "Vector_SetSubVectorComplement", (PyCFunction)(void(*)(void))_wrap_Vector_SetSubVectorComplement, METH_VARARGS|METH_KEYWORDS, "Vector_SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, + { "Vector_Randomize", (PyCFunction)(void(*)(void))_wrap_Vector_Randomize, METH_VARARGS|METH_KEYWORDS, "Vector_Randomize(Vector self, int seed=0)"}, { "Vector_Norml2", _wrap_Vector_Norml2, METH_O, "Vector_Norml2(Vector self) -> double"}, { "Vector_Normlinf", _wrap_Vector_Normlinf, METH_O, "Vector_Normlinf(Vector self) -> double"}, { "Vector_Norml1", _wrap_Vector_Norml1, METH_O, "Vector_Norml1(Vector self) -> double"}, - { "Vector_Normlp", _wrap_Vector_Normlp, METH_VARARGS, "Vector_Normlp(Vector self, double p) -> double"}, + { "Vector_Normlp", (PyCFunction)(void(*)(void))_wrap_Vector_Normlp, METH_VARARGS|METH_KEYWORDS, "Vector_Normlp(Vector self, double p) -> double"}, { "Vector_Max", _wrap_Vector_Max, METH_O, "Vector_Max(Vector self) -> double"}, { "Vector_Min", _wrap_Vector_Min, METH_O, "Vector_Min(Vector self) -> double"}, { "Vector_Sum", _wrap_Vector_Sum, METH_O, "Vector_Sum(Vector self) -> double"}, - { "Vector_DistanceSquaredTo", _wrap_Vector_DistanceSquaredTo, METH_VARARGS, "Vector_DistanceSquaredTo(Vector self, double const * p) -> double"}, - { "Vector_DistanceTo", _wrap_Vector_DistanceTo, METH_VARARGS, "Vector_DistanceTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceSquaredTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceSquaredTo, METH_VARARGS|METH_KEYWORDS, "Vector_DistanceSquaredTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceTo, METH_VARARGS|METH_KEYWORDS, "Vector_DistanceTo(Vector self, double const * p) -> double"}, { "Vector_CheckFinite", _wrap_Vector_CheckFinite, METH_O, "Vector_CheckFinite(Vector self) -> int"}, { "delete_Vector", _wrap_delete_Vector, METH_O, "delete_Vector(Vector self)"}, - { "Vector_Read", _wrap_Vector_Read, METH_VARARGS, "Vector_Read(Vector self, bool on_dev=True) -> double const"}, + { "Vector_Read", (PyCFunction)(void(*)(void))_wrap_Vector_Read, METH_VARARGS|METH_KEYWORDS, "Vector_Read(Vector self, bool on_dev=True) -> double const *"}, { "Vector_HostRead", _wrap_Vector_HostRead, METH_O, "Vector_HostRead(Vector self) -> double const *"}, - { "Vector_Write", _wrap_Vector_Write, METH_VARARGS, "Vector_Write(Vector self, bool on_dev=True) -> double"}, + { "Vector_Write", (PyCFunction)(void(*)(void))_wrap_Vector_Write, METH_VARARGS|METH_KEYWORDS, "Vector_Write(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostWrite", _wrap_Vector_HostWrite, METH_O, "Vector_HostWrite(Vector self) -> double *"}, - { "Vector_ReadWrite", _wrap_Vector_ReadWrite, METH_VARARGS, "Vector_ReadWrite(Vector self, bool on_dev=True) -> double"}, + { "Vector_ReadWrite", (PyCFunction)(void(*)(void))_wrap_Vector_ReadWrite, METH_VARARGS|METH_KEYWORDS, "Vector_ReadWrite(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostReadWrite", _wrap_Vector_HostReadWrite, METH_O, "Vector_HostReadWrite(Vector self) -> double *"}, { "new_Vector", _wrap_new_Vector, METH_VARARGS, "\n" "Vector()\n" @@ -9765,8 +9356,8 @@ static PyMethodDef SwigMethods[] = { "Vector_Assign(Vector self, double const v)\n" "Vector_Assign(Vector self, PyObject * param)\n" ""}, - { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, "Vector___setitem__(Vector self, int i, double const v)"}, - { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, "Vector___getitem__(Vector self, PyObject * param) -> PyObject *"}, + { "Vector___setitem__", (PyCFunction)(void(*)(void))_wrap_Vector___setitem__, METH_VARARGS|METH_KEYWORDS, "Vector___setitem__(Vector self, int i, double const v)"}, + { "Vector___getitem__", (PyCFunction)(void(*)(void))_wrap_Vector___getitem__, METH_VARARGS|METH_KEYWORDS, "Vector___getitem__(Vector self, PyObject * param) -> PyObject *"}, { "Vector_GetDataArray", _wrap_Vector_GetDataArray, METH_O, "Vector_GetDataArray(Vector self) -> PyObject *"}, { "Vector_Print", _wrap_Vector_Print, METH_VARARGS, "\n" "Vector_Print(Vector self, std::ostream & out=mfem::out, int width=8)\n" @@ -9779,9 +9370,9 @@ static PyMethodDef SwigMethods[] = { ""}, { "Vector_swigregister", Vector_swigregister, METH_O, NULL}, { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL}, - { "IsFinite", _wrap_IsFinite, METH_O, "IsFinite(double const & val) -> bool"}, - { "DistanceSquared", _wrap_DistanceSquared, METH_VARARGS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, - { "Distance", _wrap_Distance, METH_VARARGS, "Distance(double const * x, double const * y, int const n) -> double"}, + { "IsFinite", (PyCFunction)(void(*)(void))_wrap_IsFinite, METH_VARARGS|METH_KEYWORDS, "IsFinite(double const & val) -> bool"}, + { "DistanceSquared", (PyCFunction)(void(*)(void))_wrap_DistanceSquared, METH_VARARGS|METH_KEYWORDS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, + { "Distance", (PyCFunction)(void(*)(void))_wrap_Distance, METH_VARARGS|METH_KEYWORDS, "Distance(double const * x, double const * y, int const n) -> double"}, { NULL, NULL, 0, NULL } }; @@ -9798,7 +9389,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "subtract_vector(Vector v1, Vector v2, Vector v)\n" "subtract_vector(double const a, Vector x, Vector y, Vector z)\n" ""}, - { "CheckFinite", _wrap_CheckFinite, METH_VARARGS, "CheckFinite(double const * v, int const n) -> int"}, + { "CheckFinite", (PyCFunction)(void(*)(void))_wrap_CheckFinite, METH_VARARGS|METH_KEYWORDS, "CheckFinite(double const * v, int const n) -> int"}, { "infinity", _wrap_infinity, METH_NOARGS, "infinity() -> double"}, { "Vector_UseDevice", _wrap_Vector_UseDevice, METH_VARARGS, "\n" "UseDevice(Vector self, bool use_dev)\n" @@ -9814,10 +9405,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(Vector self, int s, mfem::MemoryType mt)\n" "SetSize(Vector self, int s, Vector v)\n" ""}, - { "Vector_SetData", _wrap_Vector_SetData, METH_VARARGS, "SetData(Vector self, double * d)"}, - { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "SetDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "NewDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_SetData", (PyCFunction)(void(*)(void))_wrap_Vector_SetData, METH_VARARGS|METH_KEYWORDS, "SetData(Vector self, double * d)"}, + { "Vector_SetDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_SetDataAndSize, METH_VARARGS|METH_KEYWORDS, "SetDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewDataAndSize, METH_VARARGS|METH_KEYWORDS, "NewDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewMemoryAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewMemoryAndSize, METH_VARARGS|METH_KEYWORDS, "NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" "MakeRef(Vector self, Vector base, int offset, int size)\n" "MakeRef(Vector self, Vector base, int offset)\n" @@ -9831,8 +9422,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemory(Vector self) -> mfem::Memory< double >\n" "GetMemory(Vector self) -> mfem::Memory< double > const &\n" ""}, - { "Vector_SyncMemory", _wrap_Vector_SyncMemory, METH_VARARGS, "SyncMemory(Vector self, Vector v)"}, - { "Vector_SyncAliasMemory", _wrap_Vector_SyncAliasMemory, METH_VARARGS, "SyncAliasMemory(Vector self, Vector v)"}, + { "Vector_SyncMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncMemory, METH_VARARGS|METH_KEYWORDS, "SyncMemory(Vector self, Vector v)"}, + { "Vector_SyncAliasMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncAliasMemory, METH_VARARGS|METH_KEYWORDS, "SyncAliasMemory(Vector self, Vector v)"}, { "Vector_OwnsData", _wrap_Vector_OwnsData, METH_O, "OwnsData(Vector self) -> bool"}, { "Vector_StealData", _wrap_Vector_StealData, METH_VARARGS, "\n" "StealData(Vector self, double ** p)\n" @@ -9850,19 +9441,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__mul__(Vector self, double const * arg2) -> double\n" "__mul__(Vector self, Vector v) -> double\n" ""}, - { "Vector___imul__", _wrap_Vector___imul__, METH_VARARGS, "__imul__(Vector self, double c) -> Vector"}, - { "Vector___itruediv__", _wrap_Vector___itruediv__, METH_VARARGS, "__itruediv__(Vector self, double c) -> Vector"}, + { "Vector___imul__", (PyCFunction)(void(*)(void))_wrap_Vector___imul__, METH_VARARGS|METH_KEYWORDS, "__imul__(Vector self, double c) -> Vector"}, + { "Vector___itruediv__", (PyCFunction)(void(*)(void))_wrap_Vector___itruediv__, METH_VARARGS|METH_KEYWORDS, "__itruediv__(Vector self, double c) -> Vector"}, { "Vector___isub__", _wrap_Vector___isub__, METH_VARARGS, "\n" "__isub__(Vector self, double c) -> Vector\n" "__isub__(Vector self, Vector v) -> Vector\n" ""}, - { "Vector___iadd__", _wrap_Vector___iadd__, METH_VARARGS, "__iadd__(Vector self, Vector v) -> Vector"}, - { "Vector_Add", _wrap_Vector_Add, METH_VARARGS, "Add(Vector self, double const a, Vector Va) -> Vector"}, - { "Vector_Set", _wrap_Vector_Set, METH_VARARGS, "Set(Vector self, double const a, Vector x) -> Vector"}, - { "Vector_SetVector", _wrap_Vector_SetVector, METH_VARARGS, "SetVector(Vector self, Vector v, int offset)"}, + { "Vector___iadd__", (PyCFunction)(void(*)(void))_wrap_Vector___iadd__, METH_VARARGS|METH_KEYWORDS, "__iadd__(Vector self, Vector v) -> Vector"}, + { "Vector_Add", (PyCFunction)(void(*)(void))_wrap_Vector_Add, METH_VARARGS|METH_KEYWORDS, "Add(Vector self, double const a, Vector Va) -> Vector"}, + { "Vector_Set", (PyCFunction)(void(*)(void))_wrap_Vector_Set, METH_VARARGS|METH_KEYWORDS, "Set(Vector self, double const a, Vector x) -> Vector"}, + { "Vector_SetVector", (PyCFunction)(void(*)(void))_wrap_Vector_SetVector, METH_VARARGS|METH_KEYWORDS, "SetVector(Vector self, Vector v, int offset)"}, { "Vector_Neg", _wrap_Vector_Neg, METH_O, "Neg(Vector self)"}, - { "Vector_Swap", _wrap_Vector_Swap, METH_VARARGS, "Swap(Vector self, Vector other)"}, - { "Vector_median", _wrap_Vector_median, METH_VARARGS, "median(Vector self, Vector lo, Vector hi)"}, + { "Vector_Swap", (PyCFunction)(void(*)(void))_wrap_Vector_Swap, METH_VARARGS|METH_KEYWORDS, "Swap(Vector self, Vector other)"}, + { "Vector_median", (PyCFunction)(void(*)(void))_wrap_Vector_median, METH_VARARGS|METH_KEYWORDS, "median(Vector self, Vector lo, Vector hi)"}, { "Vector_GetSubVector", _wrap_Vector_GetSubVector, METH_VARARGS, "\n" "GetSubVector(Vector self, intArray dofs, Vector elemvect)\n" "GetSubVector(Vector self, intArray dofs, double * elem_data)\n" @@ -9877,24 +9468,24 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AddElementVector(Vector self, intArray dofs, double * elem_data)\n" "AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect)\n" ""}, - { "Vector_SetSubVectorComplement", _wrap_Vector_SetSubVectorComplement, METH_VARARGS, "SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, - { "Vector_Randomize", _wrap_Vector_Randomize, METH_VARARGS, "Randomize(Vector self, int seed=0)"}, + { "Vector_SetSubVectorComplement", (PyCFunction)(void(*)(void))_wrap_Vector_SetSubVectorComplement, METH_VARARGS|METH_KEYWORDS, "SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, + { "Vector_Randomize", (PyCFunction)(void(*)(void))_wrap_Vector_Randomize, METH_VARARGS|METH_KEYWORDS, "Randomize(Vector self, int seed=0)"}, { "Vector_Norml2", _wrap_Vector_Norml2, METH_O, "Norml2(Vector self) -> double"}, { "Vector_Normlinf", _wrap_Vector_Normlinf, METH_O, "Normlinf(Vector self) -> double"}, { "Vector_Norml1", _wrap_Vector_Norml1, METH_O, "Norml1(Vector self) -> double"}, - { "Vector_Normlp", _wrap_Vector_Normlp, METH_VARARGS, "Normlp(Vector self, double p) -> double"}, + { "Vector_Normlp", (PyCFunction)(void(*)(void))_wrap_Vector_Normlp, METH_VARARGS|METH_KEYWORDS, "Normlp(Vector self, double p) -> double"}, { "Vector_Max", _wrap_Vector_Max, METH_O, "Max(Vector self) -> double"}, { "Vector_Min", _wrap_Vector_Min, METH_O, "Min(Vector self) -> double"}, { "Vector_Sum", _wrap_Vector_Sum, METH_O, "Sum(Vector self) -> double"}, - { "Vector_DistanceSquaredTo", _wrap_Vector_DistanceSquaredTo, METH_VARARGS, "DistanceSquaredTo(Vector self, double const * p) -> double"}, - { "Vector_DistanceTo", _wrap_Vector_DistanceTo, METH_VARARGS, "DistanceTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceSquaredTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceSquaredTo, METH_VARARGS|METH_KEYWORDS, "DistanceSquaredTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceTo, METH_VARARGS|METH_KEYWORDS, "DistanceTo(Vector self, double const * p) -> double"}, { "Vector_CheckFinite", _wrap_Vector_CheckFinite, METH_O, "CheckFinite(Vector self) -> int"}, { "delete_Vector", _wrap_delete_Vector, METH_O, "delete_Vector(Vector self)"}, - { "Vector_Read", _wrap_Vector_Read, METH_VARARGS, "Read(Vector self, bool on_dev=True) -> double const"}, + { "Vector_Read", (PyCFunction)(void(*)(void))_wrap_Vector_Read, METH_VARARGS|METH_KEYWORDS, "Read(Vector self, bool on_dev=True) -> double const *"}, { "Vector_HostRead", _wrap_Vector_HostRead, METH_O, "HostRead(Vector self) -> double const *"}, - { "Vector_Write", _wrap_Vector_Write, METH_VARARGS, "Write(Vector self, bool on_dev=True) -> double"}, + { "Vector_Write", (PyCFunction)(void(*)(void))_wrap_Vector_Write, METH_VARARGS|METH_KEYWORDS, "Write(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostWrite", _wrap_Vector_HostWrite, METH_O, "HostWrite(Vector self) -> double *"}, - { "Vector_ReadWrite", _wrap_Vector_ReadWrite, METH_VARARGS, "ReadWrite(Vector self, bool on_dev=True) -> double"}, + { "Vector_ReadWrite", (PyCFunction)(void(*)(void))_wrap_Vector_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostReadWrite", _wrap_Vector_HostReadWrite, METH_O, "HostReadWrite(Vector self) -> double *"}, { "new_Vector", _wrap_new_Vector, METH_VARARGS, "\n" "Vector()\n" @@ -9908,8 +9499,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Assign(Vector self, double const v)\n" "Assign(Vector self, PyObject * param)\n" ""}, - { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, "__setitem__(Vector self, int i, double const v)"}, - { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, "__getitem__(Vector self, PyObject * param) -> PyObject *"}, + { "Vector___setitem__", (PyCFunction)(void(*)(void))_wrap_Vector___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(Vector self, int i, double const v)"}, + { "Vector___getitem__", (PyCFunction)(void(*)(void))_wrap_Vector___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(Vector self, PyObject * param) -> PyObject *"}, { "Vector_GetDataArray", _wrap_Vector_GetDataArray, METH_O, "GetDataArray(Vector self) -> PyObject *"}, { "Vector_Print", _wrap_Vector_Print, METH_VARARGS, "\n" "Print(Vector self, std::ostream & out=mfem::out, int width=8)\n" @@ -9922,9 +9513,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Vector_swigregister", Vector_swigregister, METH_O, NULL}, { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL}, - { "IsFinite", _wrap_IsFinite, METH_O, "IsFinite(double const & val) -> bool"}, - { "DistanceSquared", _wrap_DistanceSquared, METH_VARARGS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, - { "Distance", _wrap_Distance, METH_VARARGS, "Distance(double const * x, double const * y, int const n) -> double"}, + { "IsFinite", (PyCFunction)(void(*)(void))_wrap_IsFinite, METH_VARARGS|METH_KEYWORDS, "IsFinite(double const & val) -> bool"}, + { "DistanceSquared", (PyCFunction)(void(*)(void))_wrap_DistanceSquared, METH_VARARGS|METH_KEYWORDS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, + { "Distance", (PyCFunction)(void(*)(void))_wrap_Distance, METH_VARARGS|METH_KEYWORDS, "Distance(double const * x, double const * y, int const n) -> double"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_par/vtk_wrap.cxx b/mfem/_par/vtk_wrap.cxx index 34d6ffd7..4dd911a8 100644 --- a/mfem/_par/vtk_wrap.cxx +++ b/mfem/_par/vtk_wrap.cxx @@ -3393,7 +3393,7 @@ SWIG_FromCharPtr(const char *cptr) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; mfem::Geometry::Type arg2 ; @@ -3402,10 +3402,15 @@ SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"con", (char *)"geom", (char *)"ref", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CreateVTKElementConnectivity", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CreateVTKElementConnectivity", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); } @@ -3413,16 +3418,16 @@ SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateVTKElementConnectivity" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3444,7 +3449,7 @@ SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; std::ostream *arg1 = 0 ; void *arg2 = (void *) 0 ; @@ -3455,11 +3460,17 @@ SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(se int res2 ; void *argp3 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"out", (char *)"bytes", (char *)"nbytes", (char *)"compression_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "WriteVTKEncodedCompressed", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:WriteVTKEncodedCompressed", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(obj0, (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } @@ -3473,12 +3484,12 @@ SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(se arg1 = &out1; } } - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteVTKEncodedCompressed" "', argument " "2"" of type '" "void const *""'"); } { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_uint32_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_uint32_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WriteVTKEncodedCompressed" "', argument " "3"" of type '" "uint32_t""'"); } @@ -3491,10 +3502,10 @@ SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(se } } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3554,8 +3565,8 @@ SWIGINTERN PyObject *_wrap_VTKByteOrder(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, - { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "CreateVTKElementConnectivity", (PyCFunction)(void(*)(void))_wrap_CreateVTKElementConnectivity, METH_VARARGS|METH_KEYWORDS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", (PyCFunction)(void(*)(void))_wrap_WriteVTKEncodedCompressed, METH_VARARGS|METH_KEYWORDS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, { NULL, NULL, 0, NULL } }; @@ -3563,8 +3574,8 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, - { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "CreateVTKElementConnectivity", (PyCFunction)(void(*)(void))_wrap_CreateVTKElementConnectivity, METH_VARARGS|METH_KEYWORDS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", (PyCFunction)(void(*)(void))_wrap_WriteVTKEncodedCompressed, METH_VARARGS|METH_KEYWORDS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/array.py b/mfem/_ser/array.py index dfff23b9..9dfa51f0 100644 --- a/mfem/_ser/array.py +++ b/mfem/_ser/array.py @@ -288,7 +288,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_array.intArray_MemoryUsage) def Read(self, on_dev=True): - r"""Read(intArray self, bool on_dev=True) -> int const""" + r"""Read(intArray self, bool on_dev=True) -> int const *""" return _array.intArray_Read(self, on_dev) Read = _swig_new_instance_method(_array.intArray_Read) @@ -298,7 +298,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_array.intArray_HostRead) def Write(self, on_dev=True): - r"""Write(intArray self, bool on_dev=True) -> int""" + r"""Write(intArray self, bool on_dev=True) -> int *""" return _array.intArray_Write(self, on_dev) Write = _swig_new_instance_method(_array.intArray_Write) @@ -308,7 +308,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_array.intArray_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(intArray self, bool on_dev=True) -> int""" + r"""ReadWrite(intArray self, bool on_dev=True) -> int *""" return _array.intArray_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_array.intArray_ReadWrite) @@ -583,7 +583,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_array.doubleArray_MemoryUsage) def Read(self, on_dev=True): - r"""Read(doubleArray self, bool on_dev=True) -> double const""" + r"""Read(doubleArray self, bool on_dev=True) -> double const *""" return _array.doubleArray_Read(self, on_dev) Read = _swig_new_instance_method(_array.doubleArray_Read) @@ -593,7 +593,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_array.doubleArray_HostRead) def Write(self, on_dev=True): - r"""Write(doubleArray self, bool on_dev=True) -> double""" + r"""Write(doubleArray self, bool on_dev=True) -> double *""" return _array.doubleArray_Write(self, on_dev) Write = _swig_new_instance_method(_array.doubleArray_Write) @@ -603,7 +603,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_array.doubleArray_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(doubleArray self, bool on_dev=True) -> double""" + r"""ReadWrite(doubleArray self, bool on_dev=True) -> double *""" return _array.doubleArray_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_array.doubleArray_ReadWrite) diff --git a/mfem/_ser/array_wrap.cxx b/mfem/_ser/array_wrap.cxx index c25db321..ec74e61d 100644 --- a/mfem/_ser/array_wrap.cxx +++ b/mfem/_ser/array_wrap.cxx @@ -3100,7 +3100,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Array_Sl_int_Sg__Print__SWIG_3(mfem::Array< int > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_int_Sg__Print__SWIG_1(mfem::Array< int > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3111,7 +3111,7 @@ SWIGINTERN void mfem_Array_Sl_int_Sg__Print__SWIG_3(mfem::Array< int > *self,cha self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_2(mfem::Array< int > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_1(mfem::Array< int > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3122,7 +3122,7 @@ SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_2(mfem::Array< int > *self,char self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_4(mfem::Array< int > *self){ +SWIGINTERN void mfem_Array_Sl_int_Sg__Save__SWIG_2(mfem::Array< int > *self){ self -> Save(std::cout); } @@ -3138,7 +3138,7 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Assign__SWIG_1(mfem::Array< double > *s *self = a; } SWIGINTERN void mfem_Array_Sl_double_Sg__FakeToList(mfem::Array< double > *self){} -SWIGINTERN void mfem_Array_Sl_double_Sg__Print__SWIG_3(mfem::Array< double > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_double_Sg__Print__SWIG_1(mfem::Array< double > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3149,7 +3149,7 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Print__SWIG_3(mfem::Array< double > *se self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_2(mfem::Array< double > *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_1(mfem::Array< double > *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3160,7 +3160,7 @@ SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_2(mfem::Array< double > *sel self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_4(mfem::Array< double > *self){ +SWIGINTERN void mfem_Array_Sl_double_Sg__Save__SWIG_2(mfem::Array< double > *self){ self -> Save(std::cout); } #ifdef __cplusplus @@ -3749,7 +3749,7 @@ SWIGINTERN PyObject *_wrap_intArray_OwnsData(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_intArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int **arg2 = (int **) 0 ; @@ -3757,15 +3757,19 @@ SWIGINTERN PyObject *_wrap_intArray_StealData(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_StealData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_StealData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_StealData" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_StealData" "', argument " "2"" of type '" "int **""'"); } @@ -4166,7 +4170,7 @@ SWIGINTERN PyObject *_wrap_intArray_Capacity(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_intArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -4174,15 +4178,19 @@ SWIGINTERN PyObject *_wrap_intArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"capacity", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_Reserve", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Reserve", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Reserve" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Reserve" "', argument " "2"" of type '" "int""'"); } @@ -4422,7 +4430,7 @@ SWIGINTERN PyObject *_wrap_intArray_Append(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_intArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4431,16 +4439,20 @@ SWIGINTERN PyObject *_wrap_intArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyOb int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_Prepend", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Prepend", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Prepend" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Prepend" "', argument " "2"" of type '" "int""'"); } @@ -4577,7 +4589,7 @@ SWIGINTERN PyObject *_wrap_intArray_Last(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4586,16 +4598,20 @@ SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObje int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_Union", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Union", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Union" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Union" "', argument " "2"" of type '" "int""'"); } @@ -4624,7 +4640,7 @@ SWIGINTERN PyObject *_wrap_intArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4633,16 +4649,20 @@ SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObjec int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_Find", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Find", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Find" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Find" "', argument " "2"" of type '" "int""'"); } @@ -4671,7 +4691,7 @@ SWIGINTERN PyObject *_wrap_intArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_intArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4680,16 +4700,20 @@ SWIGINTERN PyObject *_wrap_intArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), P int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "intArray_FindSorted", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_FindSorted", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_FindSorted" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_FindSorted" "', argument " "2"" of type '" "int""'"); } @@ -4755,7 +4779,7 @@ SWIGINTERN PyObject *_wrap_intArray_DeleteLast(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_intArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int *arg2 = 0 ; @@ -4764,15 +4788,19 @@ SWIGINTERN PyObject *_wrap_intArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), int temp2 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_DeleteFirst", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_DeleteFirst", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_DeleteFirst" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_DeleteFirst" "', argument " "2"" of type '" "int""'"); } @@ -4838,7 +4866,7 @@ SWIGINTERN PyObject *_wrap_intArray_DeleteAll(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_intArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4846,15 +4874,19 @@ SWIGINTERN PyObject *_wrap_intArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Copy" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Copy" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -5033,7 +5065,7 @@ SWIGINTERN PyObject *_wrap_intArray_MakeRef(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -5047,25 +5079,31 @@ SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"sa_size", (char *)"sa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray_GetSubArray", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:intArray_GetSubArray", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_GetSubArray" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_GetSubArray" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_GetSubArray" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "intArray_GetSubArray" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -5099,8 +5137,9 @@ SWIGINTERN PyObject *_wrap_intArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; @@ -5108,32 +5147,36 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self) int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { ((mfem::Array< int > const *)arg1)->Print(*arg2,arg3); @@ -5167,19 +5210,22 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; std::ostream *arg2 = 0 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + int val3 ; + int ecode3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { @@ -5197,9 +5243,16 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self) arg2 = &out2; } } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - ((mfem::Array< int > const *)arg1)->Print(*arg2); + ((mfem::Array< int > const *)arg1)->Save(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5230,21 +5283,42 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; + std::istream *arg2 = 0 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Load" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - ((mfem::Array< int > const *)arg1)->Print(); + (arg1)->Load(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5265,47 +5339,40 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + int arg2 ; + std::istream *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val3 ; - int ecode3 = 0 ; + int val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Load" "', argument " "2"" of type '" "int""'"); } - arg3 = static_cast< int >(val3); + arg2 = static_cast< int >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); + } + arg3 = reinterpret_cast< std::istream * >(argp3); { try { - ((mfem::Array< int > const *)arg1)->Save(*arg2,arg3); + (arg1)->Load(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5320,55 +5387,91 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + return NULL; +} + + +SWIGINTERN PyObject *_wrap_intArray_Load(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Load", 0, 3, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_intArray_Load__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_intArray_Load__SWIG_0(self, argc, argv); + } + } } } - return NULL; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_intArray_Load__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Load'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Array< int >::Load(std::istream &,int)\n" + " mfem::Array< int >::Load(int,std::istream &)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Max" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } { try { - ((mfem::Array< int > const *)arg1)->Save(*arg2); + result = (int)((mfem::Array< int > const *)arg1)->Max(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5382,301 +5485,26 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Load" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - (arg1)->Load(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - try { - (arg1)->Load(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - int arg2 ; - std::istream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Load" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Load" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "intArray_Load" "', argument " "3"" of type '" "std::istream &""'"); - } - arg3 = reinterpret_cast< std::istream * >(argp3); - { - try { - (arg1)->Load(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Load(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Load", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Load__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_Load__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Load__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Load'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Load(std::istream &,int)\n" - " mfem::Array< int >::Load(std::istream &)\n" - " mfem::Array< int >::Load(int,std::istream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_intArray_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Max" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - try { - result = (int)((mfem::Array< int > const *)arg1)->Max(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Min" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Min" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { @@ -6186,66 +6014,37 @@ SWIGINTERN PyObject *_wrap_intArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:intArray_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Read" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)((mfem::Array< int > const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Read" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - result = (int *)((mfem::Array< int > const *)arg1)->Read(); + result = (int *)((mfem::Array< int > const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6266,48 +6065,6 @@ SWIGINTERN PyObject *_wrap_intArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Read(bool) const\n" - " mfem::Array< int >::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_intArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -6346,66 +6103,37 @@ SWIGINTERN PyObject *_wrap_intArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_intArray_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:intArray_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Write" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Write" "', argument " "1"" of type '" "mfem::Array< int > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - result = (int *)(arg1)->Write(); + result = (int *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6426,48 +6154,6 @@ SWIGINTERN PyObject *_wrap_intArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::Write(bool)\n" - " mfem::Array< int >::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_intArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -6506,66 +6192,37 @@ SWIGINTERN PyObject *_wrap_intArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_intArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:intArray_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)(arg1)->ReadWrite(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< int > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - result = (int *)(arg1)->ReadWrite(); + result = (int *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6586,48 +6243,6 @@ SWIGINTERN PyObject *_wrap_intArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_intArray_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_intArray_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< int >::ReadWrite(bool)\n" - " mfem::Array< int >::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_intArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; @@ -6666,7 +6281,7 @@ SWIGINTERN PyObject *_wrap_intArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -6677,20 +6292,25 @@ SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intArray___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:intArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___setitem__" "', argument " "1"" of type '" "mfem::Array< int > *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___setitem__" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray___setitem__" "', argument " "3"" of type '" "int""'"); } @@ -6718,7 +6338,7 @@ SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; int arg2 ; @@ -6726,16 +6346,20 @@ SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "intArray___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___getitem__" "', argument " "1"" of type '" "mfem::Array< int > const *""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___getitem__" "', argument " "2"" of type '" "int""'"); } @@ -6892,11 +6516,11 @@ SWIGINTERN PyObject *_wrap_intArray_FakeToList(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -6905,7 +6529,7 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self) int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -6916,60 +6540,16 @@ SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_int_Sg__Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Print" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Print" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Array_Sl_int_Sg__Print__SWIG_3(arg1,(char const *)arg2); + mfem_Array_Sl_int_Sg__Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7000,34 +6580,15 @@ SWIGINTERN PyObject *_wrap_intArray_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "intArray_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_intArray_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_intArray_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_intArray_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -7038,51 +6599,37 @@ SWIGINTERN PyObject *_wrap_intArray_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_intArray_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_intArray_Print__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_intArray_Print__SWIG_3(self, argc, argv); + return _wrap_intArray_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_intArray_Print__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_intArray_Print__SWIG_0(self, argc, argv); + return _wrap_intArray_Print__SWIG_1(self, argc, argv); } } } @@ -7092,79 +6639,25 @@ SWIGINTERN PyObject *_wrap_intArray_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< int >::Print(std::ostream &,int) const\n" - " mfem::Array< int >::Print(std::ostream &) const\n" - " mfem::Array< int >::Print() const\n" - " mfem::Array< int >::Print(char const *,int)\n" - " mfem::Array< int >::Print(char const *)\n"); + " mfem::Array< int >::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; int val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_int_Sg__Save__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + int ecode3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_Save" "', argument " "1"" of type '" "mfem::Array< int > *""'"); @@ -7175,9 +6668,16 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "intArray_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - mfem_Array_Sl_int_Sg__Save__SWIG_2(arg1,(char const *)arg2); + mfem_Array_Sl_int_Sg__Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7200,7 +6700,7 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = (mfem::Array< int > *) 0 ; void *argp1 = 0 ; @@ -7214,7 +6714,7 @@ SWIGINTERN PyObject *_wrap_intArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(self), arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { try { - mfem_Array_Sl_int_Sg__Save__SWIG_4(arg1); + mfem_Array_Sl_int_Sg__Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7249,10 +6749,10 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_intArray_Save__SWIG_4(self, argc, argv); + return _wrap_intArray_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); @@ -7261,50 +6761,20 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_intArray_Save__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_intArray_Save__SWIG_1(self, argc, argv); } - } - if (_v) { - return _wrap_intArray_Save__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_intArray_Save__SWIG_2(self, argc, argv); + return _wrap_intArray_Save__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); @@ -7320,6 +6790,9 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_intArray_Save__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -7335,9 +6808,7 @@ SWIGINTERN PyObject *_wrap_intArray_Save(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'intArray_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< int >::Save(std::ostream &,int) const\n" - " mfem::Array< int >::Save(std::ostream &) const\n" " mfem::Array< int >::Save(char const *,int)\n" - " mfem::Array< int >::Save(char const *)\n" " mfem::Array< int >::Save()\n"); return 0; } @@ -7937,7 +7408,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_OwnsData(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double **arg2 = (double **) 0 ; @@ -7945,15 +7416,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_StealData(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_StealData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_StealData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_StealData" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_StealData" "', argument " "2"" of type '" "double **""'"); } @@ -8354,7 +7829,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Capacity(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -8362,15 +7837,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_Reserve(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"capacity", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Reserve", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Reserve", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Reserve" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Reserve" "', argument " "2"" of type '" "int""'"); } @@ -8610,7 +8089,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Append(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_doubleArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8619,16 +8098,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Prepend(PyObject *SWIGUNUSEDPARM(self), P double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Prepend", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Prepend", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Prepend" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Prepend" "', argument " "2"" of type '" "double""'"); } @@ -8765,7 +8248,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Last(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8774,16 +8257,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyO double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Union", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Union", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Union" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Union" "', argument " "2"" of type '" "double""'"); } @@ -8812,7 +8299,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Union(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8821,16 +8308,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyOb double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Find", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Find", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Find" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Find" "', argument " "2"" of type '" "double""'"); } @@ -8859,7 +8350,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Find(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_doubleArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_FindSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8868,16 +8359,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_FindSorted(PyObject *SWIGUNUSEDPARM(self) double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_FindSorted", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_FindSorted", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_FindSorted" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_FindSorted" "', argument " "2"" of type '" "double""'"); } @@ -8943,7 +8438,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_DeleteLast(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_doubleArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; double *arg2 = 0 ; @@ -8952,15 +8447,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_DeleteFirst(PyObject *SWIGUNUSEDPARM(self double temp2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_DeleteFirst", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_DeleteFirst", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_DeleteFirst" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_DeleteFirst" "', argument " "2"" of type '" "double""'"); } @@ -9026,7 +8525,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_DeleteAll(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; mfem::Array< double > *arg2 = 0 ; @@ -9034,15 +8533,19 @@ SWIGINTERN PyObject *_wrap_doubleArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Copy" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Copy" "', argument " "2"" of type '" "mfem::Array< double > &""'"); } @@ -9221,7 +8724,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_MakeRef(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -9235,25 +8738,31 @@ SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"sa_size", (char *)"sa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray_GetSubArray", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:doubleArray_GetSubArray", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_GetSubArray" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_GetSubArray" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_GetSubArray" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "doubleArray_GetSubArray" "', argument " "4"" of type '" "mfem::Array< double > &""'"); } @@ -9287,8 +8796,9 @@ SWIGINTERN PyObject *_wrap_doubleArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; @@ -9296,98 +8806,39 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(se int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - ((mfem::Array< double > const *)arg1)->Print(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } { try { - ((mfem::Array< double > const *)arg1)->Print(*arg2); + ((mfem::Array< double > const *)arg1)->Print(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9418,46 +8869,11 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - try { - ((mfem::Array< double > const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; std::ostream *arg2 = 0 ; - int arg3 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; @@ -9465,75 +8881,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(sel int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - ((mfem::Array< double > const *)arg1)->Save(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); @@ -9554,9 +8902,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(sel arg2 = &out2; } } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { - ((mfem::Array< double > const *)arg1)->Save(*arg2); + ((mfem::Array< double > const *)arg1)->Save(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9591,7 +8946,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; std::istream *arg2 = 0 ; - int arg3 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9599,7 +8954,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Load" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -9613,11 +8968,13 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "doubleArray_Load" "', argument " "2"" of type '" "std::istream &""'"); } arg2 = reinterpret_cast< std::istream * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Load" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Load" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { (arg1)->Load(*arg2,arg3); @@ -9642,52 +8999,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - std::istream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Load" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "doubleArray_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - try { - (arg1)->Load(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -9749,21 +9060,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Load", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Load__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); @@ -9773,6 +9070,9 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Load__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -9798,7 +9098,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_doubleArray_Load__SWIG_2(self, argc, argv); + return _wrap_doubleArray_Load__SWIG_1(self, argc, argv); } } } @@ -9808,7 +9108,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_Load(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Load'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< double >::Load(std::istream &,int)\n" - " mfem::Array< double >::Load(std::istream &)\n" " mfem::Array< double >::Load(int,std::istream &)\n"); return 0; } @@ -10374,66 +9673,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_doubleArray_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:doubleArray_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Read" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::Array< double > const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Read" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); { try { - result = (double *)((mfem::Array< double > const *)arg1)->Read(); + result = (double *)((mfem::Array< double > const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10454,48 +9724,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_doubleArray_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_doubleArray_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::Read(bool) const\n" - " mfem::Array< double >::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_doubleArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; @@ -10534,146 +9762,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_HostRead(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Write" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Write" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - { - try { - result = (double *)(arg1)->Write(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_doubleArray_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::Write(bool)\n" - " mfem::Array< double >::Write()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; double *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:doubleArray_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_HostWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Write" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->HostWrite(); + result = (double *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10694,30 +9813,24 @@ SWIGINTERN PyObject *_wrap_doubleArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + PyObject *swig_obj[1] ; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_HostWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { try { - result = (double *)(arg1)->ReadWrite(arg2); + result = (double *)(arg1)->HostWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10738,22 +9851,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:doubleArray_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10774,48 +9902,6 @@ SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_doubleArray_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_doubleArray_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< double >::ReadWrite(bool)\n" - " mfem::Array< double >::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_doubleArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; @@ -10854,7 +9940,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -10865,20 +9951,25 @@ SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doubleArray___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:doubleArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___setitem__" "', argument " "1"" of type '" "mfem::Array< double > *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___setitem__" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray___setitem__" "', argument " "3"" of type '" "double""'"); } @@ -10906,7 +9997,7 @@ SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; int arg2 ; @@ -10914,16 +10005,20 @@ SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "doubleArray___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___getitem__" "', argument " "1"" of type '" "mfem::Array< double > const *""'"); } arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___getitem__" "', argument " "2"" of type '" "int""'"); } @@ -11080,11 +10175,11 @@ SWIGINTERN PyObject *_wrap_doubleArray_FakeToList(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11093,7 +10188,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(se int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -11104,60 +10199,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_double_Sg__Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Print" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Print" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Print" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Array_Sl_double_Sg__Print__SWIG_3(arg1,(char const *)arg2); + mfem_Array_Sl_double_Sg__Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11188,34 +10239,15 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "doubleArray_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_doubleArray_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -11226,51 +10258,37 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_doubleArray_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_doubleArray_Print__SWIG_3(self, argc, argv); + return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Print__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_doubleArray_Print__SWIG_0(self, argc, argv); + return _wrap_doubleArray_Print__SWIG_1(self, argc, argv); } } } @@ -11280,19 +10298,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< double >::Print(std::ostream &,int) const\n" - " mfem::Array< double >::Print(std::ostream &) const\n" - " mfem::Array< double >::Print() const\n" - " mfem::Array< double >::Print(char const *,int)\n" - " mfem::Array< double >::Print(char const *)\n"); + " mfem::Array< double >::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; @@ -11301,7 +10316,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(sel int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > *""'"); @@ -11312,60 +10327,16 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem_Array_Sl_double_Sg__Save__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_Save" "', argument " "1"" of type '" "mfem::Array< double > *""'"); - } - arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "doubleArray_Save" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray_Save" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Array_Sl_double_Sg__Save__SWIG_2(arg1,(char const *)arg2); + mfem_Array_Sl_double_Sg__Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11388,7 +10359,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< double > *arg1 = (mfem::Array< double > *) 0 ; void *argp1 = 0 ; @@ -11402,7 +10373,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save__SWIG_4(PyObject *SWIGUNUSEDPARM(sel arg1 = reinterpret_cast< mfem::Array< double > * >(argp1); { try { - mfem_Array_Sl_double_Sg__Save__SWIG_4(arg1); + mfem_Array_Sl_double_Sg__Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11437,10 +10408,10 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_doubleArray_Save__SWIG_4(self, argc, argv); + return _wrap_doubleArray_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); @@ -11449,50 +10420,20 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_doubleArray_Save__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_doubleArray_Save__SWIG_1(self, argc, argv); } - } - if (_v) { - return _wrap_doubleArray_Save__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_doubleArray_Save__SWIG_2(self, argc, argv); + return _wrap_doubleArray_Save__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, 0); @@ -11508,6 +10449,9 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_doubleArray_Save__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -11523,9 +10467,7 @@ SWIGINTERN PyObject *_wrap_doubleArray_Save(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'doubleArray_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::Array< double >::Save(std::ostream &,int) const\n" - " mfem::Array< double >::Save(std::ostream &) const\n" " mfem::Array< double >::Save(char const *,int)\n" - " mfem::Array< double >::Save(char const *)\n" " mfem::Array< double >::Save()\n"); return 0; } @@ -11979,7 +10921,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "intArray_UseDevice", _wrap_intArray_UseDevice, METH_O, "intArray_UseDevice(intArray self) -> bool"}, { "intArray_OwnsData", _wrap_intArray_OwnsData, METH_O, "intArray_OwnsData(intArray self) -> bool"}, - { "intArray_StealData", _wrap_intArray_StealData, METH_VARARGS, "intArray_StealData(intArray self, int ** p)"}, + { "intArray_StealData", (PyCFunction)(void(*)(void))_wrap_intArray_StealData, METH_VARARGS|METH_KEYWORDS, "intArray_StealData(intArray self, int ** p)"}, { "intArray_LoseData", _wrap_intArray_LoseData, METH_O, "intArray_LoseData(intArray self)"}, { "intArray_MakeDataOwner", _wrap_intArray_MakeDataOwner, METH_O, "intArray_MakeDataOwner(intArray self)"}, { "intArray_Size", _wrap_intArray_Size, METH_O, "intArray_Size(intArray self) -> int"}, @@ -11989,29 +10931,29 @@ static PyMethodDef SwigMethods[] = { "intArray_SetSize(intArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "intArray_Capacity", _wrap_intArray_Capacity, METH_O, "intArray_Capacity(intArray self) -> int"}, - { "intArray_Reserve", _wrap_intArray_Reserve, METH_VARARGS, "intArray_Reserve(intArray self, int capacity)"}, + { "intArray_Reserve", (PyCFunction)(void(*)(void))_wrap_intArray_Reserve, METH_VARARGS|METH_KEYWORDS, "intArray_Reserve(intArray self, int capacity)"}, { "intArray_Append", _wrap_intArray_Append, METH_VARARGS, "\n" "intArray_Append(intArray self, int const & el) -> int\n" "intArray_Append(intArray self, int const * els, int nels) -> int\n" "intArray_Append(intArray self, intArray els) -> int\n" ""}, - { "intArray_Prepend", _wrap_intArray_Prepend, METH_VARARGS, "intArray_Prepend(intArray self, int const & el) -> int"}, + { "intArray_Prepend", (PyCFunction)(void(*)(void))_wrap_intArray_Prepend, METH_VARARGS|METH_KEYWORDS, "intArray_Prepend(intArray self, int const & el) -> int"}, { "intArray_Last", _wrap_intArray_Last, METH_VARARGS, "\n" "intArray_Last(intArray self) -> int\n" "intArray_Last(intArray self) -> int const &\n" ""}, - { "intArray_Union", _wrap_intArray_Union, METH_VARARGS, "intArray_Union(intArray self, int const & el) -> int"}, - { "intArray_Find", _wrap_intArray_Find, METH_VARARGS, "intArray_Find(intArray self, int const & el) -> int"}, - { "intArray_FindSorted", _wrap_intArray_FindSorted, METH_VARARGS, "intArray_FindSorted(intArray self, int const & el) -> int"}, + { "intArray_Union", (PyCFunction)(void(*)(void))_wrap_intArray_Union, METH_VARARGS|METH_KEYWORDS, "intArray_Union(intArray self, int const & el) -> int"}, + { "intArray_Find", (PyCFunction)(void(*)(void))_wrap_intArray_Find, METH_VARARGS|METH_KEYWORDS, "intArray_Find(intArray self, int const & el) -> int"}, + { "intArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_intArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "intArray_FindSorted(intArray self, int const & el) -> int"}, { "intArray_DeleteLast", _wrap_intArray_DeleteLast, METH_O, "intArray_DeleteLast(intArray self)"}, - { "intArray_DeleteFirst", _wrap_intArray_DeleteFirst, METH_VARARGS, "intArray_DeleteFirst(intArray self, int const & el)"}, + { "intArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_intArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "intArray_DeleteFirst(intArray self, int const & el)"}, { "intArray_DeleteAll", _wrap_intArray_DeleteAll, METH_O, "intArray_DeleteAll(intArray self)"}, - { "intArray_Copy", _wrap_intArray_Copy, METH_VARARGS, "intArray_Copy(intArray self, intArray copy)"}, + { "intArray_Copy", (PyCFunction)(void(*)(void))_wrap_intArray_Copy, METH_VARARGS|METH_KEYWORDS, "intArray_Copy(intArray self, intArray copy)"}, { "intArray_MakeRef", _wrap_intArray_MakeRef, METH_VARARGS, "\n" "intArray_MakeRef(intArray self, int * arg2, int arg3)\n" "intArray_MakeRef(intArray self, intArray master)\n" ""}, - { "intArray_GetSubArray", _wrap_intArray_GetSubArray, METH_VARARGS, "intArray_GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, + { "intArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_intArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "intArray_GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, { "intArray_Load", _wrap_intArray_Load, METH_VARARGS, "\n" "intArray_Load(intArray self, std::istream & _in, int fmt=0)\n" "intArray_Load(intArray self, int new_size, std::istream & _in)\n" @@ -12032,14 +10974,14 @@ static PyMethodDef SwigMethods[] = { "intArray_end(intArray self) -> int const *\n" ""}, { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "intArray_MemoryUsage(intArray self) -> long"}, - { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "intArray_Read(intArray self, bool on_dev=True) -> int const"}, + { "intArray_Read", (PyCFunction)(void(*)(void))_wrap_intArray_Read, METH_VARARGS|METH_KEYWORDS, "intArray_Read(intArray self, bool on_dev=True) -> int const *"}, { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "intArray_HostRead(intArray self) -> int const *"}, - { "intArray_Write", _wrap_intArray_Write, METH_VARARGS, "intArray_Write(intArray self, bool on_dev=True) -> int"}, + { "intArray_Write", (PyCFunction)(void(*)(void))_wrap_intArray_Write, METH_VARARGS|METH_KEYWORDS, "intArray_Write(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostWrite", _wrap_intArray_HostWrite, METH_O, "intArray_HostWrite(intArray self) -> int *"}, - { "intArray_ReadWrite", _wrap_intArray_ReadWrite, METH_VARARGS, "intArray_ReadWrite(intArray self, bool on_dev=True) -> int"}, + { "intArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_intArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "intArray_ReadWrite(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostReadWrite", _wrap_intArray_HostReadWrite, METH_O, "intArray_HostReadWrite(intArray self) -> int *"}, - { "intArray___setitem__", _wrap_intArray___setitem__, METH_VARARGS, "intArray___setitem__(intArray self, int i, int const v)"}, - { "intArray___getitem__", _wrap_intArray___getitem__, METH_VARARGS, "intArray___getitem__(intArray self, int const i) -> int const &"}, + { "intArray___setitem__", (PyCFunction)(void(*)(void))_wrap_intArray___setitem__, METH_VARARGS|METH_KEYWORDS, "intArray___setitem__(intArray self, int i, int const v)"}, + { "intArray___getitem__", (PyCFunction)(void(*)(void))_wrap_intArray___getitem__, METH_VARARGS|METH_KEYWORDS, "intArray___getitem__(intArray self, int const i) -> int const &"}, { "intArray_Assign", _wrap_intArray_Assign, METH_VARARGS, "\n" "intArray_Assign(intArray self, int const * arg2)\n" "intArray_Assign(intArray self, int const & a)\n" @@ -12074,7 +11016,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "doubleArray_UseDevice", _wrap_doubleArray_UseDevice, METH_O, "doubleArray_UseDevice(doubleArray self) -> bool"}, { "doubleArray_OwnsData", _wrap_doubleArray_OwnsData, METH_O, "doubleArray_OwnsData(doubleArray self) -> bool"}, - { "doubleArray_StealData", _wrap_doubleArray_StealData, METH_VARARGS, "doubleArray_StealData(doubleArray self, double ** p)"}, + { "doubleArray_StealData", (PyCFunction)(void(*)(void))_wrap_doubleArray_StealData, METH_VARARGS|METH_KEYWORDS, "doubleArray_StealData(doubleArray self, double ** p)"}, { "doubleArray_LoseData", _wrap_doubleArray_LoseData, METH_O, "doubleArray_LoseData(doubleArray self)"}, { "doubleArray_MakeDataOwner", _wrap_doubleArray_MakeDataOwner, METH_O, "doubleArray_MakeDataOwner(doubleArray self)"}, { "doubleArray_Size", _wrap_doubleArray_Size, METH_O, "doubleArray_Size(doubleArray self) -> int"}, @@ -12084,29 +11026,29 @@ static PyMethodDef SwigMethods[] = { "doubleArray_SetSize(doubleArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "doubleArray_Capacity", _wrap_doubleArray_Capacity, METH_O, "doubleArray_Capacity(doubleArray self) -> int"}, - { "doubleArray_Reserve", _wrap_doubleArray_Reserve, METH_VARARGS, "doubleArray_Reserve(doubleArray self, int capacity)"}, + { "doubleArray_Reserve", (PyCFunction)(void(*)(void))_wrap_doubleArray_Reserve, METH_VARARGS|METH_KEYWORDS, "doubleArray_Reserve(doubleArray self, int capacity)"}, { "doubleArray_Append", _wrap_doubleArray_Append, METH_VARARGS, "\n" "doubleArray_Append(doubleArray self, double const & el) -> int\n" "doubleArray_Append(doubleArray self, double const * els, int nels) -> int\n" "doubleArray_Append(doubleArray self, doubleArray els) -> int\n" ""}, - { "doubleArray_Prepend", _wrap_doubleArray_Prepend, METH_VARARGS, "doubleArray_Prepend(doubleArray self, double const & el) -> int"}, + { "doubleArray_Prepend", (PyCFunction)(void(*)(void))_wrap_doubleArray_Prepend, METH_VARARGS|METH_KEYWORDS, "doubleArray_Prepend(doubleArray self, double const & el) -> int"}, { "doubleArray_Last", _wrap_doubleArray_Last, METH_VARARGS, "\n" "doubleArray_Last(doubleArray self) -> double\n" "doubleArray_Last(doubleArray self) -> double const &\n" ""}, - { "doubleArray_Union", _wrap_doubleArray_Union, METH_VARARGS, "doubleArray_Union(doubleArray self, double const & el) -> int"}, - { "doubleArray_Find", _wrap_doubleArray_Find, METH_VARARGS, "doubleArray_Find(doubleArray self, double const & el) -> int"}, - { "doubleArray_FindSorted", _wrap_doubleArray_FindSorted, METH_VARARGS, "doubleArray_FindSorted(doubleArray self, double const & el) -> int"}, + { "doubleArray_Union", (PyCFunction)(void(*)(void))_wrap_doubleArray_Union, METH_VARARGS|METH_KEYWORDS, "doubleArray_Union(doubleArray self, double const & el) -> int"}, + { "doubleArray_Find", (PyCFunction)(void(*)(void))_wrap_doubleArray_Find, METH_VARARGS|METH_KEYWORDS, "doubleArray_Find(doubleArray self, double const & el) -> int"}, + { "doubleArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_doubleArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "doubleArray_FindSorted(doubleArray self, double const & el) -> int"}, { "doubleArray_DeleteLast", _wrap_doubleArray_DeleteLast, METH_O, "doubleArray_DeleteLast(doubleArray self)"}, - { "doubleArray_DeleteFirst", _wrap_doubleArray_DeleteFirst, METH_VARARGS, "doubleArray_DeleteFirst(doubleArray self, double const & el)"}, + { "doubleArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_doubleArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "doubleArray_DeleteFirst(doubleArray self, double const & el)"}, { "doubleArray_DeleteAll", _wrap_doubleArray_DeleteAll, METH_O, "doubleArray_DeleteAll(doubleArray self)"}, - { "doubleArray_Copy", _wrap_doubleArray_Copy, METH_VARARGS, "doubleArray_Copy(doubleArray self, doubleArray copy)"}, + { "doubleArray_Copy", (PyCFunction)(void(*)(void))_wrap_doubleArray_Copy, METH_VARARGS|METH_KEYWORDS, "doubleArray_Copy(doubleArray self, doubleArray copy)"}, { "doubleArray_MakeRef", _wrap_doubleArray_MakeRef, METH_VARARGS, "\n" "doubleArray_MakeRef(doubleArray self, double * arg2, int arg3)\n" "doubleArray_MakeRef(doubleArray self, doubleArray master)\n" ""}, - { "doubleArray_GetSubArray", _wrap_doubleArray_GetSubArray, METH_VARARGS, "doubleArray_GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, + { "doubleArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_doubleArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "doubleArray_GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, { "doubleArray_Load", _wrap_doubleArray_Load, METH_VARARGS, "\n" "doubleArray_Load(doubleArray self, std::istream & _in, int fmt=0)\n" "doubleArray_Load(doubleArray self, int new_size, std::istream & _in)\n" @@ -12127,14 +11069,14 @@ static PyMethodDef SwigMethods[] = { "doubleArray_end(doubleArray self) -> double const *\n" ""}, { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "doubleArray_MemoryUsage(doubleArray self) -> long"}, - { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "doubleArray_Read(doubleArray self, bool on_dev=True) -> double const"}, + { "doubleArray_Read", (PyCFunction)(void(*)(void))_wrap_doubleArray_Read, METH_VARARGS|METH_KEYWORDS, "doubleArray_Read(doubleArray self, bool on_dev=True) -> double const *"}, { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "doubleArray_HostRead(doubleArray self) -> double const *"}, - { "doubleArray_Write", _wrap_doubleArray_Write, METH_VARARGS, "doubleArray_Write(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_Write", (PyCFunction)(void(*)(void))_wrap_doubleArray_Write, METH_VARARGS|METH_KEYWORDS, "doubleArray_Write(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostWrite", _wrap_doubleArray_HostWrite, METH_O, "doubleArray_HostWrite(doubleArray self) -> double *"}, - { "doubleArray_ReadWrite", _wrap_doubleArray_ReadWrite, METH_VARARGS, "doubleArray_ReadWrite(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_doubleArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "doubleArray_ReadWrite(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostReadWrite", _wrap_doubleArray_HostReadWrite, METH_O, "doubleArray_HostReadWrite(doubleArray self) -> double *"}, - { "doubleArray___setitem__", _wrap_doubleArray___setitem__, METH_VARARGS, "doubleArray___setitem__(doubleArray self, int i, double const v)"}, - { "doubleArray___getitem__", _wrap_doubleArray___getitem__, METH_VARARGS, "doubleArray___getitem__(doubleArray self, int const i) -> double const &"}, + { "doubleArray___setitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___setitem__, METH_VARARGS|METH_KEYWORDS, "doubleArray___setitem__(doubleArray self, int i, double const v)"}, + { "doubleArray___getitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___getitem__, METH_VARARGS|METH_KEYWORDS, "doubleArray___getitem__(doubleArray self, int const i) -> double const &"}, { "doubleArray_Assign", _wrap_doubleArray_Assign, METH_VARARGS, "\n" "doubleArray_Assign(doubleArray self, double const * arg2)\n" "doubleArray_Assign(doubleArray self, double const & a)\n" @@ -12185,7 +11127,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "intArray_UseDevice", _wrap_intArray_UseDevice, METH_O, "UseDevice(intArray self) -> bool"}, { "intArray_OwnsData", _wrap_intArray_OwnsData, METH_O, "OwnsData(intArray self) -> bool"}, - { "intArray_StealData", _wrap_intArray_StealData, METH_VARARGS, "StealData(intArray self, int ** p)"}, + { "intArray_StealData", (PyCFunction)(void(*)(void))_wrap_intArray_StealData, METH_VARARGS|METH_KEYWORDS, "StealData(intArray self, int ** p)"}, { "intArray_LoseData", _wrap_intArray_LoseData, METH_O, "LoseData(intArray self)"}, { "intArray_MakeDataOwner", _wrap_intArray_MakeDataOwner, METH_O, "MakeDataOwner(intArray self)"}, { "intArray_Size", _wrap_intArray_Size, METH_O, "Size(intArray self) -> int"}, @@ -12195,29 +11137,29 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(intArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "intArray_Capacity", _wrap_intArray_Capacity, METH_O, "Capacity(intArray self) -> int"}, - { "intArray_Reserve", _wrap_intArray_Reserve, METH_VARARGS, "Reserve(intArray self, int capacity)"}, + { "intArray_Reserve", (PyCFunction)(void(*)(void))_wrap_intArray_Reserve, METH_VARARGS|METH_KEYWORDS, "Reserve(intArray self, int capacity)"}, { "intArray_Append", _wrap_intArray_Append, METH_VARARGS, "\n" "Append(intArray self, int const & el) -> int\n" "Append(intArray self, int const * els, int nels) -> int\n" "Append(intArray self, intArray els) -> int\n" ""}, - { "intArray_Prepend", _wrap_intArray_Prepend, METH_VARARGS, "Prepend(intArray self, int const & el) -> int"}, + { "intArray_Prepend", (PyCFunction)(void(*)(void))_wrap_intArray_Prepend, METH_VARARGS|METH_KEYWORDS, "Prepend(intArray self, int const & el) -> int"}, { "intArray_Last", _wrap_intArray_Last, METH_VARARGS, "\n" "Last(intArray self) -> int\n" "Last(intArray self) -> int const &\n" ""}, - { "intArray_Union", _wrap_intArray_Union, METH_VARARGS, "Union(intArray self, int const & el) -> int"}, - { "intArray_Find", _wrap_intArray_Find, METH_VARARGS, "Find(intArray self, int const & el) -> int"}, - { "intArray_FindSorted", _wrap_intArray_FindSorted, METH_VARARGS, "FindSorted(intArray self, int const & el) -> int"}, + { "intArray_Union", (PyCFunction)(void(*)(void))_wrap_intArray_Union, METH_VARARGS|METH_KEYWORDS, "Union(intArray self, int const & el) -> int"}, + { "intArray_Find", (PyCFunction)(void(*)(void))_wrap_intArray_Find, METH_VARARGS|METH_KEYWORDS, "Find(intArray self, int const & el) -> int"}, + { "intArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_intArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "FindSorted(intArray self, int const & el) -> int"}, { "intArray_DeleteLast", _wrap_intArray_DeleteLast, METH_O, "DeleteLast(intArray self)"}, - { "intArray_DeleteFirst", _wrap_intArray_DeleteFirst, METH_VARARGS, "DeleteFirst(intArray self, int const & el)"}, + { "intArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_intArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "DeleteFirst(intArray self, int const & el)"}, { "intArray_DeleteAll", _wrap_intArray_DeleteAll, METH_O, "DeleteAll(intArray self)"}, - { "intArray_Copy", _wrap_intArray_Copy, METH_VARARGS, "Copy(intArray self, intArray copy)"}, + { "intArray_Copy", (PyCFunction)(void(*)(void))_wrap_intArray_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(intArray self, intArray copy)"}, { "intArray_MakeRef", _wrap_intArray_MakeRef, METH_VARARGS, "\n" "MakeRef(intArray self, int * arg2, int arg3)\n" "MakeRef(intArray self, intArray master)\n" ""}, - { "intArray_GetSubArray", _wrap_intArray_GetSubArray, METH_VARARGS, "GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, + { "intArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_intArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "GetSubArray(intArray self, int offset, int sa_size, intArray sa)"}, { "intArray_Load", _wrap_intArray_Load, METH_VARARGS, "\n" "Load(intArray self, std::istream & _in, int fmt=0)\n" "Load(intArray self, int new_size, std::istream & _in)\n" @@ -12238,14 +11180,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "end(intArray self) -> int const *\n" ""}, { "intArray_MemoryUsage", _wrap_intArray_MemoryUsage, METH_O, "MemoryUsage(intArray self) -> long"}, - { "intArray_Read", _wrap_intArray_Read, METH_VARARGS, "Read(intArray self, bool on_dev=True) -> int const"}, + { "intArray_Read", (PyCFunction)(void(*)(void))_wrap_intArray_Read, METH_VARARGS|METH_KEYWORDS, "Read(intArray self, bool on_dev=True) -> int const *"}, { "intArray_HostRead", _wrap_intArray_HostRead, METH_O, "HostRead(intArray self) -> int const *"}, - { "intArray_Write", _wrap_intArray_Write, METH_VARARGS, "Write(intArray self, bool on_dev=True) -> int"}, + { "intArray_Write", (PyCFunction)(void(*)(void))_wrap_intArray_Write, METH_VARARGS|METH_KEYWORDS, "Write(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostWrite", _wrap_intArray_HostWrite, METH_O, "HostWrite(intArray self) -> int *"}, - { "intArray_ReadWrite", _wrap_intArray_ReadWrite, METH_VARARGS, "ReadWrite(intArray self, bool on_dev=True) -> int"}, + { "intArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_intArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(intArray self, bool on_dev=True) -> int *"}, { "intArray_HostReadWrite", _wrap_intArray_HostReadWrite, METH_O, "HostReadWrite(intArray self) -> int *"}, - { "intArray___setitem__", _wrap_intArray___setitem__, METH_VARARGS, "__setitem__(intArray self, int i, int const v)"}, - { "intArray___getitem__", _wrap_intArray___getitem__, METH_VARARGS, "__getitem__(intArray self, int const i) -> int const &"}, + { "intArray___setitem__", (PyCFunction)(void(*)(void))_wrap_intArray___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(intArray self, int i, int const v)"}, + { "intArray___getitem__", (PyCFunction)(void(*)(void))_wrap_intArray___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(intArray self, int const i) -> int const &"}, { "intArray_Assign", _wrap_intArray_Assign, METH_VARARGS, "\n" "Assign(intArray self, int const * arg2)\n" "Assign(intArray self, int const & a)\n" @@ -12280,7 +11222,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "doubleArray_UseDevice", _wrap_doubleArray_UseDevice, METH_O, "UseDevice(doubleArray self) -> bool"}, { "doubleArray_OwnsData", _wrap_doubleArray_OwnsData, METH_O, "OwnsData(doubleArray self) -> bool"}, - { "doubleArray_StealData", _wrap_doubleArray_StealData, METH_VARARGS, "StealData(doubleArray self, double ** p)"}, + { "doubleArray_StealData", (PyCFunction)(void(*)(void))_wrap_doubleArray_StealData, METH_VARARGS|METH_KEYWORDS, "StealData(doubleArray self, double ** p)"}, { "doubleArray_LoseData", _wrap_doubleArray_LoseData, METH_O, "LoseData(doubleArray self)"}, { "doubleArray_MakeDataOwner", _wrap_doubleArray_MakeDataOwner, METH_O, "MakeDataOwner(doubleArray self)"}, { "doubleArray_Size", _wrap_doubleArray_Size, METH_O, "Size(doubleArray self) -> int"}, @@ -12290,29 +11232,29 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(doubleArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "doubleArray_Capacity", _wrap_doubleArray_Capacity, METH_O, "Capacity(doubleArray self) -> int"}, - { "doubleArray_Reserve", _wrap_doubleArray_Reserve, METH_VARARGS, "Reserve(doubleArray self, int capacity)"}, + { "doubleArray_Reserve", (PyCFunction)(void(*)(void))_wrap_doubleArray_Reserve, METH_VARARGS|METH_KEYWORDS, "Reserve(doubleArray self, int capacity)"}, { "doubleArray_Append", _wrap_doubleArray_Append, METH_VARARGS, "\n" "Append(doubleArray self, double const & el) -> int\n" "Append(doubleArray self, double const * els, int nels) -> int\n" "Append(doubleArray self, doubleArray els) -> int\n" ""}, - { "doubleArray_Prepend", _wrap_doubleArray_Prepend, METH_VARARGS, "Prepend(doubleArray self, double const & el) -> int"}, + { "doubleArray_Prepend", (PyCFunction)(void(*)(void))_wrap_doubleArray_Prepend, METH_VARARGS|METH_KEYWORDS, "Prepend(doubleArray self, double const & el) -> int"}, { "doubleArray_Last", _wrap_doubleArray_Last, METH_VARARGS, "\n" "Last(doubleArray self) -> double\n" "Last(doubleArray self) -> double const &\n" ""}, - { "doubleArray_Union", _wrap_doubleArray_Union, METH_VARARGS, "Union(doubleArray self, double const & el) -> int"}, - { "doubleArray_Find", _wrap_doubleArray_Find, METH_VARARGS, "Find(doubleArray self, double const & el) -> int"}, - { "doubleArray_FindSorted", _wrap_doubleArray_FindSorted, METH_VARARGS, "FindSorted(doubleArray self, double const & el) -> int"}, + { "doubleArray_Union", (PyCFunction)(void(*)(void))_wrap_doubleArray_Union, METH_VARARGS|METH_KEYWORDS, "Union(doubleArray self, double const & el) -> int"}, + { "doubleArray_Find", (PyCFunction)(void(*)(void))_wrap_doubleArray_Find, METH_VARARGS|METH_KEYWORDS, "Find(doubleArray self, double const & el) -> int"}, + { "doubleArray_FindSorted", (PyCFunction)(void(*)(void))_wrap_doubleArray_FindSorted, METH_VARARGS|METH_KEYWORDS, "FindSorted(doubleArray self, double const & el) -> int"}, { "doubleArray_DeleteLast", _wrap_doubleArray_DeleteLast, METH_O, "DeleteLast(doubleArray self)"}, - { "doubleArray_DeleteFirst", _wrap_doubleArray_DeleteFirst, METH_VARARGS, "DeleteFirst(doubleArray self, double const & el)"}, + { "doubleArray_DeleteFirst", (PyCFunction)(void(*)(void))_wrap_doubleArray_DeleteFirst, METH_VARARGS|METH_KEYWORDS, "DeleteFirst(doubleArray self, double const & el)"}, { "doubleArray_DeleteAll", _wrap_doubleArray_DeleteAll, METH_O, "DeleteAll(doubleArray self)"}, - { "doubleArray_Copy", _wrap_doubleArray_Copy, METH_VARARGS, "Copy(doubleArray self, doubleArray copy)"}, + { "doubleArray_Copy", (PyCFunction)(void(*)(void))_wrap_doubleArray_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(doubleArray self, doubleArray copy)"}, { "doubleArray_MakeRef", _wrap_doubleArray_MakeRef, METH_VARARGS, "\n" "MakeRef(doubleArray self, double * arg2, int arg3)\n" "MakeRef(doubleArray self, doubleArray master)\n" ""}, - { "doubleArray_GetSubArray", _wrap_doubleArray_GetSubArray, METH_VARARGS, "GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, + { "doubleArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_doubleArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "GetSubArray(doubleArray self, int offset, int sa_size, doubleArray sa)"}, { "doubleArray_Load", _wrap_doubleArray_Load, METH_VARARGS, "\n" "Load(doubleArray self, std::istream & _in, int fmt=0)\n" "Load(doubleArray self, int new_size, std::istream & _in)\n" @@ -12333,14 +11275,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "end(doubleArray self) -> double const *\n" ""}, { "doubleArray_MemoryUsage", _wrap_doubleArray_MemoryUsage, METH_O, "MemoryUsage(doubleArray self) -> long"}, - { "doubleArray_Read", _wrap_doubleArray_Read, METH_VARARGS, "Read(doubleArray self, bool on_dev=True) -> double const"}, + { "doubleArray_Read", (PyCFunction)(void(*)(void))_wrap_doubleArray_Read, METH_VARARGS|METH_KEYWORDS, "Read(doubleArray self, bool on_dev=True) -> double const *"}, { "doubleArray_HostRead", _wrap_doubleArray_HostRead, METH_O, "HostRead(doubleArray self) -> double const *"}, - { "doubleArray_Write", _wrap_doubleArray_Write, METH_VARARGS, "Write(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_Write", (PyCFunction)(void(*)(void))_wrap_doubleArray_Write, METH_VARARGS|METH_KEYWORDS, "Write(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostWrite", _wrap_doubleArray_HostWrite, METH_O, "HostWrite(doubleArray self) -> double *"}, - { "doubleArray_ReadWrite", _wrap_doubleArray_ReadWrite, METH_VARARGS, "ReadWrite(doubleArray self, bool on_dev=True) -> double"}, + { "doubleArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_doubleArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(doubleArray self, bool on_dev=True) -> double *"}, { "doubleArray_HostReadWrite", _wrap_doubleArray_HostReadWrite, METH_O, "HostReadWrite(doubleArray self) -> double *"}, - { "doubleArray___setitem__", _wrap_doubleArray___setitem__, METH_VARARGS, "__setitem__(doubleArray self, int i, double const v)"}, - { "doubleArray___getitem__", _wrap_doubleArray___getitem__, METH_VARARGS, "__getitem__(doubleArray self, int const i) -> double const &"}, + { "doubleArray___setitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(doubleArray self, int i, double const v)"}, + { "doubleArray___getitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(doubleArray self, int const i) -> double const &"}, { "doubleArray_Assign", _wrap_doubleArray_Assign, METH_VARARGS, "\n" "Assign(doubleArray self, double const * arg2)\n" "Assign(doubleArray self, double const & a)\n" diff --git a/mfem/_ser/bilinearform_wrap.cxx b/mfem/_ser/bilinearform_wrap.cxx index 3f3750c1..ac5495fd 100644 --- a/mfem/_ser/bilinearform_wrap.cxx +++ b/mfem/_ser/bilinearform_wrap.cxx @@ -4054,7 +4054,7 @@ void SwigDirector_BilinearForm::AddMult(mfem::Vector const &x, mfem::Vector &y, Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 16; + const size_t swig_method_index = 14; const char *const swig_method_name = "AddMult"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4084,7 +4084,7 @@ void SwigDirector_BilinearForm::AddMultTranspose(mfem::Vector const &x, mfem::Ve Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 18; + const size_t swig_method_index = 15; const char *const swig_method_name = "AddMultTranspose"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2, NULL); @@ -4122,7 +4122,7 @@ void SwigDirector_BilinearForm::FormLinearSystem(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 21; + const size_t swig_method_index = 16; const char *const swig_method_name = "FormLinearSystem"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3,(PyObject *)obj4,(PyObject *)obj5,(PyObject *)obj6, NULL); @@ -4150,7 +4150,7 @@ void SwigDirector_BilinearForm::FormSystemMatrix(mfem::Array< int > const &ess_t Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 23; + const size_t swig_method_index = 17; const char *const swig_method_name = "FormSystemMatrix"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1, NULL); @@ -4176,7 +4176,7 @@ void SwigDirector_BilinearForm::Update(mfem::FiniteElementSpace *nfes) { Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearForm.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 24; + const size_t swig_method_index = 18; const char *const swig_method_name = "Update"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0, NULL); @@ -4233,7 +4233,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -4241,15 +4241,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -4308,17 +4312,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -4377,7 +4383,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -4385,15 +4391,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -4452,17 +4462,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -4578,14 +4590,14 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(sel PyObject *arg1 = (PyObject *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; mfem::BilinearForm *arg3 = (mfem::BilinearForm *) 0 ; - int arg4 ; + int arg4 = (int) 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; mfem::BilinearForm *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { @@ -4597,11 +4609,13 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BilinearForm" "', argument " "3"" of type '" "mfem::BilinearForm *""'"); } arg3 = reinterpret_cast< mfem::BilinearForm * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { @@ -4635,61 +4649,6 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_2(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_BilinearForm__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - mfem::BilinearForm *arg3 = (mfem::BilinearForm *) 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::BilinearForm *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BilinearForm" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_BilinearForm" "', argument " "3"" of type '" "mfem::BilinearForm *""'"); - } - arg3 = reinterpret_cast< mfem::BilinearForm * >(argp3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::BilinearForm *)new SwigDirector_BilinearForm(arg1,arg2,arg3); - } else { - result = (mfem::BilinearForm *)new mfem::BilinearForm(arg2,arg3); - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { @@ -4717,24 +4676,7 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BilinearForm__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -4746,6 +4688,9 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_new_BilinearForm__SWIG_2(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4767,8 +4712,7 @@ SWIGINTERN PyObject *_wrap_new_BilinearForm(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::BilinearForm()\n" " mfem::BilinearForm::BilinearForm(mfem::FiniteElementSpace *)\n" - " mfem::BilinearForm::BilinearForm(mfem::FiniteElementSpace *,mfem::BilinearForm *,int)\n" - " mfem::BilinearForm::BilinearForm(PyObject *,mfem::FiniteElementSpace *,mfem::BilinearForm *)\n"); + " mfem::BilinearForm::BilinearForm(PyObject *,mfem::FiniteElementSpace *,mfem::BilinearForm *,int)\n"); return 0; } @@ -4814,7 +4758,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Size(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::AssemblyLevel arg2 ; @@ -4822,15 +4766,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPAR int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"assembly_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_SetAssemblyLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); } @@ -5024,7 +4972,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SCFESpace(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -5038,25 +4986,31 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"constr_space", (char *)"constr_integ", (char *)"ess_tdof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EnableHybridization", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearForm_EnableHybridization", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EnableHybridization" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EnableHybridization" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EnableHybridization" "', argument " "3"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg3 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EnableHybridization" "', argument " "4"" of type '" "mfem::Array< int > const &""'"); } @@ -5090,66 +5044,35 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EnableHybridization(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ps", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_UsePrecomputedSparsity", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_UsePrecomputedSparsity" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->UsePrecomputedSparsity(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_UsePrecomputedSparsity" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - (arg1)->UsePrecomputedSparsity(); + (arg1)->UsePrecomputedSparsity(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5173,52 +5096,6 @@ SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_BilinearForm_UsePrecomputedSparsity(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_UsePrecomputedSparsity", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_UsePrecomputedSparsity__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_UsePrecomputedSparsity__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_UsePrecomputedSparsity'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::UsePrecomputedSparsity(int)\n" - " mfem::BilinearForm::UsePrecomputedSparsity()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BilinearForm_UseSparsity__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -5673,33 +5550,38 @@ SWIGINTERN PyObject *_wrap_BilinearForm_GetBFBFI_Marker(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BilinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm___call__" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5939,7 +5821,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Elem(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5950,17 +5832,22 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Mult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5968,7 +5855,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5977,7 +5864,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6012,7 +5899,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6023,15 +5910,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6039,7 +5931,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6073,12 +5965,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullMult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6087,16 +5979,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BilinearForm_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6104,7 +6003,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6112,13 +6011,15 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6153,7 +6054,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6164,174 +6065,44 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - Swig::Director *director = 0; - bool upcall = false; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullAddMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullAddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - ((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::AddMult((mfem::Vector const &)*arg2,*arg3); - } else { - ((mfem::BilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); - } - } + { + try { + ((mfem::BilinearForm const *)arg1)->FullAddMult((mfem::Vector const &)*arg2,*arg3); + } #ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_BilinearForm_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullAddMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullAddMult" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::BilinearForm const *)arg1)->FullAddMult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } #endif @@ -6349,12 +6120,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMult(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6363,16 +6134,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGU int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BilinearForm_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6380,7 +6158,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6388,13 +6166,15 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6429,7 +6209,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6440,150 +6220,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - ((mfem::BilinearForm const *)arg1)->mfem::BilinearForm::AddMultTranspose((mfem::Vector const &)*arg2,*arg3); - } else { - ((mfem::BilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_BilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullAddMultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullAddMultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6591,7 +6241,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullAddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6625,7 +6275,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullAddMultTranspose(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6636,17 +6286,22 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6654,7 +6309,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6663,7 +6318,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6698,7 +6353,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6709,16 +6364,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_InnerProduct", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_InnerProduct", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_InnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6726,7 +6386,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_InnerProduct(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_InnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -6816,29 +6476,36 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_Finalize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Finalize" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6873,113 +6540,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_BilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_SpMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - Swig::Director *director = 0; - bool upcall = false; + mfem::SparseMatrix *result = 0 ; if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Finalize" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Finalize(); - } else { - (arg1)->Finalize(); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Finalize", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_Finalize__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_Finalize__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Finalize(int)\n" - " mfem::BilinearForm::Finalize()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_SpMat__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SpMat" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SpMat" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -7238,7 +6809,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SpMatElim(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_BilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -7246,15 +6817,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSED int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -7439,7 +7014,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddBoundaryIntegrator(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_BilinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -7447,15 +7022,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddInteriorFaceIntegrator(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AddInteriorFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_AddInteriorFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AddInteriorFaceIntegrator" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AddInteriorFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -7640,66 +7219,35 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AddBdrFaceIntegrator(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_BilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_Assemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_Assemble", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Assemble" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Assemble(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Assemble" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { try { - (arg1)->Assemble(); + (arg1)->Assemble(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7723,53 +7271,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_BilinearForm_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Assemble(int)\n" - " mfem::BilinearForm::Assemble()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7777,15 +7279,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleDiagonal(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleDiagonal", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_AssembleDiagonal", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_AssembleDiagonal" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8052,7 +7558,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU mfem::OperatorHandle *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8070,7 +7576,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8124,11 +7630,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + if (swig_obj[7]) { + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); + } } director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); @@ -8166,95 +7674,51 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_0(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::OperatorHandle *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; + mfem::OperatorHandle *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__OperatorHandle, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::OperatorHandle &""'"); - } - arg5 = reinterpret_cast< mfem::OperatorHandle * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); + arg3 = reinterpret_cast< mfem::OperatorHandle * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); upcall = (director && (director->swig_get_self()==swig_obj[0])); try { { try { if (upcall) { - (arg1)->mfem::BilinearForm::FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->mfem::BilinearForm::FormSystemMatrix((mfem::Array< int > const &)*arg2,*arg3); } else { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->FormSystemMatrix((mfem::Array< int > const &)*arg2,*arg3); } } #ifdef MFEM_USE_EXCEPTIONS @@ -8282,103 +7746,37 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::OperatorHandle *arg3 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"X", (char *)"b", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormSystemMatrix" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); - } - arg3 = reinterpret_cast< mfem::OperatorHandle * >(argp3); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::FormSystemMatrix((mfem::Array< int > const &)*arg2,*arg3); - } else { - (arg1)->FormSystemMatrix((mfem::Array< int > const &)*arg2,*arg3); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - Swig::Director *director = 0; - bool upcall = false; - - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_RecoverFEMSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearForm_RecoverFEMSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -8386,7 +7784,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -8394,7 +7792,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_RecoverFEMSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -8403,7 +7801,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_RecoverFEMSolution(PyObject *SWIGUNUSEDP } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -8518,7 +7916,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FreeElementMatrices(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; @@ -8527,21 +7925,26 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_ComputeElementMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_ComputeElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -8575,7 +7978,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; @@ -8584,21 +7987,26 @@ SWIGINTERN PyObject *_wrap_BilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_ComputeBdrElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -8637,13 +8045,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject * mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8663,11 +8071,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { @@ -8700,12 +8110,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -8725,9 +8139,25 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8751,24 +8181,116 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleElementMatrix", 0, 5, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); + } + } + } + } + } + if ((argc >= 4) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - int arg5 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -8779,29 +8301,23 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject * } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8825,12 +8341,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_2(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; mfem::Array< int > *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -8838,10 +8355,10 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject * void *argp4 = 0 ; int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); { @@ -8852,23 +8369,31 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject * } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8892,15 +8417,15 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix__SWIG_3(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleElementMatrix", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleBdrElementMatrix", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -8918,12 +8443,25 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, Py int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + if (argc <= 3) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + } } } } } - if (argc == 4) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -8945,469 +8483,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleElementMatrix(PyObject *self, Py int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleElementMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_AssembleBdrElementMatrix", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 4) { + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); } - } - if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -9417,7 +8495,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, } } if (_v) { - return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); + return _wrap_BilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); } } } @@ -9429,9 +8507,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_AssembleBdrElementMatrix(PyObject *self, SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_AssembleBdrElementMatrix'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n" - " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &)\n"); + " mfem::BilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,int)\n"); return 0; } @@ -9442,7 +8518,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *S mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9454,83 +8530,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_0(PyObject *S int val5 ; int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); - { - try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -9560,9 +8560,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9586,11 +8593,11 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9598,7 +8605,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *S int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -9612,63 +8619,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBC" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2); + (arg1)->EliminateEssentialBC((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9700,20 +8660,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBC", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -9722,39 +8669,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); - } + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -9770,6 +8698,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_EliminateEssentialBC__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); @@ -9787,14 +8718,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBC(PyObject *self, PyO SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBC'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateEssentialBC(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9805,15 +8734,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGU int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCDiag", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_EliminateEssentialBCDiag", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9821,7 +8755,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCDiag(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCDiag" "', argument " "3"" of type '" "double""'"); } @@ -9858,7 +8792,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9870,7 +8804,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU int val5 ; int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -9900,11 +8834,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateVDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); @@ -9935,78 +8871,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_1(PyObject *SWIGUNU PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10014,7 +8879,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -10028,63 +8893,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_2(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateVDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateVDofs((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10116,20 +8934,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofs", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -10138,39 +8943,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); - } + } + if (_v) { + return _wrap_BilinearForm_EliminateVDofs__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -10186,6 +8972,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_EliminateVDofs__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); @@ -10203,9 +8992,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofs(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateVDofs'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateVDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n"); return 0; } @@ -10216,7 +9003,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10228,7 +9015,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO int val5 ; int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -10258,11 +9045,13 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); @@ -10293,78 +9082,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(PyO PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10372,7 +9090,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyO int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -10386,63 +9104,16 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofs" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2); + (arg1)->EliminateEssentialBCFromDofs((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10474,20 +9145,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofs", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -10496,39 +9154,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); - } + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -10544,6 +9183,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_BilinearForm_EliminateEssentialBCFromDofs__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); @@ -10561,14 +9203,12 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofs(PyObject *s SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_EliminateEssentialBCFromDofs'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &)\n"); + " mfem::BilinearForm::EliminateEssentialBCFromDofs(mfem::Array< int > const &,mfem::Matrix::DiagonalPolicy)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -10579,15 +9219,20 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_dofs", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateEssentialBCFromDofsDiag", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_EliminateEssentialBCFromDofsDiag", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -10595,7 +9240,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BilinearForm_EliminateEssentialBCFromDofsDiag" "', argument " "3"" of type '" "double""'"); } @@ -10626,7 +9271,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag(PyObjec } -SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -10640,15 +9285,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdofs", (char *)"x", (char *)"b", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_EliminateVDofsInRHS", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearForm_EliminateVDofsInRHS", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -10656,7 +9307,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -10664,7 +9315,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_EliminateVDofsInRHS" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -10698,7 +9349,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_EliminateVDofsInRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10709,16 +9360,21 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_FullInnerProduct", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearForm_FullInnerProduct", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FullInnerProduct" "', argument " "1"" of type '" "mfem::BilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -10726,121 +9382,78 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FullInnerProduct(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - result = (double)((mfem::BilinearForm const *)arg1)->FullInnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - (arg1)->mfem::BilinearForm::Update(arg2); - } else { - (arg1)->Update(arg2); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FullInnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + { + try { + result = (double)((mfem::BilinearForm const *)arg1)->FullInnerProduct((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } - } catch (Swig::DirectorException&) { - SWIG_fail; +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) NULL ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nfes", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BilinearForm_Update", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_Update" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_Update" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { if (upcall) { - (arg1)->mfem::BilinearForm::Update(); + (arg1)->mfem::BilinearForm::Update(arg2); } else { - (arg1)->Update(); + (arg1)->Update(arg2); } } #ifdef MFEM_USE_EXCEPTIONS @@ -10868,47 +9481,6 @@ SWIGINTERN PyObject *_wrap_BilinearForm_Update__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BilinearForm_Update(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_Update", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_Update__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_Update__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_Update'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearForm::Update(mfem::FiniteElementSpace *)\n" - " mfem::BilinearForm::Update()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BilinearForm_GetFES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; @@ -11064,7 +9636,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FESpace(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Matrix::DiagonalPolicy arg2 ; @@ -11072,15 +9644,19 @@ SWIGINTERN PyObject *_wrap_BilinearForm_SetDiagonalPolicy(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"policy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BilinearForm_SetDiagonalPolicy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearForm_SetDiagonalPolicy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BilinearForm_SetDiagonalPolicy" "', argument " "2"" of type '" "mfem::Matrix::DiagonalPolicy""'"); } @@ -11191,7 +9767,7 @@ SWIGINTERN PyObject *_wrap_delete_BilinearForm(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -11200,7 +9776,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGU mfem::SparseMatrix *arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -11216,7 +9792,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGU void *argp7 = 0 ; int res7 = 0 ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; + if ((nobjs < 7) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); @@ -11270,119 +9846,17 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_4(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[7]) { + { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(swig_obj[7]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::SparseMatrix *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearForm_FormLinearSystem" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "5"" of type '" "mfem::SparseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::SparseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearForm_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR FormLinearSystem< mfem::SparseMatrix >((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11414,7 +9888,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearForm_FormLinearSystem", 0, 8, argv))) SWIG_fail; --argc; - if (argc == 7) { + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -11443,82 +9917,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 7) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11528,7 +9929,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec } } if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_4(self, argc, argv); + return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); } } } @@ -11538,7 +9939,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec } } } - if (argc == 8) { + if ((argc >= 7) && (argc <= 8)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearForm, 0); @@ -11556,7 +9957,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__OperatorHandle, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; @@ -11567,6 +9968,9 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 7) { + return _wrap_BilinearForm_FormLinearSystem__SWIG_2(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11576,7 +9980,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec } } if (_v) { - return _wrap_BilinearForm_FormLinearSystem__SWIG_0(self, argc, argv); + return _wrap_BilinearForm_FormLinearSystem__SWIG_2(self, argc, argv); } } } @@ -11591,9 +9995,7 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormLinearSystem(PyObject *self, PyObjec SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearForm_FormLinearSystem'.\n" " Possible C/C++ prototypes are:\n" " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::OperatorHandle &,mfem::Vector &,mfem::Vector &)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &)\n"); + " mfem::BilinearForm::FormLinearSystem< mfem::SparseMatrix >(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::SparseMatrix &,mfem::Vector &,mfem::Vector &,int)\n"); return 0; } @@ -11712,16 +10114,18 @@ SWIGINTERN PyObject *_wrap_BilinearForm_FormSystemMatrix(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_BilinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearForm *arg1 = (mfem::BilinearForm *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_BilinearForm", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearForm" "', argument " "1"" of type '" "mfem::BilinearForm *""'"); } @@ -11928,268 +10332,10 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (double *) &(arg1)->Elem(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (double *) &((mfem::MixedBilinearForm const *)arg1)->Elem(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(*result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Elem", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Elem__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Elem__SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Elem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Elem(int,int)\n" - " mfem::MixedBilinearForm::Elem(int,int) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Mult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::MixedBilinearForm const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + } { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); + result = (double *) &(arg1)->Elem(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12206,50 +10352,43 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_0(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Elem" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); + result = (double *) &((mfem::MixedBilinearForm const *)arg1)->Elem(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12266,20 +10405,20 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult__SWIG_1(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(*result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Elem(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMult", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Elem", 0, 3, argv))) SWIG_fail; --argc; if (argc == 3) { int _v; @@ -12287,56 +10426,69 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_1(self, argc, argv); + return _wrap_MixedBilinearForm_Elem__SWIG_0(self, argc, argv); } } } } - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_MixedBilinearForm_AddMult__SWIG_0(self, argc, argv); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_MixedBilinearForm_Elem__SWIG_1(self, argc, argv); + } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMult'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Elem'.\n" " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); + " mfem::MixedBilinearForm::Elem(int,int)\n" + " mfem::MixedBilinearForm::Elem(int,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12347,33 +10499,38 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Mult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::MixedBilinearForm const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12397,12 +10554,12 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -12411,37 +10568,46 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject * int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:MixedBilinearForm_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMult" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); + ((mfem::MixedBilinearForm const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12465,7 +10631,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12476,32 +10642,38 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::MixedBilinearForm const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12525,87 +10697,60 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_MixedBilinearForm_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::MixedBilinearForm::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::MatrixInverse *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:MixedBilinearForm_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Inverse" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MixedBilinearForm_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { - result = (mfem::MatrixInverse *)((mfem::MixedBilinearForm const *)arg1)->Inverse(); + ((mfem::MixedBilinearForm const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12622,35 +10767,31 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::MatrixInverse *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Inverse" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - (arg1)->Finalize(arg2); + result = (mfem::MatrixInverse *)((mfem::MixedBilinearForm const *)arg1)->Inverse(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12667,28 +10808,42 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixInverse, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MixedBilinearForm_Finalize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Finalize" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } { try { - (arg1)->Finalize(); + (arg1)->Finalize(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12712,53 +10867,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Finalize", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Finalize__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Finalize(int)\n" - " mfem::MixedBilinearForm::Finalize()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; @@ -12766,15 +10875,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBlocks(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blocks", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_GetBlocks", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_GetBlocks", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "1"" of type '" "mfem::MixedBilinearForm const *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); } @@ -12963,7 +11076,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_LoseMat(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -12971,15 +11084,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddDomainIntegrator(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -13164,7 +11281,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddBoundaryIntegrator(PyObject *sel } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -13172,15 +11289,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AddTraceFaceIntegrator(PyObject *SW int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AddTraceFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_AddTraceFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_AddTraceFaceIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -13611,7 +11732,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetBTFBFI_Marker(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::AssemblyLevel arg2 ; @@ -13619,15 +11740,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUS int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"assembly_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_SetAssemblyLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MixedBilinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); } @@ -13658,66 +11783,35 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_SetAssemblyLevel(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MixedBilinearForm_Assemble", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Assemble(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_Assemble" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { try { - (arg1)->Assemble(); + (arg1)->Assemble(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13741,52 +11835,6 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::Assemble(int)\n" - " mfem::MixedBilinearForm::Assemble()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_MixedBilinearForm_GetProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; @@ -13991,7 +12039,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ConformingAssemble(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; @@ -14000,21 +12048,26 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIG int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeElementMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_ComputeElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14024,127 +12077,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeElementMatrix(PyObject *SWIG arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->ComputeElementMatrix(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_ComputeBdrElementMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - (arg1)->ComputeBdrElementMatrix(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); + (arg1)->ComputeElementMatrix(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14168,7 +12101,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_ComputeBdrElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; @@ -14177,30 +12110,36 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObj int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"elmat", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedBilinearForm_ComputeBdrElementMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_ComputeBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); + (arg1)->ComputeBdrElementMatrix(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14224,24 +12163,18 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - mfem::Array< int > *arg5 = 0 ; - int arg6 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -14261,31 +12194,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14309,13 +12228,14 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(PyObj } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; mfem::Array< int > *arg4 = 0 ; mfem::Array< int > *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -14325,7 +12245,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObj void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -14361,9 +12281,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); } arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } { try { - (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); + (arg1)->AssembleElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14395,30 +12323,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix(PyObject *sel if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleElementMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -14436,6 +12341,9 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix(PyObject *sel int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -14451,231 +12359,74 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleElementMatrix(PyObject *sel } } } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { + if ((argc >= 5) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleElementMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" - " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_MixedBilinearForm_AssembleElementMatrix__SWIG_1(self, argc, argv); + } + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleElementMatrix'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,int)\n" + " mfem::MixedBilinearForm::AssembleElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - mfem::Array< int > *arg5 = 0 ; - int arg6 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -14695,31 +12446,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "4"" of type '" "mfem::Array< int > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); - } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14743,13 +12480,14 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(Py } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; int arg2 ; mfem::DenseMatrix *arg3 = 0 ; mfem::Array< int > *arg4 = 0 ; mfem::Array< int > *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -14759,7 +12497,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(Py void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); @@ -14795,9 +12533,17 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_AssembleBdrElementMatrix" "', argument " "5"" of type '" "mfem::Array< int > &""'"); } arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } { try { - (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5); + (arg1)->AssembleBdrElementMatrix(arg2,(mfem::DenseMatrix const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14829,30 +12575,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * if (!(argc = SWIG_Python_UnpackTuple(args, "MixedBilinearForm_AssembleBdrElementMatrix", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -14870,6 +12593,9 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -14885,40 +12611,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * } } } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { + if ((argc >= 5) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MixedBilinearForm, 0); @@ -14944,6 +12637,9 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 5) { + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -14953,7 +12649,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * } } if (_v) { - return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_2(self, argc, argv); + return _wrap_MixedBilinearForm_AssembleBdrElementMatrix__SWIG_1(self, argc, argv); } } } @@ -14966,14 +12662,12 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_AssembleBdrElementMatrix(PyObject * SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MixedBilinearForm_AssembleBdrElementMatrix'.\n" " Possible C/C++ prototypes are:\n" " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,int)\n" - " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &)\n" - " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n" - " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &)\n"); + " mfem::MixedBilinearForm::AssembleBdrElementMatrix(int,mfem::DenseMatrix const &,mfem::Array< int > &,mfem::Array< int > &,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -14987,15 +12681,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"sol", (char *)"rhs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTrialDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedBilinearForm_EliminateTrialDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -15003,7 +12703,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -15011,7 +12711,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -15045,7 +12745,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTrialDofs(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -15059,15 +12759,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"marked_vdofs", (char *)"sol", (char *)"rhs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedBilinearForm_EliminateEssentialBCFromTrialDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -15075,7 +12781,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -15083,7 +12789,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_EliminateEssentialBCFromTrialDofs" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -15117,7 +12823,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs(P } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -15125,15 +12831,19 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_EliminateTestDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MixedBilinearForm_EliminateTestDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_EliminateTestDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -15167,7 +12877,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_EliminateTestDofs(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -15181,15 +12891,21 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularSystemMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedBilinearForm_FormRectangularSystemMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -15197,7 +12913,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -15205,7 +12921,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularSystemMatrix" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); } @@ -15239,7 +12955,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularSystemMatrix(PyObjec } -SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedBilinearForm *arg1 = (mfem::MixedBilinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -15265,15 +12981,25 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedBilinearForm_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:MixedBilinearForm_FormRectangularLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedBilinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::MixedBilinearForm *""'"); } arg1 = reinterpret_cast< mfem::MixedBilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -15281,7 +13007,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -15289,7 +13015,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -15297,7 +13023,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -15305,7 +13031,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); } @@ -15313,7 +13039,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::OperatorHandle &""'"); } arg6 = reinterpret_cast< mfem::OperatorHandle * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -15321,7 +13047,7 @@ SWIGINTERN PyObject *_wrap_MixedBilinearForm_FormRectangularLinearSystem(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "MixedBilinearForm_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -15674,7 +13400,7 @@ SWIGINTERN PyObject *MixedBilinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -15682,16 +13408,20 @@ SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"domain_fes", (char *)"range_fes", NULL + }; mfem::DiscreteLinearOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DiscreteLinearOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_DiscreteLinearOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DiscreteLinearOperator" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DiscreteLinearOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -15722,7 +13452,7 @@ SWIGINTERN PyObject *_wrap_new_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; mfem::DiscreteInterpolator *arg2 = (mfem::DiscreteInterpolator *) 0 ; @@ -15730,15 +13460,19 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"di", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiscreteLinearOperator_AddDomainInterpolator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiscreteLinearOperator_AddDomainInterpolator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_AddDomainInterpolator" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteLinearOperator_AddDomainInterpolator" "', argument " "2"" of type '" "mfem::DiscreteInterpolator *""'"); } @@ -15769,7 +13503,7 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddDomainInterpolator(PyObject } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; mfem::DiscreteInterpolator *arg2 = (mfem::DiscreteInterpolator *) 0 ; @@ -15777,15 +13511,19 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator(PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"di", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiscreteLinearOperator_AddTraceFaceInterpolator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiscreteLinearOperator_AddTraceFaceInterpolator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_AddTraceFaceInterpolator" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__DiscreteInterpolator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiscreteLinearOperator_AddTraceFaceInterpolator" "', argument " "2"" of type '" "mfem::DiscreteInterpolator *""'"); } @@ -15857,66 +13595,35 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_GetDI(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"skip_zeros", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DiscreteLinearOperator_Assemble", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_Assemble" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->Assemble(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiscreteLinearOperator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteLinearOperator_Assemble" "', argument " "1"" of type '" "mfem::DiscreteLinearOperator *""'"); } - arg1 = reinterpret_cast< mfem::DiscreteLinearOperator * >(argp1); { try { - (arg1)->Assemble(); + (arg1)->Assemble(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15940,52 +13647,6 @@ SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_DiscreteLinearOperator_Assemble(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiscreteLinearOperator_Assemble", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiscreteLinearOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiscreteLinearOperator_Assemble__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiscreteLinearOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DiscreteLinearOperator_Assemble__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiscreteLinearOperator_Assemble'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiscreteLinearOperator::Assemble(int)\n" - " mfem::DiscreteLinearOperator::Assemble()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_DiscreteLinearOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DiscreteLinearOperator *arg1 = (mfem::DiscreteLinearOperator *) 0 ; @@ -16042,33 +13703,33 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "new_BilinearForm", _wrap_new_BilinearForm, METH_VARARGS, "\n" "BilinearForm()\n" "BilinearForm(FiniteElementSpace f)\n" - "BilinearForm(FiniteElementSpace f, BilinearForm bf, int ps=0)\n" + "new_BilinearForm(PyObject * _self, FiniteElementSpace f, BilinearForm bf, int ps=0) -> BilinearForm\n" ""}, { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "BilinearForm_Size(BilinearForm self) -> int"}, - { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "BilinearForm_SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "BilinearForm_SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "BilinearForm_GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "BilinearForm_EnableStaticCondensation(BilinearForm self)"}, { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "BilinearForm_StaticCondensationIsEnabled(BilinearForm self) -> bool"}, { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "BilinearForm_SCFESpace(BilinearForm self) -> FiniteElementSpace"}, - { "BilinearForm_EnableHybridization", _wrap_BilinearForm_EnableHybridization, METH_VARARGS, "BilinearForm_EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, - { "BilinearForm_UsePrecomputedSparsity", _wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS, "BilinearForm_UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, + { "BilinearForm_EnableHybridization", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EnableHybridization, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, + { "BilinearForm_UsePrecomputedSparsity", (PyCFunction)(void(*)(void))_wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS|METH_KEYWORDS, "BilinearForm_UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, { "BilinearForm_UseSparsity", _wrap_BilinearForm_UseSparsity, METH_VARARGS, "\n" "BilinearForm_UseSparsity(BilinearForm self, int * I, int * J, bool isSorted)\n" "BilinearForm_UseSparsity(BilinearForm self, SparseMatrix A)\n" @@ -16080,21 +13741,21 @@ static PyMethodDef SwigMethods[] = { { "BilinearForm_GetFBFI", _wrap_BilinearForm_GetFBFI, METH_O, "BilinearForm_GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI", _wrap_BilinearForm_GetBFBFI, METH_O, "BilinearForm_GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI_Marker", _wrap_BilinearForm_GetBFBFI_Marker, METH_O, "BilinearForm_GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "BilinearForm___call__", _wrap_BilinearForm___call__, METH_VARARGS, "BilinearForm___call__(BilinearForm self, int i, int j) -> double const &"}, + { "BilinearForm___call__", (PyCFunction)(void(*)(void))_wrap_BilinearForm___call__, METH_VARARGS|METH_KEYWORDS, "BilinearForm___call__(BilinearForm self, int i, int j) -> double const &"}, { "BilinearForm_Elem", _wrap_BilinearForm_Elem, METH_VARARGS, "\n" "BilinearForm_Elem(BilinearForm self, int i, int j) -> double\n" "BilinearForm_Elem(BilinearForm self, int i, int j) -> double const &\n" ""}, - { "BilinearForm_Mult", _wrap_BilinearForm_Mult, METH_VARARGS, "BilinearForm_Mult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_FullMult", _wrap_BilinearForm_FullMult, METH_VARARGS, "BilinearForm_FullMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMult", _wrap_BilinearForm_AddMult, METH_VARARGS, "BilinearForm_AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMult", _wrap_BilinearForm_FullAddMult, METH_VARARGS, "BilinearForm_FullAddMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMultTranspose", _wrap_BilinearForm_AddMultTranspose, METH_VARARGS, "BilinearForm_AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMultTranspose", _wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS, "BilinearForm_FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_MultTranspose", _wrap_BilinearForm_MultTranspose, METH_VARARGS, "BilinearForm_MultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_InnerProduct", _wrap_BilinearForm_InnerProduct, METH_VARARGS, "BilinearForm_InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Mult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_FullMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullMult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMult, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullAddMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BilinearForm_MultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_InnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_InnerProduct, METH_VARARGS|METH_KEYWORDS, "BilinearForm_InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, { "BilinearForm_Inverse", _wrap_BilinearForm_Inverse, METH_O, "BilinearForm_Inverse(BilinearForm self) -> MatrixInverse"}, - { "BilinearForm_Finalize", _wrap_BilinearForm_Finalize, METH_VARARGS, "BilinearForm_Finalize(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Finalize(BilinearForm self, int skip_zeros=1)"}, { "BilinearForm_SpMat", _wrap_BilinearForm_SpMat, METH_VARARGS, "\n" "BilinearForm_SpMat(BilinearForm self) -> SparseMatrix\n" "BilinearForm_SpMat(BilinearForm self) -> SparseMatrix\n" @@ -16104,27 +13765,27 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_SpMatElim(BilinearForm self) -> SparseMatrix\n" "BilinearForm_SpMatElim(BilinearForm self) -> SparseMatrix\n" ""}, - { "BilinearForm_AddDomainIntegrator", _wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS, "BilinearForm_AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBoundaryIntegrator", _wrap_BilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "BilinearForm_AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "BilinearForm_AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_AddInteriorFaceIntegrator", _wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "BilinearForm_AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBdrFaceIntegrator", _wrap_BilinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "BilinearForm_AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "BilinearForm_AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "BilinearForm_Assemble(BilinearForm self, int skip_zeros=1)"}, - { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "BilinearForm_AssembleDiagonal(BilinearForm self, Vector diag)"}, + { "BilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AssembleDiagonal, METH_VARARGS|METH_KEYWORDS, "BilinearForm_AssembleDiagonal(BilinearForm self, Vector diag)"}, { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "BilinearForm_GetProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "BilinearForm_GetRestriction(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "BilinearForm_GetOutputProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "BilinearForm_GetOutputRestriction(BilinearForm self) -> Operator"}, - { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "BilinearForm_RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, + { "BilinearForm_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "BilinearForm_RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "BilinearForm_ComputeElementMatrices(BilinearForm self)"}, { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "BilinearForm_FreeElementMatrices(BilinearForm self)"}, - { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "BilinearForm_ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, - { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "BilinearForm_ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "BilinearForm_ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "BilinearForm_ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "BilinearForm_AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" @@ -16137,7 +13798,7 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCDiag", _wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS, "BilinearForm_EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, + { "BilinearForm_EliminateEssentialBCDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, { "BilinearForm_EliminateVDofs", _wrap_BilinearForm_EliminateVDofs, METH_VARARGS, "\n" "BilinearForm_EliminateVDofs(BilinearForm self, intArray vdofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" @@ -16146,16 +13807,16 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BilinearForm_EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCFromDofsDiag", _wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS, "BilinearForm_EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, - { "BilinearForm_EliminateVDofsInRHS", _wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS, "BilinearForm_EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, - { "BilinearForm_FullInnerProduct", _wrap_BilinearForm_FullInnerProduct, METH_VARARGS, "BilinearForm_FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, - { "BilinearForm_Update", _wrap_BilinearForm_Update, METH_VARARGS, "BilinearForm_Update(BilinearForm self, FiniteElementSpace nfes=None)"}, + { "BilinearForm_EliminateEssentialBCFromDofsDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, + { "BilinearForm_EliminateVDofsInRHS", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS|METH_KEYWORDS, "BilinearForm_EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, + { "BilinearForm_FullInnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullInnerProduct, METH_VARARGS|METH_KEYWORDS, "BilinearForm_FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Update", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Update, METH_VARARGS|METH_KEYWORDS, "BilinearForm_Update(BilinearForm self, FiniteElementSpace nfes=None)"}, { "BilinearForm_GetFES", _wrap_BilinearForm_GetFES, METH_O, "BilinearForm_GetFES(BilinearForm self) -> FiniteElementSpace"}, { "BilinearForm_FESpace", _wrap_BilinearForm_FESpace, METH_VARARGS, "\n" "BilinearForm_FESpace(BilinearForm self) -> FiniteElementSpace\n" "BilinearForm_FESpace(BilinearForm self) -> FiniteElementSpace\n" ""}, - { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "BilinearForm_SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_SetDiagonalPolicy", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS|METH_KEYWORDS, "BilinearForm_SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "BilinearForm_UseExternalIntegrators(BilinearForm self)"}, { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" @@ -16166,7 +13827,7 @@ static PyMethodDef SwigMethods[] = { "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, OperatorHandle A)\n" "BilinearForm_FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" ""}, - { "disown_BilinearForm", _wrap_disown_BilinearForm, METH_O, NULL}, + { "disown_BilinearForm", (PyCFunction)(void(*)(void))_wrap_disown_BilinearForm, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearForm_swigregister", BilinearForm_swigregister, METH_O, NULL}, { "BilinearForm_swiginit", BilinearForm_swiginit, METH_VARARGS, NULL}, { "new_MixedBilinearForm", _wrap_new_MixedBilinearForm, METH_VARARGS, "\n" @@ -16177,24 +13838,24 @@ static PyMethodDef SwigMethods[] = { "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double\n" "MixedBilinearForm_Elem(MixedBilinearForm self, int i, int j) -> double const &\n" ""}, - { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "MixedBilinearForm_Mult(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "MixedBilinearForm_AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MixedBilinearForm_MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_Mult(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "MixedBilinearForm_Inverse(MixedBilinearForm self) -> MatrixInverse"}, - { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "MixedBilinearForm_Finalize(MixedBilinearForm self, int skip_zeros=1)"}, - { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "MixedBilinearForm_GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "MixedBilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_Finalize(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetBlocks", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_GetBlocks, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, { "MixedBilinearForm_SpMat", _wrap_MixedBilinearForm_SpMat, METH_VARARGS, "\n" "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" "MixedBilinearForm_SpMat(MixedBilinearForm self) -> SparseMatrix\n" ""}, { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "MixedBilinearForm_LoseMat(MixedBilinearForm self) -> SparseMatrix"}, - { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "MixedBilinearForm_AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "MixedBilinearForm_AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "MixedBilinearForm_AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddTraceFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "MixedBilinearForm_AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" @@ -16205,15 +13866,15 @@ static PyMethodDef SwigMethods[] = { { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "MixedBilinearForm_GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "MixedBilinearForm_GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "MixedBilinearForm_GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "MixedBilinearForm_SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, - { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "MixedBilinearForm_Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "MixedBilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_Assemble(MixedBilinearForm self, int skip_zeros=1)"}, { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "MixedBilinearForm_GetProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "MixedBilinearForm_GetRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "MixedBilinearForm_GetOutputProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "MixedBilinearForm_GetOutputRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "MixedBilinearForm_ConformingAssemble(MixedBilinearForm self)"}, - { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, - { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "MixedBilinearForm_ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "MixedBilinearForm_AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" @@ -16222,11 +13883,11 @@ static PyMethodDef SwigMethods[] = { "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "MixedBilinearForm_AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" ""}, - { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "MixedBilinearForm_EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, - { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "MixedBilinearForm_FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, - { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "MixedBilinearForm_FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "MixedBilinearForm_EliminateTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateTestDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "MixedBilinearForm_FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "MixedBilinearForm_Update(MixedBilinearForm self)"}, { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" "MixedBilinearForm_TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" @@ -16239,11 +13900,11 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, - { "new_DiscreteLinearOperator", _wrap_new_DiscreteLinearOperator, METH_VARARGS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, - { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, - { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "DiscreteLinearOperator_AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "new_DiscreteLinearOperator", (PyCFunction)(void(*)(void))_wrap_new_DiscreteLinearOperator, METH_VARARGS|METH_KEYWORDS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, + { "DiscreteLinearOperator_AddDomainInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS|METH_KEYWORDS, "DiscreteLinearOperator_AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_AddTraceFaceInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS|METH_KEYWORDS, "DiscreteLinearOperator_AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "DiscreteLinearOperator_GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "DiscreteLinearOperator_Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, + { "DiscreteLinearOperator_Assemble", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_Assemble, METH_VARARGS|METH_KEYWORDS, "DiscreteLinearOperator_Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, { "delete_DiscreteLinearOperator", _wrap_delete_DiscreteLinearOperator, METH_O, "delete_DiscreteLinearOperator(DiscreteLinearOperator self)"}, { "DiscreteLinearOperator_swigregister", DiscreteLinearOperator_swigregister, METH_O, NULL}, { "DiscreteLinearOperator_swiginit", DiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, @@ -16255,33 +13916,33 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "new_BilinearForm", _wrap_new_BilinearForm, METH_VARARGS, "\n" "BilinearForm()\n" "BilinearForm(FiniteElementSpace f)\n" - "BilinearForm(FiniteElementSpace f, BilinearForm bf, int ps=0)\n" + "new_BilinearForm(PyObject * _self, FiniteElementSpace f, BilinearForm bf, int ps=0) -> BilinearForm\n" ""}, { "BilinearForm_Size", _wrap_BilinearForm_Size, METH_O, "Size(BilinearForm self) -> int"}, - { "BilinearForm_SetAssemblyLevel", _wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "BilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "SetAssemblyLevel(BilinearForm self, mfem::AssemblyLevel assembly_level)"}, { "BilinearForm_GetAssemblyLevel", _wrap_BilinearForm_GetAssemblyLevel, METH_O, "GetAssemblyLevel(BilinearForm self) -> mfem::AssemblyLevel"}, { "BilinearForm_EnableStaticCondensation", _wrap_BilinearForm_EnableStaticCondensation, METH_O, "EnableStaticCondensation(BilinearForm self)"}, { "BilinearForm_StaticCondensationIsEnabled", _wrap_BilinearForm_StaticCondensationIsEnabled, METH_O, "StaticCondensationIsEnabled(BilinearForm self) -> bool"}, { "BilinearForm_SCFESpace", _wrap_BilinearForm_SCFESpace, METH_O, "SCFESpace(BilinearForm self) -> FiniteElementSpace"}, - { "BilinearForm_EnableHybridization", _wrap_BilinearForm_EnableHybridization, METH_VARARGS, "EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, - { "BilinearForm_UsePrecomputedSparsity", _wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS, "UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, + { "BilinearForm_EnableHybridization", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EnableHybridization, METH_VARARGS|METH_KEYWORDS, "EnableHybridization(BilinearForm self, FiniteElementSpace constr_space, BilinearFormIntegrator constr_integ, intArray ess_tdof_list)"}, + { "BilinearForm_UsePrecomputedSparsity", (PyCFunction)(void(*)(void))_wrap_BilinearForm_UsePrecomputedSparsity, METH_VARARGS|METH_KEYWORDS, "UsePrecomputedSparsity(BilinearForm self, int ps=1)"}, { "BilinearForm_UseSparsity", _wrap_BilinearForm_UseSparsity, METH_VARARGS, "\n" "UseSparsity(BilinearForm self, int * I, int * J, bool isSorted)\n" "UseSparsity(BilinearForm self, SparseMatrix A)\n" @@ -16293,21 +13954,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "BilinearForm_GetFBFI", _wrap_BilinearForm_GetFBFI, METH_O, "GetFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI", _wrap_BilinearForm_GetBFBFI, METH_O, "GetBFBFI(BilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "BilinearForm_GetBFBFI_Marker", _wrap_BilinearForm_GetBFBFI_Marker, METH_O, "GetBFBFI_Marker(BilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "BilinearForm___call__", _wrap_BilinearForm___call__, METH_VARARGS, "__call__(BilinearForm self, int i, int j) -> double const &"}, + { "BilinearForm___call__", (PyCFunction)(void(*)(void))_wrap_BilinearForm___call__, METH_VARARGS|METH_KEYWORDS, "__call__(BilinearForm self, int i, int j) -> double const &"}, { "BilinearForm_Elem", _wrap_BilinearForm_Elem, METH_VARARGS, "\n" "Elem(BilinearForm self, int i, int j) -> double\n" "Elem(BilinearForm self, int i, int j) -> double const &\n" ""}, - { "BilinearForm_Mult", _wrap_BilinearForm_Mult, METH_VARARGS, "Mult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_FullMult", _wrap_BilinearForm_FullMult, METH_VARARGS, "FullMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMult", _wrap_BilinearForm_AddMult, METH_VARARGS, "AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMult", _wrap_BilinearForm_FullAddMult, METH_VARARGS, "FullAddMult(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_AddMultTranspose", _wrap_BilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "BilinearForm_FullAddMultTranspose", _wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS, "FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_MultTranspose", _wrap_BilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(BilinearForm self, Vector x, Vector y)"}, - { "BilinearForm_InnerProduct", _wrap_BilinearForm_InnerProduct, METH_VARARGS, "InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_FullMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullMult, METH_VARARGS|METH_KEYWORDS, "FullMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMult", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMult, METH_VARARGS|METH_KEYWORDS, "FullAddMult(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(BilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "BilinearForm_FullAddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullAddMultTranspose, METH_VARARGS|METH_KEYWORDS, "FullAddMultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BilinearForm self, Vector x, Vector y)"}, + { "BilinearForm_InnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_InnerProduct, METH_VARARGS|METH_KEYWORDS, "InnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, { "BilinearForm_Inverse", _wrap_BilinearForm_Inverse, METH_O, "Inverse(BilinearForm self) -> MatrixInverse"}, - { "BilinearForm_Finalize", _wrap_BilinearForm_Finalize, METH_VARARGS, "Finalize(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(BilinearForm self, int skip_zeros=1)"}, { "BilinearForm_SpMat", _wrap_BilinearForm_SpMat, METH_VARARGS, "\n" "SpMat(BilinearForm self) -> SparseMatrix\n" "SpMat(BilinearForm self) -> SparseMatrix\n" @@ -16317,27 +13978,27 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SpMatElim(BilinearForm self) -> SparseMatrix\n" "SpMatElim(BilinearForm self) -> SparseMatrix\n" ""}, - { "BilinearForm_AddDomainIntegrator", _wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBoundaryIntegrator", _wrap_BilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "AddBoundaryIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_AddInteriorFaceIntegrator", _wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, + { "BilinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddInteriorFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)"}, { "BilinearForm_AddBdrFaceIntegrator", _wrap_BilinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi)\n" "AddBdrFaceIntegrator(BilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "BilinearForm_Assemble", _wrap_BilinearForm_Assemble, METH_VARARGS, "Assemble(BilinearForm self, int skip_zeros=1)"}, - { "BilinearForm_AssembleDiagonal", _wrap_BilinearForm_AssembleDiagonal, METH_VARARGS, "AssembleDiagonal(BilinearForm self, Vector diag)"}, + { "BilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "Assemble(BilinearForm self, int skip_zeros=1)"}, + { "BilinearForm_AssembleDiagonal", (PyCFunction)(void(*)(void))_wrap_BilinearForm_AssembleDiagonal, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonal(BilinearForm self, Vector diag)"}, { "BilinearForm_GetProlongation", _wrap_BilinearForm_GetProlongation, METH_O, "GetProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetRestriction", _wrap_BilinearForm_GetRestriction, METH_O, "GetRestriction(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputProlongation", _wrap_BilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(BilinearForm self) -> Operator"}, { "BilinearForm_GetOutputRestriction", _wrap_BilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(BilinearForm self) -> Operator"}, - { "BilinearForm_RecoverFEMSolution", _wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, + { "BilinearForm_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_BilinearForm_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "RecoverFEMSolution(BilinearForm self, Vector X, Vector b, Vector x)"}, { "BilinearForm_ComputeElementMatrices", _wrap_BilinearForm_ComputeElementMatrices, METH_O, "ComputeElementMatrices(BilinearForm self)"}, { "BilinearForm_FreeElementMatrices", _wrap_BilinearForm_FreeElementMatrices, METH_O, "FreeElementMatrices(BilinearForm self)"}, - { "BilinearForm_ComputeElementMatrix", _wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, - { "BilinearForm_ComputeBdrElementMatrix", _wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, + { "BilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeBdrElementMatrix(BilinearForm self, int i, DenseMatrix elmat)"}, { "BilinearForm_AssembleElementMatrix", _wrap_BilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "AssembleElementMatrix(BilinearForm self, int i, DenseMatrix elmat, intArray vdofs, int skip_zeros=1)\n" @@ -16350,7 +14011,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateEssentialBC(BilinearForm self, intArray bdr_attr_is_ess, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCDiag", _wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS, "EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, + { "BilinearForm_EliminateEssentialBCDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCDiag, METH_VARARGS|METH_KEYWORDS, "EliminateEssentialBCDiag(BilinearForm self, intArray bdr_attr_is_ess, double value)"}, { "BilinearForm_EliminateVDofs", _wrap_BilinearForm_EliminateVDofs, METH_VARARGS, "\n" "EliminateVDofs(BilinearForm self, intArray vdofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateVDofs(BilinearForm self, intArray vdofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" @@ -16359,16 +14020,16 @@ static PyMethodDef SwigMethods_proxydocs[] = { "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, Vector sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateEssentialBCFromDofs(BilinearForm self, intArray ess_dofs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, - { "BilinearForm_EliminateEssentialBCFromDofsDiag", _wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS, "EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, - { "BilinearForm_EliminateVDofsInRHS", _wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS, "EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, - { "BilinearForm_FullInnerProduct", _wrap_BilinearForm_FullInnerProduct, METH_VARARGS, "FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, - { "BilinearForm_Update", _wrap_BilinearForm_Update, METH_VARARGS, "Update(BilinearForm self, FiniteElementSpace nfes=None)"}, + { "BilinearForm_EliminateEssentialBCFromDofsDiag", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateEssentialBCFromDofsDiag, METH_VARARGS|METH_KEYWORDS, "EliminateEssentialBCFromDofsDiag(BilinearForm self, intArray ess_dofs, double value)"}, + { "BilinearForm_EliminateVDofsInRHS", (PyCFunction)(void(*)(void))_wrap_BilinearForm_EliminateVDofsInRHS, METH_VARARGS|METH_KEYWORDS, "EliminateVDofsInRHS(BilinearForm self, intArray vdofs, Vector x, Vector b)"}, + { "BilinearForm_FullInnerProduct", (PyCFunction)(void(*)(void))_wrap_BilinearForm_FullInnerProduct, METH_VARARGS|METH_KEYWORDS, "FullInnerProduct(BilinearForm self, Vector x, Vector y) -> double"}, + { "BilinearForm_Update", (PyCFunction)(void(*)(void))_wrap_BilinearForm_Update, METH_VARARGS|METH_KEYWORDS, "Update(BilinearForm self, FiniteElementSpace nfes=None)"}, { "BilinearForm_GetFES", _wrap_BilinearForm_GetFES, METH_O, "GetFES(BilinearForm self) -> FiniteElementSpace"}, { "BilinearForm_FESpace", _wrap_BilinearForm_FESpace, METH_VARARGS, "\n" "FESpace(BilinearForm self) -> FiniteElementSpace\n" "FESpace(BilinearForm self) -> FiniteElementSpace\n" ""}, - { "BilinearForm_SetDiagonalPolicy", _wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS, "SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, + { "BilinearForm_SetDiagonalPolicy", (PyCFunction)(void(*)(void))_wrap_BilinearForm_SetDiagonalPolicy, METH_VARARGS|METH_KEYWORDS, "SetDiagonalPolicy(BilinearForm self, mfem::Matrix::DiagonalPolicy policy)"}, { "BilinearForm_UseExternalIntegrators", _wrap_BilinearForm_UseExternalIntegrators, METH_O, "UseExternalIntegrators(BilinearForm self)"}, { "delete_BilinearForm", _wrap_delete_BilinearForm, METH_O, "delete_BilinearForm(BilinearForm self)"}, { "BilinearForm_FormLinearSystem", _wrap_BilinearForm_FormLinearSystem, METH_VARARGS, "\n" @@ -16379,7 +14040,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, OperatorHandle A)\n" "FormSystemMatrix(BilinearForm self, intArray ess_tdof_list, SparseMatrix A)\n" ""}, - { "disown_BilinearForm", _wrap_disown_BilinearForm, METH_O, NULL}, + { "disown_BilinearForm", (PyCFunction)(void(*)(void))_wrap_disown_BilinearForm, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearForm_swigregister", BilinearForm_swigregister, METH_O, NULL}, { "BilinearForm_swiginit", BilinearForm_swiginit, METH_VARARGS, NULL}, { "new_MixedBilinearForm", _wrap_new_MixedBilinearForm, METH_VARARGS, "\n" @@ -16390,24 +14051,24 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Elem(MixedBilinearForm self, int i, int j) -> double\n" "Elem(MixedBilinearForm self, int i, int j) -> double const &\n" ""}, - { "MixedBilinearForm_Mult", _wrap_MixedBilinearForm_Mult, METH_VARARGS, "Mult(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMult", _wrap_MixedBilinearForm_AddMult, METH_VARARGS, "AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, - { "MixedBilinearForm_MultTranspose", _wrap_MixedBilinearForm_MultTranspose, METH_VARARGS, "MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, - { "MixedBilinearForm_AddMultTranspose", _wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS, "AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMult", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, + { "MixedBilinearForm_MultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(MixedBilinearForm self, Vector x, Vector y)"}, + { "MixedBilinearForm_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(MixedBilinearForm self, Vector x, Vector y, double const a=1.0)"}, { "MixedBilinearForm_Inverse", _wrap_MixedBilinearForm_Inverse, METH_O, "Inverse(MixedBilinearForm self) -> MatrixInverse"}, - { "MixedBilinearForm_Finalize", _wrap_MixedBilinearForm_Finalize, METH_VARARGS, "Finalize(MixedBilinearForm self, int skip_zeros=1)"}, - { "MixedBilinearForm_GetBlocks", _wrap_MixedBilinearForm_GetBlocks, METH_VARARGS, "GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "MixedBilinearForm_Finalize", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_GetBlocks", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_GetBlocks, METH_VARARGS|METH_KEYWORDS, "GetBlocks(MixedBilinearForm self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, { "MixedBilinearForm_SpMat", _wrap_MixedBilinearForm_SpMat, METH_VARARGS, "\n" "SpMat(MixedBilinearForm self) -> SparseMatrix\n" "SpMat(MixedBilinearForm self) -> SparseMatrix\n" ""}, { "MixedBilinearForm_LoseMat", _wrap_MixedBilinearForm_LoseMat, METH_O, "LoseMat(MixedBilinearForm self) -> SparseMatrix"}, - { "MixedBilinearForm_AddDomainIntegrator", _wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBoundaryIntegrator", _wrap_MixedBilinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "AddBoundaryIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" ""}, - { "MixedBilinearForm_AddTraceFaceIntegrator", _wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS, "AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, + { "MixedBilinearForm_AddTraceFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_AddTraceFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)"}, { "MixedBilinearForm_AddBdrTraceFaceIntegrator", _wrap_MixedBilinearForm_AddBdrTraceFaceIntegrator, METH_VARARGS, "\n" "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi)\n" "AddBdrTraceFaceIntegrator(MixedBilinearForm self, BilinearFormIntegrator bfi, intArray bdr_marker)\n" @@ -16418,15 +14079,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "MixedBilinearForm_GetTFBFI", _wrap_MixedBilinearForm_GetTFBFI, METH_O, "GetTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI", _wrap_MixedBilinearForm_GetBTFBFI, METH_O, "GetBTFBFI(MixedBilinearForm self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, { "MixedBilinearForm_GetBTFBFI_Marker", _wrap_MixedBilinearForm_GetBTFBFI_Marker, METH_O, "GetBTFBFI_Marker(MixedBilinearForm self) -> mfem::Array< mfem::Array< int > * > *"}, - { "MixedBilinearForm_SetAssemblyLevel", _wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, - { "MixedBilinearForm_Assemble", _wrap_MixedBilinearForm_Assemble, METH_VARARGS, "Assemble(MixedBilinearForm self, int skip_zeros=1)"}, + { "MixedBilinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "SetAssemblyLevel(MixedBilinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "MixedBilinearForm_Assemble", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_Assemble, METH_VARARGS|METH_KEYWORDS, "Assemble(MixedBilinearForm self, int skip_zeros=1)"}, { "MixedBilinearForm_GetProlongation", _wrap_MixedBilinearForm_GetProlongation, METH_O, "GetProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetRestriction", _wrap_MixedBilinearForm_GetRestriction, METH_O, "GetRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputProlongation", _wrap_MixedBilinearForm_GetOutputProlongation, METH_O, "GetOutputProlongation(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_GetOutputRestriction", _wrap_MixedBilinearForm_GetOutputRestriction, METH_O, "GetOutputRestriction(MixedBilinearForm self) -> Operator"}, { "MixedBilinearForm_ConformingAssemble", _wrap_MixedBilinearForm_ConformingAssemble, METH_O, "ConformingAssemble(MixedBilinearForm self)"}, - { "MixedBilinearForm_ComputeElementMatrix", _wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS, "ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, - { "MixedBilinearForm_ComputeBdrElementMatrix", _wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS, "ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, + { "MixedBilinearForm_ComputeBdrElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_ComputeBdrElementMatrix, METH_VARARGS|METH_KEYWORDS, "ComputeBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat)"}, { "MixedBilinearForm_AssembleElementMatrix", _wrap_MixedBilinearForm_AssembleElementMatrix, METH_VARARGS, "\n" "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "AssembleElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" @@ -16435,11 +14096,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, int skip_zeros=1)\n" "AssembleBdrElementMatrix(MixedBilinearForm self, int i, DenseMatrix elmat, intArray trial_vdofs, intArray test_vdofs, int skip_zeros=1)\n" ""}, - { "MixedBilinearForm_EliminateTrialDofs", _wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS, "EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", _wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS, "EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, - { "MixedBilinearForm_EliminateTestDofs", _wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS, "EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, - { "MixedBilinearForm_FormRectangularSystemMatrix", _wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS, "FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, - { "MixedBilinearForm_FormRectangularLinearSystem", _wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, + { "MixedBilinearForm_EliminateTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTrialDofs, METH_VARARGS|METH_KEYWORDS, "EliminateTrialDofs(MixedBilinearForm self, intArray bdr_attr_is_ess, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateEssentialBCFromTrialDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateEssentialBCFromTrialDofs, METH_VARARGS|METH_KEYWORDS, "EliminateEssentialBCFromTrialDofs(MixedBilinearForm self, intArray marked_vdofs, Vector sol, Vector rhs)"}, + { "MixedBilinearForm_EliminateTestDofs", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_EliminateTestDofs, METH_VARARGS|METH_KEYWORDS, "EliminateTestDofs(MixedBilinearForm self, intArray bdr_attr_is_ess)"}, + { "MixedBilinearForm_FormRectangularSystemMatrix", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularSystemMatrix, METH_VARARGS|METH_KEYWORDS, "FormRectangularSystemMatrix(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, OperatorHandle A)"}, + { "MixedBilinearForm_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_MixedBilinearForm_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormRectangularLinearSystem(MixedBilinearForm self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, OperatorHandle A, Vector X, Vector B)"}, { "MixedBilinearForm_Update", _wrap_MixedBilinearForm_Update, METH_O, "Update(MixedBilinearForm self)"}, { "MixedBilinearForm_TrialFESpace", _wrap_MixedBilinearForm_TrialFESpace, METH_VARARGS, "\n" "TrialFESpace(MixedBilinearForm self) -> FiniteElementSpace\n" @@ -16452,11 +14113,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedBilinearForm", _wrap_delete_MixedBilinearForm, METH_O, "delete_MixedBilinearForm(MixedBilinearForm self)"}, { "MixedBilinearForm_swigregister", MixedBilinearForm_swigregister, METH_O, NULL}, { "MixedBilinearForm_swiginit", MixedBilinearForm_swiginit, METH_VARARGS, NULL}, - { "new_DiscreteLinearOperator", _wrap_new_DiscreteLinearOperator, METH_VARARGS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, - { "DiscreteLinearOperator_AddDomainInterpolator", _wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS, "AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, - { "DiscreteLinearOperator_AddTraceFaceInterpolator", _wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS, "AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "new_DiscreteLinearOperator", (PyCFunction)(void(*)(void))_wrap_new_DiscreteLinearOperator, METH_VARARGS|METH_KEYWORDS, "new_DiscreteLinearOperator(FiniteElementSpace domain_fes, FiniteElementSpace range_fes) -> DiscreteLinearOperator"}, + { "DiscreteLinearOperator_AddDomainInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddDomainInterpolator, METH_VARARGS|METH_KEYWORDS, "AddDomainInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, + { "DiscreteLinearOperator_AddTraceFaceInterpolator", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_AddTraceFaceInterpolator, METH_VARARGS|METH_KEYWORDS, "AddTraceFaceInterpolator(DiscreteLinearOperator self, DiscreteInterpolator di)"}, { "DiscreteLinearOperator_GetDI", _wrap_DiscreteLinearOperator_GetDI, METH_O, "GetDI(DiscreteLinearOperator self) -> mfem::Array< mfem::BilinearFormIntegrator * > *"}, - { "DiscreteLinearOperator_Assemble", _wrap_DiscreteLinearOperator_Assemble, METH_VARARGS, "Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, + { "DiscreteLinearOperator_Assemble", (PyCFunction)(void(*)(void))_wrap_DiscreteLinearOperator_Assemble, METH_VARARGS|METH_KEYWORDS, "Assemble(DiscreteLinearOperator self, int skip_zeros=1)"}, { "delete_DiscreteLinearOperator", _wrap_delete_DiscreteLinearOperator, METH_O, "delete_DiscreteLinearOperator(DiscreteLinearOperator self)"}, { "DiscreteLinearOperator_swigregister", DiscreteLinearOperator_swigregister, METH_O, NULL}, { "DiscreteLinearOperator_swiginit", DiscreteLinearOperator_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/bilinearform_wrap.h b/mfem/_ser/bilinearform_wrap.h index 84555a81..5336778a 100644 --- a/mfem/_ser/bilinearform_wrap.h +++ b/mfem/_ser/bilinearform_wrap.h @@ -71,7 +71,7 @@ class SwigDirector_BilinearForm : public mfem::BilinearForm, public Swig::Direct return method; } private: - mutable swig::SwigVar_PyObject vtable[26]; + mutable swig::SwigVar_PyObject vtable[19]; #endif }; diff --git a/mfem/_ser/bilininteg_wrap.cxx b/mfem/_ser/bilininteg_wrap.cxx index 50948291..fad8a943 100644 --- a/mfem/_ser/bilininteg_wrap.cxx +++ b/mfem/_ser/bilininteg_wrap.cxx @@ -4128,7 +4128,7 @@ double SwigDirector_BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElemen Swig::DirectorException::raise("'self' uninitialized, maybe you forgot to call BilinearFormIntegrator.__init__."); } #if defined(SWIG_PYTHON_DIRECTOR_VTABLE) - const size_t swig_method_index = 16; + const size_t swig_method_index = 15; const char *const swig_method_name = "ComputeFluxEnergy"; PyObject *method = swig_get_method(swig_method_index, swig_method_name); swig::SwigVar_PyObject result = PyObject_CallFunctionObjArgs(method ,(PyObject *)obj0,(PyObject *)obj1,(PyObject *)obj2,(PyObject *)obj3, NULL); @@ -4160,66 +4160,33 @@ SwigDirector_BilinearFormIntegrator::~SwigDirector_BilinearFormIntegrator() { #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) NULL ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"ir", NULL + }; mfem::BilinearFormIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BilinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::BilinearFormIntegrator *)new SwigDirector_BilinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_BilinearFormIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + arg1 = obj0; + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BilinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::BilinearFormIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::BilinearFormIntegrator *)new SwigDirector_BilinearFormIntegrator(arg1); + result = (mfem::BilinearFormIntegrator *)new SwigDirector_BilinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -4248,43 +4215,6 @@ SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_new_BilinearFormIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BilinearFormIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_BilinearFormIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - _v = (argv[0] != 0); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BilinearFormIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BilinearFormIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::BilinearFormIntegrator(mfem::IntegrationRule const *)\n" - " mfem::BilinearFormIntegrator::BilinearFormIntegrator(PyObject *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; @@ -4467,7 +4397,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePA(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -4475,17 +4405,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearFormIntegrator_AssemblePAInteriorFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -4494,7 +4428,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObje } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4529,7 +4463,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces(PyObje } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -4537,17 +4471,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearFormIntegrator_AssemblePABoundaryFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -4556,7 +4494,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObje } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4591,7 +4529,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces(PyObje } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4599,17 +4537,21 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BilinearFormIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4618,7 +4560,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *S } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4653,7 +4595,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleDiagonalPA(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4664,17 +4606,22 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearFormIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4682,7 +4629,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4691,7 +4638,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4726,7 +4673,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4737,17 +4684,22 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BilinearFormIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4755,7 +4707,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4764,7 +4716,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4799,7 +4751,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AddMultTransposePA(PyObject *S } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4813,17 +4765,23 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BilinearFormIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4831,7 +4789,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4839,7 +4797,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -4848,7 +4806,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4883,7 +4841,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4900,17 +4858,24 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BilinearFormIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4918,7 +4883,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -4926,7 +4891,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -4934,7 +4899,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -4943,7 +4908,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementMatrix2(PyObjec } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5253,7 +5218,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceMatrix(PyObject *s } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5270,17 +5235,24 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BilinearFormIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5288,7 +5260,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5296,7 +5268,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -5304,7 +5276,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -5313,7 +5285,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject } arg5 = reinterpret_cast< mfem::Vector * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5348,7 +5320,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementVector(PyObject } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5365,17 +5337,24 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BilinearFormIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5383,7 +5362,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5391,7 +5370,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -5399,7 +5378,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -5408,7 +5387,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5443,7 +5422,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleElementGrad(PyObject * } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5463,17 +5442,25 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:BilinearFormIntegrator_AssembleFaceGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5481,7 +5468,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -5489,7 +5476,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -5497,7 +5484,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } @@ -5505,7 +5492,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } @@ -5514,7 +5501,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI } arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5549,7 +5536,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_AssembleFaceGrad(PyObject *SWI } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -5557,7 +5544,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO mfem::Vector *arg4 = 0 ; mfem::FiniteElement *arg5 = 0 ; mfem::Vector *arg6 = 0 ; - bool arg7 ; + bool arg7 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5572,16 +5559,26 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO int res6 = 0 ; bool val7 ; int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; Swig::Director *director = 0; bool upcall = false; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:BilinearFormIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -5589,7 +5586,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -5597,7 +5594,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5605,7 +5602,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } @@ -5613,7 +5610,7 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -5621,13 +5618,15 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + } director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -5662,14 +5661,13 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5680,66 +5678,64 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; Swig::Director *director = 0; bool upcall = false; + double result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:BilinearFormIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { if (upcall) { - (arg1)->mfem::BilinearFormIntegrator::ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } else { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } } #ifdef MFEM_USE_EXCEPTIONS @@ -5760,347 +5756,14 @@ SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(PyO } catch (Swig::DirectorException&) { SWIG_fail; } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeElementFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" - " mfem::BilinearFormIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); - } else { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - Swig::Director *director = 0; - bool upcall = false; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BilinearFormIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); - try { - { - try { - if (upcall) { - result = (double)(arg1)->mfem::BilinearFormIntegrator::ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } else { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - } catch (Swig::DirectorException&) { - SWIG_fail; - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BilinearFormIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BilinearFormIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BilinearFormIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BilinearFormIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::BilinearFormIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; void *argp1 = 0 ; @@ -6140,16 +5803,18 @@ SWIGINTERN PyObject *_wrap_delete_BilinearFormIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_disown_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_BilinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_BilinearFormIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_BilinearFormIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -6177,68 +5842,36 @@ SWIGINTERN PyObject *BilinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_bfi", (char *)"_own_bfi", NULL + }; mfem::TransposeIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_TransposeIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::TransposeIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { try { - result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1); + result = (mfem::TransposeIntegrator *)new mfem::TransposeIntegrator(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6262,53 +5895,7 @@ SWIGINTERN PyObject *_wrap_new_TransposeIntegrator__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_TransposeIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_TransposeIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_TransposeIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_TransposeIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TransposeIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::TransposeIntegrator::TransposeIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6322,15 +5909,21 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TransposeIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6338,7 +5931,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6346,7 +5939,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6380,7 +5973,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix(PyObject *S } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6397,15 +5990,22 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:TransposeIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6413,7 +6013,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -6421,7 +6021,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -6429,7 +6029,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TransposeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -6904,7 +6504,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePA(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -6912,15 +6512,19 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeIntegrator_AssemblePAInteriorFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -6954,7 +6558,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePAInteriorFaces(PyObject } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -6962,15 +6566,19 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeIntegrator_AssemblePABoundaryFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -7004,7 +6612,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AssemblePABoundaryFaces(PyObject } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7015,15 +6623,20 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7031,7 +6644,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7065,7 +6678,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultTransposePA(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7076,15 +6689,20 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::TransposeIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7092,7 +6710,7 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7125,81 +6743,24 @@ SWIGINTERN PyObject *_wrap_TransposeIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR return NULL; } - -SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeIntegrator" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *TransposeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TransposeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + +SWIGINTERN PyObject *_wrap_delete_TransposeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; + mfem::TransposeIntegrator *arg1 = (mfem::TransposeIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::LumpedIntegrator *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TransposeIntegrator" "', argument " "1"" of type '" "mfem::TransposeIntegrator *""'"); } + arg1 = reinterpret_cast< mfem::TransposeIntegrator * >(argp1); { try { - result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1,arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7216,29 +6777,54 @@ SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__LumpedIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *TransposeIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TransposeIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TransposeIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_LumpedIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_bfi", (char *)"_own_bfi", NULL + }; mfem::LumpedIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_LumpedIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_LumpedIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } { try { - result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1); + result = (mfem::LumpedIntegrator *)new mfem::LumpedIntegrator(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7262,53 +6848,7 @@ SWIGINTERN PyObject *_wrap_new_LumpedIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_new_LumpedIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_LumpedIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_LumpedIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_LumpedIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_LumpedIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::LumpedIntegrator::LumpedIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LumpedIntegrator *arg1 = (mfem::LumpedIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7322,15 +6862,21 @@ SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LumpedIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LumpedIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LumpedIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::LumpedIntegrator *""'"); } arg1 = reinterpret_cast< mfem::LumpedIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7338,7 +6884,7 @@ SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7346,7 +6892,7 @@ SWIGINTERN PyObject *_wrap_LumpedIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LumpedIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7431,68 +6977,36 @@ SWIGINTERN PyObject *LumpedIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_InverseIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"integ", (char *)"own_integ", NULL + }; mfem::InverseIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_InverseIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::InverseIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseIntegrator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); { try { - result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1); + result = (mfem::InverseIntegrator *)new mfem::InverseIntegrator(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7516,53 +7030,7 @@ SWIGINTERN PyObject *_wrap_new_InverseIntegrator__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_InverseIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_InverseIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_InverseIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *,int)\n" - " mfem::InverseIntegrator::InverseIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseIntegrator *arg1 = (mfem::InverseIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7576,15 +7044,21 @@ SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:InverseIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::InverseIntegrator *""'"); } arg1 = reinterpret_cast< mfem::InverseIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7592,7 +7066,7 @@ SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7600,7 +7074,7 @@ SWIGINTERN PyObject *_wrap_InverseIntegrator_AssembleElementMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7685,52 +7159,27 @@ SWIGINTERN PyObject *InverseIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SumIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 1 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"own_integs", NULL + }; mfem::SumIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SumIntegrator *)new mfem::SumIntegrator(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_SumIntegrator", kwnames, &obj0)) SWIG_fail; + if (obj0) { + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::SumIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::SumIntegrator *)new mfem::SumIntegrator(); + result = (mfem::SumIntegrator *)new mfem::SumIntegrator(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7754,42 +7203,7 @@ SWIGINTERN PyObject *_wrap_new_SumIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_new_SumIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SumIntegrator", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SumIntegrator__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SumIntegrator__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SumIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SumIntegrator::SumIntegrator(int)\n" - " mfem::SumIntegrator::SumIntegrator()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -7797,15 +7211,19 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"integ", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AddIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SumIntegrator_AddIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AddIntegrator" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); } arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AddIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -7836,7 +7254,7 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AddIntegrator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SumIntegrator *arg1 = (mfem::SumIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7850,15 +7268,21 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SumIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SumIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SumIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::SumIntegrator *""'"); } arg1 = reinterpret_cast< mfem::SumIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7866,7 +7290,7 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7874,7 +7298,7 @@ SWIGINTERN PyObject *_wrap_SumIntegrator_AssembleElementMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SumIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7959,7 +7383,7 @@ SWIGINTERN PyObject *SumIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7976,15 +7400,22 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MixedScalarIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7992,7 +7423,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -8000,7 +7431,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -8008,7 +7439,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -8042,7 +7473,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarIntegrator *arg1 = (mfem::MixedScalarIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8056,15 +7487,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedScalarIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8072,7 +7509,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -8080,7 +7517,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -8161,7 +7598,7 @@ SWIGINTERN PyObject *MixedScalarIntegrator_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8178,15 +7615,22 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MixedVectorIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8194,7 +7638,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -8202,7 +7646,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -8210,7 +7654,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -8244,7 +7688,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix2(PyObject } -SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedVectorIntegrator *arg1 = (mfem::MixedVectorIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8258,15 +7702,21 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedVectorIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedVectorIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MixedVectorIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedVectorIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8274,7 +7724,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -8282,7 +7732,7 @@ SWIGINTERN PyObject *_wrap_MixedVectorIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedVectorIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -8363,7 +7813,7 @@ SWIGINTERN PyObject *MixedVectorIntegrator_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarVectorIntegrator *arg1 = (mfem::MixedScalarVectorIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8380,15 +7830,22 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarVectorIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MixedScalarVectorIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarVectorIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MixedScalarVectorIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarVectorIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8396,7 +7853,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -8404,7 +7861,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -8412,7 +7869,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MixedScalarVectorIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -8647,17 +8104,19 @@ SWIGINTERN PyObject *MixedScalarMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedVectorProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedVectorProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedVectorProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -9204,17 +8663,19 @@ SWIGINTERN PyObject *MixedScalarDivergenceIntegrator_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedVectorDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedVectorDivergenceIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedVectorDivergenceIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedVectorDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -10019,17 +9480,19 @@ SWIGINTERN PyObject *MixedVectorMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -10114,17 +9577,19 @@ SWIGINTERN PyObject *MixedCrossProductIntegrator_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedDotProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedDotProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDotProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -10158,7 +9623,7 @@ SWIGINTERN PyObject *_wrap_new_MixedDotProductIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDotProductIntegrator *arg1 = (mfem::MixedDotProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10169,16 +9634,21 @@ SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedDotProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedDotProductIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDotProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDotProductIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedDotProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10186,7 +9656,7 @@ SWIGINTERN PyObject *_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDotProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -10312,17 +9782,19 @@ SWIGINTERN PyObject *MixedDotProductIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedWeakGradDotIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedWeakGradDotIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakGradDotIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -10356,7 +9828,7 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakGradDotIntegrator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10367,16 +9839,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10384,7 +9861,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -10459,7 +9936,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMe } -SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakGradDotIntegrator *arg1 = (mfem::MixedWeakGradDotIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10473,15 +9950,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakGradDotIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedWeakGradDotIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakGradDotIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedWeakGradDotIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakGradDotIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10489,7 +9972,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10497,7 +9980,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakGradDotIntegrator_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakGradDotIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -10582,17 +10065,19 @@ SWIGINTERN PyObject *MixedWeakGradDotIntegrator_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedWeakDivCrossIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedWeakDivCrossIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakDivCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -10626,7 +10111,7 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakDivCrossIntegrator(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10637,16 +10122,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10654,7 +10144,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -10729,7 +10219,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureM } -SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakDivCrossIntegrator *arg1 = (mfem::MixedWeakDivCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -10743,15 +10233,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakDivCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedWeakDivCrossIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakDivCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakDivCrossIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakDivCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -10759,7 +10255,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -10767,7 +10263,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakDivCrossIntegrator_CalcTestShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakDivCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11059,7 +10555,7 @@ SWIGINTERN PyObject *_wrap_new_MixedGradGradIntegrator(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11070,16 +10566,21 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedGradGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11087,7 +10588,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -11162,7 +10663,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessa } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11176,16 +10677,22 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_GetIntegrationOrder", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradGradIntegrator_GetIntegrationOrder", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11193,7 +10700,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -11201,7 +10708,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_GetIntegrationOrder" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -11235,7 +10742,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_GetIntegrationOrder(PyObject } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11249,15 +10756,21 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11265,7 +10778,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11273,7 +10786,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11307,7 +10820,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTrialShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradGradIntegrator *arg1 = (mfem::MixedGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11321,15 +10834,21 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11337,7 +10856,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11345,7 +10864,7 @@ SWIGINTERN PyObject *_wrap_MixedGradGradIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11430,17 +10949,19 @@ SWIGINTERN PyObject *MixedGradGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossGradGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossGradGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -11474,7 +10995,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradGradIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11485,16 +11006,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11502,7 +11028,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -11577,7 +11103,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11591,15 +11117,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11607,7 +11139,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11615,7 +11147,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11649,7 +11181,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradGradIntegrator *arg1 = (mfem::MixedCrossGradGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11663,15 +11195,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -11679,7 +11217,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11687,7 +11225,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -11979,7 +11517,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCurlCurlIntegrator(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -11990,16 +11528,21 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCurlCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12007,7 +11550,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12082,7 +11625,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessa } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12096,15 +11639,21 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCurlCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12112,7 +11661,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12120,7 +11669,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12154,7 +11703,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTrialShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCurlCurlIntegrator *arg1 = (mfem::MixedCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12168,15 +11717,21 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCurlCurlIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12184,7 +11739,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12192,7 +11747,7 @@ SWIGINTERN PyObject *_wrap_MixedCurlCurlIntegrator_CalcTestShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12277,17 +11832,19 @@ SWIGINTERN PyObject *MixedCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossCurlCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossCurlCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -12321,7 +11878,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlCurlIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12332,16 +11889,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12349,7 +11911,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12424,7 +11986,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12438,15 +12000,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12454,7 +12022,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12462,7 +12030,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12496,7 +12064,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlCurlIntegrator *arg1 = (mfem::MixedCrossCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12510,15 +12078,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlCurlIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12526,7 +12100,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12534,7 +12108,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12619,17 +12193,19 @@ SWIGINTERN PyObject *MixedCrossCurlCurlIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossCurlGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossCurlGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -12663,7 +12239,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlGradIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12674,16 +12250,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12691,7 +12272,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -12766,7 +12347,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12780,15 +12361,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12796,7 +12383,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12804,7 +12391,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12838,7 +12425,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlGradIntegrator *arg1 = (mfem::MixedCrossCurlGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -12852,15 +12439,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -12868,7 +12461,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12876,7 +12469,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlGradIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -12961,17 +12554,19 @@ SWIGINTERN PyObject *MixedCrossCurlGradIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossGradCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossGradCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13005,7 +12600,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradCurlIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13016,16 +12611,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13033,7 +12633,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13108,7 +12708,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13122,15 +12722,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13138,7 +12744,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13146,7 +12752,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13180,7 +12786,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape(PyObject } -SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradCurlIntegrator *arg1 = (mfem::MixedCrossGradCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13194,15 +12800,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradCurlIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradCurlIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13210,7 +12822,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13218,7 +12830,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradCurlIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradCurlIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13303,17 +12915,19 @@ SWIGINTERN PyObject *MixedCrossGradCurlIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedWeakCurlCrossIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedWeakCurlCrossIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13347,7 +12961,7 @@ SWIGINTERN PyObject *_wrap_new_MixedWeakCurlCrossIntegrator(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13358,16 +12972,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13375,7 +12994,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13450,7 +13069,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailure } -SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedWeakCurlCrossIntegrator *arg1 = (mfem::MixedWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13464,15 +13083,21 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedWeakCurlCrossIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedWeakCurlCrossIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedWeakCurlCrossIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13480,7 +13105,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13488,7 +13113,7 @@ SWIGINTERN PyObject *_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedWeakCurlCrossIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13573,17 +13198,19 @@ SWIGINTERN PyObject *MixedWeakCurlCrossIntegrator_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarWeakCurlCrossIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarWeakCurlCrossIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCurlCrossIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13617,7 +13244,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCurlCrossIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13628,16 +13255,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElemen int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13645,7 +13277,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElemen SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13720,7 +13352,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeF } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCurlCrossIntegrator *arg1 = (mfem::MixedScalarWeakCurlCrossIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13734,15 +13366,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCurlCrossIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarWeakCurlCrossIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCurlCrossIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakCurlCrossIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCurlCrossIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13750,7 +13388,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13758,7 +13396,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakCurlCrossIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -13843,17 +13481,19 @@ SWIGINTERN PyObject *MixedScalarWeakCurlCrossIntegrator_swiginit(PyObject *SWIGU return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -13887,7 +13527,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossGradIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -13898,16 +13538,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -13915,7 +13560,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -13990,7 +13635,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMess } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14004,15 +13649,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14020,7 +13671,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14028,7 +13679,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -14062,7 +13713,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTrialShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossGradIntegrator *arg1 = (mfem::MixedCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14076,15 +13727,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"test_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossGradIntegrator_CalcTestShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossGradIntegrator_CalcTestShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "1"" of type '" "mfem::MixedCrossGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14092,7 +13749,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14100,7 +13757,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossGradIntegrator_CalcTestShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossGradIntegrator_CalcTestShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -14185,17 +13842,19 @@ SWIGINTERN PyObject *MixedCrossGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedCrossCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedCrossCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14229,7 +13888,7 @@ SWIGINTERN PyObject *_wrap_new_MixedCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14240,16 +13899,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedCrossCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14257,7 +13921,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -14332,7 +13996,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMess } -SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedCrossCurlIntegrator *arg1 = (mfem::MixedCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14346,15 +14010,21 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedCrossCurlIntegrator_CalcTrialShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedCrossCurlIntegrator_CalcTrialShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "1"" of type '" "mfem::MixedCrossCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14362,7 +14032,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14370,7 +14040,7 @@ SWIGINTERN PyObject *_wrap_MixedCrossCurlIntegrator_CalcTrialShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedCrossCurlIntegrator_CalcTrialShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -14455,17 +14125,19 @@ SWIGINTERN PyObject *MixedCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarCrossCurlIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarCrossCurlIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossCurlIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14499,7 +14171,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossCurlIntegrator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14510,16 +14182,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTyp int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14527,7 +14204,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTyp SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -14602,7 +14279,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailu } -SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossCurlIntegrator *arg1 = (mfem::MixedScalarCrossCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14616,15 +14293,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossCurlIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarCrossCurlIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14632,7 +14315,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14640,7 +14323,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossCurlIntegrator_CalcShape(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossCurlIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -14725,17 +14408,19 @@ SWIGINTERN PyObject *MixedScalarCrossCurlIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarCrossGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarCrossGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14769,7 +14454,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossGradIntegrator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14780,16 +14465,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTyp int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14797,7 +14487,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTyp SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -14872,7 +14562,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailu } -SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossGradIntegrator *arg1 = (mfem::MixedScalarCrossGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -14886,15 +14576,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossGradIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarCrossGradIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedScalarCrossGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -14902,7 +14598,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -14910,7 +14606,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossGradIntegrator_CalcVShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarCrossGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -14995,17 +14691,19 @@ SWIGINTERN PyObject *MixedScalarCrossGradIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarCrossProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarCrossProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -15039,7 +14737,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarCrossProductIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarCrossProductIntegrator *arg1 = (mfem::MixedScalarCrossProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15050,16 +14748,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElement int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarCrossProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarCrossProductIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarCrossProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15067,7 +14770,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElement SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -15193,17 +14896,19 @@ SWIGINTERN PyObject *MixedScalarCrossProductIntegrator_swiginit(PyObject *SWIGUN return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarWeakCrossProductIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarWeakCrossProductIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakCrossProductIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -15237,7 +14942,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakCrossProductIntegrator(PyObject *S } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCrossProductIntegrator *arg1 = (mfem::MixedScalarWeakCrossProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15248,16 +14953,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteEle int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakCrossProductIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCrossProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15265,7 +14975,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteEle SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -15340,7 +15050,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTy } -SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakCrossProductIntegrator *arg1 = (mfem::MixedScalarWeakCrossProductIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15354,15 +15064,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakCrossProductIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarWeakCrossProductIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakCrossProductIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakCrossProductIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakCrossProductIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15370,7 +15086,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15378,7 +15094,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakCrossProductIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -15463,17 +15179,19 @@ SWIGINTERN PyObject *MixedScalarWeakCrossProductIntegrator_swiginit(PyObject *SW return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedDirectionalDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedDirectionalDerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedDirectionalDerivativeIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedDirectionalDerivativeIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDirectionalDerivativeIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -15507,7 +15225,7 @@ SWIGINTERN PyObject *_wrap_new_MixedDirectionalDerivativeIntegrator(PyObject *SW } -SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDirectionalDerivativeIntegrator *arg1 = (mfem::MixedDirectionalDerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15518,16 +15236,21 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElem int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDirectionalDerivativeIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedDirectionalDerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15535,7 +15258,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElem SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -15610,7 +15333,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTyp } -SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDirectionalDerivativeIntegrator *arg1 = (mfem::MixedDirectionalDerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15624,15 +15347,21 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedDirectionalDerivativeIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedDirectionalDerivativeIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDirectionalDerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedDirectionalDerivativeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedDirectionalDerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15640,7 +15369,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15648,7 +15377,7 @@ SWIGINTERN PyObject *_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedDirectionalDerivativeIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -15733,17 +15462,19 @@ SWIGINTERN PyObject *MixedDirectionalDerivativeIntegrator_swiginit(PyObject *SWI return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedGradDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedGradDivIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedGradDivIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedGradDivIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedGradDivIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -15777,7 +15508,7 @@ SWIGINTERN PyObject *_wrap_new_MixedGradDivIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradDivIntegrator *arg1 = (mfem::MixedGradDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15788,16 +15519,21 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedGradDivIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedGradDivIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedGradDivIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedGradDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15805,7 +15541,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradDivIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -15880,7 +15616,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessag } -SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradDivIntegrator *arg1 = (mfem::MixedGradDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15894,15 +15630,21 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradDivIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradDivIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedGradDivIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15910,7 +15652,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15918,7 +15660,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradDivIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -15952,7 +15694,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcVShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedGradDivIntegrator *arg1 = (mfem::MixedGradDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -15966,15 +15708,21 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedGradDivIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedGradDivIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedGradDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedGradDivIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedGradDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -15982,7 +15730,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -15990,7 +15738,7 @@ SWIGINTERN PyObject *_wrap_MixedGradDivIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedGradDivIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -16075,17 +15823,19 @@ SWIGINTERN PyObject *MixedGradDivIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedDivGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedDivGradIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedDivGradIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedDivGradIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedDivGradIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -16119,7 +15869,7 @@ SWIGINTERN PyObject *_wrap_new_MixedDivGradIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDivGradIntegrator *arg1 = (mfem::MixedDivGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -16130,16 +15880,21 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedDivGradIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedDivGradIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedDivGradIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedDivGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16147,7 +15902,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDivGradIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -16222,7 +15977,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessag } -SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDivGradIntegrator *arg1 = (mfem::MixedDivGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -16236,15 +15991,21 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedDivGradIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedDivGradIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedDivGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedDivGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16252,7 +16013,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16260,7 +16021,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedDivGradIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -16294,7 +16055,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcVShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedDivGradIntegrator *arg1 = (mfem::MixedDivGradIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -16308,15 +16069,21 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"scalar_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedDivGradIntegrator_CalcShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedDivGradIntegrator_CalcShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedDivGradIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "1"" of type '" "mfem::MixedDivGradIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedDivGradIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16324,7 +16091,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16332,7 +16099,7 @@ SWIGINTERN PyObject *_wrap_MixedDivGradIntegrator_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedDivGradIntegrator_CalcShape" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -16417,17 +16184,19 @@ SWIGINTERN PyObject *MixedDivGradIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDivergenceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vq", NULL + }; mfem::MixedScalarWeakDivergenceIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MixedScalarWeakDivergenceIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MixedScalarWeakDivergenceIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -16461,7 +16230,7 @@ SWIGINTERN PyObject *_wrap_new_MixedScalarWeakDivergenceIntegrator(PyObject *SWI } -SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakDivergenceIntegrator *arg1 = (mfem::MixedScalarWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -16472,16 +16241,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteEleme int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "1"" of type '" "mfem::MixedScalarWeakDivergenceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16489,7 +16263,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteEleme SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -16564,7 +16338,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementType } -SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MixedScalarWeakDivergenceIntegrator *arg1 = (mfem::MixedScalarWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -16578,15 +16352,21 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vector_fe", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MixedScalarWeakDivergenceIntegrator_CalcVShape", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MixedScalarWeakDivergenceIntegrator_CalcVShape", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MixedScalarWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "1"" of type '" "mfem::MixedScalarWeakDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MixedScalarWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -16594,7 +16374,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16602,7 +16382,7 @@ SWIGINTERN PyObject *_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MixedScalarWeakDivergenceIntegrator_CalcVShape" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -17871,7 +17651,7 @@ SWIGINTERN PyObject *_wrap_new_GradientIntegrator(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -17888,15 +17668,22 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:GradientIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientIntegrator *""'"); } arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -17904,7 +17691,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -17912,7 +17699,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -17920,7 +17707,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -18049,7 +17836,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AssemblePA(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18060,15 +17847,20 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GradientIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -18076,7 +17868,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -18110,7 +17902,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientIntegrator *arg1 = (mfem::GradientIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18121,15 +17913,20 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GradientIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::GradientIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::GradientIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -18137,7 +17934,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -18171,7 +17968,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_AddMultTransposePA(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -18182,11 +17979,16 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GradientIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GradientIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } @@ -18194,7 +17996,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -18202,7 +18004,7 @@ SWIGINTERN PyObject *_wrap_GradientIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -18482,7 +18284,7 @@ SWIGINTERN PyObject *_wrap_delete_DiffusionIntegrator(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -18496,15 +18298,21 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DiffusionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -18512,7 +18320,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -18520,7 +18328,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -18554,7 +18362,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix(PyObject *S } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -18571,15 +18379,22 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DiffusionIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -18587,7 +18402,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -18595,7 +18410,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -18603,7 +18418,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -18637,7 +18452,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementMatrix2(PyObject * } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -18654,15 +18469,22 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DiffusionIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -18670,227 +18492,33 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleElementVector(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - bool arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); - { - try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + (arg1)->AssembleElementVector((mfem::FiniteElement const &)*arg2,*arg3,(mfem::Vector const &)*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18914,101 +18542,15 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DiffusionIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeElementFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" - " mfem::DiffusionIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -19019,46 +18561,77 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - double result; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:DiffusionIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "DiffusionIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19075,19 +18648,20 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(PyObjec SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -19096,15 +18670,25 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:DiffusionIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19112,7 +18696,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -19120,7 +18704,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -19128,9 +18712,16 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DiffusionIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + } { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19154,75 +18745,6 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::DiffusionIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; @@ -19303,7 +18825,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssemblePA(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -19311,15 +18833,19 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiffusionIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -19353,7 +18879,7 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -19364,15 +18890,20 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DiffusionIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -19380,71 +18911,17 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::DiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElement *arg1 = 0 ; - mfem::FiniteElement *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - mfem::IntegrationRule *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); + ((mfem::DiffusionIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19461,47 +18938,48 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; - bool arg3 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", NULL + }; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DiffusionIntegrator_GetRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); { try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); + result = (mfem::IntegrationRule *) &mfem::DiffusionIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19518,29 +18996,38 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DiffusionIntegrator *arg1 = (mfem::DiffusionIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; + bool arg3 = (bool) (bool)false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", (char *)"force", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:DiffusionIntegrator_SetupPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::DiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -19548,9 +19035,16 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiffusionIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DiffusionIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } { try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19574,56 +19068,6 @@ SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_DiffusionIntegrator_SetupPA(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DiffusionIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DiffusionIntegrator_SetupPA__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DiffusionIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DiffusionIntegrator_SetupPA__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DiffusionIntegrator_SetupPA'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" - " mfem::DiffusionIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); - return 0; -} - - SWIGINTERN PyObject *DiffusionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -19637,51 +19081,22 @@ SWIGINTERN PyObject *DiffusionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self) SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; + mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) NULL ; void *argp1 = 0 ; int res1 = 0 ; mfem::MassIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); - } - arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); - { - try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if ((nobjs < 0) || (nobjs > 1)) SWIG_fail; + if (swig_obj[0]) { + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::IntegrationRule const *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::MassIntegrator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator((mfem::IntegrationRule const *)arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19705,17 +19120,17 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; mfem::MassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -19724,56 +19139,16 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MassIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::MassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1); + result = (mfem::MassIntegrator *)new mfem::MassIntegrator(*arg1,(mfem::IntegrationRule const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19805,38 +19180,32 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_MassIntegrator", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 1)) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 0) { return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MassIntegrator__SWIG_3(self, argc, argv); + return _wrap_new_MassIntegrator__SWIG_0(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MassIntegrator__SWIG_2(self, argc, argv); + return _wrap_new_MassIntegrator__SWIG_1(self, argc, argv); } } } @@ -19845,9 +19214,7 @@ SWIGINTERN PyObject *_wrap_new_MassIntegrator(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MassIntegrator'.\n" " Possible C/C++ prototypes are:\n" " mfem::MassIntegrator::MassIntegrator(mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator()\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" - " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &)\n"); + " mfem::MassIntegrator::MassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n"); return 0; } @@ -19892,7 +19259,7 @@ SWIGINTERN PyObject *_wrap_delete_MassIntegrator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19906,15 +19273,21 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MassIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19922,7 +19295,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -19930,7 +19303,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -19964,7 +19337,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -19981,15 +19354,22 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:MassIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -19997,7 +19377,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -20005,7 +19385,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -20013,7 +19393,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleElementMatrix2(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "MassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -20127,7 +19507,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssemblePA(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -20135,15 +19515,19 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MassIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -20177,7 +19561,7 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -20188,15 +19572,20 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MassIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::MassIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -20204,82 +19593,17 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::MassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElement *arg1 = 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - mfem::IntegrationRule *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "MassIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::IntegrationRule *) &mfem::MassIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); + ((mfem::MassIntegrator const *)arg1)->AddMultPA((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20296,47 +19620,60 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; - mfem::FiniteElementSpace *arg2 = 0 ; - bool arg3 ; + mfem::FiniteElement *arg1 = 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MassIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MassIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); { try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); + result = (mfem::IntegrationRule *) &mfem::MassIntegrator::GetRule((mfem::FiniteElement const &)*arg1,(mfem::FiniteElement const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20353,29 +19690,38 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MassIntegrator *arg1 = (mfem::MassIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; + bool arg3 = (bool) (bool)false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", (char *)"force", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:MassIntegrator_SetupPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MassIntegrator_SetupPA" "', argument " "1"" of type '" "mfem::MassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::MassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -20383,9 +19729,16 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MassIntegrator_SetupPA" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MassIntegrator_SetupPA" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } { try { - (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2); + (arg1)->SetupPA((mfem::FiniteElementSpace const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -20409,56 +19762,6 @@ SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_MassIntegrator_SetupPA(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MassIntegrator_SetupPA", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MassIntegrator_SetupPA__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MassIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MassIntegrator_SetupPA__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MassIntegrator_SetupPA'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &,bool const)\n" - " mfem::MassIntegrator::SetupPA(mfem::FiniteElementSpace const &)\n"); - return 0; -} - - SWIGINTERN PyObject *MassIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -20470,17 +19773,19 @@ SWIGINTERN PyObject *MassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BoundaryMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"q", NULL + }; mfem::BoundaryMassIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_BoundaryMassIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -20926,18 +20231,23 @@ SWIGINTERN PyObject *BoundaryMassIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; + double arg2 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"q", (char *)"a", NULL + }; mfem::ConvectionIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_ConvectionIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -20945,56 +20255,16 @@ SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::ConvectionIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1); + result = (mfem::ConvectionIntegrator *)new mfem::ConvectionIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21018,52 +20288,7 @@ SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_ConvectionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConvectionIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_ConvectionIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConvectionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::ConvectionIntegrator::ConvectionIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -21077,15 +20302,21 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", (char *)"arg4", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ConvectionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -21093,7 +20324,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -21101,7 +20332,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -21215,7 +20446,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AssemblePA(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConvectionIntegrator *arg1 = (mfem::ConvectionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -21226,15 +20457,20 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConvectionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConvectionIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::ConvectionIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -21242,7 +20478,7 @@ SWIGINTERN PyObject *_wrap_ConvectionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConvectionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21451,74 +20687,13 @@ SWIGINTERN PyObject *_wrap_delete_ConvectionIntegrator(PyObject *SWIGUNUSEDPARM( if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *ConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::GroupConvectionIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConvectionIntegrator" "', argument " "1"" of type '" "mfem::ConvectionIntegrator *""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + arg1 = reinterpret_cast< mfem::ConvectionIntegrator * >(argp1); { try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21535,22 +20710,41 @@ SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_0(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GroupConvectionIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *ConvectionIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ConvectionIntegrator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ConvectionIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; + double arg2 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"q", (char *)"a", NULL + }; mfem::GroupConvectionIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_GroupConvectionIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -21558,9 +20752,16 @@ SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GroupConvectionIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GroupConvectionIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + } { try { - result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1); + result = (mfem::GroupConvectionIntegrator *)new mfem::GroupConvectionIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -21584,52 +20785,7 @@ SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_GroupConvectionIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GroupConvectionIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_GroupConvectionIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GroupConvectionIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &,double)\n" - " mfem::GroupConvectionIntegrator::GroupConvectionIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GroupConvectionIntegrator *arg1 = (mfem::GroupConvectionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -21643,15 +20799,21 @@ SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", (char *)"arg4", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GroupConvectionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GroupConvectionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GroupConvectionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::GroupConvectionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::GroupConvectionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -21659,7 +20821,7 @@ SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -21667,7 +20829,7 @@ SWIGINTERN PyObject *_wrap_GroupConvectionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GroupConvectionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -21786,12 +20948,12 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - int arg2 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -21800,11 +20962,13 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -21833,48 +20997,6 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -21924,15 +21046,15 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); @@ -21941,57 +21063,17 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22015,15 +21097,15 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_5(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; - int arg2 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::VectorMassIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); @@ -22032,57 +21114,17 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_6(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorMassIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorMassIntegrator" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); { try { - result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1); + result = (mfem::VectorMassIntegrator *)new mfem::VectorMassIntegrator(*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -22101,55 +21143,31 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator__SWIG_7(PyObject *SWIGUNUSED } resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorMassIntegrator, SWIG_POINTER_NEW | 0 ); return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorMassIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_VectorMassIntegrator__SWIG_0(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_5(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_7(self, argc, argv); - } +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorMassIntegrator", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_VectorMassIntegrator__SWIG_0(self, argc, argv); } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -22159,30 +21177,41 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar } } if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); } } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); + if (argc <= 1) { + return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { return _wrap_new_VectorMassIntegrator__SWIG_3(self, argc, argv); } } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -22192,7 +21221,7 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar } } if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_6(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_4(self, argc, argv); } } } @@ -22202,16 +21231,11 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorMassIntegrator__SWIG_1(self, argc, argv); + return _wrap_new_VectorMassIntegrator__SWIG_2(self, argc, argv); } } } @@ -22221,12 +21245,9 @@ SWIGINTERN PyObject *_wrap_new_VectorMassIntegrator(PyObject *self, PyObject *ar " Possible C/C++ prototypes are:\n" " mfem::VectorMassIntegrator::VectorMassIntegrator()\n" " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &)\n" " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n" " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::VectorCoefficient &)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n" - " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &)\n"); + " mfem::VectorMassIntegrator::VectorMassIntegrator(mfem::MatrixCoefficient &,int)\n"); return 0; } @@ -22272,25 +21293,29 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_GetVDim(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_SetVDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorMassIntegrator_SetVDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_SetVDim" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -22318,7 +21343,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_SetVDim(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22332,15 +21357,21 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorMassIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22348,7 +21379,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -22356,7 +21387,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -22390,7 +21421,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22407,15 +21438,22 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorMassIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22423,7 +21461,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -22431,7 +21469,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -22439,7 +21477,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -22553,7 +21591,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssemblePA(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -22561,15 +21599,19 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorMassIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -22603,7 +21645,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AssembleDiagonalPA(PyObject *SWI } -SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorMassIntegrator *arg1 = (mfem::VectorMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -22614,15 +21656,20 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorMassIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorMassIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -22630,7 +21677,7 @@ SWIGINTERN PyObject *_wrap_VectorMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22818,7 +21865,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFEDivergenceIntegrator(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22832,15 +21879,21 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEDivergenceIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22848,7 +21901,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -22856,7 +21909,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -22890,7 +21943,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix(Py } -SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEDivergenceIntegrator *arg1 = (mfem::VectorFEDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -22907,15 +21960,22 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFEDivergenceIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -22923,7 +21983,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -22931,7 +21991,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -22939,7 +21999,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -23127,7 +22187,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFEWeakDivergenceIntegrator(PyObject *self, } -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -23141,15 +22201,21 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23157,7 +22223,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -23165,7 +22231,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -23199,7 +22265,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri } -SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEWeakDivergenceIntegrator *arg1 = (mfem::VectorFEWeakDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -23216,15 +22282,22 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEWeakDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEWeakDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEWeakDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23232,7 +22305,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -23240,7 +22313,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -23248,7 +22321,7 @@ SWIGINTERN PyObject *_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatri SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -23436,7 +22509,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFECurlIntegrator(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -23450,15 +22523,21 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFECurlIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23466,7 +22545,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -23474,7 +22553,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -23508,7 +22587,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFECurlIntegrator *arg1 = (mfem::VectorFECurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -23525,15 +22604,22 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFECurlIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFECurlIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFECurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFECurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFECurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23541,7 +22627,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -23549,7 +22635,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -23557,7 +22643,7 @@ SWIGINTERN PyObject *_wrap_VectorFECurlIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFECurlIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -23642,17 +22728,21 @@ SWIGINTERN PyObject *VectorFECurlIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"q", (char *)"i", NULL + }; mfem::DerivativeIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DerivativeIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_DerivativeIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DerivativeIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -23661,10 +22751,10 @@ SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(sel } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -23692,7 +22782,7 @@ SWIGINTERN PyObject *_wrap_new_DerivativeIntegrator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -23706,15 +22796,21 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DerivativeIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23722,7 +22818,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -23730,7 +22826,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -23764,7 +22860,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix(PyObject * } -SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DerivativeIntegrator *arg1 = (mfem::DerivativeIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -23781,15 +22877,22 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DerivativeIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DerivativeIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DerivativeIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DerivativeIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DerivativeIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -23797,7 +22900,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -23805,7 +22908,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -23813,7 +22916,7 @@ SWIGINTERN PyObject *_wrap_DerivativeIntegrator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DerivativeIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -24053,7 +23156,7 @@ SWIGINTERN PyObject *_wrap_new_CurlCurlIntegrator(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -24067,15 +23170,21 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:CurlCurlIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -24083,7 +23192,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -24091,7 +23200,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -24125,7 +23234,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleElementMatrix(PyObject *SW } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -24148,15 +23257,24 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU int res6 = 0 ; bool val7 ; int ecode7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeElementFlux", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:CurlCurlIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -24164,7 +23282,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -24172,7 +23290,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -24180,7 +23298,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } @@ -24188,7 +23306,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); } arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -24196,7 +23314,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + ecode7 = SWIG_AsVal_bool(obj6, &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CurlCurlIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); } @@ -24227,13 +23345,13 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeElementFlux(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -24244,15 +23362,23 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; double result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:CurlCurlIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -24260,7 +23386,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -24268,7 +23394,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -24276,175 +23402,36 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - { - try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + arg5 = reinterpret_cast< mfem::Vector * >(argp5); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__CurlCurlIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CurlCurlIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CurlCurlIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::CurlCurlIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; + return NULL; } @@ -24528,7 +23515,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssemblePA(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -24539,15 +23526,20 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CurlCurlIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -24555,7 +23547,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlCurlIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -24589,7 +23581,7 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlCurlIntegrator *arg1 = (mfem::CurlCurlIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -24597,15 +23589,19 @@ SWIGINTERN PyObject *_wrap_CurlCurlIntegrator_AssembleDiagonalPA(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlCurlIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CurlCurlIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::CurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::CurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlCurlIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -24793,7 +23789,7 @@ SWIGINTERN PyObject *_wrap_new_VectorCurlCurlIntegrator(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -24807,15 +23803,21 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorCurlCurlIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -24823,7 +23825,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -24831,7 +23833,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -24865,7 +23867,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix(PyObje } -SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCurlCurlIntegrator *arg1 = (mfem::VectorCurlCurlIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -24879,16 +23881,22 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "VectorCurlCurlIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorCurlCurlIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCurlCurlIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::VectorCurlCurlIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorCurlCurlIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -24896,7 +23904,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -24904,7 +23912,7 @@ SWIGINTERN PyObject *_wrap_VectorCurlCurlIntegrator_GetElementEnergy(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCurlCurlIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -25343,7 +24351,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFEMassIntegrator(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -25357,15 +24365,21 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEMassIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -25373,7 +24387,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -25381,7 +24395,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -25415,7 +24429,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix(PyObject } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -25432,15 +24446,22 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorFEMassIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -25448,7 +24469,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -25456,7 +24477,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -25464,7 +24485,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorFEMassIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -25578,7 +24599,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssemblePA(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -25589,15 +24610,20 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorFEMassIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -25605,7 +24631,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEMassIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -25639,7 +24665,7 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AddMultPA(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEMassIntegrator *arg1 = (mfem::VectorFEMassIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -25647,15 +24673,19 @@ SWIGINTERN PyObject *_wrap_VectorFEMassIntegrator_AssembleDiagonalPA(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEMassIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorFEMassIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEMassIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorFEMassIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEMassIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEMassIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -25892,7 +24922,7 @@ SWIGINTERN PyObject *_wrap_new_VectorDivergenceIntegrator(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -25909,15 +24939,22 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorDivergenceIntegrator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -25925,7 +24962,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -25933,7 +24970,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -25941,7 +24978,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDivergenceIntegrator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -26070,7 +25107,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AssemblePA(PyObject *self, } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -26081,15 +25118,20 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDivergenceIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -26097,7 +25139,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -26131,7 +25173,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultPA(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDivergenceIntegrator *arg1 = (mfem::VectorDivergenceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -26142,15 +25184,20 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDivergenceIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDivergenceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::VectorDivergenceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorDivergenceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -26158,7 +25205,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -26192,7 +25239,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_AddMultTransposePA(PyObjec } -SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26203,11 +25250,16 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"trial_fe", (char *)"test_fe", (char *)"Trans", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorDivergenceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDivergenceIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } @@ -26215,7 +25267,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26223,7 +25275,7 @@ SWIGINTERN PyObject *_wrap_VectorDivergenceIntegrator_GetRule(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDivergenceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -26411,7 +25463,7 @@ SWIGINTERN PyObject *_wrap_new_DivDivIntegrator(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivDivIntegrator *arg1 = (mfem::DivDivIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26425,15 +25477,21 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DivDivIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DivDivIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivDivIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::DivDivIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DivDivIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26441,7 +25499,7 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -26449,7 +25507,7 @@ SWIGINTERN PyObject *_wrap_DivDivIntegrator_AssembleElementMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivDivIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -26637,7 +25695,7 @@ SWIGINTERN PyObject *_wrap_new_VectorDiffusionIntegrator(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26651,15 +25709,21 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorDiffusionIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26667,7 +25731,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -26675,7 +25739,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -26709,7 +25773,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementMatrix(PyObj } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -26726,15 +25790,22 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorDiffusionIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -26742,7 +25813,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -26750,7 +25821,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -26758,7 +25829,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorDiffusionIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -26872,7 +25943,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssemblePA(PyObject *self, } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -26880,15 +25951,19 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AssembleDiagonalPA", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDiffusionIntegrator_AssembleDiagonalPA", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AssembleDiagonalPA" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -26922,7 +25997,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA(PyObject } -SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDiffusionIntegrator *arg1 = (mfem::VectorDiffusionIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -26933,15 +26008,20 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDiffusionIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorDiffusionIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDiffusionIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorDiffusionIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorDiffusionIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -26949,7 +26029,7 @@ SWIGINTERN PyObject *_wrap_VectorDiffusionIntegrator_AddMultPA(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDiffusionIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -27204,7 +26284,7 @@ SWIGINTERN PyObject *_wrap_new_ElasticityIntegrator(PyObject *self, PyObject *ar } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -27218,15 +26298,21 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", (char *)"arg4", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_AssembleElementMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ElasticityIntegrator_AssembleElementMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -27234,7 +26320,7 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -27242,211 +26328,17 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_AssembleElementMatrix(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - try { - (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - bool arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); - { - try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::FiniteElement *arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); - } - arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_AssembleElementMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6); + (arg1)->AssembleElementMatrix((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27470,101 +26362,15 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeElementFlux", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ElasticityIntegrator_ComputeElementFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeElementFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &,bool)\n" - " mfem::ElasticityIntegrator::ComputeElementFlux(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::FiniteElement const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeElementFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = (mfem::Vector *) 0 ; + mfem::FiniteElement *arg5 = 0 ; + mfem::Vector *arg6 = 0 ; + bool arg7 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -27575,46 +26381,77 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObje int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - double result; + void *argp6 = 0 ; + int res6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Trans", (char *)"u", (char *)"fluxelem", (char *)"flux", (char *)"with_coef", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:ElasticityIntegrator_ComputeElementFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "5"" of type '" "mfem::FiniteElement const &""'"); + } + arg5 = reinterpret_cast< mfem::FiniteElement * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "6"" of type '" "mfem::Vector &""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ElasticityIntegrator_ComputeElementFlux" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); + (arg1)->ComputeElementFlux((mfem::FiniteElement const &)*arg2,*arg3,*arg4,(mfem::FiniteElement const &)*arg5,*arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27631,19 +26468,20 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; mfem::ElementTransformation *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -27652,15 +26490,25 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fluxelem", (char *)"Trans", (char *)"flux", (char *)"d_energy", NULL + }; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:ElasticityIntegrator_ComputeFluxEnergy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElasticityIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "1"" of type '" "mfem::ElasticityIntegrator *""'"); } arg1 = reinterpret_cast< mfem::ElasticityIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -27668,7 +26516,7 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -27676,7 +26524,7 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -27684,9 +26532,16 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ElasticityIntegrator_ComputeFluxEnergy" "', argument " "5"" of type '" "mfem::Vector *""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + } { try { - result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4); + result = (double)(arg1)->ComputeFluxEnergy((mfem::FiniteElement const &)*arg2,*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -27710,75 +26565,6 @@ SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_ElasticityIntegrator_ComputeFluxEnergy(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ElasticityIntegrator_ComputeFluxEnergy", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElasticityIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__FiniteElement, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ElasticityIntegrator_ComputeFluxEnergy__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElasticityIntegrator_ComputeFluxEnergy'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &,mfem::Vector *)\n" - " mfem::ElasticityIntegrator::ComputeFluxEnergy(mfem::FiniteElement const &,mfem::ElementTransformation &,mfem::Vector &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_ElasticityIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ElasticityIntegrator *arg1 = (mfem::ElasticityIntegrator *) 0 ; @@ -28395,7 +27181,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssembleFaceMatrix(PyObject *self, } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -28403,15 +27189,19 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePAInteriorFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DGTraceIntegrator_AssemblePAInteriorFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePAInteriorFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -28445,7 +27235,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePAInteriorFaces(PyObject *S } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -28453,15 +27243,19 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AssemblePABoundaryFaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DGTraceIntegrator_AssemblePABoundaryFaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "1"" of type '" "mfem::DGTraceIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AssemblePABoundaryFaces" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -28495,7 +27289,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AssemblePABoundaryFaces(PyObject *S } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -28506,15 +27300,20 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultTransposePA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DGTraceIntegrator_AddMultTransposePA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -28522,7 +27321,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultTransposePA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28556,7 +27355,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultTransposePA(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DGTraceIntegrator *arg1 = (mfem::DGTraceIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -28567,15 +27366,20 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", (char *)"arg3", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DGTraceIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DGTraceIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::DGTraceIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::DGTraceIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -28583,7 +27387,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -28617,7 +27421,7 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry::Type arg1 ; int arg2 ; @@ -28626,22 +27430,27 @@ SWIGINTERN PyObject *_wrap_DGTraceIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(se int ecode1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"geom", (char *)"order", (char *)"T", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DGTraceIntegrator_GetRule", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DGTraceIntegrator_GetRule", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "DGTraceIntegrator_GetRule" "', argument " "1"" of type '" "mfem::Geometry::Type""'"); } arg1 = static_cast< mfem::Geometry::Type >(val1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DGTraceIntegrator_GetRule" "', argument " "3"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -30994,7 +29803,7 @@ SWIGINTERN PyObject *DiscreteInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientInterpolator *arg1 = (mfem::GradientInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -31011,15 +29820,22 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h1_fe", (char *)"nd_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:GradientInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::GradientInterpolator *""'"); } arg1 = reinterpret_cast< mfem::GradientInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -31027,7 +29843,7 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -31035,7 +29851,7 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -31043,7 +29859,7 @@ SWIGINTERN PyObject *_wrap_GradientInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GradientInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -31159,7 +29975,7 @@ SWIGINTERN PyObject *GradientInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityInterpolator *arg1 = (mfem::IdentityInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -31176,15 +29992,22 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:IdentityInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::IdentityInterpolator *""'"); } arg1 = reinterpret_cast< mfem::IdentityInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -31192,7 +30015,7 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -31200,7 +30023,7 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -31208,7 +30031,7 @@ SWIGINTERN PyObject *_wrap_IdentityInterpolator_AssembleElementMatrix2(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IdentityInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -31324,7 +30147,7 @@ SWIGINTERN PyObject *IdentityInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlInterpolator *arg1 = (mfem::CurlInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -31341,15 +30164,22 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:CurlInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::CurlInterpolator *""'"); } arg1 = reinterpret_cast< mfem::CurlInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -31357,7 +30187,7 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -31365,7 +30195,7 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -31373,7 +30203,7 @@ SWIGINTERN PyObject *_wrap_CurlInterpolator_AssembleElementMatrix2(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CurlInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -31489,7 +30319,7 @@ SWIGINTERN PyObject *CurlInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivergenceInterpolator *arg1 = (mfem::DivergenceInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -31506,15 +30336,22 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DivergenceInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DivergenceInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivergenceInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::DivergenceInterpolator *""'"); } arg1 = reinterpret_cast< mfem::DivergenceInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -31522,7 +30359,7 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -31530,7 +30367,7 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -31538,7 +30375,7 @@ SWIGINTERN PyObject *_wrap_DivergenceInterpolator_AssembleElementMatrix2(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "DivergenceInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -31654,7 +30491,7 @@ SWIGINTERN PyObject *DivergenceInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NormalInterpolator *arg1 = (mfem::NormalInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -31671,15 +30508,22 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NormalInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NormalInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NormalInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::NormalInterpolator *""'"); } arg1 = reinterpret_cast< mfem::NormalInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -31687,7 +30531,7 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -31695,7 +30539,7 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -31703,7 +30547,7 @@ SWIGINTERN PyObject *_wrap_NormalInterpolator_AssembleElementMatrix2(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NormalInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -31819,17 +30663,19 @@ SWIGINTERN PyObject *NormalInterpolator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"sc", NULL + }; mfem::ScalarProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ScalarProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -31863,7 +30709,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarProductInterpolator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarProductInterpolator *arg1 = (mfem::ScalarProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -31880,15 +30726,22 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ScalarProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::ScalarProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -31896,7 +30749,7 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -31904,7 +30757,7 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -31912,7 +30765,7 @@ SWIGINTERN PyObject *_wrap_ScalarProductInterpolator_AssembleElementMatrix2(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -31997,17 +30850,19 @@ SWIGINTERN PyObject *ScalarProductInterpolator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"sc", NULL + }; mfem::ScalarVectorProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ScalarVectorProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductInterpolator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -32041,7 +30896,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarVectorProductInterpolator(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarVectorProductInterpolator *arg1 = (mfem::ScalarVectorProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -32058,15 +30913,22 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarVectorProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ScalarVectorProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarVectorProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::ScalarVectorProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::ScalarVectorProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -32074,7 +30936,7 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -32082,7 +30944,7 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -32090,7 +30952,7 @@ SWIGINTERN PyObject *_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ScalarVectorProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -32175,17 +31037,19 @@ SWIGINTERN PyObject *ScalarVectorProductInterpolator_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vc", NULL + }; mfem::VectorScalarProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorScalarProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorScalarProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -32219,7 +31083,7 @@ SWIGINTERN PyObject *_wrap_new_VectorScalarProductInterpolator(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorScalarProductInterpolator *arg1 = (mfem::VectorScalarProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -32236,15 +31100,22 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dom_fe", (char *)"ran_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorScalarProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorScalarProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorScalarProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorScalarProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::VectorScalarProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -32252,7 +31123,7 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -32260,7 +31131,7 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -32268,7 +31139,7 @@ SWIGINTERN PyObject *_wrap_VectorScalarProductInterpolator_AssembleElementMatrix SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorScalarProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -32353,17 +31224,19 @@ SWIGINTERN PyObject *VectorScalarProductInterpolator_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vc", NULL + }; mfem::VectorCrossProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorCrossProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -32397,7 +31270,7 @@ SWIGINTERN PyObject *_wrap_new_VectorCrossProductInterpolator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCrossProductInterpolator *arg1 = (mfem::VectorCrossProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -32414,15 +31287,22 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nd_fe", (char *)"rt_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorCrossProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorCrossProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCrossProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorCrossProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::VectorCrossProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -32430,7 +31310,7 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -32438,7 +31318,7 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -32446,7 +31326,7 @@ SWIGINTERN PyObject *_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorCrossProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -32531,17 +31411,19 @@ SWIGINTERN PyObject *VectorCrossProductInterpolator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vc", NULL + }; mfem::VectorInnerProductInterpolator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorInnerProductInterpolator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorInnerProductInterpolator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -32575,7 +31457,7 @@ SWIGINTERN PyObject *_wrap_new_VectorInnerProductInterpolator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorInnerProductInterpolator *arg1 = (mfem::VectorInnerProductInterpolator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -32592,15 +31474,22 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rt_fe", (char *)"l2_fe", (char *)"Trans", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorInnerProductInterpolator_AssembleElementMatrix2", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorInnerProductInterpolator_AssembleElementMatrix2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorInnerProductInterpolator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "1"" of type '" "mfem::VectorInnerProductInterpolator *""'"); } arg1 = reinterpret_cast< mfem::VectorInnerProductInterpolator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -32608,7 +31497,7 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -32616,7 +31505,7 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } @@ -32624,7 +31513,7 @@ SWIGINTERN PyObject *_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "4"" of type '" "mfem::ElementTransformation &""'"); } arg4 = reinterpret_cast< mfem::ElementTransformation * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorInnerProductInterpolator_AssembleElementMatrix2" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -32712,35 +31601,35 @@ SWIGINTERN PyObject *VectorInnerProductInterpolator_swiginit(PyObject *SWIGUNUSE static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, + { "new_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BilinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> BilinearFormIntegrator"}, { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(BilinearFormIntegrator self)\n" "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" "BilinearFormIntegrator_AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "BilinearFormIntegrator_AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "BilinearFormIntegrator_AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, - { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "BilinearFormIntegrator_AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "BilinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "BilinearFormIntegrator_ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, - { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, + { "disown_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_TransposeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_TransposeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> TransposeIntegrator"}, + { "TransposeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "TransposeIntegrator_AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -32750,38 +31639,38 @@ static PyMethodDef SwigMethods[] = { "AssemblePA()\n" "TransposeIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "TransposeIntegrator_AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "TransposeIntegrator_AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "TransposeIntegrator_AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, - { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "TransposeIntegrator_AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "TransposeIntegrator_AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_LumpedIntegrator", (PyCFunction)(void(*)(void))_wrap_new_LumpedIntegrator, METH_VARARGS|METH_KEYWORDS, "new_LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> LumpedIntegrator"}, + { "LumpedIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "LumpedIntegrator_AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, - { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_InverseIntegrator", (PyCFunction)(void(*)(void))_wrap_new_InverseIntegrator, METH_VARARGS|METH_KEYWORDS, "new_InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1) -> InverseIntegrator"}, + { "InverseIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "InverseIntegrator_AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, - { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, - { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_SumIntegrator", (PyCFunction)(void(*)(void))_wrap_new_SumIntegrator, METH_VARARGS|METH_KEYWORDS, "new_SumIntegrator(int own_integs=1) -> SumIntegrator"}, + { "SumIntegrator_AddIntegrator", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AddIntegrator, METH_VARARGS|METH_KEYWORDS, "SumIntegrator_AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "SumIntegrator_AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, - { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MixedScalarIntegrator_AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedScalarIntegrator_AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, - { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MixedVectorIntegrator_AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "MixedVectorIntegrator_AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, - { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MixedScalarVectorIntegrator_AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" @@ -32791,7 +31680,7 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedScalarMassIntegrator", _wrap_delete_MixedScalarMassIntegrator, METH_O, "delete_MixedScalarMassIntegrator(MixedScalarMassIntegrator self)"}, { "MixedScalarMassIntegrator_swigregister", MixedScalarMassIntegrator_swigregister, METH_O, NULL}, { "MixedScalarMassIntegrator_swiginit", MixedScalarMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorProductIntegrator", _wrap_new_MixedVectorProductIntegrator, METH_O, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, + { "new_MixedVectorProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, { "delete_MixedVectorProductIntegrator", _wrap_delete_MixedVectorProductIntegrator, METH_O, "delete_MixedVectorProductIntegrator(MixedVectorProductIntegrator self)"}, { "MixedVectorProductIntegrator_swigregister", MixedVectorProductIntegrator_swigregister, METH_O, NULL}, { "MixedVectorProductIntegrator_swiginit", MixedVectorProductIntegrator_swiginit, METH_VARARGS, NULL}, @@ -32816,7 +31705,7 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedScalarDivergenceIntegrator", _wrap_delete_MixedScalarDivergenceIntegrator, METH_O, "delete_MixedScalarDivergenceIntegrator(MixedScalarDivergenceIntegrator self)"}, { "MixedScalarDivergenceIntegrator_swigregister", MixedScalarDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarDivergenceIntegrator_swiginit", MixedScalarDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorDivergenceIntegrator", _wrap_new_MixedVectorDivergenceIntegrator, METH_O, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, + { "new_MixedVectorDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, { "delete_MixedVectorDivergenceIntegrator", _wrap_delete_MixedVectorDivergenceIntegrator, METH_O, "delete_MixedVectorDivergenceIntegrator(MixedVectorDivergenceIntegrator self)"}, { "MixedVectorDivergenceIntegrator_swigregister", MixedVectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedVectorDivergenceIntegrator_swiginit", MixedVectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -32850,27 +31739,27 @@ static PyMethodDef SwigMethods[] = { { "delete_MixedVectorMassIntegrator", _wrap_delete_MixedVectorMassIntegrator, METH_O, "delete_MixedVectorMassIntegrator(MixedVectorMassIntegrator self)"}, { "MixedVectorMassIntegrator_swigregister", MixedVectorMassIntegrator_swigregister, METH_O, NULL}, { "MixedVectorMassIntegrator_swiginit", MixedVectorMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossProductIntegrator", _wrap_new_MixedCrossProductIntegrator, METH_O, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, + { "new_MixedCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, { "delete_MixedCrossProductIntegrator", _wrap_delete_MixedCrossProductIntegrator, METH_O, "delete_MixedCrossProductIntegrator(MixedCrossProductIntegrator self)"}, { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, - { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDotProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDotProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedDotProductIntegrator_VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDotProductIntegrator_FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, - { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakGradDotIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakGradDotIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, - { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedWeakGradDotIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedWeakGradDotIntegrator_CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, - { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakDivCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakDivCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, - { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedWeakDivCrossIntegrator_CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, @@ -32880,19 +31769,19 @@ static PyMethodDef SwigMethods[] = { "MixedGradGradIntegrator(VectorCoefficient dq)\n" "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" ""}, - { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradGradIntegrator_FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, - { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, - { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedGradGradIntegrator_CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, - { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, - { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradGradIntegrator_CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradGradIntegrator_CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, @@ -32902,120 +31791,120 @@ static PyMethodDef SwigMethods[] = { "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" ""}, - { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, - { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCurlCurlIntegrator_CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCurlCurlIntegrator_CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, - { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlCurlIntegrator_CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlCurlIntegrator_CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, - { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, - { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlGradIntegrator_CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlGradIntegrator_CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, - { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, - { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradCurlIntegrator_CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradCurlIntegrator_CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, - { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedWeakCurlCrossIntegrator_CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, - { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCurlCrossIntegrator_CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, - { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradIntegrator_VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, - { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradIntegrator_CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossGradIntegrator_CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, - { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlIntegrator_VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "MixedCrossCurlIntegrator_CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, - { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, - { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossCurlIntegrator_CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, - { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, - { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossGradIntegrator_CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, - { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, - { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, - { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakCrossProductIntegrator_CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, - { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDirectionalDerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDirectionalDerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, - { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedDirectionalDerivativeIntegrator_CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, - { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedGradDivIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedGradDivIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedGradDivIntegrator_VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedGradDivIntegrator_FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, - { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedGradDivIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedGradDivIntegrator_CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedGradDivIntegrator_CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, - { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDivGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDivGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedDivGradIntegrator_VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedDivGradIntegrator_FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, - { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedDivGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedDivGradIntegrator_CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "MixedDivGradIntegrator_CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, - { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, - { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "MixedScalarWeakDivergenceIntegrator_CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33060,14 +31949,14 @@ static PyMethodDef SwigMethods[] = { "GradientIntegrator(Coefficient _q)\n" "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" ""}, - { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "GradientIntegrator_AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "GradientIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "GradientIntegrator_AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "GradientIntegrator_AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "GradientIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GradientIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33077,39 +31966,39 @@ static PyMethodDef SwigMethods[] = { "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" ""}, { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, - { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "DiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "DiffusionIntegrator_AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, - { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, - { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, - { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "DiffusionIntegrator_SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "DiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "DiffusionIntegrator_SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" "MassIntegrator(IntegrationRule ir=None)\n" - "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" + "new_MassIntegrator(Coefficient q, IntegrationRule ir=None) -> MassIntegrator\n" ""}, { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, - { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "MassIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "MassIntegrator_AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, - { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, - { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, - { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "MassIntegrator_SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "MassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "MassIntegrator_SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, + { "new_BoundaryMassIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryMassIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "BoundaryMassIntegrator_AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -33118,13 +32007,13 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_ConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_ConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_ConvectionIntegrator(VectorCoefficient q, double a=1.0) -> ConvectionIntegrator"}, + { "ConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "ConvectionIntegrator_AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "ConvectionIntegrator_AssemblePA(FiniteElementSpace arg1)\n" ""}, - { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "ConvectionIntegrator_AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "ConvectionIntegrator_AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" "ConvectionIntegrator_GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" "ConvectionIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" @@ -33132,8 +32021,8 @@ static PyMethodDef SwigMethods[] = { { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_GroupConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_GroupConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_GroupConvectionIntegrator(VectorCoefficient q, double a=1.0) -> GroupConvectionIntegrator"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "GroupConvectionIntegrator_AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33142,18 +32031,18 @@ static PyMethodDef SwigMethods[] = { "VectorMassIntegrator(Coefficient q, int qo=0)\n" "VectorMassIntegrator(Coefficient q, IntegrationRule ir)\n" "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" - "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" + "new_VectorMassIntegrator(MatrixCoefficient q, int qo=0) -> VectorMassIntegrator\n" ""}, { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "VectorMassIntegrator_GetVDim(VectorMassIntegrator self) -> int"}, - { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, - { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_SetVDim", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_SetVDim, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorMassIntegrator_AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, - { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "VectorMassIntegrator_AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, + { "VectorMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorMassIntegrator_AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33161,8 +32050,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEDivergenceIntegrator()\n" "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" ""}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFEDivergenceIntegrator_AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFEDivergenceIntegrator_AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33170,8 +32059,8 @@ static PyMethodDef SwigMethods[] = { "VectorFEWeakDivergenceIntegrator()\n" "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" ""}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33179,14 +32068,14 @@ static PyMethodDef SwigMethods[] = { "VectorFECurlIntegrator()\n" "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" ""}, - { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFECurlIntegrator_AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFECurlIntegrator_AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, - { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_DerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, + { "DerivativeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "DerivativeIntegrator_AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "DerivativeIntegrator_AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33195,15 +32084,15 @@ static PyMethodDef SwigMethods[] = { "CurlCurlIntegrator(Coefficient q)\n" "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" ""}, - { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, - { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "CurlCurlIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "CurlCurlIntegrator_AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, - { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "CurlCurlIntegrator_AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, + { "CurlCurlIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "CurlCurlIntegrator_AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33211,8 +32100,8 @@ static PyMethodDef SwigMethods[] = { "VectorCurlCurlIntegrator()\n" "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" ""}, - { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorCurlCurlIntegrator_AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "VectorCurlCurlIntegrator_GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33225,14 +32114,14 @@ static PyMethodDef SwigMethods[] = { "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" ""}, - { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorFEMassIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "VectorFEMassIntegrator_AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, - { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorFEMassIntegrator_AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, + { "VectorFEMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "VectorFEMassIntegrator_AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33241,14 +32130,14 @@ static PyMethodDef SwigMethods[] = { "VectorDivergenceIntegrator(Coefficient _q)\n" "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" ""}, - { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorDivergenceIntegrator_AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "VectorDivergenceIntegrator_AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "VectorDivergenceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "VectorDivergenceIntegrator_GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33256,7 +32145,7 @@ static PyMethodDef SwigMethods[] = { "DivDivIntegrator()\n" "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" ""}, - { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivDivIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "DivDivIntegrator_AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33264,14 +32153,14 @@ static PyMethodDef SwigMethods[] = { "VectorDiffusionIntegrator()\n" "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" ""}, - { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "VectorDiffusionIntegrator_AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "VectorDiffusionIntegrator_AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, - { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "VectorDiffusionIntegrator_AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorDiffusionIntegrator_AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33279,9 +32168,9 @@ static PyMethodDef SwigMethods[] = { "ElasticityIntegrator(Coefficient l, Coefficient m)\n" "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" ""}, - { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, - { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "ElasticityIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "ElasticityIntegrator_AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ElasticityIntegrator_ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ElasticityIntegrator_ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33294,11 +32183,11 @@ static PyMethodDef SwigMethods[] = { "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "DGTraceIntegrator_AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "DGTraceIntegrator_AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "DGTraceIntegrator_AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, - { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "DGTraceIntegrator_AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, - { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "DGTraceIntegrator_GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33349,53 +32238,53 @@ static PyMethodDef SwigMethods[] = { { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, - { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "GradientInterpolator_AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, - { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "IdentityInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "IdentityInterpolator_AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, - { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "CurlInterpolator_AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, - { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivergenceInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "DivergenceInterpolator_AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, - { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "NormalInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "NormalInterpolator_AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, - { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "ScalarProductInterpolator_AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, - { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarVectorProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "ScalarVectorProductInterpolator_AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, - { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorScalarProductInterpolator_AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, - { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorCrossProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorCrossProductInterpolator_AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, - { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorInnerProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorInnerProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "VectorInnerProductInterpolator_AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, @@ -33405,35 +32294,35 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_BilinearFormIntegrator", _wrap_new_BilinearFormIntegrator, METH_VARARGS, "BilinearFormIntegrator(IntegrationRule ir=None)"}, + { "new_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BilinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> BilinearFormIntegrator"}, { "BilinearFormIntegrator_AssemblePA", _wrap_BilinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(BilinearFormIntegrator self)\n" "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace fes)\n" "AssemblePA(BilinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "BilinearFormIntegrator_AssemblePAInteriorFaces", _wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssemblePABoundaryFaces", _wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, - { "BilinearFormIntegrator_AssembleDiagonalPA", _wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, - { "BilinearFormIntegrator_AddMultPA", _wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AddMultTransposePA", _wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, - { "BilinearFormIntegrator_AssembleElementMatrix", _wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleElementMatrix2", _wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePAInteriorFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePABoundaryFaces(BilinearFormIntegrator self, FiniteElementSpace fes)"}, + { "BilinearFormIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(BilinearFormIntegrator self, Vector diag)"}, + { "BilinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(BilinearFormIntegrator self, Vector x, Vector y)"}, + { "BilinearFormIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(BilinearFormIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "BilinearFormIntegrator_AssembleFaceMatrix", _wrap_BilinearFormIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(BilinearFormIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "BilinearFormIntegrator_AssembleElementVector", _wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "BilinearFormIntegrator_AssembleElementGrad", _wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_AssembleFaceGrad", _wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "BilinearFormIntegrator_ComputeElementFlux", _wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "BilinearFormIntegrator_ComputeFluxEnergy", _wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "BilinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "BilinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "AssembleFaceGrad(BilinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "BilinearFormIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(BilinearFormIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "BilinearFormIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_BilinearFormIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(BilinearFormIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_BilinearFormIntegrator", _wrap_delete_BilinearFormIntegrator, METH_O, "delete_BilinearFormIntegrator(BilinearFormIntegrator self)"}, - { "disown_BilinearFormIntegrator", _wrap_disown_BilinearFormIntegrator, METH_O, NULL}, + { "disown_BilinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_BilinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "BilinearFormIntegrator_swigregister", BilinearFormIntegrator_swigregister, METH_O, NULL}, { "BilinearFormIntegrator_swiginit", BilinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_TransposeIntegrator", _wrap_new_TransposeIntegrator, METH_VARARGS, "TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "TransposeIntegrator_AssembleElementMatrix", _wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "TransposeIntegrator_AssembleElementMatrix2", _wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_TransposeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_TransposeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_TransposeIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> TransposeIntegrator"}, + { "TransposeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(TransposeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "TransposeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(TransposeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "TransposeIntegrator_AssembleFaceMatrix", _wrap_TransposeIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(TransposeIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -33443,38 +32332,38 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "TransposeIntegrator_AssemblePAInteriorFaces", _wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AssemblePABoundaryFaces", _wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, - { "TransposeIntegrator_AddMultTransposePA", _wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, - { "TransposeIntegrator_AddMultPA", _wrap_TransposeIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePAInteriorFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePABoundaryFaces(TransposeIntegrator self, FiniteElementSpace fes)"}, + { "TransposeIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(TransposeIntegrator self, Vector x, Vector y)"}, + { "TransposeIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_TransposeIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(TransposeIntegrator self, Vector x, Vector y)"}, { "delete_TransposeIntegrator", _wrap_delete_TransposeIntegrator, METH_O, "delete_TransposeIntegrator(TransposeIntegrator self)"}, { "TransposeIntegrator_swigregister", TransposeIntegrator_swigregister, METH_O, NULL}, { "TransposeIntegrator_swiginit", TransposeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_LumpedIntegrator", _wrap_new_LumpedIntegrator, METH_VARARGS, "LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1)"}, - { "LumpedIntegrator_AssembleElementMatrix", _wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_LumpedIntegrator", (PyCFunction)(void(*)(void))_wrap_new_LumpedIntegrator, METH_VARARGS|METH_KEYWORDS, "new_LumpedIntegrator(BilinearFormIntegrator _bfi, int _own_bfi=1) -> LumpedIntegrator"}, + { "LumpedIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_LumpedIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(LumpedIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_LumpedIntegrator", _wrap_delete_LumpedIntegrator, METH_O, "delete_LumpedIntegrator(LumpedIntegrator self)"}, { "LumpedIntegrator_swigregister", LumpedIntegrator_swigregister, METH_O, NULL}, { "LumpedIntegrator_swiginit", LumpedIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_InverseIntegrator", _wrap_new_InverseIntegrator, METH_VARARGS, "InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1)"}, - { "InverseIntegrator_AssembleElementMatrix", _wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_InverseIntegrator", (PyCFunction)(void(*)(void))_wrap_new_InverseIntegrator, METH_VARARGS|METH_KEYWORDS, "new_InverseIntegrator(BilinearFormIntegrator integ, int own_integ=1) -> InverseIntegrator"}, + { "InverseIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_InverseIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(InverseIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_InverseIntegrator", _wrap_delete_InverseIntegrator, METH_O, "delete_InverseIntegrator(InverseIntegrator self)"}, { "InverseIntegrator_swigregister", InverseIntegrator_swigregister, METH_O, NULL}, { "InverseIntegrator_swiginit", InverseIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_SumIntegrator", _wrap_new_SumIntegrator, METH_VARARGS, "SumIntegrator(int own_integs=1)"}, - { "SumIntegrator_AddIntegrator", _wrap_SumIntegrator_AddIntegrator, METH_VARARGS, "AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, - { "SumIntegrator_AssembleElementMatrix", _wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_SumIntegrator", (PyCFunction)(void(*)(void))_wrap_new_SumIntegrator, METH_VARARGS|METH_KEYWORDS, "new_SumIntegrator(int own_integs=1) -> SumIntegrator"}, + { "SumIntegrator_AddIntegrator", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AddIntegrator, METH_VARARGS|METH_KEYWORDS, "AddIntegrator(SumIntegrator self, BilinearFormIntegrator integ)"}, + { "SumIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_SumIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(SumIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_SumIntegrator", _wrap_delete_SumIntegrator, METH_O, "delete_SumIntegrator(SumIntegrator self)"}, { "SumIntegrator_swigregister", SumIntegrator_swigregister, METH_O, NULL}, { "SumIntegrator_swiginit", SumIntegrator_swiginit, METH_VARARGS, NULL}, - { "MixedScalarIntegrator_AssembleElementMatrix2", _wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedScalarIntegrator_AssembleElementMatrix", _wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MixedScalarIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedScalarIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(MixedScalarIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarIntegrator", _wrap_delete_MixedScalarIntegrator, METH_O, "delete_MixedScalarIntegrator(MixedScalarIntegrator self)"}, { "MixedScalarIntegrator_swigregister", MixedScalarIntegrator_swigregister, METH_O, NULL}, - { "MixedVectorIntegrator_AssembleElementMatrix2", _wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MixedVectorIntegrator_AssembleElementMatrix", _wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MixedVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedVectorIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MixedVectorIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(MixedVectorIntegrator self, FiniteElement fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedVectorIntegrator", _wrap_delete_MixedVectorIntegrator, METH_O, "delete_MixedVectorIntegrator(MixedVectorIntegrator self)"}, { "MixedVectorIntegrator_swigregister", MixedVectorIntegrator_swigregister, METH_O, NULL}, - { "MixedScalarVectorIntegrator_AssembleElementMatrix2", _wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MixedScalarVectorIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MixedScalarVectorIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MixedScalarVectorIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_MixedScalarVectorIntegrator", _wrap_delete_MixedScalarVectorIntegrator, METH_O, "delete_MixedScalarVectorIntegrator(MixedScalarVectorIntegrator self)"}, { "MixedScalarVectorIntegrator_swigregister", MixedScalarVectorIntegrator_swigregister, METH_O, NULL}, { "new_MixedScalarMassIntegrator", _wrap_new_MixedScalarMassIntegrator, METH_VARARGS, "\n" @@ -33484,7 +32373,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedScalarMassIntegrator", _wrap_delete_MixedScalarMassIntegrator, METH_O, "delete_MixedScalarMassIntegrator(MixedScalarMassIntegrator self)"}, { "MixedScalarMassIntegrator_swigregister", MixedScalarMassIntegrator_swigregister, METH_O, NULL}, { "MixedScalarMassIntegrator_swiginit", MixedScalarMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorProductIntegrator", _wrap_new_MixedVectorProductIntegrator, METH_O, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, + { "new_MixedVectorProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorProductIntegrator(VectorCoefficient vq) -> MixedVectorProductIntegrator"}, { "delete_MixedVectorProductIntegrator", _wrap_delete_MixedVectorProductIntegrator, METH_O, "delete_MixedVectorProductIntegrator(MixedVectorProductIntegrator self)"}, { "MixedVectorProductIntegrator_swigregister", MixedVectorProductIntegrator_swigregister, METH_O, NULL}, { "MixedVectorProductIntegrator_swiginit", MixedVectorProductIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33509,7 +32398,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedScalarDivergenceIntegrator", _wrap_delete_MixedScalarDivergenceIntegrator, METH_O, "delete_MixedScalarDivergenceIntegrator(MixedScalarDivergenceIntegrator self)"}, { "MixedScalarDivergenceIntegrator_swigregister", MixedScalarDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarDivergenceIntegrator_swiginit", MixedScalarDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedVectorDivergenceIntegrator", _wrap_new_MixedVectorDivergenceIntegrator, METH_O, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, + { "new_MixedVectorDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedVectorDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedVectorDivergenceIntegrator(VectorCoefficient vq) -> MixedVectorDivergenceIntegrator"}, { "delete_MixedVectorDivergenceIntegrator", _wrap_delete_MixedVectorDivergenceIntegrator, METH_O, "delete_MixedVectorDivergenceIntegrator(MixedVectorDivergenceIntegrator self)"}, { "MixedVectorDivergenceIntegrator_swigregister", MixedVectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedVectorDivergenceIntegrator_swiginit", MixedVectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33543,27 +32432,27 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MixedVectorMassIntegrator", _wrap_delete_MixedVectorMassIntegrator, METH_O, "delete_MixedVectorMassIntegrator(MixedVectorMassIntegrator self)"}, { "MixedVectorMassIntegrator_swigregister", MixedVectorMassIntegrator_swigregister, METH_O, NULL}, { "MixedVectorMassIntegrator_swiginit", MixedVectorMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossProductIntegrator", _wrap_new_MixedCrossProductIntegrator, METH_O, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, + { "new_MixedCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossProductIntegrator(VectorCoefficient vq) -> MixedCrossProductIntegrator"}, { "delete_MixedCrossProductIntegrator", _wrap_delete_MixedCrossProductIntegrator, METH_O, "delete_MixedCrossProductIntegrator(MixedCrossProductIntegrator self)"}, { "MixedCrossProductIntegrator_swigregister", MixedCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedCrossProductIntegrator_swiginit", MixedCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDotProductIntegrator", _wrap_new_MixedDotProductIntegrator, METH_O, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, - { "MixedDotProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDotProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDotProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDotProductIntegrator(VectorCoefficient vq) -> MixedDotProductIntegrator"}, + { "MixedDotProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDotProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedDotProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDotProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDotProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDotProductIntegrator self) -> char const *"}, { "delete_MixedDotProductIntegrator", _wrap_delete_MixedDotProductIntegrator, METH_O, "delete_MixedDotProductIntegrator(MixedDotProductIntegrator self)"}, { "MixedDotProductIntegrator_swigregister", MixedDotProductIntegrator_swigregister, METH_O, NULL}, { "MixedDotProductIntegrator_swiginit", MixedDotProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakGradDotIntegrator", _wrap_new_MixedWeakGradDotIntegrator, METH_O, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, - { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakGradDotIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakGradDotIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakGradDotIntegrator(VectorCoefficient vq) -> MixedWeakGradDotIntegrator"}, + { "MixedWeakGradDotIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedWeakGradDotIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakGradDotIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakGradDotIntegrator self) -> char const *"}, - { "MixedWeakGradDotIntegrator_CalcShape", _wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedWeakGradDotIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakGradDotIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedWeakGradDotIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedWeakGradDotIntegrator", _wrap_delete_MixedWeakGradDotIntegrator, METH_O, "delete_MixedWeakGradDotIntegrator(MixedWeakGradDotIntegrator self)"}, { "MixedWeakGradDotIntegrator_swigregister", MixedWeakGradDotIntegrator_swigregister, METH_O, NULL}, { "MixedWeakGradDotIntegrator_swiginit", MixedWeakGradDotIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakDivCrossIntegrator", _wrap_new_MixedWeakDivCrossIntegrator, METH_O, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, - { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakDivCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakDivCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakDivCrossIntegrator(VectorCoefficient vq) -> MixedWeakDivCrossIntegrator"}, + { "MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedWeakDivCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakDivCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakDivCrossIntegrator self) -> char const *"}, - { "MixedWeakDivCrossIntegrator_CalcTestShape", _wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakDivCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakDivCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedWeakDivCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakDivCrossIntegrator", _wrap_delete_MixedWeakDivCrossIntegrator, METH_O, "delete_MixedWeakDivCrossIntegrator(MixedWeakDivCrossIntegrator self)"}, { "MixedWeakDivCrossIntegrator_swigregister", MixedWeakDivCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakDivCrossIntegrator_swiginit", MixedWeakDivCrossIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33573,19 +32462,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MixedGradGradIntegrator(VectorCoefficient dq)\n" "new_MixedGradGradIntegrator(MatrixCoefficient mq) -> MixedGradGradIntegrator\n" ""}, - { "MixedGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradGradIntegrator self) -> char const *"}, - { "MixedGradGradIntegrator_GetIntegrationOrder", _wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS, "GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, - { "MixedGradGradIntegrator_CalcTrialShape", _wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradGradIntegrator_CalcTestShape", _wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_GetIntegrationOrder", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_GetIntegrationOrder, METH_VARARGS|METH_KEYWORDS, "GetIntegrationOrder(MixedGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> int"}, + { "MixedGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedGradGradIntegrator", _wrap_delete_MixedGradGradIntegrator, METH_O, "delete_MixedGradGradIntegrator(MixedGradGradIntegrator self)"}, { "MixedGradGradIntegrator_swigregister", MixedGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedGradGradIntegrator_swiginit", MixedGradGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradGradIntegrator", _wrap_new_MixedCrossGradGradIntegrator, METH_O, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, - { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradGradIntegrator(VectorCoefficient vq) -> MixedCrossGradGradIntegrator"}, + { "MixedCrossGradGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradGradIntegrator self) -> char const *"}, - { "MixedCrossGradGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradGradIntegrator_CalcTestShape", _wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossGradGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossGradGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradGradIntegrator", _wrap_delete_MixedCrossGradGradIntegrator, METH_O, "delete_MixedCrossGradGradIntegrator(MixedCrossGradGradIntegrator self)"}, { "MixedCrossGradGradIntegrator_swigregister", MixedCrossGradGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradGradIntegrator_swiginit", MixedCrossGradGradIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33595,120 +32484,120 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MixedCurlCurlIntegrator(VectorCoefficient dq)\n" "new_MixedCurlCurlIntegrator(MatrixCoefficient mq) -> MixedCurlCurlIntegrator\n" ""}, - { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "MixedCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCurlCurlIntegrator self) -> char const *"}, - { "MixedCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCurlCurlIntegrator_CalcTestShape", _wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCurlCurlIntegrator", _wrap_delete_MixedCurlCurlIntegrator, METH_O, "delete_MixedCurlCurlIntegrator(MixedCurlCurlIntegrator self)"}, { "MixedCurlCurlIntegrator_swigregister", MixedCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCurlCurlIntegrator_swiginit", MixedCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlCurlIntegrator", _wrap_new_MixedCrossCurlCurlIntegrator, METH_O, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, - { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlCurlIntegrator"}, + { "MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlCurlIntegrator_CalcTestShape", _wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossCurlCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossCurlCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlCurlIntegrator", _wrap_delete_MixedCrossCurlCurlIntegrator, METH_O, "delete_MixedCrossCurlCurlIntegrator(MixedCrossCurlCurlIntegrator self)"}, { "MixedCrossCurlCurlIntegrator_swigregister", MixedCrossCurlCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlCurlIntegrator_swiginit", MixedCrossCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlGradIntegrator", _wrap_new_MixedCrossCurlGradIntegrator, METH_O, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, - { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlGradIntegrator(VectorCoefficient vq) -> MixedCrossCurlGradIntegrator"}, + { "MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlGradIntegrator self) -> char const *"}, - { "MixedCrossCurlGradIntegrator_CalcTrialShape", _wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossCurlGradIntegrator_CalcTestShape", _wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossCurlGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossCurlGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlGradIntegrator", _wrap_delete_MixedCrossCurlGradIntegrator, METH_O, "delete_MixedCrossCurlGradIntegrator(MixedCrossCurlGradIntegrator self)"}, { "MixedCrossCurlGradIntegrator_swigregister", MixedCrossCurlGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlGradIntegrator_swiginit", MixedCrossCurlGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradCurlIntegrator", _wrap_new_MixedCrossGradCurlIntegrator, METH_O, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, - { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradCurlIntegrator(VectorCoefficient vq) -> MixedCrossGradCurlIntegrator"}, + { "MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradCurlIntegrator self) -> char const *"}, - { "MixedCrossGradCurlIntegrator_CalcTrialShape", _wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradCurlIntegrator_CalcTestShape", _wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossGradCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradCurlIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradCurlIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossGradCurlIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradCurlIntegrator", _wrap_delete_MixedCrossGradCurlIntegrator, METH_O, "delete_MixedCrossGradCurlIntegrator(MixedCrossGradCurlIntegrator self)"}, { "MixedCrossGradCurlIntegrator_swigregister", MixedCrossGradCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradCurlIntegrator_swiginit", MixedCrossGradCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedWeakCurlCrossIntegrator", _wrap_new_MixedWeakCurlCrossIntegrator, METH_O, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, - { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedWeakCurlCrossIntegrator"}, + { "MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedWeakCurlCrossIntegrator_CalcTestShape", _wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedWeakCurlCrossIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedWeakCurlCrossIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedWeakCurlCrossIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedWeakCurlCrossIntegrator", _wrap_delete_MixedWeakCurlCrossIntegrator, METH_O, "delete_MixedWeakCurlCrossIntegrator(MixedWeakCurlCrossIntegrator self)"}, { "MixedWeakCurlCrossIntegrator_swigregister", MixedWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedWeakCurlCrossIntegrator_swiginit", MixedWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCurlCrossIntegrator", _wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_O, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, - { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCurlCrossIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCurlCrossIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCurlCrossIntegrator(VectorCoefficient vq) -> MixedScalarWeakCurlCrossIntegrator"}, + { "MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarWeakCurlCrossIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCurlCrossIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCurlCrossIntegrator self) -> char const *"}, - { "MixedScalarWeakCurlCrossIntegrator_CalcShape", _wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCurlCrossIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCurlCrossIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedScalarWeakCurlCrossIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCurlCrossIntegrator", _wrap_delete_MixedScalarWeakCurlCrossIntegrator, METH_O, "delete_MixedScalarWeakCurlCrossIntegrator(MixedScalarWeakCurlCrossIntegrator self)"}, { "MixedScalarWeakCurlCrossIntegrator_swigregister", MixedScalarWeakCurlCrossIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCurlCrossIntegrator_swiginit", MixedScalarWeakCurlCrossIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossGradIntegrator", _wrap_new_MixedCrossGradIntegrator, METH_O, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, - { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossGradIntegrator(VectorCoefficient vq) -> MixedCrossGradIntegrator"}, + { "MixedCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossGradIntegrator self) -> char const *"}, - { "MixedCrossGradIntegrator_CalcTrialShape", _wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedCrossGradIntegrator_CalcTestShape", _wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS, "CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossGradIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossGradIntegrator_CalcTestShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossGradIntegrator_CalcTestShape, METH_VARARGS|METH_KEYWORDS, "CalcTestShape(MixedCrossGradIntegrator self, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossGradIntegrator", _wrap_delete_MixedCrossGradIntegrator, METH_O, "delete_MixedCrossGradIntegrator(MixedCrossGradIntegrator self)"}, { "MixedCrossGradIntegrator_swigregister", MixedCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedCrossGradIntegrator_swiginit", MixedCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedCrossCurlIntegrator", _wrap_new_MixedCrossCurlIntegrator, METH_O, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, - { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedCrossCurlIntegrator(VectorCoefficient vq) -> MixedCrossCurlIntegrator"}, + { "MixedCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedCrossCurlIntegrator self) -> char const *"}, - { "MixedCrossCurlIntegrator_CalcTrialShape", _wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS, "CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedCrossCurlIntegrator_CalcTrialShape", (PyCFunction)(void(*)(void))_wrap_MixedCrossCurlIntegrator_CalcTrialShape, METH_VARARGS|METH_KEYWORDS, "CalcTrialShape(MixedCrossCurlIntegrator self, FiniteElement trial_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedCrossCurlIntegrator", _wrap_delete_MixedCrossCurlIntegrator, METH_O, "delete_MixedCrossCurlIntegrator(MixedCrossCurlIntegrator self)"}, { "MixedCrossCurlIntegrator_swigregister", MixedCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedCrossCurlIntegrator_swiginit", MixedCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossCurlIntegrator", _wrap_new_MixedScalarCrossCurlIntegrator, METH_O, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, - { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossCurlIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossCurlIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossCurlIntegrator(VectorCoefficient vq) -> MixedScalarCrossCurlIntegrator"}, + { "MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarCrossCurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossCurlIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossCurlIntegrator self) -> char const *"}, - { "MixedScalarCrossCurlIntegrator_CalcShape", _wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarCrossCurlIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossCurlIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedScalarCrossCurlIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarCrossCurlIntegrator", _wrap_delete_MixedScalarCrossCurlIntegrator, METH_O, "delete_MixedScalarCrossCurlIntegrator(MixedScalarCrossCurlIntegrator self)"}, { "MixedScalarCrossCurlIntegrator_swigregister", MixedScalarCrossCurlIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossCurlIntegrator_swiginit", MixedScalarCrossCurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossGradIntegrator", _wrap_new_MixedScalarCrossGradIntegrator, METH_O, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, - { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossGradIntegrator(VectorCoefficient vq) -> MixedScalarCrossGradIntegrator"}, + { "MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarCrossGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossGradIntegrator self) -> char const *"}, - { "MixedScalarCrossGradIntegrator_CalcVShape", _wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarCrossGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedScalarCrossGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarCrossGradIntegrator", _wrap_delete_MixedScalarCrossGradIntegrator, METH_O, "delete_MixedScalarCrossGradIntegrator(MixedScalarCrossGradIntegrator self)"}, { "MixedScalarCrossGradIntegrator_swigregister", MixedScalarCrossGradIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossGradIntegrator_swiginit", MixedScalarCrossGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarCrossProductIntegrator", _wrap_new_MixedScalarCrossProductIntegrator, METH_O, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, - { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarCrossProductIntegrator"}, + { "MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarCrossProductIntegrator self) -> char const *"}, { "delete_MixedScalarCrossProductIntegrator", _wrap_delete_MixedScalarCrossProductIntegrator, METH_O, "delete_MixedScalarCrossProductIntegrator(MixedScalarCrossProductIntegrator self)"}, { "MixedScalarCrossProductIntegrator_swigregister", MixedScalarCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarCrossProductIntegrator_swiginit", MixedScalarCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakCrossProductIntegrator", _wrap_new_MixedScalarWeakCrossProductIntegrator, METH_O, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, - { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakCrossProductIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakCrossProductIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakCrossProductIntegrator(VectorCoefficient vq) -> MixedScalarWeakCrossProductIntegrator"}, + { "MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarWeakCrossProductIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakCrossProductIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakCrossProductIntegrator self) -> char const *"}, - { "MixedScalarWeakCrossProductIntegrator_CalcShape", _wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedScalarWeakCrossProductIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakCrossProductIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedScalarWeakCrossProductIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedScalarWeakCrossProductIntegrator", _wrap_delete_MixedScalarWeakCrossProductIntegrator, METH_O, "delete_MixedScalarWeakCrossProductIntegrator(MixedScalarWeakCrossProductIntegrator self)"}, { "MixedScalarWeakCrossProductIntegrator_swigregister", MixedScalarWeakCrossProductIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakCrossProductIntegrator_swiginit", MixedScalarWeakCrossProductIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDirectionalDerivativeIntegrator", _wrap_new_MixedDirectionalDerivativeIntegrator, METH_O, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, - { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", _wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDirectionalDerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDirectionalDerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDirectionalDerivativeIntegrator(VectorCoefficient vq) -> MixedDirectionalDerivativeIntegrator"}, + { "MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedDirectionalDerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDirectionalDerivativeIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDirectionalDerivativeIntegrator self) -> char const *"}, - { "MixedDirectionalDerivativeIntegrator_CalcVShape", _wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDirectionalDerivativeIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDirectionalDerivativeIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedDirectionalDerivativeIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedDirectionalDerivativeIntegrator", _wrap_delete_MixedDirectionalDerivativeIntegrator, METH_O, "delete_MixedDirectionalDerivativeIntegrator(MixedDirectionalDerivativeIntegrator self)"}, { "MixedDirectionalDerivativeIntegrator_swigregister", MixedDirectionalDerivativeIntegrator_swigregister, METH_O, NULL}, { "MixedDirectionalDerivativeIntegrator_swiginit", MixedDirectionalDerivativeIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedGradDivIntegrator", _wrap_new_MixedGradDivIntegrator, METH_O, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, - { "MixedGradDivIntegrator_VerifyFiniteElementTypes", _wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedGradDivIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedGradDivIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedGradDivIntegrator(VectorCoefficient vq) -> MixedGradDivIntegrator"}, + { "MixedGradDivIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedGradDivIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedGradDivIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedGradDivIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedGradDivIntegrator self) -> char const *"}, - { "MixedGradDivIntegrator_CalcVShape", _wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedGradDivIntegrator_CalcShape", _wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedGradDivIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedGradDivIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedGradDivIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedGradDivIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedGradDivIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedGradDivIntegrator", _wrap_delete_MixedGradDivIntegrator, METH_O, "delete_MixedGradDivIntegrator(MixedGradDivIntegrator self)"}, { "MixedGradDivIntegrator_swigregister", MixedGradDivIntegrator_swigregister, METH_O, NULL}, { "MixedGradDivIntegrator_swiginit", MixedGradDivIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedDivGradIntegrator", _wrap_new_MixedDivGradIntegrator, METH_O, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, - { "MixedDivGradIntegrator_VerifyFiniteElementTypes", _wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedDivGradIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedDivGradIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedDivGradIntegrator(VectorCoefficient vq) -> MixedDivGradIntegrator"}, + { "MixedDivGradIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedDivGradIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedDivGradIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedDivGradIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedDivGradIntegrator self) -> char const *"}, - { "MixedDivGradIntegrator_CalcVShape", _wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, - { "MixedDivGradIntegrator_CalcShape", _wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS, "CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, + { "MixedDivGradIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedDivGradIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedDivGradIntegrator_CalcShape", (PyCFunction)(void(*)(void))_wrap_MixedDivGradIntegrator_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(MixedDivGradIntegrator self, FiniteElement scalar_fe, ElementTransformation Trans, Vector shape)"}, { "delete_MixedDivGradIntegrator", _wrap_delete_MixedDivGradIntegrator, METH_O, "delete_MixedDivGradIntegrator(MixedDivGradIntegrator self)"}, { "MixedDivGradIntegrator_swigregister", MixedDivGradIntegrator_swigregister, METH_O, NULL}, { "MixedDivGradIntegrator_swiginit", MixedDivGradIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_MixedScalarWeakDivergenceIntegrator", _wrap_new_MixedScalarWeakDivergenceIntegrator, METH_O, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, - { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", _wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS, "VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, + { "new_MixedScalarWeakDivergenceIntegrator", (PyCFunction)(void(*)(void))_wrap_new_MixedScalarWeakDivergenceIntegrator, METH_VARARGS|METH_KEYWORDS, "new_MixedScalarWeakDivergenceIntegrator(VectorCoefficient vq) -> MixedScalarWeakDivergenceIntegrator"}, + { "MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_VerifyFiniteElementTypes, METH_VARARGS|METH_KEYWORDS, "VerifyFiniteElementTypes(MixedScalarWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe) -> bool"}, { "MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage", _wrap_MixedScalarWeakDivergenceIntegrator_FiniteElementTypeFailureMessage, METH_O, "FiniteElementTypeFailureMessage(MixedScalarWeakDivergenceIntegrator self) -> char const *"}, - { "MixedScalarWeakDivergenceIntegrator_CalcVShape", _wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS, "CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, + { "MixedScalarWeakDivergenceIntegrator_CalcVShape", (PyCFunction)(void(*)(void))_wrap_MixedScalarWeakDivergenceIntegrator_CalcVShape, METH_VARARGS|METH_KEYWORDS, "CalcVShape(MixedScalarWeakDivergenceIntegrator self, FiniteElement vector_fe, ElementTransformation Trans, DenseMatrix shape)"}, { "delete_MixedScalarWeakDivergenceIntegrator", _wrap_delete_MixedScalarWeakDivergenceIntegrator, METH_O, "delete_MixedScalarWeakDivergenceIntegrator(MixedScalarWeakDivergenceIntegrator self)"}, { "MixedScalarWeakDivergenceIntegrator_swigregister", MixedScalarWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "MixedScalarWeakDivergenceIntegrator_swiginit", MixedScalarWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33753,14 +32642,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GradientIntegrator(Coefficient _q)\n" "new_GradientIntegrator(Coefficient q) -> GradientIntegrator\n" ""}, - { "GradientIntegrator_AssembleElementMatrix2", _wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(GradientIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "GradientIntegrator_AssemblePA", _wrap_GradientIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "GradientIntegrator_AddMultPA", _wrap_GradientIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_AddMultTransposePA", _wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, - { "GradientIntegrator_GetRule", _wrap_GradientIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "GradientIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(GradientIntegrator self, Vector x, Vector y)"}, + { "GradientIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_GradientIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_GradientIntegrator", _wrap_delete_GradientIntegrator, METH_O, "delete_GradientIntegrator(GradientIntegrator self)"}, { "GradientIntegrator_swigregister", GradientIntegrator_swigregister, METH_O, NULL}, { "GradientIntegrator_swiginit", GradientIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33770,39 +32659,39 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_DiffusionIntegrator(MatrixCoefficient q) -> DiffusionIntegrator\n" ""}, { "delete_DiffusionIntegrator", _wrap_delete_DiffusionIntegrator, METH_O, "delete_DiffusionIntegrator(DiffusionIntegrator self)"}, - { "DiffusionIntegrator_AssembleElementMatrix", _wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementMatrix2", _wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DiffusionIntegrator_AssembleElementVector", _wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "DiffusionIntegrator_ComputeElementFlux", _wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "DiffusionIntegrator_ComputeFluxEnergy", _wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "DiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(DiffusionIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(DiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "DiffusionIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(DiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "DiffusionIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(DiffusionIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "DiffusionIntegrator_AssemblePA", _wrap_DiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "DiffusionIntegrator_AssembleDiagonalPA", _wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, - { "DiffusionIntegrator_AddMultPA", _wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, - { "DiffusionIntegrator_GetRule", _wrap_DiffusionIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, - { "DiffusionIntegrator_SetupPA", _wrap_DiffusionIntegrator_SetupPA, METH_VARARGS, "SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "DiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(DiffusionIntegrator self, Vector diag)"}, + { "DiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(DiffusionIntegrator self, Vector arg2, Vector arg3)"}, + { "DiffusionIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe) -> IntegrationRule"}, + { "DiffusionIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_DiffusionIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "SetupPA(DiffusionIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "DiffusionIntegrator_swigregister", DiffusionIntegrator_swigregister, METH_O, NULL}, { "DiffusionIntegrator_swiginit", DiffusionIntegrator_swiginit, METH_VARARGS, NULL}, { "new_MassIntegrator", _wrap_new_MassIntegrator, METH_VARARGS, "\n" "MassIntegrator(IntegrationRule ir=None)\n" - "MassIntegrator(Coefficient q, IntegrationRule ir=None)\n" + "new_MassIntegrator(Coefficient q, IntegrationRule ir=None) -> MassIntegrator\n" ""}, { "delete_MassIntegrator", _wrap_delete_MassIntegrator, METH_O, "delete_MassIntegrator(MassIntegrator self)"}, - { "MassIntegrator_AssembleElementMatrix", _wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "MassIntegrator_AssembleElementMatrix2", _wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(MassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "MassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(MassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "MassIntegrator_AssemblePA", _wrap_MassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "MassIntegrator_AssembleDiagonalPA", _wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, - { "MassIntegrator_AddMultPA", _wrap_MassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, - { "MassIntegrator_GetRule", _wrap_MassIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, - { "MassIntegrator_SetupPA", _wrap_MassIntegrator_SetupPA, METH_VARARGS, "SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, + { "MassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(MassIntegrator self, Vector diag)"}, + { "MassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(MassIntegrator self, Vector arg2, Vector arg3)"}, + { "MassIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "MassIntegrator_SetupPA", (PyCFunction)(void(*)(void))_wrap_MassIntegrator_SetupPA, METH_VARARGS|METH_KEYWORDS, "SetupPA(MassIntegrator self, FiniteElementSpace fes, bool const force=False)"}, { "MassIntegrator_swigregister", MassIntegrator_swigregister, METH_O, NULL}, { "MassIntegrator_swiginit", MassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryMassIntegrator", _wrap_new_BoundaryMassIntegrator, METH_O, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, + { "new_BoundaryMassIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryMassIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryMassIntegrator(Coefficient q) -> BoundaryMassIntegrator"}, { "BoundaryMassIntegrator_AssembleFaceMatrix", _wrap_BoundaryMassIntegrator_AssembleFaceMatrix, METH_VARARGS, "\n" "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(BoundaryMassIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" @@ -33811,13 +32700,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryMassIntegrator", _wrap_delete_BoundaryMassIntegrator, METH_O, "delete_BoundaryMassIntegrator(BoundaryMassIntegrator self)"}, { "BoundaryMassIntegrator_swigregister", BoundaryMassIntegrator_swigregister, METH_O, NULL}, { "BoundaryMassIntegrator_swiginit", BoundaryMassIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_ConvectionIntegrator", _wrap_new_ConvectionIntegrator, METH_VARARGS, "ConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "ConvectionIntegrator_AssembleElementMatrix", _wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_ConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_ConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_ConvectionIntegrator(VectorCoefficient q, double a=1.0) -> ConvectionIntegrator"}, + { "ConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(ConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "ConvectionIntegrator_AssemblePA", _wrap_ConvectionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace arg1)\n" ""}, - { "ConvectionIntegrator_AddMultPA", _wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, + { "ConvectionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_ConvectionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(ConvectionIntegrator self, Vector arg2, Vector arg3)"}, { "ConvectionIntegrator_GetRule", _wrap_ConvectionIntegrator_GetRule, METH_VARARGS, "\n" "GetRule(FiniteElement el, ElementTransformation Trans) -> IntegrationRule\n" "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule\n" @@ -33825,8 +32714,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_ConvectionIntegrator", _wrap_delete_ConvectionIntegrator, METH_O, "delete_ConvectionIntegrator(ConvectionIntegrator self)"}, { "ConvectionIntegrator_swigregister", ConvectionIntegrator_swigregister, METH_O, NULL}, { "ConvectionIntegrator_swiginit", ConvectionIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_GroupConvectionIntegrator", _wrap_new_GroupConvectionIntegrator, METH_VARARGS, "GroupConvectionIntegrator(VectorCoefficient q, double a=1.0)"}, - { "GroupConvectionIntegrator_AssembleElementMatrix", _wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "new_GroupConvectionIntegrator", (PyCFunction)(void(*)(void))_wrap_new_GroupConvectionIntegrator, METH_VARARGS|METH_KEYWORDS, "new_GroupConvectionIntegrator(VectorCoefficient q, double a=1.0) -> GroupConvectionIntegrator"}, + { "GroupConvectionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_GroupConvectionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(GroupConvectionIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, { "delete_GroupConvectionIntegrator", _wrap_delete_GroupConvectionIntegrator, METH_O, "delete_GroupConvectionIntegrator(GroupConvectionIntegrator self)"}, { "GroupConvectionIntegrator_swigregister", GroupConvectionIntegrator_swigregister, METH_O, NULL}, { "GroupConvectionIntegrator_swiginit", GroupConvectionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33835,18 +32724,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorMassIntegrator(Coefficient q, int qo=0)\n" "VectorMassIntegrator(Coefficient q, IntegrationRule ir)\n" "VectorMassIntegrator(VectorCoefficient q, int qo=0)\n" - "VectorMassIntegrator(MatrixCoefficient q, int qo=0)\n" + "new_VectorMassIntegrator(MatrixCoefficient q, int qo=0) -> VectorMassIntegrator\n" ""}, { "VectorMassIntegrator_GetVDim", _wrap_VectorMassIntegrator_GetVDim, METH_O, "GetVDim(VectorMassIntegrator self) -> int"}, - { "VectorMassIntegrator_SetVDim", _wrap_VectorMassIntegrator_SetVDim, METH_VARARGS, "SetVDim(VectorMassIntegrator self, int vdim)"}, - { "VectorMassIntegrator_AssembleElementMatrix", _wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorMassIntegrator_AssembleElementMatrix2", _wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_SetVDim", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_SetVDim, METH_VARARGS|METH_KEYWORDS, "SetVDim(VectorMassIntegrator self, int vdim)"}, + { "VectorMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorMassIntegrator_AssemblePA", _wrap_VectorMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorMassIntegrator_AssembleDiagonalPA", _wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, - { "VectorMassIntegrator_AddMultPA", _wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, + { "VectorMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(VectorMassIntegrator self, Vector diag)"}, + { "VectorMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorMassIntegrator self, Vector x, Vector y)"}, { "delete_VectorMassIntegrator", _wrap_delete_VectorMassIntegrator, METH_O, "delete_VectorMassIntegrator(VectorMassIntegrator self)"}, { "VectorMassIntegrator_swigregister", VectorMassIntegrator_swigregister, METH_O, NULL}, { "VectorMassIntegrator_swiginit", VectorMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33854,8 +32743,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFEDivergenceIntegrator()\n" "new_VectorFEDivergenceIntegrator(Coefficient q) -> VectorFEDivergenceIntegrator\n" ""}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFEDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFEDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEDivergenceIntegrator", _wrap_delete_VectorFEDivergenceIntegrator, METH_O, "delete_VectorFEDivergenceIntegrator(VectorFEDivergenceIntegrator self)"}, { "VectorFEDivergenceIntegrator_swigregister", VectorFEDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEDivergenceIntegrator_swiginit", VectorFEDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33863,8 +32752,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFEWeakDivergenceIntegrator()\n" "new_VectorFEWeakDivergenceIntegrator(Coefficient q) -> VectorFEWeakDivergenceIntegrator\n" ""}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFEWeakDivergenceIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEWeakDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFEWeakDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFEWeakDivergenceIntegrator", _wrap_delete_VectorFEWeakDivergenceIntegrator, METH_O, "delete_VectorFEWeakDivergenceIntegrator(VectorFEWeakDivergenceIntegrator self)"}, { "VectorFEWeakDivergenceIntegrator_swigregister", VectorFEWeakDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorFEWeakDivergenceIntegrator_swiginit", VectorFEWeakDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33872,14 +32761,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFECurlIntegrator()\n" "new_VectorFECurlIntegrator(Coefficient q) -> VectorFECurlIntegrator\n" ""}, - { "VectorFECurlIntegrator_AssembleElementMatrix", _wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFECurlIntegrator_AssembleElementMatrix2", _wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFECurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFECurlIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFECurlIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFECurlIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorFECurlIntegrator", _wrap_delete_VectorFECurlIntegrator, METH_O, "delete_VectorFECurlIntegrator(VectorFECurlIntegrator self)"}, { "VectorFECurlIntegrator_swigregister", VectorFECurlIntegrator_swigregister, METH_O, NULL}, { "VectorFECurlIntegrator_swiginit", VectorFECurlIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DerivativeIntegrator", _wrap_new_DerivativeIntegrator, METH_VARARGS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, - { "DerivativeIntegrator_AssembleElementMatrix", _wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "DerivativeIntegrator_AssembleElementMatrix2", _wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_DerivativeIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DerivativeIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DerivativeIntegrator(Coefficient q, int i) -> DerivativeIntegrator"}, + { "DerivativeIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(DerivativeIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DerivativeIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DerivativeIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(DerivativeIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DerivativeIntegrator", _wrap_delete_DerivativeIntegrator, METH_O, "delete_DerivativeIntegrator(DerivativeIntegrator self)"}, { "DerivativeIntegrator_swigregister", DerivativeIntegrator_swigregister, METH_O, NULL}, { "DerivativeIntegrator_swiginit", DerivativeIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33888,15 +32777,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CurlCurlIntegrator(Coefficient q)\n" "new_CurlCurlIntegrator(MatrixCoefficient m) -> CurlCurlIntegrator\n" ""}, - { "CurlCurlIntegrator_AssembleElementMatrix", _wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "CurlCurlIntegrator_ComputeElementFlux", _wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, - { "CurlCurlIntegrator_ComputeFluxEnergy", _wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "CurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlCurlIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(CurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef)"}, + { "CurlCurlIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(CurlCurlIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "CurlCurlIntegrator_AssemblePA", _wrap_CurlCurlIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "CurlCurlIntegrator_AddMultPA", _wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, - { "CurlCurlIntegrator_AssembleDiagonalPA", _wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, + { "CurlCurlIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(CurlCurlIntegrator self, Vector x, Vector y)"}, + { "CurlCurlIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_CurlCurlIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(CurlCurlIntegrator self, Vector diag)"}, { "delete_CurlCurlIntegrator", _wrap_delete_CurlCurlIntegrator, METH_O, "delete_CurlCurlIntegrator(CurlCurlIntegrator self)"}, { "CurlCurlIntegrator_swigregister", CurlCurlIntegrator_swigregister, METH_O, NULL}, { "CurlCurlIntegrator_swiginit", CurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33904,8 +32793,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorCurlCurlIntegrator()\n" "new_VectorCurlCurlIntegrator(Coefficient q) -> VectorCurlCurlIntegrator\n" ""}, - { "VectorCurlCurlIntegrator_AssembleElementMatrix", _wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorCurlCurlIntegrator_GetElementEnergy", _wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "VectorCurlCurlIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorCurlCurlIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_VectorCurlCurlIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(VectorCurlCurlIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "delete_VectorCurlCurlIntegrator", _wrap_delete_VectorCurlCurlIntegrator, METH_O, "delete_VectorCurlCurlIntegrator(VectorCurlCurlIntegrator self)"}, { "VectorCurlCurlIntegrator_swigregister", VectorCurlCurlIntegrator_swigregister, METH_O, NULL}, { "VectorCurlCurlIntegrator_swiginit", VectorCurlCurlIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33918,14 +32807,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorFEMassIntegrator(MatrixCoefficient _mq)\n" "new_VectorFEMassIntegrator(MatrixCoefficient mq) -> VectorFEMassIntegrator\n" ""}, - { "VectorFEMassIntegrator_AssembleElementMatrix", _wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorFEMassIntegrator_AssembleElementMatrix2", _wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorFEMassIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorFEMassIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorFEMassIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorFEMassIntegrator_AssemblePA", _wrap_VectorFEMassIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorFEMassIntegrator_AddMultPA", _wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, - { "VectorFEMassIntegrator_AssembleDiagonalPA", _wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, + { "VectorFEMassIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorFEMassIntegrator self, Vector x, Vector y)"}, + { "VectorFEMassIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorFEMassIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(VectorFEMassIntegrator self, Vector diag)"}, { "delete_VectorFEMassIntegrator", _wrap_delete_VectorFEMassIntegrator, METH_O, "delete_VectorFEMassIntegrator(VectorFEMassIntegrator self)"}, { "VectorFEMassIntegrator_swigregister", VectorFEMassIntegrator_swigregister, METH_O, NULL}, { "VectorFEMassIntegrator_swiginit", VectorFEMassIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33934,14 +32823,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorDivergenceIntegrator(Coefficient _q)\n" "new_VectorDivergenceIntegrator(Coefficient q) -> VectorDivergenceIntegrator\n" ""}, - { "VectorDivergenceIntegrator_AssembleElementMatrix2", _wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDivergenceIntegrator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorDivergenceIntegrator self, FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "VectorDivergenceIntegrator_AssemblePA", _wrap_VectorDivergenceIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "VectorDivergenceIntegrator_AddMultPA", _wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_AddMultTransposePA", _wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, - { "VectorDivergenceIntegrator_GetRule", _wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, + { "VectorDivergenceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(VectorDivergenceIntegrator self, Vector x, Vector y)"}, + { "VectorDivergenceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorDivergenceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement trial_fe, FiniteElement test_fe, ElementTransformation Trans) -> IntegrationRule"}, { "delete_VectorDivergenceIntegrator", _wrap_delete_VectorDivergenceIntegrator, METH_O, "delete_VectorDivergenceIntegrator(VectorDivergenceIntegrator self)"}, { "VectorDivergenceIntegrator_swigregister", VectorDivergenceIntegrator_swigregister, METH_O, NULL}, { "VectorDivergenceIntegrator_swiginit", VectorDivergenceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33949,7 +32838,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DivDivIntegrator()\n" "new_DivDivIntegrator(Coefficient q) -> DivDivIntegrator\n" ""}, - { "DivDivIntegrator_AssembleElementMatrix", _wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivDivIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_DivDivIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(DivDivIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_DivDivIntegrator", _wrap_delete_DivDivIntegrator, METH_O, "delete_DivDivIntegrator(DivDivIntegrator self)"}, { "DivDivIntegrator_swigregister", DivDivIntegrator_swigregister, METH_O, NULL}, { "DivDivIntegrator_swiginit", DivDivIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33957,14 +32846,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorDiffusionIntegrator()\n" "new_VectorDiffusionIntegrator(Coefficient q) -> VectorDiffusionIntegrator\n" ""}, - { "VectorDiffusionIntegrator_AssembleElementMatrix", _wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, - { "VectorDiffusionIntegrator_AssembleElementVector", _wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "VectorDiffusionIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Trans, DenseMatrix elmat)"}, + { "VectorDiffusionIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(VectorDiffusionIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, { "VectorDiffusionIntegrator_AssemblePA", _wrap_VectorDiffusionIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA()\n" "AssemblePA(FiniteElementSpace fes)\n" ""}, - { "VectorDiffusionIntegrator_AssembleDiagonalPA", _wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS, "AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, - { "VectorDiffusionIntegrator_AddMultPA", _wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, + { "VectorDiffusionIntegrator_AssembleDiagonalPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AssembleDiagonalPA, METH_VARARGS|METH_KEYWORDS, "AssembleDiagonalPA(VectorDiffusionIntegrator self, Vector diag)"}, + { "VectorDiffusionIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorDiffusionIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorDiffusionIntegrator self, Vector x, Vector y)"}, { "delete_VectorDiffusionIntegrator", _wrap_delete_VectorDiffusionIntegrator, METH_O, "delete_VectorDiffusionIntegrator(VectorDiffusionIntegrator self)"}, { "VectorDiffusionIntegrator_swigregister", VectorDiffusionIntegrator_swigregister, METH_O, NULL}, { "VectorDiffusionIntegrator_swiginit", VectorDiffusionIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33972,9 +32861,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ElasticityIntegrator(Coefficient l, Coefficient m)\n" "new_ElasticityIntegrator(Coefficient m, double q_l, double q_m) -> ElasticityIntegrator\n" ""}, - { "ElasticityIntegrator_AssembleElementMatrix", _wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS, "AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, - { "ElasticityIntegrator_ComputeElementFlux", _wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS, "ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, - { "ElasticityIntegrator_ComputeFluxEnergy", _wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS, "ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, + { "ElasticityIntegrator_AssembleElementMatrix", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_AssembleElementMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix(ElasticityIntegrator self, FiniteElement arg2, ElementTransformation arg3, DenseMatrix arg4)"}, + { "ElasticityIntegrator_ComputeElementFlux", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeElementFlux, METH_VARARGS|METH_KEYWORDS, "ComputeElementFlux(ElasticityIntegrator self, FiniteElement el, ElementTransformation Trans, Vector u, FiniteElement fluxelem, Vector flux, bool with_coef=True)"}, + { "ElasticityIntegrator_ComputeFluxEnergy", (PyCFunction)(void(*)(void))_wrap_ElasticityIntegrator_ComputeFluxEnergy, METH_VARARGS|METH_KEYWORDS, "ComputeFluxEnergy(ElasticityIntegrator self, FiniteElement fluxelem, ElementTransformation Trans, Vector flux, Vector d_energy=None) -> double"}, { "delete_ElasticityIntegrator", _wrap_delete_ElasticityIntegrator, METH_O, "delete_ElasticityIntegrator(ElasticityIntegrator self)"}, { "ElasticityIntegrator_swigregister", ElasticityIntegrator_swigregister, METH_O, NULL}, { "ElasticityIntegrator_swiginit", ElasticityIntegrator_swiginit, METH_VARARGS, NULL}, @@ -33987,11 +32876,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement trial_face_fe, FiniteElement test_fe1, FiniteElement test_fe2, FaceElementTransformations Trans, DenseMatrix elmat)\n" "AssembleFaceMatrix(DGTraceIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Trans, DenseMatrix elmat)\n" ""}, - { "DGTraceIntegrator_AssemblePAInteriorFaces", _wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS, "AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AssemblePABoundaryFaces", _wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS, "AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, - { "DGTraceIntegrator_AddMultTransposePA", _wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS, "AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, - { "DGTraceIntegrator_AddMultPA", _wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, - { "DGTraceIntegrator_GetRule", _wrap_DGTraceIntegrator_GetRule, METH_VARARGS, "GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, + { "DGTraceIntegrator_AssemblePAInteriorFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePAInteriorFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePAInteriorFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AssemblePABoundaryFaces", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AssemblePABoundaryFaces, METH_VARARGS|METH_KEYWORDS, "AssemblePABoundaryFaces(DGTraceIntegrator self, FiniteElementSpace fes)"}, + { "DGTraceIntegrator_AddMultTransposePA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultTransposePA, METH_VARARGS|METH_KEYWORDS, "AddMultTransposePA(DGTraceIntegrator self, Vector x, Vector y)"}, + { "DGTraceIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(DGTraceIntegrator self, Vector arg2, Vector arg3)"}, + { "DGTraceIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_DGTraceIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(mfem::Geometry::Type geom, int order, FaceElementTransformations T) -> IntegrationRule"}, { "delete_DGTraceIntegrator", _wrap_delete_DGTraceIntegrator, METH_O, "delete_DGTraceIntegrator(DGTraceIntegrator self)"}, { "DGTraceIntegrator_swigregister", DGTraceIntegrator_swigregister, METH_O, NULL}, { "DGTraceIntegrator_swiginit", DGTraceIntegrator_swiginit, METH_VARARGS, NULL}, @@ -34042,53 +32931,53 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_DiscreteInterpolator", _wrap_delete_DiscreteInterpolator, METH_O, "delete_DiscreteInterpolator(DiscreteInterpolator self)"}, { "DiscreteInterpolator_swigregister", DiscreteInterpolator_swigregister, METH_O, NULL}, { "DiscreteInterpolator_swiginit", DiscreteInterpolator_swiginit, METH_VARARGS, NULL}, - { "GradientInterpolator_AssembleElementMatrix2", _wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "GradientInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_GradientInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(GradientInterpolator self, FiniteElement h1_fe, FiniteElement nd_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_GradientInterpolator", _wrap_new_GradientInterpolator, METH_NOARGS, "new_GradientInterpolator() -> GradientInterpolator"}, { "delete_GradientInterpolator", _wrap_delete_GradientInterpolator, METH_O, "delete_GradientInterpolator(GradientInterpolator self)"}, { "GradientInterpolator_swigregister", GradientInterpolator_swigregister, METH_O, NULL}, { "GradientInterpolator_swiginit", GradientInterpolator_swiginit, METH_VARARGS, NULL}, - { "IdentityInterpolator_AssembleElementMatrix2", _wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "IdentityInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_IdentityInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(IdentityInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_IdentityInterpolator", _wrap_new_IdentityInterpolator, METH_NOARGS, "new_IdentityInterpolator() -> IdentityInterpolator"}, { "delete_IdentityInterpolator", _wrap_delete_IdentityInterpolator, METH_O, "delete_IdentityInterpolator(IdentityInterpolator self)"}, { "IdentityInterpolator_swigregister", IdentityInterpolator_swigregister, METH_O, NULL}, { "IdentityInterpolator_swiginit", IdentityInterpolator_swiginit, METH_VARARGS, NULL}, - { "CurlInterpolator_AssembleElementMatrix2", _wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "CurlInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_CurlInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(CurlInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_CurlInterpolator", _wrap_new_CurlInterpolator, METH_NOARGS, "new_CurlInterpolator() -> CurlInterpolator"}, { "delete_CurlInterpolator", _wrap_delete_CurlInterpolator, METH_O, "delete_CurlInterpolator(CurlInterpolator self)"}, { "CurlInterpolator_swigregister", CurlInterpolator_swigregister, METH_O, NULL}, { "CurlInterpolator_swiginit", CurlInterpolator_swiginit, METH_VARARGS, NULL}, - { "DivergenceInterpolator_AssembleElementMatrix2", _wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "DivergenceInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_DivergenceInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(DivergenceInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_DivergenceInterpolator", _wrap_new_DivergenceInterpolator, METH_NOARGS, "new_DivergenceInterpolator() -> DivergenceInterpolator"}, { "delete_DivergenceInterpolator", _wrap_delete_DivergenceInterpolator, METH_O, "delete_DivergenceInterpolator(DivergenceInterpolator self)"}, { "DivergenceInterpolator_swigregister", DivergenceInterpolator_swigregister, METH_O, NULL}, { "DivergenceInterpolator_swiginit", DivergenceInterpolator_swiginit, METH_VARARGS, NULL}, - { "NormalInterpolator_AssembleElementMatrix2", _wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "NormalInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_NormalInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(NormalInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "new_NormalInterpolator", _wrap_new_NormalInterpolator, METH_NOARGS, "new_NormalInterpolator() -> NormalInterpolator"}, { "delete_NormalInterpolator", _wrap_delete_NormalInterpolator, METH_O, "delete_NormalInterpolator(NormalInterpolator self)"}, { "NormalInterpolator_swigregister", NormalInterpolator_swigregister, METH_O, NULL}, { "NormalInterpolator_swiginit", NormalInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarProductInterpolator", _wrap_new_ScalarProductInterpolator, METH_O, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, - { "ScalarProductInterpolator_AssembleElementMatrix2", _wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarProductInterpolator(Coefficient sc) -> ScalarProductInterpolator"}, + { "ScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(ScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarProductInterpolator", _wrap_delete_ScalarProductInterpolator, METH_O, "delete_ScalarProductInterpolator(ScalarProductInterpolator self)"}, { "ScalarProductInterpolator_swigregister", ScalarProductInterpolator_swigregister, METH_O, NULL}, { "ScalarProductInterpolator_swiginit", ScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductInterpolator", _wrap_new_ScalarVectorProductInterpolator, METH_O, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, - { "ScalarVectorProductInterpolator_AssembleElementMatrix2", _wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_ScalarVectorProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductInterpolator(Coefficient sc) -> ScalarVectorProductInterpolator"}, + { "ScalarVectorProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_ScalarVectorProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(ScalarVectorProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_ScalarVectorProductInterpolator", _wrap_delete_ScalarVectorProductInterpolator, METH_O, "delete_ScalarVectorProductInterpolator(ScalarVectorProductInterpolator self)"}, { "ScalarVectorProductInterpolator_swigregister", ScalarVectorProductInterpolator_swigregister, METH_O, NULL}, { "ScalarVectorProductInterpolator_swiginit", ScalarVectorProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorScalarProductInterpolator", _wrap_new_VectorScalarProductInterpolator, METH_O, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, - { "VectorScalarProductInterpolator_AssembleElementMatrix2", _wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorScalarProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorScalarProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorScalarProductInterpolator(VectorCoefficient vc) -> VectorScalarProductInterpolator"}, + { "VectorScalarProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorScalarProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorScalarProductInterpolator self, FiniteElement dom_fe, FiniteElement ran_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorScalarProductInterpolator", _wrap_delete_VectorScalarProductInterpolator, METH_O, "delete_VectorScalarProductInterpolator(VectorScalarProductInterpolator self)"}, { "VectorScalarProductInterpolator_swigregister", VectorScalarProductInterpolator_swigregister, METH_O, NULL}, { "VectorScalarProductInterpolator_swiginit", VectorScalarProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductInterpolator", _wrap_new_VectorCrossProductInterpolator, METH_O, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, - { "VectorCrossProductInterpolator_AssembleElementMatrix2", _wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorCrossProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductInterpolator(VectorCoefficient vc) -> VectorCrossProductInterpolator"}, + { "VectorCrossProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorCrossProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorCrossProductInterpolator self, FiniteElement nd_fe, FiniteElement rt_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorCrossProductInterpolator", _wrap_delete_VectorCrossProductInterpolator, METH_O, "delete_VectorCrossProductInterpolator(VectorCrossProductInterpolator self)"}, { "VectorCrossProductInterpolator_swigregister", VectorCrossProductInterpolator_swigregister, METH_O, NULL}, { "VectorCrossProductInterpolator_swiginit", VectorCrossProductInterpolator_swiginit, METH_VARARGS, NULL}, - { "new_VectorInnerProductInterpolator", _wrap_new_VectorInnerProductInterpolator, METH_O, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, - { "VectorInnerProductInterpolator_AssembleElementMatrix2", _wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS, "AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, + { "new_VectorInnerProductInterpolator", (PyCFunction)(void(*)(void))_wrap_new_VectorInnerProductInterpolator, METH_VARARGS|METH_KEYWORDS, "new_VectorInnerProductInterpolator(VectorCoefficient vc) -> VectorInnerProductInterpolator"}, + { "VectorInnerProductInterpolator_AssembleElementMatrix2", (PyCFunction)(void(*)(void))_wrap_VectorInnerProductInterpolator_AssembleElementMatrix2, METH_VARARGS|METH_KEYWORDS, "AssembleElementMatrix2(VectorInnerProductInterpolator self, FiniteElement rt_fe, FiniteElement l2_fe, ElementTransformation Trans, DenseMatrix elmat)"}, { "delete_VectorInnerProductInterpolator", _wrap_delete_VectorInnerProductInterpolator, METH_O, "delete_VectorInnerProductInterpolator(VectorInnerProductInterpolator self)"}, { "VectorInnerProductInterpolator_swigregister", VectorInnerProductInterpolator_swigregister, METH_O, NULL}, { "VectorInnerProductInterpolator_swiginit", VectorInnerProductInterpolator_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/bilininteg_wrap.h b/mfem/_ser/bilininteg_wrap.h index 3361ff37..63cc9638 100644 --- a/mfem/_ser/bilininteg_wrap.h +++ b/mfem/_ser/bilininteg_wrap.h @@ -66,7 +66,7 @@ class SwigDirector_BilinearFormIntegrator : public mfem::BilinearFormIntegrator, return method; } private: - mutable swig::SwigVar_PyObject vtable[18]; + mutable swig::SwigVar_PyObject vtable[16]; #endif }; diff --git a/mfem/_ser/blockmatrix_wrap.cxx b/mfem/_ser/blockmatrix_wrap.cxx index 7007fb39..192fbf52 100644 --- a/mfem/_ser/blockmatrix_wrap.cxx +++ b/mfem/_ser/blockmatrix_wrap.cxx @@ -3501,7 +3501,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_BlockMatrix_PrintMatlab__SWIG_2(mfem::BlockMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_BlockMatrix_PrintMatlab__SWIG_1(mfem::BlockMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3656,7 +3656,7 @@ SWIGINTERN PyObject *_wrap_new_BlockMatrix(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_BlockMatrix_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; @@ -3666,27 +3666,33 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_SetBlock(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"mat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_SetBlock", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockMatrix_SetBlock", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_SetBlock" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockMatrix_SetBlock" "', argument " "4"" of type '" "mfem::SparseMatrix *""'"); } @@ -3981,33 +3987,38 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetBlock(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_BlockMatrix_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_IsZeroBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockMatrix_IsZeroBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_IsZeroBlock" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4263,26 +4274,30 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_ColOffsets(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_BlockMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_RowSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockMatrix_RowSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_RowSize" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4314,13 +4329,13 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNU PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); @@ -4332,11 +4347,13 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNU }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); + } { try { (arg1)->EliminateRowCol(arg2,arg3); @@ -4364,51 +4381,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUNU SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->EliminateRowCol(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4487,7 +4459,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_EliminateRowCol", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); @@ -4502,25 +4474,9 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject } } if (_v) { - return _wrap_BlockMatrix_EliminateRowCol__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_BlockMatrix_EliminateRowCol__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -4549,7 +4505,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_BlockMatrix_EliminateRowCol__SWIG_2(self, argc, argv); + return _wrap_BlockMatrix_EliminateRowCol__SWIG_1(self, argc, argv); } } } @@ -4560,7 +4516,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_EliminateRowCol'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockMatrix::EliminateRowCol(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::BlockMatrix::EliminateRowCol(int)\n" " mfem::BlockMatrix::EliminateRowCol(mfem::Array< int > &,mfem::Vector &,mfem::Vector &)\n"); return 0; } @@ -4569,21 +4524,23 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateRowCol(PyObject *self, PyObject SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_Finalize" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -4612,44 +4569,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_Finalize" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - try { - (arg1)->Finalize(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; @@ -4710,21 +4629,15 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_Finalize", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_Finalize__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_BlockMatrix_Finalize__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4758,7 +4671,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize(PyObject *self, PyObject *args) _v = SWIG_CheckState(res); } if (_v) { - return _wrap_BlockMatrix_Finalize__SWIG_2(self, argc, argv); + return _wrap_BlockMatrix_Finalize__SWIG_1(self, argc, argv); } } } @@ -4768,7 +4681,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_Finalize(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_Finalize'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockMatrix::Finalize(int)\n" - " mfem::BlockMatrix::Finalize()\n" " mfem::BlockMatrix::Finalize(int,bool)\n"); return 0; } @@ -4818,31 +4730,34 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_CreateMonolithic(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -4881,44 +4796,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - { - try { - ((mfem::BlockMatrix const *)arg1)->PrintMatlab(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_BlockMatrix_Elem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; @@ -5183,7 +5060,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_NumNonZeroElems(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; int arg2 ; @@ -5195,22 +5072,28 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_GetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockMatrix_GetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_GetRow" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5218,7 +5101,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockMatrix_GetRow" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5252,26 +5135,33 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - double arg2 ; + double arg2 = (double) (double)1e-12 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"threshold", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:BlockMatrix_EliminateZeroRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + } { try { (arg1)->EliminateZeroRows(arg2); @@ -5298,21 +5188,49 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockMatrix_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_Mult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->EliminateZeroRows(); + ((mfem::BlockMatrix const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5336,131 +5254,35 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BlockMatrix_EliminateZeroRows(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 +SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 = (double) (double)1. ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_EliminateZeroRows", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_EliminateZeroRows__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockMatrix_EliminateZeroRows__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_EliminateZeroRows'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockMatrix::EliminateZeroRows(double const)\n" - " mfem::BlockMatrix::EliminateZeroRows()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_Mult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BlockMatrix_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::BlockMatrix const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5468,7 +5290,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5476,11 +5298,13 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { ((mfem::BlockMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); @@ -5507,7 +5331,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5518,135 +5342,20 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMult" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::BlockMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockMatrix_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockMatrix::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BlockMatrix::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BlockMatrix_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockMatrix_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5654,7 +5363,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5688,12 +5397,12 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1. ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5702,14 +5411,21 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUN int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BlockMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); } arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5717,7 +5433,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5725,74 +5441,16 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::BlockMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::BlockMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::BlockMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::BlockMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5816,66 +5474,6 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_BlockMatrix_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockMatrix_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::BlockMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_BlockMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; @@ -5967,18 +5565,18 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_owns_blocks_get(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); @@ -5989,64 +5587,17 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_BlockMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockMatrix *arg1 = (mfem::BlockMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::BlockMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::BlockMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_BlockMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2); + mfem_BlockMatrix_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6080,34 +5631,15 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg if (!(argc = SWIG_Python_UnpackTuple(args, "BlockMatrix_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_PrintMatlab__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockMatrix_PrintMatlab__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_BlockMatrix_PrintMatlab__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -6122,7 +5654,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockMatrix, 0); @@ -6131,6 +5663,9 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_BlockMatrix_PrintMatlab__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6140,7 +5675,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_BlockMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_BlockMatrix_PrintMatlab__SWIG_1(self, argc, argv); } } } @@ -6150,9 +5685,7 @@ SWIGINTERN PyObject *_wrap_BlockMatrix_PrintMatlab(PyObject *self, PyObject *arg SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockMatrix_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::BlockMatrix::PrintMatlab() const\n" - " mfem::BlockMatrix::PrintMatlab(char const *,int)\n" - " mfem::BlockMatrix::PrintMatlab(char const *)\n"); + " mfem::BlockMatrix::PrintMatlab(char const *,int)\n"); return 0; } @@ -6175,14 +5708,14 @@ static PyMethodDef SwigMethods[] = { "BlockMatrix(intArray offsets)\n" "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" ""}, - { "BlockMatrix_SetBlock", _wrap_BlockMatrix_SetBlock, METH_VARARGS, "BlockMatrix_SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, + { "BlockMatrix_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_SetBlock, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, { "BlockMatrix_NumRowBlocks", _wrap_BlockMatrix_NumRowBlocks, METH_O, "BlockMatrix_NumRowBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_NumColBlocks", _wrap_BlockMatrix_NumColBlocks, METH_O, "BlockMatrix_NumColBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_GetBlock", _wrap_BlockMatrix_GetBlock, METH_VARARGS, "\n" "BlockMatrix_GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" "BlockMatrix_GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" ""}, - { "BlockMatrix_IsZeroBlock", _wrap_BlockMatrix_IsZeroBlock, METH_VARARGS, "BlockMatrix_IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, + { "BlockMatrix_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, { "BlockMatrix_RowOffsets", _wrap_BlockMatrix_RowOffsets, METH_VARARGS, "\n" "BlockMatrix_RowOffsets(BlockMatrix self) -> intArray\n" "BlockMatrix_RowOffsets(BlockMatrix self) -> intArray\n" @@ -6191,7 +5724,7 @@ static PyMethodDef SwigMethods[] = { "BlockMatrix_ColOffsets(BlockMatrix self) -> intArray\n" "BlockMatrix_ColOffsets(BlockMatrix self) -> intArray\n" ""}, - { "BlockMatrix_RowSize", _wrap_BlockMatrix_RowSize, METH_VARARGS, "BlockMatrix_RowSize(BlockMatrix self, int const i) -> int"}, + { "BlockMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_RowSize(BlockMatrix self, int const i) -> int"}, { "BlockMatrix_EliminateRowCol", _wrap_BlockMatrix_EliminateRowCol, METH_VARARGS, "\n" "BlockMatrix_EliminateRowCol(BlockMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "BlockMatrix_EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs)\n" @@ -6207,12 +5740,12 @@ static PyMethodDef SwigMethods[] = { ""}, { "BlockMatrix_Inverse", _wrap_BlockMatrix_Inverse, METH_O, "BlockMatrix_Inverse(BlockMatrix self) -> MatrixInverse"}, { "BlockMatrix_NumNonZeroElems", _wrap_BlockMatrix_NumNonZeroElems, METH_O, "BlockMatrix_NumNonZeroElems(BlockMatrix self) -> int"}, - { "BlockMatrix_GetRow", _wrap_BlockMatrix_GetRow, METH_VARARGS, "BlockMatrix_GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "BlockMatrix_EliminateZeroRows", _wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS, "BlockMatrix_EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, - { "BlockMatrix_Mult", _wrap_BlockMatrix_Mult, METH_VARARGS, "BlockMatrix_Mult(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMult", _wrap_BlockMatrix_AddMult, METH_VARARGS, "BlockMatrix_AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, - { "BlockMatrix_MultTranspose", _wrap_BlockMatrix_MultTranspose, METH_VARARGS, "BlockMatrix_MultTranspose(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMultTranspose", _wrap_BlockMatrix_AddMultTranspose, METH_VARARGS, "BlockMatrix_AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "BlockMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, + { "BlockMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_Mult(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_MultTranspose(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockMatrix_AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_BlockMatrix", _wrap_delete_BlockMatrix, METH_O, "delete_BlockMatrix(BlockMatrix self)"}, { "BlockMatrix_owns_blocks_set", _wrap_BlockMatrix_owns_blocks_set, METH_VARARGS, "BlockMatrix_owns_blocks_set(BlockMatrix self, int owns_blocks)"}, { "BlockMatrix_owns_blocks_get", _wrap_BlockMatrix_owns_blocks_get, METH_O, "BlockMatrix_owns_blocks_get(BlockMatrix self) -> int"}, @@ -6232,14 +5765,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "BlockMatrix(intArray offsets)\n" "new_BlockMatrix(intArray row_offsets, intArray col_offsets) -> BlockMatrix\n" ""}, - { "BlockMatrix_SetBlock", _wrap_BlockMatrix_SetBlock, METH_VARARGS, "SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, + { "BlockMatrix_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_SetBlock, METH_VARARGS|METH_KEYWORDS, "SetBlock(BlockMatrix self, int i, int j, SparseMatrix mat)"}, { "BlockMatrix_NumRowBlocks", _wrap_BlockMatrix_NumRowBlocks, METH_O, "NumRowBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_NumColBlocks", _wrap_BlockMatrix_NumColBlocks, METH_O, "NumColBlocks(BlockMatrix self) -> int"}, { "BlockMatrix_GetBlock", _wrap_BlockMatrix_GetBlock, METH_VARARGS, "\n" "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" "GetBlock(BlockMatrix self, int i, int j) -> SparseMatrix\n" ""}, - { "BlockMatrix_IsZeroBlock", _wrap_BlockMatrix_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, + { "BlockMatrix_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "IsZeroBlock(BlockMatrix self, int i, int j) -> int"}, { "BlockMatrix_RowOffsets", _wrap_BlockMatrix_RowOffsets, METH_VARARGS, "\n" "RowOffsets(BlockMatrix self) -> intArray\n" "RowOffsets(BlockMatrix self) -> intArray\n" @@ -6248,7 +5781,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ColOffsets(BlockMatrix self) -> intArray\n" "ColOffsets(BlockMatrix self) -> intArray\n" ""}, - { "BlockMatrix_RowSize", _wrap_BlockMatrix_RowSize, METH_VARARGS, "RowSize(BlockMatrix self, int const i) -> int"}, + { "BlockMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "RowSize(BlockMatrix self, int const i) -> int"}, { "BlockMatrix_EliminateRowCol", _wrap_BlockMatrix_EliminateRowCol, METH_VARARGS, "\n" "EliminateRowCol(BlockMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateRowCol(BlockMatrix self, intArray ess_bc_dofs, Vector sol, Vector rhs)\n" @@ -6264,12 +5797,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "BlockMatrix_Inverse", _wrap_BlockMatrix_Inverse, METH_O, "Inverse(BlockMatrix self) -> MatrixInverse"}, { "BlockMatrix_NumNonZeroElems", _wrap_BlockMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(BlockMatrix self) -> int"}, - { "BlockMatrix_GetRow", _wrap_BlockMatrix_GetRow, METH_VARARGS, "GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "BlockMatrix_EliminateZeroRows", _wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, - { "BlockMatrix_Mult", _wrap_BlockMatrix_Mult, METH_VARARGS, "Mult(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMult", _wrap_BlockMatrix_AddMult, METH_VARARGS, "AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, - { "BlockMatrix_MultTranspose", _wrap_BlockMatrix_MultTranspose, METH_VARARGS, "MultTranspose(BlockMatrix self, Vector x, Vector y)"}, - { "BlockMatrix_AddMultTranspose", _wrap_BlockMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(BlockMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "BlockMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "EliminateZeroRows(BlockMatrix self, double const threshold=1e-12)"}, + { "BlockMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, + { "BlockMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockMatrix self, Vector x, Vector y)"}, + { "BlockMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(BlockMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_BlockMatrix", _wrap_delete_BlockMatrix, METH_O, "delete_BlockMatrix(BlockMatrix self)"}, { "BlockMatrix_owns_blocks_set", _wrap_BlockMatrix_owns_blocks_set, METH_VARARGS, "BlockMatrix_owns_blocks_set(BlockMatrix self, int owns_blocks)"}, { "BlockMatrix_owns_blocks_get", _wrap_BlockMatrix_owns_blocks_get, METH_O, "BlockMatrix_owns_blocks_get(BlockMatrix self) -> int"}, diff --git a/mfem/_ser/blockoperator_wrap.cxx b/mfem/_ser/blockoperator_wrap.cxx index 09ac105f..5a190065 100644 --- a/mfem/_ser/blockoperator_wrap.cxx +++ b/mfem/_ser/blockoperator_wrap.cxx @@ -3273,17 +3273,19 @@ SWIGINTERNINLINE PyObject* #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_Opr2BlockOpr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Opr2BlockOpr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::BlockOperator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Opr2BlockOpr", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opr2BlockOpr" "', argument " "1"" of type '" "mfem::Operator *""'"); } @@ -3314,17 +3316,19 @@ SWIGINTERN PyObject *_wrap_Opr2BlockOpr(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Opr2SparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Opr2SparseMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Opr2SparseMat", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Opr2SparseMat" "', argument " "1"" of type '" "mfem::Operator *""'"); } @@ -3488,41 +3492,50 @@ SWIGINTERN PyObject *_wrap_new_BlockOperator(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; mfem::Operator *arg3 = (mfem::Operator *) 0 ; - double arg4 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"op", (char *)"c", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:BlockOperator_SetDiagonalBlock", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { (arg1)->SetDiagonalBlock(arg2,arg3,arg4); @@ -3549,236 +3562,61 @@ SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock__SWIG_0(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; - int arg2 ; - mfem::Operator *arg3 = (mfem::Operator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); - } - arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); - } - arg3 = reinterpret_cast< mfem::Operator * >(argp3); - { - try { - (arg1)->SetDiagonalBlock(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockOperator_SetDiagonalBlock(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockOperator_SetDiagonalBlock", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockOperator_SetDiagonalBlock__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockOperator_SetDiagonalBlock__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockOperator_SetDiagonalBlock'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockOperator::SetDiagonalBlock(int,mfem::Operator *,double)\n" - " mfem::BlockOperator::SetDiagonalBlock(int,mfem::Operator *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; mfem::Operator *arg4 = (mfem::Operator *) 0 ; - double arg5 ; + double arg5 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; double val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iRow", (char *)"iCol", (char *)"op", (char *)"c", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:BlockOperator_SetBlock", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockOperator_SetBlock" "', argument " "4"" of type '" "mfem::Operator *""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlockOperator_SetBlock" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - (arg1)->SetBlock(arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; - int arg2 ; - int arg3 ; - mfem::Operator *arg4 = (mfem::Operator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); - } - arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockOperator_SetBlock" "', argument " "4"" of type '" "mfem::Operator *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "BlockOperator_SetBlock" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } - arg4 = reinterpret_cast< mfem::Operator * >(argp4); { try { - (arg1)->SetBlock(arg2,arg3,arg4); + (arg1)->SetBlock(arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3802,98 +3640,6 @@ SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlock(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BlockOperator_SetBlock", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BlockOperator_SetBlock__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BlockOperator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BlockOperator_SetBlock__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BlockOperator_SetBlock'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BlockOperator::SetBlock(int,int,mfem::Operator *,double)\n" - " mfem::BlockOperator::SetBlock(int,int,mfem::Operator *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BlockOperator_NumRowBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; @@ -3976,33 +3722,38 @@ SWIGINTERN PyObject *_wrap_BlockOperator_NumColBlocks(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BlockOperator_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_IsZeroBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_IsZeroBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_IsZeroBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_IsZeroBlock" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4030,33 +3781,38 @@ SWIGINTERN PyObject *_wrap_BlockOperator_IsZeroBlock(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BlockOperator_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_GetBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_GetBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_GetBlock" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4084,33 +3840,38 @@ SWIGINTERN PyObject *_wrap_BlockOperator_GetBlock(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_BlockOperator_GetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_GetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_GetBlockCoef", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_GetBlockCoef", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_GetBlockCoef" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4138,7 +3899,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_GetBlockCoef(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BlockOperator_SetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_SetBlockCoef(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; int arg2 ; @@ -4148,27 +3909,33 @@ SWIGINTERN PyObject *_wrap_BlockOperator_SetBlockCoef(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_SetBlockCoef", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockOperator_SetBlockCoef", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_SetBlockCoef" "', argument " "1"" of type '" "mfem::BlockOperator *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "BlockOperator_SetBlockCoef" "', argument " "4"" of type '" "double""'"); } @@ -4281,7 +4048,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_ColOffsets(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4292,15 +4059,20 @@ SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_Mult" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4308,7 +4080,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4342,7 +4114,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_Mult(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockOperator *arg1 = (mfem::BlockOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4353,15 +4125,20 @@ SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockOperator_MultTranspose" "', argument " "1"" of type '" "mfem::BlockOperator const *""'"); } arg1 = reinterpret_cast< mfem::BlockOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4369,7 +4146,7 @@ SWIGINTERN PyObject *_wrap_BlockOperator_MultTranspose(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4505,17 +4282,19 @@ SWIGINTERN PyObject *BlockOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BlockDiagonalPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockDiagonalPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"offsets", NULL + }; mfem::BlockDiagonalPreconditioner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_BlockDiagonalPreconditioner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockDiagonalPreconditioner" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } @@ -4549,7 +4328,7 @@ SWIGINTERN PyObject *_wrap_new_BlockDiagonalPreconditioner(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; int arg2 ; @@ -4558,21 +4337,26 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_SetDiagonalBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockDiagonalPreconditioner_SetDiagonalBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockDiagonalPreconditioner_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); } @@ -4603,7 +4387,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock(PyObject } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; mfem::Operator *arg2 = 0 ; @@ -4611,15 +4395,19 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_SetOperator(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockDiagonalPreconditioner_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_SetOperator" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockDiagonalPreconditioner_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -4694,26 +4482,30 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_NumBlocks(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_GetDiagonalBlock", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockDiagonalPreconditioner_GetDiagonalBlock", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_GetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4782,7 +4574,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Offsets(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4793,15 +4585,20 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockDiagonalPreconditioner_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4809,7 +4606,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockDiagonalPreconditioner_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4843,7 +4640,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_Mult(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockDiagonalPreconditioner *arg1 = (mfem::BlockDiagonalPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4854,15 +4651,20 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockDiagonalPreconditioner_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockDiagonalPreconditioner_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockDiagonalPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "1"" of type '" "mfem::BlockDiagonalPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockDiagonalPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4870,7 +4672,7 @@ SWIGINTERN PyObject *_wrap_BlockDiagonalPreconditioner_MultTranspose(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockDiagonalPreconditioner_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5006,17 +4808,19 @@ SWIGINTERN PyObject *BlockDiagonalPreconditioner_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BlockLowerTriangularPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BlockLowerTriangularPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"offsets", NULL + }; mfem::BlockLowerTriangularPreconditioner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_BlockLowerTriangularPreconditioner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockLowerTriangularPreconditioner" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } @@ -5050,7 +4854,7 @@ SWIGINTERN PyObject *_wrap_new_BlockLowerTriangularPreconditioner(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; int arg2 ; @@ -5059,21 +4863,26 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(P int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_SetDiagonalBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_SetDiagonalBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_SetDiagonalBlock" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockLowerTriangularPreconditioner_SetDiagonalBlock" "', argument " "3"" of type '" "mfem::Operator *""'"); } @@ -5104,7 +4913,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock(P } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; int arg2 ; @@ -5114,27 +4923,33 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iRow", (char *)"iCol", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_SetBlock", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockLowerTriangularPreconditioner_SetBlock", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_SetBlock" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockLowerTriangularPreconditioner_SetBlock" "', argument " "4"" of type '" "mfem::Operator *""'"); } @@ -5165,7 +4980,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetBlock(PyObject } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; mfem::Operator *arg2 = 0 ; @@ -5173,15 +4988,19 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_SetOperator(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockLowerTriangularPreconditioner_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_SetOperator" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockLowerTriangularPreconditioner_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -5256,33 +5075,38 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_NumBlocks(PyObject } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_GetBlock(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"iblock", (char *)"jblock", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_GetBlock", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_GetBlock", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_GetBlock" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5351,7 +5175,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Offsets(PyObject * } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5362,15 +5186,20 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5378,7 +5207,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockLowerTriangularPreconditioner_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5412,7 +5241,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_Mult(PyObject *SWI } -SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockLowerTriangularPreconditioner *arg1 = (mfem::BlockLowerTriangularPreconditioner *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5423,15 +5252,20 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockLowerTriangularPreconditioner_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockLowerTriangularPreconditioner_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockLowerTriangularPreconditioner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "1"" of type '" "mfem::BlockLowerTriangularPreconditioner const *""'"); } arg1 = reinterpret_cast< mfem::BlockLowerTriangularPreconditioner * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5439,7 +5273,7 @@ SWIGINTERN PyObject *_wrap_BlockLowerTriangularPreconditioner_MultTranspose(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockLowerTriangularPreconditioner_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5578,51 +5412,51 @@ SWIGINTERN PyObject *BlockLowerTriangularPreconditioner_swiginit(PyObject *SWIGU static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, - { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, + { "Opr2BlockOpr", (PyCFunction)(void(*)(void))_wrap_Opr2BlockOpr, METH_VARARGS|METH_KEYWORDS, "Opr2BlockOpr(Operator op) -> BlockOperator"}, + { "Opr2SparseMat", (PyCFunction)(void(*)(void))_wrap_Opr2SparseMat, METH_VARARGS|METH_KEYWORDS, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, { "new_BlockOperator", _wrap_new_BlockOperator, METH_VARARGS, "\n" "BlockOperator(intArray offsets)\n" "new_BlockOperator(intArray row_offsets, intArray col_offsets) -> BlockOperator\n" ""}, - { "BlockOperator_SetDiagonalBlock", _wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS, "BlockOperator_SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, - { "BlockOperator_SetBlock", _wrap_BlockOperator_SetBlock, METH_VARARGS, "BlockOperator_SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, + { "BlockOperator_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, + { "BlockOperator_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, { "BlockOperator_NumRowBlocks", _wrap_BlockOperator_NumRowBlocks, METH_O, "BlockOperator_NumRowBlocks(BlockOperator self) -> int"}, { "BlockOperator_NumColBlocks", _wrap_BlockOperator_NumColBlocks, METH_O, "BlockOperator_NumColBlocks(BlockOperator self) -> int"}, - { "BlockOperator_IsZeroBlock", _wrap_BlockOperator_IsZeroBlock, METH_VARARGS, "BlockOperator_IsZeroBlock(BlockOperator self, int i, int j) -> int"}, - { "BlockOperator_GetBlock", _wrap_BlockOperator_GetBlock, METH_VARARGS, "BlockOperator_GetBlock(BlockOperator self, int i, int j) -> Operator"}, - { "BlockOperator_GetBlockCoef", _wrap_BlockOperator_GetBlockCoef, METH_VARARGS, "BlockOperator_GetBlockCoef(BlockOperator self, int i, int j) -> double"}, - { "BlockOperator_SetBlockCoef", _wrap_BlockOperator_SetBlockCoef, METH_VARARGS, "BlockOperator_SetBlockCoef(BlockOperator self, int i, int j, double c)"}, + { "BlockOperator_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_IsZeroBlock(BlockOperator self, int i, int j) -> int"}, + { "BlockOperator_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlock, METH_VARARGS|METH_KEYWORDS, "BlockOperator_GetBlock(BlockOperator self, int i, int j) -> Operator"}, + { "BlockOperator_GetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlockCoef, METH_VARARGS|METH_KEYWORDS, "BlockOperator_GetBlockCoef(BlockOperator self, int i, int j) -> double"}, + { "BlockOperator_SetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlockCoef, METH_VARARGS|METH_KEYWORDS, "BlockOperator_SetBlockCoef(BlockOperator self, int i, int j, double c)"}, { "BlockOperator_RowOffsets", _wrap_BlockOperator_RowOffsets, METH_O, "BlockOperator_RowOffsets(BlockOperator self) -> intArray"}, { "BlockOperator_ColOffsets", _wrap_BlockOperator_ColOffsets, METH_O, "BlockOperator_ColOffsets(BlockOperator self) -> intArray"}, - { "BlockOperator_Mult", _wrap_BlockOperator_Mult, METH_VARARGS, "BlockOperator_Mult(BlockOperator self, Vector x, Vector y)"}, - { "BlockOperator_MultTranspose", _wrap_BlockOperator_MultTranspose, METH_VARARGS, "BlockOperator_MultTranspose(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_Mult", (PyCFunction)(void(*)(void))_wrap_BlockOperator_Mult, METH_VARARGS|METH_KEYWORDS, "BlockOperator_Mult(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockOperator_MultTranspose(BlockOperator self, Vector x, Vector y)"}, { "delete_BlockOperator", _wrap_delete_BlockOperator, METH_O, "delete_BlockOperator(BlockOperator self)"}, { "BlockOperator_owns_blocks_set", _wrap_BlockOperator_owns_blocks_set, METH_VARARGS, "BlockOperator_owns_blocks_set(BlockOperator self, int owns_blocks)"}, { "BlockOperator_owns_blocks_get", _wrap_BlockOperator_owns_blocks_get, METH_O, "BlockOperator_owns_blocks_get(BlockOperator self) -> int"}, { "BlockOperator_swigregister", BlockOperator_swigregister, METH_O, NULL}, { "BlockOperator_swiginit", BlockOperator_swiginit, METH_VARARGS, NULL}, - { "new_BlockDiagonalPreconditioner", _wrap_new_BlockDiagonalPreconditioner, METH_O, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, - { "BlockDiagonalPreconditioner_SetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS, "BlockDiagonalPreconditioner_SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, - { "BlockDiagonalPreconditioner_SetOperator", _wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS, "BlockDiagonalPreconditioner_SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, + { "new_BlockDiagonalPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockDiagonalPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, + { "BlockDiagonalPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, + { "BlockDiagonalPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, { "BlockDiagonalPreconditioner_NumBlocks", _wrap_BlockDiagonalPreconditioner_NumBlocks, METH_O, "BlockDiagonalPreconditioner_NumBlocks(BlockDiagonalPreconditioner self) -> int"}, - { "BlockDiagonalPreconditioner_GetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS, "BlockDiagonalPreconditioner_GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, + { "BlockDiagonalPreconditioner_GetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, { "BlockDiagonalPreconditioner_Offsets", _wrap_BlockDiagonalPreconditioner_Offsets, METH_O, "BlockDiagonalPreconditioner_Offsets(BlockDiagonalPreconditioner self) -> intArray"}, - { "BlockDiagonalPreconditioner_Mult", _wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS, "BlockDiagonalPreconditioner_Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, - { "BlockDiagonalPreconditioner_MultTranspose", _wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS, "BlockDiagonalPreconditioner_MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockDiagonalPreconditioner_MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, { "delete_BlockDiagonalPreconditioner", _wrap_delete_BlockDiagonalPreconditioner, METH_O, "delete_BlockDiagonalPreconditioner(BlockDiagonalPreconditioner self)"}, { "BlockDiagonalPreconditioner_owns_blocks_set", _wrap_BlockDiagonalPreconditioner_owns_blocks_set, METH_VARARGS, "BlockDiagonalPreconditioner_owns_blocks_set(BlockDiagonalPreconditioner self, int owns_blocks)"}, { "BlockDiagonalPreconditioner_owns_blocks_get", _wrap_BlockDiagonalPreconditioner_owns_blocks_get, METH_O, "BlockDiagonalPreconditioner_owns_blocks_get(BlockDiagonalPreconditioner self) -> int"}, { "BlockDiagonalPreconditioner_swigregister", BlockDiagonalPreconditioner_swigregister, METH_O, NULL}, { "BlockDiagonalPreconditioner_swiginit", BlockDiagonalPreconditioner_swiginit, METH_VARARGS, NULL}, - { "new_BlockLowerTriangularPreconditioner", _wrap_new_BlockLowerTriangularPreconditioner, METH_O, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, - { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", _wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS, "BlockLowerTriangularPreconditioner_SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetBlock", _wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS, "BlockLowerTriangularPreconditioner_SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetOperator", _wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS, "BlockLowerTriangularPreconditioner_SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, + { "new_BlockLowerTriangularPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockLowerTriangularPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, + { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, { "BlockLowerTriangularPreconditioner_NumBlocks", _wrap_BlockLowerTriangularPreconditioner_NumBlocks, METH_O, "BlockLowerTriangularPreconditioner_NumBlocks(BlockLowerTriangularPreconditioner self) -> int"}, - { "BlockLowerTriangularPreconditioner_GetBlock", _wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS, "BlockLowerTriangularPreconditioner_GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, + { "BlockLowerTriangularPreconditioner_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, { "BlockLowerTriangularPreconditioner_Offsets", _wrap_BlockLowerTriangularPreconditioner_Offsets, METH_O, "BlockLowerTriangularPreconditioner_Offsets(BlockLowerTriangularPreconditioner self) -> intArray"}, - { "BlockLowerTriangularPreconditioner_Mult", _wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS, "BlockLowerTriangularPreconditioner_Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, - { "BlockLowerTriangularPreconditioner_MultTranspose", _wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS, "BlockLowerTriangularPreconditioner_MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "BlockLowerTriangularPreconditioner_MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, { "delete_BlockLowerTriangularPreconditioner", _wrap_delete_BlockLowerTriangularPreconditioner, METH_O, "delete_BlockLowerTriangularPreconditioner(BlockLowerTriangularPreconditioner self)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_set", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_set, METH_VARARGS, "BlockLowerTriangularPreconditioner_owns_blocks_set(BlockLowerTriangularPreconditioner self, int owns_blocks)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_get", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_get, METH_O, "BlockLowerTriangularPreconditioner_owns_blocks_get(BlockLowerTriangularPreconditioner self) -> int"}, @@ -5634,51 +5468,51 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Opr2BlockOpr", _wrap_Opr2BlockOpr, METH_O, "Opr2BlockOpr(Operator op) -> BlockOperator"}, - { "Opr2SparseMat", _wrap_Opr2SparseMat, METH_O, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, + { "Opr2BlockOpr", (PyCFunction)(void(*)(void))_wrap_Opr2BlockOpr, METH_VARARGS|METH_KEYWORDS, "Opr2BlockOpr(Operator op) -> BlockOperator"}, + { "Opr2SparseMat", (PyCFunction)(void(*)(void))_wrap_Opr2SparseMat, METH_VARARGS|METH_KEYWORDS, "Opr2SparseMat(Operator op) -> mfem::SparseMatrix *"}, { "new_BlockOperator", _wrap_new_BlockOperator, METH_VARARGS, "\n" "BlockOperator(intArray offsets)\n" "new_BlockOperator(intArray row_offsets, intArray col_offsets) -> BlockOperator\n" ""}, - { "BlockOperator_SetDiagonalBlock", _wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, - { "BlockOperator_SetBlock", _wrap_BlockOperator_SetBlock, METH_VARARGS, "SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, + { "BlockOperator_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "SetDiagonalBlock(BlockOperator self, int iblock, Operator op, double c=1.0)"}, + { "BlockOperator_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlock, METH_VARARGS|METH_KEYWORDS, "SetBlock(BlockOperator self, int iRow, int iCol, Operator op, double c=1.0)"}, { "BlockOperator_NumRowBlocks", _wrap_BlockOperator_NumRowBlocks, METH_O, "NumRowBlocks(BlockOperator self) -> int"}, { "BlockOperator_NumColBlocks", _wrap_BlockOperator_NumColBlocks, METH_O, "NumColBlocks(BlockOperator self) -> int"}, - { "BlockOperator_IsZeroBlock", _wrap_BlockOperator_IsZeroBlock, METH_VARARGS, "IsZeroBlock(BlockOperator self, int i, int j) -> int"}, - { "BlockOperator_GetBlock", _wrap_BlockOperator_GetBlock, METH_VARARGS, "GetBlock(BlockOperator self, int i, int j) -> Operator"}, - { "BlockOperator_GetBlockCoef", _wrap_BlockOperator_GetBlockCoef, METH_VARARGS, "GetBlockCoef(BlockOperator self, int i, int j) -> double"}, - { "BlockOperator_SetBlockCoef", _wrap_BlockOperator_SetBlockCoef, METH_VARARGS, "SetBlockCoef(BlockOperator self, int i, int j, double c)"}, + { "BlockOperator_IsZeroBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_IsZeroBlock, METH_VARARGS|METH_KEYWORDS, "IsZeroBlock(BlockOperator self, int i, int j) -> int"}, + { "BlockOperator_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlock, METH_VARARGS|METH_KEYWORDS, "GetBlock(BlockOperator self, int i, int j) -> Operator"}, + { "BlockOperator_GetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_GetBlockCoef, METH_VARARGS|METH_KEYWORDS, "GetBlockCoef(BlockOperator self, int i, int j) -> double"}, + { "BlockOperator_SetBlockCoef", (PyCFunction)(void(*)(void))_wrap_BlockOperator_SetBlockCoef, METH_VARARGS|METH_KEYWORDS, "SetBlockCoef(BlockOperator self, int i, int j, double c)"}, { "BlockOperator_RowOffsets", _wrap_BlockOperator_RowOffsets, METH_O, "RowOffsets(BlockOperator self) -> intArray"}, { "BlockOperator_ColOffsets", _wrap_BlockOperator_ColOffsets, METH_O, "ColOffsets(BlockOperator self) -> intArray"}, - { "BlockOperator_Mult", _wrap_BlockOperator_Mult, METH_VARARGS, "Mult(BlockOperator self, Vector x, Vector y)"}, - { "BlockOperator_MultTranspose", _wrap_BlockOperator_MultTranspose, METH_VARARGS, "MultTranspose(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_Mult", (PyCFunction)(void(*)(void))_wrap_BlockOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockOperator self, Vector x, Vector y)"}, + { "BlockOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockOperator self, Vector x, Vector y)"}, { "delete_BlockOperator", _wrap_delete_BlockOperator, METH_O, "delete_BlockOperator(BlockOperator self)"}, { "BlockOperator_owns_blocks_set", _wrap_BlockOperator_owns_blocks_set, METH_VARARGS, "BlockOperator_owns_blocks_set(BlockOperator self, int owns_blocks)"}, { "BlockOperator_owns_blocks_get", _wrap_BlockOperator_owns_blocks_get, METH_O, "BlockOperator_owns_blocks_get(BlockOperator self) -> int"}, { "BlockOperator_swigregister", BlockOperator_swigregister, METH_O, NULL}, { "BlockOperator_swiginit", BlockOperator_swiginit, METH_VARARGS, NULL}, - { "new_BlockDiagonalPreconditioner", _wrap_new_BlockDiagonalPreconditioner, METH_O, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, - { "BlockDiagonalPreconditioner_SetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, - { "BlockDiagonalPreconditioner_SetOperator", _wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, + { "new_BlockDiagonalPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockDiagonalPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockDiagonalPreconditioner(intArray offsets) -> BlockDiagonalPreconditioner"}, + { "BlockDiagonalPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "SetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock, Operator op)"}, + { "BlockDiagonalPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BlockDiagonalPreconditioner self, Operator op)"}, { "BlockDiagonalPreconditioner_NumBlocks", _wrap_BlockDiagonalPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockDiagonalPreconditioner self) -> int"}, - { "BlockDiagonalPreconditioner_GetDiagonalBlock", _wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS, "GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, + { "BlockDiagonalPreconditioner_GetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_GetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "GetDiagonalBlock(BlockDiagonalPreconditioner self, int iblock) -> Operator"}, { "BlockDiagonalPreconditioner_Offsets", _wrap_BlockDiagonalPreconditioner_Offsets, METH_O, "Offsets(BlockDiagonalPreconditioner self) -> intArray"}, - { "BlockDiagonalPreconditioner_Mult", _wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS, "Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, - { "BlockDiagonalPreconditioner_MultTranspose", _wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, + { "BlockDiagonalPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockDiagonalPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockDiagonalPreconditioner self, Vector x, Vector y)"}, { "delete_BlockDiagonalPreconditioner", _wrap_delete_BlockDiagonalPreconditioner, METH_O, "delete_BlockDiagonalPreconditioner(BlockDiagonalPreconditioner self)"}, { "BlockDiagonalPreconditioner_owns_blocks_set", _wrap_BlockDiagonalPreconditioner_owns_blocks_set, METH_VARARGS, "BlockDiagonalPreconditioner_owns_blocks_set(BlockDiagonalPreconditioner self, int owns_blocks)"}, { "BlockDiagonalPreconditioner_owns_blocks_get", _wrap_BlockDiagonalPreconditioner_owns_blocks_get, METH_O, "BlockDiagonalPreconditioner_owns_blocks_get(BlockDiagonalPreconditioner self) -> int"}, { "BlockDiagonalPreconditioner_swigregister", BlockDiagonalPreconditioner_swigregister, METH_O, NULL}, { "BlockDiagonalPreconditioner_swiginit", BlockDiagonalPreconditioner_swiginit, METH_VARARGS, NULL}, - { "new_BlockLowerTriangularPreconditioner", _wrap_new_BlockLowerTriangularPreconditioner, METH_O, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, - { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", _wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS, "SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetBlock", _wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS, "SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, - { "BlockLowerTriangularPreconditioner_SetOperator", _wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS, "SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, + { "new_BlockLowerTriangularPreconditioner", (PyCFunction)(void(*)(void))_wrap_new_BlockLowerTriangularPreconditioner, METH_VARARGS|METH_KEYWORDS, "new_BlockLowerTriangularPreconditioner(intArray offsets) -> BlockLowerTriangularPreconditioner"}, + { "BlockLowerTriangularPreconditioner_SetDiagonalBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetDiagonalBlock, METH_VARARGS|METH_KEYWORDS, "SetDiagonalBlock(BlockLowerTriangularPreconditioner self, int iblock, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetBlock, METH_VARARGS|METH_KEYWORDS, "SetBlock(BlockLowerTriangularPreconditioner self, int iRow, int iCol, Operator op)"}, + { "BlockLowerTriangularPreconditioner_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BlockLowerTriangularPreconditioner self, Operator op)"}, { "BlockLowerTriangularPreconditioner_NumBlocks", _wrap_BlockLowerTriangularPreconditioner_NumBlocks, METH_O, "NumBlocks(BlockLowerTriangularPreconditioner self) -> int"}, - { "BlockLowerTriangularPreconditioner_GetBlock", _wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS, "GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, + { "BlockLowerTriangularPreconditioner_GetBlock", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_GetBlock, METH_VARARGS|METH_KEYWORDS, "GetBlock(BlockLowerTriangularPreconditioner self, int iblock, int jblock) -> Operator"}, { "BlockLowerTriangularPreconditioner_Offsets", _wrap_BlockLowerTriangularPreconditioner_Offsets, METH_O, "Offsets(BlockLowerTriangularPreconditioner self) -> intArray"}, - { "BlockLowerTriangularPreconditioner_Mult", _wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS, "Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, - { "BlockLowerTriangularPreconditioner_MultTranspose", _wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS, "MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_Mult", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, + { "BlockLowerTriangularPreconditioner_MultTranspose", (PyCFunction)(void(*)(void))_wrap_BlockLowerTriangularPreconditioner_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(BlockLowerTriangularPreconditioner self, Vector x, Vector y)"}, { "delete_BlockLowerTriangularPreconditioner", _wrap_delete_BlockLowerTriangularPreconditioner, METH_O, "delete_BlockLowerTriangularPreconditioner(BlockLowerTriangularPreconditioner self)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_set", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_set, METH_VARARGS, "BlockLowerTriangularPreconditioner_owns_blocks_set(BlockLowerTriangularPreconditioner self, int owns_blocks)"}, { "BlockLowerTriangularPreconditioner_owns_blocks_get", _wrap_BlockLowerTriangularPreconditioner_owns_blocks_get, METH_O, "BlockLowerTriangularPreconditioner_owns_blocks_get(BlockLowerTriangularPreconditioner self) -> int"}, diff --git a/mfem/_ser/blockvector_wrap.cxx b/mfem/_ser/blockvector_wrap.cxx index 042aeb1b..bc5138ad 100644 --- a/mfem/_ser/blockvector_wrap.cxx +++ b/mfem/_ser/blockvector_wrap.cxx @@ -3381,7 +3381,7 @@ SWIGINTERN PyObject *_wrap_BlockVector_GetBlock(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockVector *arg1 = (mfem::BlockVector *) 0 ; int arg2 ; @@ -3390,21 +3390,26 @@ SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"blockView", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockVector_GetBlockView", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockVector_GetBlockView", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockVector_GetBlockView" "', argument " "1"" of type '" "mfem::BlockVector *""'"); } arg1 = reinterpret_cast< mfem::BlockVector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockVector_GetBlockView" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3435,26 +3440,30 @@ SWIGINTERN PyObject *_wrap_BlockVector_GetBlockView(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BlockVector_BlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockVector_BlockSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockVector *arg1 = (mfem::BlockVector *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "BlockVector_BlockSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockVector_BlockSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockVector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockVector_BlockSize" "', argument " "1"" of type '" "mfem::BlockVector *""'"); } arg1 = reinterpret_cast< mfem::BlockVector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3728,8 +3737,8 @@ static PyMethodDef SwigMethods[] = { "BlockVector_GetBlock(BlockVector self, int i) -> Vector\n" "BlockVector_GetBlock(BlockVector self, int i) -> Vector\n" ""}, - { "BlockVector_GetBlockView", _wrap_BlockVector_GetBlockView, METH_VARARGS, "BlockVector_GetBlockView(BlockVector self, int i, Vector blockView)"}, - { "BlockVector_BlockSize", _wrap_BlockVector_BlockSize, METH_VARARGS, "BlockVector_BlockSize(BlockVector self, int i) -> int"}, + { "BlockVector_GetBlockView", (PyCFunction)(void(*)(void))_wrap_BlockVector_GetBlockView, METH_VARARGS|METH_KEYWORDS, "BlockVector_GetBlockView(BlockVector self, int i, Vector blockView)"}, + { "BlockVector_BlockSize", (PyCFunction)(void(*)(void))_wrap_BlockVector_BlockSize, METH_VARARGS|METH_KEYWORDS, "BlockVector_BlockSize(BlockVector self, int i) -> int"}, { "BlockVector_Update", _wrap_BlockVector_Update, METH_VARARGS, "\n" "BlockVector_Update(BlockVector self, double * data, intArray bOffsets)\n" "BlockVector_Update(BlockVector self, intArray bOffsets)\n" @@ -3755,8 +3764,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetBlock(BlockVector self, int i) -> Vector\n" "GetBlock(BlockVector self, int i) -> Vector\n" ""}, - { "BlockVector_GetBlockView", _wrap_BlockVector_GetBlockView, METH_VARARGS, "GetBlockView(BlockVector self, int i, Vector blockView)"}, - { "BlockVector_BlockSize", _wrap_BlockVector_BlockSize, METH_VARARGS, "BlockSize(BlockVector self, int i) -> int"}, + { "BlockVector_GetBlockView", (PyCFunction)(void(*)(void))_wrap_BlockVector_GetBlockView, METH_VARARGS|METH_KEYWORDS, "GetBlockView(BlockVector self, int i, Vector blockView)"}, + { "BlockVector_BlockSize", (PyCFunction)(void(*)(void))_wrap_BlockVector_BlockSize, METH_VARARGS|METH_KEYWORDS, "BlockSize(BlockVector self, int i) -> int"}, { "BlockVector_Update", _wrap_BlockVector_Update, METH_VARARGS, "\n" "Update(BlockVector self, double * data, intArray bOffsets)\n" "Update(BlockVector self, intArray bOffsets)\n" diff --git a/mfem/_ser/coefficient_wrap.cxx b/mfem/_ser/coefficient_wrap.cxx index a963fde2..b22fa8fd 100644 --- a/mfem/_ser/coefficient_wrap.cxx +++ b/mfem/_ser/coefficient_wrap.cxx @@ -3869,7 +3869,7 @@ void SwigDirector_MatrixPyCoefficientBase::_EvalPyT(mfem::Vector &arg0, double a #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_Coefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Coefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = (mfem::Coefficient *) 0 ; double arg2 ; @@ -3877,15 +3877,19 @@ SWIGINTERN PyObject *_wrap_Coefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Coefficient_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Coefficient_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Coefficient_SetTime" "', argument " "1"" of type '" "mfem::Coefficient *""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Coefficient_SetTime" "', argument " "2"" of type '" "double""'"); } @@ -4246,53 +4250,28 @@ SWIGINTERN PyObject *_wrap_ConstantCoefficient_constant_get(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_ConstantCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"c", NULL + }; mfem::ConstantCoefficient *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantCoefficient" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::ConstantCoefficient *)new mfem::ConstantCoefficient(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_ConstantCoefficient", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstantCoefficient" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstantCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ConstantCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::ConstantCoefficient *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::ConstantCoefficient *)new mfem::ConstantCoefficient(); + result = (mfem::ConstantCoefficient *)new mfem::ConstantCoefficient(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4316,38 +4295,7 @@ SWIGINTERN PyObject *_wrap_new_ConstantCoefficient__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_ConstantCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstantCoefficient", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_ConstantCoefficient__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ConstantCoefficient__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstantCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ConstantCoefficient::ConstantCoefficient(double)\n" - " mfem::ConstantCoefficient::ConstantCoefficient()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConstantCoefficient *arg1 = (mfem::ConstantCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -4358,16 +4306,21 @@ SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ConstantCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstantCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstantCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConstantCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstantCoefficient_Eval" "', argument " "1"" of type '" "mfem::ConstantCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ConstantCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -4375,7 +4328,7 @@ SWIGINTERN PyObject *_wrap_ConstantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstantCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4462,50 +4415,21 @@ SWIGINTERN PyObject *ConstantCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self) SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 0 ; mfem::PWConstCoefficient *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::PWConstCoefficient *)new mfem::PWConstCoefficient(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if ((nobjs < 0) || (nobjs > 1)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PWConstCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::PWConstCoefficient *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::PWConstCoefficient *)new mfem::PWConstCoefficient(); + result = (mfem::PWConstCoefficient *)new mfem::PWConstCoefficient(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4529,7 +4453,7 @@ SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PWConstCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; @@ -4579,20 +4503,11 @@ SWIGINTERN PyObject *_wrap_new_PWConstCoefficient(PyObject *self, PyObject *args if (!(argc = SWIG_Python_UnpackTuple(args, "new_PWConstCoefficient", 0, 1, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_PWConstCoefficient__SWIG_1(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 1)) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_PWConstCoefficient__SWIG_2(self, argc, argv); + if (argc <= 0) { + return _wrap_new_PWConstCoefficient__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4605,18 +4520,26 @@ SWIGINTERN PyObject *_wrap_new_PWConstCoefficient(PyObject *self, PyObject *args return _wrap_new_PWConstCoefficient__SWIG_0(self, argc, argv); } } + if (argc == 1) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_PWConstCoefficient__SWIG_1(self, argc, argv); + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PWConstCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::PWConstCoefficient::PWConstCoefficient(int)\n" - " mfem::PWConstCoefficient::PWConstCoefficient()\n" " mfem::PWConstCoefficient::PWConstCoefficient(mfem::Vector &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PWConstCoefficient *arg1 = (mfem::PWConstCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4624,15 +4547,19 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PWConstCoefficient_UpdateConstants", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PWConstCoefficient_UpdateConstants", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PWConstCoefficient_UpdateConstants" "', argument " "1"" of type '" "mfem::PWConstCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PWConstCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PWConstCoefficient_UpdateConstants" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4666,26 +4593,30 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_UpdateConstants(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_PWConstCoefficient___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PWConstCoefficient___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PWConstCoefficient *arg1 = (mfem::PWConstCoefficient *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PWConstCoefficient___call__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PWConstCoefficient___call__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PWConstCoefficient___call__" "', argument " "1"" of type '" "mfem::PWConstCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PWConstCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4754,7 +4685,7 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_GetNConst(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PWConstCoefficient *arg1 = (mfem::PWConstCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -4765,16 +4696,21 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "PWConstCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PWConstCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PWConstCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PWConstCoefficient_Eval" "', argument " "1"" of type '" "mfem::PWConstCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PWConstCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PWConstCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -4782,7 +4718,7 @@ SWIGINTERN PyObject *_wrap_PWConstCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PWConstCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PWConstCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5075,7 +5011,7 @@ SWIGINTERN PyObject *_wrap_new_FunctionCoefficient(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FunctionCoefficient *arg1 = (mfem::FunctionCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5086,16 +5022,21 @@ SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "FunctionCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::FunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::FunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5103,7 +5044,7 @@ SWIGINTERN PyObject *_wrap_FunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5222,65 +5163,28 @@ SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient__SWIG_0(PyObject *SWIGUNU SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; mfem::GridFunctionCoefficient *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::GridFunctionCoefficient *)new mfem::GridFunctionCoefficient(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunctionCoefficient *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { try { - result = (mfem::GridFunctionCoefficient *)new mfem::GridFunctionCoefficient(arg1); + result = (mfem::GridFunctionCoefficient *)new mfem::GridFunctionCoefficient(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5315,21 +5219,15 @@ SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient(PyObject *self, PyObject if (argc == 0) { return _wrap_new_GridFunctionCoefficient__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GridFunctionCoefficient__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_GridFunctionCoefficient__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5348,13 +5246,12 @@ SWIGINTERN PyObject *_wrap_new_GridFunctionCoefficient(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GridFunctionCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::GridFunctionCoefficient::GridFunctionCoefficient()\n" - " mfem::GridFunctionCoefficient::GridFunctionCoefficient(mfem::GridFunction *,int)\n" - " mfem::GridFunctionCoefficient::GridFunctionCoefficient(mfem::GridFunction *)\n"); + " mfem::GridFunctionCoefficient::GridFunctionCoefficient(mfem::GridFunction *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunctionCoefficient *arg1 = (mfem::GridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -5362,15 +5259,19 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_SetGridFunction(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::GridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::GridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -5442,7 +5343,7 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_GetGridFunction(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunctionCoefficient *arg1 = (mfem::GridFunctionCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5453,16 +5354,21 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "GridFunctionCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::GridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::GridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5470,7 +5376,7 @@ SWIGINTERN PyObject *_wrap_GridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5706,7 +5612,7 @@ SWIGINTERN PyObject *_wrap_new_TransformedCoefficient(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransformedCoefficient *arg1 = (mfem::TransformedCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5717,16 +5623,21 @@ SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "TransformedCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransformedCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransformedCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransformedCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransformedCoefficient_Eval" "', argument " "1"" of type '" "mfem::TransformedCoefficient *""'"); } arg1 = reinterpret_cast< mfem::TransformedCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransformedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5734,7 +5645,7 @@ SWIGINTERN PyObject *_wrap_TransformedCoefficient_Eval(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransformedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransformedCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -6104,7 +6015,7 @@ SWIGINTERN PyObject *_wrap_new_DeltaCoefficient(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6112,15 +6023,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetDeltaCenter" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_SetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6154,7 +6069,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; double arg2 ; @@ -6162,15 +6077,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetScale", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetScale", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetScale" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeltaCoefficient_SetScale" "', argument " "2"" of type '" "double""'"); } @@ -6201,22 +6120,26 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; double (*arg2)(double) = (double (*)(double)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetFunction" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_double__double); + int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double__double); if (!SWIG_IsOK(res)) { SWIG_exception_fail(SWIG_ArgError(res), "in method '" "DeltaCoefficient_SetFunction" "', argument " "2"" of type '" "double (*)(double)""'"); } @@ -6247,7 +6170,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetFunction(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; double arg2 ; @@ -6255,15 +6178,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetTol" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DeltaCoefficient_SetTol" "', argument " "2"" of type '" "double""'"); } @@ -6294,7 +6221,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetTol(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetWeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; @@ -6302,15 +6229,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_SetWeight(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"w", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_SetWeight", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_SetWeight", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_SetWeight" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_SetWeight" "', argument " "2"" of type '" "mfem::Coefficient *""'"); } @@ -6505,7 +6436,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_Weight(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6513,15 +6444,19 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_GetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaCoefficient_GetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_GetDeltaCenter" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_GetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6555,7 +6490,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6566,16 +6501,21 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_EvalDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeltaCoefficient_EvalDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_EvalDelta" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6583,7 +6523,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeltaCoefficient_EvalDelta" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -6617,7 +6557,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaCoefficient *arg1 = (mfem::DeltaCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6628,16 +6568,21 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DeltaCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeltaCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaCoefficient_Eval" "', argument " "1"" of type '" "mfem::DeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6645,7 +6590,7 @@ SWIGINTERN PyObject *_wrap_DeltaCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeltaCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -6730,7 +6675,7 @@ SWIGINTERN PyObject *DeltaCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; @@ -6738,11 +6683,15 @@ SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_c", (char *)"attr", NULL + }; mfem::RestrictedCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_RestrictedCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_RestrictedCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RestrictedCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -6750,7 +6699,7 @@ SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RestrictedCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RestrictedCoefficient" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -6784,7 +6733,7 @@ SWIGINTERN PyObject *_wrap_new_RestrictedCoefficient(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RestrictedCoefficient *arg1 = (mfem::RestrictedCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6795,16 +6744,21 @@ SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "RestrictedCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RestrictedCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RestrictedCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RestrictedCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RestrictedCoefficient_Eval" "', argument " "1"" of type '" "mfem::RestrictedCoefficient *""'"); } arg1 = reinterpret_cast< mfem::RestrictedCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6812,7 +6766,7 @@ SWIGINTERN PyObject *_wrap_RestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RestrictedCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -6897,7 +6851,7 @@ SWIGINTERN PyObject *RestrictedCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_VectorCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = (mfem::VectorCoefficient *) 0 ; double arg2 ; @@ -6905,15 +6859,19 @@ SWIGINTERN PyObject *_wrap_VectorCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorCoefficient_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorCoefficient_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorCoefficient_SetTime" "', argument " "1"" of type '" "mfem::VectorCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorCoefficient_SetTime" "', argument " "2"" of type '" "double""'"); } @@ -7279,17 +7237,19 @@ SWIGINTERN PyObject *VectorCoefficient_swigregister(PyObject *SWIGUNUSEDPARM(sel return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_VectorConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"v", NULL + }; mfem::VectorConstantCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorConstantCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorConstantCoefficient" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -7720,12 +7680,12 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_0(PyObject *SWIGU PyObject *resultobj = 0; int arg1 ; void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp3 = 0 ; int res3 = 0 ; mfem::VectorFunctionCoefficient *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -7738,11 +7698,13 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); { try { result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2,arg3); @@ -7770,60 +7732,15 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; - mfem::VectorFunctionCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); - } - } - { - try { - result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; void (*arg2)(mfem::Vector const &,double,mfem::Vector &) = (void (*)(mfem::Vector const &,double,mfem::Vector &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp3 = 0 ; int res3 = 0 ; mfem::VectorFunctionCoefficient *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -7836,59 +7753,16 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_2(PyObject *SWIGU SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::Vector &)""'"); } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,double,mfem::Vector &) = (void (*)(mfem::Vector const &,double,mfem::Vector &)) 0 ; - mfem::VectorFunctionCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_VectorFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::Vector &)""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } { try { - result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2); + result = (mfem::VectorFunctionCoefficient *)new mfem::VectorFunctionCoefficient(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7920,7 +7794,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFunctionCoefficient", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -7935,54 +7809,19 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_new_VectorFunctionCoefficient__SWIG_0(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_2(self, argc, argv); + return _wrap_new_VectorFunctionCoefficient__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -7994,14 +7833,17 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec } if (_v) { void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__Vector__void); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_VectorFunctionCoefficient__SWIG_1(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_VectorFunctionCoefficient__SWIG_0(self, argc, argv); + return _wrap_new_VectorFunctionCoefficient__SWIG_1(self, argc, argv); } } } @@ -8011,9 +7853,7 @@ SWIGINTERN PyObject *_wrap_new_VectorFunctionCoefficient(PyObject *self, PyObjec SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFunctionCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::Vector &),mfem::Coefficient *)\n" - " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::Vector &))\n" - " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::Vector &),mfem::Coefficient *)\n" - " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::Vector &))\n"); + " mfem::VectorFunctionCoefficient::VectorFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::Vector &),mfem::Coefficient *)\n"); return 0; } @@ -8370,19 +8210,21 @@ SWIGINTERN PyObject *VectorFunctionCoefficient_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"dim", NULL + }; mfem::VectorArrayCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorArrayCoefficient", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -8410,26 +8252,30 @@ SWIGINTERN PyObject *_wrap_new_VectorArrayCoefficient(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::Coefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorArrayCoefficient_GetCoeff", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorArrayCoefficient_GetCoeff", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_GetCoeff" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -8498,41 +8344,50 @@ SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_GetCoeffs(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; int arg2 ; mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; - bool arg4 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"c", (char *)"own", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:VectorArrayCoefficient_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorArrayCoefficient_Set" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorArrayCoefficient_Set" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorArrayCoefficient_Set" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { (arg1)->Set(arg2,arg3,arg4); @@ -8559,20 +8414,24 @@ SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; int arg2 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::IntegrationPoint *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_Eval" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorArrayCoefficient * >(argp1); { @@ -8581,14 +8440,25 @@ SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUS }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorArrayCoefficient_Set" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorArrayCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorArrayCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg4 = reinterpret_cast< mfem::IntegrationPoint * >(argp4); { try { - (arg1)->Set(arg2,arg3); + result = (double)(arg1)->Eval(arg2,*arg3,(mfem::IntegrationPoint const &)*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8605,154 +8475,14 @@ SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Set(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "VectorArrayCoefficient_Set", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_VectorArrayCoefficient_Set__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_VectorArrayCoefficient_Set__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'VectorArrayCoefficient_Set'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorArrayCoefficient::Set(int,mfem::Coefficient *,bool)\n" - " mfem::VectorArrayCoefficient::Set(int,mfem::Coefficient *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; - int arg2 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::IntegrationPoint *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorArrayCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorArrayCoefficient_Eval" "', argument " "1"" of type '" "mfem::VectorArrayCoefficient *""'"); - } - arg1 = reinterpret_cast< mfem::VectorArrayCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorArrayCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorArrayCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorArrayCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); - } - arg4 = reinterpret_cast< mfem::IntegrationPoint * >(argp4); - { - try { - result = (double)(arg1)->Eval(arg2,*arg3,(mfem::IntegrationPoint const &)*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Eval__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_VectorArrayCoefficient_Eval__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorArrayCoefficient *arg1 = (mfem::VectorArrayCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9233,7 +8963,7 @@ SWIGINTERN PyObject *_wrap_new_VectorGridFunctionCoefficient(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_VectorGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorGridFunctionCoefficient *arg1 = (mfem::VectorGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -9241,15 +8971,19 @@ SWIGINTERN PyObject *_wrap_VectorGridFunctionCoefficient_SetGridFunction(PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::VectorGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -9578,17 +9312,19 @@ SWIGINTERN PyObject *VectorGridFunctionCoefficient_swiginit(PyObject *SWIGUNUSED return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GradientGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GradientGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"gf", NULL + }; mfem::GradientGridFunctionCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_GradientGridFunctionCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GradientGridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } @@ -9619,7 +9355,7 @@ SWIGINTERN PyObject *_wrap_new_GradientGridFunctionCoefficient(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GradientGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GradientGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GradientGridFunctionCoefficient *arg1 = (mfem::GradientGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -9627,15 +9363,19 @@ SWIGINTERN PyObject *_wrap_GradientGridFunctionCoefficient_SetGridFunction(PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GradientGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GradientGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GradientGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GradientGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GradientGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::GradientGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::GradientGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GradientGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -9964,7 +9704,7 @@ SWIGINTERN PyObject *GradientGridFunctionCoefficient_swiginit(PyObject *SWIGUNUS return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_CurlGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CurlGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CurlGridFunctionCoefficient *arg1 = (mfem::CurlGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -9972,15 +9712,19 @@ SWIGINTERN PyObject *_wrap_CurlGridFunctionCoefficient_SetGridFunction(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CurlGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CurlGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CurlGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CurlGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CurlGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::CurlGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::CurlGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CurlGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -10400,17 +10144,19 @@ SWIGINTERN PyObject *CurlGridFunctionCoefficient_swigregister(PyObject *SWIGUNUS return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_DivergenceGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DivergenceGridFunctionCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"gf", NULL + }; mfem::DivergenceGridFunctionCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_DivergenceGridFunctionCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DivergenceGridFunctionCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } @@ -10441,7 +10187,7 @@ SWIGINTERN PyObject *_wrap_new_DivergenceGridFunctionCoefficient(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_SetGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivergenceGridFunctionCoefficient *arg1 = (mfem::DivergenceGridFunctionCoefficient *) 0 ; mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; @@ -10449,15 +10195,19 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_SetGridFunction(PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DivergenceGridFunctionCoefficient_SetGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DivergenceGridFunctionCoefficient_SetGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceGridFunctionCoefficient_SetGridFunction" "', argument " "1"" of type '" "mfem::DivergenceGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DivergenceGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceGridFunctionCoefficient_SetGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); } @@ -10529,7 +10279,7 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_GetGridFunction(PyO } -SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DivergenceGridFunctionCoefficient *arg1 = (mfem::DivergenceGridFunctionCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -10540,16 +10290,21 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DivergenceGridFunctionCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DivergenceGridFunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DivergenceGridFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::DivergenceGridFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DivergenceGridFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -10557,7 +10312,7 @@ SWIGINTERN PyObject *_wrap_DivergenceGridFunctionCoefficient_Eval(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DivergenceGridFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11041,7 +10796,7 @@ SWIGINTERN PyObject *_wrap_new_VectorDeltaCoefficient(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::DeltaCoefficient *arg2 = 0 ; @@ -11049,15 +10804,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCoefficient(PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetDeltaCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetDeltaCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetDeltaCoefficient" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DeltaCoefficient, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_SetDeltaCoefficient" "', argument " "2"" of type '" "mfem::DeltaCoefficient const &""'"); } @@ -11132,7 +10891,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCoefficient(PyObject * } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; double arg2 ; @@ -11140,15 +10899,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDP int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetScale", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetScale", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetScale" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "VectorDeltaCoefficient_SetScale" "', argument " "2"" of type '" "double""'"); } @@ -11179,7 +10942,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetScale(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11187,15 +10950,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetDirection", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetDirection", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetDirection" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_SetDirection" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11229,7 +10996,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDirection(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11237,15 +11004,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_SetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_SetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_SetDeltaCenter" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_SetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11279,7 +11050,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_SetDeltaCenter(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11287,15 +11058,19 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_GetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorDeltaCoefficient_GetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_GetDeltaCenter" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_GetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -11329,7 +11104,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_GetDeltaCenter(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDeltaCoefficient *arg1 = (mfem::VectorDeltaCoefficient *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11343,15 +11118,21 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"V", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDeltaCoefficient_EvalDelta", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorDeltaCoefficient_EvalDelta", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDeltaCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "1"" of type '" "mfem::VectorDeltaCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorDeltaCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -11359,7 +11140,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -11367,7 +11148,7 @@ SWIGINTERN PyObject *_wrap_VectorDeltaCoefficient_EvalDelta(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDeltaCoefficient_EvalDelta" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11753,7 +11534,7 @@ SWIGINTERN PyObject *VectorDeltaCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; @@ -11761,11 +11542,15 @@ SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"vc", (char *)"attr", NULL + }; mfem::VectorRestrictedCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorRestrictedCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_VectorRestrictedCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorRestrictedCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -11773,7 +11558,7 @@ SWIGINTERN PyObject *_wrap_new_VectorRestrictedCoefficient(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorRestrictedCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorRestrictedCoefficient" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -12064,7 +11849,7 @@ SWIGINTERN PyObject *VectorRestrictedCoefficient_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MatrixCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; double arg2 ; @@ -12072,15 +11857,19 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_SetTime(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixCoefficient_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MatrixCoefficient_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixCoefficient_SetTime" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MatrixCoefficient_SetTime" "', argument " "2"" of type '" "double""'"); } @@ -12275,7 +12064,7 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_GetVDim(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = (mfem::MatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12289,15 +12078,21 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self) int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -12305,7 +12100,7 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -12313,7 +12108,7 @@ SWIGINTERN PyObject *_wrap_MatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12394,17 +12189,19 @@ SWIGINTERN PyObject *MatrixCoefficient_swigregister(PyObject *SWIGUNUSEDPARM(sel return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_MatrixConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixConstantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"m", NULL + }; mfem::MatrixConstantCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MatrixConstantCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixConstantCoefficient" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12699,12 +12496,12 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_0(PyObject *SWIGU PyObject *resultobj = 0; int arg1 ; void (*arg2)(mfem::Vector const &,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,mfem::DenseMatrix &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp3 = 0 ; int res3 = 0 ; mfem::MatrixFunctionCoefficient *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -12717,11 +12514,13 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::DenseMatrix &)""'"); } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); + } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); { try { result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2,arg3); @@ -12749,51 +12548,6 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_0(PyObject *SWIGU SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,mfem::DenseMatrix &)) 0 ; - mfem::MatrixFunctionCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__DenseMatrix__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::DenseMatrix &)""'"); - } - } - { - try { - result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; @@ -12846,16 +12600,16 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_2(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; void (*arg2)(mfem::Vector const &,double,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)) 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp3 = 0 ; int res3 = 0 ; mfem::MatrixFunctionCoefficient *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -12868,59 +12622,16 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_3(PyObject *SWIGU SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)""'"); } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixFunctionCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - void (*arg2)(mfem::Vector const &,double,mfem::DenseMatrix &) = (void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)) 0 ; - mfem::MatrixFunctionCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__DenseMatrix__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "new_MatrixFunctionCoefficient" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,double,mfem::DenseMatrix &)""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MatrixFunctionCoefficient" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } { try { - result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2); + result = (mfem::MatrixFunctionCoefficient *)new mfem::MatrixFunctionCoefficient(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12961,11 +12672,11 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_2(self, argc, argv); + return _wrap_new_MatrixFunctionCoefficient__SWIG_1(self, argc, argv); } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -12980,11 +12691,19 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__DenseMatrix__void); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_1(self, argc, argv); + if (argc <= 2) { + return _wrap_new_MatrixFunctionCoefficient__SWIG_0(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MatrixFunctionCoefficient__SWIG_0(self, argc, argv); + } } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -12999,55 +12718,15 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__DenseMatrix__void); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_double_r_mfem__DenseMatrix__void); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__DenseMatrix__void); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MatrixFunctionCoefficient__SWIG_0(self, argc, argv); - } + if (argc <= 2) { + return _wrap_new_MatrixFunctionCoefficient__SWIG_2(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_MatrixFunctionCoefficient__SWIG_2(self, argc, argv); + } } } } @@ -13056,15 +12735,13 @@ SWIGINTERN PyObject *_wrap_new_MatrixFunctionCoefficient(PyObject *self, PyObjec SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MatrixFunctionCoefficient'.\n" " Possible C/C++ prototypes are:\n" " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::DenseMatrix &),mfem::Coefficient *)\n" - " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,mfem::DenseMatrix &))\n" " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(mfem::DenseMatrix const &,mfem::Coefficient &)\n" - " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::DenseMatrix &),mfem::Coefficient *)\n" - " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::DenseMatrix &))\n"); + " mfem::MatrixFunctionCoefficient::MatrixFunctionCoefficient(int,void (*)(mfem::Vector const &,double,mfem::DenseMatrix &),mfem::Coefficient *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixFunctionCoefficient *arg1 = (mfem::MatrixFunctionCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13078,15 +12755,21 @@ SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixFunctionCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixFunctionCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixFunctionCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixFunctionCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixFunctionCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixFunctionCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13094,7 +12777,7 @@ SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13102,7 +12785,7 @@ SWIGINTERN PyObject *_wrap_MatrixFunctionCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixFunctionCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13187,19 +12870,21 @@ SWIGINTERN PyObject *MatrixFunctionCoefficient_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixArrayCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"dim", NULL + }; mfem::MatrixArrayCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_MatrixArrayCoefficient", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -13227,33 +12912,38 @@ SWIGINTERN PyObject *_wrap_new_MatrixArrayCoefficient(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; mfem::Coefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MatrixArrayCoefficient_GetCoeff", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MatrixArrayCoefficient_GetCoeff", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_GetCoeff" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -13281,111 +12971,61 @@ SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_GetCoeff(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; int arg2 ; int arg3 ; mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - bool arg5 ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; bool val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"c", (char *)"own", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:MatrixArrayCoefficient_Set", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixArrayCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixArrayCoefficient_Set" "', argument " "4"" of type '" "mfem::Coefficient *""'"); } arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MatrixArrayCoefficient_Set" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - (arg1)->Set(arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; - int arg2 ; - int arg3 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixArrayCoefficient_Set" "', argument " "1"" of type '" "mfem::MatrixArrayCoefficient *""'"); - } - arg1 = reinterpret_cast< mfem::MatrixArrayCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixArrayCoefficient_Set" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "MatrixArrayCoefficient_Set" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); { try { - (arg1)->Set(arg2,arg3,arg4); + (arg1)->Set(arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13409,98 +13049,6 @@ SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Set(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MatrixArrayCoefficient_Set", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MatrixArrayCoefficient_Set__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixArrayCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MatrixArrayCoefficient_Set__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MatrixArrayCoefficient_Set'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MatrixArrayCoefficient::Set(int,int,mfem::Coefficient *,bool)\n" - " mfem::MatrixArrayCoefficient::Set(int,int,mfem::Coefficient *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_MatrixArrayCoefficient_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::MatrixArrayCoefficient *arg1 = (mfem::MatrixArrayCoefficient *) 0 ; @@ -13777,7 +13325,7 @@ SWIGINTERN PyObject *MatrixArrayCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; @@ -13785,11 +13333,15 @@ SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"mc", (char *)"attr", NULL + }; mfem::MatrixRestrictedCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_MatrixRestrictedCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_MatrixRestrictedCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixRestrictedCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -13797,7 +13349,7 @@ SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixRestrictedCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixRestrictedCoefficient" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -13831,7 +13383,7 @@ SWIGINTERN PyObject *_wrap_new_MatrixRestrictedCoefficient(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixRestrictedCoefficient *arg1 = (mfem::MatrixRestrictedCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13845,15 +13397,21 @@ SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixRestrictedCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixRestrictedCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixRestrictedCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixRestrictedCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixRestrictedCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixRestrictedCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13861,7 +13419,7 @@ SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -13869,7 +13427,7 @@ SWIGINTERN PyObject *_wrap_MatrixRestrictedCoefficient_Eval(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixRestrictedCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13954,12 +13512,12 @@ SWIGINTERN PyObject *MatrixRestrictedCoefficient_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SumCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + double arg3 = (double) 1.0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13968,76 +13526,17 @@ SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(s int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"_alpha", (char *)"_beta", NULL + }; mfem::SumCoefficient *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SumCoefficient" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::SumCoefficient *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_SumCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -14045,7 +13544,7 @@ SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } @@ -14053,67 +13552,23 @@ SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SumCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SumCoefficient" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SumCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SumCoefficient" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2); + result = (mfem::SumCoefficient *)new mfem::SumCoefficient(*arg1,*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14127,96 +13582,17 @@ SWIGINTERN PyObject *_wrap_new_SumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(s SWIG_fail; } catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SumCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SumCoefficient", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_SumCoefficient__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SumCoefficient__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SumCoefficient__SWIG_0(self, argc, argv); - } - } - } - } + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SumCoefficient, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SumCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SumCoefficient::SumCoefficient(mfem::Coefficient &,mfem::Coefficient &,double,double)\n" - " mfem::SumCoefficient::SumCoefficient(mfem::Coefficient &,mfem::Coefficient &,double)\n" - " mfem::SumCoefficient::SumCoefficient(mfem::Coefficient &,mfem::Coefficient &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SumCoefficient *arg1 = (mfem::SumCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -14227,16 +13603,21 @@ SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "SumCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SumCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SumCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SumCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SumCoefficient_Eval" "', argument " "1"" of type '" "mfem::SumCoefficient *""'"); } arg1 = reinterpret_cast< mfem::SumCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SumCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -14244,7 +13625,7 @@ SWIGINTERN PyObject *_wrap_SumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SumCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SumCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14329,7 +13710,7 @@ SWIGINTERN PyObject *SumCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; @@ -14337,11 +13718,15 @@ SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::ProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -14349,7 +13734,7 @@ SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ProductCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } @@ -14383,7 +13768,7 @@ SWIGINTERN PyObject *_wrap_new_ProductCoefficient(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ProductCoefficient *arg1 = (mfem::ProductCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -14394,16 +13779,21 @@ SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ProductCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::ProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -14411,7 +13801,7 @@ SWIGINTERN PyObject *_wrap_ProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14496,7 +13886,7 @@ SWIGINTERN PyObject *ProductCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; double arg2 ; @@ -14504,11 +13894,15 @@ SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"_p", NULL + }; mfem::PowerCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_PowerCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_PowerCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PowerCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -14516,7 +13910,7 @@ SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PowerCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PowerCoefficient" "', argument " "2"" of type '" "double""'"); } @@ -14547,7 +13941,7 @@ SWIGINTERN PyObject *_wrap_new_PowerCoefficient(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PowerCoefficient *arg1 = (mfem::PowerCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -14558,16 +13952,21 @@ SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "PowerCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PowerCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PowerCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PowerCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PowerCoefficient_Eval" "', argument " "1"" of type '" "mfem::PowerCoefficient *""'"); } arg1 = reinterpret_cast< mfem::PowerCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PowerCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -14575,7 +13974,7 @@ SWIGINTERN PyObject *_wrap_PowerCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PowerCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PowerCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14660,7 +14059,7 @@ SWIGINTERN PyObject *PowerCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -14668,11 +14067,15 @@ SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::InnerProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_InnerProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_InnerProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InnerProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14680,7 +14083,7 @@ SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InnerProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InnerProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14714,7 +14117,7 @@ SWIGINTERN PyObject *_wrap_new_InnerProductCoefficient(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InnerProductCoefficient *arg1 = (mfem::InnerProductCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -14725,16 +14128,21 @@ SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "InnerProductCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InnerProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InnerProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InnerProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InnerProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::InnerProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::InnerProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InnerProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -14742,7 +14150,7 @@ SWIGINTERN PyObject *_wrap_InnerProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InnerProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InnerProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14827,7 +14235,7 @@ SWIGINTERN PyObject *InnerProductCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -14835,11 +14243,15 @@ SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::VectorRotProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorRotProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_VectorRotProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorRotProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14847,7 +14259,7 @@ SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorRotProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorRotProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -14881,7 +14293,7 @@ SWIGINTERN PyObject *_wrap_new_VectorRotProductCoefficient(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorRotProductCoefficient *arg1 = (mfem::VectorRotProductCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -14892,16 +14304,21 @@ SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "VectorRotProductCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorRotProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorRotProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorRotProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorRotProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::VectorRotProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::VectorRotProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorRotProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -14909,7 +14326,7 @@ SWIGINTERN PyObject *_wrap_VectorRotProductCoefficient_Eval(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorRotProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorRotProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14994,17 +14411,19 @@ SWIGINTERN PyObject *VectorRotProductCoefficient_swiginit(PyObject *SWIGUNUSEDPA return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DeterminantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DeterminantCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"A", NULL + }; mfem::DeterminantCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_DeterminantCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DeterminantCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -15038,7 +14457,7 @@ SWIGINTERN PyObject *_wrap_new_DeterminantCoefficient(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeterminantCoefficient *arg1 = (mfem::DeterminantCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -15049,16 +14468,21 @@ SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DeterminantCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeterminantCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DeterminantCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeterminantCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeterminantCoefficient_Eval" "', argument " "1"" of type '" "mfem::DeterminantCoefficient *""'"); } arg1 = reinterpret_cast< mfem::DeterminantCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeterminantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -15066,7 +14490,7 @@ SWIGINTERN PyObject *_wrap_DeterminantCoefficient_Eval(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeterminantCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeterminantCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15151,12 +14575,12 @@ SWIGINTERN PyObject *DeterminantCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + double arg3 = (double) 1.0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -15165,251 +14589,69 @@ SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_0(PyObject *SWIGUNUSED int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"_alpha", (char *)"_beta", NULL + }; mfem::VectorSumCoefficient *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VectorSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VectorSumCoefficient" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::VectorSumCoefficient *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VectorSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::VectorSumCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_VectorSumCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorSumCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorSumCoefficient", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorSumCoefficient__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorSumCoefficient__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorSumCoefficient__SWIG_0(self, argc, argv); - } - } - } + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); + } + arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorSumCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_VectorSumCoefficient" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_VectorSumCoefficient" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + { + try { + result = (mfem::VectorSumCoefficient *)new mfem::VectorSumCoefficient(*arg1,*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorSumCoefficient, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorSumCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorSumCoefficient::VectorSumCoefficient(mfem::VectorCoefficient &,mfem::VectorCoefficient &,double,double)\n" - " mfem::VectorSumCoefficient::VectorSumCoefficient(mfem::VectorCoefficient &,mfem::VectorCoefficient &,double)\n" - " mfem::VectorSumCoefficient::VectorSumCoefficient(mfem::VectorCoefficient &,mfem::VectorCoefficient &)\n"); - return 0; + return NULL; } @@ -15670,7 +14912,7 @@ SWIGINTERN PyObject *VectorSumCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -15678,11 +14920,15 @@ SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::ScalarVectorProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ScalarVectorProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ScalarVectorProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarVectorProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -15690,7 +14936,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarVectorProductCoefficient(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarVectorProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScalarVectorProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -15981,7 +15227,7 @@ SWIGINTERN PyObject *ScalarVectorProductCoefficient_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -15989,11 +15235,15 @@ SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::VectorCrossProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorCrossProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_VectorCrossProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorCrossProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -16001,7 +15251,7 @@ SWIGINTERN PyObject *_wrap_new_VectorCrossProductCoefficient(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorCrossProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_VectorCrossProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -16292,7 +15542,7 @@ SWIGINTERN PyObject *VectorCrossProductCoefficient_swiginit(PyObject *SWIGUNUSED return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -16300,11 +15550,15 @@ SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::MatVecCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_MatVecCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_MatVecCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatVecCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -16312,7 +15566,7 @@ SWIGINTERN PyObject *_wrap_new_MatVecCoefficient(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatVecCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatVecCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -16603,19 +15857,21 @@ SWIGINTERN PyObject *MatVecCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IdentityMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_IdentityMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"d", NULL + }; mfem::IdentityMatrixCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_IdentityMatrixCoefficient", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -16643,7 +15899,7 @@ SWIGINTERN PyObject *_wrap_new_IdentityMatrixCoefficient(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityMatrixCoefficient *arg1 = (mfem::IdentityMatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -16657,15 +15913,21 @@ SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityMatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityMatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IdentityMatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityMatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::IdentityMatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::IdentityMatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -16673,7 +15935,7 @@ SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -16681,7 +15943,7 @@ SWIGINTERN PyObject *_wrap_IdentityMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IdentityMatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16766,12 +16028,12 @@ SWIGINTERN PyObject *IdentityMatrixCoefficient_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; mfem::MatrixCoefficient *arg2 = 0 ; - double arg3 ; - double arg4 ; + double arg3 = (double) 1.0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -16780,134 +16042,17 @@ SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_0(PyObject *SWIGUNUSED int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"_alpha", (char *)"_beta", NULL + }; mfem::MatrixSumCoefficient *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MatrixSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MatrixSumCoefficient" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - mfem::MatrixCoefficient *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::MatrixSumCoefficient *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MatrixSumCoefficient" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MatrixCoefficient *arg1 = 0 ; - mfem::MatrixCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::MatrixSumCoefficient *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_MatrixSumCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -16915,120 +16060,55 @@ SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient__SWIG_2(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } arg1 = reinterpret_cast< mfem::MatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_MatrixSumCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - { - try { - result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_MatrixSumCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_MatrixSumCoefficient", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_MatrixSumCoefficient__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MatrixSumCoefficient__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__MatrixCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_MatrixSumCoefficient__SWIG_0(self, argc, argv); - } - } - } + } + arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_MatrixSumCoefficient" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_MatrixSumCoefficient" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + { + try { + result = (mfem::MatrixSumCoefficient *)new mfem::MatrixSumCoefficient(*arg1,*arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MatrixSumCoefficient, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MatrixSumCoefficient'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MatrixSumCoefficient::MatrixSumCoefficient(mfem::MatrixCoefficient &,mfem::MatrixCoefficient &,double,double)\n" - " mfem::MatrixSumCoefficient::MatrixSumCoefficient(mfem::MatrixCoefficient &,mfem::MatrixCoefficient &,double)\n" - " mfem::MatrixSumCoefficient::MatrixSumCoefficient(mfem::MatrixCoefficient &,mfem::MatrixCoefficient &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixSumCoefficient *arg1 = (mfem::MatrixSumCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -17042,15 +16122,21 @@ SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MatrixSumCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixSumCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixSumCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixSumCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixSumCoefficient_Eval" "', argument " "1"" of type '" "mfem::MatrixSumCoefficient *""'"); } arg1 = reinterpret_cast< mfem::MatrixSumCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixSumCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -17058,7 +16144,7 @@ SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixSumCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixSumCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -17066,7 +16152,7 @@ SWIGINTERN PyObject *_wrap_MatrixSumCoefficient_Eval(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixSumCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixSumCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17151,7 +16237,7 @@ SWIGINTERN PyObject *MatrixSumCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -17159,11 +16245,15 @@ SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::ScalarMatrixProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ScalarMatrixProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ScalarMatrixProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScalarMatrixProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -17171,7 +16261,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ScalarMatrixProductCoefficient" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ScalarMatrixProductCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -17205,7 +16295,7 @@ SWIGINTERN PyObject *_wrap_new_ScalarMatrixProductCoefficient(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarMatrixProductCoefficient *arg1 = (mfem::ScalarMatrixProductCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -17219,15 +16309,21 @@ SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarMatrixProductCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ScalarMatrixProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarMatrixProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::ScalarMatrixProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ScalarMatrixProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -17235,7 +16331,7 @@ SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -17243,7 +16339,7 @@ SWIGINTERN PyObject *_wrap_ScalarMatrixProductCoefficient_Eval(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarMatrixProductCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17328,17 +16424,19 @@ SWIGINTERN PyObject *ScalarMatrixProductCoefficient_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TransposeMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TransposeMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"A", NULL + }; mfem::TransposeMatrixCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_TransposeMatrixCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TransposeMatrixCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -17372,7 +16470,7 @@ SWIGINTERN PyObject *_wrap_new_TransposeMatrixCoefficient(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeMatrixCoefficient *arg1 = (mfem::TransposeMatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -17386,15 +16484,21 @@ SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDP int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeMatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeMatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TransposeMatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeMatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::TransposeMatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::TransposeMatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -17402,7 +16506,7 @@ SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -17410,7 +16514,7 @@ SWIGINTERN PyObject *_wrap_TransposeMatrixCoefficient_Eval(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TransposeMatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17495,17 +16599,19 @@ SWIGINTERN PyObject *TransposeMatrixCoefficient_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_InverseMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InverseMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"A", NULL + }; mfem::InverseMatrixCoefficient *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_InverseMatrixCoefficient", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseMatrixCoefficient" "', argument " "1"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -17539,7 +16645,7 @@ SWIGINTERN PyObject *_wrap_new_InverseMatrixCoefficient(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseMatrixCoefficient *arg1 = (mfem::InverseMatrixCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -17553,15 +16659,21 @@ SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseMatrixCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseMatrixCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:InverseMatrixCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseMatrixCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "1"" of type '" "mfem::InverseMatrixCoefficient *""'"); } arg1 = reinterpret_cast< mfem::InverseMatrixCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -17569,7 +16681,7 @@ SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseMatrixCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -17577,7 +16689,7 @@ SWIGINTERN PyObject *_wrap_InverseMatrixCoefficient_Eval(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseMatrixCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "InverseMatrixCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17662,7 +16774,7 @@ SWIGINTERN PyObject *InverseMatrixCoefficient_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -17670,11 +16782,15 @@ SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::OuterProductCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_OuterProductCoefficient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_OuterProductCoefficient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OuterProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -17682,7 +16798,7 @@ SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OuterProductCoefficient" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OuterProductCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -17716,7 +16832,7 @@ SWIGINTERN PyObject *_wrap_new_OuterProductCoefficient(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OuterProductCoefficient *arg1 = (mfem::OuterProductCoefficient *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -17730,15 +16846,21 @@ SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", (char *)"T", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OuterProductCoefficient_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OuterProductCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OuterProductCoefficient_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OuterProductCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OuterProductCoefficient_Eval" "', argument " "1"" of type '" "mfem::OuterProductCoefficient *""'"); } arg1 = reinterpret_cast< mfem::OuterProductCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OuterProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -17746,7 +16868,7 @@ SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OuterProductCoefficient_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OuterProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -17754,7 +16876,7 @@ SWIGINTERN PyObject *_wrap_OuterProductCoefficient_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OuterProductCoefficient_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OuterProductCoefficient_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -18075,17 +17197,19 @@ SWIGINTERN PyObject *_wrap_ComputeLpNorm(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_fake_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fake_func(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"x", NULL + }; double result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:fake_func", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fake_func" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -18119,7 +17243,7 @@ SWIGINTERN PyObject *_wrap_fake_func(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -18127,10 +17251,14 @@ SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"Ht", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "fake_func_vec", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fake_func_vec", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fake_func_vec" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -18138,7 +17266,7 @@ SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fake_func_vec" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fake_func_vec" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -18172,7 +17300,7 @@ SWIGINTERN PyObject *_wrap_fake_func_vec(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -18180,10 +17308,14 @@ SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"Kt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "fake_func_mat", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fake_func_mat", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fake_func_mat" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -18191,7 +17323,7 @@ SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "fake_func_mat" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fake_func_mat" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -18225,20 +17357,24 @@ SWIGINTERN PyObject *_wrap_fake_func_mat(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_new_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"tdep", NULL + }; mfem::PyCoefficientBase *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_PyCoefficientBase", 2, 2, swig_obj)) SWIG_fail; - arg1 = swig_obj[0]; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_PyCoefficientBase", kwnames, &obj0, &obj1)) SWIG_fail; + arg1 = obj0; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -18273,7 +17409,7 @@ SWIGINTERN PyObject *_wrap_new_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -18284,18 +17420,23 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "PyCoefficientBase_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyCoefficientBase_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCoefficientBase_Eval" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::PyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -18303,7 +17444,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyCoefficientBase_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -18312,7 +17453,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) } arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -18347,7 +17488,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18355,18 +17496,22 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "PyCoefficientBase__EvalPy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PyCoefficientBase__EvalPy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCoefficientBase__EvalPy" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::PyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -18375,7 +17520,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(se } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -18410,7 +17555,7 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18421,18 +17566,23 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "PyCoefficientBase__EvalPyT", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyCoefficientBase__EvalPyT", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCoefficientBase__EvalPyT" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::PyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -18440,13 +17590,13 @@ SWIGINTERN PyObject *_wrap_PyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyCoefficientBase__EvalPyT" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -18521,16 +17671,18 @@ SWIGINTERN PyObject *_wrap_delete_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_disown_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_PyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyCoefficientBase *arg1 = (mfem::PyCoefficientBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_PyCoefficientBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PyCoefficientBase" "', argument " "1"" of type '" "mfem::PyCoefficientBase *""'"); } @@ -18558,35 +17710,44 @@ SWIGINTERN PyObject *PyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"dim", (char *)"tdep", (char *)"q", NULL + }; mfem::VectorPyCoefficientBase *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - arg1 = swig_obj[0]; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_VectorPyCoefficientBase", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + arg1 = obj0; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VectorPyCoefficientBase" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + if (obj3) { + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_VectorPyCoefficientBase" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); { try { if ( arg1 != Py_None ) { @@ -18619,136 +17780,6 @@ SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - mfem::VectorPyCoefficientBase *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::VectorPyCoefficientBase *)new SwigDirector_VectorPyCoefficientBase(arg1,arg2,arg3); - } else { - result = (mfem::VectorPyCoefficientBase *)new mfem::VectorPyCoefficientBase(arg2,arg3); - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorPyCoefficientBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorPyCoefficientBase(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorPyCoefficientBase", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorPyCoefficientBase__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorPyCoefficientBase__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorPyCoefficientBase'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorPyCoefficientBase::VectorPyCoefficientBase(int,int,mfem::Coefficient *)\n" - " mfem::VectorPyCoefficientBase::VectorPyCoefficientBase(PyObject *,int,int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase_Eval__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; @@ -18979,7 +18010,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase_Eval(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -18990,17 +18021,22 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "VectorPyCoefficientBase__EvalPy", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorPyCoefficientBase__EvalPy", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "1"" of type '" "mfem::VectorPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::VectorPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -19008,7 +18044,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorPyCoefficientBase__EvalPy" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19017,7 +18053,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -19052,7 +18088,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -19066,17 +18102,23 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", (char *)"arg2", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "VectorPyCoefficientBase__EvalPyT", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorPyCoefficientBase__EvalPyT", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "1"" of type '" "mfem::VectorPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::VectorPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -19084,12 +18126,12 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorPyCoefficientBase__EvalPyT" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -19098,7 +18140,7 @@ SWIGINTERN PyObject *_wrap_VectorPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -19173,16 +18215,18 @@ SWIGINTERN PyObject *_wrap_delete_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_disown_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_VectorPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorPyCoefficientBase *arg1 = (mfem::VectorPyCoefficientBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_VectorPyCoefficientBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_VectorPyCoefficientBase" "', argument " "1"" of type '" "mfem::VectorPyCoefficientBase *""'"); } @@ -19210,27 +18254,32 @@ SWIGINTERN PyObject *VectorPyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"dim", (char *)"tdep", NULL + }; mfem::MatrixPyCoefficientBase *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_MatrixPyCoefficientBase", 3, 3, swig_obj)) SWIG_fail; - arg1 = swig_obj[0]; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_MatrixPyCoefficientBase", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + arg1 = obj0; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -19264,7 +18313,7 @@ SWIGINTERN PyObject *_wrap_new_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -19278,17 +18327,23 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"K", (char *)"T", (char *)"ip", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "MatrixPyCoefficientBase_Eval", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixPyCoefficientBase_Eval", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::MatrixPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -19296,7 +18351,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -19304,7 +18359,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixPyCoefficientBase_Eval" "', argument " "4"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19313,7 +18368,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM } arg4 = reinterpret_cast< mfem::IntegrationPoint * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -19348,7 +18403,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase_Eval(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -19359,17 +18414,22 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "MatrixPyCoefficientBase__EvalPy", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MatrixPyCoefficientBase__EvalPy", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::MatrixPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -19377,7 +18437,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MatrixPyCoefficientBase__EvalPy" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19386,7 +18446,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -19421,7 +18481,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPy(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -19435,17 +18495,23 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", (char *)"arg1", (char *)"arg2", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "MatrixPyCoefficientBase__EvalPyT", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MatrixPyCoefficientBase__EvalPyT", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } arg1 = reinterpret_cast< mfem::MatrixPyCoefficientBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -19453,12 +18519,12 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MatrixPyCoefficientBase__EvalPyT" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -19467,7 +18533,7 @@ SWIGINTERN PyObject *_wrap_MatrixPyCoefficientBase__EvalPyT(PyObject *SWIGUNUSED } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -19542,16 +18608,18 @@ SWIGINTERN PyObject *_wrap_delete_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_disown_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_MatrixPyCoefficientBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MatrixPyCoefficientBase *arg1 = (mfem::MatrixPyCoefficientBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_MatrixPyCoefficientBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MatrixPyCoefficientBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_MatrixPyCoefficientBase" "', argument " "1"" of type '" "mfem::MatrixPyCoefficientBase *""'"); } @@ -19582,7 +18650,7 @@ SWIGINTERN PyObject *MatrixPyCoefficientBase_swiginit(PyObject *SWIGUNUSEDPARM(s static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "Coefficient_SetTime(Coefficient self, double t)"}, + { "Coefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_Coefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "Coefficient_SetTime(Coefficient self, double t)"}, { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "Coefficient_GetTime(Coefficient self) -> double"}, { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" "Coefficient_Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip) -> double\n" @@ -19592,8 +18660,8 @@ static PyMethodDef SwigMethods[] = { { "Coefficient_swigregister", Coefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_constant_set", _wrap_ConstantCoefficient_constant_set, METH_VARARGS, "ConstantCoefficient_constant_set(ConstantCoefficient self, double constant)"}, { "ConstantCoefficient_constant_get", _wrap_ConstantCoefficient_constant_get, METH_O, "ConstantCoefficient_constant_get(ConstantCoefficient self) -> double"}, - { "new_ConstantCoefficient", _wrap_new_ConstantCoefficient, METH_VARARGS, "ConstantCoefficient(double c=1.0)"}, - { "ConstantCoefficient_Eval", _wrap_ConstantCoefficient_Eval, METH_VARARGS, "ConstantCoefficient_Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ConstantCoefficient(double c=1.0) -> ConstantCoefficient"}, + { "ConstantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ConstantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ConstantCoefficient_Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ConstantCoefficient", _wrap_delete_ConstantCoefficient, METH_O, "delete_ConstantCoefficient(ConstantCoefficient self)"}, { "ConstantCoefficient_swigregister", ConstantCoefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_swiginit", ConstantCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19601,10 +18669,10 @@ static PyMethodDef SwigMethods[] = { "PWConstCoefficient(int NumOfSubD=0)\n" "new_PWConstCoefficient(Vector c) -> PWConstCoefficient\n" ""}, - { "PWConstCoefficient_UpdateConstants", _wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS, "PWConstCoefficient_UpdateConstants(PWConstCoefficient self, Vector c)"}, - { "PWConstCoefficient___call__", _wrap_PWConstCoefficient___call__, METH_VARARGS, "PWConstCoefficient___call__(PWConstCoefficient self, int i) -> double &"}, + { "PWConstCoefficient_UpdateConstants", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS|METH_KEYWORDS, "PWConstCoefficient_UpdateConstants(PWConstCoefficient self, Vector c)"}, + { "PWConstCoefficient___call__", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient___call__, METH_VARARGS|METH_KEYWORDS, "PWConstCoefficient___call__(PWConstCoefficient self, int i) -> double &"}, { "PWConstCoefficient_GetNConst", _wrap_PWConstCoefficient_GetNConst, METH_O, "PWConstCoefficient_GetNConst(PWConstCoefficient self) -> int"}, - { "PWConstCoefficient_Eval", _wrap_PWConstCoefficient_Eval, METH_VARARGS, "PWConstCoefficient_Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PWConstCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "PWConstCoefficient_Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PWConstCoefficient", _wrap_delete_PWConstCoefficient, METH_O, "delete_PWConstCoefficient(PWConstCoefficient self)"}, { "PWConstCoefficient_swigregister", PWConstCoefficient_swigregister, METH_O, NULL}, { "PWConstCoefficient_swiginit", PWConstCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19614,17 +18682,17 @@ static PyMethodDef SwigMethods[] = { "FunctionCoefficient(double (*)(mfem::Vector &) f)\n" "new_FunctionCoefficient(double (*)(mfem::Vector &,double) tdf) -> FunctionCoefficient\n" ""}, - { "FunctionCoefficient_Eval", _wrap_FunctionCoefficient_Eval, METH_VARARGS, "FunctionCoefficient_Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "FunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_FunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "FunctionCoefficient_Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_FunctionCoefficient", _wrap_delete_FunctionCoefficient, METH_O, "delete_FunctionCoefficient(FunctionCoefficient self)"}, { "FunctionCoefficient_swigregister", FunctionCoefficient_swigregister, METH_O, NULL}, { "FunctionCoefficient_swiginit", FunctionCoefficient_swiginit, METH_VARARGS, NULL}, { "new_GridFunctionCoefficient", _wrap_new_GridFunctionCoefficient, METH_VARARGS, "\n" "GridFunctionCoefficient()\n" - "GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1)\n" + "new_GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1) -> GridFunctionCoefficient\n" ""}, - { "GridFunctionCoefficient_SetGridFunction", _wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS, "GridFunctionCoefficient_SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "GridFunctionCoefficient_SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GridFunctionCoefficient_GetGridFunction", _wrap_GridFunctionCoefficient_GetGridFunction, METH_O, "GridFunctionCoefficient_GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "GridFunctionCoefficient_Eval", _wrap_GridFunctionCoefficient_Eval, METH_VARARGS, "GridFunctionCoefficient_Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "GridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "GridFunctionCoefficient_Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_GridFunctionCoefficient", _wrap_delete_GridFunctionCoefficient, METH_O, "delete_GridFunctionCoefficient(GridFunctionCoefficient self)"}, { "GridFunctionCoefficient_swigregister", GridFunctionCoefficient_swigregister, METH_O, NULL}, { "GridFunctionCoefficient_swiginit", GridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19632,7 +18700,7 @@ static PyMethodDef SwigMethods[] = { "TransformedCoefficient(Coefficient q, double (*)(double) F)\n" "new_TransformedCoefficient(Coefficient q1, Coefficient q2, double (*)(double,double) F) -> TransformedCoefficient\n" ""}, - { "TransformedCoefficient_Eval", _wrap_TransformedCoefficient_Eval, METH_VARARGS, "TransformedCoefficient_Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "TransformedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransformedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "TransformedCoefficient_Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_TransformedCoefficient", _wrap_delete_TransformedCoefficient, METH_O, "delete_TransformedCoefficient(TransformedCoefficient self)"}, { "TransformedCoefficient_swigregister", TransformedCoefficient_swigregister, METH_O, NULL}, { "TransformedCoefficient_swiginit", TransformedCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19642,27 +18710,27 @@ static PyMethodDef SwigMethods[] = { "DeltaCoefficient(double x, double y, double s)\n" "new_DeltaCoefficient(double x, double y, double z, double s) -> DeltaCoefficient\n" ""}, - { "DeltaCoefficient_SetDeltaCenter", _wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS, "DeltaCoefficient_SetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_SetScale", _wrap_DeltaCoefficient_SetScale, METH_VARARGS, "DeltaCoefficient_SetScale(DeltaCoefficient self, double _s)"}, - { "DeltaCoefficient_SetFunction", _wrap_DeltaCoefficient_SetFunction, METH_VARARGS, "DeltaCoefficient_SetFunction(DeltaCoefficient self, double (*)(double) f)"}, - { "DeltaCoefficient_SetTol", _wrap_DeltaCoefficient_SetTol, METH_VARARGS, "DeltaCoefficient_SetTol(DeltaCoefficient self, double _tol)"}, - { "DeltaCoefficient_SetWeight", _wrap_DeltaCoefficient_SetWeight, METH_VARARGS, "DeltaCoefficient_SetWeight(DeltaCoefficient self, Coefficient w)"}, + { "DeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetScale(DeltaCoefficient self, double _s)"}, + { "DeltaCoefficient_SetFunction", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetFunction, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetFunction(DeltaCoefficient self, double (*)(double) f)"}, + { "DeltaCoefficient_SetTol", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetTol, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetTol(DeltaCoefficient self, double _tol)"}, + { "DeltaCoefficient_SetWeight", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetWeight, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_SetWeight(DeltaCoefficient self, Coefficient w)"}, { "DeltaCoefficient_Center", _wrap_DeltaCoefficient_Center, METH_O, "DeltaCoefficient_Center(DeltaCoefficient self) -> double const *"}, { "DeltaCoefficient_Scale", _wrap_DeltaCoefficient_Scale, METH_O, "DeltaCoefficient_Scale(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Tol", _wrap_DeltaCoefficient_Tol, METH_O, "DeltaCoefficient_Tol(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Weight", _wrap_DeltaCoefficient_Weight, METH_O, "DeltaCoefficient_Weight(DeltaCoefficient self) -> Coefficient"}, - { "DeltaCoefficient_GetDeltaCenter", _wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS, "DeltaCoefficient_GetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_EvalDelta", _wrap_DeltaCoefficient_EvalDelta, METH_VARARGS, "DeltaCoefficient_EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "DeltaCoefficient_Eval", _wrap_DeltaCoefficient_Eval, METH_VARARGS, "DeltaCoefficient_Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_GetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "DeltaCoefficient_Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeltaCoefficient", _wrap_delete_DeltaCoefficient, METH_O, "delete_DeltaCoefficient(DeltaCoefficient self)"}, { "DeltaCoefficient_swigregister", DeltaCoefficient_swigregister, METH_O, NULL}, { "DeltaCoefficient_swiginit", DeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_RestrictedCoefficient", _wrap_new_RestrictedCoefficient, METH_VARARGS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, - { "RestrictedCoefficient_Eval", _wrap_RestrictedCoefficient_Eval, METH_VARARGS, "RestrictedCoefficient_Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_RestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_RestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, + { "RestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_RestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "RestrictedCoefficient_Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_RestrictedCoefficient", _wrap_delete_RestrictedCoefficient, METH_O, "delete_RestrictedCoefficient(RestrictedCoefficient self)"}, { "RestrictedCoefficient_swigregister", RestrictedCoefficient_swigregister, METH_O, NULL}, { "RestrictedCoefficient_swiginit", RestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "VectorCoefficient_SetTime", _wrap_VectorCoefficient_SetTime, METH_VARARGS, "VectorCoefficient_SetTime(VectorCoefficient self, double t)"}, + { "VectorCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_VectorCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "VectorCoefficient_SetTime(VectorCoefficient self, double t)"}, { "VectorCoefficient_GetTime", _wrap_VectorCoefficient_GetTime, METH_O, "VectorCoefficient_GetTime(VectorCoefficient self) -> double"}, { "VectorCoefficient_GetVDim", _wrap_VectorCoefficient_GetVDim, METH_O, "VectorCoefficient_GetVDim(VectorCoefficient self) -> int"}, { "VectorCoefficient_Eval", _wrap_VectorCoefficient_Eval, METH_VARARGS, "\n" @@ -19671,7 +18739,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_VectorCoefficient", _wrap_delete_VectorCoefficient, METH_O, "delete_VectorCoefficient(VectorCoefficient self)"}, { "VectorCoefficient_swigregister", VectorCoefficient_swigregister, METH_O, NULL}, - { "new_VectorConstantCoefficient", _wrap_new_VectorConstantCoefficient, METH_O, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, + { "new_VectorConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, { "VectorConstantCoefficient_Eval", _wrap_VectorConstantCoefficient_Eval, METH_VARARGS, "\n" "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorConstantCoefficient_Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19683,7 +18751,7 @@ static PyMethodDef SwigMethods[] = { { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, { "new_VectorFunctionCoefficient", _wrap_new_VectorFunctionCoefficient, METH_VARARGS, "\n" "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::Vector &) F, Coefficient q=None)\n" - "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None)\n" + "new_VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None) -> VectorFunctionCoefficient\n" ""}, { "VectorFunctionCoefficient_Eval", _wrap_VectorFunctionCoefficient_Eval, METH_VARARGS, "\n" "VectorFunctionCoefficient_Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -19693,10 +18761,10 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFunctionCoefficient", _wrap_delete_VectorFunctionCoefficient, METH_O, "delete_VectorFunctionCoefficient(VectorFunctionCoefficient self)"}, { "VectorFunctionCoefficient_swigregister", VectorFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorFunctionCoefficient_swiginit", VectorFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorArrayCoefficient", _wrap_new_VectorArrayCoefficient, METH_O, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, - { "VectorArrayCoefficient_GetCoeff", _wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS, "VectorArrayCoefficient_GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, + { "new_VectorArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, + { "VectorArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "VectorArrayCoefficient_GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, { "VectorArrayCoefficient_GetCoeffs", _wrap_VectorArrayCoefficient_GetCoeffs, METH_O, "VectorArrayCoefficient_GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **"}, - { "VectorArrayCoefficient_Set", _wrap_VectorArrayCoefficient_Set, METH_VARARGS, "VectorArrayCoefficient_Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, + { "VectorArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "VectorArrayCoefficient_Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, { "VectorArrayCoefficient_Eval", _wrap_VectorArrayCoefficient_Eval, METH_VARARGS, "\n" "VectorArrayCoefficient_Eval(VectorArrayCoefficient self, int i, ElementTransformation T, IntegrationPoint ip) -> double\n" "VectorArrayCoefficient_Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -19710,7 +18778,7 @@ static PyMethodDef SwigMethods[] = { "VectorGridFunctionCoefficient()\n" "new_VectorGridFunctionCoefficient(mfem::GridFunction * gf) -> VectorGridFunctionCoefficient\n" ""}, - { "VectorGridFunctionCoefficient_SetGridFunction", _wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "VectorGridFunctionCoefficient_SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "VectorGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "VectorGridFunctionCoefficient_SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "VectorGridFunctionCoefficient_GetGridFunction", _wrap_VectorGridFunctionCoefficient_GetGridFunction, METH_O, "VectorGridFunctionCoefficient_GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "VectorGridFunctionCoefficient_Eval", _wrap_VectorGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "VectorGridFunctionCoefficient_Eval(VectorGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -19719,8 +18787,8 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorGridFunctionCoefficient", _wrap_delete_VectorGridFunctionCoefficient, METH_O, "delete_VectorGridFunctionCoefficient(VectorGridFunctionCoefficient self)"}, { "VectorGridFunctionCoefficient_swigregister", VectorGridFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorGridFunctionCoefficient_swiginit", VectorGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_GradientGridFunctionCoefficient", _wrap_new_GradientGridFunctionCoefficient, METH_O, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, - { "GradientGridFunctionCoefficient_SetGridFunction", _wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "GradientGridFunctionCoefficient_SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_GradientGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_GradientGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, + { "GradientGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "GradientGridFunctionCoefficient_SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GradientGridFunctionCoefficient_GetGridFunction", _wrap_GradientGridFunctionCoefficient_GetGridFunction, METH_O, "GradientGridFunctionCoefficient_GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "GradientGridFunctionCoefficient_Eval", _wrap_GradientGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "GradientGridFunctionCoefficient_Eval(GradientGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -19729,7 +18797,7 @@ static PyMethodDef SwigMethods[] = { { "delete_GradientGridFunctionCoefficient", _wrap_delete_GradientGridFunctionCoefficient, METH_O, "delete_GradientGridFunctionCoefficient(GradientGridFunctionCoefficient self)"}, { "GradientGridFunctionCoefficient_swigregister", GradientGridFunctionCoefficient_swigregister, METH_O, NULL}, { "GradientGridFunctionCoefficient_swiginit", GradientGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "CurlGridFunctionCoefficient_SetGridFunction", _wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "CurlGridFunctionCoefficient_SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "CurlGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "CurlGridFunctionCoefficient_SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "CurlGridFunctionCoefficient_GetGridFunction", _wrap_CurlGridFunctionCoefficient_GetGridFunction, METH_O, "CurlGridFunctionCoefficient_GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "CurlGridFunctionCoefficient_Eval", _wrap_CurlGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "CurlGridFunctionCoefficient_Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -19738,10 +18806,10 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_CurlGridFunctionCoefficient", _wrap_delete_CurlGridFunctionCoefficient, METH_O, "delete_CurlGridFunctionCoefficient(CurlGridFunctionCoefficient self)"}, { "CurlGridFunctionCoefficient_swigregister", CurlGridFunctionCoefficient_swigregister, METH_O, NULL}, - { "new_DivergenceGridFunctionCoefficient", _wrap_new_DivergenceGridFunctionCoefficient, METH_O, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, - { "DivergenceGridFunctionCoefficient_SetGridFunction", _wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "DivergenceGridFunctionCoefficient_SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_DivergenceGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DivergenceGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, + { "DivergenceGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "DivergenceGridFunctionCoefficient_SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "DivergenceGridFunctionCoefficient_GetGridFunction", _wrap_DivergenceGridFunctionCoefficient_GetGridFunction, METH_O, "DivergenceGridFunctionCoefficient_GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "DivergenceGridFunctionCoefficient_Eval", _wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS, "DivergenceGridFunctionCoefficient_Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DivergenceGridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "DivergenceGridFunctionCoefficient_Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DivergenceGridFunctionCoefficient", _wrap_delete_DivergenceGridFunctionCoefficient, METH_O, "delete_DivergenceGridFunctionCoefficient(DivergenceGridFunctionCoefficient self)"}, { "DivergenceGridFunctionCoefficient_swigregister", DivergenceGridFunctionCoefficient_swigregister, METH_O, NULL}, { "DivergenceGridFunctionCoefficient_swiginit", DivergenceGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19752,13 +18820,13 @@ static PyMethodDef SwigMethods[] = { "VectorDeltaCoefficient(Vector _dir, double x, double y, double s)\n" "new_VectorDeltaCoefficient(Vector _dir, double x, double y, double z, double s) -> VectorDeltaCoefficient\n" ""}, - { "VectorDeltaCoefficient_SetDeltaCoefficient", _wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS, "VectorDeltaCoefficient_SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, + { "VectorDeltaCoefficient_SetDeltaCoefficient", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, { "VectorDeltaCoefficient_GetDeltaCoefficient", _wrap_VectorDeltaCoefficient_GetDeltaCoefficient, METH_O, "VectorDeltaCoefficient_GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient"}, - { "VectorDeltaCoefficient_SetScale", _wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS, "VectorDeltaCoefficient_SetScale(VectorDeltaCoefficient self, double s)"}, - { "VectorDeltaCoefficient_SetDirection", _wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS, "VectorDeltaCoefficient_SetDirection(VectorDeltaCoefficient self, Vector _d)"}, - { "VectorDeltaCoefficient_SetDeltaCenter", _wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS, "VectorDeltaCoefficient_SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_GetDeltaCenter", _wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS, "VectorDeltaCoefficient_GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_EvalDelta", _wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS, "VectorDeltaCoefficient_EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, + { "VectorDeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetScale(VectorDeltaCoefficient self, double s)"}, + { "VectorDeltaCoefficient_SetDirection", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetDirection(VectorDeltaCoefficient self, Vector _d)"}, + { "VectorDeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "VectorDeltaCoefficient_EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, { "VectorDeltaCoefficient_Eval", _wrap_VectorDeltaCoefficient_Eval, METH_VARARGS, "\n" "VectorDeltaCoefficient_Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorDeltaCoefficient_Eval(VectorDeltaCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19767,7 +18835,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorDeltaCoefficient", _wrap_delete_VectorDeltaCoefficient, METH_O, "delete_VectorDeltaCoefficient(VectorDeltaCoefficient self)"}, { "VectorDeltaCoefficient_swigregister", VectorDeltaCoefficient_swigregister, METH_O, NULL}, { "VectorDeltaCoefficient_swiginit", VectorDeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRestrictedCoefficient", _wrap_new_VectorRestrictedCoefficient, METH_VARARGS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, + { "new_VectorRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, { "VectorRestrictedCoefficient_Eval", _wrap_VectorRestrictedCoefficient_Eval, METH_VARARGS, "\n" "VectorRestrictedCoefficient_Eval(VectorRestrictedCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorRestrictedCoefficient_Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19775,15 +18843,15 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorRestrictedCoefficient", _wrap_delete_VectorRestrictedCoefficient, METH_O, "delete_VectorRestrictedCoefficient(VectorRestrictedCoefficient self)"}, { "VectorRestrictedCoefficient_swigregister", VectorRestrictedCoefficient_swigregister, METH_O, NULL}, { "VectorRestrictedCoefficient_swiginit", VectorRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "MatrixCoefficient_SetTime", _wrap_MatrixCoefficient_SetTime, METH_VARARGS, "MatrixCoefficient_SetTime(MatrixCoefficient self, double t)"}, + { "MatrixCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "MatrixCoefficient_SetTime(MatrixCoefficient self, double t)"}, { "MatrixCoefficient_GetTime", _wrap_MatrixCoefficient_GetTime, METH_O, "MatrixCoefficient_GetTime(MatrixCoefficient self) -> double"}, { "MatrixCoefficient_GetHeight", _wrap_MatrixCoefficient_GetHeight, METH_O, "MatrixCoefficient_GetHeight(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetWidth", _wrap_MatrixCoefficient_GetWidth, METH_O, "MatrixCoefficient_GetWidth(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetVDim", _wrap_MatrixCoefficient_GetVDim, METH_O, "MatrixCoefficient_GetVDim(MatrixCoefficient self) -> int"}, - { "MatrixCoefficient_Eval", _wrap_MatrixCoefficient_Eval, METH_VARARGS, "MatrixCoefficient_Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixCoefficient_Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixCoefficient", _wrap_delete_MatrixCoefficient, METH_O, "delete_MatrixCoefficient(MatrixCoefficient self)"}, { "MatrixCoefficient_swigregister", MatrixCoefficient_swigregister, METH_O, NULL}, - { "new_MatrixConstantCoefficient", _wrap_new_MatrixConstantCoefficient, METH_O, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, + { "new_MatrixConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, { "MatrixConstantCoefficient_Eval", _wrap_MatrixConstantCoefficient_Eval, METH_VARARGS, "\n" "MatrixConstantCoefficient_Eval(MatrixConstantCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" "MatrixConstantCoefficient_Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)\n" @@ -19794,15 +18862,15 @@ static PyMethodDef SwigMethods[] = { { "new_MatrixFunctionCoefficient", _wrap_new_MatrixFunctionCoefficient, METH_VARARGS, "\n" "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::DenseMatrix &) F, Coefficient q=None)\n" "MatrixFunctionCoefficient(DenseMatrix m, Coefficient q)\n" - "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None)\n" + "new_MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None) -> MatrixFunctionCoefficient\n" ""}, - { "MatrixFunctionCoefficient_Eval", _wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS, "MatrixFunctionCoefficient_Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixFunctionCoefficient_Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixFunctionCoefficient", _wrap_delete_MatrixFunctionCoefficient, METH_O, "delete_MatrixFunctionCoefficient(MatrixFunctionCoefficient self)"}, { "MatrixFunctionCoefficient_swigregister", MatrixFunctionCoefficient_swigregister, METH_O, NULL}, { "MatrixFunctionCoefficient_swiginit", MatrixFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixArrayCoefficient", _wrap_new_MatrixArrayCoefficient, METH_O, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, - { "MatrixArrayCoefficient_GetCoeff", _wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS, "MatrixArrayCoefficient_GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, - { "MatrixArrayCoefficient_Set", _wrap_MatrixArrayCoefficient_Set, METH_VARARGS, "MatrixArrayCoefficient_Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, + { "new_MatrixArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, + { "MatrixArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "MatrixArrayCoefficient_GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, + { "MatrixArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "MatrixArrayCoefficient_Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, { "MatrixArrayCoefficient_Eval", _wrap_MatrixArrayCoefficient_Eval, METH_VARARGS, "\n" "MatrixArrayCoefficient_Eval(MatrixArrayCoefficient self, int i, int j, ElementTransformation T, IntegrationPoint ip) -> double\n" "MatrixArrayCoefficient_Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" @@ -19810,42 +18878,42 @@ static PyMethodDef SwigMethods[] = { { "delete_MatrixArrayCoefficient", _wrap_delete_MatrixArrayCoefficient, METH_O, "delete_MatrixArrayCoefficient(MatrixArrayCoefficient self)"}, { "MatrixArrayCoefficient_swigregister", MatrixArrayCoefficient_swigregister, METH_O, NULL}, { "MatrixArrayCoefficient_swiginit", MatrixArrayCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixRestrictedCoefficient", _wrap_new_MatrixRestrictedCoefficient, METH_VARARGS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, - { "MatrixRestrictedCoefficient_Eval", _wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS, "MatrixRestrictedCoefficient_Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, + { "MatrixRestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixRestrictedCoefficient_Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixRestrictedCoefficient", _wrap_delete_MatrixRestrictedCoefficient, METH_O, "delete_MatrixRestrictedCoefficient(MatrixRestrictedCoefficient self)"}, { "MatrixRestrictedCoefficient_swigregister", MatrixRestrictedCoefficient_swigregister, METH_O, NULL}, { "MatrixRestrictedCoefficient_swiginit", MatrixRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_SumCoefficient", _wrap_new_SumCoefficient, METH_VARARGS, "SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "SumCoefficient_Eval", _wrap_SumCoefficient_Eval, METH_VARARGS, "SumCoefficient_Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_SumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_SumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0) -> SumCoefficient"}, + { "SumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_SumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "SumCoefficient_Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_SumCoefficient", _wrap_delete_SumCoefficient, METH_O, "delete_SumCoefficient(SumCoefficient self)"}, { "SumCoefficient_swigregister", SumCoefficient_swigregister, METH_O, NULL}, { "SumCoefficient_swiginit", SumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ProductCoefficient", _wrap_new_ProductCoefficient, METH_VARARGS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, - { "ProductCoefficient_Eval", _wrap_ProductCoefficient_Eval, METH_VARARGS, "ProductCoefficient_Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, + { "ProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ProductCoefficient_Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ProductCoefficient", _wrap_delete_ProductCoefficient, METH_O, "delete_ProductCoefficient(ProductCoefficient self)"}, { "ProductCoefficient_swigregister", ProductCoefficient_swigregister, METH_O, NULL}, { "ProductCoefficient_swiginit", ProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_PowerCoefficient", _wrap_new_PowerCoefficient, METH_VARARGS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, - { "PowerCoefficient_Eval", _wrap_PowerCoefficient_Eval, METH_VARARGS, "PowerCoefficient_Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_PowerCoefficient", (PyCFunction)(void(*)(void))_wrap_new_PowerCoefficient, METH_VARARGS|METH_KEYWORDS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, + { "PowerCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PowerCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "PowerCoefficient_Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PowerCoefficient", _wrap_delete_PowerCoefficient, METH_O, "delete_PowerCoefficient(PowerCoefficient self)"}, { "PowerCoefficient_swigregister", PowerCoefficient_swigregister, METH_O, NULL}, { "PowerCoefficient_swiginit", PowerCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InnerProductCoefficient", _wrap_new_InnerProductCoefficient, METH_VARARGS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, - { "InnerProductCoefficient_Eval", _wrap_InnerProductCoefficient_Eval, METH_VARARGS, "InnerProductCoefficient_Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_InnerProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InnerProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, + { "InnerProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InnerProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "InnerProductCoefficient_Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_InnerProductCoefficient", _wrap_delete_InnerProductCoefficient, METH_O, "delete_InnerProductCoefficient(InnerProductCoefficient self)"}, { "InnerProductCoefficient_swigregister", InnerProductCoefficient_swigregister, METH_O, NULL}, { "InnerProductCoefficient_swiginit", InnerProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRotProductCoefficient", _wrap_new_VectorRotProductCoefficient, METH_VARARGS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, - { "VectorRotProductCoefficient_Eval", _wrap_VectorRotProductCoefficient_Eval, METH_VARARGS, "VectorRotProductCoefficient_Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_VectorRotProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRotProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, + { "VectorRotProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_VectorRotProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "VectorRotProductCoefficient_Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_VectorRotProductCoefficient", _wrap_delete_VectorRotProductCoefficient, METH_O, "delete_VectorRotProductCoefficient(VectorRotProductCoefficient self)"}, { "VectorRotProductCoefficient_swigregister", VectorRotProductCoefficient_swigregister, METH_O, NULL}, { "VectorRotProductCoefficient_swiginit", VectorRotProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_DeterminantCoefficient", _wrap_new_DeterminantCoefficient, METH_O, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, - { "DeterminantCoefficient_Eval", _wrap_DeterminantCoefficient_Eval, METH_VARARGS, "DeterminantCoefficient_Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_DeterminantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DeterminantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, + { "DeterminantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeterminantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "DeterminantCoefficient_Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeterminantCoefficient", _wrap_delete_DeterminantCoefficient, METH_O, "delete_DeterminantCoefficient(DeterminantCoefficient self)"}, { "DeterminantCoefficient_swigregister", DeterminantCoefficient_swigregister, METH_O, NULL}, { "DeterminantCoefficient_swiginit", DeterminantCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorSumCoefficient", _wrap_new_VectorSumCoefficient, METH_VARARGS, "VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "new_VectorSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0) -> VectorSumCoefficient"}, { "VectorSumCoefficient_Eval", _wrap_VectorSumCoefficient_Eval, METH_VARARGS, "\n" "VectorSumCoefficient_Eval(VectorSumCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorSumCoefficient_Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19853,7 +18921,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorSumCoefficient", _wrap_delete_VectorSumCoefficient, METH_O, "delete_VectorSumCoefficient(VectorSumCoefficient self)"}, { "VectorSumCoefficient_swigregister", VectorSumCoefficient_swigregister, METH_O, NULL}, { "VectorSumCoefficient_swiginit", VectorSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductCoefficient", _wrap_new_ScalarVectorProductCoefficient, METH_VARARGS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, + { "new_ScalarVectorProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, { "ScalarVectorProductCoefficient_Eval", _wrap_ScalarVectorProductCoefficient_Eval, METH_VARARGS, "\n" "ScalarVectorProductCoefficient_Eval(ScalarVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "ScalarVectorProductCoefficient_Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19861,7 +18929,7 @@ static PyMethodDef SwigMethods[] = { { "delete_ScalarVectorProductCoefficient", _wrap_delete_ScalarVectorProductCoefficient, METH_O, "delete_ScalarVectorProductCoefficient(ScalarVectorProductCoefficient self)"}, { "ScalarVectorProductCoefficient_swigregister", ScalarVectorProductCoefficient_swigregister, METH_O, NULL}, { "ScalarVectorProductCoefficient_swiginit", ScalarVectorProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductCoefficient", _wrap_new_VectorCrossProductCoefficient, METH_VARARGS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, + { "new_VectorCrossProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, { "VectorCrossProductCoefficient_Eval", _wrap_VectorCrossProductCoefficient_Eval, METH_VARARGS, "\n" "VectorCrossProductCoefficient_Eval(VectorCrossProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "VectorCrossProductCoefficient_Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19869,7 +18937,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorCrossProductCoefficient", _wrap_delete_VectorCrossProductCoefficient, METH_O, "delete_VectorCrossProductCoefficient(VectorCrossProductCoefficient self)"}, { "VectorCrossProductCoefficient_swigregister", VectorCrossProductCoefficient_swigregister, METH_O, NULL}, { "VectorCrossProductCoefficient_swiginit", VectorCrossProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatVecCoefficient", _wrap_new_MatVecCoefficient, METH_VARARGS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, + { "new_MatVecCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatVecCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, { "MatVecCoefficient_Eval", _wrap_MatVecCoefficient_Eval, METH_VARARGS, "\n" "MatVecCoefficient_Eval(MatVecCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "MatVecCoefficient_Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -19877,33 +18945,33 @@ static PyMethodDef SwigMethods[] = { { "delete_MatVecCoefficient", _wrap_delete_MatVecCoefficient, METH_O, "delete_MatVecCoefficient(MatVecCoefficient self)"}, { "MatVecCoefficient_swigregister", MatVecCoefficient_swigregister, METH_O, NULL}, { "MatVecCoefficient_swiginit", MatVecCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_IdentityMatrixCoefficient", _wrap_new_IdentityMatrixCoefficient, METH_O, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, - { "IdentityMatrixCoefficient_Eval", _wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS, "IdentityMatrixCoefficient_Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_IdentityMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_IdentityMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, + { "IdentityMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "IdentityMatrixCoefficient_Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_IdentityMatrixCoefficient", _wrap_delete_IdentityMatrixCoefficient, METH_O, "delete_IdentityMatrixCoefficient(IdentityMatrixCoefficient self)"}, { "IdentityMatrixCoefficient_swigregister", IdentityMatrixCoefficient_swigregister, METH_O, NULL}, { "IdentityMatrixCoefficient_swiginit", IdentityMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixSumCoefficient", _wrap_new_MatrixSumCoefficient, METH_VARARGS, "MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "MatrixSumCoefficient_Eval", _wrap_MatrixSumCoefficient_Eval, METH_VARARGS, "MatrixSumCoefficient_Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0) -> MatrixSumCoefficient"}, + { "MatrixSumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixSumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixSumCoefficient_Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixSumCoefficient", _wrap_delete_MatrixSumCoefficient, METH_O, "delete_MatrixSumCoefficient(MatrixSumCoefficient self)"}, { "MatrixSumCoefficient_swigregister", MatrixSumCoefficient_swigregister, METH_O, NULL}, { "MatrixSumCoefficient_swiginit", MatrixSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarMatrixProductCoefficient", _wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, - { "ScalarMatrixProductCoefficient_Eval", _wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS, "ScalarMatrixProductCoefficient_Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_ScalarMatrixProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, + { "ScalarMatrixProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ScalarMatrixProductCoefficient_Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_ScalarMatrixProductCoefficient", _wrap_delete_ScalarMatrixProductCoefficient, METH_O, "delete_ScalarMatrixProductCoefficient(ScalarMatrixProductCoefficient self)"}, { "ScalarMatrixProductCoefficient_swigregister", ScalarMatrixProductCoefficient_swigregister, METH_O, NULL}, { "ScalarMatrixProductCoefficient_swiginit", ScalarMatrixProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_TransposeMatrixCoefficient", _wrap_new_TransposeMatrixCoefficient, METH_O, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, - { "TransposeMatrixCoefficient_Eval", _wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS, "TransposeMatrixCoefficient_Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_TransposeMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_TransposeMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, + { "TransposeMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "TransposeMatrixCoefficient_Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_TransposeMatrixCoefficient", _wrap_delete_TransposeMatrixCoefficient, METH_O, "delete_TransposeMatrixCoefficient(TransposeMatrixCoefficient self)"}, { "TransposeMatrixCoefficient_swigregister", TransposeMatrixCoefficient_swigregister, METH_O, NULL}, { "TransposeMatrixCoefficient_swiginit", TransposeMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InverseMatrixCoefficient", _wrap_new_InverseMatrixCoefficient, METH_O, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, - { "InverseMatrixCoefficient_Eval", _wrap_InverseMatrixCoefficient_Eval, METH_VARARGS, "InverseMatrixCoefficient_Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_InverseMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InverseMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, + { "InverseMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InverseMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "InverseMatrixCoefficient_Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_InverseMatrixCoefficient", _wrap_delete_InverseMatrixCoefficient, METH_O, "delete_InverseMatrixCoefficient(InverseMatrixCoefficient self)"}, { "InverseMatrixCoefficient_swigregister", InverseMatrixCoefficient_swigregister, METH_O, NULL}, { "InverseMatrixCoefficient_swiginit", InverseMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_OuterProductCoefficient", _wrap_new_OuterProductCoefficient, METH_VARARGS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, - { "OuterProductCoefficient_Eval", _wrap_OuterProductCoefficient_Eval, METH_VARARGS, "OuterProductCoefficient_Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_OuterProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_OuterProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, + { "OuterProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_OuterProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "OuterProductCoefficient_Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_OuterProductCoefficient", _wrap_delete_OuterProductCoefficient, METH_O, "delete_OuterProductCoefficient(OuterProductCoefficient self)"}, { "OuterProductCoefficient_swigregister", OuterProductCoefficient_swigregister, METH_O, NULL}, { "OuterProductCoefficient_swiginit", OuterProductCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19911,34 +18979,34 @@ static PyMethodDef SwigMethods[] = { "ComputeLpNorm(double p, Coefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" "ComputeLpNorm(double p, VectorCoefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" ""}, - { "fake_func", _wrap_fake_func, METH_O, "fake_func(Vector x) -> double"}, - { "fake_func_vec", _wrap_fake_func_vec, METH_VARARGS, "fake_func_vec(Vector x, Vector Ht)"}, - { "fake_func_mat", _wrap_fake_func_mat, METH_VARARGS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, - { "new_PyCoefficientBase", _wrap_new_PyCoefficientBase, METH_VARARGS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, - { "PyCoefficientBase_Eval", _wrap_PyCoefficientBase_Eval, METH_VARARGS, "PyCoefficientBase_Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "PyCoefficientBase__EvalPy", _wrap_PyCoefficientBase__EvalPy, METH_VARARGS, "PyCoefficientBase__EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, - { "PyCoefficientBase__EvalPyT", _wrap_PyCoefficientBase__EvalPyT, METH_VARARGS, "PyCoefficientBase__EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, + { "fake_func", (PyCFunction)(void(*)(void))_wrap_fake_func, METH_VARARGS|METH_KEYWORDS, "fake_func(Vector x) -> double"}, + { "fake_func_vec", (PyCFunction)(void(*)(void))_wrap_fake_func_vec, METH_VARARGS|METH_KEYWORDS, "fake_func_vec(Vector x, Vector Ht)"}, + { "fake_func_mat", (PyCFunction)(void(*)(void))_wrap_fake_func_mat, METH_VARARGS|METH_KEYWORDS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, + { "new_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, + { "PyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "PyCoefficientBase_Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "PyCoefficientBase__EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, + { "PyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "PyCoefficientBase__EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, { "delete_PyCoefficientBase", _wrap_delete_PyCoefficientBase, METH_O, "delete_PyCoefficientBase(PyCoefficientBase self)"}, - { "disown_PyCoefficientBase", _wrap_disown_PyCoefficientBase, METH_O, NULL}, + { "disown_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyCoefficientBase_swigregister", PyCoefficientBase_swigregister, METH_O, NULL}, { "PyCoefficientBase_swiginit", PyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_VectorPyCoefficientBase", _wrap_new_VectorPyCoefficientBase, METH_VARARGS, "VectorPyCoefficientBase(int dim, int tdep, Coefficient q=None)"}, + { "new_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_VectorPyCoefficientBase(PyObject * _self, int dim, int tdep, Coefficient q=None) -> VectorPyCoefficientBase"}, { "VectorPyCoefficientBase_Eval", _wrap_VectorPyCoefficientBase_Eval, METH_VARARGS, "\n" "VectorPyCoefficientBase_Eval(VectorPyCoefficientBase self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" "VectorPyCoefficientBase_Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" ""}, - { "VectorPyCoefficientBase__EvalPy", _wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS, "VectorPyCoefficientBase__EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, - { "VectorPyCoefficientBase__EvalPyT", _wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS, "VectorPyCoefficientBase__EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, + { "VectorPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "VectorPyCoefficientBase__EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, + { "VectorPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "VectorPyCoefficientBase__EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, { "delete_VectorPyCoefficientBase", _wrap_delete_VectorPyCoefficientBase, METH_O, "delete_VectorPyCoefficientBase(VectorPyCoefficientBase self)"}, - { "disown_VectorPyCoefficientBase", _wrap_disown_VectorPyCoefficientBase, METH_O, NULL}, + { "disown_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "VectorPyCoefficientBase_swigregister", VectorPyCoefficientBase_swigregister, METH_O, NULL}, { "VectorPyCoefficientBase_swiginit", VectorPyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_MatrixPyCoefficientBase", _wrap_new_MatrixPyCoefficientBase, METH_VARARGS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, - { "MatrixPyCoefficientBase_Eval", _wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS, "MatrixPyCoefficientBase_Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, - { "MatrixPyCoefficientBase__EvalPy", _wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS, "MatrixPyCoefficientBase__EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, - { "MatrixPyCoefficientBase__EvalPyT", _wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS, "MatrixPyCoefficientBase__EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, + { "new_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, + { "MatrixPyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "MatrixPyCoefficientBase_Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "MatrixPyCoefficientBase__EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, + { "MatrixPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "MatrixPyCoefficientBase__EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, { "delete_MatrixPyCoefficientBase", _wrap_delete_MatrixPyCoefficientBase, METH_O, "delete_MatrixPyCoefficientBase(MatrixPyCoefficientBase self)"}, - { "disown_MatrixPyCoefficientBase", _wrap_disown_MatrixPyCoefficientBase, METH_O, NULL}, + { "disown_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "MatrixPyCoefficientBase_swigregister", MatrixPyCoefficientBase_swigregister, METH_O, NULL}, { "MatrixPyCoefficientBase_swiginit", MatrixPyCoefficientBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -19947,7 +19015,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Coefficient_SetTime", _wrap_Coefficient_SetTime, METH_VARARGS, "SetTime(Coefficient self, double t)"}, + { "Coefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_Coefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(Coefficient self, double t)"}, { "Coefficient_GetTime", _wrap_Coefficient_GetTime, METH_O, "GetTime(Coefficient self) -> double"}, { "Coefficient_Eval", _wrap_Coefficient_Eval, METH_VARARGS, "\n" "Eval(Coefficient self, ElementTransformation T, IntegrationPoint ip) -> double\n" @@ -19957,8 +19025,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Coefficient_swigregister", Coefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_constant_set", _wrap_ConstantCoefficient_constant_set, METH_VARARGS, "ConstantCoefficient_constant_set(ConstantCoefficient self, double constant)"}, { "ConstantCoefficient_constant_get", _wrap_ConstantCoefficient_constant_get, METH_O, "ConstantCoefficient_constant_get(ConstantCoefficient self) -> double"}, - { "new_ConstantCoefficient", _wrap_new_ConstantCoefficient, METH_VARARGS, "ConstantCoefficient(double c=1.0)"}, - { "ConstantCoefficient_Eval", _wrap_ConstantCoefficient_Eval, METH_VARARGS, "Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ConstantCoefficient(double c=1.0) -> ConstantCoefficient"}, + { "ConstantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ConstantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ConstantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ConstantCoefficient", _wrap_delete_ConstantCoefficient, METH_O, "delete_ConstantCoefficient(ConstantCoefficient self)"}, { "ConstantCoefficient_swigregister", ConstantCoefficient_swigregister, METH_O, NULL}, { "ConstantCoefficient_swiginit", ConstantCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19966,10 +19034,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "PWConstCoefficient(int NumOfSubD=0)\n" "new_PWConstCoefficient(Vector c) -> PWConstCoefficient\n" ""}, - { "PWConstCoefficient_UpdateConstants", _wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS, "UpdateConstants(PWConstCoefficient self, Vector c)"}, - { "PWConstCoefficient___call__", _wrap_PWConstCoefficient___call__, METH_VARARGS, "__call__(PWConstCoefficient self, int i) -> double &"}, + { "PWConstCoefficient_UpdateConstants", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_UpdateConstants, METH_VARARGS|METH_KEYWORDS, "UpdateConstants(PWConstCoefficient self, Vector c)"}, + { "PWConstCoefficient___call__", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient___call__, METH_VARARGS|METH_KEYWORDS, "__call__(PWConstCoefficient self, int i) -> double &"}, { "PWConstCoefficient_GetNConst", _wrap_PWConstCoefficient_GetNConst, METH_O, "GetNConst(PWConstCoefficient self) -> int"}, - { "PWConstCoefficient_Eval", _wrap_PWConstCoefficient_Eval, METH_VARARGS, "Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PWConstCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PWConstCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(PWConstCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PWConstCoefficient", _wrap_delete_PWConstCoefficient, METH_O, "delete_PWConstCoefficient(PWConstCoefficient self)"}, { "PWConstCoefficient_swigregister", PWConstCoefficient_swigregister, METH_O, NULL}, { "PWConstCoefficient_swiginit", PWConstCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19979,17 +19047,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FunctionCoefficient(double (*)(mfem::Vector &) f)\n" "new_FunctionCoefficient(double (*)(mfem::Vector &,double) tdf) -> FunctionCoefficient\n" ""}, - { "FunctionCoefficient_Eval", _wrap_FunctionCoefficient_Eval, METH_VARARGS, "Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "FunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_FunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(FunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_FunctionCoefficient", _wrap_delete_FunctionCoefficient, METH_O, "delete_FunctionCoefficient(FunctionCoefficient self)"}, { "FunctionCoefficient_swigregister", FunctionCoefficient_swigregister, METH_O, NULL}, { "FunctionCoefficient_swiginit", FunctionCoefficient_swiginit, METH_VARARGS, NULL}, { "new_GridFunctionCoefficient", _wrap_new_GridFunctionCoefficient, METH_VARARGS, "\n" "GridFunctionCoefficient()\n" - "GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1)\n" + "new_GridFunctionCoefficient(mfem::GridFunction * gf, int comp=1) -> GridFunctionCoefficient\n" ""}, - { "GridFunctionCoefficient_SetGridFunction", _wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "GridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(GridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GridFunctionCoefficient_GetGridFunction", _wrap_GridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "GridFunctionCoefficient_Eval", _wrap_GridFunctionCoefficient_Eval, METH_VARARGS, "Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "GridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_GridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(GridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_GridFunctionCoefficient", _wrap_delete_GridFunctionCoefficient, METH_O, "delete_GridFunctionCoefficient(GridFunctionCoefficient self)"}, { "GridFunctionCoefficient_swigregister", GridFunctionCoefficient_swigregister, METH_O, NULL}, { "GridFunctionCoefficient_swiginit", GridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -19997,7 +19065,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "TransformedCoefficient(Coefficient q, double (*)(double) F)\n" "new_TransformedCoefficient(Coefficient q1, Coefficient q2, double (*)(double,double) F) -> TransformedCoefficient\n" ""}, - { "TransformedCoefficient_Eval", _wrap_TransformedCoefficient_Eval, METH_VARARGS, "Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "TransformedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransformedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(TransformedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_TransformedCoefficient", _wrap_delete_TransformedCoefficient, METH_O, "delete_TransformedCoefficient(TransformedCoefficient self)"}, { "TransformedCoefficient_swigregister", TransformedCoefficient_swigregister, METH_O, NULL}, { "TransformedCoefficient_swiginit", TransformedCoefficient_swiginit, METH_VARARGS, NULL}, @@ -20007,27 +19075,27 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DeltaCoefficient(double x, double y, double s)\n" "new_DeltaCoefficient(double x, double y, double z, double s) -> DeltaCoefficient\n" ""}, - { "DeltaCoefficient_SetDeltaCenter", _wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_SetScale", _wrap_DeltaCoefficient_SetScale, METH_VARARGS, "SetScale(DeltaCoefficient self, double _s)"}, - { "DeltaCoefficient_SetFunction", _wrap_DeltaCoefficient_SetFunction, METH_VARARGS, "SetFunction(DeltaCoefficient self, double (*)(double) f)"}, - { "DeltaCoefficient_SetTol", _wrap_DeltaCoefficient_SetTol, METH_VARARGS, "SetTol(DeltaCoefficient self, double _tol)"}, - { "DeltaCoefficient_SetWeight", _wrap_DeltaCoefficient_SetWeight, METH_VARARGS, "SetWeight(DeltaCoefficient self, Coefficient w)"}, + { "DeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "SetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "SetScale(DeltaCoefficient self, double _s)"}, + { "DeltaCoefficient_SetFunction", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetFunction, METH_VARARGS|METH_KEYWORDS, "SetFunction(DeltaCoefficient self, double (*)(double) f)"}, + { "DeltaCoefficient_SetTol", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetTol, METH_VARARGS|METH_KEYWORDS, "SetTol(DeltaCoefficient self, double _tol)"}, + { "DeltaCoefficient_SetWeight", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_SetWeight, METH_VARARGS|METH_KEYWORDS, "SetWeight(DeltaCoefficient self, Coefficient w)"}, { "DeltaCoefficient_Center", _wrap_DeltaCoefficient_Center, METH_O, "Center(DeltaCoefficient self) -> double const *"}, { "DeltaCoefficient_Scale", _wrap_DeltaCoefficient_Scale, METH_O, "Scale(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Tol", _wrap_DeltaCoefficient_Tol, METH_O, "Tol(DeltaCoefficient self) -> double"}, { "DeltaCoefficient_Weight", _wrap_DeltaCoefficient_Weight, METH_O, "Weight(DeltaCoefficient self) -> Coefficient"}, - { "DeltaCoefficient_GetDeltaCenter", _wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaCoefficient self, Vector center)"}, - { "DeltaCoefficient_EvalDelta", _wrap_DeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "DeltaCoefficient_Eval", _wrap_DeltaCoefficient_Eval, METH_VARARGS, "Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "GetDeltaCenter(DeltaCoefficient self, Vector center)"}, + { "DeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "EvalDelta(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DeltaCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeltaCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DeltaCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeltaCoefficient", _wrap_delete_DeltaCoefficient, METH_O, "delete_DeltaCoefficient(DeltaCoefficient self)"}, { "DeltaCoefficient_swigregister", DeltaCoefficient_swigregister, METH_O, NULL}, { "DeltaCoefficient_swiginit", DeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_RestrictedCoefficient", _wrap_new_RestrictedCoefficient, METH_VARARGS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, - { "RestrictedCoefficient_Eval", _wrap_RestrictedCoefficient_Eval, METH_VARARGS, "Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_RestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_RestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_RestrictedCoefficient(Coefficient _c, intArray attr) -> RestrictedCoefficient"}, + { "RestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_RestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(RestrictedCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_RestrictedCoefficient", _wrap_delete_RestrictedCoefficient, METH_O, "delete_RestrictedCoefficient(RestrictedCoefficient self)"}, { "RestrictedCoefficient_swigregister", RestrictedCoefficient_swigregister, METH_O, NULL}, { "RestrictedCoefficient_swiginit", RestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "VectorCoefficient_SetTime", _wrap_VectorCoefficient_SetTime, METH_VARARGS, "SetTime(VectorCoefficient self, double t)"}, + { "VectorCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_VectorCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(VectorCoefficient self, double t)"}, { "VectorCoefficient_GetTime", _wrap_VectorCoefficient_GetTime, METH_O, "GetTime(VectorCoefficient self) -> double"}, { "VectorCoefficient_GetVDim", _wrap_VectorCoefficient_GetVDim, METH_O, "GetVDim(VectorCoefficient self) -> int"}, { "VectorCoefficient_Eval", _wrap_VectorCoefficient_Eval, METH_VARARGS, "\n" @@ -20036,7 +19104,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_VectorCoefficient", _wrap_delete_VectorCoefficient, METH_O, "delete_VectorCoefficient(VectorCoefficient self)"}, { "VectorCoefficient_swigregister", VectorCoefficient_swigregister, METH_O, NULL}, - { "new_VectorConstantCoefficient", _wrap_new_VectorConstantCoefficient, METH_O, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, + { "new_VectorConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorConstantCoefficient(Vector v) -> VectorConstantCoefficient"}, { "VectorConstantCoefficient_Eval", _wrap_VectorConstantCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorConstantCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -20048,7 +19116,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "VectorConstantCoefficient_swiginit", VectorConstantCoefficient_swiginit, METH_VARARGS, NULL}, { "new_VectorFunctionCoefficient", _wrap_new_VectorFunctionCoefficient, METH_VARARGS, "\n" "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::Vector &) F, Coefficient q=None)\n" - "VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None)\n" + "new_VectorFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::Vector &) TDF, Coefficient q=None) -> VectorFunctionCoefficient\n" ""}, { "VectorFunctionCoefficient_Eval", _wrap_VectorFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -20058,10 +19126,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFunctionCoefficient", _wrap_delete_VectorFunctionCoefficient, METH_O, "delete_VectorFunctionCoefficient(VectorFunctionCoefficient self)"}, { "VectorFunctionCoefficient_swigregister", VectorFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorFunctionCoefficient_swiginit", VectorFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorArrayCoefficient", _wrap_new_VectorArrayCoefficient, METH_O, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, - { "VectorArrayCoefficient_GetCoeff", _wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, + { "new_VectorArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorArrayCoefficient(int dim) -> VectorArrayCoefficient"}, + { "VectorArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "GetCoeff(VectorArrayCoefficient self, int i) -> Coefficient"}, { "VectorArrayCoefficient_GetCoeffs", _wrap_VectorArrayCoefficient_GetCoeffs, METH_O, "GetCoeffs(VectorArrayCoefficient self) -> mfem::Coefficient **"}, - { "VectorArrayCoefficient_Set", _wrap_VectorArrayCoefficient_Set, METH_VARARGS, "Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, + { "VectorArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_VectorArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "Set(VectorArrayCoefficient self, int i, Coefficient c, bool own=True)"}, { "VectorArrayCoefficient_Eval", _wrap_VectorArrayCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorArrayCoefficient self, int i, ElementTransformation T, IntegrationPoint ip) -> double\n" "Eval(VectorArrayCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -20075,7 +19143,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorGridFunctionCoefficient()\n" "new_VectorGridFunctionCoefficient(mfem::GridFunction * gf) -> VectorGridFunctionCoefficient\n" ""}, - { "VectorGridFunctionCoefficient_SetGridFunction", _wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "VectorGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_VectorGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(VectorGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "VectorGridFunctionCoefficient_GetGridFunction", _wrap_VectorGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(VectorGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "VectorGridFunctionCoefficient_Eval", _wrap_VectorGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -20084,8 +19152,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorGridFunctionCoefficient", _wrap_delete_VectorGridFunctionCoefficient, METH_O, "delete_VectorGridFunctionCoefficient(VectorGridFunctionCoefficient self)"}, { "VectorGridFunctionCoefficient_swigregister", VectorGridFunctionCoefficient_swigregister, METH_O, NULL}, { "VectorGridFunctionCoefficient_swiginit", VectorGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_GradientGridFunctionCoefficient", _wrap_new_GradientGridFunctionCoefficient, METH_O, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, - { "GradientGridFunctionCoefficient_SetGridFunction", _wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_GradientGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_GradientGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_GradientGridFunctionCoefficient(mfem::GridFunction * gf) -> GradientGridFunctionCoefficient"}, + { "GradientGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_GradientGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(GradientGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "GradientGridFunctionCoefficient_GetGridFunction", _wrap_GradientGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(GradientGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "GradientGridFunctionCoefficient_Eval", _wrap_GradientGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(GradientGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -20094,7 +19162,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_GradientGridFunctionCoefficient", _wrap_delete_GradientGridFunctionCoefficient, METH_O, "delete_GradientGridFunctionCoefficient(GradientGridFunctionCoefficient self)"}, { "GradientGridFunctionCoefficient_swigregister", GradientGridFunctionCoefficient_swigregister, METH_O, NULL}, { "GradientGridFunctionCoefficient_swiginit", GradientGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "CurlGridFunctionCoefficient_SetGridFunction", _wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "CurlGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_CurlGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(CurlGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "CurlGridFunctionCoefficient_GetGridFunction", _wrap_CurlGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(CurlGridFunctionCoefficient self) -> mfem::GridFunction *"}, { "CurlGridFunctionCoefficient_Eval", _wrap_CurlGridFunctionCoefficient_Eval, METH_VARARGS, "\n" "Eval(CurlGridFunctionCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" @@ -20103,10 +19171,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_CurlGridFunctionCoefficient", _wrap_delete_CurlGridFunctionCoefficient, METH_O, "delete_CurlGridFunctionCoefficient(CurlGridFunctionCoefficient self)"}, { "CurlGridFunctionCoefficient_swigregister", CurlGridFunctionCoefficient_swigregister, METH_O, NULL}, - { "new_DivergenceGridFunctionCoefficient", _wrap_new_DivergenceGridFunctionCoefficient, METH_O, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, - { "DivergenceGridFunctionCoefficient_SetGridFunction", _wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS, "SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, + { "new_DivergenceGridFunctionCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DivergenceGridFunctionCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DivergenceGridFunctionCoefficient(mfem::GridFunction * gf) -> DivergenceGridFunctionCoefficient"}, + { "DivergenceGridFunctionCoefficient_SetGridFunction", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_SetGridFunction, METH_VARARGS|METH_KEYWORDS, "SetGridFunction(DivergenceGridFunctionCoefficient self, mfem::GridFunction * gf)"}, { "DivergenceGridFunctionCoefficient_GetGridFunction", _wrap_DivergenceGridFunctionCoefficient_GetGridFunction, METH_O, "GetGridFunction(DivergenceGridFunctionCoefficient self) -> mfem::GridFunction *"}, - { "DivergenceGridFunctionCoefficient_Eval", _wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS, "Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "DivergenceGridFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DivergenceGridFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DivergenceGridFunctionCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DivergenceGridFunctionCoefficient", _wrap_delete_DivergenceGridFunctionCoefficient, METH_O, "delete_DivergenceGridFunctionCoefficient(DivergenceGridFunctionCoefficient self)"}, { "DivergenceGridFunctionCoefficient_swigregister", DivergenceGridFunctionCoefficient_swigregister, METH_O, NULL}, { "DivergenceGridFunctionCoefficient_swiginit", DivergenceGridFunctionCoefficient_swiginit, METH_VARARGS, NULL}, @@ -20117,13 +19185,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorDeltaCoefficient(Vector _dir, double x, double y, double s)\n" "new_VectorDeltaCoefficient(Vector _dir, double x, double y, double z, double s) -> VectorDeltaCoefficient\n" ""}, - { "VectorDeltaCoefficient_SetDeltaCoefficient", _wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS, "SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, + { "VectorDeltaCoefficient_SetDeltaCoefficient", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCoefficient, METH_VARARGS|METH_KEYWORDS, "SetDeltaCoefficient(VectorDeltaCoefficient self, DeltaCoefficient _d)"}, { "VectorDeltaCoefficient_GetDeltaCoefficient", _wrap_VectorDeltaCoefficient_GetDeltaCoefficient, METH_O, "GetDeltaCoefficient(VectorDeltaCoefficient self) -> DeltaCoefficient"}, - { "VectorDeltaCoefficient_SetScale", _wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS, "SetScale(VectorDeltaCoefficient self, double s)"}, - { "VectorDeltaCoefficient_SetDirection", _wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS, "SetDirection(VectorDeltaCoefficient self, Vector _d)"}, - { "VectorDeltaCoefficient_SetDeltaCenter", _wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS, "SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_GetDeltaCenter", _wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, - { "VectorDeltaCoefficient_EvalDelta", _wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS, "EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, + { "VectorDeltaCoefficient_SetScale", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetScale, METH_VARARGS|METH_KEYWORDS, "SetScale(VectorDeltaCoefficient self, double s)"}, + { "VectorDeltaCoefficient_SetDirection", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDirection, METH_VARARGS|METH_KEYWORDS, "SetDirection(VectorDeltaCoefficient self, Vector _d)"}, + { "VectorDeltaCoefficient_SetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_SetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "SetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "GetDeltaCenter(VectorDeltaCoefficient self, Vector center)"}, + { "VectorDeltaCoefficient_EvalDelta", (PyCFunction)(void(*)(void))_wrap_VectorDeltaCoefficient_EvalDelta, METH_VARARGS|METH_KEYWORDS, "EvalDelta(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)"}, { "VectorDeltaCoefficient_Eval", _wrap_VectorDeltaCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorDeltaCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorDeltaCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -20132,7 +19200,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorDeltaCoefficient", _wrap_delete_VectorDeltaCoefficient, METH_O, "delete_VectorDeltaCoefficient(VectorDeltaCoefficient self)"}, { "VectorDeltaCoefficient_swigregister", VectorDeltaCoefficient_swigregister, METH_O, NULL}, { "VectorDeltaCoefficient_swiginit", VectorDeltaCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRestrictedCoefficient", _wrap_new_VectorRestrictedCoefficient, METH_VARARGS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, + { "new_VectorRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRestrictedCoefficient(VectorCoefficient vc, intArray attr) -> VectorRestrictedCoefficient"}, { "VectorRestrictedCoefficient_Eval", _wrap_VectorRestrictedCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorRestrictedCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorRestrictedCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -20140,15 +19208,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorRestrictedCoefficient", _wrap_delete_VectorRestrictedCoefficient, METH_O, "delete_VectorRestrictedCoefficient(VectorRestrictedCoefficient self)"}, { "VectorRestrictedCoefficient_swigregister", VectorRestrictedCoefficient_swigregister, METH_O, NULL}, { "VectorRestrictedCoefficient_swiginit", VectorRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "MatrixCoefficient_SetTime", _wrap_MatrixCoefficient_SetTime, METH_VARARGS, "SetTime(MatrixCoefficient self, double t)"}, + { "MatrixCoefficient_SetTime", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(MatrixCoefficient self, double t)"}, { "MatrixCoefficient_GetTime", _wrap_MatrixCoefficient_GetTime, METH_O, "GetTime(MatrixCoefficient self) -> double"}, { "MatrixCoefficient_GetHeight", _wrap_MatrixCoefficient_GetHeight, METH_O, "GetHeight(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetWidth", _wrap_MatrixCoefficient_GetWidth, METH_O, "GetWidth(MatrixCoefficient self) -> int"}, { "MatrixCoefficient_GetVDim", _wrap_MatrixCoefficient_GetVDim, METH_O, "GetVDim(MatrixCoefficient self) -> int"}, - { "MatrixCoefficient_Eval", _wrap_MatrixCoefficient_Eval, METH_VARARGS, "Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixCoefficient", _wrap_delete_MatrixCoefficient, METH_O, "delete_MatrixCoefficient(MatrixCoefficient self)"}, { "MatrixCoefficient_swigregister", MatrixCoefficient_swigregister, METH_O, NULL}, - { "new_MatrixConstantCoefficient", _wrap_new_MatrixConstantCoefficient, METH_O, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, + { "new_MatrixConstantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixConstantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixConstantCoefficient(DenseMatrix m) -> MatrixConstantCoefficient"}, { "MatrixConstantCoefficient_Eval", _wrap_MatrixConstantCoefficient_Eval, METH_VARARGS, "\n" "Eval(MatrixConstantCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" "Eval(MatrixConstantCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)\n" @@ -20159,15 +19227,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "new_MatrixFunctionCoefficient", _wrap_new_MatrixFunctionCoefficient, METH_VARARGS, "\n" "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,mfem::DenseMatrix &) F, Coefficient q=None)\n" "MatrixFunctionCoefficient(DenseMatrix m, Coefficient q)\n" - "MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None)\n" + "new_MatrixFunctionCoefficient(int dim, void (*)(mfem::Vector const &,double,mfem::DenseMatrix &) TDF, Coefficient q=None) -> MatrixFunctionCoefficient\n" ""}, - { "MatrixFunctionCoefficient_Eval", _wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS, "Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixFunctionCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixFunctionCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixFunctionCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixFunctionCoefficient", _wrap_delete_MatrixFunctionCoefficient, METH_O, "delete_MatrixFunctionCoefficient(MatrixFunctionCoefficient self)"}, { "MatrixFunctionCoefficient_swigregister", MatrixFunctionCoefficient_swigregister, METH_O, NULL}, { "MatrixFunctionCoefficient_swiginit", MatrixFunctionCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixArrayCoefficient", _wrap_new_MatrixArrayCoefficient, METH_O, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, - { "MatrixArrayCoefficient_GetCoeff", _wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS, "GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, - { "MatrixArrayCoefficient_Set", _wrap_MatrixArrayCoefficient_Set, METH_VARARGS, "Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, + { "new_MatrixArrayCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixArrayCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixArrayCoefficient(int dim) -> MatrixArrayCoefficient"}, + { "MatrixArrayCoefficient_GetCoeff", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_GetCoeff, METH_VARARGS|METH_KEYWORDS, "GetCoeff(MatrixArrayCoefficient self, int i, int j) -> Coefficient"}, + { "MatrixArrayCoefficient_Set", (PyCFunction)(void(*)(void))_wrap_MatrixArrayCoefficient_Set, METH_VARARGS|METH_KEYWORDS, "Set(MatrixArrayCoefficient self, int i, int j, Coefficient c, bool own=True)"}, { "MatrixArrayCoefficient_Eval", _wrap_MatrixArrayCoefficient_Eval, METH_VARARGS, "\n" "Eval(MatrixArrayCoefficient self, int i, int j, ElementTransformation T, IntegrationPoint ip) -> double\n" "Eval(MatrixArrayCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)\n" @@ -20175,42 +19243,42 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MatrixArrayCoefficient", _wrap_delete_MatrixArrayCoefficient, METH_O, "delete_MatrixArrayCoefficient(MatrixArrayCoefficient self)"}, { "MatrixArrayCoefficient_swigregister", MatrixArrayCoefficient_swigregister, METH_O, NULL}, { "MatrixArrayCoefficient_swiginit", MatrixArrayCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixRestrictedCoefficient", _wrap_new_MatrixRestrictedCoefficient, METH_VARARGS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, - { "MatrixRestrictedCoefficient_Eval", _wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS, "Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixRestrictedCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixRestrictedCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixRestrictedCoefficient(MatrixCoefficient mc, intArray attr) -> MatrixRestrictedCoefficient"}, + { "MatrixRestrictedCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixRestrictedCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixRestrictedCoefficient self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixRestrictedCoefficient", _wrap_delete_MatrixRestrictedCoefficient, METH_O, "delete_MatrixRestrictedCoefficient(MatrixRestrictedCoefficient self)"}, { "MatrixRestrictedCoefficient_swigregister", MatrixRestrictedCoefficient_swigregister, METH_O, NULL}, { "MatrixRestrictedCoefficient_swiginit", MatrixRestrictedCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_SumCoefficient", _wrap_new_SumCoefficient, METH_VARARGS, "SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "SumCoefficient_Eval", _wrap_SumCoefficient_Eval, METH_VARARGS, "Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_SumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_SumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_SumCoefficient(Coefficient A, Coefficient B, double _alpha=1.0, double _beta=1.0) -> SumCoefficient"}, + { "SumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_SumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(SumCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_SumCoefficient", _wrap_delete_SumCoefficient, METH_O, "delete_SumCoefficient(SumCoefficient self)"}, { "SumCoefficient_swigregister", SumCoefficient_swigregister, METH_O, NULL}, { "SumCoefficient_swiginit", SumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ProductCoefficient", _wrap_new_ProductCoefficient, METH_VARARGS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, - { "ProductCoefficient_Eval", _wrap_ProductCoefficient_Eval, METH_VARARGS, "Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_ProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ProductCoefficient(Coefficient A, Coefficient B) -> ProductCoefficient"}, + { "ProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ProductCoefficient", _wrap_delete_ProductCoefficient, METH_O, "delete_ProductCoefficient(ProductCoefficient self)"}, { "ProductCoefficient_swigregister", ProductCoefficient_swigregister, METH_O, NULL}, { "ProductCoefficient_swiginit", ProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_PowerCoefficient", _wrap_new_PowerCoefficient, METH_VARARGS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, - { "PowerCoefficient_Eval", _wrap_PowerCoefficient_Eval, METH_VARARGS, "Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_PowerCoefficient", (PyCFunction)(void(*)(void))_wrap_new_PowerCoefficient, METH_VARARGS|METH_KEYWORDS, "new_PowerCoefficient(Coefficient A, double _p) -> PowerCoefficient"}, + { "PowerCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_PowerCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(PowerCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_PowerCoefficient", _wrap_delete_PowerCoefficient, METH_O, "delete_PowerCoefficient(PowerCoefficient self)"}, { "PowerCoefficient_swigregister", PowerCoefficient_swigregister, METH_O, NULL}, { "PowerCoefficient_swiginit", PowerCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InnerProductCoefficient", _wrap_new_InnerProductCoefficient, METH_VARARGS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, - { "InnerProductCoefficient_Eval", _wrap_InnerProductCoefficient_Eval, METH_VARARGS, "Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_InnerProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InnerProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InnerProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> InnerProductCoefficient"}, + { "InnerProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InnerProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(InnerProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_InnerProductCoefficient", _wrap_delete_InnerProductCoefficient, METH_O, "delete_InnerProductCoefficient(InnerProductCoefficient self)"}, { "InnerProductCoefficient_swigregister", InnerProductCoefficient_swigregister, METH_O, NULL}, { "InnerProductCoefficient_swiginit", InnerProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorRotProductCoefficient", _wrap_new_VectorRotProductCoefficient, METH_VARARGS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, - { "VectorRotProductCoefficient_Eval", _wrap_VectorRotProductCoefficient_Eval, METH_VARARGS, "Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_VectorRotProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorRotProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorRotProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorRotProductCoefficient"}, + { "VectorRotProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_VectorRotProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(VectorRotProductCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_VectorRotProductCoefficient", _wrap_delete_VectorRotProductCoefficient, METH_O, "delete_VectorRotProductCoefficient(VectorRotProductCoefficient self)"}, { "VectorRotProductCoefficient_swigregister", VectorRotProductCoefficient_swigregister, METH_O, NULL}, { "VectorRotProductCoefficient_swiginit", VectorRotProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_DeterminantCoefficient", _wrap_new_DeterminantCoefficient, METH_O, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, - { "DeterminantCoefficient_Eval", _wrap_DeterminantCoefficient_Eval, METH_VARARGS, "Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "new_DeterminantCoefficient", (PyCFunction)(void(*)(void))_wrap_new_DeterminantCoefficient, METH_VARARGS|METH_KEYWORDS, "new_DeterminantCoefficient(MatrixCoefficient A) -> DeterminantCoefficient"}, + { "DeterminantCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_DeterminantCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DeterminantCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_DeterminantCoefficient", _wrap_delete_DeterminantCoefficient, METH_O, "delete_DeterminantCoefficient(DeterminantCoefficient self)"}, { "DeterminantCoefficient_swigregister", DeterminantCoefficient_swigregister, METH_O, NULL}, { "DeterminantCoefficient_swiginit", DeterminantCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorSumCoefficient", _wrap_new_VectorSumCoefficient, METH_VARARGS, "VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0)"}, + { "new_VectorSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorSumCoefficient(VectorCoefficient A, VectorCoefficient B, double _alpha=1.0, double _beta=1.0) -> VectorSumCoefficient"}, { "VectorSumCoefficient_Eval", _wrap_VectorSumCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorSumCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -20218,7 +19286,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorSumCoefficient", _wrap_delete_VectorSumCoefficient, METH_O, "delete_VectorSumCoefficient(VectorSumCoefficient self)"}, { "VectorSumCoefficient_swigregister", VectorSumCoefficient_swigregister, METH_O, NULL}, { "VectorSumCoefficient_swiginit", VectorSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarVectorProductCoefficient", _wrap_new_ScalarVectorProductCoefficient, METH_VARARGS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, + { "new_ScalarVectorProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarVectorProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarVectorProductCoefficient(Coefficient A, VectorCoefficient B) -> ScalarVectorProductCoefficient"}, { "ScalarVectorProductCoefficient_Eval", _wrap_ScalarVectorProductCoefficient_Eval, METH_VARARGS, "\n" "Eval(ScalarVectorProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(ScalarVectorProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -20226,7 +19294,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_ScalarVectorProductCoefficient", _wrap_delete_ScalarVectorProductCoefficient, METH_O, "delete_ScalarVectorProductCoefficient(ScalarVectorProductCoefficient self)"}, { "ScalarVectorProductCoefficient_swigregister", ScalarVectorProductCoefficient_swigregister, METH_O, NULL}, { "ScalarVectorProductCoefficient_swiginit", ScalarVectorProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_VectorCrossProductCoefficient", _wrap_new_VectorCrossProductCoefficient, METH_VARARGS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, + { "new_VectorCrossProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_VectorCrossProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_VectorCrossProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> VectorCrossProductCoefficient"}, { "VectorCrossProductCoefficient_Eval", _wrap_VectorCrossProductCoefficient_Eval, METH_VARARGS, "\n" "Eval(VectorCrossProductCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(VectorCrossProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -20234,7 +19302,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorCrossProductCoefficient", _wrap_delete_VectorCrossProductCoefficient, METH_O, "delete_VectorCrossProductCoefficient(VectorCrossProductCoefficient self)"}, { "VectorCrossProductCoefficient_swigregister", VectorCrossProductCoefficient_swigregister, METH_O, NULL}, { "VectorCrossProductCoefficient_swiginit", VectorCrossProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatVecCoefficient", _wrap_new_MatVecCoefficient, METH_VARARGS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, + { "new_MatVecCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatVecCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatVecCoefficient(MatrixCoefficient A, VectorCoefficient B) -> MatVecCoefficient"}, { "MatVecCoefficient_Eval", _wrap_MatVecCoefficient_Eval, METH_VARARGS, "\n" "Eval(MatVecCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(MatVecCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -20242,33 +19310,33 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MatVecCoefficient", _wrap_delete_MatVecCoefficient, METH_O, "delete_MatVecCoefficient(MatVecCoefficient self)"}, { "MatVecCoefficient_swigregister", MatVecCoefficient_swigregister, METH_O, NULL}, { "MatVecCoefficient_swiginit", MatVecCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_IdentityMatrixCoefficient", _wrap_new_IdentityMatrixCoefficient, METH_O, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, - { "IdentityMatrixCoefficient_Eval", _wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS, "Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_IdentityMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_IdentityMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_IdentityMatrixCoefficient(int d) -> IdentityMatrixCoefficient"}, + { "IdentityMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_IdentityMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(IdentityMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_IdentityMatrixCoefficient", _wrap_delete_IdentityMatrixCoefficient, METH_O, "delete_IdentityMatrixCoefficient(IdentityMatrixCoefficient self)"}, { "IdentityMatrixCoefficient_swigregister", IdentityMatrixCoefficient_swigregister, METH_O, NULL}, { "IdentityMatrixCoefficient_swiginit", IdentityMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_MatrixSumCoefficient", _wrap_new_MatrixSumCoefficient, METH_VARARGS, "MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0)"}, - { "MatrixSumCoefficient_Eval", _wrap_MatrixSumCoefficient_Eval, METH_VARARGS, "Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_MatrixSumCoefficient", (PyCFunction)(void(*)(void))_wrap_new_MatrixSumCoefficient, METH_VARARGS|METH_KEYWORDS, "new_MatrixSumCoefficient(MatrixCoefficient A, MatrixCoefficient B, double _alpha=1.0, double _beta=1.0) -> MatrixSumCoefficient"}, + { "MatrixSumCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixSumCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixSumCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_MatrixSumCoefficient", _wrap_delete_MatrixSumCoefficient, METH_O, "delete_MatrixSumCoefficient(MatrixSumCoefficient self)"}, { "MatrixSumCoefficient_swigregister", MatrixSumCoefficient_swigregister, METH_O, NULL}, { "MatrixSumCoefficient_swiginit", MatrixSumCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_ScalarMatrixProductCoefficient", _wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, - { "ScalarMatrixProductCoefficient_Eval", _wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS, "Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_ScalarMatrixProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ScalarMatrixProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ScalarMatrixProductCoefficient(Coefficient A, MatrixCoefficient B) -> ScalarMatrixProductCoefficient"}, + { "ScalarMatrixProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ScalarMatrixProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ScalarMatrixProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_ScalarMatrixProductCoefficient", _wrap_delete_ScalarMatrixProductCoefficient, METH_O, "delete_ScalarMatrixProductCoefficient(ScalarMatrixProductCoefficient self)"}, { "ScalarMatrixProductCoefficient_swigregister", ScalarMatrixProductCoefficient_swigregister, METH_O, NULL}, { "ScalarMatrixProductCoefficient_swiginit", ScalarMatrixProductCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_TransposeMatrixCoefficient", _wrap_new_TransposeMatrixCoefficient, METH_O, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, - { "TransposeMatrixCoefficient_Eval", _wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS, "Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_TransposeMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_TransposeMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_TransposeMatrixCoefficient(MatrixCoefficient A) -> TransposeMatrixCoefficient"}, + { "TransposeMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_TransposeMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(TransposeMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_TransposeMatrixCoefficient", _wrap_delete_TransposeMatrixCoefficient, METH_O, "delete_TransposeMatrixCoefficient(TransposeMatrixCoefficient self)"}, { "TransposeMatrixCoefficient_swigregister", TransposeMatrixCoefficient_swigregister, METH_O, NULL}, { "TransposeMatrixCoefficient_swiginit", TransposeMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_InverseMatrixCoefficient", _wrap_new_InverseMatrixCoefficient, METH_O, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, - { "InverseMatrixCoefficient_Eval", _wrap_InverseMatrixCoefficient_Eval, METH_VARARGS, "Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_InverseMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_new_InverseMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "new_InverseMatrixCoefficient(MatrixCoefficient A) -> InverseMatrixCoefficient"}, + { "InverseMatrixCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_InverseMatrixCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(InverseMatrixCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_InverseMatrixCoefficient", _wrap_delete_InverseMatrixCoefficient, METH_O, "delete_InverseMatrixCoefficient(InverseMatrixCoefficient self)"}, { "InverseMatrixCoefficient_swigregister", InverseMatrixCoefficient_swigregister, METH_O, NULL}, { "InverseMatrixCoefficient_swiginit", InverseMatrixCoefficient_swiginit, METH_VARARGS, NULL}, - { "new_OuterProductCoefficient", _wrap_new_OuterProductCoefficient, METH_VARARGS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, - { "OuterProductCoefficient_Eval", _wrap_OuterProductCoefficient_Eval, METH_VARARGS, "Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, + { "new_OuterProductCoefficient", (PyCFunction)(void(*)(void))_wrap_new_OuterProductCoefficient, METH_VARARGS|METH_KEYWORDS, "new_OuterProductCoefficient(VectorCoefficient A, VectorCoefficient B) -> OuterProductCoefficient"}, + { "OuterProductCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_OuterProductCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(OuterProductCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationPoint ip)"}, { "delete_OuterProductCoefficient", _wrap_delete_OuterProductCoefficient, METH_O, "delete_OuterProductCoefficient(OuterProductCoefficient self)"}, { "OuterProductCoefficient_swigregister", OuterProductCoefficient_swigregister, METH_O, NULL}, { "OuterProductCoefficient_swiginit", OuterProductCoefficient_swiginit, METH_VARARGS, NULL}, @@ -20276,34 +19344,34 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ComputeLpNorm(double p, Coefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" "ComputeLpNorm(double p, VectorCoefficient coeff, mfem::Mesh & mesh, mfem::IntegrationRule const *[] irs) -> double\n" ""}, - { "fake_func", _wrap_fake_func, METH_O, "fake_func(Vector x) -> double"}, - { "fake_func_vec", _wrap_fake_func_vec, METH_VARARGS, "fake_func_vec(Vector x, Vector Ht)"}, - { "fake_func_mat", _wrap_fake_func_mat, METH_VARARGS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, - { "new_PyCoefficientBase", _wrap_new_PyCoefficientBase, METH_VARARGS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, - { "PyCoefficientBase_Eval", _wrap_PyCoefficientBase_Eval, METH_VARARGS, "Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, - { "PyCoefficientBase__EvalPy", _wrap_PyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, - { "PyCoefficientBase__EvalPyT", _wrap_PyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, + { "fake_func", (PyCFunction)(void(*)(void))_wrap_fake_func, METH_VARARGS|METH_KEYWORDS, "fake_func(Vector x) -> double"}, + { "fake_func_vec", (PyCFunction)(void(*)(void))_wrap_fake_func_vec, METH_VARARGS|METH_KEYWORDS, "fake_func_vec(Vector x, Vector Ht)"}, + { "fake_func_mat", (PyCFunction)(void(*)(void))_wrap_fake_func_mat, METH_VARARGS|METH_KEYWORDS, "fake_func_mat(Vector x, DenseMatrix Kt)"}, + { "new_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_PyCoefficientBase(PyObject * _self, int tdep) -> PyCoefficientBase"}, + { "PyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(PyCoefficientBase self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "PyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "_EvalPy(PyCoefficientBase self, Vector arg0) -> double"}, + { "PyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_PyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "_EvalPyT(PyCoefficientBase self, Vector arg0, double arg1) -> double"}, { "delete_PyCoefficientBase", _wrap_delete_PyCoefficientBase, METH_O, "delete_PyCoefficientBase(PyCoefficientBase self)"}, - { "disown_PyCoefficientBase", _wrap_disown_PyCoefficientBase, METH_O, NULL}, + { "disown_PyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_PyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyCoefficientBase_swigregister", PyCoefficientBase_swigregister, METH_O, NULL}, { "PyCoefficientBase_swiginit", PyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_VectorPyCoefficientBase", _wrap_new_VectorPyCoefficientBase, METH_VARARGS, "VectorPyCoefficientBase(int dim, int tdep, Coefficient q=None)"}, + { "new_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_VectorPyCoefficientBase(PyObject * _self, int dim, int tdep, Coefficient q=None) -> VectorPyCoefficientBase"}, { "VectorPyCoefficientBase_Eval", _wrap_VectorPyCoefficientBase_Eval, METH_VARARGS, "\n" "Eval(VectorPyCoefficientBase self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" "Eval(VectorPyCoefficientBase self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" ""}, - { "VectorPyCoefficientBase__EvalPy", _wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, - { "VectorPyCoefficientBase__EvalPyT", _wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, + { "VectorPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "_EvalPy(VectorPyCoefficientBase self, Vector arg0, Vector arg1)"}, + { "VectorPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_VectorPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "_EvalPyT(VectorPyCoefficientBase self, Vector arg0, double arg1, Vector arg2)"}, { "delete_VectorPyCoefficientBase", _wrap_delete_VectorPyCoefficientBase, METH_O, "delete_VectorPyCoefficientBase(VectorPyCoefficientBase self)"}, - { "disown_VectorPyCoefficientBase", _wrap_disown_VectorPyCoefficientBase, METH_O, NULL}, + { "disown_VectorPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_VectorPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "VectorPyCoefficientBase_swigregister", VectorPyCoefficientBase_swigregister, METH_O, NULL}, { "VectorPyCoefficientBase_swiginit", VectorPyCoefficientBase_swiginit, METH_VARARGS, NULL}, - { "new_MatrixPyCoefficientBase", _wrap_new_MatrixPyCoefficientBase, METH_VARARGS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, - { "MatrixPyCoefficientBase_Eval", _wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS, "Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, - { "MatrixPyCoefficientBase__EvalPy", _wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS, "_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, - { "MatrixPyCoefficientBase__EvalPyT", _wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS, "_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, + { "new_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_new_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, "new_MatrixPyCoefficientBase(PyObject * _self, int dim, int tdep) -> MatrixPyCoefficientBase"}, + { "MatrixPyCoefficientBase_Eval", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(MatrixPyCoefficientBase self, DenseMatrix K, ElementTransformation T, IntegrationPoint ip)"}, + { "MatrixPyCoefficientBase__EvalPy", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPy, METH_VARARGS|METH_KEYWORDS, "_EvalPy(MatrixPyCoefficientBase self, Vector arg0, DenseMatrix arg1)"}, + { "MatrixPyCoefficientBase__EvalPyT", (PyCFunction)(void(*)(void))_wrap_MatrixPyCoefficientBase__EvalPyT, METH_VARARGS|METH_KEYWORDS, "_EvalPyT(MatrixPyCoefficientBase self, Vector arg0, double arg1, DenseMatrix arg2)"}, { "delete_MatrixPyCoefficientBase", _wrap_delete_MatrixPyCoefficientBase, METH_O, "delete_MatrixPyCoefficientBase(MatrixPyCoefficientBase self)"}, - { "disown_MatrixPyCoefficientBase", _wrap_disown_MatrixPyCoefficientBase, METH_O, NULL}, + { "disown_MatrixPyCoefficientBase", (PyCFunction)(void(*)(void))_wrap_disown_MatrixPyCoefficientBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "MatrixPyCoefficientBase_swigregister", MatrixPyCoefficientBase_swigregister, METH_O, NULL}, { "MatrixPyCoefficientBase_swiginit", MatrixPyCoefficientBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } diff --git a/mfem/_ser/common_functions_wrap.cxx b/mfem/_ser/common_functions_wrap.cxx index 5df0e673..c45ed2e3 100644 --- a/mfem/_ser/common_functions_wrap.cxx +++ b/mfem/_ser/common_functions_wrap.cxx @@ -2944,7 +2944,7 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ PyObject *resultobj = 0; mfem::Table *arg1 = 0 ; mfem::Table *arg2 = 0 ; - int arg3 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -2952,7 +2952,7 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Table const &""'"); @@ -2969,11 +2969,13 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { mfem::Transpose((mfem::Table const &)*arg1,*arg2,arg3); @@ -2998,55 +3000,6 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_Transpose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = 0 ; - mfem::Table *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Table const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Table const &""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); - { - try { - mfem::Transpose((mfem::Table const &)*arg1,*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Transpose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = 0 ; void *argp1 = 0 ; @@ -3085,11 +3038,11 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Transpose__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; mfem::Table *arg2 = 0 ; - int arg3 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3097,7 +3050,7 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); @@ -3114,63 +3067,16 @@ SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); - { - try { - mfem::Transpose((mfem::Array< int > const &)*arg1,*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Transpose__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = 0 ; - mfem::Table *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Transpose" "', argument " "2"" of type '" "mfem::Table &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Transpose" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); } - arg2 = reinterpret_cast< mfem::Table * >(argp2); { try { - mfem::Transpose((mfem::Array< int > const &)*arg1,*arg2); + mfem::Transpose((mfem::Array< int > const &)*arg1,*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3301,7 +3207,7 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize } -SWIGINTERN PyObject *_wrap_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -3309,11 +3215,15 @@ SWIGINTERN PyObject *_wrap_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"y", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "InnerProduct", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InnerProduct", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InnerProduct" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -3321,7 +3231,7 @@ SWIGINTERN PyObject *_wrap_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InnerProduct" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3626,7 +3536,7 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize } -SWIGINTERN PyObject *_wrap_Transpose__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Transpose__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; void *argp1 = 0 ; @@ -3669,7 +3579,7 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; - mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) 0 ; + mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3678,7 +3588,7 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize int res3 = 0 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -3695,11 +3605,13 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { result = (mfem::SparseMatrix *)mfem::Mult((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2,arg3); @@ -3724,56 +3636,6 @@ SWIGINTERN PyObject *_wrap_Mult__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize SWIGINTERN PyObject *_wrap_Mult__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - mfem::SparseMatrix *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - { - try { - result = (mfem::SparseMatrix *)mfem::Mult((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mult__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -3927,7 +3789,7 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; - mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) 0 ; + mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3936,7 +3798,7 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res3 = 0 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -3953,11 +3815,13 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { result = (mfem::SparseMatrix *)mfem::RAP((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2,arg3); @@ -3982,56 +3846,6 @@ SWIGINTERN PyObject *_wrap_RAP__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIGINTERN PyObject *_wrap_RAP__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - mfem::SparseMatrix *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAP" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); - } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - { - try { - result = (mfem::SparseMatrix *)mfem::RAP((mfem::SparseMatrix const &)*arg1,(mfem::SparseMatrix const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_RAP__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -4126,19 +3940,7 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { } } } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_RAP__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -4146,6 +3948,9 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_RAP__SWIG_2(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); @@ -4166,7 +3971,7 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_RAP__SWIG_4(self, argc, argv); + return _wrap_RAP__SWIG_3(self, argc, argv); } } } @@ -4178,7 +3983,6 @@ SWIGINTERN PyObject *_wrap_RAP(PyObject *self, PyObject *args) { " mfem::RAP(mfem::SparseMatrix const &,mfem::DenseMatrix &)\n" " mfem::RAP(mfem::DenseMatrix &,mfem::SparseMatrix const &)\n" " mfem::RAP(mfem::SparseMatrix const &,mfem::SparseMatrix const &,mfem::SparseMatrix *)\n" - " mfem::RAP(mfem::SparseMatrix const &,mfem::SparseMatrix const &)\n" " mfem::RAP(mfem::SparseMatrix const &,mfem::SparseMatrix const &,mfem::SparseMatrix const &)\n"); return 0; } @@ -4566,7 +4370,7 @@ SWIGINTERN PyObject *_wrap_Add(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Transpose__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Transpose__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = 0 ; void *argp1 = 0 ; @@ -4618,7 +4422,7 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_2(self, argc, argv); + return _wrap_Transpose__SWIG_1(self, argc, argv); } } if (argc == 1) { @@ -4626,7 +4430,7 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_5(self, argc, argv); + return _wrap_Transpose__SWIG_3(self, argc, argv); } } if (argc == 1) { @@ -4634,10 +4438,10 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BlockMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_6(self, argc, argv); + return _wrap_Transpose__SWIG_4(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -4646,57 +4450,37 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Transpose__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Transpose__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Transpose__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Transpose__SWIG_3(self, argc, argv); + return _wrap_Transpose__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Transpose__SWIG_2(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_Transpose__SWIG_0(self, argc, argv); + return _wrap_Transpose__SWIG_2(self, argc, argv); } } } @@ -4706,17 +4490,15 @@ SWIGINTERN PyObject *_wrap_Transpose(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Transpose'.\n" " Possible C/C++ prototypes are:\n" " mfem::Transpose(mfem::Table const &,mfem::Table &,int)\n" - " mfem::Transpose(mfem::Table const &,mfem::Table &)\n" " mfem::Transpose(mfem::Table const &)\n" " mfem::Transpose(mfem::Array< int > const &,mfem::Table &,int)\n" - " mfem::Transpose(mfem::Array< int > const &,mfem::Table &)\n" " mfem::Transpose(mfem::SparseMatrix const &)\n" " mfem::Transpose(mfem::BlockMatrix const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mult__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mult__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BlockMatrix *arg1 = 0 ; mfem::BlockMatrix *arg2 = 0 ; @@ -4786,7 +4568,7 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -4794,7 +4576,15 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mult__SWIG_4(self, argc, argv); + if (argc <= 2) { + return _wrap_Mult__SWIG_3(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mult__SWIG_3(self, argc, argv); + } } } } @@ -4807,7 +4597,7 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mult__SWIG_5(self, argc, argv); + return _wrap_Mult__SWIG_4(self, argc, argv); } } } @@ -4819,24 +4609,7 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__BlockMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mult__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mult__SWIG_0(self, argc, argv); - } + return _wrap_Mult__SWIG_5(self, argc, argv); } } } @@ -4859,17 +4632,17 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { } if (argc == 3) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Table, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mult__SWIG_3(self, argc, argv); + return _wrap_Mult__SWIG_0(self, argc, argv); } } } @@ -4882,7 +4655,6 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { " mfem::Mult(mfem::Table const &,mfem::Table const &)\n" " mfem::Mult(mfem::DenseMatrix const &,mfem::DenseMatrix const &,mfem::DenseMatrix &)\n" " mfem::Mult(mfem::SparseMatrix const &,mfem::SparseMatrix const &,mfem::SparseMatrix *)\n" - " mfem::Mult(mfem::SparseMatrix const &,mfem::SparseMatrix const &)\n" " mfem::Mult(mfem::SparseMatrix const &,mfem::DenseMatrix &)\n" " mfem::Mult(mfem::BlockMatrix const &,mfem::BlockMatrix const &)\n"); return 0; @@ -4892,7 +4664,7 @@ SWIGINTERN PyObject *_wrap_Mult(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "InnerProduct", _wrap_InnerProduct, METH_VARARGS, "InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double"}, + { "InnerProduct", (PyCFunction)(void(*)(void))_wrap_InnerProduct, METH_VARARGS|METH_KEYWORDS, "InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double"}, { "RAP", _wrap_RAP, METH_VARARGS, "\n" "RAP(mfem::SparseMatrix const & A, mfem::DenseMatrix & P) -> mfem::DenseMatrix\n" "RAP(mfem::DenseMatrix & A, mfem::SparseMatrix const & P) -> mfem::DenseMatrix\n" @@ -4929,7 +4701,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "InnerProduct", _wrap_InnerProduct, METH_VARARGS, "InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double"}, + { "InnerProduct", (PyCFunction)(void(*)(void))_wrap_InnerProduct, METH_VARARGS|METH_KEYWORDS, "InnerProduct(mfem::Vector const & x, mfem::Vector const & y) -> double"}, { "RAP", _wrap_RAP, METH_VARARGS, "\n" "RAP(mfem::SparseMatrix const & A, mfem::DenseMatrix & P) -> mfem::DenseMatrix\n" "RAP(mfem::DenseMatrix & A, mfem::SparseMatrix const & P) -> mfem::DenseMatrix\n" diff --git a/mfem/_ser/complex_operator.py b/mfem/_ser/complex_operator.py index 5de9f9aa..6efb58ea 100644 --- a/mfem/_ser/complex_operator.py +++ b/mfem/_ser/complex_operator.py @@ -148,9 +148,9 @@ class ComplexSparseMatrix(ComplexOperator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ComplexSparseMatrix self, SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix""" - _complex_operator.ComplexSparseMatrix_swiginit(self, _complex_operator.new_ComplexSparseMatrix(*args)) + _complex_operator.ComplexSparseMatrix_swiginit(self, _complex_operator.new_ComplexSparseMatrix(*args, **kwargs)) def real(self, *args): r""" diff --git a/mfem/_ser/complex_operator_wrap.cxx b/mfem/_ser/complex_operator_wrap.cxx index 36ed4eee..f640711f 100644 --- a/mfem/_ser/complex_operator_wrap.cxx +++ b/mfem/_ser/complex_operator_wrap.cxx @@ -3352,7 +3352,7 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) return SWIG_OK; } -SWIGINTERN mfem::ComplexOperator *new_mfem_ComplexOperator__SWIG_0(mfem::Operator *Op_Real,mfem::Operator *Op_Imag,bool ownReal=false,bool ownImag=false,bool hermitan=true){ +SWIGINTERN mfem::ComplexOperator *new_mfem_ComplexOperator(mfem::Operator *Op_Real,mfem::Operator *Op_Imag,bool ownReal=false,bool ownImag=false,bool hermitan=true){ if (hermitan){ return new mfem::ComplexOperator(Op_Real, Op_Imag, ownReal, ownImag, mfem::ComplexOperator::HERMITIAN); @@ -3748,7 +3748,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_imag(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3759,15 +3759,20 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ComplexOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ComplexOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_Mult" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); } arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComplexOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3775,7 +3780,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComplexOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComplexOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3809,7 +3814,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ComplexOperator *arg1 = (mfem::ComplexOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3820,15 +3825,20 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ComplexOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ComplexOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ComplexOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ComplexOperator_MultTranspose" "', argument " "1"" of type '" "mfem::ComplexOperator const *""'"); } arg1 = reinterpret_cast< mfem::ComplexOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ComplexOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3836,7 +3846,7 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_MultTranspose(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComplexOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComplexOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3911,13 +3921,13 @@ SWIGINTERN PyObject *_wrap_ComplexOperator_GetType(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ComplexOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; - bool arg3 ; - bool arg4 ; - bool arg5 ; + bool arg3 = (bool) false ; + bool arg4 = (bool) false ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3928,202 +3938,51 @@ SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_0(PyObject *SWIGUNUSEDPARM( int ecode4 = 0 ; bool val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"Op_Real", (char *)"Op_Imag", (char *)"ownReal", (char *)"ownImag", (char *)"hermitan", NULL + }; mfem::ComplexOperator *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexOperator" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - bool arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::ComplexOperator *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - mfem::ComplexOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:new_ComplexOperator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexOperator" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Operator *arg2 = (mfem::Operator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::ComplexOperator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexOperator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexOperator" "', argument " "2"" of type '" "mfem::Operator *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexOperator" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - result = (mfem::ComplexOperator *)new_mfem_ComplexOperator__SWIG_0(arg1,arg2); + result = (mfem::ComplexOperator *)new_mfem_ComplexOperator(arg1,arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4147,118 +4006,6 @@ SWIGINTERN PyObject *_wrap_new_ComplexOperator__SWIG_3(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_ComplexOperator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComplexOperator", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ComplexOperator__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexOperator__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexOperator__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexOperator__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComplexOperator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *,bool,bool,bool)\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *,bool,bool)\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *,bool)\n" - " mfem::ComplexOperator::ComplexOperator(mfem::Operator *,mfem::Operator *)\n"); - return 0; -} - - SWIGINTERN PyObject *ComplexOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -4270,13 +4017,13 @@ SWIGINTERN PyObject *ComplexOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = (mfem::SparseMatrix *) 0 ; bool arg3 ; bool arg4 ; - mfem::ComplexOperator::Convention arg5 ; + mfem::ComplexOperator::Convention arg5 = (mfem::ComplexOperator::Convention) mfem::ComplexOperator::HERMITIAN ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4287,100 +4034,47 @@ SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_0(PyObject *SWIGUNUSEDP int ecode4 = 0 ; int val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"A_Real", (char *)"A_Imag", (char *)"ownReal", (char *)"ownImag", (char *)"convention", NULL + }; mfem::ComplexSparseMatrix *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:new_ComplexSparseMatrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexSparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexSparseMatrix" "', argument " "2"" of type '" "mfem::SparseMatrix *""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_bool(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexSparseMatrix" "', argument " "3"" of type '" "bool""'"); } arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexSparseMatrix" "', argument " "4"" of type '" "bool""'"); } arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexSparseMatrix" "', argument " "5"" of type '" "mfem::ComplexOperator::Convention""'"); - } - arg5 = static_cast< mfem::ComplexOperator::Convention >(val5); - { - try { - result = (mfem::ComplexSparseMatrix *)new mfem::ComplexSparseMatrix(arg1,arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ComplexSparseMatrix, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::SparseMatrix *arg2 = (mfem::SparseMatrix *) 0 ; - bool arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::ComplexSparseMatrix *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ComplexSparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ComplexSparseMatrix" "', argument " "2"" of type '" "mfem::SparseMatrix *""'"); + if (obj4) { + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_ComplexSparseMatrix" "', argument " "5"" of type '" "mfem::ComplexOperator::Convention""'"); + } + arg5 = static_cast< mfem::ComplexOperator::Convention >(val5); } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ComplexSparseMatrix" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ComplexSparseMatrix" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - result = (mfem::ComplexSparseMatrix *)new mfem::ComplexSparseMatrix(arg1,arg2,arg3,arg4); + result = (mfem::ComplexSparseMatrix *)new mfem::ComplexSparseMatrix(arg1,arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4404,82 +4098,6 @@ SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_ComplexSparseMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ComplexSparseMatrix", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexSparseMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ComplexSparseMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ComplexSparseMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ComplexSparseMatrix::ComplexSparseMatrix(mfem::SparseMatrix *,mfem::SparseMatrix *,bool,bool,mfem::ComplexOperator::Convention)\n" - " mfem::ComplexSparseMatrix::ComplexSparseMatrix(mfem::SparseMatrix *,mfem::SparseMatrix *,bool,bool)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ComplexSparseMatrix_real__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ComplexSparseMatrix *arg1 = (mfem::ComplexSparseMatrix *) 0 ; @@ -4855,13 +4473,13 @@ static PyMethodDef SwigMethods[] = { "ComplexOperator_imag(ComplexOperator self) -> Operator\n" "ComplexOperator_imag(ComplexOperator self) -> Operator\n" ""}, - { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "ComplexOperator_Mult(ComplexOperator self, Vector x, Vector y)"}, - { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "ComplexOperator_MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ComplexOperator_Mult(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ComplexOperator_MultTranspose(ComplexOperator self, Vector x, Vector y)"}, { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "ComplexOperator_GetType(ComplexOperator self) -> mfem::Operator::Type"}, - { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, + { "new_ComplexOperator", (PyCFunction)(void(*)(void))_wrap_new_ComplexOperator, METH_VARARGS|METH_KEYWORDS, "new_ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True) -> ComplexOperator"}, { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, - { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "new_ComplexSparseMatrix", (PyCFunction)(void(*)(void))_wrap_new_ComplexSparseMatrix, METH_VARARGS|METH_KEYWORDS, "new_ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix"}, { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" "ComplexSparseMatrix_real(ComplexSparseMatrix self) -> SparseMatrix\n" @@ -4892,13 +4510,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "imag(ComplexOperator self) -> Operator\n" "imag(ComplexOperator self) -> Operator\n" ""}, - { "ComplexOperator_Mult", _wrap_ComplexOperator_Mult, METH_VARARGS, "Mult(ComplexOperator self, Vector x, Vector y)"}, - { "ComplexOperator_MultTranspose", _wrap_ComplexOperator_MultTranspose, METH_VARARGS, "MultTranspose(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ComplexOperator self, Vector x, Vector y)"}, + { "ComplexOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ComplexOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ComplexOperator self, Vector x, Vector y)"}, { "ComplexOperator_GetType", _wrap_ComplexOperator_GetType, METH_O, "GetType(ComplexOperator self) -> mfem::Operator::Type"}, - { "new_ComplexOperator", _wrap_new_ComplexOperator, METH_VARARGS, "ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True)"}, + { "new_ComplexOperator", (PyCFunction)(void(*)(void))_wrap_new_ComplexOperator, METH_VARARGS|METH_KEYWORDS, "new_ComplexOperator(Operator Op_Real, Operator Op_Imag, bool ownReal=False, bool ownImag=False, bool hermitan=True) -> ComplexOperator"}, { "ComplexOperator_swigregister", ComplexOperator_swigregister, METH_O, NULL}, { "ComplexOperator_swiginit", ComplexOperator_swiginit, METH_VARARGS, NULL}, - { "new_ComplexSparseMatrix", _wrap_new_ComplexSparseMatrix, METH_VARARGS, "ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN)"}, + { "new_ComplexSparseMatrix", (PyCFunction)(void(*)(void))_wrap_new_ComplexSparseMatrix, METH_VARARGS|METH_KEYWORDS, "new_ComplexSparseMatrix(SparseMatrix A_Real, SparseMatrix A_Imag, bool ownReal, bool ownImag, mfem::ComplexOperator::Convention convention=HERMITIAN) -> ComplexSparseMatrix"}, { "ComplexSparseMatrix_real", _wrap_ComplexSparseMatrix_real, METH_VARARGS, "\n" "real(ComplexSparseMatrix self) -> SparseMatrix\n" "real(ComplexSparseMatrix self) -> SparseMatrix\n" diff --git a/mfem/_ser/densemat.py b/mfem/_ser/densemat.py index 4717d807..d5eef674 100644 --- a/mfem/_ser/densemat.py +++ b/mfem/_ser/densemat.py @@ -538,7 +538,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_densemat.DenseMatrix_MemoryUsage) def Read(self, on_dev=True): - r"""Read(DenseMatrix self, bool on_dev=True) -> double const""" + r"""Read(DenseMatrix self, bool on_dev=True) -> double const *""" return _densemat.DenseMatrix_Read(self, on_dev) Read = _swig_new_instance_method(_densemat.DenseMatrix_Read) @@ -548,7 +548,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_densemat.DenseMatrix_HostRead) def Write(self, on_dev=True): - r"""Write(DenseMatrix self, bool on_dev=True) -> double""" + r"""Write(DenseMatrix self, bool on_dev=True) -> double *""" return _densemat.DenseMatrix_Write(self, on_dev) Write = _swig_new_instance_method(_densemat.DenseMatrix_Write) @@ -558,7 +558,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(DenseMatrix self, bool on_dev=True) -> double""" + r"""ReadWrite(DenseMatrix self, bool on_dev=True) -> double *""" return _densemat.DenseMatrix_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_ReadWrite) @@ -1077,7 +1077,7 @@ def MemoryUsage(self): MemoryUsage = _swig_new_instance_method(_densemat.DenseTensor_MemoryUsage) def Read(self, on_dev=True): - r"""Read(DenseTensor self, bool on_dev=True) -> double const""" + r"""Read(DenseTensor self, bool on_dev=True) -> double const *""" return _densemat.DenseTensor_Read(self, on_dev) Read = _swig_new_instance_method(_densemat.DenseTensor_Read) @@ -1087,7 +1087,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_densemat.DenseTensor_HostRead) def Write(self, on_dev=True): - r"""Write(DenseTensor self, bool on_dev=True) -> double""" + r"""Write(DenseTensor self, bool on_dev=True) -> double *""" return _densemat.DenseTensor_Write(self, on_dev) Write = _swig_new_instance_method(_densemat.DenseTensor_Write) @@ -1097,7 +1097,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_densemat.DenseTensor_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(DenseTensor self, bool on_dev=True) -> double""" + r"""ReadWrite(DenseTensor self, bool on_dev=True) -> double *""" return _densemat.DenseTensor_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_densemat.DenseTensor_ReadWrite) diff --git a/mfem/_ser/densemat_wrap.cxx b/mfem/_ser/densemat_wrap.cxx index df896a45..a050c861 100644 --- a/mfem/_ser/densemat_wrap.cxx +++ b/mfem/_ser/densemat_wrap.cxx @@ -3590,7 +3590,7 @@ SWIGINTERN PyObject *mfem_DenseMatrix_GetDataArray(mfem::DenseMatrix const *self -SWIGINTERN void mfem_DenseMatrix_Print__SWIG_3(mfem::DenseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_DenseMatrix_Print__SWIG_1(mfem::DenseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3601,7 +3601,7 @@ SWIGINTERN void mfem_DenseMatrix_Print__SWIG_3(mfem::DenseMatrix *self,char cons self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_DenseMatrix_PrintT__SWIG_3(mfem::DenseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_DenseMatrix_PrintT__SWIG_1(mfem::DenseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3612,7 +3612,7 @@ SWIGINTERN void mfem_DenseMatrix_PrintT__SWIG_3(mfem::DenseMatrix *self,char con self -> PrintT(ofile); ofile.close(); } -SWIGINTERN void mfem_DenseMatrix_PrintMatlab__SWIG_2(mfem::DenseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_DenseMatrix_PrintMatlab__SWIG_1(mfem::DenseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -4028,7 +4028,7 @@ SWIGINTERN PyObject *_wrap_new_DenseMatrix(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -4038,30 +4038,36 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"h", (char *)"w", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_UseExternalData", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_UseExternalData", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_UseExternalData" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_UseExternalData" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -4089,7 +4095,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_UseExternalData(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DenseMatrix_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -4099,30 +4105,36 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Reset(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"h", (char *)"w", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Reset", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_Reset", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Reset" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Reset" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -4853,7 +4865,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___call__(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -4861,16 +4873,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___mul__(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___mul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix___mul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___mul__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix___mul__" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5467,7 +5483,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_MultTranspose(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5478,15 +5494,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_AddMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMult" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5494,7 +5515,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5528,7 +5549,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5539,15 +5560,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5555,7 +5581,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5589,7 +5615,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -5603,20 +5629,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMult_a", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_AddMult_a", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMult_a" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_AddMult_a" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMult_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -5624,7 +5656,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMult_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseMatrix_AddMult_a" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5658,7 +5690,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMult_a(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -5672,20 +5704,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddMultTranspose_a", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_AddMultTranspose_a", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -5693,7 +5731,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMultTranspose_a(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseMatrix_AddMultTranspose_a" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5782,7 +5820,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InnerProduct__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5790,15 +5828,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_LeftScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_LeftScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_LeftScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_LeftScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5832,7 +5874,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_LeftScaling(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5840,15 +5882,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_InvLeftScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_InvLeftScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_InvLeftScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_InvLeftScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5882,7 +5928,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvLeftScaling(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5890,15 +5936,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_RightScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_RightScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_RightScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_RightScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5932,7 +5982,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_RightScaling(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5940,15 +5990,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_InvRightScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_InvRightScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_InvRightScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_InvRightScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5982,7 +6036,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvRightScaling(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5990,15 +6044,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_SymmetricScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_SymmetricScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SymmetricScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_SymmetricScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6032,7 +6090,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SymmetricScaling(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_DenseMatrix_InvSymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_InvSymmetricScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6040,15 +6098,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_InvSymmetricScaling(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_InvSymmetricScaling", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_InvSymmetricScaling", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_InvSymmetricScaling" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_InvSymmetricScaling" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6568,7 +6630,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Set(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -6579,20 +6641,25 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Add(PyObject *SWIGUNUSEDPARM(self), PyObj int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Add", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_Add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Add" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Add" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_Add" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6768,7 +6835,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___iadd__(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -6776,16 +6843,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___isub__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix___isub__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___isub__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix___isub__" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6819,7 +6890,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___isub__(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -6827,16 +6898,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___imul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix___imul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___imul__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix___imul__" "', argument " "2"" of type '" "double""'"); } @@ -6907,7 +6982,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Neg(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_DenseMatrix_Norm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Norm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -6915,15 +6990,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Norm2(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Norm2", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Norm2", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Norm2" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Norm2" "', argument " "2"" of type '" "double *""'"); } @@ -7605,7 +7684,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Eigensystem(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7613,15 +7692,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_SingularValues", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_SingularValues", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_SingularValues" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_SingularValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7655,7 +7738,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SingularValues(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -7663,16 +7746,20 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Rank", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Rank", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Rank" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Rank" "', argument " "2"" of type '" "double""'"); } @@ -7703,26 +7790,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Rank(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_DenseMatrix_CalcSingularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CalcSingularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CalcSingularvalue", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_CalcSingularvalue", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CalcSingularvalue" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7750,7 +7841,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CalcSingularvalue(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double *arg2 = (double *) 0 ; @@ -7761,20 +7852,25 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_lambda", (char *)"vec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CalcEigenvalues", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_CalcEigenvalues", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CalcEigenvalues" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CalcEigenvalues" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_CalcEigenvalues" "', argument " "3"" of type '" "double *""'"); } @@ -7805,7 +7901,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CalcEigenvalues(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -7814,21 +7910,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"row", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetRow", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_GetRow", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetRow" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8091,7 +8192,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumn(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -8100,21 +8201,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetColumnReference(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", (char *)"col", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetColumnReference", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_GetColumnReference", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetColumnReference" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_GetColumnReference" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8654,7 +8760,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_SetCol(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8662,15 +8768,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetDiag", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GetDiag", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetDiag" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GetDiag" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8704,7 +8814,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8712,15 +8822,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"l", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Getl1Diag", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Getl1Diag", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Getl1Diag" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Getl1Diag" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8754,7 +8868,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Getl1Diag(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8762,15 +8876,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"l", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetRowSums", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GetRowSums", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetRowSums" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GetRowSums" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -9184,7 +9302,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Lump(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -9192,15 +9310,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GradToCurl", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GradToCurl", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GradToCurl" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GradToCurl" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -9234,7 +9356,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToCurl(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9242,15 +9364,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"div", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GradToDiv", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_GradToDiv", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GradToDiv" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_GradToDiv" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -9284,7 +9410,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GradToDiv(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -9294,15 +9420,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"row1", (char *)"row2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyRows", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyRows", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyRows" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyRows" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -9311,16 +9443,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -9348,7 +9480,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyRows(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -9358,15 +9490,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"col1", (char *)"col2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyCols", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyCols", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyCols" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyCols" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -9375,16 +9513,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyCols(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -9552,7 +9690,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMN__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -9562,15 +9700,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"row_offset", (char *)"col_offset", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyMNt", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyMNt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyMNt" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyMNt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -9579,16 +9723,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNt(PyObject *SWIGUNUSEDPARM(self), P } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -10126,7 +10270,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyMNDiag(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -10136,15 +10280,21 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"m", (char *)"n", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_CopyExceptMN", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix_CopyExceptMN", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_CopyExceptMN" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_CopyExceptMN" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -10153,16 +10303,16 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CopyExceptMN(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -10415,7 +10565,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddMatrix(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -10424,21 +10574,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AddToVector", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_AddToVector", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AddToVector" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_AddToVector" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10472,7 +10627,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AddToVector(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -10481,21 +10636,26 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_GetFromVector", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix_GetFromVector", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_GetFromVector" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseMatrix_GetFromVector" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -10529,7 +10689,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetFromVector(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -10537,15 +10697,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_AdjustDofDirection", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_AdjustDofDirection", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_AdjustDofDirection" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_AdjustDofDirection" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } @@ -10579,7 +10743,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_AdjustDofDirection(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_DenseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; double arg2 ; @@ -10587,15 +10751,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"eps", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix_Threshold", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrix_Threshold", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Threshold" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Threshold" "', argument " "2"" of type '" "double""'"); } @@ -10670,39 +10838,44 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_CheckFinite(PyObject *SWIGUNUSEDPARM(self SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -10740,39 +10913,42 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { try { - ((mfem::DenseMatrix const *)arg1)->Print(*arg2); + ((mfem::DenseMatrix const *)arg1)->PrintMatlab(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10806,21 +10982,51 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - ((mfem::DenseMatrix const *)arg1)->Print(); + ((mfem::DenseMatrix const *)arg1)->PrintT(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10838,45 +11044,39 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(se } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_TestInversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + PyObject *swig_obj[1] ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_TestInversion" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } { try { - ((mfem::DenseMatrix const *)arg1)->PrintMatlab(*arg2); + (arg1)->TestInversion(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10894,278 +11094,13 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - ((mfem::DenseMatrix const *)arg1)->PrintMatlab(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::DenseMatrix const *)arg1)->PrintT(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::DenseMatrix const *)arg1)->PrintT(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - ((mfem::DenseMatrix const *)arg1)->PrintT(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_TestInversion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_TestInversion" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - (arg1)->TestInversion(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix_MemoryUsage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; void *argp1 = 0 ; @@ -11206,69 +11141,37 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseMatrix_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::DenseMatrix const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Read" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { try { - result = (double *)((mfem::DenseMatrix const *)arg1)->Read(); + result = (double *)((mfem::DenseMatrix const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11292,48 +11195,6 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseMatrix_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseMatrix_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::Read(bool) const\n" - " mfem::DenseMatrix::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseMatrix_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; @@ -11375,69 +11236,37 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_HostRead(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseMatrix_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Write" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { try { - result = (double *)(arg1)->Write(); + result = (double *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11461,48 +11290,6 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseMatrix_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseMatrix_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::Write(bool)\n" - " mfem::DenseMatrix::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; @@ -11515,59 +11302,12 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_HostWrite(PyObject *SWIGUNUSEDPARM(self), swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - { - try { - result = (double *)(arg1)->HostWrite(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_HostWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { try { - result = (double *)(arg1)->ReadWrite(arg2); + result = (double *)(arg1)->HostWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11591,22 +11331,37 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseMatrix_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_ReadWrite" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseMatrix_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11630,48 +11385,6 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrix_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseMatrix_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseMatrix::ReadWrite(bool)\n" - " mfem::DenseMatrix::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseMatrix_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; @@ -11947,33 +11660,38 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Assign(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___getitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DenseMatrix___getitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___getitem__" "', argument " "1"" of type '" "mfem::DenseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12001,7 +11719,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___getitem__(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; int arg2 ; @@ -12011,27 +11729,33 @@ SWIGINTERN PyObject *_wrap_DenseMatrix___setitem__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrix___setitem__", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseMatrix___setitem__", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix___setitem__" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DenseMatrix___setitem__" "', argument " "4"" of type '" "double""'"); } @@ -12103,18 +11827,18 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); @@ -12125,64 +11849,17 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_DenseMatrix_Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_Print" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_DenseMatrix_Print__SWIG_3(arg1,(char const *)arg2); + mfem_DenseMatrix_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12216,34 +11893,15 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -12254,19 +11912,9 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -12276,27 +11924,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_Print__SWIG_3(self, argc, argv); + return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -12306,7 +11950,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_Print__SWIG_0(self, argc, argv); + return _wrap_DenseMatrix_Print__SWIG_1(self, argc, argv); } } } @@ -12316,26 +11960,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::DenseMatrix::Print(std::ostream &,int) const\n" - " mfem::DenseMatrix::Print(std::ostream &) const\n" - " mfem::DenseMatrix::Print() const\n" - " mfem::DenseMatrix::Print(char const *,int)\n" - " mfem::DenseMatrix::Print(char const *)\n"); + " mfem::DenseMatrix::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); @@ -12346,64 +11987,17 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_3(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintT" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_DenseMatrix_PrintT__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintT" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintT" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_DenseMatrix_PrintT__SWIG_3(arg1,(char const *)arg2); + mfem_DenseMatrix_PrintT__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12437,57 +12031,28 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_PrintT", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); + _v = 0; + } else { + _v = 1; + } + } if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -12497,27 +12062,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_3(self, argc, argv); + return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_PrintT__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -12527,7 +12088,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_DenseMatrix_PrintT__SWIG_0(self, argc, argv); + return _wrap_DenseMatrix_PrintT__SWIG_1(self, argc, argv); } } } @@ -12537,26 +12098,23 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintT(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintT'.\n" " Possible C/C++ prototypes are:\n" " mfem::DenseMatrix::PrintT(std::ostream &,int) const\n" - " mfem::DenseMatrix::PrintT(std::ostream &) const\n" - " mfem::DenseMatrix::PrintT() const\n" - " mfem::DenseMatrix::PrintT(char const *,int)\n" - " mfem::DenseMatrix::PrintT(char const *)\n"); + " mfem::DenseMatrix::PrintT(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); @@ -12567,64 +12125,17 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_DenseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = (mfem::DenseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::DenseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_DenseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2); + mfem_DenseMatrix_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12658,34 +12169,15 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg if (!(argc = SWIG_Python_UnpackTuple(args, "DenseMatrix_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_DenseMatrix_PrintMatlab__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -12700,7 +12192,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, 0); @@ -12709,6 +12201,9 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_DenseMatrix_PrintMatlab__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -12718,7 +12213,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_DenseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_DenseMatrix_PrintMatlab__SWIG_1(self, argc, argv); } } } @@ -12728,9 +12223,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrix_PrintMatlab(PyObject *self, PyObject *arg SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseMatrix_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::DenseMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::DenseMatrix::PrintMatlab() const\n" - " mfem::DenseMatrix::PrintMatlab(char const *,int)\n" - " mfem::DenseMatrix::PrintMatlab(char const *)\n"); + " mfem::DenseMatrix::PrintMatlab(char const *,int)\n"); return 0; } @@ -12746,21 +12239,27 @@ SWIGINTERN PyObject *DenseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_LinearSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; double *arg2 = (double *) 0 ; - double arg3 ; + double arg3 = (double) 1.e-9 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; double val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"X", (char *)"TOL", NULL + }; bool result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:LinearSolve", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); } @@ -12768,69 +12267,21 @@ SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearSolve" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)mfem::LinearSolve(*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseMatrix *arg1 = 0 ; - double *arg2 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LinearSolve" "', argument " "1"" of type '" "mfem::DenseMatrix &""'"); - } - arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearSolve" "', argument " "2"" of type '" "double *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LinearSolve" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - arg2 = reinterpret_cast< double * >(argp2); { try { - result = (bool)mfem::LinearSolve(*arg1,arg2); + result = (bool)mfem::LinearSolve(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12854,59 +12305,7 @@ SWIGINTERN PyObject *_wrap_LinearSolve__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_LinearSolve(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "LinearSolve", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_LinearSolve__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_LinearSolve__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LinearSolve'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::LinearSolve(mfem::DenseMatrix &,double *,double)\n" - " mfem::LinearSolve(mfem::DenseMatrix &,double *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12917,10 +12316,15 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"b", (char *)"c", (char *)"a", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMult" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12928,7 +12332,7 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -12936,7 +12340,7 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12970,7 +12374,7 @@ SWIGINTERN PyObject *_wrap_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -12984,15 +12388,21 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"alpha", (char *)"b", (char *)"c", (char *)"a", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMult_a", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13000,7 +12410,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13008,7 +12418,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13042,7 +12452,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13050,10 +12460,14 @@ SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"adja", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcAdjugate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcAdjugate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcAdjugate" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13061,7 +12475,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcAdjugate" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcAdjugate" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13095,7 +12509,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugate(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13103,10 +12517,14 @@ SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"adjat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcAdjugateTranspose", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcAdjugateTranspose", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcAdjugateTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13114,7 +12532,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcAdjugateTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcAdjugateTranspose" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13148,7 +12566,7 @@ SWIGINTERN PyObject *_wrap_CalcAdjugateTranspose(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13156,10 +12574,14 @@ SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"inva", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcInverse", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcInverse", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcInverse" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13167,7 +12589,7 @@ SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcInverse" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcInverse" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13201,7 +12623,7 @@ SWIGINTERN PyObject *_wrap_CalcInverse(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13209,10 +12631,14 @@ SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"inva", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcInverseTranspose", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcInverseTranspose", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcInverseTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13220,7 +12646,7 @@ SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcInverseTranspose" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcInverseTranspose" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13254,7 +12680,7 @@ SWIGINTERN PyObject *_wrap_CalcInverseTranspose(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -13262,10 +12688,14 @@ SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"J", (char *)"n", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CalcOrtho", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CalcOrtho", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CalcOrtho" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13273,7 +12703,7 @@ SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CalcOrtho" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CalcOrtho" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -13307,7 +12737,7 @@ SWIGINTERN PyObject *_wrap_CalcOrtho(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13315,10 +12745,14 @@ SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"aat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultAAt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MultAAt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultAAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13326,7 +12760,7 @@ SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultAAt" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -13360,7 +12794,7 @@ SWIGINTERN PyObject *_wrap_MultAAt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -13371,10 +12805,15 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"ADAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultADAt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultADAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13382,7 +12821,7 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13390,7 +12829,7 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultADAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13424,7 +12863,7 @@ SWIGINTERN PyObject *_wrap_MultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -13435,10 +12874,15 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"ADAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultADAt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMultADAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13446,7 +12890,7 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADAt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13454,7 +12898,7 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADAt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultADAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13488,7 +12932,7 @@ SWIGINTERN PyObject *_wrap_AddMultADAt(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13499,10 +12943,15 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"ABt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultABt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultABt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13510,7 +12959,7 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13518,7 +12967,7 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultABt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13552,7 +13001,7 @@ SWIGINTERN PyObject *_wrap_MultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -13566,10 +13015,16 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"B", (char *)"ADBt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultADBt", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:MultADBt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13577,7 +13032,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13585,7 +13040,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13593,7 +13048,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MultADBt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13627,7 +13082,7 @@ SWIGINTERN PyObject *_wrap_MultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13638,10 +13093,15 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"ABt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultABt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMultABt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13649,7 +13109,7 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultABt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13657,7 +13117,7 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultABt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13691,7 +13151,7 @@ SWIGINTERN PyObject *_wrap_AddMultABt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -13705,10 +13165,16 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"B", (char *)"ADBt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultADBt", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMultADBt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13716,7 +13182,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADBt" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13724,7 +13190,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADBt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13732,7 +13198,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultADBt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMultADBt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13766,7 +13232,7 @@ SWIGINTERN PyObject *_wrap_AddMultADBt(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13780,15 +13246,21 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"A", (char *)"B", (char *)"ABt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_ABt", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMult_a_ABt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_ABt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_ABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13796,7 +13268,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_ABt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_ABt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13804,7 +13276,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_ABt" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a_ABt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -13838,7 +13310,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_ABt(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13849,10 +13321,15 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"AtB", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultAtB", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultAtB", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultAtB" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13860,7 +13337,7 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAtB" "', argument " "1"" of type '" "mfem::DenseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::DenseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultAtB" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13868,7 +13345,7 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAtB" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultAtB" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13902,7 +13379,7 @@ SWIGINTERN PyObject *_wrap_MultAtB(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13913,15 +13390,20 @@ SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"A", (char *)"AAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_AAt", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMult_a_AAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_AAt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13929,7 +13411,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_AAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13963,7 +13445,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::DenseMatrix *arg2 = 0 ; @@ -13974,15 +13456,20 @@ SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"A", (char *)"AAt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mult_a_AAt", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mult_a_AAt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Mult_a_AAt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -13990,7 +13477,7 @@ SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_a_AAt" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult_a_AAt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14024,7 +13511,7 @@ SWIGINTERN PyObject *_wrap_Mult_a_AAt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -14032,10 +13519,14 @@ SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"vvt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultVVt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MultVVt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -14043,7 +13534,7 @@ SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultVVt" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -14077,7 +13568,7 @@ SWIGINTERN PyObject *_wrap_MultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -14088,10 +13579,15 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"w", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MultVWt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MultVWt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -14099,7 +13595,7 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14107,7 +13603,7 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MultVWt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14141,7 +13637,7 @@ SWIGINTERN PyObject *_wrap_MultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *arg } -SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -14152,10 +13648,15 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"w", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultVWt", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMultVWt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -14163,7 +13664,7 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultVWt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14171,7 +13672,7 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultVWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMultVWt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14205,7 +13706,7 @@ SWIGINTERN PyObject *_wrap_AddMultVWt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -14213,10 +13714,14 @@ SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMultVVt", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:AddMultVVt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AddMultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } @@ -14224,7 +13729,7 @@ SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMultVVt" "', argument " "1"" of type '" "mfem::Vector const &""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMultVVt" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -14258,7 +13763,7 @@ SWIGINTERN PyObject *_wrap_AddMultVVt(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::Vector *arg2 = 0 ; @@ -14272,15 +13777,21 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"v", (char *)"w", (char *)"VWt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_VWt", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AddMult_a_VWt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_VWt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_VWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14288,7 +13799,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_VWt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_VWt" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -14296,7 +13807,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_VWt" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AddMult_a_VWt" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -14330,7 +13841,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VWt(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; mfem::Vector *arg2 = 0 ; @@ -14341,15 +13852,20 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"v", (char *)"VVt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AddMult_a_VVt", 3, 3, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AddMult_a_VVt", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "AddMult_a_VVt" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AddMult_a_VVt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14357,7 +13873,7 @@ SWIGINTERN PyObject *_wrap_AddMult_a_VVt(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AddMult_a_VVt" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AddMult_a_VVt" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14608,34 +14124,42 @@ SWIGINTERN PyObject *_wrap_new_LUFactors(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; - double arg3 ; + double arg3 = (double) 0.0 ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"TOL", NULL + }; bool result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:LUFactors_Factor", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LUFactors_Factor" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "LUFactors_Factor" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { result = (bool)(arg1)->Factor(arg2,arg3); @@ -14662,134 +14186,30 @@ SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_LUFactors_Factor__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Factor" "', argument " "1"" of type '" "mfem::LUFactors *""'"); - } - arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (bool)(arg1)->Factor(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_LUFactors_Factor(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "LUFactors_Factor", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_LUFactors_Factor__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__LUFactors, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_LUFactors_Factor__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'LUFactors_Factor'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::LUFactors::Factor(int,double)\n" - " mfem::LUFactors::Factor(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; double result; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Det", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LUFactors_Det", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Det" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -14817,7 +14237,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_Det(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14827,27 +14247,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Mult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_Mult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Mult" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_Mult" "', argument " "4"" of type '" "double *""'"); } @@ -14878,7 +14304,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14888,27 +14314,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_LSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_LSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_LSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_LSolve" "', argument " "4"" of type '" "double *""'"); } @@ -14939,7 +14371,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_LSolve(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -14949,27 +14381,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_USolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_USolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_USolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_USolve" "', argument " "4"" of type '" "double *""'"); } @@ -15000,7 +14438,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_USolve(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -15010,27 +14448,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_Solve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_Solve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_Solve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_Solve" "', argument " "4"" of type '" "double *""'"); } @@ -15061,7 +14505,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_Solve(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -15071,27 +14515,33 @@ SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_RightSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:LUFactors_RightSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_RightSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_RightSolve" "', argument " "4"" of type '" "double *""'"); } @@ -15122,7 +14572,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_RightSolve(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -15131,21 +14581,26 @@ SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"X", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_GetInverseMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LUFactors_GetInverseMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_GetInverseMatrix" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LUFactors_GetInverseMatrix" "', argument " "3"" of type '" "double *""'"); } @@ -15176,7 +14631,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -15190,38 +14645,46 @@ SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyO int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"m", (char *)"n", (char *)"r", (char *)"A21", (char *)"X1", (char *)"X2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_SubMult", 6, 6, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:LUFactors_SubMult", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_SubMult" "', argument " "4"" of type '" "double const *""'"); } arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_SubMult" "', argument " "5"" of type '" "double const *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_SubMult" "', argument " "6"" of type '" "double *""'"); } @@ -15252,7 +14715,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_SubMult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -15268,37 +14731,45 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"A12", (char *)"A21", (char *)"A22", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_BlockFactor", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:LUFactors_BlockFactor", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_BlockFactor" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "LUFactors_BlockFactor" "', argument " "4"" of type '" "double *""'"); } arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_BlockFactor" "', argument " "5"" of type '" "double *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_BlockFactor" "', argument " "6"" of type '" "double *""'"); } @@ -15329,7 +14800,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockFactor(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -15346,43 +14817,52 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(sel int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"r", (char *)"L21", (char *)"B1", (char *)"B2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_BlockForwSolve", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:LUFactors_BlockForwSolve", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_BlockForwSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_BlockForwSolve" "', argument " "5"" of type '" "double const *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_BlockForwSolve" "', argument " "6"" of type '" "double *""'"); } arg6 = reinterpret_cast< double * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_double, 0 | 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "LUFactors_BlockForwSolve" "', argument " "7"" of type '" "double *""'"); } @@ -15413,7 +14893,7 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockForwSolve(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_LUFactors_BlockBackSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LUFactors_BlockBackSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LUFactors *arg1 = (mfem::LUFactors *) 0 ; int arg2 ; @@ -15430,43 +14910,52 @@ SWIGINTERN PyObject *_wrap_LUFactors_BlockBackSolve(PyObject *SWIGUNUSEDPARM(sel int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"n", (char *)"r", (char *)"U12", (char *)"X2", (char *)"Y1", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LUFactors_BlockBackSolve", 7, 7, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:LUFactors_BlockBackSolve", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LUFactors, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LUFactors_BlockBackSolve" "', argument " "1"" of type '" "mfem::LUFactors const *""'"); } arg1 = reinterpret_cast< mfem::LUFactors * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_double, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "LUFactors_BlockBackSolve" "', argument " "5"" of type '" "double const *""'"); } arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_double, 0 | 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "LUFactors_BlockBackSolve" "', argument " "6"" of type '" "double const *""'"); } arg6 = reinterpret_cast< double * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_double, 0 | 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "LUFactors_BlockBackSolve" "', argument " "7"" of type '" "double *""'"); } @@ -15867,7 +15356,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_Factor(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_DenseMatrixInverse_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixInverse_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixInverse *arg1 = (mfem::DenseMatrixInverse *) 0 ; mfem::Operator *arg2 = 0 ; @@ -15875,15 +15364,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_SetOperator(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixInverse_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixInverse_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixInverse_SetOperator" "', argument " "1"" of type '" "mfem::DenseMatrixInverse *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixInverse * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrixInverse_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -16155,7 +15648,7 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_Mult(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_DenseMatrixInverse_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixInverse_GetInverseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixInverse *arg1 = (mfem::DenseMatrixInverse *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -16163,15 +15656,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrixInverse_GetInverseMatrix(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Ainv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixInverse_GetInverseMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixInverse_GetInverseMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixInverse, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixInverse_GetInverseMatrix" "', argument " "1"" of type '" "mfem::DenseMatrixInverse const *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixInverse * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrixInverse_GetInverseMatrix" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -16578,26 +16075,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvectors(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixEigensystem *arg1 = (mfem::DenseMatrixEigensystem *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixEigensystem_Eigenvalue", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixEigensystem_Eigenvalue", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixEigensystem_Eigenvalue" "', argument " "1"" of type '" "mfem::DenseMatrixEigensystem *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixEigensystem * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16625,26 +16126,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvalue(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixEigensystem_Eigenvector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixEigensystem *arg1 = (mfem::DenseMatrixEigensystem *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixEigensystem_Eigenvector", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixEigensystem_Eigenvector", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixEigensystem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixEigensystem_Eigenvector" "', argument " "1"" of type '" "mfem::DenseMatrixEigensystem *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixEigensystem * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -16861,7 +16366,7 @@ SWIGINTERN PyObject *_wrap_new_DenseMatrixSVD(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixSVD *arg1 = (mfem::DenseMatrixSVD *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -16869,15 +16374,19 @@ SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Eval(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixSVD_Eval", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixSVD_Eval", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixSVD_Eval" "', argument " "1"" of type '" "mfem::DenseMatrixSVD *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixSVD * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseMatrixSVD_Eval" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); } @@ -16952,26 +16461,30 @@ SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Singularvalues(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Singularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseMatrixSVD_Singularvalue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseMatrixSVD *arg1 = (mfem::DenseMatrixSVD *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DenseMatrixSVD_Singularvalue", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseMatrixSVD_Singularvalue", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseMatrixSVD, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseMatrixSVD_Singularvalue" "', argument " "1"" of type '" "mfem::DenseMatrixSVD *""'"); } arg1 = reinterpret_cast< mfem::DenseMatrixSVD * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -17403,7 +16916,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_TotalSize(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; int arg2 ; @@ -17411,31 +16924,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), P int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"k", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_SetSize", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseTensor_SetSize", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_SetSize" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -17463,7 +16982,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_SetSize(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; double *arg2 = (double *) 0 ; @@ -17474,36 +16993,43 @@ SWIGINTERN PyObject *_wrap_DenseTensor_UseExternalData(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ext_data", (char *)"i", (char *)"j", (char *)"k", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_UseExternalData", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DenseTensor_UseExternalData", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_UseExternalData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_UseExternalData" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { try { @@ -17879,26 +17405,30 @@ SWIGINTERN PyObject *_wrap_DenseTensor___call__(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"k", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_GetData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseTensor_GetData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_GetData" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -18154,7 +17684,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_GetMemory(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; mfem::Table *arg2 = 0 ; @@ -18168,15 +17698,21 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"elem_dof", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_AddMult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DenseTensor_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_AddMult" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); } @@ -18184,7 +17720,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "2"" of type '" "mfem::Table const &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -18192,7 +17728,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor_AddMult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DenseTensor_AddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DenseTensor_AddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -18307,69 +17843,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_MemoryUsage(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseTensor_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::DenseTensor const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Read" "', argument " "1"" of type '" "mfem::DenseTensor const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)((mfem::DenseTensor const *)arg1)->Read(); + result = (double *)((mfem::DenseTensor const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18393,48 +17897,6 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_DenseTensor_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseTensor_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseTensor_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::Read(bool) const\n" - " mfem::DenseTensor::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseTensor_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; @@ -18476,69 +17938,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_HostRead(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseTensor_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Write" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)(arg1)->Write(); + result = (double *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18562,48 +17992,6 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DenseTensor_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseTensor_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseTensor_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::Write(bool)\n" - " mfem::DenseTensor::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseTensor_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; @@ -18645,69 +18033,37 @@ SWIGINTERN PyObject *_wrap_DenseTensor_HostWrite(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:DenseTensor_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->ReadWrite(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_ReadWrite" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18731,48 +18087,6 @@ SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_DenseTensor_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "DenseTensor_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_DenseTensor_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__DenseTensor, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_DenseTensor_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DenseTensor_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::DenseTensor::ReadWrite(bool)\n" - " mfem::DenseTensor::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_DenseTensor_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; @@ -18854,7 +18168,7 @@ SWIGINTERN PyObject *_wrap_delete_DenseTensor(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_DenseTensor_Assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor_Assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; double arg2 ; @@ -18862,15 +18176,19 @@ SWIGINTERN PyObject *_wrap_DenseTensor_Assign(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor_Assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DenseTensor_Assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor_Assign" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DenseTensor_Assign" "', argument " "2"" of type '" "double""'"); } @@ -19083,7 +18401,7 @@ SWIGINTERN PyObject *_wrap_DenseTensor___getitem__(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_DenseTensor___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DenseTensor___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DenseTensor *arg1 = (mfem::DenseTensor *) 0 ; int arg2 ; @@ -19094,33 +18412,40 @@ SWIGINTERN PyObject *_wrap_DenseTensor___setitem__(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; double val5 ; int ecode5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"k", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DenseTensor___setitem__", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:DenseTensor___setitem__", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DenseTensor, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DenseTensor___setitem__" "', argument " "1"" of type '" "mfem::DenseTensor *""'"); } arg1 = reinterpret_cast< mfem::DenseTensor * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_double(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DenseTensor___setitem__" "', argument " "5"" of type '" "double""'"); } @@ -19214,8 +18539,8 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix(DenseMatrix mat, char ch)\n" "new_DenseMatrix(double * d, int h, int w) -> DenseMatrix\n" ""}, - { "DenseMatrix_UseExternalData", _wrap_DenseMatrix_UseExternalData, METH_VARARGS, "DenseMatrix_UseExternalData(DenseMatrix self, double * d, int h, int w)"}, - { "DenseMatrix_Reset", _wrap_DenseMatrix_Reset, METH_VARARGS, "DenseMatrix_Reset(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_UseExternalData, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_UseExternalData(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_Reset", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Reset, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Reset(DenseMatrix self, double * d, int h, int w)"}, { "DenseMatrix_ClearExternalData", _wrap_DenseMatrix_ClearExternalData, METH_O, "DenseMatrix_ClearExternalData(DenseMatrix self)"}, { "DenseMatrix_Clear", _wrap_DenseMatrix_Clear, METH_O, "DenseMatrix_Clear(DenseMatrix self)"}, { "DenseMatrix_Size", _wrap_DenseMatrix_Size, METH_O, "DenseMatrix_Size(DenseMatrix self) -> int"}, @@ -19234,7 +18559,7 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix___call__(DenseMatrix self, int i, int j) -> double\n" "DenseMatrix___call__(DenseMatrix self, int i, int j) -> double const &\n" ""}, - { "DenseMatrix___mul__", _wrap_DenseMatrix___mul__, METH_VARARGS, "DenseMatrix___mul__(DenseMatrix self, DenseMatrix m) -> double"}, + { "DenseMatrix___mul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___mul__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___mul__(DenseMatrix self, DenseMatrix m) -> double"}, { "DenseMatrix_Trace", _wrap_DenseMatrix_Trace, METH_O, "DenseMatrix_Trace(DenseMatrix self) -> double"}, { "DenseMatrix_Elem", _wrap_DenseMatrix_Elem, METH_VARARGS, "\n" "DenseMatrix_Elem(DenseMatrix self, int i, int j) -> double\n" @@ -19248,16 +18573,16 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_MultTranspose(DenseMatrix self, double const * x, double * y)\n" "DenseMatrix_MultTranspose(DenseMatrix self, Vector x, Vector y)\n" ""}, - { "DenseMatrix_AddMult", _wrap_DenseMatrix_AddMult, METH_VARARGS, "DenseMatrix_AddMult(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose", _wrap_DenseMatrix_AddMultTranspose, METH_VARARGS, "DenseMatrix_AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMult_a", _wrap_DenseMatrix_AddMult_a, METH_VARARGS, "DenseMatrix_AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose_a", _wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS, "DenseMatrix_AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_LeftScaling", _wrap_DenseMatrix_LeftScaling, METH_VARARGS, "DenseMatrix_LeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvLeftScaling", _wrap_DenseMatrix_InvLeftScaling, METH_VARARGS, "DenseMatrix_InvLeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_RightScaling", _wrap_DenseMatrix_RightScaling, METH_VARARGS, "DenseMatrix_RightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvRightScaling", _wrap_DenseMatrix_InvRightScaling, METH_VARARGS, "DenseMatrix_InvRightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_SymmetricScaling", _wrap_DenseMatrix_SymmetricScaling, METH_VARARGS, "DenseMatrix_SymmetricScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvSymmetricScaling", _wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS, "DenseMatrix_InvSymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMult(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMult_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult_a, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_LeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_LeftScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_LeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvLeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvLeftScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_InvLeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_RightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_RightScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_RightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvRightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvRightScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_InvRightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_SymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SymmetricScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_SymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvSymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_InvSymmetricScaling(DenseMatrix self, Vector s)"}, { "DenseMatrix_InnerProduct", _wrap_DenseMatrix_InnerProduct, METH_VARARGS, "\n" "DenseMatrix_InnerProduct(DenseMatrix self, double const * x, double const * y) -> double\n" "DenseMatrix_InnerProduct(DenseMatrix self, Vector x, Vector y) -> double\n" @@ -19271,15 +18596,15 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_Set(DenseMatrix self, double alpha, double const * A)\n" "DenseMatrix_Set(DenseMatrix self, double alpha, DenseMatrix A)\n" ""}, - { "DenseMatrix_Add", _wrap_DenseMatrix_Add, METH_VARARGS, "DenseMatrix_Add(DenseMatrix self, double const c, DenseMatrix A)"}, + { "DenseMatrix_Add", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Add, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Add(DenseMatrix self, double const c, DenseMatrix A)"}, { "DenseMatrix___iadd__", _wrap_DenseMatrix___iadd__, METH_VARARGS, "\n" "DenseMatrix___iadd__(DenseMatrix self, double const * m) -> DenseMatrix\n" "DenseMatrix___iadd__(DenseMatrix self, DenseMatrix m) -> DenseMatrix\n" ""}, - { "DenseMatrix___isub__", _wrap_DenseMatrix___isub__, METH_VARARGS, "DenseMatrix___isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, - { "DenseMatrix___imul__", _wrap_DenseMatrix___imul__, METH_VARARGS, "DenseMatrix___imul__(DenseMatrix self, double c) -> DenseMatrix"}, + { "DenseMatrix___isub__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___isub__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, + { "DenseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___imul__(DenseMatrix self, double c) -> DenseMatrix"}, { "DenseMatrix_Neg", _wrap_DenseMatrix_Neg, METH_O, "DenseMatrix_Neg(DenseMatrix self)"}, - { "DenseMatrix_Norm2", _wrap_DenseMatrix_Norm2, METH_VARARGS, "DenseMatrix_Norm2(DenseMatrix self, double * v)"}, + { "DenseMatrix_Norm2", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Norm2, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Norm2(DenseMatrix self, double * v)"}, { "DenseMatrix_MaxMaxNorm", _wrap_DenseMatrix_MaxMaxNorm, METH_O, "DenseMatrix_MaxMaxNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm", _wrap_DenseMatrix_FNorm, METH_O, "DenseMatrix_FNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm2", _wrap_DenseMatrix_FNorm2, METH_O, "DenseMatrix_FNorm2(DenseMatrix self) -> double"}, @@ -19293,17 +18618,17 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_Eigensystem(DenseMatrix self, Vector ev, DenseMatrix evect)\n" "DenseMatrix_Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" ""}, - { "DenseMatrix_SingularValues", _wrap_DenseMatrix_SingularValues, METH_VARARGS, "DenseMatrix_SingularValues(DenseMatrix self, Vector sv)"}, - { "DenseMatrix_Rank", _wrap_DenseMatrix_Rank, METH_VARARGS, "DenseMatrix_Rank(DenseMatrix self, double tol) -> int"}, - { "DenseMatrix_CalcSingularvalue", _wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS, "DenseMatrix_CalcSingularvalue(DenseMatrix self, int const i) -> double"}, - { "DenseMatrix_CalcEigenvalues", _wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS, "DenseMatrix_CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, - { "DenseMatrix_GetRow", _wrap_DenseMatrix_GetRow, METH_VARARGS, "DenseMatrix_GetRow(DenseMatrix self, int r, Vector row)"}, + { "DenseMatrix_SingularValues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SingularValues, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_SingularValues(DenseMatrix self, Vector sv)"}, + { "DenseMatrix_Rank", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Rank, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Rank(DenseMatrix self, double tol) -> int"}, + { "DenseMatrix_CalcSingularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CalcSingularvalue(DenseMatrix self, int const i) -> double"}, + { "DenseMatrix_CalcEigenvalues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, + { "DenseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetRow(DenseMatrix self, int r, Vector row)"}, { "DenseMatrix_GetColumn", _wrap_DenseMatrix_GetColumn, METH_VARARGS, "\n" "DenseMatrix_GetColumn(DenseMatrix self, int c, Vector col)\n" "DenseMatrix_GetColumn(DenseMatrix self, int col) -> double\n" "DenseMatrix_GetColumn(DenseMatrix self, int col) -> double const *\n" ""}, - { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "DenseMatrix_GetColumnReference(DenseMatrix self, int c, Vector col)"}, + { "DenseMatrix_GetColumnReference", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetColumnReference, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetColumnReference(DenseMatrix self, int c, Vector col)"}, { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" "DenseMatrix_SetRow(DenseMatrix self, int r, double const * row)\n" "DenseMatrix_SetRow(DenseMatrix self, int r, Vector row)\n" @@ -19314,9 +18639,9 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_SetCol(DenseMatrix self, int c, Vector col)\n" "DenseMatrix_SetCol(DenseMatrix self, int col, double value)\n" ""}, - { "DenseMatrix_GetDiag", _wrap_DenseMatrix_GetDiag, METH_VARARGS, "DenseMatrix_GetDiag(DenseMatrix self, Vector d)"}, - { "DenseMatrix_Getl1Diag", _wrap_DenseMatrix_Getl1Diag, METH_VARARGS, "DenseMatrix_Getl1Diag(DenseMatrix self, Vector l)"}, - { "DenseMatrix_GetRowSums", _wrap_DenseMatrix_GetRowSums, METH_VARARGS, "DenseMatrix_GetRowSums(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetDiag(DenseMatrix self, Vector d)"}, + { "DenseMatrix_Getl1Diag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Getl1Diag, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Getl1Diag(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetRowSums(DenseMatrix self, Vector l)"}, { "DenseMatrix_Diag", _wrap_DenseMatrix_Diag, METH_VARARGS, "\n" "DenseMatrix_Diag(DenseMatrix self, double c, int n)\n" "DenseMatrix_Diag(DenseMatrix self, double * diag, int n)\n" @@ -19327,11 +18652,11 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_Symmetrize", _wrap_DenseMatrix_Symmetrize, METH_O, "DenseMatrix_Symmetrize(DenseMatrix self)"}, { "DenseMatrix_Lump", _wrap_DenseMatrix_Lump, METH_O, "DenseMatrix_Lump(DenseMatrix self)"}, - { "DenseMatrix_GradToCurl", _wrap_DenseMatrix_GradToCurl, METH_VARARGS, "DenseMatrix_GradToCurl(DenseMatrix self, DenseMatrix curl)"}, - { "DenseMatrix_GradToDiv", _wrap_DenseMatrix_GradToDiv, METH_VARARGS, "DenseMatrix_GradToDiv(DenseMatrix self, Vector div)"}, - { "DenseMatrix_CopyRows", _wrap_DenseMatrix_CopyRows, METH_VARARGS, "DenseMatrix_CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, - { "DenseMatrix_CopyCols", _wrap_DenseMatrix_CopyCols, METH_VARARGS, "DenseMatrix_CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, - { "DenseMatrix_CopyMNt", _wrap_DenseMatrix_CopyMNt, METH_VARARGS, "DenseMatrix_CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, + { "DenseMatrix_GradToCurl", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToCurl, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GradToCurl(DenseMatrix self, DenseMatrix curl)"}, + { "DenseMatrix_GradToDiv", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToDiv, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GradToDiv(DenseMatrix self, Vector div)"}, + { "DenseMatrix_CopyRows", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyRows, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, + { "DenseMatrix_CopyCols", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyCols, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, + { "DenseMatrix_CopyMNt", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyMNt, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, { "DenseMatrix_CopyMN", _wrap_DenseMatrix_CopyMN, METH_VARARGS, "\n" "DenseMatrix_CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco)\n" "DenseMatrix_CopyMN(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)\n" @@ -19341,23 +18666,23 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_CopyMNDiag(DenseMatrix self, double c, int n, int row_offset, int col_offset)\n" "DenseMatrix_CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset)\n" ""}, - { "DenseMatrix_CopyExceptMN", _wrap_DenseMatrix_CopyExceptMN, METH_VARARGS, "DenseMatrix_CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, + { "DenseMatrix_CopyExceptMN", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyExceptMN, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, { "DenseMatrix_AddMatrix", _wrap_DenseMatrix_AddMatrix, METH_VARARGS, "\n" "DenseMatrix_AddMatrix(DenseMatrix self, DenseMatrix A, int ro, int co)\n" "DenseMatrix_AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co)\n" ""}, - { "DenseMatrix_AddToVector", _wrap_DenseMatrix_AddToVector, METH_VARARGS, "DenseMatrix_AddToVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_GetFromVector", _wrap_DenseMatrix_GetFromVector, METH_VARARGS, "DenseMatrix_GetFromVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_AdjustDofDirection", _wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS, "DenseMatrix_AdjustDofDirection(DenseMatrix self, intArray dofs)"}, - { "DenseMatrix_Threshold", _wrap_DenseMatrix_Threshold, METH_VARARGS, "DenseMatrix_Threshold(DenseMatrix self, double eps)"}, + { "DenseMatrix_AddToVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddToVector, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AddToVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_GetFromVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetFromVector, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_GetFromVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_AdjustDofDirection", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_AdjustDofDirection(DenseMatrix self, intArray dofs)"}, + { "DenseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Threshold(DenseMatrix self, double eps)"}, { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "DenseMatrix_CheckFinite(DenseMatrix self) -> int"}, { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "DenseMatrix_TestInversion(DenseMatrix self)"}, { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "DenseMatrix_MemoryUsage(DenseMatrix self) -> long"}, - { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "DenseMatrix_Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_Read", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Read, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Read(DenseMatrix self, bool on_dev=True) -> double const *"}, { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "DenseMatrix_HostRead(DenseMatrix self) -> double const *"}, - { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "DenseMatrix_Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_Write", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Write, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_Write(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "DenseMatrix_HostWrite(DenseMatrix self) -> double *"}, - { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "DenseMatrix_ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_ReadWrite, METH_VARARGS|METH_KEYWORDS, "DenseMatrix_ReadWrite(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "DenseMatrix_HostReadWrite(DenseMatrix self) -> double *"}, { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" @@ -19365,8 +18690,8 @@ static PyMethodDef SwigMethods[] = { "DenseMatrix_Assign(DenseMatrix self, DenseMatrix m)\n" "DenseMatrix_Assign(DenseMatrix self, PyObject * numpymat)\n" ""}, - { "DenseMatrix___getitem__", _wrap_DenseMatrix___getitem__, METH_VARARGS, "DenseMatrix___getitem__(DenseMatrix self, int const i, int const j) -> double const"}, - { "DenseMatrix___setitem__", _wrap_DenseMatrix___setitem__, METH_VARARGS, "DenseMatrix___setitem__(DenseMatrix self, int i, int j, double const v)"}, + { "DenseMatrix___getitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___getitem__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___getitem__(DenseMatrix self, int const i, int const j) -> double const"}, + { "DenseMatrix___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___setitem__, METH_VARARGS|METH_KEYWORDS, "DenseMatrix___setitem__(DenseMatrix self, int i, int j, double const v)"}, { "DenseMatrix_GetDataArray", _wrap_DenseMatrix_GetDataArray, METH_O, "DenseMatrix_GetDataArray(DenseMatrix self) -> PyObject *"}, { "DenseMatrix_Print", _wrap_DenseMatrix_Print, METH_VARARGS, "\n" "DenseMatrix_Print(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -19382,31 +18707,31 @@ static PyMethodDef SwigMethods[] = { ""}, { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, - { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, - { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, - { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, - { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, - { "CalcInverseTranspose", _wrap_CalcInverseTranspose, METH_VARARGS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, - { "CalcOrtho", _wrap_CalcOrtho, METH_VARARGS, "CalcOrtho(DenseMatrix J, Vector n)"}, - { "MultAAt", _wrap_MultAAt, METH_VARARGS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, - { "MultADAt", _wrap_MultADAt, METH_VARARGS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "AddMultADAt", _wrap_AddMultADAt, METH_VARARGS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "MultABt", _wrap_MultABt, METH_VARARGS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultADBt", _wrap_MultADBt, METH_VARARGS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMultABt", _wrap_AddMultABt, METH_VARARGS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "AddMultADBt", _wrap_AddMultADBt, METH_VARARGS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMult_a_ABt", _wrap_AddMult_a_ABt, METH_VARARGS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultAtB", _wrap_MultAtB, METH_VARARGS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, - { "AddMult_a_AAt", _wrap_AddMult_a_AAt, METH_VARARGS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "Mult_a_AAt", _wrap_Mult_a_AAt, METH_VARARGS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "MultVVt", _wrap_MultVVt, METH_VARARGS, "MultVVt(Vector v, DenseMatrix vvt)"}, - { "MultVWt", _wrap_MultVWt, METH_VARARGS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVWt", _wrap_AddMultVWt, METH_VARARGS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVVt", _wrap_AddMultVVt, METH_VARARGS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, - { "AddMult_a_VWt", _wrap_AddMult_a_VWt, METH_VARARGS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMult_a_VVt", _wrap_AddMult_a_VVt, METH_VARARGS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, + { "LinearSolve", (PyCFunction)(void(*)(void))_wrap_LinearSolve, METH_VARARGS|METH_KEYWORDS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, + { "AddMult", (PyCFunction)(void(*)(void))_wrap_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", (PyCFunction)(void(*)(void))_wrap_AddMult_a, METH_VARARGS|METH_KEYWORDS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "CalcAdjugate", (PyCFunction)(void(*)(void))_wrap_CalcAdjugate, METH_VARARGS|METH_KEYWORDS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, + { "CalcAdjugateTranspose", (PyCFunction)(void(*)(void))_wrap_CalcAdjugateTranspose, METH_VARARGS|METH_KEYWORDS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, + { "CalcInverse", (PyCFunction)(void(*)(void))_wrap_CalcInverse, METH_VARARGS|METH_KEYWORDS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, + { "CalcInverseTranspose", (PyCFunction)(void(*)(void))_wrap_CalcInverseTranspose, METH_VARARGS|METH_KEYWORDS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, + { "CalcOrtho", (PyCFunction)(void(*)(void))_wrap_CalcOrtho, METH_VARARGS|METH_KEYWORDS, "CalcOrtho(DenseMatrix J, Vector n)"}, + { "MultAAt", (PyCFunction)(void(*)(void))_wrap_MultAAt, METH_VARARGS|METH_KEYWORDS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, + { "MultADAt", (PyCFunction)(void(*)(void))_wrap_MultADAt, METH_VARARGS|METH_KEYWORDS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "AddMultADAt", (PyCFunction)(void(*)(void))_wrap_AddMultADAt, METH_VARARGS|METH_KEYWORDS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "MultABt", (PyCFunction)(void(*)(void))_wrap_MultABt, METH_VARARGS|METH_KEYWORDS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultADBt", (PyCFunction)(void(*)(void))_wrap_MultADBt, METH_VARARGS|METH_KEYWORDS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMultABt", (PyCFunction)(void(*)(void))_wrap_AddMultABt, METH_VARARGS|METH_KEYWORDS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "AddMultADBt", (PyCFunction)(void(*)(void))_wrap_AddMultADBt, METH_VARARGS|METH_KEYWORDS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMult_a_ABt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_ABt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultAtB", (PyCFunction)(void(*)(void))_wrap_MultAtB, METH_VARARGS|METH_KEYWORDS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, + { "AddMult_a_AAt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_AAt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "Mult_a_AAt", (PyCFunction)(void(*)(void))_wrap_Mult_a_AAt, METH_VARARGS|METH_KEYWORDS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "MultVVt", (PyCFunction)(void(*)(void))_wrap_MultVVt, METH_VARARGS|METH_KEYWORDS, "MultVVt(Vector v, DenseMatrix vvt)"}, + { "MultVWt", (PyCFunction)(void(*)(void))_wrap_MultVWt, METH_VARARGS|METH_KEYWORDS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVWt", (PyCFunction)(void(*)(void))_wrap_AddMultVWt, METH_VARARGS|METH_KEYWORDS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVVt", (PyCFunction)(void(*)(void))_wrap_AddMultVVt, METH_VARARGS|METH_KEYWORDS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, + { "AddMult_a_VWt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VWt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMult_a_VVt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VVt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, { "LUFactors_data_set", _wrap_LUFactors_data_set, METH_VARARGS, "LUFactors_data_set(LUFactors self, double * data)"}, { "LUFactors_data_get", _wrap_LUFactors_data_get, METH_O, "LUFactors_data_get(LUFactors self) -> double *"}, { "LUFactors_ipiv_set", _wrap_LUFactors_ipiv_set, METH_VARARGS, "LUFactors_ipiv_set(LUFactors self, int * ipiv)"}, @@ -19415,18 +18740,18 @@ static PyMethodDef SwigMethods[] = { "LUFactors()\n" "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" ""}, - { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "LUFactors_Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, - { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "LUFactors_Det(LUFactors self, int m) -> double"}, - { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "LUFactors_Mult(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LUFactors_LSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "LUFactors_USolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "LUFactors_Solve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "LUFactors_RightSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "LUFactors_GetInverseMatrix(LUFactors self, int m, double * X)"}, - { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, - { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "LUFactors_BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, - { "LUFactors_BlockForwSolve", _wrap_LUFactors_BlockForwSolve, METH_VARARGS, "LUFactors_BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, - { "LUFactors_BlockBackSolve", _wrap_LUFactors_BlockBackSolve, METH_VARARGS, "LUFactors_BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, + { "LUFactors_Factor", (PyCFunction)(void(*)(void))_wrap_LUFactors_Factor, METH_VARARGS|METH_KEYWORDS, "LUFactors_Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, + { "LUFactors_Det", (PyCFunction)(void(*)(void))_wrap_LUFactors_Det, METH_VARARGS|METH_KEYWORDS, "LUFactors_Det(LUFactors self, int m) -> double"}, + { "LUFactors_Mult", (PyCFunction)(void(*)(void))_wrap_LUFactors_Mult, METH_VARARGS|METH_KEYWORDS, "LUFactors_Mult(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_LSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_LSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_LSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_USolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_USolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_USolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_Solve", (PyCFunction)(void(*)(void))_wrap_LUFactors_Solve, METH_VARARGS|METH_KEYWORDS, "LUFactors_Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_RightSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_RightSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_LUFactors_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "LUFactors_GetInverseMatrix(LUFactors self, int m, double * X)"}, + { "LUFactors_SubMult", (PyCFunction)(void(*)(void))_wrap_LUFactors_SubMult, METH_VARARGS|METH_KEYWORDS, "LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, + { "LUFactors_BlockFactor", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockFactor, METH_VARARGS|METH_KEYWORDS, "LUFactors_BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, + { "LUFactors_BlockForwSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockForwSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, + { "LUFactors_BlockBackSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockBackSolve, METH_VARARGS|METH_KEYWORDS, "LUFactors_BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, { "delete_LUFactors", _wrap_delete_LUFactors, METH_O, "delete_LUFactors(LUFactors self)"}, { "LUFactors_swigregister", LUFactors_swigregister, METH_O, NULL}, { "LUFactors_swiginit", LUFactors_swiginit, METH_VARARGS, NULL}, @@ -19440,13 +18765,13 @@ static PyMethodDef SwigMethods[] = { "DenseMatrixInverse_Factor(DenseMatrixInverse self)\n" "DenseMatrixInverse_Factor(DenseMatrixInverse self, DenseMatrix mat)\n" ""}, - { "DenseMatrixInverse_SetOperator", _wrap_DenseMatrixInverse_SetOperator, METH_VARARGS, "DenseMatrixInverse_SetOperator(DenseMatrixInverse self, Operator op)"}, + { "DenseMatrixInverse_SetOperator", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_SetOperator, METH_VARARGS|METH_KEYWORDS, "DenseMatrixInverse_SetOperator(DenseMatrixInverse self, Operator op)"}, { "DenseMatrixInverse_Mult", _wrap_DenseMatrixInverse_Mult, METH_VARARGS, "\n" "DenseMatrixInverse_Mult(DenseMatrixInverse self, Vector x, Vector y)\n" "DenseMatrixInverse_Mult(DenseMatrixInverse self, DenseMatrix B, DenseMatrix X)\n" "DenseMatrixInverse_Mult(DenseMatrixInverse self, DenseMatrix X)\n" ""}, - { "DenseMatrixInverse_GetInverseMatrix", _wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS, "DenseMatrixInverse_GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, + { "DenseMatrixInverse_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "DenseMatrixInverse_GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, { "DenseMatrixInverse_Det", _wrap_DenseMatrixInverse_Det, METH_O, "DenseMatrixInverse_Det(DenseMatrixInverse self) -> double"}, { "DenseMatrixInverse_TestInversion", _wrap_DenseMatrixInverse_TestInversion, METH_O, "DenseMatrixInverse_TestInversion(DenseMatrixInverse self)"}, { "delete_DenseMatrixInverse", _wrap_delete_DenseMatrixInverse, METH_O, "delete_DenseMatrixInverse(DenseMatrixInverse self)"}, @@ -19459,8 +18784,8 @@ static PyMethodDef SwigMethods[] = { { "DenseMatrixEigensystem_Eval", _wrap_DenseMatrixEigensystem_Eval, METH_O, "DenseMatrixEigensystem_Eval(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_Eigenvalues", _wrap_DenseMatrixEigensystem_Eigenvalues, METH_O, "DenseMatrixEigensystem_Eigenvalues(DenseMatrixEigensystem self) -> Vector"}, { "DenseMatrixEigensystem_Eigenvectors", _wrap_DenseMatrixEigensystem_Eigenvectors, METH_O, "DenseMatrixEigensystem_Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix"}, - { "DenseMatrixEigensystem_Eigenvalue", _wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS, "DenseMatrixEigensystem_Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, - { "DenseMatrixEigensystem_Eigenvector", _wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS, "DenseMatrixEigensystem_Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, + { "DenseMatrixEigensystem_Eigenvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS|METH_KEYWORDS, "DenseMatrixEigensystem_Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, + { "DenseMatrixEigensystem_Eigenvector", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS|METH_KEYWORDS, "DenseMatrixEigensystem_Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, { "delete_DenseMatrixEigensystem", _wrap_delete_DenseMatrixEigensystem, METH_O, "delete_DenseMatrixEigensystem(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_swigregister", DenseMatrixEigensystem_swigregister, METH_O, NULL}, { "DenseMatrixEigensystem_swiginit", DenseMatrixEigensystem_swiginit, METH_VARARGS, NULL}, @@ -19468,9 +18793,9 @@ static PyMethodDef SwigMethods[] = { "DenseMatrixSVD(DenseMatrix M)\n" "new_DenseMatrixSVD(int h, int w) -> DenseMatrixSVD\n" ""}, - { "DenseMatrixSVD_Eval", _wrap_DenseMatrixSVD_Eval, METH_VARARGS, "DenseMatrixSVD_Eval(DenseMatrixSVD self, DenseMatrix M)"}, + { "DenseMatrixSVD_Eval", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Eval, METH_VARARGS|METH_KEYWORDS, "DenseMatrixSVD_Eval(DenseMatrixSVD self, DenseMatrix M)"}, { "DenseMatrixSVD_Singularvalues", _wrap_DenseMatrixSVD_Singularvalues, METH_O, "DenseMatrixSVD_Singularvalues(DenseMatrixSVD self) -> Vector"}, - { "DenseMatrixSVD_Singularvalue", _wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS, "DenseMatrixSVD_Singularvalue(DenseMatrixSVD self, int i) -> double"}, + { "DenseMatrixSVD_Singularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS|METH_KEYWORDS, "DenseMatrixSVD_Singularvalue(DenseMatrixSVD self, int i) -> double"}, { "delete_DenseMatrixSVD", _wrap_delete_DenseMatrixSVD, METH_O, "delete_DenseMatrixSVD(DenseMatrixSVD self)"}, { "DenseMatrixSVD_swigregister", DenseMatrixSVD_swigregister, METH_O, NULL}, { "DenseMatrixSVD_swiginit", DenseMatrixSVD_swiginit, METH_VARARGS, NULL}, @@ -19483,15 +18808,15 @@ static PyMethodDef SwigMethods[] = { { "DenseTensor_SizeJ", _wrap_DenseTensor_SizeJ, METH_O, "DenseTensor_SizeJ(DenseTensor self) -> int"}, { "DenseTensor_SizeK", _wrap_DenseTensor_SizeK, METH_O, "DenseTensor_SizeK(DenseTensor self) -> int"}, { "DenseTensor_TotalSize", _wrap_DenseTensor_TotalSize, METH_O, "DenseTensor_TotalSize(DenseTensor self) -> int"}, - { "DenseTensor_SetSize", _wrap_DenseTensor_SetSize, METH_VARARGS, "DenseTensor_SetSize(DenseTensor self, int i, int j, int k)"}, - { "DenseTensor_UseExternalData", _wrap_DenseTensor_UseExternalData, METH_VARARGS, "DenseTensor_UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, + { "DenseTensor_SetSize", (PyCFunction)(void(*)(void))_wrap_DenseTensor_SetSize, METH_VARARGS|METH_KEYWORDS, "DenseTensor_SetSize(DenseTensor self, int i, int j, int k)"}, + { "DenseTensor_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_UseExternalData, METH_VARARGS|METH_KEYWORDS, "DenseTensor_UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, { "DenseTensor___call__", _wrap_DenseTensor___call__, METH_VARARGS, "\n" "DenseTensor___call__(DenseTensor self, int k) -> DenseMatrix\n" "DenseTensor___call__(DenseTensor self, int k) -> DenseMatrix\n" "DenseTensor___call__(DenseTensor self, int i, int j, int k) -> double\n" "DenseTensor___call__(DenseTensor self, int i, int j, int k) -> double const &\n" ""}, - { "DenseTensor_GetData", _wrap_DenseTensor_GetData, METH_VARARGS, "DenseTensor_GetData(DenseTensor self, int k) -> double *"}, + { "DenseTensor_GetData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_GetData, METH_VARARGS|METH_KEYWORDS, "DenseTensor_GetData(DenseTensor self, int k) -> double *"}, { "DenseTensor_Data", _wrap_DenseTensor_Data, METH_VARARGS, "\n" "DenseTensor_Data(DenseTensor self) -> double\n" "DenseTensor_Data(DenseTensor self) -> double const *\n" @@ -19500,22 +18825,22 @@ static PyMethodDef SwigMethods[] = { "DenseTensor_GetMemory(DenseTensor self) -> mfem::Memory< double >\n" "DenseTensor_GetMemory(DenseTensor self) -> mfem::Memory< double > const &\n" ""}, - { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "DenseTensor_AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, + { "DenseTensor_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseTensor_AddMult, METH_VARARGS|METH_KEYWORDS, "DenseTensor_AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "DenseTensor_Clear(DenseTensor self)"}, { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "DenseTensor_MemoryUsage(DenseTensor self) -> long"}, - { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "DenseTensor_Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_Read", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Read, METH_VARARGS|METH_KEYWORDS, "DenseTensor_Read(DenseTensor self, bool on_dev=True) -> double const *"}, { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "DenseTensor_HostRead(DenseTensor self) -> double const *"}, - { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "DenseTensor_Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_Write", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Write, METH_VARARGS|METH_KEYWORDS, "DenseTensor_Write(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "DenseTensor_HostWrite(DenseTensor self) -> double *"}, - { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "DenseTensor_ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseTensor_ReadWrite, METH_VARARGS|METH_KEYWORDS, "DenseTensor_ReadWrite(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "DenseTensor_HostReadWrite(DenseTensor self) -> double *"}, { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, - { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "DenseTensor_Assign(DenseTensor self, double const c)"}, + { "DenseTensor_Assign", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Assign, METH_VARARGS|METH_KEYWORDS, "DenseTensor_Assign(DenseTensor self, double const c)"}, { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" "DenseTensor___getitem__(DenseTensor self, int const i, int const j, int const k) -> double const\n" "DenseTensor___getitem__(DenseTensor self, int const k) -> DenseMatrix\n" ""}, - { "DenseTensor___setitem__", _wrap_DenseTensor___setitem__, METH_VARARGS, "DenseTensor___setitem__(DenseTensor self, int i, int j, int k, double const v)"}, + { "DenseTensor___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseTensor___setitem__, METH_VARARGS|METH_KEYWORDS, "DenseTensor___setitem__(DenseTensor self, int i, int j, int k, double const v)"}, { "DenseTensor_GetDataArray", _wrap_DenseTensor_GetDataArray, METH_O, "DenseTensor_GetDataArray(DenseTensor self) -> PyObject *"}, { "DenseTensor_swigregister", DenseTensor_swigregister, METH_O, NULL}, { "DenseTensor_swiginit", DenseTensor_swiginit, METH_VARARGS, NULL}, @@ -19533,8 +18858,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DenseMatrix(DenseMatrix mat, char ch)\n" "new_DenseMatrix(double * d, int h, int w) -> DenseMatrix\n" ""}, - { "DenseMatrix_UseExternalData", _wrap_DenseMatrix_UseExternalData, METH_VARARGS, "UseExternalData(DenseMatrix self, double * d, int h, int w)"}, - { "DenseMatrix_Reset", _wrap_DenseMatrix_Reset, METH_VARARGS, "Reset(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_UseExternalData, METH_VARARGS|METH_KEYWORDS, "UseExternalData(DenseMatrix self, double * d, int h, int w)"}, + { "DenseMatrix_Reset", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Reset, METH_VARARGS|METH_KEYWORDS, "Reset(DenseMatrix self, double * d, int h, int w)"}, { "DenseMatrix_ClearExternalData", _wrap_DenseMatrix_ClearExternalData, METH_O, "ClearExternalData(DenseMatrix self)"}, { "DenseMatrix_Clear", _wrap_DenseMatrix_Clear, METH_O, "Clear(DenseMatrix self)"}, { "DenseMatrix_Size", _wrap_DenseMatrix_Size, METH_O, "Size(DenseMatrix self) -> int"}, @@ -19553,7 +18878,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__call__(DenseMatrix self, int i, int j) -> double\n" "__call__(DenseMatrix self, int i, int j) -> double const &\n" ""}, - { "DenseMatrix___mul__", _wrap_DenseMatrix___mul__, METH_VARARGS, "__mul__(DenseMatrix self, DenseMatrix m) -> double"}, + { "DenseMatrix___mul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___mul__, METH_VARARGS|METH_KEYWORDS, "__mul__(DenseMatrix self, DenseMatrix m) -> double"}, { "DenseMatrix_Trace", _wrap_DenseMatrix_Trace, METH_O, "Trace(DenseMatrix self) -> double"}, { "DenseMatrix_Elem", _wrap_DenseMatrix_Elem, METH_VARARGS, "\n" "Elem(DenseMatrix self, int i, int j) -> double\n" @@ -19567,16 +18892,16 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MultTranspose(DenseMatrix self, double const * x, double * y)\n" "MultTranspose(DenseMatrix self, Vector x, Vector y)\n" ""}, - { "DenseMatrix_AddMult", _wrap_DenseMatrix_AddMult, METH_VARARGS, "AddMult(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose", _wrap_DenseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, - { "DenseMatrix_AddMult_a", _wrap_DenseMatrix_AddMult_a, METH_VARARGS, "AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_AddMultTranspose_a", _wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS, "AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, - { "DenseMatrix_LeftScaling", _wrap_DenseMatrix_LeftScaling, METH_VARARGS, "LeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvLeftScaling", _wrap_DenseMatrix_InvLeftScaling, METH_VARARGS, "InvLeftScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_RightScaling", _wrap_DenseMatrix_RightScaling, METH_VARARGS, "RightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvRightScaling", _wrap_DenseMatrix_InvRightScaling, METH_VARARGS, "InvRightScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_SymmetricScaling", _wrap_DenseMatrix_SymmetricScaling, METH_VARARGS, "SymmetricScaling(DenseMatrix self, Vector s)"}, - { "DenseMatrix_InvSymmetricScaling", _wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS, "InvSymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(DenseMatrix self, Vector x, Vector y)"}, + { "DenseMatrix_AddMult_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMult_a, METH_VARARGS|METH_KEYWORDS, "AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_AddMultTranspose_a", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddMultTranspose_a, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"}, + { "DenseMatrix_LeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_LeftScaling, METH_VARARGS|METH_KEYWORDS, "LeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvLeftScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvLeftScaling, METH_VARARGS|METH_KEYWORDS, "InvLeftScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_RightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_RightScaling, METH_VARARGS|METH_KEYWORDS, "RightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvRightScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvRightScaling, METH_VARARGS|METH_KEYWORDS, "InvRightScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_SymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SymmetricScaling, METH_VARARGS|METH_KEYWORDS, "SymmetricScaling(DenseMatrix self, Vector s)"}, + { "DenseMatrix_InvSymmetricScaling", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_InvSymmetricScaling, METH_VARARGS|METH_KEYWORDS, "InvSymmetricScaling(DenseMatrix self, Vector s)"}, { "DenseMatrix_InnerProduct", _wrap_DenseMatrix_InnerProduct, METH_VARARGS, "\n" "InnerProduct(DenseMatrix self, double const * x, double const * y) -> double\n" "InnerProduct(DenseMatrix self, Vector x, Vector y) -> double\n" @@ -19590,15 +18915,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Set(DenseMatrix self, double alpha, double const * A)\n" "Set(DenseMatrix self, double alpha, DenseMatrix A)\n" ""}, - { "DenseMatrix_Add", _wrap_DenseMatrix_Add, METH_VARARGS, "Add(DenseMatrix self, double const c, DenseMatrix A)"}, + { "DenseMatrix_Add", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Add, METH_VARARGS|METH_KEYWORDS, "Add(DenseMatrix self, double const c, DenseMatrix A)"}, { "DenseMatrix___iadd__", _wrap_DenseMatrix___iadd__, METH_VARARGS, "\n" "__iadd__(DenseMatrix self, double const * m) -> DenseMatrix\n" "__iadd__(DenseMatrix self, DenseMatrix m) -> DenseMatrix\n" ""}, - { "DenseMatrix___isub__", _wrap_DenseMatrix___isub__, METH_VARARGS, "__isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, - { "DenseMatrix___imul__", _wrap_DenseMatrix___imul__, METH_VARARGS, "__imul__(DenseMatrix self, double c) -> DenseMatrix"}, + { "DenseMatrix___isub__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___isub__, METH_VARARGS|METH_KEYWORDS, "__isub__(DenseMatrix self, DenseMatrix m) -> DenseMatrix"}, + { "DenseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "__imul__(DenseMatrix self, double c) -> DenseMatrix"}, { "DenseMatrix_Neg", _wrap_DenseMatrix_Neg, METH_O, "Neg(DenseMatrix self)"}, - { "DenseMatrix_Norm2", _wrap_DenseMatrix_Norm2, METH_VARARGS, "Norm2(DenseMatrix self, double * v)"}, + { "DenseMatrix_Norm2", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Norm2, METH_VARARGS|METH_KEYWORDS, "Norm2(DenseMatrix self, double * v)"}, { "DenseMatrix_MaxMaxNorm", _wrap_DenseMatrix_MaxMaxNorm, METH_O, "MaxMaxNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm", _wrap_DenseMatrix_FNorm, METH_O, "FNorm(DenseMatrix self) -> double"}, { "DenseMatrix_FNorm2", _wrap_DenseMatrix_FNorm2, METH_O, "FNorm2(DenseMatrix self) -> double"}, @@ -19612,17 +18937,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Eigensystem(DenseMatrix self, Vector ev, DenseMatrix evect)\n" "Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)\n" ""}, - { "DenseMatrix_SingularValues", _wrap_DenseMatrix_SingularValues, METH_VARARGS, "SingularValues(DenseMatrix self, Vector sv)"}, - { "DenseMatrix_Rank", _wrap_DenseMatrix_Rank, METH_VARARGS, "Rank(DenseMatrix self, double tol) -> int"}, - { "DenseMatrix_CalcSingularvalue", _wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS, "CalcSingularvalue(DenseMatrix self, int const i) -> double"}, - { "DenseMatrix_CalcEigenvalues", _wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS, "CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, - { "DenseMatrix_GetRow", _wrap_DenseMatrix_GetRow, METH_VARARGS, "GetRow(DenseMatrix self, int r, Vector row)"}, + { "DenseMatrix_SingularValues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_SingularValues, METH_VARARGS|METH_KEYWORDS, "SingularValues(DenseMatrix self, Vector sv)"}, + { "DenseMatrix_Rank", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Rank, METH_VARARGS|METH_KEYWORDS, "Rank(DenseMatrix self, double tol) -> int"}, + { "DenseMatrix_CalcSingularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcSingularvalue, METH_VARARGS|METH_KEYWORDS, "CalcSingularvalue(DenseMatrix self, int const i) -> double"}, + { "DenseMatrix_CalcEigenvalues", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CalcEigenvalues, METH_VARARGS|METH_KEYWORDS, "CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"}, + { "DenseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(DenseMatrix self, int r, Vector row)"}, { "DenseMatrix_GetColumn", _wrap_DenseMatrix_GetColumn, METH_VARARGS, "\n" "GetColumn(DenseMatrix self, int c, Vector col)\n" "GetColumn(DenseMatrix self, int col) -> double\n" "GetColumn(DenseMatrix self, int col) -> double const *\n" ""}, - { "DenseMatrix_GetColumnReference", _wrap_DenseMatrix_GetColumnReference, METH_VARARGS, "GetColumnReference(DenseMatrix self, int c, Vector col)"}, + { "DenseMatrix_GetColumnReference", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetColumnReference, METH_VARARGS|METH_KEYWORDS, "GetColumnReference(DenseMatrix self, int c, Vector col)"}, { "DenseMatrix_SetRow", _wrap_DenseMatrix_SetRow, METH_VARARGS, "\n" "SetRow(DenseMatrix self, int r, double const * row)\n" "SetRow(DenseMatrix self, int r, Vector row)\n" @@ -19633,9 +18958,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetCol(DenseMatrix self, int c, Vector col)\n" "SetCol(DenseMatrix self, int col, double value)\n" ""}, - { "DenseMatrix_GetDiag", _wrap_DenseMatrix_GetDiag, METH_VARARGS, "GetDiag(DenseMatrix self, Vector d)"}, - { "DenseMatrix_Getl1Diag", _wrap_DenseMatrix_Getl1Diag, METH_VARARGS, "Getl1Diag(DenseMatrix self, Vector l)"}, - { "DenseMatrix_GetRowSums", _wrap_DenseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "GetDiag(DenseMatrix self, Vector d)"}, + { "DenseMatrix_Getl1Diag", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Getl1Diag, METH_VARARGS|METH_KEYWORDS, "Getl1Diag(DenseMatrix self, Vector l)"}, + { "DenseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "GetRowSums(DenseMatrix self, Vector l)"}, { "DenseMatrix_Diag", _wrap_DenseMatrix_Diag, METH_VARARGS, "\n" "Diag(DenseMatrix self, double c, int n)\n" "Diag(DenseMatrix self, double * diag, int n)\n" @@ -19646,11 +18971,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "DenseMatrix_Symmetrize", _wrap_DenseMatrix_Symmetrize, METH_O, "Symmetrize(DenseMatrix self)"}, { "DenseMatrix_Lump", _wrap_DenseMatrix_Lump, METH_O, "Lump(DenseMatrix self)"}, - { "DenseMatrix_GradToCurl", _wrap_DenseMatrix_GradToCurl, METH_VARARGS, "GradToCurl(DenseMatrix self, DenseMatrix curl)"}, - { "DenseMatrix_GradToDiv", _wrap_DenseMatrix_GradToDiv, METH_VARARGS, "GradToDiv(DenseMatrix self, Vector div)"}, - { "DenseMatrix_CopyRows", _wrap_DenseMatrix_CopyRows, METH_VARARGS, "CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, - { "DenseMatrix_CopyCols", _wrap_DenseMatrix_CopyCols, METH_VARARGS, "CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, - { "DenseMatrix_CopyMNt", _wrap_DenseMatrix_CopyMNt, METH_VARARGS, "CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, + { "DenseMatrix_GradToCurl", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToCurl, METH_VARARGS|METH_KEYWORDS, "GradToCurl(DenseMatrix self, DenseMatrix curl)"}, + { "DenseMatrix_GradToDiv", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GradToDiv, METH_VARARGS|METH_KEYWORDS, "GradToDiv(DenseMatrix self, Vector div)"}, + { "DenseMatrix_CopyRows", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyRows, METH_VARARGS|METH_KEYWORDS, "CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"}, + { "DenseMatrix_CopyCols", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyCols, METH_VARARGS|METH_KEYWORDS, "CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"}, + { "DenseMatrix_CopyMNt", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyMNt, METH_VARARGS|METH_KEYWORDS, "CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"}, { "DenseMatrix_CopyMN", _wrap_DenseMatrix_CopyMN, METH_VARARGS, "\n" "CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco)\n" "CopyMN(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)\n" @@ -19660,23 +18985,23 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CopyMNDiag(DenseMatrix self, double c, int n, int row_offset, int col_offset)\n" "CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset)\n" ""}, - { "DenseMatrix_CopyExceptMN", _wrap_DenseMatrix_CopyExceptMN, METH_VARARGS, "CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, + { "DenseMatrix_CopyExceptMN", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_CopyExceptMN, METH_VARARGS|METH_KEYWORDS, "CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"}, { "DenseMatrix_AddMatrix", _wrap_DenseMatrix_AddMatrix, METH_VARARGS, "\n" "AddMatrix(DenseMatrix self, DenseMatrix A, int ro, int co)\n" "AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co)\n" ""}, - { "DenseMatrix_AddToVector", _wrap_DenseMatrix_AddToVector, METH_VARARGS, "AddToVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_GetFromVector", _wrap_DenseMatrix_GetFromVector, METH_VARARGS, "GetFromVector(DenseMatrix self, int offset, Vector v)"}, - { "DenseMatrix_AdjustDofDirection", _wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS, "AdjustDofDirection(DenseMatrix self, intArray dofs)"}, - { "DenseMatrix_Threshold", _wrap_DenseMatrix_Threshold, METH_VARARGS, "Threshold(DenseMatrix self, double eps)"}, + { "DenseMatrix_AddToVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AddToVector, METH_VARARGS|METH_KEYWORDS, "AddToVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_GetFromVector", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_GetFromVector, METH_VARARGS|METH_KEYWORDS, "GetFromVector(DenseMatrix self, int offset, Vector v)"}, + { "DenseMatrix_AdjustDofDirection", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_AdjustDofDirection, METH_VARARGS|METH_KEYWORDS, "AdjustDofDirection(DenseMatrix self, intArray dofs)"}, + { "DenseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "Threshold(DenseMatrix self, double eps)"}, { "DenseMatrix_CheckFinite", _wrap_DenseMatrix_CheckFinite, METH_O, "CheckFinite(DenseMatrix self) -> int"}, { "DenseMatrix_TestInversion", _wrap_DenseMatrix_TestInversion, METH_O, "TestInversion(DenseMatrix self)"}, { "DenseMatrix_MemoryUsage", _wrap_DenseMatrix_MemoryUsage, METH_O, "MemoryUsage(DenseMatrix self) -> long"}, - { "DenseMatrix_Read", _wrap_DenseMatrix_Read, METH_VARARGS, "Read(DenseMatrix self, bool on_dev=True) -> double const"}, + { "DenseMatrix_Read", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Read, METH_VARARGS|METH_KEYWORDS, "Read(DenseMatrix self, bool on_dev=True) -> double const *"}, { "DenseMatrix_HostRead", _wrap_DenseMatrix_HostRead, METH_O, "HostRead(DenseMatrix self) -> double const *"}, - { "DenseMatrix_Write", _wrap_DenseMatrix_Write, METH_VARARGS, "Write(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_Write", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_Write, METH_VARARGS|METH_KEYWORDS, "Write(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostWrite", _wrap_DenseMatrix_HostWrite, METH_O, "HostWrite(DenseMatrix self) -> double *"}, - { "DenseMatrix_ReadWrite", _wrap_DenseMatrix_ReadWrite, METH_VARARGS, "ReadWrite(DenseMatrix self, bool on_dev=True) -> double"}, + { "DenseMatrix_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseMatrix_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(DenseMatrix self, bool on_dev=True) -> double *"}, { "DenseMatrix_HostReadWrite", _wrap_DenseMatrix_HostReadWrite, METH_O, "HostReadWrite(DenseMatrix self) -> double *"}, { "delete_DenseMatrix", _wrap_delete_DenseMatrix, METH_O, "delete_DenseMatrix(DenseMatrix self)"}, { "DenseMatrix_Assign", _wrap_DenseMatrix_Assign, METH_VARARGS, "\n" @@ -19684,8 +19009,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Assign(DenseMatrix self, DenseMatrix m)\n" "Assign(DenseMatrix self, PyObject * numpymat)\n" ""}, - { "DenseMatrix___getitem__", _wrap_DenseMatrix___getitem__, METH_VARARGS, "__getitem__(DenseMatrix self, int const i, int const j) -> double const"}, - { "DenseMatrix___setitem__", _wrap_DenseMatrix___setitem__, METH_VARARGS, "__setitem__(DenseMatrix self, int i, int j, double const v)"}, + { "DenseMatrix___getitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(DenseMatrix self, int const i, int const j) -> double const"}, + { "DenseMatrix___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseMatrix___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(DenseMatrix self, int i, int j, double const v)"}, { "DenseMatrix_GetDataArray", _wrap_DenseMatrix_GetDataArray, METH_O, "GetDataArray(DenseMatrix self) -> PyObject *"}, { "DenseMatrix_Print", _wrap_DenseMatrix_Print, METH_VARARGS, "\n" "Print(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -19701,31 +19026,31 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "DenseMatrix_swigregister", DenseMatrix_swigregister, METH_O, NULL}, { "DenseMatrix_swiginit", DenseMatrix_swiginit, METH_VARARGS, NULL}, - { "LinearSolve", _wrap_LinearSolve, METH_VARARGS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, - { "AddMult", _wrap_AddMult, METH_VARARGS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "AddMult_a", _wrap_AddMult_a, METH_VARARGS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, - { "CalcAdjugate", _wrap_CalcAdjugate, METH_VARARGS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, - { "CalcAdjugateTranspose", _wrap_CalcAdjugateTranspose, METH_VARARGS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, - { "CalcInverse", _wrap_CalcInverse, METH_VARARGS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, - { "CalcInverseTranspose", _wrap_CalcInverseTranspose, METH_VARARGS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, - { "CalcOrtho", _wrap_CalcOrtho, METH_VARARGS, "CalcOrtho(DenseMatrix J, Vector n)"}, - { "MultAAt", _wrap_MultAAt, METH_VARARGS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, - { "MultADAt", _wrap_MultADAt, METH_VARARGS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "AddMultADAt", _wrap_AddMultADAt, METH_VARARGS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, - { "MultABt", _wrap_MultABt, METH_VARARGS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultADBt", _wrap_MultADBt, METH_VARARGS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMultABt", _wrap_AddMultABt, METH_VARARGS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "AddMultADBt", _wrap_AddMultADBt, METH_VARARGS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, - { "AddMult_a_ABt", _wrap_AddMult_a_ABt, METH_VARARGS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, - { "MultAtB", _wrap_MultAtB, METH_VARARGS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, - { "AddMult_a_AAt", _wrap_AddMult_a_AAt, METH_VARARGS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "Mult_a_AAt", _wrap_Mult_a_AAt, METH_VARARGS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, - { "MultVVt", _wrap_MultVVt, METH_VARARGS, "MultVVt(Vector v, DenseMatrix vvt)"}, - { "MultVWt", _wrap_MultVWt, METH_VARARGS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVWt", _wrap_AddMultVWt, METH_VARARGS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMultVVt", _wrap_AddMultVVt, METH_VARARGS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, - { "AddMult_a_VWt", _wrap_AddMult_a_VWt, METH_VARARGS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, - { "AddMult_a_VVt", _wrap_AddMult_a_VVt, METH_VARARGS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, + { "LinearSolve", (PyCFunction)(void(*)(void))_wrap_LinearSolve, METH_VARARGS|METH_KEYWORDS, "LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"}, + { "AddMult", (PyCFunction)(void(*)(void))_wrap_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "AddMult_a", (PyCFunction)(void(*)(void))_wrap_AddMult_a, METH_VARARGS|METH_KEYWORDS, "AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"}, + { "CalcAdjugate", (PyCFunction)(void(*)(void))_wrap_CalcAdjugate, METH_VARARGS|METH_KEYWORDS, "CalcAdjugate(DenseMatrix a, DenseMatrix adja)"}, + { "CalcAdjugateTranspose", (PyCFunction)(void(*)(void))_wrap_CalcAdjugateTranspose, METH_VARARGS|METH_KEYWORDS, "CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"}, + { "CalcInverse", (PyCFunction)(void(*)(void))_wrap_CalcInverse, METH_VARARGS|METH_KEYWORDS, "CalcInverse(DenseMatrix a, DenseMatrix inva)"}, + { "CalcInverseTranspose", (PyCFunction)(void(*)(void))_wrap_CalcInverseTranspose, METH_VARARGS|METH_KEYWORDS, "CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"}, + { "CalcOrtho", (PyCFunction)(void(*)(void))_wrap_CalcOrtho, METH_VARARGS|METH_KEYWORDS, "CalcOrtho(DenseMatrix J, Vector n)"}, + { "MultAAt", (PyCFunction)(void(*)(void))_wrap_MultAAt, METH_VARARGS|METH_KEYWORDS, "MultAAt(DenseMatrix a, DenseMatrix aat)"}, + { "MultADAt", (PyCFunction)(void(*)(void))_wrap_MultADAt, METH_VARARGS|METH_KEYWORDS, "MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "AddMultADAt", (PyCFunction)(void(*)(void))_wrap_AddMultADAt, METH_VARARGS|METH_KEYWORDS, "AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"}, + { "MultABt", (PyCFunction)(void(*)(void))_wrap_MultABt, METH_VARARGS|METH_KEYWORDS, "MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultADBt", (PyCFunction)(void(*)(void))_wrap_MultADBt, METH_VARARGS|METH_KEYWORDS, "MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMultABt", (PyCFunction)(void(*)(void))_wrap_AddMultABt, METH_VARARGS|METH_KEYWORDS, "AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "AddMultADBt", (PyCFunction)(void(*)(void))_wrap_AddMultADBt, METH_VARARGS|METH_KEYWORDS, "AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"}, + { "AddMult_a_ABt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_ABt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"}, + { "MultAtB", (PyCFunction)(void(*)(void))_wrap_MultAtB, METH_VARARGS|METH_KEYWORDS, "MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"}, + { "AddMult_a_AAt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_AAt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "Mult_a_AAt", (PyCFunction)(void(*)(void))_wrap_Mult_a_AAt, METH_VARARGS|METH_KEYWORDS, "Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"}, + { "MultVVt", (PyCFunction)(void(*)(void))_wrap_MultVVt, METH_VARARGS|METH_KEYWORDS, "MultVVt(Vector v, DenseMatrix vvt)"}, + { "MultVWt", (PyCFunction)(void(*)(void))_wrap_MultVWt, METH_VARARGS|METH_KEYWORDS, "MultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVWt", (PyCFunction)(void(*)(void))_wrap_AddMultVWt, METH_VARARGS|METH_KEYWORDS, "AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMultVVt", (PyCFunction)(void(*)(void))_wrap_AddMultVVt, METH_VARARGS|METH_KEYWORDS, "AddMultVVt(Vector v, DenseMatrix VWt)"}, + { "AddMult_a_VWt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VWt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"}, + { "AddMult_a_VVt", (PyCFunction)(void(*)(void))_wrap_AddMult_a_VVt, METH_VARARGS|METH_KEYWORDS, "AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"}, { "LUFactors_data_set", _wrap_LUFactors_data_set, METH_VARARGS, "LUFactors_data_set(LUFactors self, double * data)"}, { "LUFactors_data_get", _wrap_LUFactors_data_get, METH_O, "LUFactors_data_get(LUFactors self) -> double *"}, { "LUFactors_ipiv_set", _wrap_LUFactors_ipiv_set, METH_VARARGS, "LUFactors_ipiv_set(LUFactors self, int * ipiv)"}, @@ -19734,18 +19059,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { "LUFactors()\n" "new_LUFactors(double * data_, int * ipiv_) -> LUFactors\n" ""}, - { "LUFactors_Factor", _wrap_LUFactors_Factor, METH_VARARGS, "Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, - { "LUFactors_Det", _wrap_LUFactors_Det, METH_VARARGS, "Det(LUFactors self, int m) -> double"}, - { "LUFactors_Mult", _wrap_LUFactors_Mult, METH_VARARGS, "Mult(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_LSolve", _wrap_LUFactors_LSolve, METH_VARARGS, "LSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_USolve", _wrap_LUFactors_USolve, METH_VARARGS, "USolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_Solve", _wrap_LUFactors_Solve, METH_VARARGS, "Solve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_RightSolve", _wrap_LUFactors_RightSolve, METH_VARARGS, "RightSolve(LUFactors self, int m, int n, double * X)"}, - { "LUFactors_GetInverseMatrix", _wrap_LUFactors_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(LUFactors self, int m, double * X)"}, - { "LUFactors_SubMult", _wrap_LUFactors_SubMult, METH_VARARGS, "SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, - { "LUFactors_BlockFactor", _wrap_LUFactors_BlockFactor, METH_VARARGS, "BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, - { "LUFactors_BlockForwSolve", _wrap_LUFactors_BlockForwSolve, METH_VARARGS, "BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, - { "LUFactors_BlockBackSolve", _wrap_LUFactors_BlockBackSolve, METH_VARARGS, "BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, + { "LUFactors_Factor", (PyCFunction)(void(*)(void))_wrap_LUFactors_Factor, METH_VARARGS|METH_KEYWORDS, "Factor(LUFactors self, int m, double TOL=0.0) -> bool"}, + { "LUFactors_Det", (PyCFunction)(void(*)(void))_wrap_LUFactors_Det, METH_VARARGS|METH_KEYWORDS, "Det(LUFactors self, int m) -> double"}, + { "LUFactors_Mult", (PyCFunction)(void(*)(void))_wrap_LUFactors_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_LSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_LSolve, METH_VARARGS|METH_KEYWORDS, "LSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_USolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_USolve, METH_VARARGS|METH_KEYWORDS, "USolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_Solve", (PyCFunction)(void(*)(void))_wrap_LUFactors_Solve, METH_VARARGS|METH_KEYWORDS, "Solve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_RightSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_RightSolve, METH_VARARGS|METH_KEYWORDS, "RightSolve(LUFactors self, int m, int n, double * X)"}, + { "LUFactors_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_LUFactors_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "GetInverseMatrix(LUFactors self, int m, double * X)"}, + { "LUFactors_SubMult", (PyCFunction)(void(*)(void))_wrap_LUFactors_SubMult, METH_VARARGS|METH_KEYWORDS, "SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"}, + { "LUFactors_BlockFactor", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockFactor, METH_VARARGS|METH_KEYWORDS, "BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"}, + { "LUFactors_BlockForwSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockForwSolve, METH_VARARGS|METH_KEYWORDS, "BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"}, + { "LUFactors_BlockBackSolve", (PyCFunction)(void(*)(void))_wrap_LUFactors_BlockBackSolve, METH_VARARGS|METH_KEYWORDS, "BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"}, { "delete_LUFactors", _wrap_delete_LUFactors, METH_O, "delete_LUFactors(LUFactors self)"}, { "LUFactors_swigregister", LUFactors_swigregister, METH_O, NULL}, { "LUFactors_swiginit", LUFactors_swiginit, METH_VARARGS, NULL}, @@ -19759,13 +19084,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Factor(DenseMatrixInverse self)\n" "Factor(DenseMatrixInverse self, DenseMatrix mat)\n" ""}, - { "DenseMatrixInverse_SetOperator", _wrap_DenseMatrixInverse_SetOperator, METH_VARARGS, "SetOperator(DenseMatrixInverse self, Operator op)"}, + { "DenseMatrixInverse_SetOperator", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(DenseMatrixInverse self, Operator op)"}, { "DenseMatrixInverse_Mult", _wrap_DenseMatrixInverse_Mult, METH_VARARGS, "\n" "Mult(DenseMatrixInverse self, Vector x, Vector y)\n" "Mult(DenseMatrixInverse self, DenseMatrix B, DenseMatrix X)\n" "Mult(DenseMatrixInverse self, DenseMatrix X)\n" ""}, - { "DenseMatrixInverse_GetInverseMatrix", _wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS, "GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, + { "DenseMatrixInverse_GetInverseMatrix", (PyCFunction)(void(*)(void))_wrap_DenseMatrixInverse_GetInverseMatrix, METH_VARARGS|METH_KEYWORDS, "GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"}, { "DenseMatrixInverse_Det", _wrap_DenseMatrixInverse_Det, METH_O, "Det(DenseMatrixInverse self) -> double"}, { "DenseMatrixInverse_TestInversion", _wrap_DenseMatrixInverse_TestInversion, METH_O, "TestInversion(DenseMatrixInverse self)"}, { "delete_DenseMatrixInverse", _wrap_delete_DenseMatrixInverse, METH_O, "delete_DenseMatrixInverse(DenseMatrixInverse self)"}, @@ -19778,8 +19103,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "DenseMatrixEigensystem_Eval", _wrap_DenseMatrixEigensystem_Eval, METH_O, "Eval(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_Eigenvalues", _wrap_DenseMatrixEigensystem_Eigenvalues, METH_O, "Eigenvalues(DenseMatrixEigensystem self) -> Vector"}, { "DenseMatrixEigensystem_Eigenvectors", _wrap_DenseMatrixEigensystem_Eigenvectors, METH_O, "Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix"}, - { "DenseMatrixEigensystem_Eigenvalue", _wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS, "Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, - { "DenseMatrixEigensystem_Eigenvector", _wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS, "Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, + { "DenseMatrixEigensystem_Eigenvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvalue, METH_VARARGS|METH_KEYWORDS, "Eigenvalue(DenseMatrixEigensystem self, int i) -> double"}, + { "DenseMatrixEigensystem_Eigenvector", (PyCFunction)(void(*)(void))_wrap_DenseMatrixEigensystem_Eigenvector, METH_VARARGS|METH_KEYWORDS, "Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"}, { "delete_DenseMatrixEigensystem", _wrap_delete_DenseMatrixEigensystem, METH_O, "delete_DenseMatrixEigensystem(DenseMatrixEigensystem self)"}, { "DenseMatrixEigensystem_swigregister", DenseMatrixEigensystem_swigregister, METH_O, NULL}, { "DenseMatrixEigensystem_swiginit", DenseMatrixEigensystem_swiginit, METH_VARARGS, NULL}, @@ -19787,9 +19112,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "DenseMatrixSVD(DenseMatrix M)\n" "new_DenseMatrixSVD(int h, int w) -> DenseMatrixSVD\n" ""}, - { "DenseMatrixSVD_Eval", _wrap_DenseMatrixSVD_Eval, METH_VARARGS, "Eval(DenseMatrixSVD self, DenseMatrix M)"}, + { "DenseMatrixSVD_Eval", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(DenseMatrixSVD self, DenseMatrix M)"}, { "DenseMatrixSVD_Singularvalues", _wrap_DenseMatrixSVD_Singularvalues, METH_O, "Singularvalues(DenseMatrixSVD self) -> Vector"}, - { "DenseMatrixSVD_Singularvalue", _wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS, "Singularvalue(DenseMatrixSVD self, int i) -> double"}, + { "DenseMatrixSVD_Singularvalue", (PyCFunction)(void(*)(void))_wrap_DenseMatrixSVD_Singularvalue, METH_VARARGS|METH_KEYWORDS, "Singularvalue(DenseMatrixSVD self, int i) -> double"}, { "delete_DenseMatrixSVD", _wrap_delete_DenseMatrixSVD, METH_O, "delete_DenseMatrixSVD(DenseMatrixSVD self)"}, { "DenseMatrixSVD_swigregister", DenseMatrixSVD_swigregister, METH_O, NULL}, { "DenseMatrixSVD_swiginit", DenseMatrixSVD_swiginit, METH_VARARGS, NULL}, @@ -19802,15 +19127,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "DenseTensor_SizeJ", _wrap_DenseTensor_SizeJ, METH_O, "SizeJ(DenseTensor self) -> int"}, { "DenseTensor_SizeK", _wrap_DenseTensor_SizeK, METH_O, "SizeK(DenseTensor self) -> int"}, { "DenseTensor_TotalSize", _wrap_DenseTensor_TotalSize, METH_O, "TotalSize(DenseTensor self) -> int"}, - { "DenseTensor_SetSize", _wrap_DenseTensor_SetSize, METH_VARARGS, "SetSize(DenseTensor self, int i, int j, int k)"}, - { "DenseTensor_UseExternalData", _wrap_DenseTensor_UseExternalData, METH_VARARGS, "UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, + { "DenseTensor_SetSize", (PyCFunction)(void(*)(void))_wrap_DenseTensor_SetSize, METH_VARARGS|METH_KEYWORDS, "SetSize(DenseTensor self, int i, int j, int k)"}, + { "DenseTensor_UseExternalData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_UseExternalData, METH_VARARGS|METH_KEYWORDS, "UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"}, { "DenseTensor___call__", _wrap_DenseTensor___call__, METH_VARARGS, "\n" "__call__(DenseTensor self, int k) -> DenseMatrix\n" "__call__(DenseTensor self, int k) -> DenseMatrix\n" "__call__(DenseTensor self, int i, int j, int k) -> double\n" "__call__(DenseTensor self, int i, int j, int k) -> double const &\n" ""}, - { "DenseTensor_GetData", _wrap_DenseTensor_GetData, METH_VARARGS, "GetData(DenseTensor self, int k) -> double *"}, + { "DenseTensor_GetData", (PyCFunction)(void(*)(void))_wrap_DenseTensor_GetData, METH_VARARGS|METH_KEYWORDS, "GetData(DenseTensor self, int k) -> double *"}, { "DenseTensor_Data", _wrap_DenseTensor_Data, METH_VARARGS, "\n" "Data(DenseTensor self) -> double\n" "Data(DenseTensor self) -> double const *\n" @@ -19819,22 +19144,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemory(DenseTensor self) -> mfem::Memory< double >\n" "GetMemory(DenseTensor self) -> mfem::Memory< double > const &\n" ""}, - { "DenseTensor_AddMult", _wrap_DenseTensor_AddMult, METH_VARARGS, "AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, + { "DenseTensor_AddMult", (PyCFunction)(void(*)(void))_wrap_DenseTensor_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"}, { "DenseTensor_Clear", _wrap_DenseTensor_Clear, METH_O, "Clear(DenseTensor self)"}, { "DenseTensor_MemoryUsage", _wrap_DenseTensor_MemoryUsage, METH_O, "MemoryUsage(DenseTensor self) -> long"}, - { "DenseTensor_Read", _wrap_DenseTensor_Read, METH_VARARGS, "Read(DenseTensor self, bool on_dev=True) -> double const"}, + { "DenseTensor_Read", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Read, METH_VARARGS|METH_KEYWORDS, "Read(DenseTensor self, bool on_dev=True) -> double const *"}, { "DenseTensor_HostRead", _wrap_DenseTensor_HostRead, METH_O, "HostRead(DenseTensor self) -> double const *"}, - { "DenseTensor_Write", _wrap_DenseTensor_Write, METH_VARARGS, "Write(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_Write", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Write, METH_VARARGS|METH_KEYWORDS, "Write(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostWrite", _wrap_DenseTensor_HostWrite, METH_O, "HostWrite(DenseTensor self) -> double *"}, - { "DenseTensor_ReadWrite", _wrap_DenseTensor_ReadWrite, METH_VARARGS, "ReadWrite(DenseTensor self, bool on_dev=True) -> double"}, + { "DenseTensor_ReadWrite", (PyCFunction)(void(*)(void))_wrap_DenseTensor_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(DenseTensor self, bool on_dev=True) -> double *"}, { "DenseTensor_HostReadWrite", _wrap_DenseTensor_HostReadWrite, METH_O, "HostReadWrite(DenseTensor self) -> double *"}, { "delete_DenseTensor", _wrap_delete_DenseTensor, METH_O, "delete_DenseTensor(DenseTensor self)"}, - { "DenseTensor_Assign", _wrap_DenseTensor_Assign, METH_VARARGS, "Assign(DenseTensor self, double const c)"}, + { "DenseTensor_Assign", (PyCFunction)(void(*)(void))_wrap_DenseTensor_Assign, METH_VARARGS|METH_KEYWORDS, "Assign(DenseTensor self, double const c)"}, { "DenseTensor___getitem__", _wrap_DenseTensor___getitem__, METH_VARARGS, "\n" "__getitem__(DenseTensor self, int const i, int const j, int const k) -> double const\n" "__getitem__(DenseTensor self, int const k) -> DenseMatrix\n" ""}, - { "DenseTensor___setitem__", _wrap_DenseTensor___setitem__, METH_VARARGS, "__setitem__(DenseTensor self, int i, int j, int k, double const v)"}, + { "DenseTensor___setitem__", (PyCFunction)(void(*)(void))_wrap_DenseTensor___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(DenseTensor self, int i, int j, int k, double const v)"}, { "DenseTensor_GetDataArray", _wrap_DenseTensor_GetDataArray, METH_O, "GetDataArray(DenseTensor self) -> PyObject *"}, { "DenseTensor_swigregister", DenseTensor_swigregister, METH_O, NULL}, { "DenseTensor_swiginit", DenseTensor_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/device.py b/mfem/_ser/device.py index 2843896a..eb4addb7 100644 --- a/mfem/_ser/device.py +++ b/mfem/_ser/device.py @@ -110,8 +110,8 @@ def Configure(self, device, dev=0): return _device.Device_Configure(self, device, dev) Configure = _swig_new_instance_method(_device.Device_Configure) - def Print(self, *args): - return _device.Device_Print(self, *args) + def Print(self, *args, **kwargs): + return _device.Device_Print(self, *args, **kwargs) Print = _swig_new_instance_method(_device.Device_Print) @staticmethod diff --git a/mfem/_ser/device_wrap.cxx b/mfem/_ser/device_wrap.cxx index 8b6f5deb..e85de6b5 100644 --- a/mfem/_ser/device_wrap.cxx +++ b/mfem/_ser/device_wrap.cxx @@ -3111,14 +3111,14 @@ SWIGINTERN PyObject *_wrap_new_Device__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py SWIGINTERN PyObject *_wrap_new_Device__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; std::string *arg1 = 0 ; - int arg2 ; + int arg2 = (int) (int)0 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; mfem::Device *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); @@ -3127,53 +3127,16 @@ SWIGINTERN PyObject *_wrap_new_Device__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); } arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Device" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - try { - result = (mfem::Device *)new mfem::Device((std::string const &)*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Device, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Device__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::Device *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Device" "', argument " "1"" of type '" "std::string const &""'"); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Device" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - arg1 = reinterpret_cast< std::string * >(argp1); { try { - result = (mfem::Device *)new mfem::Device((std::string const &)*arg1); + result = (mfem::Device *)new mfem::Device((std::string const &)*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3205,19 +3168,14 @@ SWIGINTERN PyObject *_wrap_new_Device(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Device__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Device__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_Device__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); @@ -3232,8 +3190,7 @@ SWIGINTERN PyObject *_wrap_new_Device(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Device'.\n" " Possible C/C++ prototypes are:\n" " mfem::Device::Device()\n" - " mfem::Device::Device(std::string const &,int const)\n" - " mfem::Device::Device(std::string const &)\n"); + " mfem::Device::Device(std::string const &,int const)\n"); return 0; } @@ -3275,25 +3232,31 @@ SWIGINTERN PyObject *_wrap_delete_Device(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Device_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Device *arg1 = (mfem::Device *) 0 ; std::string *arg2 = 0 ; - int arg3 ; + int arg3 = (int) (int)0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; int val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"device", (char *)"dev", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Device_Configure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Configure" "', argument " "1"" of type '" "mfem::Device *""'"); } arg1 = reinterpret_cast< mfem::Device * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); } @@ -3301,11 +3264,13 @@ SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); } arg2 = reinterpret_cast< std::string * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Device_Configure" "', argument " "3"" of type '" "int""'"); - } - arg3 = static_cast< int >(val3); + if (obj2) { + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Device_Configure" "', argument " "3"" of type '" "int""'"); + } + arg3 = static_cast< int >(val3); + } { try { (arg1)->Configure((std::string const &)*arg2,arg3); @@ -3329,163 +3294,40 @@ SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Device_Configure__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Device_Print(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Device *arg1 = (mfem::Device *) 0 ; - std::string *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Configure" "', argument " "1"" of type '" "mfem::Device *""'"); - } - arg1 = reinterpret_cast< mfem::Device * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Configure" "', argument " "2"" of type '" "std::string const &""'"); - } - arg2 = reinterpret_cast< std::string * >(argp2); - { - try { - (arg1)->Configure((std::string const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Device_Configure(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Device_Configure", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Device_Configure__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Device_Configure__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_Configure'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Device::Configure(std::string const &,int const)\n" - " mfem::Device::Configure(std::string const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Device_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Device *arg1 = (mfem::Device *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Device_Print", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Print" "', argument " "1"" of type '" "mfem::Device *""'"); } arg1 = reinterpret_cast< mfem::Device * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - { - try { - (arg1)->Print(*arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Device_Print" "', argument " "2"" of type '" "std::ostream &""'"); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg2 = reinterpret_cast< std::ostream * >(argp2); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Device_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Device *arg1 = (mfem::Device *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Device, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_Print" "', argument " "1"" of type '" "mfem::Device *""'"); - } - arg1 = reinterpret_cast< mfem::Device * >(argp1); { try { - (arg1)->Print(); + (arg1)->Print(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3506,47 +3348,6 @@ SWIGINTERN PyObject *_wrap_Device_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Device_Print(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Device_Print", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Device_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Device, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Device_Print__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_Print'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Device::Print(std::ostream &)\n" - " mfem::Device::Print()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Device_IsConfigured(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; bool result; @@ -3659,17 +3460,19 @@ SWIGINTERN PyObject *_wrap_Device_IsDisabled(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Device_Allows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Device_Allows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; unsigned long arg1 ; unsigned long val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_mask", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_unsigned_SS_long(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Device_Allows", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_long(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_Allows" "', argument " "1"" of type '" "unsigned long""'"); } @@ -3865,48 +3668,27 @@ SWIGINTERN PyObject *_wrap_Device_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - bool arg1 ; + bool arg1 = (bool) (bool)true ; bool val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"force", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_SetGPUAwareMPI" "', argument " "1"" of type '" "bool""'"); - } - arg1 = static_cast< bool >(val1); - { - try { - mfem::Device::SetGPUAwareMPI(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:Device_SetGPUAwareMPI", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_bool(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Device_SetGPUAwareMPI" "', argument " "1"" of type '" "bool""'"); + } + arg1 = static_cast< bool >(val1); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - mfem::Device::SetGPUAwareMPI(); + mfem::Device::SetGPUAwareMPI(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3927,37 +3709,6 @@ SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Device_SetGPUAwareMPI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Device_SetGPUAwareMPI", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_Device_SetGPUAwareMPI__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_bool(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Device_SetGPUAwareMPI__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Device_SetGPUAwareMPI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Device::SetGPUAwareMPI(bool const)\n" - " mfem::Device::SetGPUAwareMPI()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Device_GetGPUAwareMPI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; bool result; @@ -4006,20 +3757,20 @@ static PyMethodDef SwigMethods[] = { { "Backend_swiginit", Backend_swiginit, METH_VARARGS, NULL}, { "new_Device", _wrap_new_Device, METH_VARARGS, NULL}, { "delete_Device", _wrap_delete_Device, METH_O, NULL}, - { "Device_Configure", _wrap_Device_Configure, METH_VARARGS, NULL}, - { "Device_Print", _wrap_Device_Print, METH_VARARGS, NULL}, + { "Device_Configure", (PyCFunction)(void(*)(void))_wrap_Device_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, + { "Device_Print", (PyCFunction)(void(*)(void))_wrap_Device_Print, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_IsConfigured", _wrap_Device_IsConfigured, METH_NOARGS, NULL}, { "Device_IsAvailable", _wrap_Device_IsAvailable, METH_NOARGS, NULL}, { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, - { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_Allows", (PyCFunction)(void(*)(void))_wrap_Device_Allows, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, - { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_SetGPUAwareMPI", (PyCFunction)(void(*)(void))_wrap_Device_SetGPUAwareMPI, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, { "Device_swigregister", Device_swigregister, METH_O, NULL}, { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, @@ -4035,20 +3786,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Backend_swiginit", Backend_swiginit, METH_VARARGS, NULL}, { "new_Device", _wrap_new_Device, METH_VARARGS, NULL}, { "delete_Device", _wrap_delete_Device, METH_O, NULL}, - { "Device_Configure", _wrap_Device_Configure, METH_VARARGS, NULL}, - { "Device_Print", _wrap_Device_Print, METH_VARARGS, NULL}, + { "Device_Configure", (PyCFunction)(void(*)(void))_wrap_Device_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, + { "Device_Print", (PyCFunction)(void(*)(void))_wrap_Device_Print, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_IsConfigured", _wrap_Device_IsConfigured, METH_NOARGS, NULL}, { "Device_IsAvailable", _wrap_Device_IsAvailable, METH_NOARGS, NULL}, { "Device_IsEnabled", _wrap_Device_IsEnabled, METH_NOARGS, NULL}, { "Device_IsDisabled", _wrap_Device_IsDisabled, METH_NOARGS, NULL}, - { "Device_Allows", _wrap_Device_Allows, METH_O, NULL}, + { "Device_Allows", (PyCFunction)(void(*)(void))_wrap_Device_Allows, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetHostMemoryType", _wrap_Device_GetHostMemoryType, METH_NOARGS, NULL}, { "Device_GetHostMemoryClass", _wrap_Device_GetHostMemoryClass, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryType", _wrap_Device_GetDeviceMemoryType, METH_NOARGS, NULL}, { "Device_GetMemoryType", _wrap_Device_GetMemoryType, METH_NOARGS, NULL}, { "Device_GetDeviceMemoryClass", _wrap_Device_GetDeviceMemoryClass, METH_NOARGS, NULL}, { "Device_GetMemoryClass", _wrap_Device_GetMemoryClass, METH_NOARGS, NULL}, - { "Device_SetGPUAwareMPI", _wrap_Device_SetGPUAwareMPI, METH_VARARGS, NULL}, + { "Device_SetGPUAwareMPI", (PyCFunction)(void(*)(void))_wrap_Device_SetGPUAwareMPI, METH_VARARGS|METH_KEYWORDS, NULL}, { "Device_GetGPUAwareMPI", _wrap_Device_GetGPUAwareMPI, METH_NOARGS, NULL}, { "Device_swigregister", Device_swigregister, METH_O, NULL}, { "Device_swiginit", Device_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/element_wrap.cxx b/mfem/_ser/element_wrap.cxx index 505f6f66..1515134a 100644 --- a/mfem/_ser/element_wrap.cxx +++ b/mfem/_ser/element_wrap.cxx @@ -3345,25 +3345,29 @@ SWIGINTERN PyObject *_wrap_Element_GetAttribute(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Element_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_SetAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_SetAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_SetAttribute" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3391,7 +3395,7 @@ SWIGINTERN PyObject *_wrap_Element_SetAttribute(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Element_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int *arg2 = (int *) 0 ; @@ -3399,15 +3403,19 @@ SWIGINTERN PyObject *_wrap_Element_SetVertices(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ind", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_SetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_SetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_SetVertices" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_SetVertices" "', argument " "2"" of type '" "int const *""'"); } @@ -3698,26 +3706,30 @@ SWIGINTERN PyObject *_wrap_Element_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Element_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Element_GetEdgeVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_GetEdgeVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3875,26 +3887,30 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaces(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Element_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_GetNFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3922,26 +3938,30 @@ SWIGINTERN PyObject *_wrap_Element_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Element_GetFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_GetFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_GetFaceVertices" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3969,7 +3989,7 @@ SWIGINTERN PyObject *_wrap_Element_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; mfem::DSTable *arg2 = 0 ; @@ -3980,15 +4000,20 @@ SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v_to_v", (char *)"length", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_MarkEdge", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Element_MarkEdge", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_MarkEdge" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DSTable, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DSTable, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_MarkEdge" "', argument " "2"" of type '" "mfem::DSTable const &""'"); } @@ -3996,7 +4021,7 @@ SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Element_MarkEdge" "', argument " "2"" of type '" "mfem::DSTable const &""'"); } arg2 = reinterpret_cast< mfem::DSTable * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Element_MarkEdge" "', argument " "3"" of type '" "int const *""'"); } @@ -4027,7 +4052,7 @@ SWIGINTERN PyObject *_wrap_Element_MarkEdge(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; mfem::HashTable< mfem::Hashed2 > *arg2 = 0 ; @@ -4035,16 +4060,20 @@ SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v_to_v", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Element_NeedRefinement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_NeedRefinement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_NeedRefinement" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__HashTableT_mfem__Hashed2_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__HashTableT_mfem__Hashed2_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_NeedRefinement" "', argument " "2"" of type '" "mfem::HashTable< mfem::Hashed2 > &""'"); } @@ -4078,25 +4107,29 @@ SWIGINTERN PyObject *_wrap_Element_NeedRefinement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Element_ResetTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_ResetTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_ResetTransform", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_ResetTransform", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_ResetTransform" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4124,25 +4157,29 @@ SWIGINTERN PyObject *_wrap_Element_ResetTransform(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Element_PushTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_PushTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Element_PushTransform", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_PushTransform", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_PushTransform" "', argument " "1"" of type '" "mfem::Element *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4211,7 +4248,7 @@ SWIGINTERN PyObject *_wrap_Element_GetTransform(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Element_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Element_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Element *arg1 = (mfem::Element *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -4219,16 +4256,20 @@ SWIGINTERN PyObject *_wrap_Element_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::Element *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Element_Duplicate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Element_Duplicate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Element, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Element_Duplicate" "', argument " "1"" of type '" "mfem::Element const *""'"); } arg1 = reinterpret_cast< mfem::Element * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Element_Duplicate" "', argument " "2"" of type '" "mfem::Mesh *""'"); } @@ -4353,8 +4394,8 @@ static PyMethodDef SwigMethods[] = { { "Element_GetType", _wrap_Element_GetType, METH_O, "Element_GetType(Element self) -> mfem::Element::Type"}, { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "Element_GetGeometryType(Element self) -> mfem::Geometry::Type"}, { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "Element_GetAttribute(Element self) -> int"}, - { "Element_SetAttribute", _wrap_Element_SetAttribute, METH_VARARGS, "Element_SetAttribute(Element self, int const attr)"}, - { "Element_SetVertices", _wrap_Element_SetVertices, METH_VARARGS, "Element_SetVertices(Element self, int const * ind)"}, + { "Element_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Element_SetAttribute, METH_VARARGS|METH_KEYWORDS, "Element_SetAttribute(Element self, int const attr)"}, + { "Element_SetVertices", (PyCFunction)(void(*)(void))_wrap_Element_SetVertices, METH_VARARGS|METH_KEYWORDS, "Element_SetVertices(Element self, int const * ind)"}, { "Element_GetVertices", _wrap_Element_GetVertices, METH_VARARGS, "\n" "Element_GetVertices(Element self, intArray v)\n" "Element_GetVertices(Element self) -> int\n" @@ -4362,19 +4403,19 @@ static PyMethodDef SwigMethods[] = { ""}, { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "Element_GetNVertices(Element self) -> int"}, { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "Element_GetNEdges(Element self) -> int"}, - { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "Element_GetEdgeVertices(Element self, int arg2) -> int const *"}, + { "Element_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Element_GetEdgeVertices(Element self, int arg2) -> int const *"}, { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" "Element_GetNFaces(Element self, int & nFaceVertices) -> int\n" "Element_GetNFaces(Element self) -> int\n" ""}, - { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "Element_GetNFaceVertices(Element self, int fi) -> int"}, - { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "Element_GetFaceVertices(Element self, int fi) -> int const *"}, - { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "Element_MarkEdge(Element self, DSTable v_to_v, int const * length)"}, - { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "Element_NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, - { "Element_ResetTransform", _wrap_Element_ResetTransform, METH_VARARGS, "Element_ResetTransform(Element self, int tr)"}, - { "Element_PushTransform", _wrap_Element_PushTransform, METH_VARARGS, "Element_PushTransform(Element self, int tr)"}, + { "Element_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "Element_GetNFaceVertices(Element self, int fi) -> int"}, + { "Element_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Element_GetFaceVertices(Element self, int fi) -> int const *"}, + { "Element_MarkEdge", (PyCFunction)(void(*)(void))_wrap_Element_MarkEdge, METH_VARARGS|METH_KEYWORDS, "Element_MarkEdge(Element self, DSTable v_to_v, int const * length)"}, + { "Element_NeedRefinement", (PyCFunction)(void(*)(void))_wrap_Element_NeedRefinement, METH_VARARGS|METH_KEYWORDS, "Element_NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, + { "Element_ResetTransform", (PyCFunction)(void(*)(void))_wrap_Element_ResetTransform, METH_VARARGS|METH_KEYWORDS, "Element_ResetTransform(Element self, int tr)"}, + { "Element_PushTransform", (PyCFunction)(void(*)(void))_wrap_Element_PushTransform, METH_VARARGS|METH_KEYWORDS, "Element_PushTransform(Element self, int tr)"}, { "Element_GetTransform", _wrap_Element_GetTransform, METH_O, "Element_GetTransform(Element self) -> unsigned int"}, - { "Element_Duplicate", _wrap_Element_Duplicate, METH_VARARGS, "Element_Duplicate(Element self, mfem::Mesh * m) -> Element"}, + { "Element_Duplicate", (PyCFunction)(void(*)(void))_wrap_Element_Duplicate, METH_VARARGS|METH_KEYWORDS, "Element_Duplicate(Element self, mfem::Mesh * m) -> Element"}, { "delete_Element", _wrap_delete_Element, METH_O, "delete_Element(Element self)"}, { "Element_GetVerticesArray", _wrap_Element_GetVerticesArray, METH_O, "Element_GetVerticesArray(Element self) -> PyObject *"}, { "Element_swigregister", Element_swigregister, METH_O, NULL}, @@ -4387,8 +4428,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Element_GetType", _wrap_Element_GetType, METH_O, "GetType(Element self) -> mfem::Element::Type"}, { "Element_GetGeometryType", _wrap_Element_GetGeometryType, METH_O, "GetGeometryType(Element self) -> mfem::Geometry::Type"}, { "Element_GetAttribute", _wrap_Element_GetAttribute, METH_O, "GetAttribute(Element self) -> int"}, - { "Element_SetAttribute", _wrap_Element_SetAttribute, METH_VARARGS, "SetAttribute(Element self, int const attr)"}, - { "Element_SetVertices", _wrap_Element_SetVertices, METH_VARARGS, "SetVertices(Element self, int const * ind)"}, + { "Element_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Element_SetAttribute, METH_VARARGS|METH_KEYWORDS, "SetAttribute(Element self, int const attr)"}, + { "Element_SetVertices", (PyCFunction)(void(*)(void))_wrap_Element_SetVertices, METH_VARARGS|METH_KEYWORDS, "SetVertices(Element self, int const * ind)"}, { "Element_GetVertices", _wrap_Element_GetVertices, METH_VARARGS, "\n" "GetVertices(Element self, intArray v)\n" "GetVertices(Element self) -> int\n" @@ -4396,19 +4437,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Element_GetNVertices", _wrap_Element_GetNVertices, METH_O, "GetNVertices(Element self) -> int"}, { "Element_GetNEdges", _wrap_Element_GetNEdges, METH_O, "GetNEdges(Element self) -> int"}, - { "Element_GetEdgeVertices", _wrap_Element_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Element self, int arg2) -> int const *"}, + { "Element_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Element self, int arg2) -> int const *"}, { "Element_GetNFaces", _wrap_Element_GetNFaces, METH_VARARGS, "\n" "GetNFaces(Element self, int & nFaceVertices) -> int\n" "GetNFaces(Element self) -> int\n" ""}, - { "Element_GetNFaceVertices", _wrap_Element_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Element self, int fi) -> int"}, - { "Element_GetFaceVertices", _wrap_Element_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Element self, int fi) -> int const *"}, - { "Element_MarkEdge", _wrap_Element_MarkEdge, METH_VARARGS, "MarkEdge(Element self, DSTable v_to_v, int const * length)"}, - { "Element_NeedRefinement", _wrap_Element_NeedRefinement, METH_VARARGS, "NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, - { "Element_ResetTransform", _wrap_Element_ResetTransform, METH_VARARGS, "ResetTransform(Element self, int tr)"}, - { "Element_PushTransform", _wrap_Element_PushTransform, METH_VARARGS, "PushTransform(Element self, int tr)"}, + { "Element_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetNFaceVertices(Element self, int fi) -> int"}, + { "Element_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Element_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Element self, int fi) -> int const *"}, + { "Element_MarkEdge", (PyCFunction)(void(*)(void))_wrap_Element_MarkEdge, METH_VARARGS|METH_KEYWORDS, "MarkEdge(Element self, DSTable v_to_v, int const * length)"}, + { "Element_NeedRefinement", (PyCFunction)(void(*)(void))_wrap_Element_NeedRefinement, METH_VARARGS|METH_KEYWORDS, "NeedRefinement(Element self, mfem::HashTable< mfem::Hashed2 > & v_to_v) -> int"}, + { "Element_ResetTransform", (PyCFunction)(void(*)(void))_wrap_Element_ResetTransform, METH_VARARGS|METH_KEYWORDS, "ResetTransform(Element self, int tr)"}, + { "Element_PushTransform", (PyCFunction)(void(*)(void))_wrap_Element_PushTransform, METH_VARARGS|METH_KEYWORDS, "PushTransform(Element self, int tr)"}, { "Element_GetTransform", _wrap_Element_GetTransform, METH_O, "GetTransform(Element self) -> unsigned int"}, - { "Element_Duplicate", _wrap_Element_Duplicate, METH_VARARGS, "Duplicate(Element self, mfem::Mesh * m) -> Element"}, + { "Element_Duplicate", (PyCFunction)(void(*)(void))_wrap_Element_Duplicate, METH_VARARGS|METH_KEYWORDS, "Duplicate(Element self, mfem::Mesh * m) -> Element"}, { "delete_Element", _wrap_delete_Element, METH_O, "delete_Element(Element self)"}, { "Element_GetVerticesArray", _wrap_Element_GetVerticesArray, METH_O, "GetVerticesArray(Element self) -> PyObject *"}, { "Element_swigregister", Element_swigregister, METH_O, NULL}, diff --git a/mfem/_ser/eltrans_wrap.cxx b/mfem/_ser/eltrans_wrap.cxx index f4b7972c..34ddcc87 100644 --- a/mfem/_ser/eltrans_wrap.cxx +++ b/mfem/_ser/eltrans_wrap.cxx @@ -3560,7 +3560,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_ElementNo_get(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ElementTransformation_SetIntPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementTransformation_SetIntPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; mfem::IntegrationPoint *arg2 = (mfem::IntegrationPoint *) 0 ; @@ -3568,15 +3568,19 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_SetIntPoint(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementTransformation_SetIntPoint", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElementTransformation_SetIntPoint", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_SetIntPoint" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementTransformation_SetIntPoint" "', argument " "2"" of type '" "mfem::IntegrationPoint const *""'"); } @@ -4229,7 +4233,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_OrderW(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_ElementTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; mfem::FiniteElement *arg2 = (mfem::FiniteElement *) 0 ; @@ -4237,16 +4241,20 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_OrderGrad(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ElementTransformation_OrderGrad", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElementTransformation_OrderGrad", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_OrderGrad" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementTransformation_OrderGrad" "', argument " "2"" of type '" "mfem::FiniteElement const *""'"); } @@ -4400,7 +4408,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_GetSpaceDim(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4411,16 +4419,21 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ip", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ElementTransformation_TransformBack", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementTransformation_TransformBack", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementTransformation_TransformBack" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4428,7 +4441,7 @@ SWIGINTERN PyObject *_wrap_ElementTransformation_TransformBack(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementTransformation_TransformBack" "', argument " "3"" of type '" "mfem::IntegrationPoint &""'"); } @@ -4509,53 +4522,28 @@ SWIGINTERN PyObject *ElementTransformation_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_InverseElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_InverseElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) 0 ; + mfem::ElementTransformation *arg1 = (mfem::ElementTransformation *) NULL ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"Trans", NULL + }; mfem::InverseElementTransformation *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseElementTransformation" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); - } - arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); - { - try { - result = (mfem::InverseElementTransformation *)new mfem::InverseElementTransformation(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_InverseElementTransformation", kwnames, &obj0)) SWIG_fail; + if (obj0) { + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InverseElementTransformation" "', argument " "1"" of type '" "mfem::ElementTransformation *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg1 = reinterpret_cast< mfem::ElementTransformation * >(argp1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__InverseElementTransformation, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_InverseElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::InverseElementTransformation *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::InverseElementTransformation *)new mfem::InverseElementTransformation(); + result = (mfem::InverseElementTransformation *)new mfem::InverseElementTransformation(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4579,36 +4567,6 @@ SWIGINTERN PyObject *_wrap_new_InverseElementTransformation__SWIG_1(PyObject *SW } -SWIGINTERN PyObject *_wrap_new_InverseElementTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_InverseElementTransformation", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_InverseElementTransformation__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ElementTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_InverseElementTransformation__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_InverseElementTransformation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::InverseElementTransformation::InverseElementTransformation(mfem::ElementTransformation *)\n" - " mfem::InverseElementTransformation::InverseElementTransformation()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_InverseElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; @@ -4649,7 +4607,7 @@ SWIGINTERN PyObject *_wrap_delete_InverseElementTransformation(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -4657,15 +4615,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetTransformation" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_SetTransformation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -4699,7 +4661,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetTransformation(PyObje } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::InverseElementTransformation::InitGuessType arg2 ; @@ -4707,15 +4669,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"itype", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitialGuessType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitialGuessType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitialGuessType" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetInitialGuessType" "', argument " "2"" of type '" "mfem::InverseElementTransformation::InitGuessType""'"); } @@ -4746,7 +4712,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuessType(PyOb } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -4754,15 +4720,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"init_ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitialGuess", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitialGuess", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitialGuess" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_SetInitialGuess" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4796,25 +4766,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitialGuess(PyObject } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessPointsType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessPointsType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q_type", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitGuessPointsType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitGuessPointsType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitGuessPointsType" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4842,25 +4816,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessPointsType(P } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessRelOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessRelOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"order", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetInitGuessRelOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetInitGuessRelOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetInitGuessRelOrder" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4888,7 +4866,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetInitGuessRelOrder(PyO } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::InverseElementTransformation::SolverType arg2 ; @@ -4896,15 +4874,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"stype", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetSolverType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetSolverType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetSolverType" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetSolverType" "', argument " "2"" of type '" "mfem::InverseElementTransformation::SolverType""'"); } @@ -4935,25 +4917,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetSolverType(PyObject * } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_it", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetMaxIter" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4981,7 +4967,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetMaxIter(PyObject *SWI } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; double arg2 ; @@ -4989,15 +4975,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ref_sp_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetReferenceTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetReferenceTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetReferenceTol" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetReferenceTol" "', argument " "2"" of type '" "double""'"); } @@ -5028,7 +5018,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetReferenceTol(PyObject } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; double arg2 ; @@ -5036,15 +5026,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"phys_rel_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetPhysicalRelTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetPhysicalRelTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetPhysicalRelTol" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetPhysicalRelTol" "', argument " "2"" of type '" "double""'"); } @@ -5075,7 +5069,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPhysicalRelTol(PyObje } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; double arg2 ; @@ -5083,15 +5077,19 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject * int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el_tol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetElementTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetElementTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetElementTol" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InverseElementTransformation_SetElementTol" "', argument " "2"" of type '" "double""'"); } @@ -5122,25 +5120,29 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetElementTol(PyObject * } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseElementTransformation_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_SetPrintLevel" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5168,7 +5170,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_SetPrintLevel(PyObject * } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5179,16 +5181,21 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ir", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_FindClosestPhysPoint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseElementTransformation_FindClosestPhysPoint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5196,7 +5203,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseElementTransformation_FindClosestPhysPoint" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } @@ -5230,7 +5237,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestPhysPoint(PyO } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5241,16 +5248,21 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ir", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_FindClosestRefPoint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseElementTransformation_FindClosestRefPoint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5258,7 +5270,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseElementTransformation_FindClosestRefPoint" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } @@ -5292,7 +5304,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_FindClosestRefPoint(PyOb } -SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseElementTransformation *arg1 = (mfem::InverseElementTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5303,16 +5315,21 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pt", (char *)"ip", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "InverseElementTransformation_Transform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseElementTransformation_Transform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseElementTransformation_Transform" "', argument " "1"" of type '" "mfem::InverseElementTransformation *""'"); } arg1 = reinterpret_cast< mfem::InverseElementTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseElementTransformation_Transform" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5320,7 +5337,7 @@ SWIGINTERN PyObject *_wrap_InverseElementTransformation_Transform(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseElementTransformation_Transform" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseElementTransformation_Transform" "', argument " "3"" of type '" "mfem::IntegrationPoint &""'"); } @@ -5365,7 +5382,7 @@ SWIGINTERN PyObject *InverseElementTransformation_swiginit(PyObject *SWIGUNUSEDP return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::FiniteElement *arg2 = (mfem::FiniteElement *) 0 ; @@ -5373,15 +5390,19 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetFE(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FE", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_SetFE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IsoparametricTransformation_SetFE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_SetFE" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsoparametricTransformation_SetFE" "', argument " "2"" of type '" "mfem::FiniteElement const *""'"); } @@ -5534,7 +5555,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_FinalizeTransformation(Py } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetIdentityTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetIdentityTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::Geometry::Type arg2 ; @@ -5542,15 +5563,19 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_SetIdentityTransformation int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_SetIdentityTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IsoparametricTransformation_SetIdentityTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_SetIdentityTransformation" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IsoparametricTransformation_SetIdentityTransformation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -5957,7 +5982,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderW(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::FiniteElement *arg2 = (mfem::FiniteElement *) 0 ; @@ -5965,16 +5990,20 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_OrderGrad", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IsoparametricTransformation_OrderGrad", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_OrderGrad" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsoparametricTransformation_OrderGrad" "', argument " "2"" of type '" "mfem::FiniteElement const *""'"); } @@ -6005,7 +6034,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_OrderGrad(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IsoparametricTransformation *arg1 = (mfem::IsoparametricTransformation *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6016,16 +6045,21 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", (char *)"ip", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IsoparametricTransformation_TransformBack", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IsoparametricTransformation_TransformBack", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsoparametricTransformation_TransformBack" "', argument " "1"" of type '" "mfem::IsoparametricTransformation *""'"); } arg1 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IsoparametricTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6033,7 +6067,7 @@ SWIGINTERN PyObject *_wrap_IsoparametricTransformation_TransformBack(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IsoparametricTransformation_TransformBack" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IsoparametricTransformation_TransformBack" "', argument " "3"" of type '" "mfem::IntegrationPoint &""'"); } @@ -6959,7 +6993,7 @@ static PyMethodDef SwigMethods[] = { { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, { "ElementTransformation_ElementNo_get", _wrap_ElementTransformation_ElementNo_get, METH_O, "ElementTransformation_ElementNo_get(ElementTransformation self) -> int"}, - { "ElementTransformation_SetIntPoint", _wrap_ElementTransformation_SetIntPoint, METH_VARARGS, "ElementTransformation_SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, + { "ElementTransformation_SetIntPoint", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_SetIntPoint, METH_VARARGS|METH_KEYWORDS, "ElementTransformation_SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, { "ElementTransformation_GetIntPoint", _wrap_ElementTransformation_GetIntPoint, METH_O, "ElementTransformation_GetIntPoint(ElementTransformation self) -> IntegrationPoint"}, { "ElementTransformation_Transform", _wrap_ElementTransformation_Transform, METH_VARARGS, "\n" "ElementTransformation_Transform(ElementTransformation self, IntegrationPoint arg2, Vector arg3)\n" @@ -6974,36 +7008,36 @@ static PyMethodDef SwigMethods[] = { { "ElementTransformation_Order", _wrap_ElementTransformation_Order, METH_O, "ElementTransformation_Order(ElementTransformation self) -> int"}, { "ElementTransformation_OrderJ", _wrap_ElementTransformation_OrderJ, METH_O, "ElementTransformation_OrderJ(ElementTransformation self) -> int"}, { "ElementTransformation_OrderW", _wrap_ElementTransformation_OrderW, METH_O, "ElementTransformation_OrderW(ElementTransformation self) -> int"}, - { "ElementTransformation_OrderGrad", _wrap_ElementTransformation_OrderGrad, METH_VARARGS, "ElementTransformation_OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, + { "ElementTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "ElementTransformation_OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, { "ElementTransformation_GetGeometryType", _wrap_ElementTransformation_GetGeometryType, METH_O, "ElementTransformation_GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type"}, { "ElementTransformation_GetDimension", _wrap_ElementTransformation_GetDimension, METH_O, "ElementTransformation_GetDimension(ElementTransformation self) -> int"}, { "ElementTransformation_GetSpaceDim", _wrap_ElementTransformation_GetSpaceDim, METH_O, "ElementTransformation_GetSpaceDim(ElementTransformation self) -> int"}, - { "ElementTransformation_TransformBack", _wrap_ElementTransformation_TransformBack, METH_VARARGS, "ElementTransformation_TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "ElementTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "ElementTransformation_TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "delete_ElementTransformation", _wrap_delete_ElementTransformation, METH_O, "delete_ElementTransformation(ElementTransformation self)"}, { "ElementTransformation_swigregister", ElementTransformation_swigregister, METH_O, NULL}, - { "new_InverseElementTransformation", _wrap_new_InverseElementTransformation, METH_VARARGS, "InverseElementTransformation(ElementTransformation Trans=None)"}, + { "new_InverseElementTransformation", (PyCFunction)(void(*)(void))_wrap_new_InverseElementTransformation, METH_VARARGS|METH_KEYWORDS, "new_InverseElementTransformation(ElementTransformation Trans=None) -> InverseElementTransformation"}, { "delete_InverseElementTransformation", _wrap_delete_InverseElementTransformation, METH_O, "delete_InverseElementTransformation(InverseElementTransformation self)"}, - { "InverseElementTransformation_SetTransformation", _wrap_InverseElementTransformation_SetTransformation, METH_VARARGS, "InverseElementTransformation_SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, - { "InverseElementTransformation_SetInitialGuessType", _wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS, "InverseElementTransformation_SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, - { "InverseElementTransformation_SetInitialGuess", _wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS, "InverseElementTransformation_SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, - { "InverseElementTransformation_SetInitGuessPointsType", _wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS, "InverseElementTransformation_SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, - { "InverseElementTransformation_SetInitGuessRelOrder", _wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS, "InverseElementTransformation_SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, - { "InverseElementTransformation_SetSolverType", _wrap_InverseElementTransformation_SetSolverType, METH_VARARGS, "InverseElementTransformation_SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, - { "InverseElementTransformation_SetMaxIter", _wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS, "InverseElementTransformation_SetMaxIter(InverseElementTransformation self, int max_it)"}, - { "InverseElementTransformation_SetReferenceTol", _wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS, "InverseElementTransformation_SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, - { "InverseElementTransformation_SetPhysicalRelTol", _wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS, "InverseElementTransformation_SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, - { "InverseElementTransformation_SetElementTol", _wrap_InverseElementTransformation_SetElementTol, METH_VARARGS, "InverseElementTransformation_SetElementTol(InverseElementTransformation self, double el_tol)"}, - { "InverseElementTransformation_SetPrintLevel", _wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS, "InverseElementTransformation_SetPrintLevel(InverseElementTransformation self, int pr_level)"}, - { "InverseElementTransformation_FindClosestPhysPoint", _wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS, "InverseElementTransformation_FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_FindClosestRefPoint", _wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS, "InverseElementTransformation_FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_Transform", _wrap_InverseElementTransformation_Transform, METH_VARARGS, "InverseElementTransformation_Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "InverseElementTransformation_SetTransformation", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetTransformation, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, + { "InverseElementTransformation_SetInitialGuessType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, + { "InverseElementTransformation_SetInitialGuess", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, + { "InverseElementTransformation_SetInitGuessPointsType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, + { "InverseElementTransformation_SetInitGuessRelOrder", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, + { "InverseElementTransformation_SetSolverType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetSolverType, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, + { "InverseElementTransformation_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetMaxIter(InverseElementTransformation self, int max_it)"}, + { "InverseElementTransformation_SetReferenceTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, + { "InverseElementTransformation_SetPhysicalRelTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, + { "InverseElementTransformation_SetElementTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetElementTol, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetElementTol(InverseElementTransformation self, double el_tol)"}, + { "InverseElementTransformation_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_SetPrintLevel(InverseElementTransformation self, int pr_level)"}, + { "InverseElementTransformation_FindClosestPhysPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_FindClosestRefPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_Transform", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_Transform, METH_VARARGS|METH_KEYWORDS, "InverseElementTransformation_Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "InverseElementTransformation_swigregister", InverseElementTransformation_swigregister, METH_O, NULL}, { "InverseElementTransformation_swiginit", InverseElementTransformation_swiginit, METH_VARARGS, NULL}, - { "IsoparametricTransformation_SetFE", _wrap_IsoparametricTransformation_SetFE, METH_VARARGS, "IsoparametricTransformation_SetFE(IsoparametricTransformation self, FiniteElement FE)"}, + { "IsoparametricTransformation_SetFE", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetFE, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_SetFE(IsoparametricTransformation self, FiniteElement FE)"}, { "IsoparametricTransformation_GetFE", _wrap_IsoparametricTransformation_GetFE, METH_O, "IsoparametricTransformation_GetFE(IsoparametricTransformation self) -> FiniteElement"}, { "IsoparametricTransformation_GetPointMat", _wrap_IsoparametricTransformation_GetPointMat, METH_O, "IsoparametricTransformation_GetPointMat(IsoparametricTransformation self) -> DenseMatrix"}, { "IsoparametricTransformation_FinalizeTransformation", _wrap_IsoparametricTransformation_FinalizeTransformation, METH_O, "IsoparametricTransformation_FinalizeTransformation(IsoparametricTransformation self)"}, - { "IsoparametricTransformation_SetIdentityTransformation", _wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS, "IsoparametricTransformation_SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, + { "IsoparametricTransformation_SetIdentityTransformation", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, { "IsoparametricTransformation_Transform", _wrap_IsoparametricTransformation_Transform, METH_VARARGS, "\n" "IsoparametricTransformation_Transform(IsoparametricTransformation self, IntegrationPoint arg2, Vector arg3)\n" "IsoparametricTransformation_Transform(IsoparametricTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" @@ -7012,8 +7046,8 @@ static PyMethodDef SwigMethods[] = { { "IsoparametricTransformation_Order", _wrap_IsoparametricTransformation_Order, METH_O, "IsoparametricTransformation_Order(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderJ", _wrap_IsoparametricTransformation_OrderJ, METH_O, "IsoparametricTransformation_OrderJ(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderW", _wrap_IsoparametricTransformation_OrderW, METH_O, "IsoparametricTransformation_OrderW(IsoparametricTransformation self) -> int"}, - { "IsoparametricTransformation_OrderGrad", _wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS, "IsoparametricTransformation_OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, - { "IsoparametricTransformation_TransformBack", _wrap_IsoparametricTransformation_TransformBack, METH_VARARGS, "IsoparametricTransformation_TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, + { "IsoparametricTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, + { "IsoparametricTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "IsoparametricTransformation_TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, { "delete_IsoparametricTransformation", _wrap_delete_IsoparametricTransformation, METH_O, "delete_IsoparametricTransformation(IsoparametricTransformation self)"}, { "new_IsoparametricTransformation", _wrap_new_IsoparametricTransformation, METH_NOARGS, "new_IsoparametricTransformation() -> IsoparametricTransformation"}, { "IsoparametricTransformation_swigregister", IsoparametricTransformation_swigregister, METH_O, NULL}, @@ -7058,7 +7092,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "ElementTransformation_Attribute_get", _wrap_ElementTransformation_Attribute_get, METH_O, "ElementTransformation_Attribute_get(ElementTransformation self) -> int"}, { "ElementTransformation_ElementNo_set", _wrap_ElementTransformation_ElementNo_set, METH_VARARGS, "ElementTransformation_ElementNo_set(ElementTransformation self, int ElementNo)"}, { "ElementTransformation_ElementNo_get", _wrap_ElementTransformation_ElementNo_get, METH_O, "ElementTransformation_ElementNo_get(ElementTransformation self) -> int"}, - { "ElementTransformation_SetIntPoint", _wrap_ElementTransformation_SetIntPoint, METH_VARARGS, "SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, + { "ElementTransformation_SetIntPoint", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_SetIntPoint, METH_VARARGS|METH_KEYWORDS, "SetIntPoint(ElementTransformation self, IntegrationPoint ip)"}, { "ElementTransformation_GetIntPoint", _wrap_ElementTransformation_GetIntPoint, METH_O, "GetIntPoint(ElementTransformation self) -> IntegrationPoint"}, { "ElementTransformation_Transform", _wrap_ElementTransformation_Transform, METH_VARARGS, "\n" "Transform(ElementTransformation self, IntegrationPoint arg2, Vector arg3)\n" @@ -7073,36 +7107,36 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "ElementTransformation_Order", _wrap_ElementTransformation_Order, METH_O, "Order(ElementTransformation self) -> int"}, { "ElementTransformation_OrderJ", _wrap_ElementTransformation_OrderJ, METH_O, "OrderJ(ElementTransformation self) -> int"}, { "ElementTransformation_OrderW", _wrap_ElementTransformation_OrderW, METH_O, "OrderW(ElementTransformation self) -> int"}, - { "ElementTransformation_OrderGrad", _wrap_ElementTransformation_OrderGrad, METH_VARARGS, "OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, + { "ElementTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "OrderGrad(ElementTransformation self, FiniteElement fe) -> int"}, { "ElementTransformation_GetGeometryType", _wrap_ElementTransformation_GetGeometryType, METH_O, "GetGeometryType(ElementTransformation self) -> mfem::Geometry::Type"}, { "ElementTransformation_GetDimension", _wrap_ElementTransformation_GetDimension, METH_O, "GetDimension(ElementTransformation self) -> int"}, { "ElementTransformation_GetSpaceDim", _wrap_ElementTransformation_GetSpaceDim, METH_O, "GetSpaceDim(ElementTransformation self) -> int"}, - { "ElementTransformation_TransformBack", _wrap_ElementTransformation_TransformBack, METH_VARARGS, "TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "ElementTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_ElementTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "TransformBack(ElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "delete_ElementTransformation", _wrap_delete_ElementTransformation, METH_O, "delete_ElementTransformation(ElementTransformation self)"}, { "ElementTransformation_swigregister", ElementTransformation_swigregister, METH_O, NULL}, - { "new_InverseElementTransformation", _wrap_new_InverseElementTransformation, METH_VARARGS, "InverseElementTransformation(ElementTransformation Trans=None)"}, + { "new_InverseElementTransformation", (PyCFunction)(void(*)(void))_wrap_new_InverseElementTransformation, METH_VARARGS|METH_KEYWORDS, "new_InverseElementTransformation(ElementTransformation Trans=None) -> InverseElementTransformation"}, { "delete_InverseElementTransformation", _wrap_delete_InverseElementTransformation, METH_O, "delete_InverseElementTransformation(InverseElementTransformation self)"}, - { "InverseElementTransformation_SetTransformation", _wrap_InverseElementTransformation_SetTransformation, METH_VARARGS, "SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, - { "InverseElementTransformation_SetInitialGuessType", _wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS, "SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, - { "InverseElementTransformation_SetInitialGuess", _wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS, "SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, - { "InverseElementTransformation_SetInitGuessPointsType", _wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS, "SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, - { "InverseElementTransformation_SetInitGuessRelOrder", _wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS, "SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, - { "InverseElementTransformation_SetSolverType", _wrap_InverseElementTransformation_SetSolverType, METH_VARARGS, "SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, - { "InverseElementTransformation_SetMaxIter", _wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS, "SetMaxIter(InverseElementTransformation self, int max_it)"}, - { "InverseElementTransformation_SetReferenceTol", _wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS, "SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, - { "InverseElementTransformation_SetPhysicalRelTol", _wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS, "SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, - { "InverseElementTransformation_SetElementTol", _wrap_InverseElementTransformation_SetElementTol, METH_VARARGS, "SetElementTol(InverseElementTransformation self, double el_tol)"}, - { "InverseElementTransformation_SetPrintLevel", _wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS, "SetPrintLevel(InverseElementTransformation self, int pr_level)"}, - { "InverseElementTransformation_FindClosestPhysPoint", _wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS, "FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_FindClosestRefPoint", _wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS, "FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, - { "InverseElementTransformation_Transform", _wrap_InverseElementTransformation_Transform, METH_VARARGS, "Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, + { "InverseElementTransformation_SetTransformation", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetTransformation, METH_VARARGS|METH_KEYWORDS, "SetTransformation(InverseElementTransformation self, ElementTransformation Trans)"}, + { "InverseElementTransformation_SetInitialGuessType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuessType, METH_VARARGS|METH_KEYWORDS, "SetInitialGuessType(InverseElementTransformation self, mfem::InverseElementTransformation::InitGuessType itype)"}, + { "InverseElementTransformation_SetInitialGuess", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitialGuess, METH_VARARGS|METH_KEYWORDS, "SetInitialGuess(InverseElementTransformation self, IntegrationPoint init_ip)"}, + { "InverseElementTransformation_SetInitGuessPointsType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessPointsType, METH_VARARGS|METH_KEYWORDS, "SetInitGuessPointsType(InverseElementTransformation self, int q_type)"}, + { "InverseElementTransformation_SetInitGuessRelOrder", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetInitGuessRelOrder, METH_VARARGS|METH_KEYWORDS, "SetInitGuessRelOrder(InverseElementTransformation self, int order)"}, + { "InverseElementTransformation_SetSolverType", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetSolverType, METH_VARARGS|METH_KEYWORDS, "SetSolverType(InverseElementTransformation self, mfem::InverseElementTransformation::SolverType stype)"}, + { "InverseElementTransformation_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(InverseElementTransformation self, int max_it)"}, + { "InverseElementTransformation_SetReferenceTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetReferenceTol, METH_VARARGS|METH_KEYWORDS, "SetReferenceTol(InverseElementTransformation self, double ref_sp_tol)"}, + { "InverseElementTransformation_SetPhysicalRelTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPhysicalRelTol, METH_VARARGS|METH_KEYWORDS, "SetPhysicalRelTol(InverseElementTransformation self, double phys_rel_tol)"}, + { "InverseElementTransformation_SetElementTol", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetElementTol, METH_VARARGS|METH_KEYWORDS, "SetElementTol(InverseElementTransformation self, double el_tol)"}, + { "InverseElementTransformation_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(InverseElementTransformation self, int pr_level)"}, + { "InverseElementTransformation_FindClosestPhysPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestPhysPoint, METH_VARARGS|METH_KEYWORDS, "FindClosestPhysPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_FindClosestRefPoint", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_FindClosestRefPoint, METH_VARARGS|METH_KEYWORDS, "FindClosestRefPoint(InverseElementTransformation self, Vector pt, IntegrationRule ir) -> int"}, + { "InverseElementTransformation_Transform", (PyCFunction)(void(*)(void))_wrap_InverseElementTransformation_Transform, METH_VARARGS|METH_KEYWORDS, "Transform(InverseElementTransformation self, Vector pt, IntegrationPoint ip) -> int"}, { "InverseElementTransformation_swigregister", InverseElementTransformation_swigregister, METH_O, NULL}, { "InverseElementTransformation_swiginit", InverseElementTransformation_swiginit, METH_VARARGS, NULL}, - { "IsoparametricTransformation_SetFE", _wrap_IsoparametricTransformation_SetFE, METH_VARARGS, "SetFE(IsoparametricTransformation self, FiniteElement FE)"}, + { "IsoparametricTransformation_SetFE", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetFE, METH_VARARGS|METH_KEYWORDS, "SetFE(IsoparametricTransformation self, FiniteElement FE)"}, { "IsoparametricTransformation_GetFE", _wrap_IsoparametricTransformation_GetFE, METH_O, "GetFE(IsoparametricTransformation self) -> FiniteElement"}, { "IsoparametricTransformation_GetPointMat", _wrap_IsoparametricTransformation_GetPointMat, METH_O, "GetPointMat(IsoparametricTransformation self) -> DenseMatrix"}, { "IsoparametricTransformation_FinalizeTransformation", _wrap_IsoparametricTransformation_FinalizeTransformation, METH_O, "FinalizeTransformation(IsoparametricTransformation self)"}, - { "IsoparametricTransformation_SetIdentityTransformation", _wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS, "SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, + { "IsoparametricTransformation_SetIdentityTransformation", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_SetIdentityTransformation, METH_VARARGS|METH_KEYWORDS, "SetIdentityTransformation(IsoparametricTransformation self, mfem::Geometry::Type GeomType)"}, { "IsoparametricTransformation_Transform", _wrap_IsoparametricTransformation_Transform, METH_VARARGS, "\n" "Transform(IsoparametricTransformation self, IntegrationPoint arg2, Vector arg3)\n" "Transform(IsoparametricTransformation self, IntegrationRule arg2, DenseMatrix arg3)\n" @@ -7111,8 +7145,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "IsoparametricTransformation_Order", _wrap_IsoparametricTransformation_Order, METH_O, "Order(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderJ", _wrap_IsoparametricTransformation_OrderJ, METH_O, "OrderJ(IsoparametricTransformation self) -> int"}, { "IsoparametricTransformation_OrderW", _wrap_IsoparametricTransformation_OrderW, METH_O, "OrderW(IsoparametricTransformation self) -> int"}, - { "IsoparametricTransformation_OrderGrad", _wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS, "OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, - { "IsoparametricTransformation_TransformBack", _wrap_IsoparametricTransformation_TransformBack, METH_VARARGS, "TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, + { "IsoparametricTransformation_OrderGrad", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_OrderGrad, METH_VARARGS|METH_KEYWORDS, "OrderGrad(IsoparametricTransformation self, FiniteElement fe) -> int"}, + { "IsoparametricTransformation_TransformBack", (PyCFunction)(void(*)(void))_wrap_IsoparametricTransformation_TransformBack, METH_VARARGS|METH_KEYWORDS, "TransformBack(IsoparametricTransformation self, Vector v, IntegrationPoint ip) -> int"}, { "delete_IsoparametricTransformation", _wrap_delete_IsoparametricTransformation, METH_O, "delete_IsoparametricTransformation(IsoparametricTransformation self)"}, { "new_IsoparametricTransformation", _wrap_new_IsoparametricTransformation, METH_NOARGS, "new_IsoparametricTransformation() -> IsoparametricTransformation"}, { "IsoparametricTransformation_swigregister", IsoparametricTransformation_swigregister, METH_O, NULL}, diff --git a/mfem/_ser/error_wrap.cxx b/mfem/_ser/error_wrap.cxx index 6245645f..9e70e4d3 100644 --- a/mfem/_ser/error_wrap.cxx +++ b/mfem/_ser/error_wrap.cxx @@ -3055,16 +3055,18 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_set_error_action(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_set_error_action(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ErrorAction arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"action", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:set_error_action", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_error_action" "', argument " "1"" of type '" "mfem::ErrorAction""'"); } @@ -3120,91 +3122,38 @@ SWIGINTERN PyObject *_wrap_get_error_action(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_mfem_backtrace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + int arg1 = (int) 0 ; + int arg2 = (int) -1 ; int val1 ; int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"mode", (char *)"depth", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mfem_backtrace" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mfem_backtrace" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - try { - mfem::mfem_backtrace(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:mfem_backtrace", kwnames, &obj0, &obj1)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mfem_backtrace" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mfem_backtrace" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - { - try { - mfem::mfem_backtrace(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (obj1) { + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mfem_backtrace" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - mfem::mfem_backtrace(); + mfem::mfem_backtrace(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3225,67 +3174,25 @@ SWIGINTERN PyObject *_wrap_mfem_backtrace__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_mfem_backtrace(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "mfem_backtrace", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_mfem_backtrace__SWIG_2(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_mfem_backtrace__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_mfem_backtrace__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mfem_backtrace'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::mfem_backtrace(int,int)\n" - " mfem::mfem_backtrace(int)\n" - " mfem::mfem_backtrace()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_mfem_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_mfem_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = (char *) NULL ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"msg", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_error" "', argument " "1"" of type '" "char const *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:mfem_error", kwnames, &obj0)) SWIG_fail; + if (obj0) { + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_error" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); } - arg1 = reinterpret_cast< char * >(buf1); { try { mfem::mfem_error((char const *)arg1); @@ -3311,75 +3218,25 @@ SWIGINTERN PyObject *_wrap_mfem_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_mfem_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - mfem::mfem_error(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_error(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "mfem_error", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_mfem_error__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_mfem_error__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mfem_error'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::mfem_error(char const *)\n" - " mfem::mfem_error()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_mfem_warning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_mfem_warning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + char *arg1 = (char *) NULL ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"msg", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_warning" "', argument " "1"" of type '" "char const *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:mfem_warning", kwnames, &obj0)) SWIG_fail; + if (obj0) { + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mfem_warning" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); } - arg1 = reinterpret_cast< char * >(buf1); { try { mfem::mfem_warning((char const *)arg1); @@ -3405,81 +3262,25 @@ SWIGINTERN PyObject *_wrap_mfem_warning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_mfem_warning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - mfem::mfem_warning(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_mfem_warning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "mfem_warning", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_mfem_warning__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_mfem_warning__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'mfem_warning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::mfem_warning(char const *)\n" - " mfem::mfem_warning()\n"); - return 0; -} - - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "set_error_action", _wrap_set_error_action, METH_O, NULL}, + { "set_error_action", (PyCFunction)(void(*)(void))_wrap_set_error_action, METH_VARARGS|METH_KEYWORDS, NULL}, { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, - { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, - { "mfem_error", _wrap_mfem_error, METH_VARARGS, NULL}, - { "mfem_warning", _wrap_mfem_warning, METH_VARARGS, NULL}, + { "mfem_backtrace", (PyCFunction)(void(*)(void))_wrap_mfem_backtrace, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_error", (PyCFunction)(void(*)(void))_wrap_mfem_error, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_warning", (PyCFunction)(void(*)(void))_wrap_mfem_warning, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "set_error_action", _wrap_set_error_action, METH_O, NULL}, + { "set_error_action", (PyCFunction)(void(*)(void))_wrap_set_error_action, METH_VARARGS|METH_KEYWORDS, NULL}, { "get_error_action", _wrap_get_error_action, METH_NOARGS, NULL}, - { "mfem_backtrace", _wrap_mfem_backtrace, METH_VARARGS, NULL}, - { "mfem_error", _wrap_mfem_error, METH_VARARGS, NULL}, - { "mfem_warning", _wrap_mfem_warning, METH_VARARGS, NULL}, + { "mfem_backtrace", (PyCFunction)(void(*)(void))_wrap_mfem_backtrace, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_error", (PyCFunction)(void(*)(void))_wrap_mfem_error, METH_VARARGS|METH_KEYWORDS, NULL}, + { "mfem_warning", (PyCFunction)(void(*)(void))_wrap_mfem_warning, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/estimators_wrap.cxx b/mfem/_ser/estimators_wrap.cxx index 97ef9513..4f6f9df8 100644 --- a/mfem/_ser/estimators_wrap.cxx +++ b/mfem/_ser/estimators_wrap.cxx @@ -3417,7 +3417,7 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) #define SWIG_From_double PyFloat_FromDouble -SWIGINTERN mfem::ZienkiewiczZhuEstimator *new_mfem_ZienkiewiczZhuEstimator__SWIG_0(mfem::BilinearFormIntegrator &integ,mfem::GridFunction &sol,mfem::FiniteElementSpace *flux_fes,bool own_flux_fes=false){ +SWIGINTERN mfem::ZienkiewiczZhuEstimator *new_mfem_ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &integ,mfem::GridFunction &sol,mfem::FiniteElementSpace *flux_fes,bool own_flux_fes=false){ if (own_flux_fes){ return new mfem::ZienkiewiczZhuEstimator(integ, sol, flux_fes); } else { @@ -3733,67 +3733,36 @@ SWIGINTERN PyObject *AnisotropicErrorEstimator_swigregister(PyObject *SWIGUNUSED return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"w_coeff", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ZienkiewiczZhuEstimator_SetWithCoeff", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); } arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetWithCoeff(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetWithCoeff" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); { try { - (arg1)->SetWithCoeff(); + (arg1)->SetWithCoeff(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3817,68 +3786,33 @@ SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetWithCoeff(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetWithCoeff", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetWithCoeff__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZienkiewiczZhuEstimator_SetWithCoeff'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZienkiewiczZhuEstimator::SetWithCoeff(bool)\n" - " mfem::ZienkiewiczZhuEstimator::SetWithCoeff()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"aniso", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ZienkiewiczZhuEstimator_SetAnisotropic", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); } arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { (arg1)->SetAnisotropic(arg2); @@ -3905,105 +3839,29 @@ SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_0(PyObje } -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetAnisotropic" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); - } - arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); - { - try { - (arg1)->SetAnisotropic(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetAnisotropic(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetAnisotropic", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ZienkiewiczZhuEstimator_SetAnisotropic__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZienkiewiczZhuEstimator_SetAnisotropic'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZienkiewiczZhuEstimator::SetAnisotropic(bool)\n" - " mfem::ZienkiewiczZhuEstimator::SetAnisotropic()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ZienkiewiczZhuEstimator *arg1 = (mfem::ZienkiewiczZhuEstimator *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ZienkiewiczZhuEstimator_SetFluxAveraging", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ZienkiewiczZhuEstimator_SetFluxAveraging", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZienkiewiczZhuEstimator_SetFluxAveraging" "', argument " "1"" of type '" "mfem::ZienkiewiczZhuEstimator *""'"); } arg1 = reinterpret_cast< mfem::ZienkiewiczZhuEstimator * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4234,12 +4092,12 @@ SWIGINTERN PyObject *_wrap_delete_ZienkiewiczZhuEstimator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; mfem::FiniteElementSpace *arg3 = (mfem::FiniteElementSpace *) 0 ; - bool arg4 ; + bool arg4 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4248,10 +4106,17 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNU int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"integ", (char *)"sol", (char *)"flux_fes", (char *)"own_flux_fes", NULL + }; mfem::ZienkiewiczZhuEstimator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_ZienkiewiczZhuEstimator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -4259,7 +4124,7 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } @@ -4267,80 +4132,21 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "3"" of type '" "mfem::FiniteElementSpace *""'"); } arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - result = (mfem::ZienkiewiczZhuEstimator *)new_mfem_ZienkiewiczZhuEstimator__SWIG_0(*arg1,*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ZienkiewiczZhuEstimator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::FiniteElementSpace *arg3 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::ZienkiewiczZhuEstimator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "3"" of type '" "mfem::FiniteElementSpace *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ZienkiewiczZhuEstimator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg3 = reinterpret_cast< mfem::FiniteElementSpace * >(argp3); { try { - result = (mfem::ZienkiewiczZhuEstimator *)new_mfem_ZienkiewiczZhuEstimator__SWIG_0(*arg1,*arg2,arg3); + result = (mfem::ZienkiewiczZhuEstimator *)new_mfem_ZienkiewiczZhuEstimator(*arg1,*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4364,68 +4170,6 @@ SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_ZienkiewiczZhuEstimator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ZienkiewiczZhuEstimator", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ZienkiewiczZhuEstimator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ZienkiewiczZhuEstimator__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ZienkiewiczZhuEstimator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZienkiewiczZhuEstimator::ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::FiniteElementSpace *,bool)\n" - " mfem::ZienkiewiczZhuEstimator::ZienkiewiczZhuEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::FiniteElementSpace *)\n"); - return 0; -} - - SWIGINTERN PyObject *ZienkiewiczZhuEstimator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; @@ -4451,15 +4195,15 @@ static PyMethodDef SwigMethods[] = { { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "AnisotropicErrorEstimator_GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, - { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "ZienkiewiczZhuEstimator_SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, - { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "ZienkiewiczZhuEstimator_SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, - { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "ZienkiewiczZhuEstimator_SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS|METH_KEYWORDS, "ZienkiewiczZhuEstimator_SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, + { "ZienkiewiczZhuEstimator_SetAnisotropic", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS|METH_KEYWORDS, "ZienkiewiczZhuEstimator_SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, + { "ZienkiewiczZhuEstimator_SetFluxAveraging", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS|METH_KEYWORDS, "ZienkiewiczZhuEstimator_SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "ZienkiewiczZhuEstimator_GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, { "ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "ZienkiewiczZhuEstimator_GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector"}, { "ZienkiewiczZhuEstimator_GetAnisotropicFlags", _wrap_ZienkiewiczZhuEstimator_GetAnisotropicFlags, METH_O, "ZienkiewiczZhuEstimator_GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray"}, { "ZienkiewiczZhuEstimator_Reset", _wrap_ZienkiewiczZhuEstimator_Reset, METH_O, "ZienkiewiczZhuEstimator_Reset(ZienkiewiczZhuEstimator self)"}, { "delete_ZienkiewiczZhuEstimator", _wrap_delete_ZienkiewiczZhuEstimator, METH_O, "delete_ZienkiewiczZhuEstimator(ZienkiewiczZhuEstimator self)"}, - { "new_ZienkiewiczZhuEstimator", _wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS, "ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False)"}, + { "new_ZienkiewiczZhuEstimator", (PyCFunction)(void(*)(void))_wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS|METH_KEYWORDS, "new_ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False) -> ZienkiewiczZhuEstimator"}, { "ZienkiewiczZhuEstimator_swigregister", ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, { "ZienkiewiczZhuEstimator_swiginit", ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -4479,15 +4223,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "AnisotropicErrorEstimator_GetAnisotropicFlags", _wrap_AnisotropicErrorEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(AnisotropicErrorEstimator self) -> intArray"}, { "delete_AnisotropicErrorEstimator", _wrap_delete_AnisotropicErrorEstimator, METH_O, "delete_AnisotropicErrorEstimator(AnisotropicErrorEstimator self)"}, { "AnisotropicErrorEstimator_swigregister", AnisotropicErrorEstimator_swigregister, METH_O, NULL}, - { "ZienkiewiczZhuEstimator_SetWithCoeff", _wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS, "SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, - { "ZienkiewiczZhuEstimator_SetAnisotropic", _wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS, "SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, - { "ZienkiewiczZhuEstimator_SetFluxAveraging", _wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS, "SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, + { "ZienkiewiczZhuEstimator_SetWithCoeff", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetWithCoeff, METH_VARARGS|METH_KEYWORDS, "SetWithCoeff(ZienkiewiczZhuEstimator self, bool w_coeff=True)"}, + { "ZienkiewiczZhuEstimator_SetAnisotropic", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetAnisotropic, METH_VARARGS|METH_KEYWORDS, "SetAnisotropic(ZienkiewiczZhuEstimator self, bool aniso=True)"}, + { "ZienkiewiczZhuEstimator_SetFluxAveraging", (PyCFunction)(void(*)(void))_wrap_ZienkiewiczZhuEstimator_SetFluxAveraging, METH_VARARGS|METH_KEYWORDS, "SetFluxAveraging(ZienkiewiczZhuEstimator self, int fa)"}, { "ZienkiewiczZhuEstimator_GetTotalError", _wrap_ZienkiewiczZhuEstimator_GetTotalError, METH_O, "GetTotalError(ZienkiewiczZhuEstimator self) -> double"}, { "ZienkiewiczZhuEstimator_GetLocalErrors", _wrap_ZienkiewiczZhuEstimator_GetLocalErrors, METH_O, "GetLocalErrors(ZienkiewiczZhuEstimator self) -> Vector"}, { "ZienkiewiczZhuEstimator_GetAnisotropicFlags", _wrap_ZienkiewiczZhuEstimator_GetAnisotropicFlags, METH_O, "GetAnisotropicFlags(ZienkiewiczZhuEstimator self) -> intArray"}, { "ZienkiewiczZhuEstimator_Reset", _wrap_ZienkiewiczZhuEstimator_Reset, METH_O, "Reset(ZienkiewiczZhuEstimator self)"}, { "delete_ZienkiewiczZhuEstimator", _wrap_delete_ZienkiewiczZhuEstimator, METH_O, "delete_ZienkiewiczZhuEstimator(ZienkiewiczZhuEstimator self)"}, - { "new_ZienkiewiczZhuEstimator", _wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS, "ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False)"}, + { "new_ZienkiewiczZhuEstimator", (PyCFunction)(void(*)(void))_wrap_new_ZienkiewiczZhuEstimator, METH_VARARGS|METH_KEYWORDS, "new_ZienkiewiczZhuEstimator(BilinearFormIntegrator integ, GridFunction sol, FiniteElementSpace flux_fes, bool own_flux_fes=False) -> ZienkiewiczZhuEstimator"}, { "ZienkiewiczZhuEstimator_swigregister", ZienkiewiczZhuEstimator_swigregister, METH_O, NULL}, { "ZienkiewiczZhuEstimator_swiginit", ZienkiewiczZhuEstimator_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } diff --git a/mfem/_ser/fe.py b/mfem/_ser/fe.py index 01df573a..6c22472d 100644 --- a/mfem/_ser/fe.py +++ b/mfem/_ser/fe.py @@ -641,9 +641,9 @@ class VectorFiniteElement(FiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(VectorFiniteElement self, int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk) -> VectorFiniteElement""" - _fe.VectorFiniteElement_swiginit(self, _fe.new_VectorFiniteElement(*args)) + _fe.VectorFiniteElement_swiginit(self, _fe.new_VectorFiniteElement(*args, **kwargs)) __swig_destroy__ = _fe.delete_VectorFiniteElement # Register VectorFiniteElement in _fe: @@ -2177,14 +2177,14 @@ def GetPoints(self, p, btype): return _fe.Poly_1D_GetPoints(self, p, btype) GetPoints = _swig_new_instance_method(_fe.Poly_1D_GetPoints) - def OpenPoints(self, *args): - r"""OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const""" - return _fe.Poly_1D_OpenPoints(self, *args) + def OpenPoints(self, *args, **kwargs): + r"""OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const *""" + return _fe.Poly_1D_OpenPoints(self, *args, **kwargs) OpenPoints = _swig_new_instance_method(_fe.Poly_1D_OpenPoints) - def ClosedPoints(self, *args): - r"""ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const""" - return _fe.Poly_1D_ClosedPoints(self, *args) + def ClosedPoints(self, *args, **kwargs): + r"""ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const *""" + return _fe.Poly_1D_ClosedPoints(self, *args, **kwargs) ClosedPoints = _swig_new_instance_method(_fe.Poly_1D_ClosedPoints) def GetBasis(self, p, btype): @@ -2432,9 +2432,9 @@ class H1_SegmentElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_SegmentElement self, int const p, int const btype=GaussLobatto) -> H1_SegmentElement""" - _fe.H1_SegmentElement_swiginit(self, _fe.new_H1_SegmentElement(*args)) + _fe.H1_SegmentElement_swiginit(self, _fe.new_H1_SegmentElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)""" @@ -2461,9 +2461,9 @@ class H1_QuadrilateralElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_QuadrilateralElement self, int const p, int const btype=GaussLobatto) -> H1_QuadrilateralElement""" - _fe.H1_QuadrilateralElement_swiginit(self, _fe.new_H1_QuadrilateralElement(*args)) + _fe.H1_QuadrilateralElement_swiginit(self, _fe.new_H1_QuadrilateralElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" @@ -2490,9 +2490,9 @@ class H1_HexahedronElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_HexahedronElement self, int const p, int const btype=GaussLobatto) -> H1_HexahedronElement""" - _fe.H1_HexahedronElement_swiginit(self, _fe.new_H1_HexahedronElement(*args)) + _fe.H1_HexahedronElement_swiginit(self, _fe.new_H1_HexahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -2644,9 +2644,9 @@ class H1_TriangleElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_TriangleElement self, int const p, int const btype=GaussLobatto) -> H1_TriangleElement""" - _fe.H1_TriangleElement_swiginit(self, _fe.new_H1_TriangleElement(*args)) + _fe.H1_TriangleElement_swiginit(self, _fe.new_H1_TriangleElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)""" @@ -2673,9 +2673,9 @@ class H1_TetrahedronElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_TetrahedronElement self, int const p, int const btype=GaussLobatto) -> H1_TetrahedronElement""" - _fe.H1_TetrahedronElement_swiginit(self, _fe.new_H1_TetrahedronElement(*args)) + _fe.H1_TetrahedronElement_swiginit(self, _fe.new_H1_TetrahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -2762,9 +2762,9 @@ class H1_WedgeElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_WedgeElement self, int const p, int const btype=GaussLobatto) -> H1_WedgeElement""" - _fe.H1_WedgeElement_swiginit(self, _fe.new_H1_WedgeElement(*args)) + _fe.H1_WedgeElement_swiginit(self, _fe.new_H1_WedgeElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)""" @@ -2852,9 +2852,9 @@ class L2_SegmentElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_SegmentElement self, int const p, int const btype=GaussLegendre) -> L2_SegmentElement""" - _fe.L2_SegmentElement_swiginit(self, _fe.new_L2_SegmentElement(*args)) + _fe.L2_SegmentElement_swiginit(self, _fe.new_L2_SegmentElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)""" @@ -2910,9 +2910,9 @@ class L2_QuadrilateralElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_QuadrilateralElement self, int const p, int const btype=GaussLegendre) -> L2_QuadrilateralElement""" - _fe.L2_QuadrilateralElement_swiginit(self, _fe.new_L2_QuadrilateralElement(*args)) + _fe.L2_QuadrilateralElement_swiginit(self, _fe.new_L2_QuadrilateralElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)""" @@ -2973,9 +2973,9 @@ class L2_HexahedronElement(NodalTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_HexahedronElement self, int const p, int const btype=GaussLegendre) -> L2_HexahedronElement""" - _fe.L2_HexahedronElement_swiginit(self, _fe.new_L2_HexahedronElement(*args)) + _fe.L2_HexahedronElement_swiginit(self, _fe.new_L2_HexahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -3031,9 +3031,9 @@ class L2_TriangleElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_TriangleElement self, int const p, int const btype=GaussLegendre) -> L2_TriangleElement""" - _fe.L2_TriangleElement_swiginit(self, _fe.new_L2_TriangleElement(*args)) + _fe.L2_TriangleElement_swiginit(self, _fe.new_L2_TriangleElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)""" @@ -3094,9 +3094,9 @@ class L2_TetrahedronElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_TetrahedronElement self, int const p, int const btype=GaussLegendre) -> L2_TetrahedronElement""" - _fe.L2_TetrahedronElement_swiginit(self, _fe.new_L2_TetrahedronElement(*args)) + _fe.L2_TetrahedronElement_swiginit(self, _fe.new_L2_TetrahedronElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)""" @@ -3152,9 +3152,9 @@ class L2_WedgeElement(NodalFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_WedgeElement self, int const p, int const btype=GaussLegendre) -> L2_WedgeElement""" - _fe.L2_WedgeElement_swiginit(self, _fe.new_L2_WedgeElement(*args)) + _fe.L2_WedgeElement_swiginit(self, _fe.new_L2_WedgeElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)""" @@ -3214,9 +3214,9 @@ class RT_QuadrilateralElement(VectorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RT_QuadrilateralElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_QuadrilateralElement""" - _fe.RT_QuadrilateralElement_swiginit(self, _fe.new_RT_QuadrilateralElement(*args)) + _fe.RT_QuadrilateralElement_swiginit(self, _fe.new_RT_QuadrilateralElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3282,9 +3282,9 @@ class RT_HexahedronElement(VectorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RT_HexahedronElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_HexahedronElement""" - _fe.RT_HexahedronElement_swiginit(self, _fe.new_RT_HexahedronElement(*args)) + _fe.RT_HexahedronElement_swiginit(self, _fe.new_RT_HexahedronElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3476,9 +3476,9 @@ class ND_HexahedronElement(VectorTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_HexahedronElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_HexahedronElement""" - _fe.ND_HexahedronElement_swiginit(self, _fe.new_ND_HexahedronElement(*args)) + _fe.ND_HexahedronElement_swiginit(self, _fe.new_ND_HexahedronElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3544,9 +3544,9 @@ class ND_QuadrilateralElement(VectorTensorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_QuadrilateralElement self, int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_QuadrilateralElement""" - _fe.ND_QuadrilateralElement_swiginit(self, _fe.new_ND_QuadrilateralElement(*args)) + _fe.ND_QuadrilateralElement_swiginit(self, _fe.new_ND_QuadrilateralElement(*args, **kwargs)) def CalcVShape(self, *args): r""" @@ -3738,9 +3738,9 @@ class ND_SegmentElement(VectorFiniteElement): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_SegmentElement self, int const p, int const ob_type=GaussLegendre) -> ND_SegmentElement""" - _fe.ND_SegmentElement_swiginit(self, _fe.new_ND_SegmentElement(*args)) + _fe.ND_SegmentElement_swiginit(self, _fe.new_ND_SegmentElement(*args, **kwargs)) def CalcShape(self, ip, shape): r"""CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)""" diff --git a/mfem/_ser/fe_coll.py b/mfem/_ser/fe_coll.py index b30d5c84..e5a4e6ea 100644 --- a/mfem/_ser/fe_coll.py +++ b/mfem/_ser/fe_coll.py @@ -226,9 +226,9 @@ class H1_FECollection(FiniteElementCollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_FECollection self, int const p, int const dim=3, int const btype=GaussLobatto) -> H1_FECollection""" - _fe_coll.H1_FECollection_swiginit(self, _fe_coll.new_H1_FECollection(*args)) + _fe_coll.H1_FECollection_swiginit(self, _fe_coll.new_H1_FECollection(*args, **kwargs)) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" @@ -303,9 +303,9 @@ class H1_Trace_FECollection(H1_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(H1_Trace_FECollection self, int const p, int const dim, int const btype=GaussLobatto) -> H1_Trace_FECollection""" - _fe_coll.H1_Trace_FECollection_swiginit(self, _fe_coll.new_H1_Trace_FECollection(*args)) + _fe_coll.H1_Trace_FECollection_swiginit(self, _fe_coll.new_H1_Trace_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_H1_Trace_FECollection # Register H1_Trace_FECollection in _fe_coll: @@ -317,9 +317,9 @@ class L2_FECollection(FiniteElementCollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2_FECollection self, int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE) -> L2_FECollection""" - _fe_coll.L2_FECollection_swiginit(self, _fe_coll.new_L2_FECollection(*args)) + _fe_coll.L2_FECollection_swiginit(self, _fe_coll.new_L2_FECollection(*args, **kwargs)) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" @@ -400,9 +400,9 @@ class RT_Trace_FECollection(RT_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RT_Trace_FECollection self, int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre) -> RT_Trace_FECollection""" - _fe_coll.RT_Trace_FECollection_swiginit(self, _fe_coll.new_RT_Trace_FECollection(*args)) + _fe_coll.RT_Trace_FECollection_swiginit(self, _fe_coll.new_RT_Trace_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_RT_Trace_FECollection # Register RT_Trace_FECollection in _fe_coll: @@ -414,9 +414,9 @@ class DG_Interface_FECollection(RT_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(DG_Interface_FECollection self, int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre) -> DG_Interface_FECollection""" - _fe_coll.DG_Interface_FECollection_swiginit(self, _fe_coll.new_DG_Interface_FECollection(*args)) + _fe_coll.DG_Interface_FECollection_swiginit(self, _fe_coll.new_DG_Interface_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_DG_Interface_FECollection # Register DG_Interface_FECollection in _fe_coll: @@ -428,9 +428,9 @@ class ND_FECollection(FiniteElementCollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_FECollection self, int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_FECollection""" - _fe_coll.ND_FECollection_swiginit(self, _fe_coll.new_ND_FECollection(*args)) + _fe_coll.ND_FECollection_swiginit(self, _fe_coll.new_ND_FECollection(*args, **kwargs)) def FiniteElementForGeometry(self, GeomType): r"""FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement""" @@ -467,9 +467,9 @@ class ND_Trace_FECollection(ND_FECollection): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(ND_Trace_FECollection self, int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_Trace_FECollection""" - _fe_coll.ND_Trace_FECollection_swiginit(self, _fe_coll.new_ND_Trace_FECollection(*args)) + _fe_coll.ND_Trace_FECollection_swiginit(self, _fe_coll.new_ND_Trace_FECollection(*args, **kwargs)) __swig_destroy__ = _fe_coll.delete_ND_Trace_FECollection # Register ND_Trace_FECollection in _fe_coll: @@ -483,9 +483,9 @@ class NURBSFECollection(FiniteElementCollection): VariableOrder = _fe_coll.NURBSFECollection_VariableOrder - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(NURBSFECollection self, int Order=VariableOrder) -> NURBSFECollection""" - _fe_coll.NURBSFECollection_swiginit(self, _fe_coll.new_NURBSFECollection(*args)) + _fe_coll.NURBSFECollection_swiginit(self, _fe_coll.new_NURBSFECollection(*args, **kwargs)) def Reset(self): r"""Reset(NURBSFECollection self)""" diff --git a/mfem/_ser/fe_coll_wrap.cxx b/mfem/_ser/fe_coll_wrap.cxx index 0d4a24db..dd044ade 100644 --- a/mfem/_ser/fe_coll_wrap.cxx +++ b/mfem/_ser/fe_coll_wrap.cxx @@ -3743,7 +3743,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -3751,15 +3751,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -3818,17 +3822,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -3887,7 +3893,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -3895,15 +3901,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -3962,17 +3972,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -3996,7 +4008,7 @@ SWIGINTERN PyObject *doublep_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4004,16 +4016,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4044,7 +4060,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_FiniteElementForGeometry(PyOb } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4052,16 +4068,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_DofForGeometry" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4092,7 +4112,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofForGeometry(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4101,25 +4121,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_DofOrderForOrientation(PyObje int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementCollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4188,7 +4213,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_Name(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4196,16 +4221,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNU int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_HasFaceDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_HasFaceDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_HasFaceDofs" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_HasFaceDofs" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4236,7 +4265,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_HasFaceDofs(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4244,16 +4273,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_TraceFiniteElementForGeometry int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_TraceFiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementCollection_TraceFiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_TraceFiniteElementForGeometry" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_TraceFiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4365,18 +4398,20 @@ SWIGINTERN PyObject *_wrap_delete_FiniteElementCollection(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_New(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"name", NULL + }; mfem::FiniteElementCollection *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElementCollection_New", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_New" "', argument " "1"" of type '" "char const *""'"); } @@ -4409,7 +4444,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_New(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElementCollection_SubDofOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementCollection_SubDofOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementCollection *arg1 = (mfem::FiniteElementCollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4422,32 +4457,39 @@ SWIGINTERN PyObject *_wrap_FiniteElementCollection_SubDofOrder(PyObject *SWIGUNU int ecode2 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Geom", (char *)"SDim", (char *)"Info", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementCollection_SubDofOrder", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:FiniteElementCollection_SubDofOrder", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementCollection_SubDofOrder" "', argument " "1"" of type '" "mfem::FiniteElementCollection const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementCollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementCollection_SubDofOrder" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "FiniteElementCollection_SubDofOrder" "', argument " "5"" of type '" "mfem::Array< int > &""'"); } @@ -4488,118 +4530,45 @@ SWIGINTERN PyObject *FiniteElementCollection_swigregister(PyObject *SWIGUNUSEDPA return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)3 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"btype", NULL + }; mfem::H1_FECollection *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_H1_FECollection", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::H1_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_FECollection *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1); + result = (mfem::H1_FECollection *)new mfem::H1_FECollection(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4623,98 +4592,7 @@ SWIGINTERN PyObject *_wrap_new_H1_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_H1_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_FECollection", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_FECollection__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_FECollection__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_FECollection::H1_FECollection(int const,int const,int const)\n" - " mfem::H1_FECollection::H1_FECollection(int const,int const)\n" - " mfem::H1_FECollection::H1_FECollection(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4722,16 +4600,20 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:H1_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4762,7 +4644,7 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_FiniteElementForGeometry(PyObject *SW } -SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4770,16 +4652,20 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:H1_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -4810,7 +4696,7 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4819,25 +4705,30 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_DofOrderForOrientation(PyObject *SWIG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4988,7 +4879,7 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_GetBasisType(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1_FECollection_GetDofMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_FECollection_GetDofMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_FECollection *arg1 = (mfem::H1_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -4996,16 +4887,20 @@ SWIGINTERN PyObject *_wrap_H1_FECollection_GetDofMap(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "H1_FECollection_GetDofMap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:H1_FECollection_GetDofMap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_FECollection_GetDofMap" "', argument " "1"" of type '" "mfem::H1_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::H1_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "H1_FECollection_GetDofMap" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -5087,24 +4982,31 @@ SWIGINTERN PyObject *H1_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", NULL + }; mfem::H1Pos_FECollection *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1Pos_FECollection", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -5132,21 +5034,23 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_H1Pos_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - mfem::H1Pos_FECollection *result = 0 ; + mfem::H1Pos_FECollection *arg1 = (mfem::H1Pos_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Pos_FECollection" "', argument " "1"" of type '" "mfem::H1Pos_FECollection *""'"); } + arg1 = reinterpret_cast< mfem::H1Pos_FECollection * >(argp1); { try { - result = (mfem::H1Pos_FECollection *)new mfem::H1Pos_FECollection(arg1); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5163,83 +5067,90 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Pos_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_H1Pos_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 +SWIGINTERN PyObject *H1Pos_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Pos_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *H1Pos_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 = (int) (int)2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", NULL }; + mfem::H1Ser_FECollection *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1Pos_FECollection", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1Ser_FECollection", kwnames, &obj0, &obj1)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); + } + if (obj1) { { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Pos_FECollection__SWIG_1(self, argc, argv); + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + { + try { + result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1,arg2); } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Pos_FECollection__SWIG_0(self, argc, argv); - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1Pos_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1Pos_FECollection::H1Pos_FECollection(int const,int const)\n" - " mfem::H1Pos_FECollection::H1Pos_FECollection(int const)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_delete_H1Pos_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::H1Pos_FECollection *arg1 = (mfem::H1Pos_FECollection *) 0 ; + mfem::H1Ser_FECollection *arg1 = (mfem::H1Ser_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Pos_FECollection" "', argument " "1"" of type '" "mfem::H1Pos_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Ser_FECollection" "', argument " "1"" of type '" "mfem::H1Ser_FECollection *""'"); } - arg1 = reinterpret_cast< mfem::H1Pos_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::H1Ser_FECollection * >(argp1); { try { delete arg1; @@ -5266,77 +5177,54 @@ SWIGINTERN PyObject *_wrap_delete_H1Pos_FECollection(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *H1Pos_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *H1Ser_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Pos_FECollection, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *H1Pos_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *H1Ser_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - mfem::H1Ser_FECollection *result = 0 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"btype", NULL + }; + mfem::H1_Trace_FECollection *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:new_H1_Trace_FECollection", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - try { - result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1Ser_FECollection *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1Ser_FECollection *)new mfem::H1Ser_FECollection(arg1); + result = (mfem::H1_Trace_FECollection *)new mfem::H1_Trace_FECollection(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5353,83 +5241,27 @@ SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_H1Ser_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1Ser_FECollection", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Ser_FECollection__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1Ser_FECollection__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1Ser_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1Ser_FECollection::H1Ser_FECollection(int const,int const)\n" - " mfem::H1Ser_FECollection::H1Ser_FECollection(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_H1_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::H1Ser_FECollection *arg1 = (mfem::H1Ser_FECollection *) 0 ; + mfem::H1_Trace_FECollection *arg1 = (mfem::H1_Trace_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1Ser_FECollection" "', argument " "1"" of type '" "mfem::H1Ser_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1_Trace_FECollection" "', argument " "1"" of type '" "mfem::H1_Trace_FECollection *""'"); } - arg1 = reinterpret_cast< mfem::H1Ser_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::H1_Trace_FECollection * >(argp1); { try { delete arg1; @@ -5456,46 +5288,64 @@ SWIGINTERN PyObject *_wrap_delete_H1Ser_FECollection(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *H1Ser_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *H1_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1Ser_FECollection, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *H1Ser_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *H1_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; - mfem::H1_Trace_FECollection *result = 0 ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + int arg4 = (int) (int)mfem::FiniteElement::VALUE ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"btype", (char *)"map_type", NULL + }; + mfem::L2_FECollection *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_L2_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (mfem::H1_Trace_FECollection *)new mfem::H1_Trace_FECollection(arg1,arg2,arg3); + result = (mfem::L2_FECollection *)new mfem::L2_FECollection(arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5512,35 +5362,42 @@ SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_L2_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::H1_Trace_FECollection *result = 0 ; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:L2_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::H1_Trace_FECollection *)new mfem::H1_Trace_FECollection(arg1,arg2); + result = (mfem::FiniteElement *)((mfem::L2_FECollection const *)arg1)->FiniteElementForGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5557,176 +5414,42 @@ SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_H1_Trace_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_L2_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL }; + int result; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_Trace_FECollection", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_Trace_FECollection__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_Trace_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_Trace_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_Trace_FECollection::H1_Trace_FECollection(int const,int const,int const)\n" - " mfem::H1_Trace_FECollection::H1_Trace_FECollection(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_H1_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::H1_Trace_FECollection *arg1 = (mfem::H1_Trace_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:L2_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_H1_Trace_FECollection" "', argument " "1"" of type '" "mfem::H1_Trace_FECollection *""'"); - } - arg1 = reinterpret_cast< mfem::H1_Trace_FECollection * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *H1_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__H1_Trace_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *H1_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::L2_FECollection *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::L2_FECollection *)new mfem::L2_FECollection(arg1,arg2,arg3,arg4); + result = (int)((mfem::L2_FECollection const *)arg1)->DofForGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5743,1418 +5466,91 @@ SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_L2_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; int arg3 ; - mfem::L2_FECollection *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::L2_FECollection *)new mfem::L2_FECollection(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::L2_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::L2_FECollection *)new mfem::L2_FECollection(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_FECollection::L2_FECollection(int const,int const,int const,int const)\n" - " mfem::L2_FECollection::L2_FECollection(int const,int const,int const)\n" - " mfem::L2_FECollection::L2_FECollection(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (mfem::FiniteElement *)((mfem::L2_FECollection const *)arg1)->FiniteElementForGeometry(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (int)((mfem::L2_FECollection const *)arg1)->DofForGeometry(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[3] ; - int *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (int *)((mfem::L2_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - char *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_Name" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - { - try { - result = (char *)((mfem::L2_FECollection const *)arg1)->Name(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_FromCharPtr((const char *)result); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "L2_FECollection_TraceFiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_TraceFiniteElementForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_TraceFiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (mfem::FiniteElement *)((mfem::L2_FECollection const *)arg1)->TraceFiniteElementForGeometry(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_L2_FECollection_GetBasisType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_GetBasisType" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - { - try { - result = (int)((mfem::L2_FECollection const *)arg1)->GetBasisType(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_L2_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_L2_FECollection" "', argument " "1"" of type '" "mfem::L2_FECollection *""'"); - } - arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *L2_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__L2_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *L2_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::RT_FECollection *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::RT_FECollection *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::RT_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_FECollection__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_FECollection__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_FECollection__SWIG_2(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RT_FECollection::RT_FECollection(int const,int const,int const,int const)\n" - " mfem::RT_FECollection::RT_FECollection(int const,int const,int const)\n" - " mfem::RT_FECollection::RT_FECollection(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_RT_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "RT_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (mfem::FiniteElement *)((mfem::RT_FECollection const *)arg1)->FiniteElementForGeometry(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_RT_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "RT_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - try { - result = (int)((mfem::RT_FECollection const *)arg1)->DofForGeometry(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_RT_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[3] ; - int *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "RT_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (int *)((mfem::RT_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_RT_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - char *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_Name" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - { - try { - result = (char *)((mfem::RT_FECollection const *)arg1)->Name(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_FromCharPtr((const char *)result); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_RT_FECollection_GetTraceCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElementCollection *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_GetTraceCollection" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); - } - arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - { - try { - result = (mfem::FiniteElementCollection *)((mfem::RT_FECollection const *)arg1)->GetTraceCollection(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_RT_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RT_FECollection" "', argument " "1"" of type '" "mfem::RT_FECollection *""'"); - } - arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *RT_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RT_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *RT_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::RT_Trace_FECollection *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::RT_Trace_FECollection *)new mfem::RT_Trace_FECollection(arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::RT_Trace_FECollection *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::RT_Trace_FECollection *)new mfem::RT_Trace_FECollection(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::RT_Trace_FECollection *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::RT_Trace_FECollection *)new mfem::RT_Trace_FECollection(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_Trace_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_Trace_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_Trace_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_Trace_FECollection__SWIG_0(self, argc, argv); - } - } - } + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; + int *result = 0 ; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); + } + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + { + try { + result = (int *)((mfem::L2_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_Trace_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RT_Trace_FECollection::RT_Trace_FECollection(int const,int const,int const,int const)\n" - " mfem::RT_Trace_FECollection::RT_Trace_FECollection(int const,int const,int const)\n" - " mfem::RT_Trace_FECollection::RT_Trace_FECollection(int const,int const)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_delete_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::RT_Trace_FECollection *arg1 = (mfem::RT_Trace_FECollection *) 0 ; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + char *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RT_Trace_FECollection" "', argument " "1"" of type '" "mfem::RT_Trace_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_Name" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } - arg1 = reinterpret_cast< mfem::RT_Trace_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); { try { - delete arg1; + result = (char *)((mfem::L2_FECollection const *)arg1)->Name(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7171,60 +5567,42 @@ SWIGINTERN PyObject *_wrap_delete_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *RT_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *RT_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_L2_FECollection_TraceFiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::DG_Interface_FECollection *result = 0 ; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:L2_FECollection_TraceFiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_TraceFiniteElementForGeometry" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "L2_FECollection_TraceFiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2,arg3,arg4); + result = (mfem::FiniteElement *)((mfem::L2_FECollection const *)arg1)->TraceFiniteElementForGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7241,42 +5619,71 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_0(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_L2_FECollection_GetBasisType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::DG_Interface_FECollection *result = 0 ; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_FECollection_GetBasisType" "', argument " "1"" of type '" "mfem::L2_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + result = (int)((mfem::L2_FECollection const *)arg1)->GetBasisType(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_L2_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::L2_FECollection *arg1 = (mfem::L2_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_L2_FECollection" "', argument " "1"" of type '" "mfem::L2_FECollection *""'"); } + arg1 = reinterpret_cast< mfem::L2_FECollection * >(argp1); { try { - result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2,arg3); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7293,20 +5700,33 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_1(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *L2_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__L2_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *L2_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_RT_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - mfem::DG_Interface_FECollection *result = 0 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + mfem::RT_FECollection *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -7319,9 +5739,25 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_2(PyObject *SWIGU }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } { try { - result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2); + result = (mfem::RT_FECollection *)new mfem::RT_FECollection(arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7338,80 +5774,22 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection__SWIG_2(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RT_FECollection(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_DG_Interface_FECollection", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_FECollection", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_DG_Interface_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_DG_Interface_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -7431,6 +5809,9 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *self, PyObjec } } if (_v) { + if (argc <= 2) { + return _wrap_new_RT_FECollection__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -7440,6 +5821,9 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *self, PyObjec } } if (_v) { + if (argc <= 3) { + return _wrap_new_RT_FECollection__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -7449,7 +5833,7 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *self, PyObjec } } if (_v) { - return _wrap_new_DG_Interface_FECollection__SWIG_0(self, argc, argv); + return _wrap_new_RT_FECollection__SWIG_1(self, argc, argv); } } } @@ -7457,32 +5841,42 @@ SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *self, PyObjec } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DG_Interface_FECollection'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_FECollection'.\n" " Possible C/C++ prototypes are:\n" - " mfem::DG_Interface_FECollection::DG_Interface_FECollection(int const,int const,int const,int const)\n" - " mfem::DG_Interface_FECollection::DG_Interface_FECollection(int const,int const,int const)\n" - " mfem::DG_Interface_FECollection::DG_Interface_FECollection(int const,int const)\n"); + " mfem::RT_FECollection::RT_FECollection(int const,int const,int const,int const)\n"); return 0; } -SWIGINTERN PyObject *_wrap_delete_DG_Interface_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::DG_Interface_FECollection *arg1 = (mfem::DG_Interface_FECollection *) 0 ; + mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + mfem::FiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DG_Interface_FECollection" "', argument " "1"" of type '" "mfem::DG_Interface_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } - arg1 = reinterpret_cast< mfem::DG_Interface_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - delete arg1; + result = (mfem::FiniteElement *)((mfem::RT_FECollection const *)arg1)->FiniteElementForGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7499,60 +5893,42 @@ SWIGINTERN PyObject *_wrap_delete_DG_Interface_FECollection(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *DG_Interface_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *DG_Interface_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_RT_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::ND_FECollection *result = 0 ; + mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2,arg3,arg4); + result = (int)((mfem::RT_FECollection const *)arg1)->DofForGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7569,42 +5945,50 @@ SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_RT_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; int arg3 ; - mfem::ND_FECollection *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; + int *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { - result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2,arg3); + result = (int *)((mfem::RT_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7621,35 +6005,31 @@ SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_RT_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_FECollection *result = 0 ; + mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_Name" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); { try { - result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2); + result = (char *)((mfem::RT_FECollection const *)arg1)->Name(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7666,159 +6046,71 @@ SWIGINTERN PyObject *_wrap_new_ND_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ND_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_RT_FECollection_GetTraceCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::FiniteElementCollection *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_FECollection__SWIG_1(self, argc, argv); - } - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_FECollection_GetTraceCollection" "', argument " "1"" of type '" "mfem::RT_FECollection const *""'"); } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_FECollection__SWIG_0(self, argc, argv); - } - } - } + arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); + { + try { + result = (mfem::FiniteElementCollection *)((mfem::RT_FECollection const *)arg1)->GetTraceCollection(); } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_FECollection::ND_FECollection(int const,int const,int const,int const)\n" - " mfem::ND_FECollection::ND_FECollection(int const,int const,int const)\n" - " mfem::ND_FECollection::ND_FECollection(int const,int const)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_ND_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_RT_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; + mfem::RT_FECollection *arg1 = (mfem::RT_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "ND_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RT_FECollection" "', argument " "1"" of type '" "mfem::RT_FECollection *""'"); } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); + arg1 = reinterpret_cast< mfem::RT_FECollection * >(argp1); { try { - result = (mfem::FiniteElement *)((mfem::ND_FECollection const *)arg1)->FiniteElementForGeometry(arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7835,38 +6127,71 @@ SWIGINTERN PyObject *_wrap_ND_FECollection_FiniteElementForGeometry(PyObject *SW SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ND_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *RT_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RT_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *RT_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - int result; + int arg1 ; + int arg2 ; + int arg3 = (int) (int)mfem::FiniteElement::INTEGRAL ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"map_type", (char *)"ob_type", NULL + }; + mfem::RT_Trace_FECollection *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ND_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_RT_Trace_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); + } + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (int)((mfem::ND_FECollection const *)arg1)->DofForGeometry(arg2); + result = (mfem::RT_Trace_FECollection *)new mfem::RT_Trace_FECollection(arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7883,45 +6208,111 @@ SWIGINTERN PyObject *_wrap_ND_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ND_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_RT_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; - mfem::Geometry::Type arg2 ; - int arg3 ; + mfem::RT_Trace_FECollection *arg1 = (mfem::RT_Trace_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[3] ; - int *result = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "ND_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RT_Trace_FECollection" "', argument " "1"" of type '" "mfem::RT_Trace_FECollection *""'"); + } + arg1 = reinterpret_cast< mfem::RT_Trace_FECollection * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *RT_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RT_Trace_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *RT_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_DG_Interface_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 = (int) (int)mfem::FiniteElement::VALUE ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"map_type", (char *)"ob_type", NULL + }; + mfem::DG_Interface_FECollection *result = 0 ; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_DG_Interface_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (int *)((mfem::ND_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); + result = (mfem::DG_Interface_FECollection *)new mfem::DG_Interface_FECollection(arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7938,31 +6329,30 @@ SWIGINTERN PyObject *_wrap_ND_FECollection_DofOrderForOrientation(PyObject *SWIG SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ND_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_DG_Interface_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + mfem::DG_Interface_FECollection *arg1 = (mfem::DG_Interface_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - char *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_Name" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DG_Interface_FECollection" "', argument " "1"" of type '" "mfem::DG_Interface_FECollection *""'"); } - arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::DG_Interface_FECollection * >(argp1); { try { - result = (char *)((mfem::ND_FECollection const *)arg1)->Name(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7979,31 +6369,123 @@ SWIGINTERN PyObject *_wrap_ND_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_FromCharPtr((const char *)result); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_ND_FECollection_GetTraceCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *DG_Interface_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__DG_Interface_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *DG_Interface_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ND_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"cb_type", (char *)"ob_type", NULL + }; + mfem::ND_FECollection *result = 0 ; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_ND_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); + } + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } + { + try { + result = (mfem::ND_FECollection *)new mfem::ND_FECollection(arg1,arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_ND_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElementCollection *result = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + mfem::FiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_GetTraceCollection" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - result = (mfem::FiniteElementCollection *)((mfem::ND_FECollection const *)arg1)->GetTraceCollection(); + result = (mfem::FiniteElement *)((mfem::ND_FECollection const *)arg1)->FiniteElementForGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8020,30 +6502,42 @@ SWIGINTERN PyObject *_wrap_ND_FECollection_GetTraceCollection(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_delete_ND_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; + int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_FECollection" "', argument " "1"" of type '" "mfem::ND_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - delete arg1; + result = (int)((mfem::ND_FECollection const *)arg1)->DofForGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8060,60 +6554,50 @@ SWIGINTERN PyObject *_wrap_delete_ND_FECollection(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *ND_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_FECollection, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *ND_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ND_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + mfem::Geometry::Type arg2 ; int arg3 ; - int arg4 ; - mfem::ND_Trace_FECollection *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; + int *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); + } + arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { - result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2,arg3,arg4); + result = (int *)((mfem::ND_FECollection const *)arg1)->DofOrderForOrientation(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8130,42 +6614,31 @@ SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_0(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ND_FECollection_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::ND_Trace_FECollection *result = 0 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + char *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_Name" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); { try { - result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2,arg3); + result = (char *)((mfem::ND_FECollection const *)arg1)->Name(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8182,35 +6655,31 @@ SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_1(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_FromCharPtr((const char *)result); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ND_FECollection_GetTraceCollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_Trace_FECollection *result = 0 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::FiniteElementCollection *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_FECollection_GetTraceCollection" "', argument " "1"" of type '" "mfem::ND_FECollection const *""'"); } + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); { try { - result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2); + result = (mfem::FiniteElementCollection *)((mfem::ND_FECollection const *)arg1)->GetTraceCollection(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8227,148 +6696,27 @@ SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection__SWIG_2(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_Trace_FECollection", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_Trace_FECollection__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_Trace_FECollection__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_Trace_FECollection__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_Trace_FECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_Trace_FECollection::ND_Trace_FECollection(int const,int const,int const,int const)\n" - " mfem::ND_Trace_FECollection::ND_Trace_FECollection(int const,int const,int const)\n" - " mfem::ND_Trace_FECollection::ND_Trace_FECollection(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_ND_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::ND_Trace_FECollection *arg1 = (mfem::ND_Trace_FECollection *) 0 ; + mfem::ND_FECollection *arg1 = (mfem::ND_FECollection *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_FECollection, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_Trace_FECollection" "', argument " "1"" of type '" "mfem::ND_Trace_FECollection *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_FECollection" "', argument " "1"" of type '" "mfem::ND_FECollection *""'"); } - arg1 = reinterpret_cast< mfem::ND_Trace_FECollection * >(argp1); + arg1 = reinterpret_cast< mfem::ND_FECollection * >(argp1); { try { delete arg1; @@ -8395,32 +6743,64 @@ SWIGINTERN PyObject *_wrap_delete_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *ND_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ND_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_FECollection, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *ND_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *ND_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_NURBSFECollection__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - mfem::NURBSFECollection *result = 0 ; + int arg2 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg4 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"dim", (char *)"cb_type", (char *)"ob_type", NULL + }; + mfem::ND_Trace_FECollection *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_ND_Trace_FECollection", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); + } + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (mfem::NURBSFECollection *)new mfem::NURBSFECollection(arg1); + result = (mfem::ND_Trace_FECollection *)new mfem::ND_Trace_FECollection(arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8437,21 +6817,30 @@ SWIGINTERN PyObject *_wrap_new_NURBSFECollection__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NURBSFECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_NURBSFECollection__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_delete_ND_Trace_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::NURBSFECollection *result = 0 ; + mfem::ND_Trace_FECollection *arg1 = (mfem::ND_Trace_FECollection *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ND_Trace_FECollection" "', argument " "1"" of type '" "mfem::ND_Trace_FECollection *""'"); + } + arg1 = reinterpret_cast< mfem::ND_Trace_FECollection * >(argp1); { try { - result = (mfem::NURBSFECollection *)new mfem::NURBSFECollection(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8468,45 +6857,65 @@ SWIGINTERN PyObject *_wrap_new_NURBSFECollection__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NURBSFECollection, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_NURBSFECollection(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 +SWIGINTERN PyObject *ND_Trace_FECollection_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__ND_Trace_FECollection, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *ND_Trace_FECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_NURBSFECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + int arg1 = (int) mfem::NURBSFECollection::VariableOrder ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"Order", NULL }; + mfem::NURBSFECollection *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "new_NURBSFECollection", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_NURBSFECollection__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_NURBSFECollection", kwnames, &obj0)) SWIG_fail; + if (obj0) { { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } - if (_v) { - return _wrap_new_NURBSFECollection__SWIG_0(self, argc, argv); + } + { + try { + result = (mfem::NURBSFECollection *)new mfem::NURBSFECollection(arg1); } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NURBSFECollection, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NURBSFECollection'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NURBSFECollection::NURBSFECollection(int)\n" - " mfem::NURBSFECollection::NURBSFECollection()\n"); - return 0; + return NULL; } @@ -8591,25 +7000,29 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_GetOrder(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_NURBSFECollection_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Order", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_SetOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFECollection_SetOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_SetOrder" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -8637,7 +7050,7 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_SetOrder(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8645,16 +7058,20 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NURBSFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8685,7 +7102,7 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_FiniteElementForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8693,16 +7110,20 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSED int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NURBSFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -8733,7 +7154,7 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_DofForGeometry(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_NURBSFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFECollection *arg1 = (mfem::NURBSFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8742,25 +7163,30 @@ SWIGINTERN PyObject *_wrap_NURBSFECollection_DofOrderForOrientation(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NURBSFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBSFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::NURBSFECollection const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NURBSFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -8952,7 +7378,7 @@ SWIGINTERN PyObject *_wrap_new_LinearFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFECollection *arg1 = (mfem::LinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -8960,16 +7386,20 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9000,7 +7430,7 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFECollection *arg1 = (mfem::LinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9008,16 +7438,20 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9048,7 +7482,7 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_LinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFECollection *arg1 = (mfem::LinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9057,25 +7491,30 @@ SWIGINTERN PyObject *_wrap_LinearFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9226,7 +7665,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticFECollection(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticFECollection *arg1 = (mfem::QuadraticFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9234,16 +7673,20 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObje int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9274,7 +7717,7 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_FiniteElementForGeometry(PyObje } -SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticFECollection *arg1 = (mfem::QuadraticFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9282,16 +7725,20 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUN int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9322,7 +7769,7 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofForGeometry(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticFECollection *arg1 = (mfem::QuadraticFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9331,25 +7778,30 @@ SWIGINTERN PyObject *_wrap_QuadraticFECollection_DofOrderForOrientation(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9500,7 +7952,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticPosFECollection(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosFECollection *arg1 = (mfem::QuadraticPosFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9508,16 +7960,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyO int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9548,7 +8004,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_FiniteElementForGeometry(PyO } -SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosFECollection *arg1 = (mfem::QuadraticPosFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9556,16 +8012,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWI int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9596,7 +8056,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofForGeometry(PyObject *SWI } -SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosFECollection *arg1 = (mfem::QuadraticPosFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9605,25 +8065,30 @@ SWIGINTERN PyObject *_wrap_QuadraticPosFECollection_DofOrderForOrientation(PyObj int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticPosFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticPosFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9774,7 +8239,7 @@ SWIGINTERN PyObject *_wrap_new_CubicFECollection(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicFECollection *arg1 = (mfem::CubicFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9782,16 +8247,20 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::CubicFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9822,7 +8291,7 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_FiniteElementForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicFECollection *arg1 = (mfem::CubicFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9830,16 +8299,20 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSED int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CubicFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::CubicFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -9870,7 +8343,7 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_DofForGeometry(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_CubicFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicFECollection *arg1 = (mfem::CubicFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -9879,25 +8352,30 @@ SWIGINTERN PyObject *_wrap_CubicFECollection_DofOrderForOrientation(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CubicFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::CubicFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10048,7 +8526,7 @@ SWIGINTERN PyObject *_wrap_new_CrouzeixRaviartFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFECollection *arg1 = (mfem::CrouzeixRaviartFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10056,16 +8534,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CrouzeixRaviartFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrouzeixRaviartFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10096,7 +8578,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFECollection *arg1 = (mfem::CrouzeixRaviartFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10104,16 +8586,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CrouzeixRaviartFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrouzeixRaviartFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10144,7 +8630,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFECollection *arg1 = (mfem::CrouzeixRaviartFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10153,25 +8639,30 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CrouzeixRaviartFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10322,7 +8813,7 @@ SWIGINTERN PyObject *_wrap_new_LinearNonConf3DFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearNonConf3DFECollection *arg1 = (mfem::LinearNonConf3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10330,16 +8821,20 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearNonConf3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearNonConf3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearNonConf3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearNonConf3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearNonConf3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearNonConf3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10370,7 +8865,7 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearNonConf3DFECollection *arg1 = (mfem::LinearNonConf3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10378,16 +8873,20 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearNonConf3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearNonConf3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearNonConf3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearNonConf3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearNonConf3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearNonConf3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10418,7 +8917,7 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearNonConf3DFECollection *arg1 = (mfem::LinearNonConf3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10427,25 +8926,30 @@ SWIGINTERN PyObject *_wrap_LinearNonConf3DFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearNonConf3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearNonConf3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearNonConf3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearNonConf3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearNonConf3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearNonConf3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearNonConf3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10596,7 +9100,7 @@ SWIGINTERN PyObject *_wrap_new_RT0_2DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_2DFECollection *arg1 = (mfem::RT0_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10604,16 +9108,20 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT0_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10644,7 +9152,7 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_2DFECollection *arg1 = (mfem::RT0_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10652,16 +9160,20 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT0_2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT0_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10692,7 +9204,7 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_2DFECollection *arg1 = (mfem::RT0_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10701,25 +9213,30 @@ SWIGINTERN PyObject *_wrap_RT0_2DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0_2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT0_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -10870,7 +9387,7 @@ SWIGINTERN PyObject *_wrap_new_RT1_2DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_2DFECollection *arg1 = (mfem::RT1_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10878,16 +9395,20 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT1_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10918,7 +9439,7 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_2DFECollection *arg1 = (mfem::RT1_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10926,16 +9447,20 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT1_2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT1_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -10966,7 +9491,7 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_2DFECollection *arg1 = (mfem::RT1_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -10975,25 +9500,30 @@ SWIGINTERN PyObject *_wrap_RT1_2DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1_2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT1_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11144,7 +9674,7 @@ SWIGINTERN PyObject *_wrap_new_RT2_2DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2_2DFECollection *arg1 = (mfem::RT2_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11152,16 +9682,20 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT2_2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT2_2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2_2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT2_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT2_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT2_2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11192,7 +9726,7 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2_2DFECollection *arg1 = (mfem::RT2_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11200,16 +9734,20 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT2_2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT2_2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2_2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT2_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT2_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT2_2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11240,7 +9778,7 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2_2DFECollection *arg1 = (mfem::RT2_2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11249,25 +9787,30 @@ SWIGINTERN PyObject *_wrap_RT2_2DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT2_2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2_2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2_2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2_2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT2_2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT2_2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT2_2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11418,7 +9961,7 @@ SWIGINTERN PyObject *_wrap_new_Const2DFECollection(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const2DFECollection *arg1 = (mfem::Const2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11426,16 +9969,20 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::Const2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11466,7 +10013,7 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const2DFECollection *arg1 = (mfem::Const2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11474,16 +10021,20 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUS int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Const2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::Const2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11514,7 +10065,7 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_DofForGeometry(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Const2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const2DFECollection *arg1 = (mfem::Const2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11523,25 +10074,30 @@ SWIGINTERN PyObject *_wrap_Const2DFECollection_DofOrderForOrientation(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Const2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::Const2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11692,7 +10248,7 @@ SWIGINTERN PyObject *_wrap_new_LinearDiscont2DFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont2DFECollection *arg1 = (mfem::LinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11700,16 +10256,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11740,7 +10300,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont2DFECollection *arg1 = (mfem::LinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11748,16 +10308,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -11788,7 +10352,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont2DFECollection *arg1 = (mfem::LinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11797,25 +10361,30 @@ SWIGINTERN PyObject *_wrap_LinearDiscont2DFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -11966,7 +10535,7 @@ SWIGINTERN PyObject *_wrap_new_GaussLinearDiscont2DFECollection(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinearDiscont2DFECollection *arg1 = (mfem::GaussLinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -11974,16 +10543,20 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeom int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussLinearDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::GaussLinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussLinearDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12014,7 +10587,7 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeom } -SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinearDiscont2DFECollection *arg1 = (mfem::GaussLinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12022,16 +10595,20 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObj int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GaussLinearDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussLinearDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinearDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::GaussLinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussLinearDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12062,7 +10639,7 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofForGeometry(PyObj } -SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinearDiscont2DFECollection *arg1 = (mfem::GaussLinearDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12071,25 +10648,30 @@ SWIGINTERN PyObject *_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientati int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussLinearDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinearDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinearDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::GaussLinearDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinearDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussLinearDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12240,7 +10822,7 @@ SWIGINTERN PyObject *_wrap_new_P1OnQuadFECollection(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFECollection *arg1 = (mfem::P1OnQuadFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12248,16 +10830,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObjec int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:P1OnQuadFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::P1OnQuadFECollection const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "P1OnQuadFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12288,7 +10874,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_FiniteElementForGeometry(PyObjec } -SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFECollection *arg1 = (mfem::P1OnQuadFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12296,16 +10882,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNU int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:P1OnQuadFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::P1OnQuadFECollection const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "P1OnQuadFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12336,7 +10926,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofForGeometry(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFECollection *arg1 = (mfem::P1OnQuadFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12345,25 +10935,30 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFECollection_DofOrderForOrientation(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::P1OnQuadFECollection const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "P1OnQuadFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12514,7 +11109,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticDiscont2DFECollection(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont2DFECollection *arg1 = (mfem::QuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12522,16 +11117,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeomet int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12562,7 +11161,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeomet } -SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont2DFECollection *arg1 = (mfem::QuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12570,16 +11169,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObjec int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12610,7 +11213,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofForGeometry(PyObjec } -SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont2DFECollection *arg1 = (mfem::QuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12619,25 +11222,30 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -12788,7 +11396,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticPosDiscont2DFECollection(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosDiscont2DFECollection *arg1 = (mfem::QuadraticPosDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12796,16 +11404,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeo int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12836,7 +11448,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeo } -SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosDiscont2DFECollection *arg1 = (mfem::QuadraticPosDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12844,16 +11456,20 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticPosDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticPosDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -12884,7 +11500,7 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry(PyOb } -SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticPosDiscont2DFECollection *arg1 = (mfem::QuadraticPosDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -12893,25 +11509,30 @@ SWIGINTERN PyObject *_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientat int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticPosDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticPosDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticPosDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticPosDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticPosDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticPosDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -13062,7 +11683,7 @@ SWIGINTERN PyObject *_wrap_new_GaussQuadraticDiscont2DFECollection(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuadraticDiscont2DFECollection *arg1 = (mfem::GaussQuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13070,16 +11691,20 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForG int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::GaussQuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13110,7 +11735,7 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForG } -SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuadraticDiscont2DFECollection *arg1 = (mfem::GaussQuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13118,16 +11743,20 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "GaussQuadraticDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GaussQuadraticDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuadraticDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::GaussQuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussQuadraticDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13158,7 +11787,7 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry(Py } -SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuadraticDiscont2DFECollection *arg1 = (mfem::GaussQuadraticDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13167,25 +11796,30 @@ SWIGINTERN PyObject *_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrient int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuadraticDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::GaussQuadraticDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuadraticDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -13336,7 +11970,7 @@ SWIGINTERN PyObject *_wrap_new_CubicDiscont2DFECollection(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicDiscont2DFECollection *arg1 = (mfem::CubicDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13344,16 +11978,20 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(P int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicDiscont2DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicDiscont2DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicDiscont2DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::CubicDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicDiscont2DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13384,7 +12022,7 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry(P } -SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicDiscont2DFECollection *arg1 = (mfem::CubicDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13392,16 +12030,20 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CubicDiscont2DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CubicDiscont2DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicDiscont2DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::CubicDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicDiscont2DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13432,7 +12074,7 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofForGeometry(PyObject *S } -SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CubicDiscont2DFECollection *arg1 = (mfem::CubicDiscont2DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13441,25 +12083,30 @@ SWIGINTERN PyObject *_wrap_CubicDiscont2DFECollection_DofOrderForOrientation(PyO int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "CubicDiscont2DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CubicDiscont2DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CubicDiscont2DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CubicDiscont2DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::CubicDiscont2DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::CubicDiscont2DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CubicDiscont2DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -13610,7 +12257,7 @@ SWIGINTERN PyObject *_wrap_new_Const3DFECollection(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const3DFECollection *arg1 = (mfem::Const3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13618,16 +12265,20 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::Const3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13658,7 +12309,7 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const3DFECollection *arg1 = (mfem::Const3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13666,16 +12317,20 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUS int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Const3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Const3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::Const3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13706,7 +12361,7 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_DofForGeometry(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Const3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Const3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Const3DFECollection *arg1 = (mfem::Const3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13715,25 +12370,30 @@ SWIGINTERN PyObject *_wrap_Const3DFECollection_DofOrderForOrientation(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Const3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Const3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Const3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Const3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::Const3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::Const3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Const3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -13884,7 +12544,7 @@ SWIGINTERN PyObject *_wrap_new_LinearDiscont3DFECollection(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont3DFECollection *arg1 = (mfem::LinearDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13892,16 +12552,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry( int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13932,7 +12596,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry( } -SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont3DFECollection *arg1 = (mfem::LinearDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13940,16 +12604,20 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject * int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearDiscont3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::LinearDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -13980,7 +12648,7 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofForGeometry(PyObject * } -SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearDiscont3DFECollection *arg1 = (mfem::LinearDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -13989,25 +12657,30 @@ SWIGINTERN PyObject *_wrap_LinearDiscont3DFECollection_DofOrderForOrientation(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "LinearDiscont3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LinearDiscont3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearDiscont3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::LinearDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::LinearDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LinearDiscont3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -14158,7 +12831,7 @@ SWIGINTERN PyObject *_wrap_new_QuadraticDiscont3DFECollection(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont3DFECollection *arg1 = (mfem::QuadraticDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14166,16 +12839,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeomet int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -14206,7 +12883,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeomet } -SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont3DFECollection *arg1 = (mfem::QuadraticDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14214,16 +12891,20 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObjec int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadraticDiscont3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::QuadraticDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -14254,7 +12935,7 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofForGeometry(PyObjec } -SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadraticDiscont3DFECollection *arg1 = (mfem::QuadraticDiscont3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14263,25 +12944,30 @@ SWIGINTERN PyObject *_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadraticDiscont3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadraticDiscont3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadraticDiscont3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadraticDiscont3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::QuadraticDiscont3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::QuadraticDiscont3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadraticDiscont3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -14432,7 +13118,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinearFECollection(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinearFECollection *arg1 = (mfem::RefinedLinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14440,16 +13126,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinearFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RefinedLinearFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinearFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RefinedLinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RefinedLinearFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -14480,7 +13170,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_FiniteElementForGeometry(Py } -SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinearFECollection *arg1 = (mfem::RefinedLinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14488,16 +13178,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinearFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RefinedLinearFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinearFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RefinedLinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RefinedLinearFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -14528,7 +13222,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofForGeometry(PyObject *SW } -SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinearFECollection *arg1 = (mfem::RefinedLinearFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14537,25 +13231,30 @@ SWIGINTERN PyObject *_wrap_RefinedLinearFECollection_DofOrderForOrientation(PyOb int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinearFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinearFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinearFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinearFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RefinedLinearFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinearFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RefinedLinearFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -14706,7 +13405,7 @@ SWIGINTERN PyObject *_wrap_new_ND1_3DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND1_3DFECollection *arg1 = (mfem::ND1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14714,16 +13413,20 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ND1_3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND1_3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND1_3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::ND1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND1_3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -14754,7 +13457,7 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND1_3DFECollection *arg1 = (mfem::ND1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14762,16 +13465,20 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ND1_3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ND1_3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND1_3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::ND1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND1_3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -14802,7 +13509,7 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND1_3DFECollection *arg1 = (mfem::ND1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14811,25 +13518,30 @@ SWIGINTERN PyObject *_wrap_ND1_3DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ND1_3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND1_3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND1_3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::ND1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::ND1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ND1_3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -14980,7 +13692,7 @@ SWIGINTERN PyObject *_wrap_new_RT0_3DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_3DFECollection *arg1 = (mfem::RT0_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -14988,16 +13700,20 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT0_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -15028,7 +13744,7 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_3DFECollection *arg1 = (mfem::RT0_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15036,16 +13752,20 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT0_3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT0_3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT0_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -15076,7 +13796,7 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0_3DFECollection *arg1 = (mfem::RT0_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15085,25 +13805,30 @@ SWIGINTERN PyObject *_wrap_RT0_3DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT0_3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0_3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0_3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT0_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT0_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT0_3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -15254,7 +13979,7 @@ SWIGINTERN PyObject *_wrap_new_RT1_3DFECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_3DFECollection *arg1 = (mfem::RT1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15262,16 +13987,20 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_3DFECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_3DFECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_3DFECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::RT1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_3DFECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -15302,7 +14031,7 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_3DFECollection *arg1 = (mfem::RT1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15310,16 +14039,20 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "RT1_3DFECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RT1_3DFECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_3DFECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::RT1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_3DFECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -15350,7 +14083,7 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1_3DFECollection *arg1 = (mfem::RT1_3DFECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15359,25 +14092,30 @@ SWIGINTERN PyObject *_wrap_RT1_3DFECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RT1_3DFECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1_3DFECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1_3DFECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1_3DFECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::RT1_3DFECollection const *""'"); } arg1 = reinterpret_cast< mfem::RT1_3DFECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RT1_3DFECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -15497,18 +14235,20 @@ SWIGINTERN PyObject *RT1_3DFECollection_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_Local_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Local_FECollection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"fe_name", NULL + }; mfem::Local_FECollection *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_Local_FECollection", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Local_FECollection" "', argument " "1"" of type '" "char const *""'"); } @@ -15541,7 +14281,7 @@ SWIGINTERN PyObject *_wrap_new_Local_FECollection(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Local_FECollection *arg1 = (mfem::Local_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15549,16 +14289,20 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_GeomType", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Local_FECollection_FiniteElementForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Local_FECollection_FiniteElementForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Local_FECollection_FiniteElementForGeometry" "', argument " "1"" of type '" "mfem::Local_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::Local_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Local_FECollection_FiniteElementForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -15589,7 +14333,7 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_FiniteElementForGeometry(PyObject } -SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Local_FECollection *arg1 = (mfem::Local_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15597,16 +14341,20 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Local_FECollection_DofForGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Local_FECollection_DofForGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Local_FECollection_DofForGeometry" "', argument " "1"" of type '" "mfem::Local_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::Local_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Local_FECollection_DofForGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } @@ -15637,7 +14385,7 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_DofForGeometry(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Local_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Local_FECollection_DofOrderForOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Local_FECollection *arg1 = (mfem::Local_FECollection *) 0 ; mfem::Geometry::Type arg2 ; @@ -15646,25 +14394,30 @@ SWIGINTERN PyObject *_wrap_Local_FECollection_DofOrderForOrientation(PyObject *S int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Or", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Local_FECollection_DofOrderForOrientation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Local_FECollection_DofOrderForOrientation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Local_FECollection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Local_FECollection_DofOrderForOrientation" "', argument " "1"" of type '" "mfem::Local_FECollection const *""'"); } arg1 = reinterpret_cast< mfem::Local_FECollection * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Local_FECollection_DofOrderForOrientation" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -15789,302 +14542,302 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, - { "FiniteElementCollection_FiniteElementForGeometry", _wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementCollection_FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "FiniteElementCollection_DofForGeometry", _wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS, "FiniteElementCollection_DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_DofOrderForOrientation", _wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS, "FiniteElementCollection_DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "FiniteElementCollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "FiniteElementCollection_Name", _wrap_FiniteElementCollection_Name, METH_O, "FiniteElementCollection_Name(FiniteElementCollection self) -> char const *"}, - { "FiniteElementCollection_HasFaceDofs", _wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS, "FiniteElementCollection_HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_TraceFiniteElementForGeometry", _wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS, "FiniteElementCollection_TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_HasFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "FiniteElementCollection_GetTraceCollection", _wrap_FiniteElementCollection_GetTraceCollection, METH_O, "FiniteElementCollection_GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection"}, { "delete_FiniteElementCollection", _wrap_delete_FiniteElementCollection, METH_O, "delete_FiniteElementCollection(FiniteElementCollection self)"}, - { "FiniteElementCollection_New", _wrap_FiniteElementCollection_New, METH_O, "FiniteElementCollection_New(char const * name) -> FiniteElementCollection"}, - { "FiniteElementCollection_SubDofOrder", _wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS, "FiniteElementCollection_SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, + { "FiniteElementCollection_New", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_New, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_New(char const * name) -> FiniteElementCollection"}, + { "FiniteElementCollection_SubDofOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS|METH_KEYWORDS, "FiniteElementCollection_SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, { "FiniteElementCollection_swigregister", FiniteElementCollection_swigregister, METH_O, NULL}, - { "new_H1_FECollection", _wrap_new_H1_FECollection, METH_VARARGS, "H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto)"}, - { "H1_FECollection_FiniteElementForGeometry", _wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS, "H1_FECollection_FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "H1_FECollection_DofForGeometry", _wrap_H1_FECollection_DofForGeometry, METH_VARARGS, "H1_FECollection_DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "H1_FECollection_DofOrderForOrientation", _wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS, "H1_FECollection_DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_H1_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto) -> H1_FECollection"}, + { "H1_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "H1_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "H1_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "H1_FECollection_Name", _wrap_H1_FECollection_Name, METH_O, "H1_FECollection_Name(H1_FECollection self) -> char const *"}, { "H1_FECollection_GetTraceCollection", _wrap_H1_FECollection_GetTraceCollection, METH_O, "H1_FECollection_GetTraceCollection(H1_FECollection self) -> FiniteElementCollection"}, { "H1_FECollection_GetBasisType", _wrap_H1_FECollection_GetBasisType, METH_O, "H1_FECollection_GetBasisType(H1_FECollection self) -> int"}, - { "H1_FECollection_GetDofMap", _wrap_H1_FECollection_GetDofMap, METH_VARARGS, "H1_FECollection_GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, + { "H1_FECollection_GetDofMap", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_GetDofMap, METH_VARARGS|METH_KEYWORDS, "H1_FECollection_GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, { "delete_H1_FECollection", _wrap_delete_H1_FECollection, METH_O, "delete_H1_FECollection(H1_FECollection self)"}, { "H1_FECollection_swigregister", H1_FECollection_swigregister, METH_O, NULL}, { "H1_FECollection_swiginit", H1_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_FECollection", _wrap_new_H1Pos_FECollection, METH_VARARGS, "H1Pos_FECollection(int const p, int const dim=3)"}, + { "new_H1Pos_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_FECollection(int const p, int const dim=3) -> H1Pos_FECollection"}, { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "new_H1Ser_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_FECollection(int const p, int const dim=2) -> H1Ser_FECollection"}, { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, + { "new_H1_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto) -> H1_Trace_FECollection"}, { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, { "H1_Trace_FECollection_swiginit", H1_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_L2_FECollection", _wrap_new_L2_FECollection, METH_VARARGS, "L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE)"}, - { "L2_FECollection_FiniteElementForGeometry", _wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS, "L2_FECollection_FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "L2_FECollection_DofForGeometry", _wrap_L2_FECollection_DofForGeometry, METH_VARARGS, "L2_FECollection_DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "L2_FECollection_DofOrderForOrientation", _wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS, "L2_FECollection_DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_L2_FECollection", (PyCFunction)(void(*)(void))_wrap_new_L2_FECollection, METH_VARARGS|METH_KEYWORDS, "new_L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE) -> L2_FECollection"}, + { "L2_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "L2_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "L2_FECollection_Name", _wrap_L2_FECollection_Name, METH_O, "L2_FECollection_Name(L2_FECollection self) -> char const *"}, - { "L2_FECollection_TraceFiniteElementForGeometry", _wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS, "L2_FECollection_TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "L2_FECollection_TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "L2_FECollection_GetBasisType", _wrap_L2_FECollection_GetBasisType, METH_O, "L2_FECollection_GetBasisType(L2_FECollection self) -> int"}, { "delete_L2_FECollection", _wrap_delete_L2_FECollection, METH_O, "delete_L2_FECollection(L2_FECollection self)"}, { "L2_FECollection_swigregister", L2_FECollection_swigregister, METH_O, NULL}, { "L2_FECollection_swiginit", L2_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, "RT_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "RT_FECollection_FiniteElementForGeometry", _wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS, "RT_FECollection_FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT_FECollection_DofForGeometry", _wrap_RT_FECollection_DofForGeometry, METH_VARARGS, "RT_FECollection_DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT_FECollection_DofOrderForOrientation", _wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS, "RT_FECollection_DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, NULL}, + { "RT_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT_FECollection_FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT_FECollection_DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT_FECollection_DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT_FECollection_Name", _wrap_RT_FECollection_Name, METH_O, "RT_FECollection_Name(RT_FECollection self) -> char const *"}, { "RT_FECollection_GetTraceCollection", _wrap_RT_FECollection_GetTraceCollection, METH_O, "RT_FECollection_GetTraceCollection(RT_FECollection self) -> FiniteElementCollection"}, { "delete_RT_FECollection", _wrap_delete_RT_FECollection, METH_O, "delete_RT_FECollection(RT_FECollection self)"}, { "RT_FECollection_swigregister", RT_FECollection_swigregister, METH_O, NULL}, { "RT_FECollection_swiginit", RT_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_Trace_FECollection", _wrap_new_RT_Trace_FECollection, METH_VARARGS, "RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre)"}, + { "new_RT_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_RT_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre) -> RT_Trace_FECollection"}, { "delete_RT_Trace_FECollection", _wrap_delete_RT_Trace_FECollection, METH_O, "delete_RT_Trace_FECollection(RT_Trace_FECollection self)"}, { "RT_Trace_FECollection_swigregister", RT_Trace_FECollection_swigregister, METH_O, NULL}, { "RT_Trace_FECollection_swiginit", RT_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_DG_Interface_FECollection", _wrap_new_DG_Interface_FECollection, METH_VARARGS, "DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre)"}, + { "new_DG_Interface_FECollection", (PyCFunction)(void(*)(void))_wrap_new_DG_Interface_FECollection, METH_VARARGS|METH_KEYWORDS, "new_DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre) -> DG_Interface_FECollection"}, { "delete_DG_Interface_FECollection", _wrap_delete_DG_Interface_FECollection, METH_O, "delete_DG_Interface_FECollection(DG_Interface_FECollection self)"}, { "DG_Interface_FECollection_swigregister", DG_Interface_FECollection_swigregister, METH_O, NULL}, { "DG_Interface_FECollection_swiginit", DG_Interface_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_FECollection", _wrap_new_ND_FECollection, METH_VARARGS, "ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "ND_FECollection_FiniteElementForGeometry", _wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS, "ND_FECollection_FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND_FECollection_DofForGeometry", _wrap_ND_FECollection_DofForGeometry, METH_VARARGS, "ND_FECollection_DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND_FECollection_DofOrderForOrientation", _wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS, "ND_FECollection_DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_ND_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_FECollection"}, + { "ND_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "ND_FECollection_FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "ND_FECollection_DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "ND_FECollection_DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND_FECollection_Name", _wrap_ND_FECollection_Name, METH_O, "ND_FECollection_Name(ND_FECollection self) -> char const *"}, { "ND_FECollection_GetTraceCollection", _wrap_ND_FECollection_GetTraceCollection, METH_O, "ND_FECollection_GetTraceCollection(ND_FECollection self) -> FiniteElementCollection"}, { "delete_ND_FECollection", _wrap_delete_ND_FECollection, METH_O, "delete_ND_FECollection(ND_FECollection self)"}, { "ND_FECollection_swigregister", ND_FECollection_swigregister, METH_O, NULL}, { "ND_FECollection_swiginit", ND_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_Trace_FECollection", _wrap_new_ND_Trace_FECollection, METH_VARARGS, "ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_Trace_FECollection"}, { "delete_ND_Trace_FECollection", _wrap_delete_ND_Trace_FECollection, METH_O, "delete_ND_Trace_FECollection(ND_Trace_FECollection self)"}, { "ND_Trace_FECollection_swigregister", ND_Trace_FECollection_swigregister, METH_O, NULL}, { "ND_Trace_FECollection_swiginit", ND_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_NURBSFECollection", _wrap_new_NURBSFECollection, METH_VARARGS, "NURBSFECollection(int Order=VariableOrder)"}, + { "new_NURBSFECollection", (PyCFunction)(void(*)(void))_wrap_new_NURBSFECollection, METH_VARARGS|METH_KEYWORDS, "new_NURBSFECollection(int Order=VariableOrder) -> NURBSFECollection"}, { "NURBSFECollection_Reset", _wrap_NURBSFECollection_Reset, METH_O, "NURBSFECollection_Reset(NURBSFECollection self)"}, { "NURBSFECollection_GetOrder", _wrap_NURBSFECollection_GetOrder, METH_O, "NURBSFECollection_GetOrder(NURBSFECollection self) -> int"}, - { "NURBSFECollection_SetOrder", _wrap_NURBSFECollection_SetOrder, METH_VARARGS, "NURBSFECollection_SetOrder(NURBSFECollection self, int Order)"}, - { "NURBSFECollection_FiniteElementForGeometry", _wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS, "NURBSFECollection_FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "NURBSFECollection_DofForGeometry", _wrap_NURBSFECollection_DofForGeometry, METH_VARARGS, "NURBSFECollection_DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "NURBSFECollection_DofOrderForOrientation", _wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS, "NURBSFECollection_DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "NURBSFECollection_SetOrder", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_SetOrder, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_SetOrder(NURBSFECollection self, int Order)"}, + { "NURBSFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "NURBSFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "NURBSFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "NURBSFECollection_DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "NURBSFECollection_Name", _wrap_NURBSFECollection_Name, METH_O, "NURBSFECollection_Name(NURBSFECollection self) -> char const *"}, { "NURBSFECollection_GetTraceCollection", _wrap_NURBSFECollection_GetTraceCollection, METH_O, "NURBSFECollection_GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection"}, { "delete_NURBSFECollection", _wrap_delete_NURBSFECollection, METH_O, "delete_NURBSFECollection(NURBSFECollection self)"}, { "NURBSFECollection_swigregister", NURBSFECollection_swigregister, METH_O, NULL}, { "NURBSFECollection_swiginit", NURBSFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearFECollection", _wrap_new_LinearFECollection, METH_NOARGS, "new_LinearFECollection() -> LinearFECollection"}, - { "LinearFECollection_FiniteElementForGeometry", _wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearFECollection_FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearFECollection_DofForGeometry", _wrap_LinearFECollection_DofForGeometry, METH_VARARGS, "LinearFECollection_DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearFECollection_DofOrderForOrientation", _wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS, "LinearFECollection_DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearFECollection_FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearFECollection_DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearFECollection_DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearFECollection_Name", _wrap_LinearFECollection_Name, METH_O, "LinearFECollection_Name(LinearFECollection self) -> char const *"}, { "delete_LinearFECollection", _wrap_delete_LinearFECollection, METH_O, "delete_LinearFECollection(LinearFECollection self)"}, { "LinearFECollection_swigregister", LinearFECollection_swigregister, METH_O, NULL}, { "LinearFECollection_swiginit", LinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticFECollection", _wrap_new_QuadraticFECollection, METH_NOARGS, "new_QuadraticFECollection() -> QuadraticFECollection"}, - { "QuadraticFECollection_FiniteElementForGeometry", _wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticFECollection_FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticFECollection_DofForGeometry", _wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS, "QuadraticFECollection_DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticFECollection_DofOrderForOrientation", _wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticFECollection_DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticFECollection_FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticFECollection_DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticFECollection_DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticFECollection_Name", _wrap_QuadraticFECollection_Name, METH_O, "QuadraticFECollection_Name(QuadraticFECollection self) -> char const *"}, { "delete_QuadraticFECollection", _wrap_delete_QuadraticFECollection, METH_O, "delete_QuadraticFECollection(QuadraticFECollection self)"}, { "QuadraticFECollection_swigregister", QuadraticFECollection_swigregister, METH_O, NULL}, { "QuadraticFECollection_swiginit", QuadraticFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosFECollection", _wrap_new_QuadraticPosFECollection, METH_NOARGS, "new_QuadraticPosFECollection() -> QuadraticPosFECollection"}, - { "QuadraticPosFECollection_FiniteElementForGeometry", _wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticPosFECollection_FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosFECollection_DofForGeometry", _wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS, "QuadraticPosFECollection_DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosFECollection_DofOrderForOrientation", _wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticPosFECollection_DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosFECollection_FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosFECollection_DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticPosFECollection_DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosFECollection_Name", _wrap_QuadraticPosFECollection_Name, METH_O, "QuadraticPosFECollection_Name(QuadraticPosFECollection self) -> char const *"}, { "delete_QuadraticPosFECollection", _wrap_delete_QuadraticPosFECollection, METH_O, "delete_QuadraticPosFECollection(QuadraticPosFECollection self)"}, { "QuadraticPosFECollection_swigregister", QuadraticPosFECollection_swigregister, METH_O, NULL}, { "QuadraticPosFECollection_swiginit", QuadraticPosFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicFECollection", _wrap_new_CubicFECollection, METH_NOARGS, "new_CubicFECollection() -> CubicFECollection"}, - { "CubicFECollection_FiniteElementForGeometry", _wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS, "CubicFECollection_FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicFECollection_DofForGeometry", _wrap_CubicFECollection_DofForGeometry, METH_VARARGS, "CubicFECollection_DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicFECollection_DofOrderForOrientation", _wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS, "CubicFECollection_DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicFECollection_FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicFECollection_DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "CubicFECollection_DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicFECollection_Name", _wrap_CubicFECollection_Name, METH_O, "CubicFECollection_Name(CubicFECollection self) -> char const *"}, { "delete_CubicFECollection", _wrap_delete_CubicFECollection, METH_O, "delete_CubicFECollection(CubicFECollection self)"}, { "CubicFECollection_swigregister", CubicFECollection_swigregister, METH_O, NULL}, { "CubicFECollection_swiginit", CubicFECollection_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFECollection", _wrap_new_CrouzeixRaviartFECollection, METH_NOARGS, "new_CrouzeixRaviartFECollection() -> CrouzeixRaviartFECollection"}, - { "CrouzeixRaviartFECollection_FiniteElementForGeometry", _wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS, "CrouzeixRaviartFECollection_FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CrouzeixRaviartFECollection_DofForGeometry", _wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS, "CrouzeixRaviartFECollection_DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CrouzeixRaviartFECollection_DofOrderForOrientation", _wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS, "CrouzeixRaviartFECollection_DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CrouzeixRaviartFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFECollection_FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CrouzeixRaviartFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFECollection_DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CrouzeixRaviartFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFECollection_DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CrouzeixRaviartFECollection_Name", _wrap_CrouzeixRaviartFECollection_Name, METH_O, "CrouzeixRaviartFECollection_Name(CrouzeixRaviartFECollection self) -> char const *"}, { "delete_CrouzeixRaviartFECollection", _wrap_delete_CrouzeixRaviartFECollection, METH_O, "delete_CrouzeixRaviartFECollection(CrouzeixRaviartFECollection self)"}, { "CrouzeixRaviartFECollection_swigregister", CrouzeixRaviartFECollection_swigregister, METH_O, NULL}, { "CrouzeixRaviartFECollection_swiginit", CrouzeixRaviartFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearNonConf3DFECollection", _wrap_new_LinearNonConf3DFECollection, METH_NOARGS, "new_LinearNonConf3DFECollection() -> LinearNonConf3DFECollection"}, - { "LinearNonConf3DFECollection_FiniteElementForGeometry", _wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearNonConf3DFECollection_FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearNonConf3DFECollection_DofForGeometry", _wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS, "LinearNonConf3DFECollection_DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearNonConf3DFECollection_DofOrderForOrientation", _wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS, "LinearNonConf3DFECollection_DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearNonConf3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearNonConf3DFECollection_FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearNonConf3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearNonConf3DFECollection_DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearNonConf3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearNonConf3DFECollection_DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearNonConf3DFECollection_Name", _wrap_LinearNonConf3DFECollection_Name, METH_O, "LinearNonConf3DFECollection_Name(LinearNonConf3DFECollection self) -> char const *"}, { "delete_LinearNonConf3DFECollection", _wrap_delete_LinearNonConf3DFECollection, METH_O, "delete_LinearNonConf3DFECollection(LinearNonConf3DFECollection self)"}, { "LinearNonConf3DFECollection_swigregister", LinearNonConf3DFECollection_swigregister, METH_O, NULL}, { "LinearNonConf3DFECollection_swiginit", LinearNonConf3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_2DFECollection", _wrap_new_RT0_2DFECollection, METH_NOARGS, "new_RT0_2DFECollection() -> RT0_2DFECollection"}, - { "RT0_2DFECollection_FiniteElementForGeometry", _wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT0_2DFECollection_FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_2DFECollection_DofForGeometry", _wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS, "RT0_2DFECollection_DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_2DFECollection_DofOrderForOrientation", _wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS, "RT0_2DFECollection_DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_2DFECollection_FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_2DFECollection_DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT0_2DFECollection_DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_2DFECollection_Name", _wrap_RT0_2DFECollection_Name, METH_O, "RT0_2DFECollection_Name(RT0_2DFECollection self) -> char const *"}, { "delete_RT0_2DFECollection", _wrap_delete_RT0_2DFECollection, METH_O, "delete_RT0_2DFECollection(RT0_2DFECollection self)"}, { "RT0_2DFECollection_swigregister", RT0_2DFECollection_swigregister, METH_O, NULL}, { "RT0_2DFECollection_swiginit", RT0_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_2DFECollection", _wrap_new_RT1_2DFECollection, METH_NOARGS, "new_RT1_2DFECollection() -> RT1_2DFECollection"}, - { "RT1_2DFECollection_FiniteElementForGeometry", _wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT1_2DFECollection_FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_2DFECollection_DofForGeometry", _wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS, "RT1_2DFECollection_DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_2DFECollection_DofOrderForOrientation", _wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS, "RT1_2DFECollection_DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_2DFECollection_FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_2DFECollection_DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT1_2DFECollection_DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_2DFECollection_Name", _wrap_RT1_2DFECollection_Name, METH_O, "RT1_2DFECollection_Name(RT1_2DFECollection self) -> char const *"}, { "delete_RT1_2DFECollection", _wrap_delete_RT1_2DFECollection, METH_O, "delete_RT1_2DFECollection(RT1_2DFECollection self)"}, { "RT1_2DFECollection_swigregister", RT1_2DFECollection_swigregister, METH_O, NULL}, { "RT1_2DFECollection_swiginit", RT1_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT2_2DFECollection", _wrap_new_RT2_2DFECollection, METH_NOARGS, "new_RT2_2DFECollection() -> RT2_2DFECollection"}, - { "RT2_2DFECollection_FiniteElementForGeometry", _wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT2_2DFECollection_FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT2_2DFECollection_DofForGeometry", _wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS, "RT2_2DFECollection_DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT2_2DFECollection_DofOrderForOrientation", _wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS, "RT2_2DFECollection_DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT2_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT2_2DFECollection_FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT2_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT2_2DFECollection_DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT2_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT2_2DFECollection_DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT2_2DFECollection_Name", _wrap_RT2_2DFECollection_Name, METH_O, "RT2_2DFECollection_Name(RT2_2DFECollection self) -> char const *"}, { "delete_RT2_2DFECollection", _wrap_delete_RT2_2DFECollection, METH_O, "delete_RT2_2DFECollection(RT2_2DFECollection self)"}, { "RT2_2DFECollection_swigregister", RT2_2DFECollection_swigregister, METH_O, NULL}, { "RT2_2DFECollection_swiginit", RT2_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const2DFECollection", _wrap_new_Const2DFECollection, METH_NOARGS, "new_Const2DFECollection() -> Const2DFECollection"}, - { "Const2DFECollection_FiniteElementForGeometry", _wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS, "Const2DFECollection_FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const2DFECollection_DofForGeometry", _wrap_Const2DFECollection_DofForGeometry, METH_VARARGS, "Const2DFECollection_DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const2DFECollection_DofOrderForOrientation", _wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS, "Const2DFECollection_DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "Const2DFECollection_FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "Const2DFECollection_DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "Const2DFECollection_DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const2DFECollection_Name", _wrap_Const2DFECollection_Name, METH_O, "Const2DFECollection_Name(Const2DFECollection self) -> char const *"}, { "delete_Const2DFECollection", _wrap_delete_Const2DFECollection, METH_O, "delete_Const2DFECollection(Const2DFECollection self)"}, { "Const2DFECollection_swigregister", Const2DFECollection_swigregister, METH_O, NULL}, { "Const2DFECollection_swiginit", Const2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont2DFECollection", _wrap_new_LinearDiscont2DFECollection, METH_NOARGS, "new_LinearDiscont2DFECollection() -> LinearDiscont2DFECollection"}, - { "LinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearDiscont2DFECollection_FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont2DFECollection_DofForGeometry", _wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "LinearDiscont2DFECollection_DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont2DFECollection_DofOrderForOrientation", _wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "LinearDiscont2DFECollection_DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont2DFECollection_FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont2DFECollection_DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearDiscont2DFECollection_DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont2DFECollection_Name", _wrap_LinearDiscont2DFECollection_Name, METH_O, "LinearDiscont2DFECollection_Name(LinearDiscont2DFECollection self) -> char const *"}, { "delete_LinearDiscont2DFECollection", _wrap_delete_LinearDiscont2DFECollection, METH_O, "delete_LinearDiscont2DFECollection(LinearDiscont2DFECollection self)"}, { "LinearDiscont2DFECollection_swigregister", LinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont2DFECollection_swiginit", LinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussLinearDiscont2DFECollection", _wrap_new_GaussLinearDiscont2DFECollection, METH_NOARGS, "new_GaussLinearDiscont2DFECollection() -> GaussLinearDiscont2DFECollection"}, - { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "GaussLinearDiscont2DFECollection_FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussLinearDiscont2DFECollection_DofForGeometry", _wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "GaussLinearDiscont2DFECollection_DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "GaussLinearDiscont2DFECollection_DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussLinearDiscont2DFECollection_FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussLinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussLinearDiscont2DFECollection_DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "GaussLinearDiscont2DFECollection_DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussLinearDiscont2DFECollection_Name", _wrap_GaussLinearDiscont2DFECollection_Name, METH_O, "GaussLinearDiscont2DFECollection_Name(GaussLinearDiscont2DFECollection self) -> char const *"}, { "delete_GaussLinearDiscont2DFECollection", _wrap_delete_GaussLinearDiscont2DFECollection, METH_O, "delete_GaussLinearDiscont2DFECollection(GaussLinearDiscont2DFECollection self)"}, { "GaussLinearDiscont2DFECollection_swigregister", GaussLinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussLinearDiscont2DFECollection_swiginit", GaussLinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFECollection", _wrap_new_P1OnQuadFECollection, METH_NOARGS, "new_P1OnQuadFECollection() -> P1OnQuadFECollection"}, - { "P1OnQuadFECollection_FiniteElementForGeometry", _wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS, "P1OnQuadFECollection_FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "P1OnQuadFECollection_DofForGeometry", _wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS, "P1OnQuadFECollection_DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "P1OnQuadFECollection_DofOrderForOrientation", _wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS, "P1OnQuadFECollection_DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "P1OnQuadFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFECollection_FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "P1OnQuadFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFECollection_DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "P1OnQuadFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFECollection_DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "P1OnQuadFECollection_Name", _wrap_P1OnQuadFECollection_Name, METH_O, "P1OnQuadFECollection_Name(P1OnQuadFECollection self) -> char const *"}, { "delete_P1OnQuadFECollection", _wrap_delete_P1OnQuadFECollection, METH_O, "delete_P1OnQuadFECollection(P1OnQuadFECollection self)"}, { "P1OnQuadFECollection_swigregister", P1OnQuadFECollection_swigregister, METH_O, NULL}, { "P1OnQuadFECollection_swiginit", P1OnQuadFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont2DFECollection", _wrap_new_QuadraticDiscont2DFECollection, METH_NOARGS, "new_QuadraticDiscont2DFECollection() -> QuadraticDiscont2DFECollection"}, - { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticDiscont2DFECollection_FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont2DFECollection_DofForGeometry", _wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "QuadraticDiscont2DFECollection_DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticDiscont2DFECollection_DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont2DFECollection_FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont2DFECollection_DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont2DFECollection_DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont2DFECollection_Name", _wrap_QuadraticDiscont2DFECollection_Name, METH_O, "QuadraticDiscont2DFECollection_Name(QuadraticDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticDiscont2DFECollection", _wrap_delete_QuadraticDiscont2DFECollection, METH_O, "delete_QuadraticDiscont2DFECollection(QuadraticDiscont2DFECollection self)"}, { "QuadraticDiscont2DFECollection_swigregister", QuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont2DFECollection_swiginit", QuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosDiscont2DFECollection", _wrap_new_QuadraticPosDiscont2DFECollection, METH_NOARGS, "new_QuadraticPosDiscont2DFECollection() -> QuadraticPosDiscont2DFECollection"}, - { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosDiscont2DFECollection_DofForGeometry", _wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS, "QuadraticPosDiscont2DFECollection_DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticPosDiscont2DFECollection_DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticPosDiscont2DFECollection_DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticPosDiscont2DFECollection_DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosDiscont2DFECollection_Name", _wrap_QuadraticPosDiscont2DFECollection_Name, METH_O, "QuadraticPosDiscont2DFECollection_Name(QuadraticPosDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticPosDiscont2DFECollection", _wrap_delete_QuadraticPosDiscont2DFECollection, METH_O, "delete_QuadraticPosDiscont2DFECollection(QuadraticPosDiscont2DFECollection self)"}, { "QuadraticPosDiscont2DFECollection_swigregister", QuadraticPosDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticPosDiscont2DFECollection_swiginit", QuadraticPosDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussQuadraticDiscont2DFECollection", _wrap_new_GaussQuadraticDiscont2DFECollection, METH_NOARGS, "new_GaussQuadraticDiscont2DFECollection() -> GaussQuadraticDiscont2DFECollection"}, - { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussQuadraticDiscont2DFECollection_DofForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "GaussQuadraticDiscont2DFECollection_DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussQuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "GaussQuadraticDiscont2DFECollection_DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussQuadraticDiscont2DFECollection_Name", _wrap_GaussQuadraticDiscont2DFECollection_Name, METH_O, "GaussQuadraticDiscont2DFECollection_Name(GaussQuadraticDiscont2DFECollection self) -> char const *"}, { "delete_GaussQuadraticDiscont2DFECollection", _wrap_delete_GaussQuadraticDiscont2DFECollection, METH_O, "delete_GaussQuadraticDiscont2DFECollection(GaussQuadraticDiscont2DFECollection self)"}, { "GaussQuadraticDiscont2DFECollection_swigregister", GaussQuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussQuadraticDiscont2DFECollection_swiginit", GaussQuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicDiscont2DFECollection", _wrap_new_CubicDiscont2DFECollection, METH_NOARGS, "new_CubicDiscont2DFECollection() -> CubicDiscont2DFECollection"}, - { "CubicDiscont2DFECollection_FiniteElementForGeometry", _wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "CubicDiscont2DFECollection_FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicDiscont2DFECollection_DofForGeometry", _wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS, "CubicDiscont2DFECollection_DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicDiscont2DFECollection_DofOrderForOrientation", _wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "CubicDiscont2DFECollection_DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicDiscont2DFECollection_FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "CubicDiscont2DFECollection_DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "CubicDiscont2DFECollection_DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicDiscont2DFECollection_Name", _wrap_CubicDiscont2DFECollection_Name, METH_O, "CubicDiscont2DFECollection_Name(CubicDiscont2DFECollection self) -> char const *"}, { "delete_CubicDiscont2DFECollection", _wrap_delete_CubicDiscont2DFECollection, METH_O, "delete_CubicDiscont2DFECollection(CubicDiscont2DFECollection self)"}, { "CubicDiscont2DFECollection_swigregister", CubicDiscont2DFECollection_swigregister, METH_O, NULL}, { "CubicDiscont2DFECollection_swiginit", CubicDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const3DFECollection", _wrap_new_Const3DFECollection, METH_NOARGS, "new_Const3DFECollection() -> Const3DFECollection"}, - { "Const3DFECollection_FiniteElementForGeometry", _wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS, "Const3DFECollection_FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const3DFECollection_DofForGeometry", _wrap_Const3DFECollection_DofForGeometry, METH_VARARGS, "Const3DFECollection_DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const3DFECollection_DofOrderForOrientation", _wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS, "Const3DFECollection_DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "Const3DFECollection_FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "Const3DFECollection_DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "Const3DFECollection_DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const3DFECollection_Name", _wrap_Const3DFECollection_Name, METH_O, "Const3DFECollection_Name(Const3DFECollection self) -> char const *"}, { "delete_Const3DFECollection", _wrap_delete_Const3DFECollection, METH_O, "delete_Const3DFECollection(Const3DFECollection self)"}, { "Const3DFECollection_swigregister", Const3DFECollection_swigregister, METH_O, NULL}, { "Const3DFECollection_swiginit", Const3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont3DFECollection", _wrap_new_LinearDiscont3DFECollection, METH_NOARGS, "new_LinearDiscont3DFECollection() -> LinearDiscont3DFECollection"}, - { "LinearDiscont3DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "LinearDiscont3DFECollection_FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont3DFECollection_DofForGeometry", _wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS, "LinearDiscont3DFECollection_DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont3DFECollection_DofOrderForOrientation", _wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "LinearDiscont3DFECollection_DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont3DFECollection_FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "LinearDiscont3DFECollection_DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "LinearDiscont3DFECollection_DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont3DFECollection_Name", _wrap_LinearDiscont3DFECollection_Name, METH_O, "LinearDiscont3DFECollection_Name(LinearDiscont3DFECollection self) -> char const *"}, { "delete_LinearDiscont3DFECollection", _wrap_delete_LinearDiscont3DFECollection, METH_O, "delete_LinearDiscont3DFECollection(LinearDiscont3DFECollection self)"}, { "LinearDiscont3DFECollection_swigregister", LinearDiscont3DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont3DFECollection_swiginit", LinearDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont3DFECollection", _wrap_new_QuadraticDiscont3DFECollection, METH_NOARGS, "new_QuadraticDiscont3DFECollection() -> QuadraticDiscont3DFECollection"}, - { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "QuadraticDiscont3DFECollection_FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont3DFECollection_DofForGeometry", _wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS, "QuadraticDiscont3DFECollection_DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont3DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "QuadraticDiscont3DFECollection_DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont3DFECollection_FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont3DFECollection_DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "QuadraticDiscont3DFECollection_DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont3DFECollection_Name", _wrap_QuadraticDiscont3DFECollection_Name, METH_O, "QuadraticDiscont3DFECollection_Name(QuadraticDiscont3DFECollection self) -> char const *"}, { "delete_QuadraticDiscont3DFECollection", _wrap_delete_QuadraticDiscont3DFECollection, METH_O, "delete_QuadraticDiscont3DFECollection(QuadraticDiscont3DFECollection self)"}, { "QuadraticDiscont3DFECollection_swigregister", QuadraticDiscont3DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont3DFECollection_swiginit", QuadraticDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinearFECollection", _wrap_new_RefinedLinearFECollection, METH_NOARGS, "new_RefinedLinearFECollection() -> RefinedLinearFECollection"}, - { "RefinedLinearFECollection_FiniteElementForGeometry", _wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS, "RefinedLinearFECollection_FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RefinedLinearFECollection_DofForGeometry", _wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS, "RefinedLinearFECollection_DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RefinedLinearFECollection_DofOrderForOrientation", _wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS, "RefinedLinearFECollection_DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RefinedLinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RefinedLinearFECollection_FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RefinedLinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RefinedLinearFECollection_DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RefinedLinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RefinedLinearFECollection_DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RefinedLinearFECollection_Name", _wrap_RefinedLinearFECollection_Name, METH_O, "RefinedLinearFECollection_Name(RefinedLinearFECollection self) -> char const *"}, { "delete_RefinedLinearFECollection", _wrap_delete_RefinedLinearFECollection, METH_O, "delete_RefinedLinearFECollection(RefinedLinearFECollection self)"}, { "RefinedLinearFECollection_swigregister", RefinedLinearFECollection_swigregister, METH_O, NULL}, { "RefinedLinearFECollection_swiginit", RefinedLinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_ND1_3DFECollection", _wrap_new_ND1_3DFECollection, METH_NOARGS, "new_ND1_3DFECollection() -> ND1_3DFECollection"}, - { "ND1_3DFECollection_FiniteElementForGeometry", _wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "ND1_3DFECollection_FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND1_3DFECollection_DofForGeometry", _wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS, "ND1_3DFECollection_DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND1_3DFECollection_DofOrderForOrientation", _wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "ND1_3DFECollection_DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "ND1_3DFECollection_FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "ND1_3DFECollection_DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "ND1_3DFECollection_DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND1_3DFECollection_Name", _wrap_ND1_3DFECollection_Name, METH_O, "ND1_3DFECollection_Name(ND1_3DFECollection self) -> char const *"}, { "delete_ND1_3DFECollection", _wrap_delete_ND1_3DFECollection, METH_O, "delete_ND1_3DFECollection(ND1_3DFECollection self)"}, { "ND1_3DFECollection_swigregister", ND1_3DFECollection_swigregister, METH_O, NULL}, { "ND1_3DFECollection_swiginit", ND1_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_3DFECollection", _wrap_new_RT0_3DFECollection, METH_NOARGS, "new_RT0_3DFECollection() -> RT0_3DFECollection"}, - { "RT0_3DFECollection_FiniteElementForGeometry", _wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT0_3DFECollection_FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_3DFECollection_DofForGeometry", _wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS, "RT0_3DFECollection_DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_3DFECollection_DofOrderForOrientation", _wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS, "RT0_3DFECollection_DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_3DFECollection_FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT0_3DFECollection_DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT0_3DFECollection_DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_3DFECollection_Name", _wrap_RT0_3DFECollection_Name, METH_O, "RT0_3DFECollection_Name(RT0_3DFECollection self) -> char const *"}, { "delete_RT0_3DFECollection", _wrap_delete_RT0_3DFECollection, METH_O, "delete_RT0_3DFECollection(RT0_3DFECollection self)"}, { "RT0_3DFECollection_swigregister", RT0_3DFECollection_swigregister, METH_O, NULL}, { "RT0_3DFECollection_swiginit", RT0_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_3DFECollection", _wrap_new_RT1_3DFECollection, METH_NOARGS, "new_RT1_3DFECollection() -> RT1_3DFECollection"}, - { "RT1_3DFECollection_FiniteElementForGeometry", _wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "RT1_3DFECollection_FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_3DFECollection_DofForGeometry", _wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS, "RT1_3DFECollection_DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_3DFECollection_DofOrderForOrientation", _wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "RT1_3DFECollection_DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_3DFECollection_FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "RT1_3DFECollection_DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "RT1_3DFECollection_DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_3DFECollection_Name", _wrap_RT1_3DFECollection_Name, METH_O, "RT1_3DFECollection_Name(RT1_3DFECollection self) -> char const *"}, { "delete_RT1_3DFECollection", _wrap_delete_RT1_3DFECollection, METH_O, "delete_RT1_3DFECollection(RT1_3DFECollection self)"}, { "RT1_3DFECollection_swigregister", RT1_3DFECollection_swigregister, METH_O, NULL}, { "RT1_3DFECollection_swiginit", RT1_3DFECollection_swiginit, METH_VARARGS, NULL}, - { "new_Local_FECollection", _wrap_new_Local_FECollection, METH_O, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, - { "Local_FECollection_FiniteElementForGeometry", _wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS, "Local_FECollection_FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, - { "Local_FECollection_DofForGeometry", _wrap_Local_FECollection_DofForGeometry, METH_VARARGS, "Local_FECollection_DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, - { "Local_FECollection_DofOrderForOrientation", _wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS, "Local_FECollection_DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_Local_FECollection", (PyCFunction)(void(*)(void))_wrap_new_Local_FECollection, METH_VARARGS|METH_KEYWORDS, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, + { "Local_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "Local_FECollection_FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, + { "Local_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "Local_FECollection_DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, + { "Local_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "Local_FECollection_DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Local_FECollection_Name", _wrap_Local_FECollection_Name, METH_O, "Local_FECollection_Name(Local_FECollection self) -> char const *"}, { "delete_Local_FECollection", _wrap_delete_Local_FECollection, METH_O, "delete_Local_FECollection(Local_FECollection self)"}, { "Local_FECollection_swigregister", Local_FECollection_swigregister, METH_O, NULL}, @@ -16097,302 +14850,302 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, - { "FiniteElementCollection_FiniteElementForGeometry", _wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "FiniteElementCollection_DofForGeometry", _wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS, "DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_DofOrderForOrientation", _wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "FiniteElementCollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(FiniteElementCollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "FiniteElementCollection_Name", _wrap_FiniteElementCollection_Name, METH_O, "Name(FiniteElementCollection self) -> char const *"}, - { "FiniteElementCollection_HasFaceDofs", _wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS, "HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, - { "FiniteElementCollection_TraceFiniteElementForGeometry", _wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "FiniteElementCollection_HasFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_HasFaceDofs, METH_VARARGS|METH_KEYWORDS, "HasFaceDofs(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> int"}, + { "FiniteElementCollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "TraceFiniteElementForGeometry(FiniteElementCollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "FiniteElementCollection_GetTraceCollection", _wrap_FiniteElementCollection_GetTraceCollection, METH_O, "GetTraceCollection(FiniteElementCollection self) -> FiniteElementCollection"}, { "delete_FiniteElementCollection", _wrap_delete_FiniteElementCollection, METH_O, "delete_FiniteElementCollection(FiniteElementCollection self)"}, - { "FiniteElementCollection_New", _wrap_FiniteElementCollection_New, METH_O, "New(char const * name) -> FiniteElementCollection"}, - { "FiniteElementCollection_SubDofOrder", _wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS, "SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, + { "FiniteElementCollection_New", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_New, METH_VARARGS|METH_KEYWORDS, "New(char const * name) -> FiniteElementCollection"}, + { "FiniteElementCollection_SubDofOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementCollection_SubDofOrder, METH_VARARGS|METH_KEYWORDS, "SubDofOrder(FiniteElementCollection self, mfem::Geometry::Type Geom, int SDim, int Info, intArray dofs)"}, { "FiniteElementCollection_swigregister", FiniteElementCollection_swigregister, METH_O, NULL}, - { "new_H1_FECollection", _wrap_new_H1_FECollection, METH_VARARGS, "H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto)"}, - { "H1_FECollection_FiniteElementForGeometry", _wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "H1_FECollection_DofForGeometry", _wrap_H1_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "H1_FECollection_DofOrderForOrientation", _wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_H1_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_FECollection(int const p, int const dim=3, int const btype=GaussLobatto) -> H1_FECollection"}, + { "H1_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "H1_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(H1_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "H1_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(H1_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "H1_FECollection_Name", _wrap_H1_FECollection_Name, METH_O, "Name(H1_FECollection self) -> char const *"}, { "H1_FECollection_GetTraceCollection", _wrap_H1_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(H1_FECollection self) -> FiniteElementCollection"}, { "H1_FECollection_GetBasisType", _wrap_H1_FECollection_GetBasisType, METH_O, "GetBasisType(H1_FECollection self) -> int"}, - { "H1_FECollection_GetDofMap", _wrap_H1_FECollection_GetDofMap, METH_VARARGS, "GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, + { "H1_FECollection_GetDofMap", (PyCFunction)(void(*)(void))_wrap_H1_FECollection_GetDofMap, METH_VARARGS|METH_KEYWORDS, "GetDofMap(H1_FECollection self, mfem::Geometry::Type GeomType) -> int const *"}, { "delete_H1_FECollection", _wrap_delete_H1_FECollection, METH_O, "delete_H1_FECollection(H1_FECollection self)"}, { "H1_FECollection_swigregister", H1_FECollection_swigregister, METH_O, NULL}, { "H1_FECollection_swiginit", H1_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_FECollection", _wrap_new_H1Pos_FECollection, METH_VARARGS, "H1Pos_FECollection(int const p, int const dim=3)"}, + { "new_H1Pos_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_FECollection(int const p, int const dim=3) -> H1Pos_FECollection"}, { "delete_H1Pos_FECollection", _wrap_delete_H1Pos_FECollection, METH_O, "delete_H1Pos_FECollection(H1Pos_FECollection self)"}, { "H1Pos_FECollection_swigregister", H1Pos_FECollection_swigregister, METH_O, NULL}, { "H1Pos_FECollection_swiginit", H1Pos_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_FECollection", _wrap_new_H1Ser_FECollection, METH_VARARGS, "H1Ser_FECollection(int const p, int const dim=2)"}, + { "new_H1Ser_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_FECollection(int const p, int const dim=2) -> H1Ser_FECollection"}, { "delete_H1Ser_FECollection", _wrap_delete_H1Ser_FECollection, METH_O, "delete_H1Ser_FECollection(H1Ser_FECollection self)"}, { "H1Ser_FECollection_swigregister", H1Ser_FECollection_swigregister, METH_O, NULL}, { "H1Ser_FECollection_swiginit", H1Ser_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_H1_Trace_FECollection", _wrap_new_H1_Trace_FECollection, METH_VARARGS, "H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto)"}, + { "new_H1_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_H1_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_H1_Trace_FECollection(int const p, int const dim, int const btype=GaussLobatto) -> H1_Trace_FECollection"}, { "delete_H1_Trace_FECollection", _wrap_delete_H1_Trace_FECollection, METH_O, "delete_H1_Trace_FECollection(H1_Trace_FECollection self)"}, { "H1_Trace_FECollection_swigregister", H1_Trace_FECollection_swigregister, METH_O, NULL}, { "H1_Trace_FECollection_swiginit", H1_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_L2_FECollection", _wrap_new_L2_FECollection, METH_VARARGS, "L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE)"}, - { "L2_FECollection_FiniteElementForGeometry", _wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "L2_FECollection_DofForGeometry", _wrap_L2_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "L2_FECollection_DofOrderForOrientation", _wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_L2_FECollection", (PyCFunction)(void(*)(void))_wrap_new_L2_FECollection, METH_VARARGS|METH_KEYWORDS, "new_L2_FECollection(int const p, int const dim, int const btype=GaussLegendre, int const map_type=VALUE) -> L2_FECollection"}, + { "L2_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "L2_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(L2_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "L2_FECollection_Name", _wrap_L2_FECollection_Name, METH_O, "Name(L2_FECollection self) -> char const *"}, - { "L2_FECollection_TraceFiniteElementForGeometry", _wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS, "TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "L2_FECollection_TraceFiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_L2_FECollection_TraceFiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "TraceFiniteElementForGeometry(L2_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, { "L2_FECollection_GetBasisType", _wrap_L2_FECollection_GetBasisType, METH_O, "GetBasisType(L2_FECollection self) -> int"}, { "delete_L2_FECollection", _wrap_delete_L2_FECollection, METH_O, "delete_L2_FECollection(L2_FECollection self)"}, { "L2_FECollection_swigregister", L2_FECollection_swigregister, METH_O, NULL}, { "L2_FECollection_swiginit", L2_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, "RT_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "RT_FECollection_FiniteElementForGeometry", _wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT_FECollection_DofForGeometry", _wrap_RT_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT_FECollection_DofOrderForOrientation", _wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_RT_FECollection", _wrap_new_RT_FECollection, METH_VARARGS, NULL}, + { "RT_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT_FECollection_Name", _wrap_RT_FECollection_Name, METH_O, "Name(RT_FECollection self) -> char const *"}, { "RT_FECollection_GetTraceCollection", _wrap_RT_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(RT_FECollection self) -> FiniteElementCollection"}, { "delete_RT_FECollection", _wrap_delete_RT_FECollection, METH_O, "delete_RT_FECollection(RT_FECollection self)"}, { "RT_FECollection_swigregister", RT_FECollection_swigregister, METH_O, NULL}, { "RT_FECollection_swiginit", RT_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_RT_Trace_FECollection", _wrap_new_RT_Trace_FECollection, METH_VARARGS, "RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre)"}, + { "new_RT_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_RT_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_RT_Trace_FECollection(int const p, int const dim, int const map_type=INTEGRAL, int const ob_type=GaussLegendre) -> RT_Trace_FECollection"}, { "delete_RT_Trace_FECollection", _wrap_delete_RT_Trace_FECollection, METH_O, "delete_RT_Trace_FECollection(RT_Trace_FECollection self)"}, { "RT_Trace_FECollection_swigregister", RT_Trace_FECollection_swigregister, METH_O, NULL}, { "RT_Trace_FECollection_swiginit", RT_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_DG_Interface_FECollection", _wrap_new_DG_Interface_FECollection, METH_VARARGS, "DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre)"}, + { "new_DG_Interface_FECollection", (PyCFunction)(void(*)(void))_wrap_new_DG_Interface_FECollection, METH_VARARGS|METH_KEYWORDS, "new_DG_Interface_FECollection(int const p, int const dim, int const map_type=VALUE, int const ob_type=GaussLegendre) -> DG_Interface_FECollection"}, { "delete_DG_Interface_FECollection", _wrap_delete_DG_Interface_FECollection, METH_O, "delete_DG_Interface_FECollection(DG_Interface_FECollection self)"}, { "DG_Interface_FECollection_swigregister", DG_Interface_FECollection_swigregister, METH_O, NULL}, { "DG_Interface_FECollection_swiginit", DG_Interface_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_FECollection", _wrap_new_ND_FECollection, METH_VARARGS, "ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, - { "ND_FECollection_FiniteElementForGeometry", _wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND_FECollection_DofForGeometry", _wrap_ND_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND_FECollection_DofOrderForOrientation", _wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_ND_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_FECollection"}, + { "ND_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(ND_FECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(ND_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND_FECollection_Name", _wrap_ND_FECollection_Name, METH_O, "Name(ND_FECollection self) -> char const *"}, { "ND_FECollection_GetTraceCollection", _wrap_ND_FECollection_GetTraceCollection, METH_O, "GetTraceCollection(ND_FECollection self) -> FiniteElementCollection"}, { "delete_ND_FECollection", _wrap_delete_ND_FECollection, METH_O, "delete_ND_FECollection(ND_FECollection self)"}, { "ND_FECollection_swigregister", ND_FECollection_swigregister, METH_O, NULL}, { "ND_FECollection_swiginit", ND_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_ND_Trace_FECollection", _wrap_new_ND_Trace_FECollection, METH_VARARGS, "ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_Trace_FECollection", (PyCFunction)(void(*)(void))_wrap_new_ND_Trace_FECollection, METH_VARARGS|METH_KEYWORDS, "new_ND_Trace_FECollection(int const p, int const dim, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_Trace_FECollection"}, { "delete_ND_Trace_FECollection", _wrap_delete_ND_Trace_FECollection, METH_O, "delete_ND_Trace_FECollection(ND_Trace_FECollection self)"}, { "ND_Trace_FECollection_swigregister", ND_Trace_FECollection_swigregister, METH_O, NULL}, { "ND_Trace_FECollection_swiginit", ND_Trace_FECollection_swiginit, METH_VARARGS, NULL}, - { "new_NURBSFECollection", _wrap_new_NURBSFECollection, METH_VARARGS, "NURBSFECollection(int Order=VariableOrder)"}, + { "new_NURBSFECollection", (PyCFunction)(void(*)(void))_wrap_new_NURBSFECollection, METH_VARARGS|METH_KEYWORDS, "new_NURBSFECollection(int Order=VariableOrder) -> NURBSFECollection"}, { "NURBSFECollection_Reset", _wrap_NURBSFECollection_Reset, METH_O, "Reset(NURBSFECollection self)"}, { "NURBSFECollection_GetOrder", _wrap_NURBSFECollection_GetOrder, METH_O, "GetOrder(NURBSFECollection self) -> int"}, - { "NURBSFECollection_SetOrder", _wrap_NURBSFECollection_SetOrder, METH_VARARGS, "SetOrder(NURBSFECollection self, int Order)"}, - { "NURBSFECollection_FiniteElementForGeometry", _wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "NURBSFECollection_DofForGeometry", _wrap_NURBSFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "NURBSFECollection_DofOrderForOrientation", _wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "NURBSFECollection_SetOrder", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_SetOrder, METH_VARARGS|METH_KEYWORDS, "SetOrder(NURBSFECollection self, int Order)"}, + { "NURBSFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "NURBSFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(NURBSFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "NURBSFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_NURBSFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(NURBSFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "NURBSFECollection_Name", _wrap_NURBSFECollection_Name, METH_O, "Name(NURBSFECollection self) -> char const *"}, { "NURBSFECollection_GetTraceCollection", _wrap_NURBSFECollection_GetTraceCollection, METH_O, "GetTraceCollection(NURBSFECollection self) -> FiniteElementCollection"}, { "delete_NURBSFECollection", _wrap_delete_NURBSFECollection, METH_O, "delete_NURBSFECollection(NURBSFECollection self)"}, { "NURBSFECollection_swigregister", NURBSFECollection_swigregister, METH_O, NULL}, { "NURBSFECollection_swiginit", NURBSFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearFECollection", _wrap_new_LinearFECollection, METH_NOARGS, "new_LinearFECollection() -> LinearFECollection"}, - { "LinearFECollection_FiniteElementForGeometry", _wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearFECollection_DofForGeometry", _wrap_LinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearFECollection_DofOrderForOrientation", _wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearFECollection_Name", _wrap_LinearFECollection_Name, METH_O, "Name(LinearFECollection self) -> char const *"}, { "delete_LinearFECollection", _wrap_delete_LinearFECollection, METH_O, "delete_LinearFECollection(LinearFECollection self)"}, { "LinearFECollection_swigregister", LinearFECollection_swigregister, METH_O, NULL}, { "LinearFECollection_swiginit", LinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticFECollection", _wrap_new_QuadraticFECollection, METH_NOARGS, "new_QuadraticFECollection() -> QuadraticFECollection"}, - { "QuadraticFECollection_FiniteElementForGeometry", _wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticFECollection_DofForGeometry", _wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticFECollection_DofOrderForOrientation", _wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticFECollection_Name", _wrap_QuadraticFECollection_Name, METH_O, "Name(QuadraticFECollection self) -> char const *"}, { "delete_QuadraticFECollection", _wrap_delete_QuadraticFECollection, METH_O, "delete_QuadraticFECollection(QuadraticFECollection self)"}, { "QuadraticFECollection_swigregister", QuadraticFECollection_swigregister, METH_O, NULL}, { "QuadraticFECollection_swiginit", QuadraticFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosFECollection", _wrap_new_QuadraticPosFECollection, METH_NOARGS, "new_QuadraticPosFECollection() -> QuadraticPosFECollection"}, - { "QuadraticPosFECollection_FiniteElementForGeometry", _wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosFECollection_DofForGeometry", _wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosFECollection_DofOrderForOrientation", _wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticPosFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticPosFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosFECollection_Name", _wrap_QuadraticPosFECollection_Name, METH_O, "Name(QuadraticPosFECollection self) -> char const *"}, { "delete_QuadraticPosFECollection", _wrap_delete_QuadraticPosFECollection, METH_O, "delete_QuadraticPosFECollection(QuadraticPosFECollection self)"}, { "QuadraticPosFECollection_swigregister", QuadraticPosFECollection_swigregister, METH_O, NULL}, { "QuadraticPosFECollection_swiginit", QuadraticPosFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicFECollection", _wrap_new_CubicFECollection, METH_NOARGS, "new_CubicFECollection() -> CubicFECollection"}, - { "CubicFECollection_FiniteElementForGeometry", _wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicFECollection_DofForGeometry", _wrap_CubicFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicFECollection_DofOrderForOrientation", _wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(CubicFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(CubicFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicFECollection_Name", _wrap_CubicFECollection_Name, METH_O, "Name(CubicFECollection self) -> char const *"}, { "delete_CubicFECollection", _wrap_delete_CubicFECollection, METH_O, "delete_CubicFECollection(CubicFECollection self)"}, { "CubicFECollection_swigregister", CubicFECollection_swigregister, METH_O, NULL}, { "CubicFECollection_swiginit", CubicFECollection_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFECollection", _wrap_new_CrouzeixRaviartFECollection, METH_NOARGS, "new_CrouzeixRaviartFECollection() -> CrouzeixRaviartFECollection"}, - { "CrouzeixRaviartFECollection_FiniteElementForGeometry", _wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CrouzeixRaviartFECollection_DofForGeometry", _wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CrouzeixRaviartFECollection_DofOrderForOrientation", _wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CrouzeixRaviartFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CrouzeixRaviartFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CrouzeixRaviartFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(CrouzeixRaviartFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CrouzeixRaviartFECollection_Name", _wrap_CrouzeixRaviartFECollection_Name, METH_O, "Name(CrouzeixRaviartFECollection self) -> char const *"}, { "delete_CrouzeixRaviartFECollection", _wrap_delete_CrouzeixRaviartFECollection, METH_O, "delete_CrouzeixRaviartFECollection(CrouzeixRaviartFECollection self)"}, { "CrouzeixRaviartFECollection_swigregister", CrouzeixRaviartFECollection_swigregister, METH_O, NULL}, { "CrouzeixRaviartFECollection_swiginit", CrouzeixRaviartFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearNonConf3DFECollection", _wrap_new_LinearNonConf3DFECollection, METH_NOARGS, "new_LinearNonConf3DFECollection() -> LinearNonConf3DFECollection"}, - { "LinearNonConf3DFECollection_FiniteElementForGeometry", _wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearNonConf3DFECollection_DofForGeometry", _wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearNonConf3DFECollection_DofOrderForOrientation", _wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearNonConf3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearNonConf3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearNonConf3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearNonConf3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearNonConf3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearNonConf3DFECollection_Name", _wrap_LinearNonConf3DFECollection_Name, METH_O, "Name(LinearNonConf3DFECollection self) -> char const *"}, { "delete_LinearNonConf3DFECollection", _wrap_delete_LinearNonConf3DFECollection, METH_O, "delete_LinearNonConf3DFECollection(LinearNonConf3DFECollection self)"}, { "LinearNonConf3DFECollection_swigregister", LinearNonConf3DFECollection_swigregister, METH_O, NULL}, { "LinearNonConf3DFECollection_swiginit", LinearNonConf3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_2DFECollection", _wrap_new_RT0_2DFECollection, METH_NOARGS, "new_RT0_2DFECollection() -> RT0_2DFECollection"}, - { "RT0_2DFECollection_FiniteElementForGeometry", _wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_2DFECollection_DofForGeometry", _wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_2DFECollection_DofOrderForOrientation", _wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT0_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT0_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_2DFECollection_Name", _wrap_RT0_2DFECollection_Name, METH_O, "Name(RT0_2DFECollection self) -> char const *"}, { "delete_RT0_2DFECollection", _wrap_delete_RT0_2DFECollection, METH_O, "delete_RT0_2DFECollection(RT0_2DFECollection self)"}, { "RT0_2DFECollection_swigregister", RT0_2DFECollection_swigregister, METH_O, NULL}, { "RT0_2DFECollection_swiginit", RT0_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_2DFECollection", _wrap_new_RT1_2DFECollection, METH_NOARGS, "new_RT1_2DFECollection() -> RT1_2DFECollection"}, - { "RT1_2DFECollection_FiniteElementForGeometry", _wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_2DFECollection_DofForGeometry", _wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_2DFECollection_DofOrderForOrientation", _wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT1_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT1_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_2DFECollection_Name", _wrap_RT1_2DFECollection_Name, METH_O, "Name(RT1_2DFECollection self) -> char const *"}, { "delete_RT1_2DFECollection", _wrap_delete_RT1_2DFECollection, METH_O, "delete_RT1_2DFECollection(RT1_2DFECollection self)"}, { "RT1_2DFECollection_swigregister", RT1_2DFECollection_swigregister, METH_O, NULL}, { "RT1_2DFECollection_swiginit", RT1_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT2_2DFECollection", _wrap_new_RT2_2DFECollection, METH_NOARGS, "new_RT2_2DFECollection() -> RT2_2DFECollection"}, - { "RT2_2DFECollection_FiniteElementForGeometry", _wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT2_2DFECollection_DofForGeometry", _wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT2_2DFECollection_DofOrderForOrientation", _wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT2_2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT2_2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT2_2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT2_2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT2_2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT2_2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT2_2DFECollection_Name", _wrap_RT2_2DFECollection_Name, METH_O, "Name(RT2_2DFECollection self) -> char const *"}, { "delete_RT2_2DFECollection", _wrap_delete_RT2_2DFECollection, METH_O, "delete_RT2_2DFECollection(RT2_2DFECollection self)"}, { "RT2_2DFECollection_swigregister", RT2_2DFECollection_swigregister, METH_O, NULL}, { "RT2_2DFECollection_swiginit", RT2_2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const2DFECollection", _wrap_new_Const2DFECollection, METH_NOARGS, "new_Const2DFECollection() -> Const2DFECollection"}, - { "Const2DFECollection_FiniteElementForGeometry", _wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const2DFECollection_DofForGeometry", _wrap_Const2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const2DFECollection_DofOrderForOrientation", _wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(Const2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(Const2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const2DFECollection_Name", _wrap_Const2DFECollection_Name, METH_O, "Name(Const2DFECollection self) -> char const *"}, { "delete_Const2DFECollection", _wrap_delete_Const2DFECollection, METH_O, "delete_Const2DFECollection(Const2DFECollection self)"}, { "Const2DFECollection_swigregister", Const2DFECollection_swigregister, METH_O, NULL}, { "Const2DFECollection_swiginit", Const2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont2DFECollection", _wrap_new_LinearDiscont2DFECollection, METH_NOARGS, "new_LinearDiscont2DFECollection() -> LinearDiscont2DFECollection"}, - { "LinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont2DFECollection_DofForGeometry", _wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont2DFECollection_DofOrderForOrientation", _wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont2DFECollection_Name", _wrap_LinearDiscont2DFECollection_Name, METH_O, "Name(LinearDiscont2DFECollection self) -> char const *"}, { "delete_LinearDiscont2DFECollection", _wrap_delete_LinearDiscont2DFECollection, METH_O, "delete_LinearDiscont2DFECollection(LinearDiscont2DFECollection self)"}, { "LinearDiscont2DFECollection_swigregister", LinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont2DFECollection_swiginit", LinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussLinearDiscont2DFECollection", _wrap_new_GaussLinearDiscont2DFECollection, METH_NOARGS, "new_GaussLinearDiscont2DFECollection() -> GaussLinearDiscont2DFECollection"}, - { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussLinearDiscont2DFECollection_DofForGeometry", _wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussLinearDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussLinearDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussLinearDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussLinearDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(GaussLinearDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussLinearDiscont2DFECollection_Name", _wrap_GaussLinearDiscont2DFECollection_Name, METH_O, "Name(GaussLinearDiscont2DFECollection self) -> char const *"}, { "delete_GaussLinearDiscont2DFECollection", _wrap_delete_GaussLinearDiscont2DFECollection, METH_O, "delete_GaussLinearDiscont2DFECollection(GaussLinearDiscont2DFECollection self)"}, { "GaussLinearDiscont2DFECollection_swigregister", GaussLinearDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussLinearDiscont2DFECollection_swiginit", GaussLinearDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFECollection", _wrap_new_P1OnQuadFECollection, METH_NOARGS, "new_P1OnQuadFECollection() -> P1OnQuadFECollection"}, - { "P1OnQuadFECollection_FiniteElementForGeometry", _wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "P1OnQuadFECollection_DofForGeometry", _wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "P1OnQuadFECollection_DofOrderForOrientation", _wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "P1OnQuadFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "P1OnQuadFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(P1OnQuadFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "P1OnQuadFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(P1OnQuadFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "P1OnQuadFECollection_Name", _wrap_P1OnQuadFECollection_Name, METH_O, "Name(P1OnQuadFECollection self) -> char const *"}, { "delete_P1OnQuadFECollection", _wrap_delete_P1OnQuadFECollection, METH_O, "delete_P1OnQuadFECollection(P1OnQuadFECollection self)"}, { "P1OnQuadFECollection_swigregister", P1OnQuadFECollection_swigregister, METH_O, NULL}, { "P1OnQuadFECollection_swiginit", P1OnQuadFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont2DFECollection", _wrap_new_QuadraticDiscont2DFECollection, METH_NOARGS, "new_QuadraticDiscont2DFECollection() -> QuadraticDiscont2DFECollection"}, - { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont2DFECollection_DofForGeometry", _wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont2DFECollection_Name", _wrap_QuadraticDiscont2DFECollection_Name, METH_O, "Name(QuadraticDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticDiscont2DFECollection", _wrap_delete_QuadraticDiscont2DFECollection, METH_O, "delete_QuadraticDiscont2DFECollection(QuadraticDiscont2DFECollection self)"}, { "QuadraticDiscont2DFECollection_swigregister", QuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont2DFECollection_swiginit", QuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticPosDiscont2DFECollection", _wrap_new_QuadraticPosDiscont2DFECollection, METH_NOARGS, "new_QuadraticPosDiscont2DFECollection() -> QuadraticPosDiscont2DFECollection"}, - { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", _wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticPosDiscont2DFECollection_DofForGeometry", _wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", _wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticPosDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticPosDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticPosDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticPosDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticPosDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticPosDiscont2DFECollection_Name", _wrap_QuadraticPosDiscont2DFECollection_Name, METH_O, "Name(QuadraticPosDiscont2DFECollection self) -> char const *"}, { "delete_QuadraticPosDiscont2DFECollection", _wrap_delete_QuadraticPosDiscont2DFECollection, METH_O, "delete_QuadraticPosDiscont2DFECollection(QuadraticPosDiscont2DFECollection self)"}, { "QuadraticPosDiscont2DFECollection_swigregister", QuadraticPosDiscont2DFECollection_swigregister, METH_O, NULL}, { "QuadraticPosDiscont2DFECollection_swiginit", QuadraticPosDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_GaussQuadraticDiscont2DFECollection", _wrap_new_GaussQuadraticDiscont2DFECollection, METH_NOARGS, "new_GaussQuadraticDiscont2DFECollection() -> GaussQuadraticDiscont2DFECollection"}, - { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "GaussQuadraticDiscont2DFECollection_DofForGeometry", _wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", _wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "GaussQuadraticDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "GaussQuadraticDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_GaussQuadraticDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(GaussQuadraticDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "GaussQuadraticDiscont2DFECollection_Name", _wrap_GaussQuadraticDiscont2DFECollection_Name, METH_O, "Name(GaussQuadraticDiscont2DFECollection self) -> char const *"}, { "delete_GaussQuadraticDiscont2DFECollection", _wrap_delete_GaussQuadraticDiscont2DFECollection, METH_O, "delete_GaussQuadraticDiscont2DFECollection(GaussQuadraticDiscont2DFECollection self)"}, { "GaussQuadraticDiscont2DFECollection_swigregister", GaussQuadraticDiscont2DFECollection_swigregister, METH_O, NULL}, { "GaussQuadraticDiscont2DFECollection_swiginit", GaussQuadraticDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_CubicDiscont2DFECollection", _wrap_new_CubicDiscont2DFECollection, METH_NOARGS, "new_CubicDiscont2DFECollection() -> CubicDiscont2DFECollection"}, - { "CubicDiscont2DFECollection_FiniteElementForGeometry", _wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "CubicDiscont2DFECollection_DofForGeometry", _wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "CubicDiscont2DFECollection_DofOrderForOrientation", _wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "CubicDiscont2DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "CubicDiscont2DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "CubicDiscont2DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_CubicDiscont2DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(CubicDiscont2DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "CubicDiscont2DFECollection_Name", _wrap_CubicDiscont2DFECollection_Name, METH_O, "Name(CubicDiscont2DFECollection self) -> char const *"}, { "delete_CubicDiscont2DFECollection", _wrap_delete_CubicDiscont2DFECollection, METH_O, "delete_CubicDiscont2DFECollection(CubicDiscont2DFECollection self)"}, { "CubicDiscont2DFECollection_swigregister", CubicDiscont2DFECollection_swigregister, METH_O, NULL}, { "CubicDiscont2DFECollection_swiginit", CubicDiscont2DFECollection_swiginit, METH_VARARGS, NULL}, { "new_Const3DFECollection", _wrap_new_Const3DFECollection, METH_NOARGS, "new_Const3DFECollection() -> Const3DFECollection"}, - { "Const3DFECollection_FiniteElementForGeometry", _wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "Const3DFECollection_DofForGeometry", _wrap_Const3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "Const3DFECollection_DofOrderForOrientation", _wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "Const3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "Const3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(Const3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "Const3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Const3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(Const3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Const3DFECollection_Name", _wrap_Const3DFECollection_Name, METH_O, "Name(Const3DFECollection self) -> char const *"}, { "delete_Const3DFECollection", _wrap_delete_Const3DFECollection, METH_O, "delete_Const3DFECollection(Const3DFECollection self)"}, { "Const3DFECollection_swigregister", Const3DFECollection_swigregister, METH_O, NULL}, { "Const3DFECollection_swiginit", Const3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_LinearDiscont3DFECollection", _wrap_new_LinearDiscont3DFECollection, METH_NOARGS, "new_LinearDiscont3DFECollection() -> LinearDiscont3DFECollection"}, - { "LinearDiscont3DFECollection_FiniteElementForGeometry", _wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "LinearDiscont3DFECollection_DofForGeometry", _wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "LinearDiscont3DFECollection_DofOrderForOrientation", _wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "LinearDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "LinearDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "LinearDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_LinearDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(LinearDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "LinearDiscont3DFECollection_Name", _wrap_LinearDiscont3DFECollection_Name, METH_O, "Name(LinearDiscont3DFECollection self) -> char const *"}, { "delete_LinearDiscont3DFECollection", _wrap_delete_LinearDiscont3DFECollection, METH_O, "delete_LinearDiscont3DFECollection(LinearDiscont3DFECollection self)"}, { "LinearDiscont3DFECollection_swigregister", LinearDiscont3DFECollection_swigregister, METH_O, NULL}, { "LinearDiscont3DFECollection_swiginit", LinearDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_QuadraticDiscont3DFECollection", _wrap_new_QuadraticDiscont3DFECollection, METH_NOARGS, "new_QuadraticDiscont3DFECollection() -> QuadraticDiscont3DFECollection"}, - { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", _wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "QuadraticDiscont3DFECollection_DofForGeometry", _wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "QuadraticDiscont3DFECollection_DofOrderForOrientation", _wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "QuadraticDiscont3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "QuadraticDiscont3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "QuadraticDiscont3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_QuadraticDiscont3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(QuadraticDiscont3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "QuadraticDiscont3DFECollection_Name", _wrap_QuadraticDiscont3DFECollection_Name, METH_O, "Name(QuadraticDiscont3DFECollection self) -> char const *"}, { "delete_QuadraticDiscont3DFECollection", _wrap_delete_QuadraticDiscont3DFECollection, METH_O, "delete_QuadraticDiscont3DFECollection(QuadraticDiscont3DFECollection self)"}, { "QuadraticDiscont3DFECollection_swigregister", QuadraticDiscont3DFECollection_swigregister, METH_O, NULL}, { "QuadraticDiscont3DFECollection_swiginit", QuadraticDiscont3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinearFECollection", _wrap_new_RefinedLinearFECollection, METH_NOARGS, "new_RefinedLinearFECollection() -> RefinedLinearFECollection"}, - { "RefinedLinearFECollection_FiniteElementForGeometry", _wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RefinedLinearFECollection_DofForGeometry", _wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RefinedLinearFECollection_DofOrderForOrientation", _wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RefinedLinearFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RefinedLinearFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RefinedLinearFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RefinedLinearFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RefinedLinearFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RefinedLinearFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RefinedLinearFECollection_Name", _wrap_RefinedLinearFECollection_Name, METH_O, "Name(RefinedLinearFECollection self) -> char const *"}, { "delete_RefinedLinearFECollection", _wrap_delete_RefinedLinearFECollection, METH_O, "delete_RefinedLinearFECollection(RefinedLinearFECollection self)"}, { "RefinedLinearFECollection_swigregister", RefinedLinearFECollection_swigregister, METH_O, NULL}, { "RefinedLinearFECollection_swiginit", RefinedLinearFECollection_swiginit, METH_VARARGS, NULL}, { "new_ND1_3DFECollection", _wrap_new_ND1_3DFECollection, METH_NOARGS, "new_ND1_3DFECollection() -> ND1_3DFECollection"}, - { "ND1_3DFECollection_FiniteElementForGeometry", _wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "ND1_3DFECollection_DofForGeometry", _wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "ND1_3DFECollection_DofOrderForOrientation", _wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "ND1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "ND1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(ND1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "ND1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_ND1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(ND1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "ND1_3DFECollection_Name", _wrap_ND1_3DFECollection_Name, METH_O, "Name(ND1_3DFECollection self) -> char const *"}, { "delete_ND1_3DFECollection", _wrap_delete_ND1_3DFECollection, METH_O, "delete_ND1_3DFECollection(ND1_3DFECollection self)"}, { "ND1_3DFECollection_swigregister", ND1_3DFECollection_swigregister, METH_O, NULL}, { "ND1_3DFECollection_swiginit", ND1_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT0_3DFECollection", _wrap_new_RT0_3DFECollection, METH_NOARGS, "new_RT0_3DFECollection() -> RT0_3DFECollection"}, - { "RT0_3DFECollection_FiniteElementForGeometry", _wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT0_3DFECollection_DofForGeometry", _wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT0_3DFECollection_DofOrderForOrientation", _wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT0_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT0_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT0_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT0_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT0_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT0_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT0_3DFECollection_Name", _wrap_RT0_3DFECollection_Name, METH_O, "Name(RT0_3DFECollection self) -> char const *"}, { "delete_RT0_3DFECollection", _wrap_delete_RT0_3DFECollection, METH_O, "delete_RT0_3DFECollection(RT0_3DFECollection self)"}, { "RT0_3DFECollection_swigregister", RT0_3DFECollection_swigregister, METH_O, NULL}, { "RT0_3DFECollection_swiginit", RT0_3DFECollection_swiginit, METH_VARARGS, NULL}, { "new_RT1_3DFECollection", _wrap_new_RT1_3DFECollection, METH_NOARGS, "new_RT1_3DFECollection() -> RT1_3DFECollection"}, - { "RT1_3DFECollection_FiniteElementForGeometry", _wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, - { "RT1_3DFECollection_DofForGeometry", _wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, - { "RT1_3DFECollection_DofOrderForOrientation", _wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "RT1_3DFECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> FiniteElement"}, + { "RT1_3DFECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(RT1_3DFECollection self, mfem::Geometry::Type GeomType) -> int"}, + { "RT1_3DFECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_RT1_3DFECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(RT1_3DFECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "RT1_3DFECollection_Name", _wrap_RT1_3DFECollection_Name, METH_O, "Name(RT1_3DFECollection self) -> char const *"}, { "delete_RT1_3DFECollection", _wrap_delete_RT1_3DFECollection, METH_O, "delete_RT1_3DFECollection(RT1_3DFECollection self)"}, { "RT1_3DFECollection_swigregister", RT1_3DFECollection_swigregister, METH_O, NULL}, { "RT1_3DFECollection_swiginit", RT1_3DFECollection_swiginit, METH_VARARGS, NULL}, - { "new_Local_FECollection", _wrap_new_Local_FECollection, METH_O, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, - { "Local_FECollection_FiniteElementForGeometry", _wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS, "FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, - { "Local_FECollection_DofForGeometry", _wrap_Local_FECollection_DofForGeometry, METH_VARARGS, "DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, - { "Local_FECollection_DofOrderForOrientation", _wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS, "DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, + { "new_Local_FECollection", (PyCFunction)(void(*)(void))_wrap_new_Local_FECollection, METH_VARARGS|METH_KEYWORDS, "new_Local_FECollection(char const * fe_name) -> Local_FECollection"}, + { "Local_FECollection_FiniteElementForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_FiniteElementForGeometry, METH_VARARGS|METH_KEYWORDS, "FiniteElementForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> FiniteElement"}, + { "Local_FECollection_DofForGeometry", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofForGeometry, METH_VARARGS|METH_KEYWORDS, "DofForGeometry(Local_FECollection self, mfem::Geometry::Type _GeomType) -> int"}, + { "Local_FECollection_DofOrderForOrientation", (PyCFunction)(void(*)(void))_wrap_Local_FECollection_DofOrderForOrientation, METH_VARARGS|METH_KEYWORDS, "DofOrderForOrientation(Local_FECollection self, mfem::Geometry::Type GeomType, int Or) -> int const *"}, { "Local_FECollection_Name", _wrap_Local_FECollection_Name, METH_O, "Name(Local_FECollection self) -> char const *"}, { "delete_Local_FECollection", _wrap_delete_Local_FECollection, METH_O, "delete_Local_FECollection(Local_FECollection self)"}, { "Local_FECollection_swigregister", Local_FECollection_swigregister, METH_O, NULL}, diff --git a/mfem/_ser/fe_wrap.cxx b/mfem/_ser/fe_wrap.cxx index 9c97692a..42f6a04b 100644 --- a/mfem/_ser/fe_wrap.cxx +++ b/mfem/_ser/fe_wrap.cxx @@ -3694,19 +3694,21 @@ SWIG_AsVal_bool (PyObject *obj, bool *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_BasisType_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_Check", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3734,19 +3736,21 @@ SWIGINTERN PyObject *_wrap_BasisType_Check(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_BasisType_CheckNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_CheckNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_CheckNodal", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3774,19 +3778,21 @@ SWIGINTERN PyObject *_wrap_BasisType_CheckNodal(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BasisType_GetQuadrature1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetQuadrature1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetQuadrature1D", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3814,19 +3820,21 @@ SWIGINTERN PyObject *_wrap_BasisType_GetQuadrature1D(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BasisType_GetNodalBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetNodalBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"qpt_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetNodalBasis", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3854,19 +3862,21 @@ SWIGINTERN PyObject *_wrap_BasisType_GetNodalBasis(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_BasisType_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_Name(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; char *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_Name", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3894,19 +3904,21 @@ SWIGINTERN PyObject *_wrap_BasisType_Name(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_BasisType_GetChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetChar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; char result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetChar", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3934,17 +3946,19 @@ SWIGINTERN PyObject *_wrap_BasisType_GetChar(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_BasisType_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BasisType_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; char arg1 ; char val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_ident", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_char(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:BasisType_GetType", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_char(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "BasisType_GetType" "', argument " "1"" of type '" "char""'"); } @@ -5127,7 +5141,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetDerivMapType(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5138,15 +5152,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5154,7 +5173,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5188,7 +5207,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5199,15 +5218,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5215,7 +5239,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5249,7 +5273,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5260,15 +5284,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5276,7 +5305,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5310,7 +5339,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5321,15 +5350,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysDShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysDShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5337,7 +5371,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysDShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5587,7 +5621,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcVShape(PyObject *self, PyObject *ar } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5598,15 +5632,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysVShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysVShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysVShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysVShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5614,7 +5653,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysVShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysVShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5648,7 +5687,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysVShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5659,15 +5698,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5675,7 +5719,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5709,7 +5753,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5720,15 +5764,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5736,7 +5785,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5770,7 +5819,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysDivShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5781,15 +5830,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5797,7 +5851,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5831,7 +5885,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5842,15 +5896,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5858,7 +5917,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5892,7 +5951,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysCurlShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; int arg2 ; @@ -5904,26 +5963,32 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face", (char *)"dofs", (char *)"ndofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_GetFaceDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetFaceDofs" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetFaceDofs" "', argument " "3"" of type '" "int **""'"); } arg3 = reinterpret_cast< int ** >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_GetFaceDofs" "', argument " "4"" of type '" "int *""'"); } @@ -5954,7 +6019,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -5965,15 +6030,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"Hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5981,7 +6051,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -6015,7 +6085,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6026,15 +6096,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"Hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6042,7 +6117,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysHessian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -6076,7 +6151,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysHessian(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6087,15 +6162,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"Laplacian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLaplacian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysLaplacian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6103,7 +6183,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6137,7 +6217,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLaplacian(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6148,15 +6228,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"Laplacian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_CalcPhysLinLaplacian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_CalcPhysLinLaplacian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6164,7 +6249,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_CalcPhysLinLaplacian" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6198,7 +6283,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_CalcPhysLinLaplacian(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6209,15 +6294,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6225,7 +6315,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -6259,7 +6349,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalInterpolation(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -6270,15 +6360,20 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -6286,7 +6381,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -6320,7 +6415,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetLocalRestriction(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6334,15 +6429,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDP int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6350,7 +6451,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6358,7 +6459,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6534,7 +6635,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_Project__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -6548,15 +6649,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -6564,7 +6671,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6572,7 +6679,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -6606,7 +6713,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectMatrixCoefficient(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; int arg2 ; @@ -6615,21 +6722,26 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6824,7 +6936,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_Project(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6838,15 +6950,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectGrad" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6854,7 +6972,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6862,7 +6980,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6896,7 +7014,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6910,15 +7028,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectCurl" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6926,7 +7050,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6934,7 +7058,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -6968,7 +7092,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6982,15 +7106,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"div", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_ProjectDiv", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:FiniteElement_ProjectDiv", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_ProjectDiv" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6998,7 +7128,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7006,7 +7136,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "FiniteElement_ProjectDiv" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7040,7 +7170,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = (mfem::FiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -7051,16 +7181,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::FiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -7068,7 +7203,7 @@ SWIGINTERN PyObject *_wrap_FiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -7139,19 +7274,21 @@ SWIGINTERN PyObject *_wrap_delete_FiniteElement(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_FiniteElement_IsClosedType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_IsClosedType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_IsClosedType", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -7179,19 +7316,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_IsClosedType(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElement_IsOpenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_IsOpenType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_IsOpenType", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -7219,19 +7358,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_IsOpenType(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_VerifyClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_VerifyClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_VerifyClosed", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -7259,19 +7400,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_VerifyClosed(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElement_VerifyOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_VerifyOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_VerifyOpen", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -7299,19 +7442,21 @@ SWIGINTERN PyObject *_wrap_FiniteElement_VerifyOpen(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElement_VerifyNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElement_VerifyNodal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"b_type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElement_VerifyNodal", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -7346,25 +7491,29 @@ SWIGINTERN PyObject *FiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(self), return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_SetMapType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_SetMapType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"M", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_SetMapType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ScalarFiniteElement_SetMapType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_SetMapType" "', argument " "1"" of type '" "mfem::ScalarFiniteElement *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7392,7 +7541,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_SetMapType(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7406,15 +7555,21 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", (char *)"fine_fe", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_NodalLocalInterpolation", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ScalarFiniteElement_NodalLocalInterpolation", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "1"" of type '" "mfem::ScalarFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7422,7 +7577,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7430,7 +7585,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarFiniteElement_NodalLocalInterpolation" "', argument " "4"" of type '" "mfem::ScalarFiniteElement const &""'"); } @@ -7464,7 +7619,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_NodalLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7478,15 +7633,21 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", (char *)"fine_fe", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_ScalarLocalInterpolation", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ScalarFiniteElement_ScalarLocalInterpolation", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "1"" of type '" "mfem::ScalarFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7494,7 +7655,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7502,7 +7663,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ScalarFiniteElement_ScalarLocalInterpolation" "', argument " "4"" of type '" "mfem::ScalarFiniteElement const &""'"); } @@ -7536,7 +7697,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_ScalarLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScalarFiniteElement *arg1 = (mfem::ScalarFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -7547,16 +7708,21 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSED int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "ScalarFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ScalarFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScalarFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::ScalarFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::ScalarFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -7564,7 +7730,7 @@ SWIGINTERN PyObject *_wrap_ScalarFiniteElement_GetDofToQuad(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ScalarFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -7642,7 +7808,7 @@ SWIGINTERN PyObject *ScalarFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(s return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7653,15 +7819,20 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NodalFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7669,7 +7840,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7703,7 +7874,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalInterpolation(PyObject *SW } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7714,15 +7885,20 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NodalFiniteElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7730,7 +7906,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -7764,7 +7940,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetLocalRestriction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7778,15 +7954,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7794,7 +7976,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7802,7 +7984,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -7978,7 +8160,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_Project__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -7992,15 +8174,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -8008,7 +8196,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -8016,7 +8204,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -8211,7 +8399,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_Project(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8225,15 +8413,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8241,7 +8435,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -8249,7 +8443,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -8283,7 +8477,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectGrad(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalFiniteElement *arg1 = (mfem::NodalFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8297,15 +8491,21 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"div", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodalFiniteElement_ProjectDiv", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NodalFiniteElement_ProjectDiv", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "1"" of type '" "mfem::NodalFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8313,7 +8513,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -8321,7 +8521,7 @@ SWIGINTERN PyObject *_wrap_NodalFiniteElement_ProjectDiv(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NodalFiniteElement_ProjectDiv" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -8402,7 +8602,7 @@ SWIGINTERN PyObject *NodalFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(se return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PositiveFiniteElement *arg1 = (mfem::PositiveFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -8413,15 +8613,20 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PositiveFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PositiveFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::PositiveFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PositiveFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -8429,7 +8634,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PositiveFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -8463,7 +8668,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PositiveFiniteElement *arg1 = (mfem::PositiveFiniteElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -8477,15 +8682,21 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PositiveFiniteElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:PositiveFiniteElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PositiveFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::PositiveFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PositiveFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -8493,7 +8704,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -8501,7 +8712,7 @@ SWIGINTERN PyObject *_wrap_PositiveFiniteElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PositiveFiniteElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -9172,124 +9383,68 @@ SWIGINTERN PyObject *PositiveFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_VectorFiniteElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; mfem::Geometry::Type arg2 ; int arg3 ; int arg4 ; int arg5 ; - int arg6 ; + int arg6 = (int) mfem::FunctionSpace::Pk ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"D", (char *)"G", (char *)"Do", (char *)"O", (char *)"M", (char *)"F", NULL + }; mfem::VectorFiniteElement *result = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:new_VectorFiniteElement", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorFiniteElement" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg5 = PyArray_PyIntAsInt(obj4); } - { - try { - result = (mfem::VectorFiniteElement *)new mfem::VectorFiniteElement(arg1,arg2,arg3,arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorFiniteElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorFiniteElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Geometry::Type arg2 ; - int arg3 ; - int arg4 ; - int arg5 ; - int val2 ; - int ecode2 = 0 ; - mfem::VectorFiniteElement *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorFiniteElement" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); } { try { - result = (mfem::VectorFiniteElement *)new mfem::VectorFiniteElement(arg1,arg2,arg3,arg4,arg5); + result = (mfem::VectorFiniteElement *)new mfem::VectorFiniteElement(arg1,arg2,arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9313,134 +9468,6 @@ SWIGINTERN PyObject *_wrap_new_VectorFiniteElement__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_VectorFiniteElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorFiniteElement", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorFiniteElement__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_VectorFiniteElement__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorFiniteElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorFiniteElement::VectorFiniteElement(int,mfem::Geometry::Type,int,int,int,int)\n" - " mfem::VectorFiniteElement::VectorFiniteElement(int,mfem::Geometry::Type,int,int,int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_VectorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::VectorFiniteElement *arg1 = (mfem::VectorFiniteElement *) 0 ; @@ -9523,7 +9550,7 @@ SWIGINTERN PyObject *_wrap_new_PointFiniteElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PointFiniteElement *arg1 = (mfem::PointFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9534,15 +9561,20 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PointFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PointFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::PointFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PointFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PointFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9550,7 +9582,7 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PointFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PointFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9584,7 +9616,7 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PointFiniteElement *arg1 = (mfem::PointFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9595,15 +9627,20 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "PointFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PointFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PointFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PointFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::PointFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PointFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PointFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9611,7 +9648,7 @@ SWIGINTERN PyObject *_wrap_PointFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PointFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PointFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9727,7 +9764,7 @@ SWIGINTERN PyObject *_wrap_new_Linear1DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear1DFiniteElement *arg1 = (mfem::Linear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9738,15 +9775,20 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Linear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9754,7 +9796,7 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9788,7 +9830,7 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear1DFiniteElement *arg1 = (mfem::Linear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9799,15 +9841,20 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Linear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9815,7 +9862,7 @@ SWIGINTERN PyObject *_wrap_Linear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -9931,7 +9978,7 @@ SWIGINTERN PyObject *_wrap_new_Linear2DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear2DFiniteElement *arg1 = (mfem::Linear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -9942,15 +9989,20 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Linear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -9958,7 +10010,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9992,7 +10044,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear2DFiniteElement *arg1 = (mfem::Linear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10003,15 +10055,20 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Linear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10019,7 +10076,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10053,7 +10110,7 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear2DFiniteElement *arg1 = (mfem::Linear2DFiniteElement *) 0 ; int arg2 ; @@ -10062,21 +10119,26 @@ SWIGINTERN PyObject *_wrap_Linear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::Linear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10192,7 +10254,7 @@ SWIGINTERN PyObject *_wrap_new_BiLinear2DFiniteElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10203,15 +10265,20 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10219,7 +10286,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10253,7 +10320,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10264,15 +10331,20 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10280,7 +10352,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10314,7 +10386,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10325,15 +10397,20 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10341,7 +10418,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10375,7 +10452,7 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_CalcHessian(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiLinear2DFiniteElement *arg1 = (mfem::BiLinear2DFiniteElement *) 0 ; int arg2 ; @@ -10384,21 +10461,26 @@ SWIGINTERN PyObject *_wrap_BiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiLinear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiLinear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiLinear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::BiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiLinear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiLinear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10514,7 +10596,7 @@ SWIGINTERN PyObject *_wrap_new_GaussLinear2DFiniteElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinear2DFiniteElement *arg1 = (mfem::GaussLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10525,15 +10607,20 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10541,7 +10628,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10575,7 +10662,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinear2DFiniteElement *arg1 = (mfem::GaussLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10586,15 +10673,20 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10602,7 +10694,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10636,7 +10728,7 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussLinear2DFiniteElement *arg1 = (mfem::GaussLinear2DFiniteElement *) 0 ; int arg2 ; @@ -10645,21 +10737,26 @@ SWIGINTERN PyObject *_wrap_GaussLinear2DFiniteElement_ProjectDelta(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussLinear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussLinear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussLinear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::GaussLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussLinear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussLinear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10775,7 +10872,7 @@ SWIGINTERN PyObject *_wrap_new_GaussBiLinear2DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiLinear2DFiniteElement *arg1 = (mfem::GaussBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10786,15 +10883,20 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10802,7 +10904,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10836,7 +10938,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiLinear2DFiniteElement *arg1 = (mfem::GaussBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -10847,15 +10949,20 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -10863,7 +10970,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -10897,7 +11004,7 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_CalcDShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiLinear2DFiniteElement *arg1 = (mfem::GaussBiLinear2DFiniteElement *) 0 ; int arg2 ; @@ -10906,21 +11013,26 @@ SWIGINTERN PyObject *_wrap_GaussBiLinear2DFiniteElement_ProjectDelta(PyObject *S int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiLinear2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiLinear2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiLinear2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::GaussBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiLinear2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiLinear2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11036,7 +11148,7 @@ SWIGINTERN PyObject *_wrap_new_P1OnQuadFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFiniteElement *arg1 = (mfem::P1OnQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11047,15 +11159,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P1OnQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11063,7 +11180,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1OnQuadFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11097,7 +11214,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFiniteElement *arg1 = (mfem::P1OnQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11108,15 +11225,20 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P1OnQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11124,7 +11246,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1OnQuadFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11158,7 +11280,7 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1OnQuadFiniteElement *arg1 = (mfem::P1OnQuadFiniteElement *) 0 ; int arg2 ; @@ -11167,21 +11289,26 @@ SWIGINTERN PyObject *_wrap_P1OnQuadFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1OnQuadFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1OnQuadFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1OnQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1OnQuadFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P1OnQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1OnQuadFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1OnQuadFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11297,7 +11424,7 @@ SWIGINTERN PyObject *_wrap_new_Quad1DFiniteElement(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad1DFiniteElement *arg1 = (mfem::Quad1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11308,15 +11435,20 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Quad1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11324,7 +11456,7 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11358,7 +11490,7 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad1DFiniteElement *arg1 = (mfem::Quad1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11369,15 +11501,20 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Quad1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11385,7 +11522,7 @@ SWIGINTERN PyObject *_wrap_Quad1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11501,7 +11638,7 @@ SWIGINTERN PyObject *_wrap_new_QuadPos1DFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadPos1DFiniteElement *arg1 = (mfem::QuadPos1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11512,15 +11649,20 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadPos1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadPos1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::QuadPos1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::QuadPos1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11528,7 +11670,7 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadPos1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11562,7 +11704,7 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadPos1DFiniteElement *arg1 = (mfem::QuadPos1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11573,15 +11715,20 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadPos1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadPos1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadPos1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::QuadPos1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::QuadPos1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11589,7 +11736,7 @@ SWIGINTERN PyObject *_wrap_QuadPos1DFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadPos1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11705,7 +11852,7 @@ SWIGINTERN PyObject *_wrap_new_Quad2DFiniteElement(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11716,15 +11863,20 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11732,7 +11884,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11766,7 +11918,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11777,15 +11929,20 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11793,7 +11950,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11827,7 +11984,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -11838,15 +11995,20 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -11854,7 +12016,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -11888,7 +12050,7 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quad2DFiniteElement *arg1 = (mfem::Quad2DFiniteElement *) 0 ; int arg2 ; @@ -11897,21 +12059,26 @@ SWIGINTERN PyObject *_wrap_Quad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSED int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quad2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quad2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quad2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::Quad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quad2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quad2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12027,7 +12194,7 @@ SWIGINTERN PyObject *_wrap_new_GaussQuad2DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuad2DFiniteElement *arg1 = (mfem::GaussQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12038,15 +12205,20 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussQuad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussQuad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12054,7 +12226,7 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussQuad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12088,7 +12260,7 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussQuad2DFiniteElement *arg1 = (mfem::GaussQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12099,15 +12271,20 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussQuad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussQuad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12115,7 +12292,7 @@ SWIGINTERN PyObject *_wrap_GaussQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussQuad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12231,7 +12408,7 @@ SWIGINTERN PyObject *_wrap_new_BiQuad2DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuad2DFiniteElement *arg1 = (mfem::BiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12242,15 +12419,20 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12258,7 +12440,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12292,7 +12474,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuad2DFiniteElement *arg1 = (mfem::BiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12303,15 +12485,20 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12319,7 +12506,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12353,7 +12540,7 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuad2DFiniteElement *arg1 = (mfem::BiQuad2DFiniteElement *) 0 ; int arg2 ; @@ -12362,21 +12549,26 @@ SWIGINTERN PyObject *_wrap_BiQuad2DFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuad2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuad2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuad2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::BiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuad2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuad2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12492,7 +12684,7 @@ SWIGINTERN PyObject *_wrap_new_BiQuadPos2DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12503,15 +12695,20 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12519,7 +12716,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12553,7 +12750,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -12564,15 +12761,20 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -12580,7 +12782,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -12614,7 +12816,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_CalcDShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -12625,15 +12827,20 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -12641,7 +12848,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13170,7 +13377,7 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_Project(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiQuadPos2DFiniteElement *arg1 = (mfem::BiQuadPos2DFiniteElement *) 0 ; int arg2 ; @@ -13179,21 +13386,26 @@ SWIGINTERN PyObject *_wrap_BiQuadPos2DFiniteElement_ProjectDelta(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiQuadPos2DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiQuadPos2DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiQuadPos2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiQuadPos2DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::BiQuadPos2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiQuadPos2DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiQuadPos2DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13309,7 +13521,7 @@ SWIGINTERN PyObject *_wrap_new_GaussBiQuad2DFiniteElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiQuad2DFiniteElement *arg1 = (mfem::GaussBiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13320,15 +13532,20 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiQuad2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiQuad2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::GaussBiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13336,7 +13553,7 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiQuad2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13370,7 +13587,7 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GaussBiQuad2DFiniteElement *arg1 = (mfem::GaussBiQuad2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13381,15 +13598,20 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GaussBiQuad2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GaussBiQuad2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GaussBiQuad2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::GaussBiQuad2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::GaussBiQuad2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13397,7 +13619,7 @@ SWIGINTERN PyObject *_wrap_GaussBiQuad2DFiniteElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GaussBiQuad2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13513,7 +13735,7 @@ SWIGINTERN PyObject *_wrap_new_BiCubic2DFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiCubic2DFiniteElement *arg1 = (mfem::BiCubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13524,15 +13746,20 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCubic2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCubic2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::BiCubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiCubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13540,7 +13767,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCubic2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13574,7 +13801,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiCubic2DFiniteElement *arg1 = (mfem::BiCubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13585,15 +13812,20 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCubic2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCubic2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::BiCubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiCubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13601,7 +13833,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCubic2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13635,7 +13867,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BiCubic2DFiniteElement *arg1 = (mfem::BiCubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13646,15 +13878,20 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BiCubic2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCubic2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::BiCubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::BiCubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13662,7 +13899,7 @@ SWIGINTERN PyObject *_wrap_BiCubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCubic2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13778,7 +14015,7 @@ SWIGINTERN PyObject *_wrap_new_Cubic1DFiniteElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic1DFiniteElement *arg1 = (mfem::Cubic1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13789,15 +14026,20 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Cubic1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13805,7 +14047,7 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13839,7 +14081,7 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic1DFiniteElement *arg1 = (mfem::Cubic1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13850,15 +14092,20 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Cubic1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -13866,7 +14113,7 @@ SWIGINTERN PyObject *_wrap_Cubic1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -13982,7 +14229,7 @@ SWIGINTERN PyObject *_wrap_new_Cubic2DFiniteElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic2DFiniteElement *arg1 = (mfem::Cubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -13993,15 +14240,20 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Cubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14009,7 +14261,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14043,7 +14295,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic2DFiniteElement *arg1 = (mfem::Cubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14054,15 +14306,20 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Cubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14070,7 +14327,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14104,7 +14361,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic2DFiniteElement *arg1 = (mfem::Cubic2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14115,15 +14372,20 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"h", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::Cubic2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14131,7 +14393,7 @@ SWIGINTERN PyObject *_wrap_Cubic2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14247,7 +14509,7 @@ SWIGINTERN PyObject *_wrap_new_Cubic3DFiniteElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic3DFiniteElement *arg1 = (mfem::Cubic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14258,15 +14520,20 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Cubic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14274,7 +14541,7 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14308,7 +14575,7 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Cubic3DFiniteElement *arg1 = (mfem::Cubic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14319,15 +14586,20 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Cubic3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Cubic3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Cubic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Cubic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Cubic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14335,7 +14607,7 @@ SWIGINTERN PyObject *_wrap_Cubic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Cubic3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14451,7 +14723,7 @@ SWIGINTERN PyObject *_wrap_new_P0TriangleFiniteElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TriangleFiniteElement *arg1 = (mfem::P0TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14462,15 +14734,20 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TriangleFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TriangleFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14478,7 +14755,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TriangleFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14512,7 +14789,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TriangleFiniteElement *arg1 = (mfem::P0TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14523,15 +14800,20 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TriangleFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TriangleFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14539,7 +14821,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TriangleFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14573,7 +14855,7 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TriangleFiniteElement *arg1 = (mfem::P0TriangleFiniteElement *) 0 ; int arg2 ; @@ -14582,21 +14864,26 @@ SWIGINTERN PyObject *_wrap_P0TriangleFiniteElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TriangleFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TriangleFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TriangleFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TriangleFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TriangleFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14712,7 +14999,7 @@ SWIGINTERN PyObject *_wrap_new_P0QuadFiniteElement(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0QuadFiniteElement *arg1 = (mfem::P0QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14723,15 +15010,20 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0QuadFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0QuadFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14739,7 +15031,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0QuadFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14773,7 +15065,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0QuadFiniteElement *arg1 = (mfem::P0QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14784,15 +15076,20 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0QuadFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0QuadFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -14800,7 +15097,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0QuadFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -14834,7 +15131,7 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0QuadFiniteElement *arg1 = (mfem::P0QuadFiniteElement *) 0 ; int arg2 ; @@ -14843,21 +15140,26 @@ SWIGINTERN PyObject *_wrap_P0QuadFiniteElement_ProjectDelta(PyObject *SWIGUNUSED int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0QuadFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0QuadFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0QuadFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0QuadFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0QuadFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14973,7 +15275,7 @@ SWIGINTERN PyObject *_wrap_new_Linear3DFiniteElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -14984,15 +15286,20 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15000,7 +15307,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15034,7 +15341,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15045,15 +15352,20 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15061,7 +15373,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -15095,7 +15407,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; int arg2 ; @@ -15104,21 +15416,26 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Linear3DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15152,7 +15469,7 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Linear3DFiniteElement *arg1 = (mfem::Linear3DFiniteElement *) 0 ; int arg2 ; @@ -15164,26 +15481,32 @@ SWIGINTERN PyObject *_wrap_Linear3DFiniteElement_GetFaceDofs(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face", (char *)"dofs", (char *)"ndofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Linear3DFiniteElement_GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Linear3DFiniteElement_GetFaceDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Linear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Linear3DFiniteElement_GetFaceDofs" "', argument " "1"" of type '" "mfem::Linear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Linear3DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Linear3DFiniteElement_GetFaceDofs" "', argument " "3"" of type '" "int **""'"); } arg3 = reinterpret_cast< int ** >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Linear3DFiniteElement_GetFaceDofs" "', argument " "4"" of type '" "int *""'"); } @@ -15296,7 +15619,7 @@ SWIGINTERN PyObject *_wrap_new_Quadratic3DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quadratic3DFiniteElement *arg1 = (mfem::Quadratic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15307,15 +15630,20 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quadratic3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quadratic3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Quadratic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quadratic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15323,7 +15651,7 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quadratic3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15357,7 +15685,7 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Quadratic3DFiniteElement *arg1 = (mfem::Quadratic3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15368,15 +15696,20 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Quadratic3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Quadratic3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Quadratic3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Quadratic3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Quadratic3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15384,7 +15717,7 @@ SWIGINTERN PyObject *_wrap_Quadratic3DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Quadratic3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -15500,7 +15833,7 @@ SWIGINTERN PyObject *_wrap_new_TriLinear3DFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TriLinear3DFiniteElement *arg1 = (mfem::TriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15511,15 +15844,20 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TriLinear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TriLinear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::TriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::TriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15527,7 +15865,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TriLinear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15561,7 +15899,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TriLinear3DFiniteElement *arg1 = (mfem::TriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15572,15 +15910,20 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TriLinear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TriLinear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::TriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::TriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15588,7 +15931,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TriLinear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -15622,7 +15965,7 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TriLinear3DFiniteElement *arg1 = (mfem::TriLinear3DFiniteElement *) 0 ; int arg2 ; @@ -15631,21 +15974,26 @@ SWIGINTERN PyObject *_wrap_TriLinear3DFiniteElement_ProjectDelta(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TriLinear3DFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TriLinear3DFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TriLinear3DFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::TriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::TriLinear3DFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TriLinear3DFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15761,7 +16109,7 @@ SWIGINTERN PyObject *_wrap_new_CrouzeixRaviartFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFiniteElement *arg1 = (mfem::CrouzeixRaviartFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15772,15 +16120,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15788,7 +16141,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15822,7 +16175,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFiniteElement *arg1 = (mfem::CrouzeixRaviartFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -15833,15 +16186,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -15849,7 +16207,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -15883,7 +16241,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_CalcDShape(PyObject *SWI } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartFiniteElement *arg1 = (mfem::CrouzeixRaviartFiniteElement *) 0 ; int arg2 ; @@ -15892,21 +16250,26 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartFiniteElement_ProjectDelta(PyObject *S int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::CrouzeixRaviartFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -16022,7 +16385,7 @@ SWIGINTERN PyObject *_wrap_new_CrouzeixRaviartQuadFiniteElement(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartQuadFiniteElement *arg1 = (mfem::CrouzeixRaviartQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -16033,15 +16396,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartQuadFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartQuadFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16049,7 +16417,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -16083,7 +16451,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape(PyObject * } -SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CrouzeixRaviartQuadFiniteElement *arg1 = (mfem::CrouzeixRaviartQuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -16094,15 +16462,20 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CrouzeixRaviartQuadFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CrouzeixRaviartQuadFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CrouzeixRaviartQuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::CrouzeixRaviartQuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::CrouzeixRaviartQuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16110,7 +16483,7 @@ SWIGINTERN PyObject *_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CrouzeixRaviartQuadFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -16195,52 +16568,27 @@ SWIGINTERN PyObject *CrouzeixRaviartQuadFiniteElement_swiginit(PyObject *SWIGUNU return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"Ord", NULL + }; mfem::P0SegmentFiniteElement *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::P0SegmentFiniteElement *)new mfem::P0SegmentFiniteElement(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_P0SegmentFiniteElement", kwnames, &obj0)) SWIG_fail; + if (obj0) { + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__P0SegmentFiniteElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::P0SegmentFiniteElement *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::P0SegmentFiniteElement *)new mfem::P0SegmentFiniteElement(); + result = (mfem::P0SegmentFiniteElement *)new mfem::P0SegmentFiniteElement(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16264,42 +16612,7 @@ SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_new_P0SegmentFiniteElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_P0SegmentFiniteElement", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_P0SegmentFiniteElement__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_P0SegmentFiniteElement__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_P0SegmentFiniteElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::P0SegmentFiniteElement::P0SegmentFiniteElement(int)\n" - " mfem::P0SegmentFiniteElement::P0SegmentFiniteElement()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0SegmentFiniteElement *arg1 = (mfem::P0SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -16310,15 +16623,20 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0SegmentFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0SegmentFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16326,7 +16644,7 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0SegmentFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -16360,7 +16678,7 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0SegmentFiniteElement *arg1 = (mfem::P0SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -16371,15 +16689,20 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0SegmentFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0SegmentFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16387,7 +16710,7 @@ SWIGINTERN PyObject *_wrap_P0SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0SegmentFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -16678,7 +17001,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TriangleFiniteElement *arg1 = (mfem::RT0TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -16689,15 +17012,20 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TriangleFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TriangleFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -16705,7 +17033,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TriangleFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -16739,7 +17067,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_CalcDivShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TriangleFiniteElement *arg1 = (mfem::RT0TriangleFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -16750,15 +17078,20 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TriangleFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TriangleFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -16766,7 +17099,7 @@ SWIGINTERN PyObject *_wrap_RT0TriangleFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TriangleFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -17456,7 +17789,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0QuadFiniteElement *arg1 = (mfem::RT0QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -17467,15 +17800,20 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0QuadFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0QuadFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -17483,7 +17821,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0QuadFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -17517,7 +17855,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0QuadFiniteElement *arg1 = (mfem::RT0QuadFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -17528,15 +17866,20 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0QuadFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0QuadFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -17544,7 +17887,7 @@ SWIGINTERN PyObject *_wrap_RT0QuadFiniteElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0QuadFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -18234,7 +18577,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1TriangleFiniteElement *arg1 = (mfem::RT1TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -18245,15 +18588,20 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1TriangleFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1TriangleFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT1TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -18261,7 +18609,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1TriangleFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -18295,7 +18643,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_CalcDivShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1TriangleFiniteElement *arg1 = (mfem::RT1TriangleFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -18306,15 +18654,20 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1TriangleFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1TriangleFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT1TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -18322,7 +18675,7 @@ SWIGINTERN PyObject *_wrap_RT1TriangleFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1TriangleFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19012,7 +19365,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1QuadFiniteElement *arg1 = (mfem::RT1QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19023,15 +19376,20 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1QuadFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1QuadFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT1QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19039,7 +19397,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1QuadFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -19073,7 +19431,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1QuadFiniteElement *arg1 = (mfem::RT1QuadFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -19084,15 +19442,20 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1QuadFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1QuadFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT1QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -19100,7 +19463,7 @@ SWIGINTERN PyObject *_wrap_RT1QuadFiniteElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1QuadFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -19790,7 +20153,7 @@ SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2TriangleFiniteElement *arg1 = (mfem::RT2TriangleFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -19801,15 +20164,20 @@ SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT2TriangleFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2TriangleFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2TriangleFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2TriangleFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT2TriangleFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT2TriangleFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19817,7 +20185,7 @@ SWIGINTERN PyObject *_wrap_RT2TriangleFiniteElement_CalcDivShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT2TriangleFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20108,7 +20476,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2QuadFiniteElement *arg1 = (mfem::RT2QuadFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20119,15 +20487,20 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT2QuadFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2QuadFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT2QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT2QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20135,7 +20508,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT2QuadFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20169,7 +20542,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT2QuadFiniteElement *arg1 = (mfem::RT2QuadFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -20180,15 +20553,20 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT2QuadFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT2QuadFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT2QuadFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT2QuadFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT2QuadFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -20196,7 +20574,7 @@ SWIGINTERN PyObject *_wrap_RT2QuadFiniteElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT2QuadFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -20711,7 +21089,7 @@ SWIGINTERN PyObject *_wrap_new_P1SegmentFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1SegmentFiniteElement *arg1 = (mfem::P1SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20722,15 +21100,20 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1SegmentFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1SegmentFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P1SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20738,7 +21121,7 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1SegmentFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20772,7 +21155,7 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1SegmentFiniteElement *arg1 = (mfem::P1SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20783,15 +21166,20 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1SegmentFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1SegmentFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P1SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20799,7 +21187,7 @@ SWIGINTERN PyObject *_wrap_P1SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1SegmentFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -20915,7 +21303,7 @@ SWIGINTERN PyObject *_wrap_new_P2SegmentFiniteElement(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P2SegmentFiniteElement *arg1 = (mfem::P2SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20926,15 +21314,20 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P2SegmentFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P2SegmentFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P2SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P2SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -20942,7 +21335,7 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P2SegmentFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -20976,7 +21369,7 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P2SegmentFiniteElement *arg1 = (mfem::P2SegmentFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -20987,15 +21380,20 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P2SegmentFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P2SegmentFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P2SegmentFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P2SegmentFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P2SegmentFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21003,7 +21401,7 @@ SWIGINTERN PyObject *_wrap_P2SegmentFiniteElement_CalcDShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P2SegmentFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21088,19 +21486,21 @@ SWIGINTERN PyObject *P2SegmentFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_Lagrange1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Lagrange1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"degree", NULL + }; mfem::Lagrange1DFiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_Lagrange1DFiniteElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -21128,7 +21528,7 @@ SWIGINTERN PyObject *_wrap_new_Lagrange1DFiniteElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Lagrange1DFiniteElement *arg1 = (mfem::Lagrange1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21139,15 +21539,20 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Lagrange1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Lagrange1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::Lagrange1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Lagrange1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21155,7 +21560,7 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Lagrange1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21189,7 +21594,7 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Lagrange1DFiniteElement *arg1 = (mfem::Lagrange1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21200,15 +21605,20 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Lagrange1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Lagrange1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Lagrange1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::Lagrange1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Lagrange1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21216,7 +21626,7 @@ SWIGINTERN PyObject *_wrap_Lagrange1DFiniteElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Lagrange1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21332,7 +21742,7 @@ SWIGINTERN PyObject *_wrap_new_P1TetNonConfFiniteElement(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1TetNonConfFiniteElement *arg1 = (mfem::P1TetNonConfFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21343,15 +21753,20 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1TetNonConfFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1TetNonConfFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P1TetNonConfFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1TetNonConfFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21359,7 +21774,7 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1TetNonConfFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21393,7 +21808,7 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P1TetNonConfFiniteElement *arg1 = (mfem::P1TetNonConfFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21404,15 +21819,20 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P1TetNonConfFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P1TetNonConfFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P1TetNonConfFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P1TetNonConfFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P1TetNonConfFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21420,7 +21840,7 @@ SWIGINTERN PyObject *_wrap_P1TetNonConfFiniteElement_CalcDShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P1TetNonConfFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21536,7 +21956,7 @@ SWIGINTERN PyObject *_wrap_new_P0TetFiniteElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TetFiniteElement *arg1 = (mfem::P0TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21547,15 +21967,20 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TetFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TetFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TetFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TetFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21563,7 +21988,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TetFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TetFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21597,7 +22022,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TetFiniteElement *arg1 = (mfem::P0TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21608,15 +22033,20 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TetFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TetFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21624,7 +22054,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TetFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21658,7 +22088,7 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P0TetFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0TetFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0TetFiniteElement *arg1 = (mfem::P0TetFiniteElement *) 0 ; int arg2 ; @@ -21667,21 +22097,26 @@ SWIGINTERN PyObject *_wrap_P0TetFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0TetFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0TetFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0TetFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0TetFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0TetFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21797,7 +22232,7 @@ SWIGINTERN PyObject *_wrap_new_P0HexFiniteElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0HexFiniteElement *arg1 = (mfem::P0HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21808,15 +22243,20 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0HexFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0HexFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0HexFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::P0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0HexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21824,7 +22264,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0HexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0HexFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -21858,7 +22298,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0HexFiniteElement *arg1 = (mfem::P0HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -21869,15 +22309,20 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0HexFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0HexFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::P0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -21885,7 +22330,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0HexFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -21919,7 +22364,7 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_P0HexFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_P0HexFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::P0HexFiniteElement *arg1 = (mfem::P0HexFiniteElement *) 0 ; int arg2 ; @@ -21928,21 +22373,26 @@ SWIGINTERN PyObject *_wrap_P0HexFiniteElement_ProjectDelta(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "P0HexFiniteElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:P0HexFiniteElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__P0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "P0HexFiniteElement_ProjectDelta" "', argument " "1"" of type '" "mfem::P0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::P0HexFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "P0HexFiniteElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22027,19 +22477,21 @@ SWIGINTERN PyObject *P0HexFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_LagrangeHexFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_LagrangeHexFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"degree", NULL + }; mfem::LagrangeHexFiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_LagrangeHexFiniteElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -22067,7 +22519,7 @@ SWIGINTERN PyObject *_wrap_new_LagrangeHexFiniteElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LagrangeHexFiniteElement *arg1 = (mfem::LagrangeHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22078,15 +22530,20 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LagrangeHexFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LagrangeHexFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::LagrangeHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::LagrangeHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22094,7 +22551,7 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LagrangeHexFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22128,7 +22585,7 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LagrangeHexFiniteElement *arg1 = (mfem::LagrangeHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22139,15 +22596,20 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LagrangeHexFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:LagrangeHexFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LagrangeHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::LagrangeHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::LagrangeHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22155,7 +22617,7 @@ SWIGINTERN PyObject *_wrap_LagrangeHexFiniteElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "LagrangeHexFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -22271,7 +22733,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinear1DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear1DFiniteElement *arg1 = (mfem::RefinedLinear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22282,15 +22744,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedLinear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22298,7 +22765,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22332,7 +22799,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear1DFiniteElement *arg1 = (mfem::RefinedLinear1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22343,15 +22810,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedLinear1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22359,7 +22831,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear1DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -22475,7 +22947,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinear2DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear2DFiniteElement *arg1 = (mfem::RefinedLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22486,15 +22958,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22502,7 +22979,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22536,7 +23013,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear2DFiniteElement *arg1 = (mfem::RefinedLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22547,15 +23024,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22563,7 +23045,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear2DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -22679,7 +23161,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedLinear3DFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear3DFiniteElement *arg1 = (mfem::RefinedLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22690,15 +23172,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22706,7 +23193,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22740,7 +23227,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedLinear3DFiniteElement *arg1 = (mfem::RefinedLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22751,15 +23238,20 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedLinear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedLinear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22767,7 +23259,7 @@ SWIGINTERN PyObject *_wrap_RefinedLinear3DFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedLinear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -22883,7 +23375,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedBiLinear2DFiniteElement(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedBiLinear2DFiniteElement *arg1 = (mfem::RefinedBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22894,15 +23386,20 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedBiLinear2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedBiLinear2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22910,7 +23407,7 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedBiLinear2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -22944,7 +23441,7 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcShape(PyObject *SW } -SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedBiLinear2DFiniteElement *arg1 = (mfem::RefinedBiLinear2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -22955,15 +23452,20 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedBiLinear2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedBiLinear2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedBiLinear2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedBiLinear2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedBiLinear2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -22971,7 +23473,7 @@ SWIGINTERN PyObject *_wrap_RefinedBiLinear2DFiniteElement_CalcDShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedBiLinear2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -23087,7 +23589,7 @@ SWIGINTERN PyObject *_wrap_new_RefinedTriLinear3DFiniteElement(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedTriLinear3DFiniteElement *arg1 = (mfem::RefinedTriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -23098,15 +23600,20 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedTriLinear3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedTriLinear3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RefinedTriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedTriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -23114,7 +23621,7 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedTriLinear3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -23148,7 +23655,7 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcShape(PyObject *S } -SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RefinedTriLinear3DFiniteElement *arg1 = (mfem::RefinedTriLinear3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -23159,15 +23666,20 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RefinedTriLinear3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RefinedTriLinear3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RefinedTriLinear3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RefinedTriLinear3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RefinedTriLinear3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -23175,7 +23687,7 @@ SWIGINTERN PyObject *_wrap_RefinedTriLinear3DFiniteElement_CalcDShape(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RefinedTriLinear3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -23466,7 +23978,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1HexFiniteElement *arg1 = (mfem::Nedelec1HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -23477,15 +23989,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1HexFiniteElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1HexFiniteElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::Nedelec1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -23493,7 +24010,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1HexFiniteElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -23527,7 +24044,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_CalcCurlShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1HexFiniteElement *arg1 = (mfem::Nedelec1HexFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -23538,15 +24055,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1HexFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1HexFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::Nedelec1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -23554,7 +24076,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1HexFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -24244,7 +24766,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcVShape(PyObject *self, P } -SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1TetFiniteElement *arg1 = (mfem::Nedelec1TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -24255,15 +24777,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1TetFiniteElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1TetFiniteElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::Nedelec1TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -24271,7 +24798,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1TetFiniteElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -24305,7 +24832,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_CalcCurlShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Nedelec1TetFiniteElement *arg1 = (mfem::Nedelec1TetFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -24316,15 +24843,20 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Nedelec1TetFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Nedelec1TetFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Nedelec1TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::Nedelec1TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::Nedelec1TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -24332,7 +24864,7 @@ SWIGINTERN PyObject *_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Nedelec1TetFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -25022,7 +25554,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcVShape(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0HexFiniteElement *arg1 = (mfem::RT0HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -25033,15 +25565,20 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0HexFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0HexFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -25049,7 +25586,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0HexFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -25083,7 +25620,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0HexFiniteElement *arg1 = (mfem::RT0HexFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -25094,15 +25631,20 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0HexFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0HexFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -25110,7 +25652,7 @@ SWIGINTERN PyObject *_wrap_RT0HexFiniteElement_GetLocalInterpolation(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0HexFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -25800,7 +26342,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcVShape(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1HexFiniteElement *arg1 = (mfem::RT1HexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -25811,15 +26353,20 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1HexFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1HexFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -25827,7 +26374,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1HexFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -25861,7 +26408,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_CalcDivShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT1HexFiniteElement *arg1 = (mfem::RT1HexFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -25872,15 +26419,20 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT1HexFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT1HexFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT1HexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT1HexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT1HexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -25888,7 +26440,7 @@ SWIGINTERN PyObject *_wrap_RT1HexFiniteElement_GetLocalInterpolation(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT1HexFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -26578,7 +27130,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcVShape(PyObject *self, PyObje } -SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TetFiniteElement *arg1 = (mfem::RT0TetFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -26589,15 +27141,20 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TetFiniteElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TetFiniteElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -26605,7 +27162,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TetFiniteElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -26639,7 +27196,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_CalcDivShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT0TetFiniteElement *arg1 = (mfem::RT0TetFiniteElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -26650,15 +27207,20 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT0TetFiniteElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT0TetFiniteElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT0TetFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT0TetFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RT0TetFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -26666,7 +27228,7 @@ SWIGINTERN PyObject *_wrap_RT0TetFiniteElement_GetLocalInterpolation(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT0TetFiniteElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -27181,7 +27743,7 @@ SWIGINTERN PyObject *_wrap_new_RotTriLinearHexFiniteElement(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RotTriLinearHexFiniteElement *arg1 = (mfem::RotTriLinearHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -27192,15 +27754,20 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RotTriLinearHexFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RotTriLinearHexFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::RotTriLinearHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RotTriLinearHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -27208,7 +27775,7 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RotTriLinearHexFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -27242,7 +27809,7 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcShape(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RotTriLinearHexFiniteElement *arg1 = (mfem::RotTriLinearHexFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -27253,15 +27820,20 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RotTriLinearHexFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RotTriLinearHexFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RotTriLinearHexFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::RotTriLinearHexFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::RotTriLinearHexFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -27269,7 +27841,7 @@ SWIGINTERN PyObject *_wrap_RotTriLinearHexFiniteElement_CalcDShape(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RotTriLinearHexFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -27385,19 +27957,21 @@ SWIGINTERN PyObject *_wrap_new_Poly_1D(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Poly_1D_Binom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_Binom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Poly_1D_Binom", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -27425,33 +27999,38 @@ SWIGINTERN PyObject *_wrap_Poly_1D_Binom(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Poly_1D_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL + }; double *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_GetPoints", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Poly_1D_GetPoints", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_GetPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -27479,32 +28058,40 @@ SWIGINTERN PyObject *_wrap_Poly_1D_GetPoints(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; - int arg3 ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL + }; double *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Poly_1D_OpenPoints", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_OpenPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { @@ -27532,144 +28119,40 @@ SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; + int arg3 = (int) (int)mfem::BasisType::GaussLobatto ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_OpenPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); - } - arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double *)(arg1)->OpenPoints(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_OpenPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Poly_1D_OpenPoints", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_OpenPoints__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_OpenPoints__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Poly_1D_OpenPoints'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Poly_1D::OpenPoints(int const,int const)\n" - " mfem::Poly_1D::OpenPoints(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; double *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Poly_1D_ClosedPoints", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_ClosedPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { @@ -27697,145 +28180,38 @@ SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_ClosedPoints" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); - } - arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double *)(arg1)->ClosedPoints(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_ClosedPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Poly_1D_ClosedPoints", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_ClosedPoints__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Poly_1D, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Poly_1D_ClosedPoints__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Poly_1D_ClosedPoints'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Poly_1D::ClosedPoints(int const,int const)\n" - " mfem::Poly_1D::ClosedPoints(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Poly_1D_GetBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_GetBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Poly_1D *arg1 = (mfem::Poly_1D *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"btype", NULL + }; mfem::Poly_1D::Basis *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_GetBasis", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Poly_1D_GetBasis", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Poly_1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Poly_1D_GetBasis" "', argument " "1"" of type '" "mfem::Poly_1D *""'"); } arg1 = reinterpret_cast< mfem::Poly_1D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -28155,23 +28531,27 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcBasis(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Poly_1D_CalcDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_CalcDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double arg2 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_CalcDelta", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Poly_1D_CalcDelta", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcDelta" "', argument " "2"" of type '" "double""'"); } @@ -28202,22 +28582,26 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcDelta(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Poly_1D_ChebyshevPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_ChebyshevPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_ChebyshevPoints", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Poly_1D_ChebyshevPoints", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Poly_1D_ChebyshevPoints" "', argument " "2"" of type '" "double *""'"); } @@ -28463,7 +28847,7 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcBinomTerms(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_Poly_1D_CalcDBinomTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Poly_1D_CalcDBinomTerms(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double arg2 ; @@ -28475,26 +28859,32 @@ SWIGINTERN PyObject *_wrap_Poly_1D_CalcDBinomTerms(PyObject *SWIGUNUSEDPARM(self int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"x", (char *)"y", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Poly_1D_CalcDBinomTerms", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Poly_1D_CalcDBinomTerms", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Poly_1D_CalcDBinomTerms" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Poly_1D_CalcDBinomTerms" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Poly_1D_CalcDBinomTerms" "', argument " "4"" of type '" "double *""'"); } @@ -28950,7 +29340,7 @@ SWIGINTERN PyObject *Poly_1D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TensorBasisElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TensorBasisElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -28958,29 +29348,35 @@ SWIGINTERN PyObject *_wrap_new_TensorBasisElement(PyObject *SWIGUNUSEDPARM(self) mfem::TensorBasisElement::DofMapType arg4 ; int val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"dims", (char *)"p", (char *)"btype", (char *)"dmtype", NULL + }; mfem::TensorBasisElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_TensorBasisElement", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_TensorBasisElement", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TensorBasisElement" "', argument " "4"" of type '" "mfem::TensorBasisElement::DofMapType""'"); } @@ -29134,19 +29530,21 @@ SWIGINTERN PyObject *_wrap_TensorBasisElement_GetDofMap(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_TensorBasisElement_GetTensorProductGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TensorBasisElement_GetTensorProductGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"dim", NULL + }; mfem::Geometry::Type result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:TensorBasisElement_GetTensorProductGeometry", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -29174,25 +29572,29 @@ SWIGINTERN PyObject *_wrap_TensorBasisElement_GetTensorProductGeometry(PyObject } -SWIGINTERN PyObject *_wrap_TensorBasisElement_Pow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TensorBasisElement_Pow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"base", (char *)"dim", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "TensorBasisElement_Pow", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TensorBasisElement_Pow", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -29271,7 +29673,7 @@ SWIGINTERN PyObject *TensorBasisElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodalTensorFiniteElement *arg1 = (mfem::NodalTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -29282,16 +29684,21 @@ SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGU int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NodalTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodalTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NodalTensorFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodalTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::NodalTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NodalTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -29299,7 +29706,7 @@ SWIGINTERN PyObject *_wrap_NodalTensorFiniteElement_GetDofToQuad(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "NodalTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -29377,7 +29784,7 @@ SWIGINTERN PyObject *NodalTensorFiniteElement_swigregister(PyObject *SWIGUNUSEDP return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PositiveTensorFiniteElement *arg1 = (mfem::PositiveTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -29388,16 +29795,21 @@ SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SW int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PositiveTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PositiveTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PositiveTensorFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PositiveTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::PositiveTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::PositiveTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -29405,7 +29817,7 @@ SWIGINTERN PyObject *_wrap_PositiveTensorFiniteElement_GetDofToQuad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PositiveTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -29483,7 +29895,7 @@ SWIGINTERN PyObject *PositiveTensorFiniteElement_swigregister(PyObject *SWIGUNUS return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -29494,47 +29906,56 @@ SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPAR mfem::TensorBasisElement::DofMapType arg7 ; int val7 ; int ecode7 = 0 ; - PyObject *swig_obj[7] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"dims", (char *)"d", (char *)"p", (char *)"cbtype", (char *)"obtype", (char *)"M", (char *)"dmtype", NULL + }; mfem::VectorTensorFiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_VectorTensorFiniteElement", 7, 7, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:new_VectorTensorFiniteElement", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg6 = PyArray_PyIntAsInt(obj5); } - ecode7 = SWIG_AsVal_int(swig_obj[6], &val7); + ecode7 = SWIG_AsVal_int(obj6, &val7); if (!SWIG_IsOK(ecode7)) { SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_VectorTensorFiniteElement" "', argument " "7"" of type '" "mfem::TensorBasisElement::DofMapType""'"); } @@ -29565,7 +29986,7 @@ SWIGINTERN PyObject *_wrap_new_VectorTensorFiniteElement(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -29576,16 +29997,21 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIG int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorTensorFiniteElement_GetDofToQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -29593,7 +30019,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -29624,7 +30050,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuad(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -29635,16 +30061,21 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject * int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetDofToQuadOpen", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorTensorFiniteElement_GetDofToQuadOpen", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -29652,7 +30083,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetDofToQuadOpen" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } @@ -29683,7 +30114,7 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetDofToQuadOpen(PyObject * } -SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorTensorFiniteElement *arg1 = (mfem::VectorTensorFiniteElement *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -29697,16 +30128,22 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"mode", (char *)"closed", NULL + }; mfem::DofToQuad *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorTensorFiniteElement_GetTensorDofToQuad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorTensorFiniteElement_GetTensorDofToQuad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorTensorFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "1"" of type '" "mfem::VectorTensorFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::VectorTensorFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -29714,12 +30151,12 @@ SWIGINTERN PyObject *_wrap_VectorTensorFiniteElement_GetTensorDofToQuad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "3"" of type '" "mfem::DofToQuad::Mode""'"); } arg3 = static_cast< mfem::DofToQuad::Mode >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "VectorTensorFiniteElement_GetTensorDofToQuad" "', argument " "4"" of type '" "bool""'"); } @@ -29801,66 +30238,35 @@ SWIGINTERN PyObject *VectorTensorFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_SegmentElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_SegmentElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1_SegmentElement *)new mfem::H1_SegmentElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_SegmentElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_SegmentElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_SegmentElement *)new mfem::H1_SegmentElement(arg1); + result = (mfem::H1_SegmentElement *)new mfem::H1_SegmentElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -29884,63 +30290,7 @@ SWIGINTERN PyObject *_wrap_new_H1_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_H1_SegmentElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_SegmentElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_SegmentElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_SegmentElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_SegmentElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_SegmentElement::H1_SegmentElement(int const,int const)\n" - " mfem::H1_SegmentElement::H1_SegmentElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_SegmentElement *arg1 = (mfem::H1_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -29951,15 +30301,20 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -29967,7 +30322,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -30001,7 +30356,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_SegmentElement *arg1 = (mfem::H1_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30012,15 +30367,20 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30028,7 +30388,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -30062,7 +30422,7 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_SegmentElement *arg1 = (mfem::H1_SegmentElement *) 0 ; int arg2 ; @@ -30071,21 +30431,26 @@ SWIGINTERN PyObject *_wrap_H1_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -30170,66 +30535,35 @@ SWIGINTERN PyObject *H1_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_QuadrilateralElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_QuadrilateralElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::H1_QuadrilateralElement *)new mfem::H1_QuadrilateralElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_QuadrilateralElement *)new mfem::H1_QuadrilateralElement(arg1); + result = (mfem::H1_QuadrilateralElement *)new mfem::H1_QuadrilateralElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -30253,63 +30587,7 @@ SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_H1_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_QuadrilateralElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_QuadrilateralElement::H1_QuadrilateralElement(int const,int const)\n" - " mfem::H1_QuadrilateralElement::H1_QuadrilateralElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_QuadrilateralElement *arg1 = (mfem::H1_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30320,15 +30598,20 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30336,7 +30619,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -30370,7 +30653,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_QuadrilateralElement *arg1 = (mfem::H1_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30381,15 +30664,20 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30397,7 +30685,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -30431,7 +30719,7 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_QuadrilateralElement *arg1 = (mfem::H1_QuadrilateralElement *) 0 ; int arg2 ; @@ -30440,21 +30728,26 @@ SWIGINTERN PyObject *_wrap_H1_QuadrilateralElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -30539,66 +30832,35 @@ SWIGINTERN PyObject *H1_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_HexahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_HexahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1_HexahedronElement *)new mfem::H1_HexahedronElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_HexahedronElement *)new mfem::H1_HexahedronElement(arg1); + result = (mfem::H1_HexahedronElement *)new mfem::H1_HexahedronElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -30622,63 +30884,7 @@ SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_H1_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_HexahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_HexahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_HexahedronElement::H1_HexahedronElement(int const,int const)\n" - " mfem::H1_HexahedronElement::H1_HexahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_HexahedronElement *arg1 = (mfem::H1_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30689,15 +30895,20 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30705,7 +30916,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -30739,7 +30950,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_HexahedronElement *arg1 = (mfem::H1_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30750,15 +30961,20 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30766,7 +30982,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -30800,7 +31016,7 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_H1_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_HexahedronElement *arg1 = (mfem::H1_HexahedronElement *) 0 ; int arg2 ; @@ -30809,21 +31025,26 @@ SWIGINTERN PyObject *_wrap_H1_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -30908,19 +31129,21 @@ SWIGINTERN PyObject *H1_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_SegmentElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_SegmentElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -30948,7 +31171,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_SegmentElement *arg1 = (mfem::H1Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -30959,15 +31182,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -30975,7 +31203,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -31009,7 +31237,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_SegmentElement *arg1 = (mfem::H1Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31020,15 +31248,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31036,7 +31269,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -31070,7 +31303,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_SegmentElement *arg1 = (mfem::H1Pos_SegmentElement *) 0 ; int arg2 ; @@ -31079,21 +31312,26 @@ SWIGINTERN PyObject *_wrap_H1Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -31178,19 +31416,21 @@ SWIGINTERN PyObject *H1Pos_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_QuadrilateralElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_QuadrilateralElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -31218,7 +31458,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_QuadrilateralElement *arg1 = (mfem::H1Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31229,15 +31469,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31245,7 +31490,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -31279,7 +31524,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_QuadrilateralElement *arg1 = (mfem::H1Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31290,15 +31535,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31306,7 +31556,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -31340,7 +31590,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_QuadrilateralElement *arg1 = (mfem::H1Pos_QuadrilateralElement *) 0 ; int arg2 ; @@ -31349,21 +31599,26 @@ SWIGINTERN PyObject *_wrap_H1Pos_QuadrilateralElement_ProjectDelta(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -31448,19 +31703,21 @@ SWIGINTERN PyObject *H1Pos_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Ser_QuadrilateralElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Ser_QuadrilateralElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -31488,7 +31745,7 @@ SWIGINTERN PyObject *_wrap_new_H1Ser_QuadrilateralElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31499,15 +31756,20 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Ser_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31515,7 +31777,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -31549,7 +31811,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -31560,15 +31822,20 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Ser_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -31576,7 +31843,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -31610,7 +31877,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Ser_QuadrilateralElement *arg1 = (mfem::H1Ser_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -31621,15 +31888,20 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Ser_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Ser_QuadrilateralElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Ser_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::H1Ser_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Ser_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -31637,7 +31909,7 @@ SWIGINTERN PyObject *_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Ser_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32025,19 +32297,21 @@ SWIGINTERN PyObject *H1Ser_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_HexahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_HexahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -32065,7 +32339,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32076,15 +32350,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32092,7 +32371,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32126,7 +32405,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32137,15 +32416,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32153,7 +32437,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32187,7 +32471,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_HexahedronElement *arg1 = (mfem::H1Pos_HexahedronElement *) 0 ; int arg2 ; @@ -32196,21 +32480,26 @@ SWIGINTERN PyObject *_wrap_H1Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::H1Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32295,66 +32584,35 @@ SWIGINTERN PyObject *H1Pos_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_TriangleElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_TriangleElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TriangleElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_TriangleElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1); + result = (mfem::H1_TriangleElement *)new mfem::H1_TriangleElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -32378,63 +32636,7 @@ SWIGINTERN PyObject *_wrap_new_H1_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_H1_TriangleElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_TriangleElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TriangleElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TriangleElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_TriangleElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_TriangleElement::H1_TriangleElement(int const,int const)\n" - " mfem::H1_TriangleElement::H1_TriangleElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TriangleElement *arg1 = (mfem::H1_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32445,15 +32647,20 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TriangleElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TriangleElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TriangleElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32461,7 +32668,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TriangleElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -32495,7 +32702,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TriangleElement *arg1 = (mfem::H1_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32506,15 +32713,20 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TriangleElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TriangleElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TriangleElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32522,7 +32734,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TriangleElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32556,7 +32768,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TriangleElement *arg1 = (mfem::H1_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32567,15 +32779,20 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"ddshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TriangleElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TriangleElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TriangleElement_CalcHessian" "', argument " "1"" of type '" "mfem::H1_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TriangleElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -32583,7 +32800,7 @@ SWIGINTERN PyObject *_wrap_H1_TriangleElement_CalcHessian(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TriangleElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TriangleElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -32668,24 +32885,31 @@ SWIGINTERN PyObject *H1_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_TetrahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_TetrahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -32713,21 +32937,49 @@ SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - mfem::H1_TetrahedronElement *result = 0 ; + mfem::H1_TetrahedronElement *arg1 = (mfem::H1_TetrahedronElement *) 0 ; + mfem::IntegrationPoint *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TetrahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); + } + arg1 = reinterpret_cast< mfem::H1_TetrahedronElement * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::H1_TetrahedronElement *)new mfem::H1_TetrahedronElement(arg1); + ((mfem::H1_TetrahedronElement const *)arg1)->CalcShape((mfem::IntegrationPoint const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -32744,107 +32996,56 @@ SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement__SWIG_1(PyObject *SWIGUNUSE SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_TetrahedronElement, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_H1_TetrahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_TetrahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TetrahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_TetrahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_TetrahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_TetrahedronElement::H1_TetrahedronElement(int const,int const)\n" - " mfem::H1_TetrahedronElement::H1_TetrahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TetrahedronElement *arg1 = (mfem::H1_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TetrahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TetrahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::H1_TetrahedronElement const *)arg1)->CalcShape((mfem::IntegrationPoint const &)*arg2,*arg3); + ((mfem::H1_TetrahedronElement const *)arg1)->CalcDShape((mfem::IntegrationPoint const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -32868,7 +33069,7 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_TetrahedronElement *arg1 = (mfem::H1_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -32879,94 +33080,38 @@ SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"ddshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_TetrahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_TetrahedronElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::H1_TetrahedronElement const *)arg1)->CalcDShape((mfem::IntegrationPoint const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_H1_TetrahedronElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::H1_TetrahedronElement *arg1 = (mfem::H1_TetrahedronElement *) 0 ; - mfem::IntegrationPoint *arg2 = 0 ; - mfem::DenseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "H1_TetrahedronElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_TetrahedronElement, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "1"" of type '" "mfem::H1_TetrahedronElement const *""'"); - } - arg1 = reinterpret_cast< mfem::H1_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_TetrahedronElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - { - try { - ((mfem::H1_TetrahedronElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); + ((mfem::H1_TetrahedronElement const *)arg1)->CalcHessian((mfem::IntegrationPoint const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -33041,19 +33186,21 @@ SWIGINTERN PyObject *H1_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -33521,19 +33668,21 @@ SWIGINTERN PyObject *H1Pos_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -34029,66 +34178,35 @@ SWIGINTERN PyObject *H1Pos_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1_WedgeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_H1_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::H1_WedgeElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_H1_WedgeElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::H1_WedgeElement *)new mfem::H1_WedgeElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__H1_WedgeElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_H1_WedgeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::H1_WedgeElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::H1_WedgeElement *)new mfem::H1_WedgeElement(arg1); + result = (mfem::H1_WedgeElement *)new mfem::H1_WedgeElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -34112,63 +34230,7 @@ SWIGINTERN PyObject *_wrap_new_H1_WedgeElement__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_H1_WedgeElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_H1_WedgeElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_WedgeElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_H1_WedgeElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_H1_WedgeElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::H1_WedgeElement::H1_WedgeElement(int const,int const)\n" - " mfem::H1_WedgeElement::H1_WedgeElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_WedgeElement *arg1 = (mfem::H1_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34179,15 +34241,20 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::H1_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34195,7 +34262,7 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34229,7 +34296,7 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1_WedgeElement *arg1 = (mfem::H1_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34240,15 +34307,20 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34256,7 +34328,7 @@ SWIGINTERN PyObject *_wrap_H1_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -34587,19 +34659,21 @@ SWIGINTERN PyObject *BiCubic3DFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::H1Pos_WedgeElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_H1Pos_WedgeElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -34627,7 +34701,7 @@ SWIGINTERN PyObject *_wrap_new_H1Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_WedgeElement *arg1 = (mfem::H1Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34638,15 +34712,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::H1Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34654,7 +34733,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -34688,7 +34767,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1Pos_WedgeElement *arg1 = (mfem::H1Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34699,15 +34778,20 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1Pos_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1Pos_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::H1Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::H1Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34715,7 +34799,7 @@ SWIGINTERN PyObject *_wrap_H1Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1Pos_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -34800,66 +34884,35 @@ SWIGINTERN PyObject *H1Pos_WedgeElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_SegmentElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_SegmentElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::L2_SegmentElement *)new mfem::L2_SegmentElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_SegmentElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_SegmentElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_SegmentElement *)new mfem::L2_SegmentElement(arg1); + result = (mfem::L2_SegmentElement *)new mfem::L2_SegmentElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -34883,63 +34936,7 @@ SWIGINTERN PyObject *_wrap_new_L2_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_L2_SegmentElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_SegmentElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_SegmentElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_SegmentElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_SegmentElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_SegmentElement::L2_SegmentElement(int const,int const)\n" - " mfem::L2_SegmentElement::L2_SegmentElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_SegmentElement *arg1 = (mfem::L2_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -34950,15 +34947,20 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -34966,7 +34968,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35000,7 +35002,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_SegmentElement *arg1 = (mfem::L2_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35011,15 +35013,20 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35027,7 +35034,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -35061,7 +35068,7 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_SegmentElement *arg1 = (mfem::L2_SegmentElement *) 0 ; int arg2 ; @@ -35070,21 +35077,26 @@ SWIGINTERN PyObject *_wrap_L2_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35169,19 +35181,21 @@ SWIGINTERN PyObject *L2_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_SegmentElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_SegmentElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -35209,7 +35223,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_SegmentElement(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_SegmentElement *arg1 = (mfem::L2Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35220,15 +35234,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35236,7 +35255,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35270,7 +35289,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_SegmentElement *arg1 = (mfem::L2Pos_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35281,15 +35300,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_SegmentElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_SegmentElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35297,7 +35321,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_SegmentElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -35331,7 +35355,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_SegmentElement *arg1 = (mfem::L2Pos_SegmentElement *) 0 ; int arg2 ; @@ -35340,21 +35364,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_SegmentElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_SegmentElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_SegmentElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_SegmentElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_SegmentElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_SegmentElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35439,66 +35468,35 @@ SWIGINTERN PyObject *L2Pos_SegmentElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_QuadrilateralElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_QuadrilateralElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::L2_QuadrilateralElement *)new mfem::L2_QuadrilateralElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_QuadrilateralElement *)new mfem::L2_QuadrilateralElement(arg1); + result = (mfem::L2_QuadrilateralElement *)new mfem::L2_QuadrilateralElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -35522,63 +35520,7 @@ SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_L2_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_QuadrilateralElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_QuadrilateralElement::L2_QuadrilateralElement(int const,int const)\n" - " mfem::L2_QuadrilateralElement::L2_QuadrilateralElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35589,15 +35531,20 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35605,7 +35552,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35639,7 +35586,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35650,15 +35597,20 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35666,7 +35618,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -35700,7 +35652,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; int arg2 ; @@ -35709,21 +35661,26 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35757,7 +35714,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectDelta(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_QuadrilateralElement *arg1 = (mfem::L2_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -35771,15 +35728,21 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_QuadrilateralElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:L2_QuadrilateralElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "1"" of type '" "mfem::L2_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -35787,7 +35750,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -35795,7 +35758,7 @@ SWIGINTERN PyObject *_wrap_L2_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2_QuadrilateralElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -35880,19 +35843,21 @@ SWIGINTERN PyObject *L2_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_QuadrilateralElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_QuadrilateralElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -35920,7 +35885,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_QuadrilateralElement(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_QuadrilateralElement *arg1 = (mfem::L2Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35931,15 +35896,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_QuadrilateralElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_QuadrilateralElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -35947,7 +35917,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_QuadrilateralElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -35981,7 +35951,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_QuadrilateralElement *arg1 = (mfem::L2Pos_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -35992,15 +35962,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_QuadrilateralElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_QuadrilateralElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -36008,7 +35983,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_QuadrilateralElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -36042,7 +36017,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_CalcDShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_QuadrilateralElement *arg1 = (mfem::L2Pos_QuadrilateralElement *) 0 ; int arg2 ; @@ -36051,21 +36026,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_QuadrilateralElement_ProjectDelta(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_QuadrilateralElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_QuadrilateralElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_QuadrilateralElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_QuadrilateralElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_QuadrilateralElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -36150,66 +36130,35 @@ SWIGINTERN PyObject *L2Pos_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_HexahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_HexahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::L2_HexahedronElement *)new mfem::L2_HexahedronElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_HexahedronElement *)new mfem::L2_HexahedronElement(arg1); + result = (mfem::L2_HexahedronElement *)new mfem::L2_HexahedronElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -36233,63 +36182,7 @@ SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_L2_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_HexahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_HexahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_HexahedronElement::L2_HexahedronElement(int const,int const)\n" - " mfem::L2_HexahedronElement::L2_HexahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_HexahedronElement *arg1 = (mfem::L2_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -36300,15 +36193,20 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -36316,7 +36214,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -36350,7 +36248,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_HexahedronElement *arg1 = (mfem::L2_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -36361,15 +36259,20 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -36377,7 +36280,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -36411,7 +36314,7 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_HexahedronElement *arg1 = (mfem::L2_HexahedronElement *) 0 ; int arg2 ; @@ -36420,21 +36323,26 @@ SWIGINTERN PyObject *_wrap_L2_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -36519,19 +36427,21 @@ SWIGINTERN PyObject *L2_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_HexahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_HexahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -36559,7 +36469,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_HexahedronElement(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_HexahedronElement *arg1 = (mfem::L2Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -36570,15 +36480,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_HexahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_HexahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -36586,7 +36501,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_HexahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -36620,7 +36535,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_HexahedronElement *arg1 = (mfem::L2Pos_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -36631,15 +36546,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_HexahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_HexahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -36647,7 +36567,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_HexahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -36681,7 +36601,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_CalcDShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_HexahedronElement *arg1 = (mfem::L2Pos_HexahedronElement *) 0 ; int arg2 ; @@ -36690,21 +36610,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_HexahedronElement_ProjectDelta(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_HexahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_HexahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_HexahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_HexahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_HexahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -36789,66 +36714,35 @@ SWIGINTERN PyObject *L2Pos_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_TriangleElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_TriangleElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_TriangleElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::L2_TriangleElement *)new mfem::L2_TriangleElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_TriangleElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_TriangleElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::L2_TriangleElement *)new mfem::L2_TriangleElement(arg1); + result = (mfem::L2_TriangleElement *)new mfem::L2_TriangleElement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -36872,63 +36766,7 @@ SWIGINTERN PyObject *_wrap_new_L2_TriangleElement__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_L2_TriangleElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_TriangleElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TriangleElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TriangleElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_TriangleElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_TriangleElement::L2_TriangleElement(int const,int const)\n" - " mfem::L2_TriangleElement::L2_TriangleElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -36939,15 +36777,20 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TriangleElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -36955,7 +36798,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -36989,7 +36832,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37000,15 +36843,20 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TriangleElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37016,7 +36864,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -37050,7 +36898,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; int arg2 ; @@ -37059,21 +36907,26 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TriangleElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -37107,7 +36960,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TriangleElement *arg1 = (mfem::L2_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -37121,15 +36974,21 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TriangleElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:L2_TriangleElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "1"" of type '" "mfem::L2_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -37137,7 +36996,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -37145,7 +37004,7 @@ SWIGINTERN PyObject *_wrap_L2_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "L2_TriangleElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -37230,19 +37089,21 @@ SWIGINTERN PyObject *L2_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -37270,7 +37131,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_TriangleElement(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TriangleElement *arg1 = (mfem::L2Pos_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37281,15 +37142,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TriangleElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TriangleElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37297,7 +37163,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TriangleElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -37331,7 +37197,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TriangleElement *arg1 = (mfem::L2Pos_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37342,15 +37208,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TriangleElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TriangleElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37358,7 +37229,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TriangleElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -37392,7 +37263,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TriangleElement *arg1 = (mfem::L2Pos_TriangleElement *) 0 ; int arg2 ; @@ -37401,21 +37272,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_TriangleElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TriangleElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TriangleElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TriangleElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TriangleElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TriangleElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -37500,24 +37376,31 @@ SWIGINTERN PyObject *L2Pos_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_TetrahedronElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_TetrahedronElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -37545,101 +37428,7 @@ SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_TetrahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::L2_TetrahedronElement *)new mfem::L2_TetrahedronElement(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_TetrahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_TetrahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_TetrahedronElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TetrahedronElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_TetrahedronElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_TetrahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_TetrahedronElement::L2_TetrahedronElement(int const,int const)\n" - " mfem::L2_TetrahedronElement::L2_TetrahedronElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TetrahedronElement *arg1 = (mfem::L2_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37650,15 +37439,20 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TetrahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TetrahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37666,7 +37460,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -37700,7 +37494,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TetrahedronElement *arg1 = (mfem::L2_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37711,15 +37505,20 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TetrahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TetrahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37727,7 +37526,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -37761,7 +37560,7 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_TetrahedronElement *arg1 = (mfem::L2_TetrahedronElement *) 0 ; int arg2 ; @@ -37770,21 +37569,26 @@ SWIGINTERN PyObject *_wrap_L2_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_TetrahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_TetrahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_TetrahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_TetrahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_TetrahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -37869,19 +37673,21 @@ SWIGINTERN PyObject *L2_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -37909,7 +37715,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_TetrahedronElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TetrahedronElement *arg1 = (mfem::L2Pos_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37920,15 +37726,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TetrahedronElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TetrahedronElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37936,7 +37747,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TetrahedronElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -37970,7 +37781,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TetrahedronElement *arg1 = (mfem::L2Pos_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -37981,15 +37792,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TetrahedronElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TetrahedronElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -37997,7 +37813,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TetrahedronElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -38031,7 +37847,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_CalcDShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_ProjectDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_TetrahedronElement *arg1 = (mfem::L2Pos_TetrahedronElement *) 0 ; int arg2 ; @@ -38040,21 +37856,26 @@ SWIGINTERN PyObject *_wrap_L2Pos_TetrahedronElement_ProjectDelta(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertex", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_TetrahedronElement_ProjectDelta", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_TetrahedronElement_ProjectDelta", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_TetrahedronElement_ProjectDelta" "', argument " "1"" of type '" "mfem::L2Pos_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_TetrahedronElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_TetrahedronElement_ProjectDelta" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -38139,24 +37960,31 @@ SWIGINTERN PyObject *L2Pos_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2_WedgeElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"btype", NULL + }; mfem::L2_WedgeElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_L2_WedgeElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -38184,101 +38012,7 @@ SWIGINTERN PyObject *_wrap_new_L2_WedgeElement__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_L2_WedgeElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::L2_WedgeElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::L2_WedgeElement *)new mfem::L2_WedgeElement(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2_WedgeElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2_WedgeElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2_WedgeElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_WedgeElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_L2_WedgeElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2_WedgeElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2_WedgeElement::L2_WedgeElement(int const,int const)\n" - " mfem::L2_WedgeElement::L2_WedgeElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_WedgeElement *arg1 = (mfem::L2_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -38289,15 +38023,20 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::L2_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -38305,7 +38044,7 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -38339,7 +38078,7 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2_WedgeElement *arg1 = (mfem::L2_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -38350,15 +38089,20 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -38366,7 +38110,7 @@ SWIGINTERN PyObject *_wrap_L2_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -38533,19 +38277,21 @@ SWIGINTERN PyObject *P0WedgeFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::L2Pos_WedgeElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2Pos_WedgeElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -38573,7 +38319,7 @@ SWIGINTERN PyObject *_wrap_new_L2Pos_WedgeElement(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_WedgeElement *arg1 = (mfem::L2Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -38584,15 +38330,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_WedgeElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_WedgeElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "1"" of type '" "mfem::L2Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -38600,7 +38351,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_WedgeElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -38634,7 +38385,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcShape(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2Pos_WedgeElement *arg1 = (mfem::L2Pos_WedgeElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -38645,15 +38396,20 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2Pos_WedgeElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2Pos_WedgeElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2Pos_WedgeElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "1"" of type '" "mfem::L2Pos_WedgeElement const *""'"); } arg1 = reinterpret_cast< mfem::L2Pos_WedgeElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -38661,7 +38417,7 @@ SWIGINTERN PyObject *_wrap_L2Pos_WedgeElement_CalcDShape(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2Pos_WedgeElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -38746,118 +38502,45 @@ SWIGINTERN PyObject *L2Pos_WedgeElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::RT_QuadrilateralElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_RT_QuadrilateralElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::RT_QuadrilateralElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::RT_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1); + result = (mfem::RT_QuadrilateralElement *)new mfem::RT_QuadrilateralElement(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -38881,97 +38564,6 @@ SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_RT_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_QuadrilateralElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_QuadrilateralElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RT_QuadrilateralElement::RT_QuadrilateralElement(int const,int const,int const)\n" - " mfem::RT_QuadrilateralElement::RT_QuadrilateralElement(int const,int const)\n" - " mfem::RT_QuadrilateralElement::RT_QuadrilateralElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; @@ -39147,7 +38739,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcVShape(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -39158,15 +38750,20 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_QuadrilateralElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -39174,7 +38771,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -39208,7 +38805,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_CalcDivShape(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -39219,15 +38816,20 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_QuadrilateralElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -39235,7 +38837,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -39269,7 +38871,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalInterpolation(PyObjec } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -39280,15 +38882,20 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_QuadrilateralElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -39296,7 +38903,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -39330,7 +38937,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetLocalRestriction(PyObject } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -39344,15 +38951,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -39360,7 +38973,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -39368,7 +38981,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -39686,7 +39299,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_Project__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -39700,15 +39313,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -39716,7 +39335,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -39724,7 +39343,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -39968,7 +39587,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_Project(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -39982,15 +39601,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -39998,7 +39623,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -40006,7 +39631,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -40040,7 +39665,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_QuadrilateralElement *arg1 = (mfem::RT_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -40054,15 +39679,21 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_QuadrilateralElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_QuadrilateralElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -40070,7 +39701,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -40078,7 +39709,7 @@ SWIGINTERN PyObject *_wrap_RT_QuadrilateralElement_ProjectCurl(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_QuadrilateralElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -40163,118 +39794,45 @@ SWIGINTERN PyObject *RT_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::RT_HexahedronElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_RT_HexahedronElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::RT_HexahedronElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RT_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::RT_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1); + result = (mfem::RT_HexahedronElement *)new mfem::RT_HexahedronElement(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -40298,97 +39856,6 @@ SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement__SWIG_2(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_RT_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RT_HexahedronElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_HexahedronElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_HexahedronElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RT_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RT_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RT_HexahedronElement::RT_HexahedronElement(int const,int const,int const)\n" - " mfem::RT_HexahedronElement::RT_HexahedronElement(int const,int const)\n" - " mfem::RT_HexahedronElement::RT_HexahedronElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; @@ -40564,7 +40031,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -40575,15 +40042,20 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_HexahedronElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -40591,7 +40063,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -40625,7 +40097,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_CalcDivShape(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -40636,15 +40108,20 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_HexahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -40652,7 +40129,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -40686,7 +40163,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalInterpolation(PyObject * } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -40697,15 +40174,20 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_HexahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -40713,7 +40195,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -40747,7 +40229,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetLocalRestriction(PyObject *SW } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -40761,15 +40243,21 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_HexahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -40777,7 +40265,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -40785,7 +40273,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_HexahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -41103,7 +40591,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_Project__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -41117,15 +40605,21 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_HexahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -41133,7 +40627,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -41141,7 +40635,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_HexahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -41385,7 +40879,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_Project(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_HexahedronElement *arg1 = (mfem::RT_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -41399,15 +40893,21 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_HexahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_HexahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -41415,7 +40915,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -41423,7 +40923,7 @@ SWIGINTERN PyObject *_wrap_RT_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_HexahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -41508,19 +41008,21 @@ SWIGINTERN PyObject *RT_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RT_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::RT_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_RT_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -41723,7 +41225,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcVShape(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -41734,15 +41236,20 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TriangleElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -41750,7 +41257,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -41784,7 +41291,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_CalcDivShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -41795,15 +41302,20 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TriangleElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -41811,7 +41323,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -41845,7 +41357,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalInterpolation(PyObject *SW } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -41856,15 +41368,20 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TriangleElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -41872,7 +41389,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -41906,7 +41423,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetLocalRestriction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -41920,15 +41437,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -41936,7 +41459,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -41944,7 +41467,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -42262,7 +41785,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_Project__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -42276,15 +41799,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -42292,7 +41821,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -42300,7 +41829,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -42544,7 +42073,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_Project(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -42558,15 +42087,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -42574,7 +42109,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -42582,7 +42117,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -42616,7 +42151,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TriangleElement *arg1 = (mfem::RT_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -42630,15 +42165,21 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TriangleElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TriangleElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -42646,7 +42187,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -42654,7 +42195,7 @@ SWIGINTERN PyObject *_wrap_RT_TriangleElement_ProjectCurl(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TriangleElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -42739,19 +42280,21 @@ SWIGINTERN PyObject *RT_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RT_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RT_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::RT_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_RT_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -42954,7 +42497,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcVShape(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -42965,15 +42508,20 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"divshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_CalcDivShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TetrahedronElement_CalcDivShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -42981,7 +42529,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_CalcDivShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -43015,7 +42563,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_CalcDivShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -43026,15 +42574,20 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TetrahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -43042,7 +42595,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -43076,7 +42629,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -43087,15 +42640,20 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RT_TetrahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -43103,7 +42661,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -43137,7 +42695,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetLocalRestriction(PyObject *S } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -43151,15 +42709,21 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TetrahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -43167,7 +42731,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -43175,7 +42739,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TetrahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -43493,7 +43057,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_Project__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -43507,15 +43071,21 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TetrahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -43523,7 +43093,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -43531,7 +43101,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -43775,7 +43345,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_Project(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RT_TetrahedronElement *arg1 = (mfem::RT_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -43789,15 +43359,21 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RT_TetrahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RT_TetrahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RT_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::RT_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::RT_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -43805,7 +43381,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -43813,7 +43389,7 @@ SWIGINTERN PyObject *_wrap_RT_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "RT_TetrahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -43898,118 +43474,45 @@ SWIGINTERN PyObject *RT_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::ND_HexahedronElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_ND_HexahedronElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_HexahedronElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_HexahedronElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::ND_HexahedronElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1); + result = (mfem::ND_HexahedronElement *)new mfem::ND_HexahedronElement(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -44033,97 +43536,6 @@ SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement__SWIG_2(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_ND_HexahedronElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_HexahedronElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_HexahedronElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_HexahedronElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_HexahedronElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_HexahedronElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_HexahedronElement::ND_HexahedronElement(int const,int const,int const)\n" - " mfem::ND_HexahedronElement::ND_HexahedronElement(int const,int const)\n" - " mfem::ND_HexahedronElement::ND_HexahedronElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; @@ -44299,7 +43711,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcVShape(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -44310,15 +43722,20 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_HexahedronElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -44326,7 +43743,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -44360,7 +43777,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_CalcCurlShape(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -44371,15 +43788,20 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_HexahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -44387,7 +43809,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -44421,7 +43843,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalInterpolation(PyObject * } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -44432,15 +43854,20 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_HexahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -44448,7 +43875,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -44482,7 +43909,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetLocalRestriction(PyObject *SW } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -44496,15 +43923,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -44512,7 +43945,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -44520,7 +43953,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_GetTransferMatrix(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -44838,7 +44271,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_Project__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -44852,15 +44285,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -44868,7 +44307,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -44876,7 +44315,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectMatrixCoefficient(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -45120,7 +44559,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_Project(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -45134,15 +44573,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -45150,7 +44595,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -45158,7 +44603,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -45192,7 +44637,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectGrad(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_HexahedronElement *arg1 = (mfem::ND_HexahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -45206,15 +44651,21 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_HexahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_HexahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_HexahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::ND_HexahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_HexahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -45222,7 +44673,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -45230,7 +44681,7 @@ SWIGINTERN PyObject *_wrap_ND_HexahedronElement_ProjectCurl(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_HexahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -45315,118 +44766,45 @@ SWIGINTERN PyObject *ND_HexahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; - int arg3 ; + int arg2 = (int) (int)mfem::BasisType::GaussLobatto ; + int arg3 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"cb_type", (char *)"ob_type", NULL + }; mfem::ND_QuadrilateralElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_ND_QuadrilateralElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - try { - result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::ND_QuadrilateralElement *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_QuadrilateralElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::ND_QuadrilateralElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1); + result = (mfem::ND_QuadrilateralElement *)new mfem::ND_QuadrilateralElement(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -45450,97 +44828,6 @@ SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_ND_QuadrilateralElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_QuadrilateralElement", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_QuadrilateralElement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_QuadrilateralElement__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_QuadrilateralElement__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_QuadrilateralElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_QuadrilateralElement::ND_QuadrilateralElement(int const,int const,int const)\n" - " mfem::ND_QuadrilateralElement::ND_QuadrilateralElement(int const,int const)\n" - " mfem::ND_QuadrilateralElement::ND_QuadrilateralElement(int const)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcVShape__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; @@ -45716,7 +45003,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcVShape(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -45727,15 +45014,20 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_QuadrilateralElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -45743,7 +45035,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -45777,7 +45069,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_CalcCurlShape(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -45788,15 +45080,20 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_QuadrilateralElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -45804,7 +45101,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -45838,7 +45135,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalInterpolation(PyObjec } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -45849,15 +45146,20 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_QuadrilateralElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -45865,7 +45167,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -45899,7 +45201,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetLocalRestriction(PyObject } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -45913,15 +45215,21 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *S int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_QuadrilateralElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -45929,7 +45237,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -45937,7 +45245,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_GetTransferMatrix(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_QuadrilateralElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -46255,7 +45563,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_Project__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -46269,15 +45577,21 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyOb int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_QuadrilateralElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -46285,7 +45599,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -46293,7 +45607,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_QuadrilateralElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -46537,7 +45851,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_Project(PyObject *self, PyObj } -SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_QuadrilateralElement *arg1 = (mfem::ND_QuadrilateralElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -46551,15 +45865,21 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_QuadrilateralElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_QuadrilateralElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_QuadrilateralElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_QuadrilateralElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_QuadrilateralElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -46567,7 +45887,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -46575,7 +45895,7 @@ SWIGINTERN PyObject *_wrap_ND_QuadrilateralElement_ProjectGrad(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_QuadrilateralElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -46660,19 +45980,21 @@ SWIGINTERN PyObject *ND_QuadrilateralElement_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ND_TetrahedronElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::ND_TetrahedronElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ND_TetrahedronElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -46875,7 +46197,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcVShape(PyObject *self, PyOb } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -46886,15 +46208,20 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TetrahedronElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -46902,7 +46229,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -46936,7 +46263,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_CalcCurlShape(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -46947,15 +46274,20 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TetrahedronElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -46963,7 +46295,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -46997,7 +46329,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalInterpolation(PyObject } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -47008,15 +46340,20 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *S int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TetrahedronElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -47024,7 +46361,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -47058,7 +46395,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetLocalRestriction(PyObject *S } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -47072,15 +46409,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWI int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -47088,7 +46431,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -47096,7 +46439,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_GetTransferMatrix(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -47414,7 +46757,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_Project__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -47428,15 +46771,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObje int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -47444,7 +46793,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -47452,7 +46801,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient(PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -47696,7 +47045,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_Project(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -47710,15 +47059,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -47726,7 +47081,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -47734,7 +47089,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -47768,7 +47123,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectGrad(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TetrahedronElement *arg1 = (mfem::ND_TetrahedronElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -47782,15 +47137,21 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"curl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TetrahedronElement_ProjectCurl", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TetrahedronElement_ProjectCurl", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TetrahedronElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "1"" of type '" "mfem::ND_TetrahedronElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TetrahedronElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -47798,7 +47159,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -47806,7 +47167,7 @@ SWIGINTERN PyObject *_wrap_ND_TetrahedronElement_ProjectCurl(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TetrahedronElement_ProjectCurl" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -47891,19 +47252,21 @@ SWIGINTERN PyObject *ND_TetrahedronElement_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ND_TriangleElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::ND_TriangleElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ND_TriangleElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -48106,7 +47469,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcVShape(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -48117,15 +47480,20 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"curl_shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_CalcCurlShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TriangleElement_CalcCurlShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -48133,7 +47501,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_CalcCurlShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -48167,7 +47535,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_CalcCurlShape(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -48178,15 +47546,20 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TriangleElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -48194,7 +47567,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -48228,7 +47601,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalInterpolation(PyObject *SW } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -48239,15 +47612,20 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_TriangleElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -48255,7 +47633,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -48289,7 +47667,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetLocalRestriction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -48303,15 +47681,21 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUN int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TriangleElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -48319,7 +47703,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -48327,7 +47711,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_GetTransferMatrix(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TriangleElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -48645,7 +48029,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_Project__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -48659,15 +48043,21 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TriangleElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -48675,7 +48065,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -48683,7 +48073,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectMatrixCoefficient(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TriangleElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -48927,7 +48317,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_Project(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_TriangleElement *arg1 = (mfem::ND_TriangleElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -48941,15 +48331,21 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_TriangleElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_TriangleElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_TriangleElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_TriangleElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_TriangleElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -48957,7 +48353,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -48965,7 +48361,7 @@ SWIGINTERN PyObject *_wrap_ND_TriangleElement_ProjectGrad(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_TriangleElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -49050,24 +48446,31 @@ SWIGINTERN PyObject *ND_TriangleElement_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ND_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_ND_SegmentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) (int)mfem::BasisType::GaussLegendre ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"ob_type", NULL + }; mfem::ND_SegmentElement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_ND_SegmentElement", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -49095,101 +48498,7 @@ SWIGINTERN PyObject *_wrap_new_ND_SegmentElement__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_ND_SegmentElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::ND_SegmentElement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::ND_SegmentElement *)new mfem::ND_SegmentElement(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ND_SegmentElement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_ND_SegmentElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ND_SegmentElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_SegmentElement__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_ND_SegmentElement__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ND_SegmentElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ND_SegmentElement::ND_SegmentElement(int const,int const)\n" - " mfem::ND_SegmentElement::ND_SegmentElement(int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -49200,15 +48509,20 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_SegmentElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_CalcShape" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -49216,7 +48530,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcShape(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -49425,7 +48739,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_CalcVShape(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -49436,15 +48750,20 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_GetLocalInterpolation", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_SegmentElement_GetLocalInterpolation", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -49452,7 +48771,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_GetLocalInterpolation" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -49486,7 +48805,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalInterpolation(PyObject *SWI } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -49497,15 +48816,20 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Trans", (char *)"R", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_GetLocalRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ND_SegmentElement_GetLocalRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -49513,7 +48837,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_GetLocalRestriction" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -49547,7 +48871,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetLocalRestriction(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -49561,15 +48885,21 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"I", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_GetTransferMatrix", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_SegmentElement_GetTransferMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -49577,7 +48907,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -49585,7 +48915,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_GetTransferMatrix(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_SegmentElement_GetTransferMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -49903,7 +49233,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_Project__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::MatrixCoefficient *arg2 = 0 ; @@ -49917,15 +49247,21 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", (char *)"T", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_ProjectMatrixCoefficient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_SegmentElement_ProjectMatrixCoefficient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MatrixCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } @@ -49933,7 +49269,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "2"" of type '" "mfem::MatrixCoefficient &""'"); } arg2 = reinterpret_cast< mfem::MatrixCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -49941,7 +49277,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectMatrixCoefficient(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_SegmentElement_ProjectMatrixCoefficient" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -50185,7 +49521,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_Project(PyObject *self, PyObject *a } -SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ND_SegmentElement *arg1 = (mfem::ND_SegmentElement *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -50199,15 +49535,21 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ND_SegmentElement_ProjectGrad", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ND_SegmentElement_ProjectGrad", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ND_SegmentElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "1"" of type '" "mfem::ND_SegmentElement const *""'"); } arg1 = reinterpret_cast< mfem::ND_SegmentElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -50215,7 +49557,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -50223,7 +49565,7 @@ SWIGINTERN PyObject *_wrap_ND_SegmentElement_ProjectGrad(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ND_SegmentElement_ProjectGrad" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -50348,7 +49690,7 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_Reset(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetIJK(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFiniteElement *arg1 = (mfem::NURBSFiniteElement *) 0 ; int *arg2 = (int *) 0 ; @@ -50356,15 +49698,19 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetIJK(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"IJK", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFiniteElement_SetIJK", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFiniteElement_SetIJK", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFiniteElement_SetIJK" "', argument " "1"" of type '" "mfem::NURBSFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBSFiniteElement_SetIJK" "', argument " "2"" of type '" "int const *""'"); } @@ -50436,25 +49782,29 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_GetPatch(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetPatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetPatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFiniteElement *arg1 = (mfem::NURBSFiniteElement *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFiniteElement_SetPatch", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFiniteElement_SetPatch", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFiniteElement_SetPatch" "', argument " "1"" of type '" "mfem::NURBSFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -50523,25 +49873,29 @@ SWIGINTERN PyObject *_wrap_NURBSFiniteElement_GetElement(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBSFiniteElement_SetElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBSFiniteElement *arg1 = (mfem::NURBSFiniteElement *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"e", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBSFiniteElement_SetElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NURBSFiniteElement_SetElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBSFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBSFiniteElement_SetElement" "', argument " "1"" of type '" "mfem::NURBSFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBSFiniteElement * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -50738,19 +50092,21 @@ SWIGINTERN PyObject *NURBSFiniteElement_swigregister(PyObject *SWIGUNUSEDPARM(se return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_NURBS1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_NURBS1DFiniteElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"p", NULL + }; mfem::NURBS1DFiniteElement *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_NURBS1DFiniteElement", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -50818,7 +50174,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_SetOrder(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -50829,15 +50185,20 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS1DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -50845,7 +50206,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -50879,7 +50240,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -50890,15 +50251,20 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS1DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -50906,7 +50272,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -50940,7 +50306,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS1DFiniteElement *arg1 = (mfem::NURBS1DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -50951,15 +50317,20 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS1DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS1DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS1DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS1DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS1DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -50967,7 +50338,7 @@ SWIGINTERN PyObject *_wrap_NURBS1DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS1DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -51231,7 +50602,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_SetOrder(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -51242,15 +50613,20 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS2DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -51258,7 +50634,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -51292,7 +50668,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -51303,15 +50679,20 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS2DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -51319,7 +50700,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -51353,7 +50734,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS2DFiniteElement *arg1 = (mfem::NURBS2DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -51364,15 +50745,20 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS2DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS2DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS2DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS2DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS2DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -51380,7 +50766,7 @@ SWIGINTERN PyObject *_wrap_NURBS2DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS2DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -51661,7 +51047,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_SetOrder(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -51672,15 +51058,20 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"shape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS3DFiniteElement_CalcShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -51688,7 +51079,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcShape" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -51722,7 +51113,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcShape(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -51733,15 +51124,20 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"dshape", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcDShape", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS3DFiniteElement_CalcDShape", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -51749,7 +51145,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcDShape" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -51783,7 +51179,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcDShape(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NURBS3DFiniteElement *arg1 = (mfem::NURBS3DFiniteElement *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -51794,15 +51190,20 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ip", (char *)"hessian", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NURBS3DFiniteElement_CalcHessian", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NURBS3DFiniteElement_CalcHessian", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NURBS3DFiniteElement, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "1"" of type '" "mfem::NURBS3DFiniteElement const *""'"); } arg1 = reinterpret_cast< mfem::NURBS3DFiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -51810,7 +51211,7 @@ SWIGINTERN PyObject *_wrap_NURBS3DFiniteElement_CalcHessian(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationPoint * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NURBS3DFiniteElement_CalcHessian" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -51898,13 +51299,13 @@ SWIGINTERN PyObject *NURBS3DFiniteElement_swiginit(PyObject *SWIGUNUSEDPARM(self static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "BasisType_Check", _wrap_BasisType_Check, METH_O, "BasisType_Check(int b_type) -> int"}, - { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "BasisType_CheckNodal(int b_type) -> int"}, - { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "BasisType_GetQuadrature1D(int b_type) -> int"}, - { "BasisType_GetNodalBasis", _wrap_BasisType_GetNodalBasis, METH_O, "BasisType_GetNodalBasis(int qpt_type) -> int"}, - { "BasisType_Name", _wrap_BasisType_Name, METH_O, "BasisType_Name(int b_type) -> char const *"}, - { "BasisType_GetChar", _wrap_BasisType_GetChar, METH_O, "BasisType_GetChar(int b_type) -> char"}, - { "BasisType_GetType", _wrap_BasisType_GetType, METH_O, "BasisType_GetType(char b_ident) -> int"}, + { "BasisType_Check", (PyCFunction)(void(*)(void))_wrap_BasisType_Check, METH_VARARGS|METH_KEYWORDS, "BasisType_Check(int b_type) -> int"}, + { "BasisType_CheckNodal", (PyCFunction)(void(*)(void))_wrap_BasisType_CheckNodal, METH_VARARGS|METH_KEYWORDS, "BasisType_CheckNodal(int b_type) -> int"}, + { "BasisType_GetQuadrature1D", (PyCFunction)(void(*)(void))_wrap_BasisType_GetQuadrature1D, METH_VARARGS|METH_KEYWORDS, "BasisType_GetQuadrature1D(int b_type) -> int"}, + { "BasisType_GetNodalBasis", (PyCFunction)(void(*)(void))_wrap_BasisType_GetNodalBasis, METH_VARARGS|METH_KEYWORDS, "BasisType_GetNodalBasis(int qpt_type) -> int"}, + { "BasisType_Name", (PyCFunction)(void(*)(void))_wrap_BasisType_Name, METH_VARARGS|METH_KEYWORDS, "BasisType_Name(int b_type) -> char const *"}, + { "BasisType_GetChar", (PyCFunction)(void(*)(void))_wrap_BasisType_GetChar, METH_VARARGS|METH_KEYWORDS, "BasisType_GetChar(int b_type) -> char"}, + { "BasisType_GetType", (PyCFunction)(void(*)(void))_wrap_BasisType_GetType, METH_VARARGS|METH_KEYWORDS, "BasisType_GetType(char b_ident) -> int"}, { "new_BasisType", _wrap_new_BasisType, METH_NOARGS, "new_BasisType() -> BasisType"}, { "delete_BasisType", _wrap_delete_BasisType, METH_O, "delete_BasisType(BasisType self)"}, { "BasisType_swigregister", BasisType_swigregister, METH_O, NULL}, @@ -51945,67 +51346,67 @@ static PyMethodDef SwigMethods[] = { { "FiniteElement_GetMapType", _wrap_FiniteElement_GetMapType, METH_O, "FiniteElement_GetMapType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivType", _wrap_FiniteElement_GetDerivType, METH_O, "FiniteElement_GetDerivType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivMapType", _wrap_FiniteElement_GetDerivMapType, METH_O, "FiniteElement_GetDerivMapType(FiniteElement self) -> int"}, - { "FiniteElement_CalcShape", _wrap_FiniteElement_CalcShape, METH_VARARGS, "FiniteElement_CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "FiniteElement_CalcPhysShape", _wrap_FiniteElement_CalcPhysShape, METH_VARARGS, "FiniteElement_CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, - { "FiniteElement_CalcDShape", _wrap_FiniteElement_CalcDShape, METH_VARARGS, "FiniteElement_CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "FiniteElement_CalcPhysDShape", _wrap_FiniteElement_CalcPhysDShape, METH_VARARGS, "FiniteElement_CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, + { "FiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "FiniteElement_CalcPhysShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, + { "FiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "FiniteElement_CalcPhysDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, { "FiniteElement_GetNodes", _wrap_FiniteElement_GetNodes, METH_O, "FiniteElement_GetNodes(FiniteElement self) -> IntegrationRule"}, { "FiniteElement_CalcVShape", _wrap_FiniteElement_CalcVShape, METH_VARARGS, "\n" "FiniteElement_CalcVShape(FiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "FiniteElement_CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "FiniteElement_CalcPhysVShape", _wrap_FiniteElement_CalcPhysVShape, METH_VARARGS, "FiniteElement_CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, - { "FiniteElement_CalcDivShape", _wrap_FiniteElement_CalcDivShape, METH_VARARGS, "FiniteElement_CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "FiniteElement_CalcPhysDivShape", _wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS, "FiniteElement_CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, - { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "FiniteElement_CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "FiniteElement_CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, - { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "FiniteElement_GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, - { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "FiniteElement_CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "FiniteElement_CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "FiniteElement_GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "FiniteElement_GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "FiniteElement_GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_ProjectMatrixCoefficient", _wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "FiniteElement_ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, - { "FiniteElement_ProjectDelta", _wrap_FiniteElement_ProjectDelta, METH_VARARGS, "FiniteElement_ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, + { "FiniteElement_CalcPhysVShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysVShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, + { "FiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "FiniteElement_CalcPhysDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, + { "FiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "FiniteElement_CalcPhysCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, + { "FiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "FiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysHessian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS|METH_KEYWORDS, "FiniteElement_CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "FiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "FiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, { "FiniteElement_Project", _wrap_FiniteElement_Project, METH_VARARGS, "\n" "FiniteElement_Project(FiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "FiniteElement_Project(FiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "FiniteElement_Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "FiniteElement_ProjectGrad", _wrap_FiniteElement_ProjectGrad, METH_VARARGS, "FiniteElement_ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "FiniteElement_ProjectCurl", _wrap_FiniteElement_ProjectCurl, METH_VARARGS, "FiniteElement_ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, - { "FiniteElement_ProjectDiv", _wrap_FiniteElement_ProjectDiv, METH_VARARGS, "FiniteElement_ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, - { "FiniteElement_GetDofToQuad", _wrap_FiniteElement_GetDofToQuad, METH_VARARGS, "FiniteElement_GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "FiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "FiniteElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "FiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "FiniteElement_ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "FiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "FiniteElement_GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_FiniteElement", _wrap_delete_FiniteElement, METH_O, "delete_FiniteElement(FiniteElement self)"}, - { "FiniteElement_IsClosedType", _wrap_FiniteElement_IsClosedType, METH_O, "FiniteElement_IsClosedType(int b_type) -> bool"}, - { "FiniteElement_IsOpenType", _wrap_FiniteElement_IsOpenType, METH_O, "FiniteElement_IsOpenType(int b_type) -> bool"}, - { "FiniteElement_VerifyClosed", _wrap_FiniteElement_VerifyClosed, METH_O, "FiniteElement_VerifyClosed(int b_type) -> int"}, - { "FiniteElement_VerifyOpen", _wrap_FiniteElement_VerifyOpen, METH_O, "FiniteElement_VerifyOpen(int b_type) -> int"}, - { "FiniteElement_VerifyNodal", _wrap_FiniteElement_VerifyNodal, METH_O, "FiniteElement_VerifyNodal(int b_type) -> int"}, + { "FiniteElement_IsClosedType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsClosedType, METH_VARARGS|METH_KEYWORDS, "FiniteElement_IsClosedType(int b_type) -> bool"}, + { "FiniteElement_IsOpenType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsOpenType, METH_VARARGS|METH_KEYWORDS, "FiniteElement_IsOpenType(int b_type) -> bool"}, + { "FiniteElement_VerifyClosed", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyClosed, METH_VARARGS|METH_KEYWORDS, "FiniteElement_VerifyClosed(int b_type) -> int"}, + { "FiniteElement_VerifyOpen", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyOpen, METH_VARARGS|METH_KEYWORDS, "FiniteElement_VerifyOpen(int b_type) -> int"}, + { "FiniteElement_VerifyNodal", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyNodal, METH_VARARGS|METH_KEYWORDS, "FiniteElement_VerifyNodal(int b_type) -> int"}, { "FiniteElement_swigregister", FiniteElement_swigregister, METH_O, NULL}, - { "ScalarFiniteElement_SetMapType", _wrap_ScalarFiniteElement_SetMapType, METH_VARARGS, "ScalarFiniteElement_SetMapType(ScalarFiniteElement self, int M)"}, - { "ScalarFiniteElement_NodalLocalInterpolation", _wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS, "ScalarFiniteElement_NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_ScalarLocalInterpolation", _wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS, "ScalarFiniteElement_ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_GetDofToQuad", _wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS, "ScalarFiniteElement_GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "ScalarFiniteElement_SetMapType", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_SetMapType, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_SetMapType(ScalarFiniteElement self, int M)"}, + { "ScalarFiniteElement_NodalLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_ScalarLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "ScalarFiniteElement_GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_ScalarFiniteElement", _wrap_delete_ScalarFiniteElement, METH_O, "delete_ScalarFiniteElement(ScalarFiniteElement self)"}, { "ScalarFiniteElement_swigregister", ScalarFiniteElement_swigregister, METH_O, NULL}, - { "NodalFiniteElement_GetLocalInterpolation", _wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS, "NodalFiniteElement_GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_GetLocalRestriction", _wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS, "NodalFiniteElement_GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "NodalFiniteElement_GetTransferMatrix", _wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS, "NodalFiniteElement_GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_ProjectMatrixCoefficient", _wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "NodalFiniteElement_ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "NodalFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "NodalFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "NodalFiniteElement_Project", _wrap_NodalFiniteElement_Project, METH_VARARGS, "\n" "NodalFiniteElement_Project(NodalFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "NodalFiniteElement_Project(NodalFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "NodalFiniteElement_Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "NodalFiniteElement_ProjectGrad", _wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS, "NodalFiniteElement_ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "NodalFiniteElement_ProjectDiv", _wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS, "NodalFiniteElement_ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "NodalFiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "NodalFiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "NodalFiniteElement_ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, { "delete_NodalFiniteElement", _wrap_delete_NodalFiniteElement, METH_O, "delete_NodalFiniteElement(NodalFiniteElement self)"}, { "NodalFiniteElement_swigregister", NodalFiniteElement_swigregister, METH_O, NULL}, - { "PositiveFiniteElement_GetLocalInterpolation", _wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS, "PositiveFiniteElement_GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "PositiveFiniteElement_GetTransferMatrix", _wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS, "PositiveFiniteElement_GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "PositiveFiniteElement_GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "PositiveFiniteElement_GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "PositiveFiniteElement_Project", _wrap_PositiveFiniteElement_Project, METH_VARARGS, "\n" "PositiveFiniteElement_Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "PositiveFiniteElement_Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52016,95 +51417,95 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_PositiveFiniteElement", _wrap_delete_PositiveFiniteElement, METH_O, "delete_PositiveFiniteElement(PositiveFiniteElement self)"}, { "PositiveFiniteElement_swigregister", PositiveFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorFiniteElement", _wrap_new_VectorFiniteElement, METH_VARARGS, "VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk)"}, + { "new_VectorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk) -> VectorFiniteElement"}, { "delete_VectorFiniteElement", _wrap_delete_VectorFiniteElement, METH_O, "delete_VectorFiniteElement(VectorFiniteElement self)"}, { "VectorFiniteElement_swigregister", VectorFiniteElement_swigregister, METH_O, NULL}, { "VectorFiniteElement_swiginit", VectorFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_PointFiniteElement", _wrap_new_PointFiniteElement, METH_NOARGS, "new_PointFiniteElement() -> PointFiniteElement"}, - { "PointFiniteElement_CalcShape", _wrap_PointFiniteElement_CalcShape, METH_VARARGS, "PointFiniteElement_CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "PointFiniteElement_CalcDShape", _wrap_PointFiniteElement_CalcDShape, METH_VARARGS, "PointFiniteElement_CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "PointFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "PointFiniteElement_CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "PointFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "PointFiniteElement_CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_PointFiniteElement", _wrap_delete_PointFiniteElement, METH_O, "delete_PointFiniteElement(PointFiniteElement self)"}, { "PointFiniteElement_swigregister", PointFiniteElement_swigregister, METH_O, NULL}, { "PointFiniteElement_swiginit", PointFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear1DFiniteElement", _wrap_new_Linear1DFiniteElement, METH_NOARGS, "new_Linear1DFiniteElement() -> Linear1DFiniteElement"}, - { "Linear1DFiniteElement_CalcShape", _wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS, "Linear1DFiniteElement_CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear1DFiniteElement_CalcDShape", _wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS, "Linear1DFiniteElement_CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Linear1DFiniteElement_CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Linear1DFiniteElement_CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Linear1DFiniteElement", _wrap_delete_Linear1DFiniteElement, METH_O, "delete_Linear1DFiniteElement(Linear1DFiniteElement self)"}, { "Linear1DFiniteElement_swigregister", Linear1DFiniteElement_swigregister, METH_O, NULL}, { "Linear1DFiniteElement_swiginit", Linear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear2DFiniteElement", _wrap_new_Linear2DFiniteElement, METH_NOARGS, "new_Linear2DFiniteElement() -> Linear2DFiniteElement"}, - { "Linear2DFiniteElement_CalcShape", _wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS, "Linear2DFiniteElement_CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear2DFiniteElement_CalcDShape", _wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS, "Linear2DFiniteElement_CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear2DFiniteElement_ProjectDelta", _wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS, "Linear2DFiniteElement_ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Linear2DFiniteElement_CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Linear2DFiniteElement_CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "Linear2DFiniteElement_ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Linear2DFiniteElement", _wrap_delete_Linear2DFiniteElement, METH_O, "delete_Linear2DFiniteElement(Linear2DFiniteElement self)"}, { "Linear2DFiniteElement_swigregister", Linear2DFiniteElement_swigregister, METH_O, NULL}, { "Linear2DFiniteElement_swiginit", Linear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiLinear2DFiniteElement", _wrap_new_BiLinear2DFiniteElement, METH_NOARGS, "new_BiLinear2DFiniteElement() -> BiLinear2DFiniteElement"}, - { "BiLinear2DFiniteElement_CalcShape", _wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS, "BiLinear2DFiniteElement_CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiLinear2DFiniteElement_CalcDShape", _wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "BiLinear2DFiniteElement_CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiLinear2DFiniteElement_CalcHessian", _wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS, "BiLinear2DFiniteElement_CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "BiLinear2DFiniteElement_ProjectDelta", _wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "BiLinear2DFiniteElement_ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiLinear2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "BiLinear2DFiniteElement_ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiLinear2DFiniteElement", _wrap_delete_BiLinear2DFiniteElement, METH_O, "delete_BiLinear2DFiniteElement(BiLinear2DFiniteElement self)"}, { "BiLinear2DFiniteElement_swigregister", BiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "BiLinear2DFiniteElement_swiginit", BiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussLinear2DFiniteElement", _wrap_new_GaussLinear2DFiniteElement, METH_NOARGS, "new_GaussLinear2DFiniteElement() -> GaussLinear2DFiniteElement"}, - { "GaussLinear2DFiniteElement_CalcShape", _wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS, "GaussLinear2DFiniteElement_CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussLinear2DFiniteElement_CalcDShape", _wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS, "GaussLinear2DFiniteElement_CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussLinear2DFiniteElement_ProjectDelta", _wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "GaussLinear2DFiniteElement_ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussLinear2DFiniteElement_CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussLinear2DFiniteElement_CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "GaussLinear2DFiniteElement_ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussLinear2DFiniteElement", _wrap_delete_GaussLinear2DFiniteElement, METH_O, "delete_GaussLinear2DFiniteElement(GaussLinear2DFiniteElement self)"}, { "GaussLinear2DFiniteElement_swigregister", GaussLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussLinear2DFiniteElement_swiginit", GaussLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiLinear2DFiniteElement", _wrap_new_GaussBiLinear2DFiniteElement, METH_NOARGS, "new_GaussBiLinear2DFiniteElement() -> GaussBiLinear2DFiniteElement"}, - { "GaussBiLinear2DFiniteElement_CalcShape", _wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "GaussBiLinear2DFiniteElement_CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiLinear2DFiniteElement_CalcDShape", _wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "GaussBiLinear2DFiniteElement_CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussBiLinear2DFiniteElement_ProjectDelta", _wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "GaussBiLinear2DFiniteElement_ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussBiLinear2DFiniteElement_CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussBiLinear2DFiniteElement_CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "GaussBiLinear2DFiniteElement_ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussBiLinear2DFiniteElement", _wrap_delete_GaussBiLinear2DFiniteElement, METH_O, "delete_GaussBiLinear2DFiniteElement(GaussBiLinear2DFiniteElement self)"}, { "GaussBiLinear2DFiniteElement_swigregister", GaussBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiLinear2DFiniteElement_swiginit", GaussBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFiniteElement", _wrap_new_P1OnQuadFiniteElement, METH_NOARGS, "new_P1OnQuadFiniteElement() -> P1OnQuadFiniteElement"}, - { "P1OnQuadFiniteElement_CalcShape", _wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS, "P1OnQuadFiniteElement_CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1OnQuadFiniteElement_CalcDShape", _wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS, "P1OnQuadFiniteElement_CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P1OnQuadFiniteElement_ProjectDelta", _wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS, "P1OnQuadFiniteElement_ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, + { "P1OnQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFiniteElement_CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1OnQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFiniteElement_CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1OnQuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P1OnQuadFiniteElement_ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P1OnQuadFiniteElement", _wrap_delete_P1OnQuadFiniteElement, METH_O, "delete_P1OnQuadFiniteElement(P1OnQuadFiniteElement self)"}, { "P1OnQuadFiniteElement_swigregister", P1OnQuadFiniteElement_swigregister, METH_O, NULL}, { "P1OnQuadFiniteElement_swiginit", P1OnQuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad1DFiniteElement", _wrap_new_Quad1DFiniteElement, METH_NOARGS, "new_Quad1DFiniteElement() -> Quad1DFiniteElement"}, - { "Quad1DFiniteElement_CalcShape", _wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS, "Quad1DFiniteElement_CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad1DFiniteElement_CalcDShape", _wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS, "Quad1DFiniteElement_CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Quad1DFiniteElement_CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Quad1DFiniteElement_CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quad1DFiniteElement", _wrap_delete_Quad1DFiniteElement, METH_O, "delete_Quad1DFiniteElement(Quad1DFiniteElement self)"}, { "Quad1DFiniteElement_swigregister", Quad1DFiniteElement_swigregister, METH_O, NULL}, { "Quad1DFiniteElement_swiginit", Quad1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_QuadPos1DFiniteElement", _wrap_new_QuadPos1DFiniteElement, METH_NOARGS, "new_QuadPos1DFiniteElement() -> QuadPos1DFiniteElement"}, - { "QuadPos1DFiniteElement_CalcShape", _wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS, "QuadPos1DFiniteElement_CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "QuadPos1DFiniteElement_CalcDShape", _wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS, "QuadPos1DFiniteElement_CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "QuadPos1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "QuadPos1DFiniteElement_CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "QuadPos1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "QuadPos1DFiniteElement_CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_QuadPos1DFiniteElement", _wrap_delete_QuadPos1DFiniteElement, METH_O, "delete_QuadPos1DFiniteElement(QuadPos1DFiniteElement self)"}, { "QuadPos1DFiniteElement_swigregister", QuadPos1DFiniteElement_swigregister, METH_O, NULL}, { "QuadPos1DFiniteElement_swiginit", QuadPos1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad2DFiniteElement", _wrap_new_Quad2DFiniteElement, METH_NOARGS, "new_Quad2DFiniteElement() -> Quad2DFiniteElement"}, - { "Quad2DFiniteElement_CalcShape", _wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS, "Quad2DFiniteElement_CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad2DFiniteElement_CalcDShape", _wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS, "Quad2DFiniteElement_CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Quad2DFiniteElement_CalcHessian", _wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS, "Quad2DFiniteElement_CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "Quad2DFiniteElement_ProjectDelta", _wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS, "Quad2DFiniteElement_ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, + { "Quad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Quad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "Quad2DFiniteElement_ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Quad2DFiniteElement", _wrap_delete_Quad2DFiniteElement, METH_O, "delete_Quad2DFiniteElement(Quad2DFiniteElement self)"}, { "Quad2DFiniteElement_swigregister", Quad2DFiniteElement_swigregister, METH_O, NULL}, { "Quad2DFiniteElement_swiginit", Quad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussQuad2DFiniteElement", _wrap_new_GaussQuad2DFiniteElement, METH_NOARGS, "new_GaussQuad2DFiniteElement() -> GaussQuad2DFiniteElement"}, - { "GaussQuad2DFiniteElement_CalcShape", _wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS, "GaussQuad2DFiniteElement_CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussQuad2DFiniteElement_CalcDShape", _wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS, "GaussQuad2DFiniteElement_CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussQuad2DFiniteElement_CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussQuad2DFiniteElement_CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussQuad2DFiniteElement", _wrap_delete_GaussQuad2DFiniteElement, METH_O, "delete_GaussQuad2DFiniteElement(GaussQuad2DFiniteElement self)"}, { "GaussQuad2DFiniteElement_swigregister", GaussQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussQuad2DFiniteElement_swiginit", GaussQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuad2DFiniteElement", _wrap_new_BiQuad2DFiniteElement, METH_NOARGS, "new_BiQuad2DFiniteElement() -> BiQuad2DFiniteElement"}, - { "BiQuad2DFiniteElement_CalcShape", _wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS, "BiQuad2DFiniteElement_CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuad2DFiniteElement_CalcDShape", _wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "BiQuad2DFiniteElement_CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuad2DFiniteElement_ProjectDelta", _wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS, "BiQuad2DFiniteElement_ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiQuad2DFiniteElement_CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiQuad2DFiniteElement_CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "BiQuad2DFiniteElement_ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuad2DFiniteElement", _wrap_delete_BiQuad2DFiniteElement, METH_O, "delete_BiQuad2DFiniteElement(BiQuad2DFiniteElement self)"}, { "BiQuad2DFiniteElement_swigregister", BiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuad2DFiniteElement_swiginit", BiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuadPos2DFiniteElement", _wrap_new_BiQuadPos2DFiniteElement, METH_NOARGS, "new_BiQuadPos2DFiniteElement() -> BiQuadPos2DFiniteElement"}, - { "BiQuadPos2DFiniteElement_CalcShape", _wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS, "BiQuadPos2DFiniteElement_CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuadPos2DFiniteElement_CalcDShape", _wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS, "BiQuadPos2DFiniteElement_CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuadPos2DFiniteElement_GetLocalInterpolation", _wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS, "BiQuadPos2DFiniteElement_GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "BiQuadPos2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuadPos2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuadPos2DFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "BiQuadPos2DFiniteElement_Project", _wrap_BiQuadPos2DFiniteElement_Project, METH_VARARGS, "\n" "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52112,93 +51513,93 @@ static PyMethodDef SwigMethods[] = { "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "BiQuadPos2DFiniteElement_Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" ""}, - { "BiQuadPos2DFiniteElement_ProjectDelta", _wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS, "BiQuadPos2DFiniteElement_ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuadPos2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "BiQuadPos2DFiniteElement_ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuadPos2DFiniteElement", _wrap_delete_BiQuadPos2DFiniteElement, METH_O, "delete_BiQuadPos2DFiniteElement(BiQuadPos2DFiniteElement self)"}, { "BiQuadPos2DFiniteElement_swigregister", BiQuadPos2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuadPos2DFiniteElement_swiginit", BiQuadPos2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiQuad2DFiniteElement", _wrap_new_GaussBiQuad2DFiniteElement, METH_NOARGS, "new_GaussBiQuad2DFiniteElement() -> GaussBiQuad2DFiniteElement"}, - { "GaussBiQuad2DFiniteElement_CalcShape", _wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS, "GaussBiQuad2DFiniteElement_CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiQuad2DFiniteElement_CalcDShape", _wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "GaussBiQuad2DFiniteElement_CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "GaussBiQuad2DFiniteElement_CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "GaussBiQuad2DFiniteElement_CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussBiQuad2DFiniteElement", _wrap_delete_GaussBiQuad2DFiniteElement, METH_O, "delete_GaussBiQuad2DFiniteElement(GaussBiQuad2DFiniteElement self)"}, { "GaussBiQuad2DFiniteElement_swigregister", GaussBiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiQuad2DFiniteElement_swiginit", GaussBiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiCubic2DFiniteElement", _wrap_new_BiCubic2DFiniteElement, METH_NOARGS, "new_BiCubic2DFiniteElement() -> BiCubic2DFiniteElement"}, - { "BiCubic2DFiniteElement_CalcShape", _wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS, "BiCubic2DFiniteElement_CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiCubic2DFiniteElement_CalcDShape", _wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS, "BiCubic2DFiniteElement_CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiCubic2DFiniteElement_CalcHessian", _wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS, "BiCubic2DFiniteElement_CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiCubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "BiCubic2DFiniteElement_CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiCubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "BiCubic2DFiniteElement_CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiCubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "BiCubic2DFiniteElement_CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_BiCubic2DFiniteElement", _wrap_delete_BiCubic2DFiniteElement, METH_O, "delete_BiCubic2DFiniteElement(BiCubic2DFiniteElement self)"}, { "BiCubic2DFiniteElement_swigregister", BiCubic2DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic2DFiniteElement_swiginit", BiCubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic1DFiniteElement", _wrap_new_Cubic1DFiniteElement, METH_NOARGS, "new_Cubic1DFiniteElement() -> Cubic1DFiniteElement"}, - { "Cubic1DFiniteElement_CalcShape", _wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS, "Cubic1DFiniteElement_CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic1DFiniteElement_CalcDShape", _wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS, "Cubic1DFiniteElement_CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Cubic1DFiniteElement_CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Cubic1DFiniteElement_CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic1DFiniteElement", _wrap_delete_Cubic1DFiniteElement, METH_O, "delete_Cubic1DFiniteElement(Cubic1DFiniteElement self)"}, { "Cubic1DFiniteElement_swigregister", Cubic1DFiniteElement_swigregister, METH_O, NULL}, { "Cubic1DFiniteElement_swiginit", Cubic1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic2DFiniteElement", _wrap_new_Cubic2DFiniteElement, METH_NOARGS, "new_Cubic2DFiniteElement() -> Cubic2DFiniteElement"}, - { "Cubic2DFiniteElement_CalcShape", _wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS, "Cubic2DFiniteElement_CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic2DFiniteElement_CalcDShape", _wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS, "Cubic2DFiniteElement_CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Cubic2DFiniteElement_CalcHessian", _wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS, "Cubic2DFiniteElement_CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Cubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Cubic2DFiniteElement_CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Cubic2DFiniteElement_CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "Cubic2DFiniteElement_CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_Cubic2DFiniteElement", _wrap_delete_Cubic2DFiniteElement, METH_O, "delete_Cubic2DFiniteElement(Cubic2DFiniteElement self)"}, { "Cubic2DFiniteElement_swigregister", Cubic2DFiniteElement_swigregister, METH_O, NULL}, { "Cubic2DFiniteElement_swiginit", Cubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic3DFiniteElement", _wrap_new_Cubic3DFiniteElement, METH_NOARGS, "new_Cubic3DFiniteElement() -> Cubic3DFiniteElement"}, - { "Cubic3DFiniteElement_CalcShape", _wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS, "Cubic3DFiniteElement_CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic3DFiniteElement_CalcDShape", _wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS, "Cubic3DFiniteElement_CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Cubic3DFiniteElement_CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Cubic3DFiniteElement_CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic3DFiniteElement", _wrap_delete_Cubic3DFiniteElement, METH_O, "delete_Cubic3DFiniteElement(Cubic3DFiniteElement self)"}, { "Cubic3DFiniteElement_swigregister", Cubic3DFiniteElement_swigregister, METH_O, NULL}, { "Cubic3DFiniteElement_swiginit", Cubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TriangleFiniteElement", _wrap_new_P0TriangleFiniteElement, METH_NOARGS, "new_P0TriangleFiniteElement() -> P0TriangleFiniteElement"}, - { "P0TriangleFiniteElement_CalcShape", _wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS, "P0TriangleFiniteElement_CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TriangleFiniteElement_CalcDShape", _wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS, "P0TriangleFiniteElement_CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TriangleFiniteElement_ProjectDelta", _wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS, "P0TriangleFiniteElement_ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, + { "P0TriangleFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0TriangleFiniteElement_CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TriangleFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0TriangleFiniteElement_CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TriangleFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0TriangleFiniteElement_ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TriangleFiniteElement", _wrap_delete_P0TriangleFiniteElement, METH_O, "delete_P0TriangleFiniteElement(P0TriangleFiniteElement self)"}, { "P0TriangleFiniteElement_swigregister", P0TriangleFiniteElement_swigregister, METH_O, NULL}, { "P0TriangleFiniteElement_swiginit", P0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0QuadFiniteElement", _wrap_new_P0QuadFiniteElement, METH_NOARGS, "new_P0QuadFiniteElement() -> P0QuadFiniteElement"}, - { "P0QuadFiniteElement_CalcShape", _wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS, "P0QuadFiniteElement_CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0QuadFiniteElement_CalcDShape", _wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS, "P0QuadFiniteElement_CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0QuadFiniteElement_ProjectDelta", _wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS, "P0QuadFiniteElement_ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, + { "P0QuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0QuadFiniteElement_CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0QuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0QuadFiniteElement_CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0QuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0QuadFiniteElement_ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0QuadFiniteElement", _wrap_delete_P0QuadFiniteElement, METH_O, "delete_P0QuadFiniteElement(P0QuadFiniteElement self)"}, { "P0QuadFiniteElement_swigregister", P0QuadFiniteElement_swigregister, METH_O, NULL}, { "P0QuadFiniteElement_swiginit", P0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear3DFiniteElement", _wrap_new_Linear3DFiniteElement, METH_NOARGS, "new_Linear3DFiniteElement() -> Linear3DFiniteElement"}, - { "Linear3DFiniteElement_CalcShape", _wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS, "Linear3DFiniteElement_CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear3DFiniteElement_CalcDShape", _wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS, "Linear3DFiniteElement_CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear3DFiniteElement_ProjectDelta", _wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS, "Linear3DFiniteElement_ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, - { "Linear3DFiniteElement_GetFaceDofs", _wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS, "Linear3DFiniteElement_GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "Linear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear3DFiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "Linear3DFiniteElement_GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, { "delete_Linear3DFiniteElement", _wrap_delete_Linear3DFiniteElement, METH_O, "delete_Linear3DFiniteElement(Linear3DFiniteElement self)"}, { "Linear3DFiniteElement_swigregister", Linear3DFiniteElement_swigregister, METH_O, NULL}, { "Linear3DFiniteElement_swiginit", Linear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quadratic3DFiniteElement", _wrap_new_Quadratic3DFiniteElement, METH_NOARGS, "new_Quadratic3DFiniteElement() -> Quadratic3DFiniteElement"}, - { "Quadratic3DFiniteElement_CalcShape", _wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS, "Quadratic3DFiniteElement_CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quadratic3DFiniteElement_CalcDShape", _wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS, "Quadratic3DFiniteElement_CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quadratic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Quadratic3DFiniteElement_CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quadratic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Quadratic3DFiniteElement_CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quadratic3DFiniteElement", _wrap_delete_Quadratic3DFiniteElement, METH_O, "delete_Quadratic3DFiniteElement(Quadratic3DFiniteElement self)"}, { "Quadratic3DFiniteElement_swigregister", Quadratic3DFiniteElement_swigregister, METH_O, NULL}, { "Quadratic3DFiniteElement_swiginit", Quadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_TriLinear3DFiniteElement", _wrap_new_TriLinear3DFiniteElement, METH_NOARGS, "new_TriLinear3DFiniteElement() -> TriLinear3DFiniteElement"}, - { "TriLinear3DFiniteElement_CalcShape", _wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS, "TriLinear3DFiniteElement_CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "TriLinear3DFiniteElement_CalcDShape", _wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "TriLinear3DFiniteElement_CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "TriLinear3DFiniteElement_ProjectDelta", _wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS, "TriLinear3DFiniteElement_ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, + { "TriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "TriLinear3DFiniteElement_CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "TriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "TriLinear3DFiniteElement_CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "TriLinear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "TriLinear3DFiniteElement_ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, { "delete_TriLinear3DFiniteElement", _wrap_delete_TriLinear3DFiniteElement, METH_O, "delete_TriLinear3DFiniteElement(TriLinear3DFiniteElement self)"}, { "TriLinear3DFiniteElement_swigregister", TriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "TriLinear3DFiniteElement_swiginit", TriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFiniteElement", _wrap_new_CrouzeixRaviartFiniteElement, METH_NOARGS, "new_CrouzeixRaviartFiniteElement() -> CrouzeixRaviartFiniteElement"}, - { "CrouzeixRaviartFiniteElement_CalcShape", _wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS, "CrouzeixRaviartFiniteElement_CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartFiniteElement_CalcDShape", _wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS, "CrouzeixRaviartFiniteElement_CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "CrouzeixRaviartFiniteElement_ProjectDelta", _wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS, "CrouzeixRaviartFiniteElement_ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, + { "CrouzeixRaviartFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFiniteElement_CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFiniteElement_CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartFiniteElement_ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, { "delete_CrouzeixRaviartFiniteElement", _wrap_delete_CrouzeixRaviartFiniteElement, METH_O, "delete_CrouzeixRaviartFiniteElement(CrouzeixRaviartFiniteElement self)"}, { "CrouzeixRaviartFiniteElement_swigregister", CrouzeixRaviartFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartFiniteElement_swiginit", CrouzeixRaviartFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartQuadFiniteElement", _wrap_new_CrouzeixRaviartQuadFiniteElement, METH_NOARGS, "new_CrouzeixRaviartQuadFiniteElement() -> CrouzeixRaviartQuadFiniteElement"}, - { "CrouzeixRaviartQuadFiniteElement_CalcShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS, "CrouzeixRaviartQuadFiniteElement_CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartQuadFiniteElement_CalcDShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS, "CrouzeixRaviartQuadFiniteElement_CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartQuadFiniteElement_CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CrouzeixRaviartQuadFiniteElement_CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_CrouzeixRaviartQuadFiniteElement", _wrap_delete_CrouzeixRaviartQuadFiniteElement, METH_O, "delete_CrouzeixRaviartQuadFiniteElement(CrouzeixRaviartQuadFiniteElement self)"}, { "CrouzeixRaviartQuadFiniteElement_swigregister", CrouzeixRaviartQuadFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartQuadFiniteElement_swiginit", CrouzeixRaviartQuadFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_P0SegmentFiniteElement", _wrap_new_P0SegmentFiniteElement, METH_VARARGS, "P0SegmentFiniteElement(int Ord=0)"}, - { "P0SegmentFiniteElement_CalcShape", _wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS, "P0SegmentFiniteElement_CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0SegmentFiniteElement_CalcDShape", _wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS, "P0SegmentFiniteElement_CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_P0SegmentFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_P0SegmentFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_P0SegmentFiniteElement(int Ord=0) -> P0SegmentFiniteElement"}, + { "P0SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0SegmentFiniteElement_CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0SegmentFiniteElement_CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P0SegmentFiniteElement", _wrap_delete_P0SegmentFiniteElement, METH_O, "delete_P0SegmentFiniteElement(P0SegmentFiniteElement self)"}, { "P0SegmentFiniteElement_swigregister", P0SegmentFiniteElement_swigregister, METH_O, NULL}, { "P0SegmentFiniteElement_swiginit", P0SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -52207,8 +51608,8 @@ static PyMethodDef SwigMethods[] = { "RT0TriangleFiniteElement_CalcVShape(RT0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0TriangleFiniteElement_CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TriangleFiniteElement_CalcDivShape", _wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS, "RT0TriangleFiniteElement_CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TriangleFiniteElement_GetLocalInterpolation", _wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0TriangleFiniteElement_GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0TriangleFiniteElement_CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0TriangleFiniteElement_GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TriangleFiniteElement_Project", _wrap_RT0TriangleFiniteElement_Project, METH_VARARGS, "\n" "RT0TriangleFiniteElement_Project(RT0TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0TriangleFiniteElement_Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52223,8 +51624,8 @@ static PyMethodDef SwigMethods[] = { "RT0QuadFiniteElement_CalcVShape(RT0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0QuadFiniteElement_CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0QuadFiniteElement_CalcDivShape", _wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS, "RT0QuadFiniteElement_CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0QuadFiniteElement_GetLocalInterpolation", _wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0QuadFiniteElement_GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0QuadFiniteElement_CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0QuadFiniteElement_GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0QuadFiniteElement_Project", _wrap_RT0QuadFiniteElement_Project, METH_VARARGS, "\n" "RT0QuadFiniteElement_Project(RT0QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0QuadFiniteElement_Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52239,8 +51640,8 @@ static PyMethodDef SwigMethods[] = { "RT1TriangleFiniteElement_CalcVShape(RT1TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT1TriangleFiniteElement_CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1TriangleFiniteElement_CalcDivShape", _wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS, "RT1TriangleFiniteElement_CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1TriangleFiniteElement_GetLocalInterpolation", _wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT1TriangleFiniteElement_GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT1TriangleFiniteElement_CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT1TriangleFiniteElement_GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1TriangleFiniteElement_Project", _wrap_RT1TriangleFiniteElement_Project, METH_VARARGS, "\n" "RT1TriangleFiniteElement_Project(RT1TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT1TriangleFiniteElement_Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52255,8 +51656,8 @@ static PyMethodDef SwigMethods[] = { "RT1QuadFiniteElement_CalcVShape(RT1QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT1QuadFiniteElement_CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1QuadFiniteElement_CalcDivShape", _wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS, "RT1QuadFiniteElement_CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1QuadFiniteElement_GetLocalInterpolation", _wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT1QuadFiniteElement_GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT1QuadFiniteElement_CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT1QuadFiniteElement_GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1QuadFiniteElement_Project", _wrap_RT1QuadFiniteElement_Project, METH_VARARGS, "\n" "RT1QuadFiniteElement_Project(RT1QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT1QuadFiniteElement_Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52271,7 +51672,7 @@ static PyMethodDef SwigMethods[] = { "RT2TriangleFiniteElement_CalcVShape(RT2TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT2TriangleFiniteElement_CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2TriangleFiniteElement_CalcDivShape", _wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS, "RT2TriangleFiniteElement_CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT2TriangleFiniteElement_CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, { "delete_RT2TriangleFiniteElement", _wrap_delete_RT2TriangleFiniteElement, METH_O, "delete_RT2TriangleFiniteElement(RT2TriangleFiniteElement self)"}, { "RT2TriangleFiniteElement_swigregister", RT2TriangleFiniteElement_swigregister, METH_O, NULL}, { "RT2TriangleFiniteElement_swiginit", RT2TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -52280,8 +51681,8 @@ static PyMethodDef SwigMethods[] = { "RT2QuadFiniteElement_CalcVShape(RT2QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT2QuadFiniteElement_CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2QuadFiniteElement_CalcDivShape", _wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS, "RT2QuadFiniteElement_CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT2QuadFiniteElement_GetLocalInterpolation", _wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT2QuadFiniteElement_GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT2QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT2QuadFiniteElement_CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT2QuadFiniteElement_GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT2QuadFiniteElement_Project", _wrap_RT2QuadFiniteElement_Project, METH_VARARGS, "\n" "RT2QuadFiniteElement_Project(RT2QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT2QuadFiniteElement_Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52292,76 +51693,76 @@ static PyMethodDef SwigMethods[] = { { "RT2QuadFiniteElement_swigregister", RT2QuadFiniteElement_swigregister, METH_O, NULL}, { "RT2QuadFiniteElement_swiginit", RT2QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1SegmentFiniteElement", _wrap_new_P1SegmentFiniteElement, METH_NOARGS, "new_P1SegmentFiniteElement() -> P1SegmentFiniteElement"}, - { "P1SegmentFiniteElement_CalcShape", _wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS, "P1SegmentFiniteElement_CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1SegmentFiniteElement_CalcDShape", _wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS, "P1SegmentFiniteElement_CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P1SegmentFiniteElement_CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P1SegmentFiniteElement_CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1SegmentFiniteElement", _wrap_delete_P1SegmentFiniteElement, METH_O, "delete_P1SegmentFiniteElement(P1SegmentFiniteElement self)"}, { "P1SegmentFiniteElement_swigregister", P1SegmentFiniteElement_swigregister, METH_O, NULL}, { "P1SegmentFiniteElement_swiginit", P1SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P2SegmentFiniteElement", _wrap_new_P2SegmentFiniteElement, METH_NOARGS, "new_P2SegmentFiniteElement() -> P2SegmentFiniteElement"}, - { "P2SegmentFiniteElement_CalcShape", _wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS, "P2SegmentFiniteElement_CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P2SegmentFiniteElement_CalcDShape", _wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS, "P2SegmentFiniteElement_CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P2SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P2SegmentFiniteElement_CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P2SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P2SegmentFiniteElement_CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P2SegmentFiniteElement", _wrap_delete_P2SegmentFiniteElement, METH_O, "delete_P2SegmentFiniteElement(P2SegmentFiniteElement self)"}, { "P2SegmentFiniteElement_swigregister", P2SegmentFiniteElement_swigregister, METH_O, NULL}, { "P2SegmentFiniteElement_swiginit", P2SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_Lagrange1DFiniteElement", _wrap_new_Lagrange1DFiniteElement, METH_O, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, - { "Lagrange1DFiniteElement_CalcShape", _wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS, "Lagrange1DFiniteElement_CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Lagrange1DFiniteElement_CalcDShape", _wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS, "Lagrange1DFiniteElement_CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_Lagrange1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_Lagrange1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, + { "Lagrange1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "Lagrange1DFiniteElement_CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Lagrange1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "Lagrange1DFiniteElement_CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Lagrange1DFiniteElement", _wrap_delete_Lagrange1DFiniteElement, METH_O, "delete_Lagrange1DFiniteElement(Lagrange1DFiniteElement self)"}, { "Lagrange1DFiniteElement_swigregister", Lagrange1DFiniteElement_swigregister, METH_O, NULL}, { "Lagrange1DFiniteElement_swiginit", Lagrange1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1TetNonConfFiniteElement", _wrap_new_P1TetNonConfFiniteElement, METH_NOARGS, "new_P1TetNonConfFiniteElement() -> P1TetNonConfFiniteElement"}, - { "P1TetNonConfFiniteElement_CalcShape", _wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS, "P1TetNonConfFiniteElement_CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1TetNonConfFiniteElement_CalcDShape", _wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS, "P1TetNonConfFiniteElement_CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1TetNonConfFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P1TetNonConfFiniteElement_CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1TetNonConfFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P1TetNonConfFiniteElement_CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1TetNonConfFiniteElement", _wrap_delete_P1TetNonConfFiniteElement, METH_O, "delete_P1TetNonConfFiniteElement(P1TetNonConfFiniteElement self)"}, { "P1TetNonConfFiniteElement_swigregister", P1TetNonConfFiniteElement_swigregister, METH_O, NULL}, { "P1TetNonConfFiniteElement_swiginit", P1TetNonConfFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TetFiniteElement", _wrap_new_P0TetFiniteElement, METH_NOARGS, "new_P0TetFiniteElement() -> P0TetFiniteElement"}, - { "P0TetFiniteElement_CalcShape", _wrap_P0TetFiniteElement_CalcShape, METH_VARARGS, "P0TetFiniteElement_CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TetFiniteElement_CalcDShape", _wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS, "P0TetFiniteElement_CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TetFiniteElement_ProjectDelta", _wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS, "P0TetFiniteElement_ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, + { "P0TetFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0TetFiniteElement_CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TetFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0TetFiniteElement_CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TetFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0TetFiniteElement_ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TetFiniteElement", _wrap_delete_P0TetFiniteElement, METH_O, "delete_P0TetFiniteElement(P0TetFiniteElement self)"}, { "P0TetFiniteElement_swigregister", P0TetFiniteElement_swigregister, METH_O, NULL}, { "P0TetFiniteElement_swiginit", P0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0HexFiniteElement", _wrap_new_P0HexFiniteElement, METH_NOARGS, "new_P0HexFiniteElement() -> P0HexFiniteElement"}, - { "P0HexFiniteElement_CalcShape", _wrap_P0HexFiniteElement_CalcShape, METH_VARARGS, "P0HexFiniteElement_CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0HexFiniteElement_CalcDShape", _wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS, "P0HexFiniteElement_CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0HexFiniteElement_ProjectDelta", _wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS, "P0HexFiniteElement_ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, + { "P0HexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "P0HexFiniteElement_CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0HexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "P0HexFiniteElement_CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0HexFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "P0HexFiniteElement_ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0HexFiniteElement", _wrap_delete_P0HexFiniteElement, METH_O, "delete_P0HexFiniteElement(P0HexFiniteElement self)"}, { "P0HexFiniteElement_swigregister", P0HexFiniteElement_swigregister, METH_O, NULL}, { "P0HexFiniteElement_swiginit", P0HexFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_LagrangeHexFiniteElement", _wrap_new_LagrangeHexFiniteElement, METH_O, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, - { "LagrangeHexFiniteElement_CalcShape", _wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS, "LagrangeHexFiniteElement_CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "LagrangeHexFiniteElement_CalcDShape", _wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS, "LagrangeHexFiniteElement_CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_LagrangeHexFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_LagrangeHexFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, + { "LagrangeHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "LagrangeHexFiniteElement_CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "LagrangeHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "LagrangeHexFiniteElement_CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_LagrangeHexFiniteElement", _wrap_delete_LagrangeHexFiniteElement, METH_O, "delete_LagrangeHexFiniteElement(LagrangeHexFiniteElement self)"}, { "LagrangeHexFiniteElement_swigregister", LagrangeHexFiniteElement_swigregister, METH_O, NULL}, { "LagrangeHexFiniteElement_swiginit", LagrangeHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear1DFiniteElement", _wrap_new_RefinedLinear1DFiniteElement, METH_NOARGS, "new_RefinedLinear1DFiniteElement() -> RefinedLinear1DFiniteElement"}, - { "RefinedLinear1DFiniteElement_CalcShape", _wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS, "RefinedLinear1DFiniteElement_CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear1DFiniteElement_CalcDShape", _wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS, "RefinedLinear1DFiniteElement_CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear1DFiniteElement_CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear1DFiniteElement_CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear1DFiniteElement", _wrap_delete_RefinedLinear1DFiniteElement, METH_O, "delete_RefinedLinear1DFiniteElement(RefinedLinear1DFiniteElement self)"}, { "RefinedLinear1DFiniteElement_swigregister", RefinedLinear1DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear1DFiniteElement_swiginit", RefinedLinear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear2DFiniteElement", _wrap_new_RefinedLinear2DFiniteElement, METH_NOARGS, "new_RefinedLinear2DFiniteElement() -> RefinedLinear2DFiniteElement"}, - { "RefinedLinear2DFiniteElement_CalcShape", _wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS, "RefinedLinear2DFiniteElement_CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear2DFiniteElement_CalcDShape", _wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS, "RefinedLinear2DFiniteElement_CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear2DFiniteElement_CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear2DFiniteElement_CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear2DFiniteElement", _wrap_delete_RefinedLinear2DFiniteElement, METH_O, "delete_RefinedLinear2DFiniteElement(RefinedLinear2DFiniteElement self)"}, { "RefinedLinear2DFiniteElement_swigregister", RefinedLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear2DFiniteElement_swiginit", RefinedLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear3DFiniteElement", _wrap_new_RefinedLinear3DFiniteElement, METH_NOARGS, "new_RefinedLinear3DFiniteElement() -> RefinedLinear3DFiniteElement"}, - { "RefinedLinear3DFiniteElement_CalcShape", _wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS, "RefinedLinear3DFiniteElement_CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear3DFiniteElement_CalcDShape", _wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS, "RefinedLinear3DFiniteElement_CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear3DFiniteElement_CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedLinear3DFiniteElement_CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear3DFiniteElement", _wrap_delete_RefinedLinear3DFiniteElement, METH_O, "delete_RefinedLinear3DFiniteElement(RefinedLinear3DFiniteElement self)"}, { "RefinedLinear3DFiniteElement_swigregister", RefinedLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear3DFiniteElement_swiginit", RefinedLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedBiLinear2DFiniteElement", _wrap_new_RefinedBiLinear2DFiniteElement, METH_NOARGS, "new_RefinedBiLinear2DFiniteElement() -> RefinedBiLinear2DFiniteElement"}, - { "RefinedBiLinear2DFiniteElement_CalcShape", _wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "RefinedBiLinear2DFiniteElement_CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedBiLinear2DFiniteElement_CalcDShape", _wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "RefinedBiLinear2DFiniteElement_CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedBiLinear2DFiniteElement_CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedBiLinear2DFiniteElement_CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedBiLinear2DFiniteElement", _wrap_delete_RefinedBiLinear2DFiniteElement, METH_O, "delete_RefinedBiLinear2DFiniteElement(RefinedBiLinear2DFiniteElement self)"}, { "RefinedBiLinear2DFiniteElement_swigregister", RefinedBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedBiLinear2DFiniteElement_swiginit", RefinedBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedTriLinear3DFiniteElement", _wrap_new_RefinedTriLinear3DFiniteElement, METH_NOARGS, "new_RefinedTriLinear3DFiniteElement() -> RefinedTriLinear3DFiniteElement"}, - { "RefinedTriLinear3DFiniteElement_CalcShape", _wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS, "RefinedTriLinear3DFiniteElement_CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedTriLinear3DFiniteElement_CalcDShape", _wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "RefinedTriLinear3DFiniteElement_CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedTriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RefinedTriLinear3DFiniteElement_CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedTriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RefinedTriLinear3DFiniteElement_CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedTriLinear3DFiniteElement", _wrap_delete_RefinedTriLinear3DFiniteElement, METH_O, "delete_RefinedTriLinear3DFiniteElement(RefinedTriLinear3DFiniteElement self)"}, { "RefinedTriLinear3DFiniteElement_swigregister", RefinedTriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedTriLinear3DFiniteElement_swiginit", RefinedTriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -52370,8 +51771,8 @@ static PyMethodDef SwigMethods[] = { "Nedelec1HexFiniteElement_CalcVShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "Nedelec1HexFiniteElement_CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1HexFiniteElement_CalcCurlShape", _wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS, "Nedelec1HexFiniteElement_CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1HexFiniteElement_GetLocalInterpolation", _wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "Nedelec1HexFiniteElement_GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1HexFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "Nedelec1HexFiniteElement_CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "Nedelec1HexFiniteElement_GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1HexFiniteElement_Project", _wrap_Nedelec1HexFiniteElement_Project, METH_VARARGS, "\n" "Nedelec1HexFiniteElement_Project(Nedelec1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Nedelec1HexFiniteElement_Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52386,8 +51787,8 @@ static PyMethodDef SwigMethods[] = { "Nedelec1TetFiniteElement_CalcVShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "Nedelec1TetFiniteElement_CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1TetFiniteElement_CalcCurlShape", _wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS, "Nedelec1TetFiniteElement_CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1TetFiniteElement_GetLocalInterpolation", _wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "Nedelec1TetFiniteElement_GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1TetFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "Nedelec1TetFiniteElement_CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "Nedelec1TetFiniteElement_GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1TetFiniteElement_Project", _wrap_Nedelec1TetFiniteElement_Project, METH_VARARGS, "\n" "Nedelec1TetFiniteElement_Project(Nedelec1TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Nedelec1TetFiniteElement_Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52402,8 +51803,8 @@ static PyMethodDef SwigMethods[] = { "RT0HexFiniteElement_CalcVShape(RT0HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0HexFiniteElement_CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0HexFiniteElement_CalcDivShape", _wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS, "RT0HexFiniteElement_CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0HexFiniteElement_GetLocalInterpolation", _wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0HexFiniteElement_GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0HexFiniteElement_CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0HexFiniteElement_GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0HexFiniteElement_Project", _wrap_RT0HexFiniteElement_Project, METH_VARARGS, "\n" "RT0HexFiniteElement_Project(RT0HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0HexFiniteElement_Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52418,8 +51819,8 @@ static PyMethodDef SwigMethods[] = { "RT1HexFiniteElement_CalcVShape(RT1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT1HexFiniteElement_CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1HexFiniteElement_CalcDivShape", _wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS, "RT1HexFiniteElement_CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1HexFiniteElement_GetLocalInterpolation", _wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT1HexFiniteElement_GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT1HexFiniteElement_CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT1HexFiniteElement_GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1HexFiniteElement_Project", _wrap_RT1HexFiniteElement_Project, METH_VARARGS, "\n" "RT1HexFiniteElement_Project(RT1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT1HexFiniteElement_Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52434,8 +51835,8 @@ static PyMethodDef SwigMethods[] = { "RT0TetFiniteElement_CalcVShape(RT0TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT0TetFiniteElement_CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TetFiniteElement_CalcDivShape", _wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS, "RT0TetFiniteElement_CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TetFiniteElement_GetLocalInterpolation", _wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "RT0TetFiniteElement_GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TetFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT0TetFiniteElement_CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT0TetFiniteElement_GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TetFiniteElement_Project", _wrap_RT0TetFiniteElement_Project, METH_VARARGS, "\n" "RT0TetFiniteElement_Project(RT0TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT0TetFiniteElement_Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52446,29 +51847,29 @@ static PyMethodDef SwigMethods[] = { { "RT0TetFiniteElement_swigregister", RT0TetFiniteElement_swigregister, METH_O, NULL}, { "RT0TetFiniteElement_swiginit", RT0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RotTriLinearHexFiniteElement", _wrap_new_RotTriLinearHexFiniteElement, METH_NOARGS, "new_RotTriLinearHexFiniteElement() -> RotTriLinearHexFiniteElement"}, - { "RotTriLinearHexFiniteElement_CalcShape", _wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS, "RotTriLinearHexFiniteElement_CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RotTriLinearHexFiniteElement_CalcDShape", _wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS, "RotTriLinearHexFiniteElement_CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RotTriLinearHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "RotTriLinearHexFiniteElement_CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RotTriLinearHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "RotTriLinearHexFiniteElement_CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RotTriLinearHexFiniteElement", _wrap_delete_RotTriLinearHexFiniteElement, METH_O, "delete_RotTriLinearHexFiniteElement(RotTriLinearHexFiniteElement self)"}, { "RotTriLinearHexFiniteElement_swigregister", RotTriLinearHexFiniteElement_swigregister, METH_O, NULL}, { "RotTriLinearHexFiniteElement_swiginit", RotTriLinearHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Poly_1D", _wrap_new_Poly_1D, METH_NOARGS, "new_Poly_1D() -> Poly_1D"}, - { "Poly_1D_Binom", _wrap_Poly_1D_Binom, METH_O, "Poly_1D_Binom(int const p) -> int const *"}, - { "Poly_1D_GetPoints", _wrap_Poly_1D_GetPoints, METH_VARARGS, "Poly_1D_GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, - { "Poly_1D_OpenPoints", _wrap_Poly_1D_OpenPoints, METH_VARARGS, "Poly_1D_OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const"}, - { "Poly_1D_ClosedPoints", _wrap_Poly_1D_ClosedPoints, METH_VARARGS, "Poly_1D_ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const"}, - { "Poly_1D_GetBasis", _wrap_Poly_1D_GetBasis, METH_VARARGS, "Poly_1D_GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, + { "Poly_1D_Binom", (PyCFunction)(void(*)(void))_wrap_Poly_1D_Binom, METH_VARARGS|METH_KEYWORDS, "Poly_1D_Binom(int const p) -> int const *"}, + { "Poly_1D_GetPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, + { "Poly_1D_OpenPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_OpenPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const *"}, + { "Poly_1D_ClosedPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ClosedPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const *"}, + { "Poly_1D_GetBasis", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetBasis, METH_VARARGS|METH_KEYWORDS, "Poly_1D_GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, { "Poly_1D_CalcBasis", _wrap_Poly_1D_CalcBasis, METH_VARARGS, "\n" "Poly_1D_CalcBasis(int const p, double const x, double * u)\n" "Poly_1D_CalcBasis(int const p, double const x, double * u, double * d)\n" "Poly_1D_CalcBasis(int const p, double const x, double * u, double * d, double * dd)\n" ""}, - { "Poly_1D_CalcDelta", _wrap_Poly_1D_CalcDelta, METH_VARARGS, "Poly_1D_CalcDelta(int const p, double const x) -> double"}, - { "Poly_1D_ChebyshevPoints", _wrap_Poly_1D_ChebyshevPoints, METH_VARARGS, "Poly_1D_ChebyshevPoints(int const p, double * x)"}, + { "Poly_1D_CalcDelta", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDelta, METH_VARARGS|METH_KEYWORDS, "Poly_1D_CalcDelta(int const p, double const x) -> double"}, + { "Poly_1D_ChebyshevPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ChebyshevPoints, METH_VARARGS|METH_KEYWORDS, "Poly_1D_ChebyshevPoints(int const p, double * x)"}, { "Poly_1D_CalcBinomTerms", _wrap_Poly_1D_CalcBinomTerms, METH_VARARGS, "\n" "Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u)\n" "Poly_1D_CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)\n" ""}, - { "Poly_1D_CalcDBinomTerms", _wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS, "Poly_1D_CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, + { "Poly_1D_CalcDBinomTerms", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS|METH_KEYWORDS, "Poly_1D_CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, { "Poly_1D_CalcBernstein", _wrap_Poly_1D_CalcBernstein, METH_VARARGS, "\n" "Poly_1D_CalcBernstein(int const p, double const x, double * u)\n" "Poly_1D_CalcBernstein(int const p, double const x, double * u, double * d)\n" @@ -52480,67 +51881,67 @@ static PyMethodDef SwigMethods[] = { { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, - { "new_TensorBasisElement", _wrap_new_TensorBasisElement, METH_VARARGS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, + { "new_TensorBasisElement", (PyCFunction)(void(*)(void))_wrap_new_TensorBasisElement, METH_VARARGS|METH_KEYWORDS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, { "TensorBasisElement_GetBasisType", _wrap_TensorBasisElement_GetBasisType, METH_O, "TensorBasisElement_GetBasisType(TensorBasisElement self) -> int"}, { "TensorBasisElement_GetBasis1D", _wrap_TensorBasisElement_GetBasis1D, METH_O, "TensorBasisElement_GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &"}, { "TensorBasisElement_GetDofMap", _wrap_TensorBasisElement_GetDofMap, METH_O, "TensorBasisElement_GetDofMap(TensorBasisElement self) -> intArray"}, - { "TensorBasisElement_GetTensorProductGeometry", _wrap_TensorBasisElement_GetTensorProductGeometry, METH_O, "TensorBasisElement_GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, - { "TensorBasisElement_Pow", _wrap_TensorBasisElement_Pow, METH_VARARGS, "TensorBasisElement_Pow(int base, int dim) -> int"}, + { "TensorBasisElement_GetTensorProductGeometry", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_GetTensorProductGeometry, METH_VARARGS|METH_KEYWORDS, "TensorBasisElement_GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, + { "TensorBasisElement_Pow", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_Pow, METH_VARARGS|METH_KEYWORDS, "TensorBasisElement_Pow(int base, int dim) -> int"}, { "delete_TensorBasisElement", _wrap_delete_TensorBasisElement, METH_O, "delete_TensorBasisElement(TensorBasisElement self)"}, { "TensorBasisElement_swigregister", TensorBasisElement_swigregister, METH_O, NULL}, { "TensorBasisElement_swiginit", TensorBasisElement_swiginit, METH_VARARGS, NULL}, - { "NodalTensorFiniteElement_GetDofToQuad", _wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS, "NodalTensorFiniteElement_GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "NodalTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "NodalTensorFiniteElement_GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_NodalTensorFiniteElement", _wrap_delete_NodalTensorFiniteElement, METH_O, "delete_NodalTensorFiniteElement(NodalTensorFiniteElement self)"}, { "NodalTensorFiniteElement_swigregister", NodalTensorFiniteElement_swigregister, METH_O, NULL}, - { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "PositiveTensorFiniteElement_GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "PositiveTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "PositiveTensorFiniteElement_GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, - { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "VectorTensorFiniteElement_GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "VectorTensorFiniteElement_GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "new_VectorTensorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorTensorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "VectorTensorFiniteElement_GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS|METH_KEYWORDS, "VectorTensorFiniteElement_GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS|METH_KEYWORDS, "VectorTensorFiniteElement_GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, - { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "H1_SegmentElement_CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "H1_SegmentElement_CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_SegmentElement_ProjectDelta", _wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS, "H1_SegmentElement_ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1_SegmentElement(int const p, int const btype=GaussLobatto) -> H1_SegmentElement"}, + { "H1_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_SegmentElement_CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_SegmentElement_CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1_SegmentElement_ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1_SegmentElement", _wrap_delete_H1_SegmentElement, METH_O, "delete_H1_SegmentElement(H1_SegmentElement self)"}, { "H1_SegmentElement_swigregister", H1_SegmentElement_swigregister, METH_O, NULL}, { "H1_SegmentElement_swiginit", H1_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_QuadrilateralElement", _wrap_new_H1_QuadrilateralElement, METH_VARARGS, "H1_QuadrilateralElement(int const p, int const btype=GaussLobatto)"}, - { "H1_QuadrilateralElement_CalcShape", _wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS, "H1_QuadrilateralElement_CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_QuadrilateralElement_CalcDShape", _wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1_QuadrilateralElement_CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_QuadrilateralElement_ProjectDelta", _wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS, "H1_QuadrilateralElement_ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1_QuadrilateralElement(int const p, int const btype=GaussLobatto) -> H1_QuadrilateralElement"}, + { "H1_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_QuadrilateralElement_CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_QuadrilateralElement_CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1_QuadrilateralElement_ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1_QuadrilateralElement", _wrap_delete_H1_QuadrilateralElement, METH_O, "delete_H1_QuadrilateralElement(H1_QuadrilateralElement self)"}, { "H1_QuadrilateralElement_swigregister", H1_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1_QuadrilateralElement_swiginit", H1_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_HexahedronElement", _wrap_new_H1_HexahedronElement, METH_VARARGS, "H1_HexahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_HexahedronElement_CalcShape", _wrap_H1_HexahedronElement_CalcShape, METH_VARARGS, "H1_HexahedronElement_CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_HexahedronElement_CalcDShape", _wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS, "H1_HexahedronElement_CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_HexahedronElement_ProjectDelta", _wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS, "H1_HexahedronElement_ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_HexahedronElement(int const p, int const btype=GaussLobatto) -> H1_HexahedronElement"}, + { "H1_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_HexahedronElement_CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_HexahedronElement_CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1_HexahedronElement_ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1_HexahedronElement", _wrap_delete_H1_HexahedronElement, METH_O, "delete_H1_HexahedronElement(H1_HexahedronElement self)"}, { "H1_HexahedronElement_swigregister", H1_HexahedronElement_swigregister, METH_O, NULL}, { "H1_HexahedronElement_swiginit", H1_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_SegmentElement", _wrap_new_H1Pos_SegmentElement, METH_O, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, - { "H1Pos_SegmentElement_CalcShape", _wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS, "H1Pos_SegmentElement_CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_SegmentElement_CalcDShape", _wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS, "H1Pos_SegmentElement_CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_SegmentElement_ProjectDelta", _wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS, "H1Pos_SegmentElement_ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, + { "H1Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_SegmentElement_CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_SegmentElement_CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1Pos_SegmentElement_ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_SegmentElement", _wrap_delete_H1Pos_SegmentElement, METH_O, "delete_H1Pos_SegmentElement(H1Pos_SegmentElement self)"}, { "H1Pos_SegmentElement_swigregister", H1Pos_SegmentElement_swigregister, METH_O, NULL}, { "H1Pos_SegmentElement_swiginit", H1Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_QuadrilateralElement", _wrap_new_H1Pos_QuadrilateralElement, METH_O, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, - { "H1Pos_QuadrilateralElement_CalcShape", _wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "H1Pos_QuadrilateralElement_CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_QuadrilateralElement_CalcDShape", _wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1Pos_QuadrilateralElement_CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_QuadrilateralElement_ProjectDelta", _wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "H1Pos_QuadrilateralElement_ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, + { "H1Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_QuadrilateralElement_CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_QuadrilateralElement_CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1Pos_QuadrilateralElement_ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, - { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "H1Ser_QuadrilateralElement_CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "H1Ser_QuadrilateralElement_GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "new_H1Ser_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Ser_QuadrilateralElement_CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Ser_QuadrilateralElement_CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "H1Ser_QuadrilateralElement_GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "H1Ser_QuadrilateralElement_Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52549,28 +51950,28 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, - { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "H1Pos_HexahedronElement_CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_HexahedronElement_ProjectDelta", _wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "H1Pos_HexahedronElement_ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, + { "H1Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_HexahedronElement_CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_HexahedronElement_CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "H1Pos_HexahedronElement_ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_HexahedronElement", _wrap_delete_H1Pos_HexahedronElement, METH_O, "delete_H1Pos_HexahedronElement(H1Pos_HexahedronElement self)"}, { "H1Pos_HexahedronElement_swigregister", H1Pos_HexahedronElement_swigregister, METH_O, NULL}, { "H1Pos_HexahedronElement_swiginit", H1Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TriangleElement", _wrap_new_H1_TriangleElement, METH_VARARGS, "H1_TriangleElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TriangleElement_CalcShape", _wrap_H1_TriangleElement_CalcShape, METH_VARARGS, "H1_TriangleElement_CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TriangleElement_CalcDShape", _wrap_H1_TriangleElement_CalcDShape, METH_VARARGS, "H1_TriangleElement_CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TriangleElement_CalcHessian", _wrap_H1_TriangleElement_CalcHessian, METH_VARARGS, "H1_TriangleElement_CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TriangleElement(int const p, int const btype=GaussLobatto) -> H1_TriangleElement"}, + { "H1_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_TriangleElement_CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_TriangleElement_CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TriangleElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "H1_TriangleElement_CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TriangleElement", _wrap_delete_H1_TriangleElement, METH_O, "delete_H1_TriangleElement(H1_TriangleElement self)"}, { "H1_TriangleElement_swigregister", H1_TriangleElement_swigregister, METH_O, NULL}, { "H1_TriangleElement_swiginit", H1_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TetrahedronElement", _wrap_new_H1_TetrahedronElement, METH_VARARGS, "H1_TetrahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TetrahedronElement_CalcShape", _wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS, "H1_TetrahedronElement_CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TetrahedronElement_CalcDShape", _wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS, "H1_TetrahedronElement_CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TetrahedronElement_CalcHessian", _wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS, "H1_TetrahedronElement_CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TetrahedronElement(int const p, int const btype=GaussLobatto) -> H1_TetrahedronElement"}, + { "H1_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_TetrahedronElement_CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_TetrahedronElement_CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TetrahedronElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "H1_TetrahedronElement_CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TetrahedronElement", _wrap_delete_H1_TetrahedronElement, METH_O, "delete_H1_TetrahedronElement(H1_TetrahedronElement self)"}, { "H1_TetrahedronElement_swigregister", H1_TetrahedronElement_swigregister, METH_O, NULL}, { "H1_TetrahedronElement_swiginit", H1_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TriangleElement", _wrap_new_H1Pos_TriangleElement, METH_O, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, + { "new_H1Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, { "H1Pos_TriangleElement_CalcShape", _wrap_H1Pos_TriangleElement_CalcShape, METH_VARARGS, "\n" "H1Pos_TriangleElement_CalcShape(int const p, double const x, double const y, double * shape)\n" "H1Pos_TriangleElement_CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -52582,7 +51983,7 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_TriangleElement", _wrap_delete_H1Pos_TriangleElement, METH_O, "delete_H1Pos_TriangleElement(H1Pos_TriangleElement self)"}, { "H1Pos_TriangleElement_swigregister", H1Pos_TriangleElement_swigregister, METH_O, NULL}, { "H1Pos_TriangleElement_swiginit", H1Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TetrahedronElement", _wrap_new_H1Pos_TetrahedronElement, METH_O, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, + { "new_H1Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, { "H1Pos_TetrahedronElement_CalcShape", _wrap_H1Pos_TetrahedronElement_CalcShape, METH_VARARGS, "\n" "H1Pos_TetrahedronElement_CalcShape(int const p, double const x, double const y, double const z, double * shape)\n" "H1Pos_TetrahedronElement_CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -52594,9 +51995,9 @@ static PyMethodDef SwigMethods[] = { { "delete_H1Pos_TetrahedronElement", _wrap_delete_H1Pos_TetrahedronElement, METH_O, "delete_H1Pos_TetrahedronElement(H1Pos_TetrahedronElement self)"}, { "H1Pos_TetrahedronElement_swigregister", H1Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "H1Pos_TetrahedronElement_swiginit", H1Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_WedgeElement", _wrap_new_H1_WedgeElement, METH_VARARGS, "H1_WedgeElement(int const p, int const btype=GaussLobatto)"}, - { "H1_WedgeElement_CalcShape", _wrap_H1_WedgeElement_CalcShape, METH_VARARGS, "H1_WedgeElement_CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_WedgeElement_CalcDShape", _wrap_H1_WedgeElement_CalcDShape, METH_VARARGS, "H1_WedgeElement_CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1_WedgeElement(int const p, int const btype=GaussLobatto) -> H1_WedgeElement"}, + { "H1_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1_WedgeElement_CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1_WedgeElement_CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1_WedgeElement", _wrap_delete_H1_WedgeElement, METH_O, "delete_H1_WedgeElement(H1_WedgeElement self)"}, { "H1_WedgeElement_swigregister", H1_WedgeElement_swigregister, METH_O, NULL}, { "H1_WedgeElement_swiginit", H1_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -52612,87 +52013,87 @@ static PyMethodDef SwigMethods[] = { { "delete_BiCubic3DFiniteElement", _wrap_delete_BiCubic3DFiniteElement, METH_O, "delete_BiCubic3DFiniteElement(BiCubic3DFiniteElement self)"}, { "BiCubic3DFiniteElement_swigregister", BiCubic3DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic3DFiniteElement_swiginit", BiCubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_WedgeElement", _wrap_new_H1Pos_WedgeElement, METH_O, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, - { "H1Pos_WedgeElement_CalcShape", _wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS, "H1Pos_WedgeElement_CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_WedgeElement_CalcDShape", _wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS, "H1Pos_WedgeElement_CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, + { "H1Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_WedgeElement_CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "H1Pos_WedgeElement_CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1Pos_WedgeElement", _wrap_delete_H1Pos_WedgeElement, METH_O, "delete_H1Pos_WedgeElement(H1Pos_WedgeElement self)"}, { "H1Pos_WedgeElement_swigregister", H1Pos_WedgeElement_swigregister, METH_O, NULL}, { "H1Pos_WedgeElement_swiginit", H1Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_SegmentElement", _wrap_new_L2_SegmentElement, METH_VARARGS, "L2_SegmentElement(int const p, int const btype=GaussLegendre)"}, - { "L2_SegmentElement_CalcShape", _wrap_L2_SegmentElement_CalcShape, METH_VARARGS, "L2_SegmentElement_CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_SegmentElement_CalcDShape", _wrap_L2_SegmentElement_CalcDShape, METH_VARARGS, "L2_SegmentElement_CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_SegmentElement_ProjectDelta", _wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS, "L2_SegmentElement_ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2_SegmentElement(int const p, int const btype=GaussLegendre) -> L2_SegmentElement"}, + { "L2_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_SegmentElement_CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_SegmentElement_CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_SegmentElement_ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2_SegmentElement", _wrap_delete_L2_SegmentElement, METH_O, "delete_L2_SegmentElement(L2_SegmentElement self)"}, { "L2_SegmentElement_swigregister", L2_SegmentElement_swigregister, METH_O, NULL}, { "L2_SegmentElement_swiginit", L2_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_SegmentElement", _wrap_new_L2Pos_SegmentElement, METH_O, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, - { "L2Pos_SegmentElement_CalcShape", _wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS, "L2Pos_SegmentElement_CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_SegmentElement_CalcDShape", _wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS, "L2Pos_SegmentElement_CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_SegmentElement_ProjectDelta", _wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS, "L2Pos_SegmentElement_ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, + { "L2Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_SegmentElement_CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_SegmentElement_CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_SegmentElement_ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_SegmentElement", _wrap_delete_L2Pos_SegmentElement, METH_O, "delete_L2Pos_SegmentElement(L2Pos_SegmentElement self)"}, { "L2Pos_SegmentElement_swigregister", L2Pos_SegmentElement_swigregister, METH_O, NULL}, { "L2Pos_SegmentElement_swiginit", L2Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_QuadrilateralElement", _wrap_new_L2_QuadrilateralElement, METH_VARARGS, "L2_QuadrilateralElement(int const p, int const btype=GaussLegendre)"}, - { "L2_QuadrilateralElement_CalcShape", _wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS, "L2_QuadrilateralElement_CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_QuadrilateralElement_CalcDShape", _wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS, "L2_QuadrilateralElement_CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_QuadrilateralElement_ProjectDelta", _wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS, "L2_QuadrilateralElement_ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, - { "L2_QuadrilateralElement_ProjectCurl", _wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS, "L2_QuadrilateralElement_ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2_QuadrilateralElement(int const p, int const btype=GaussLegendre) -> L2_QuadrilateralElement"}, + { "L2_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "L2_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "L2_QuadrilateralElement_ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_QuadrilateralElement", _wrap_delete_L2_QuadrilateralElement, METH_O, "delete_L2_QuadrilateralElement(L2_QuadrilateralElement self)"}, { "L2_QuadrilateralElement_swigregister", L2_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2_QuadrilateralElement_swiginit", L2_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_QuadrilateralElement", _wrap_new_L2Pos_QuadrilateralElement, METH_O, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, - { "L2Pos_QuadrilateralElement_CalcShape", _wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "L2Pos_QuadrilateralElement_CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_QuadrilateralElement_CalcDShape", _wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "L2Pos_QuadrilateralElement_CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_QuadrilateralElement_ProjectDelta", _wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "L2Pos_QuadrilateralElement_ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, + { "L2Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_QuadrilateralElement_CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_QuadrilateralElement_CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_QuadrilateralElement_ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_QuadrilateralElement", _wrap_delete_L2Pos_QuadrilateralElement, METH_O, "delete_L2Pos_QuadrilateralElement(L2Pos_QuadrilateralElement self)"}, { "L2Pos_QuadrilateralElement_swigregister", L2Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2Pos_QuadrilateralElement_swiginit", L2Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_HexahedronElement", _wrap_new_L2_HexahedronElement, METH_VARARGS, "L2_HexahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_HexahedronElement_CalcShape", _wrap_L2_HexahedronElement_CalcShape, METH_VARARGS, "L2_HexahedronElement_CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_HexahedronElement_CalcDShape", _wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS, "L2_HexahedronElement_CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_HexahedronElement_ProjectDelta", _wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS, "L2_HexahedronElement_ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_HexahedronElement(int const p, int const btype=GaussLegendre) -> L2_HexahedronElement"}, + { "L2_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_HexahedronElement_CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_HexahedronElement_CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_HexahedronElement_ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_HexahedronElement", _wrap_delete_L2_HexahedronElement, METH_O, "delete_L2_HexahedronElement(L2_HexahedronElement self)"}, { "L2_HexahedronElement_swigregister", L2_HexahedronElement_swigregister, METH_O, NULL}, { "L2_HexahedronElement_swiginit", L2_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_HexahedronElement", _wrap_new_L2Pos_HexahedronElement, METH_O, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, - { "L2Pos_HexahedronElement_CalcShape", _wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS, "L2Pos_HexahedronElement_CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_HexahedronElement_CalcDShape", _wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS, "L2Pos_HexahedronElement_CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_HexahedronElement_ProjectDelta", _wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "L2Pos_HexahedronElement_ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, + { "L2Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_HexahedronElement_CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_HexahedronElement_CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_HexahedronElement_ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_HexahedronElement", _wrap_delete_L2Pos_HexahedronElement, METH_O, "delete_L2Pos_HexahedronElement(L2Pos_HexahedronElement self)"}, { "L2Pos_HexahedronElement_swigregister", L2Pos_HexahedronElement_swigregister, METH_O, NULL}, { "L2Pos_HexahedronElement_swiginit", L2Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TriangleElement", _wrap_new_L2_TriangleElement, METH_VARARGS, "L2_TriangleElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TriangleElement_CalcShape", _wrap_L2_TriangleElement_CalcShape, METH_VARARGS, "L2_TriangleElement_CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TriangleElement_CalcDShape", _wrap_L2_TriangleElement_CalcDShape, METH_VARARGS, "L2_TriangleElement_CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TriangleElement_ProjectDelta", _wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS, "L2_TriangleElement_ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, - { "L2_TriangleElement_ProjectCurl", _wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS, "L2_TriangleElement_ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TriangleElement(int const p, int const btype=GaussLegendre) -> L2_TriangleElement"}, + { "L2_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, + { "L2_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "L2_TriangleElement_ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_TriangleElement", _wrap_delete_L2_TriangleElement, METH_O, "delete_L2_TriangleElement(L2_TriangleElement self)"}, { "L2_TriangleElement_swigregister", L2_TriangleElement_swigregister, METH_O, NULL}, { "L2_TriangleElement_swiginit", L2_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TriangleElement", _wrap_new_L2Pos_TriangleElement, METH_O, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, - { "L2Pos_TriangleElement_CalcShape", _wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS, "L2Pos_TriangleElement_CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TriangleElement_CalcDShape", _wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS, "L2Pos_TriangleElement_CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TriangleElement_ProjectDelta", _wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS, "L2Pos_TriangleElement_ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, + { "L2Pos_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TriangleElement_CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TriangleElement_CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_TriangleElement_ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TriangleElement", _wrap_delete_L2Pos_TriangleElement, METH_O, "delete_L2Pos_TriangleElement(L2Pos_TriangleElement self)"}, { "L2Pos_TriangleElement_swigregister", L2Pos_TriangleElement_swigregister, METH_O, NULL}, { "L2Pos_TriangleElement_swiginit", L2Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TetrahedronElement", _wrap_new_L2_TetrahedronElement, METH_VARARGS, "L2_TetrahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TetrahedronElement_CalcShape", _wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS, "L2_TetrahedronElement_CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TetrahedronElement_CalcDShape", _wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS, "L2_TetrahedronElement_CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TetrahedronElement_ProjectDelta", _wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS, "L2_TetrahedronElement_ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TetrahedronElement(int const p, int const btype=GaussLegendre) -> L2_TetrahedronElement"}, + { "L2_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_TetrahedronElement_CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_TetrahedronElement_CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2_TetrahedronElement_ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_TetrahedronElement", _wrap_delete_L2_TetrahedronElement, METH_O, "delete_L2_TetrahedronElement(L2_TetrahedronElement self)"}, { "L2_TetrahedronElement_swigregister", L2_TetrahedronElement_swigregister, METH_O, NULL}, { "L2_TetrahedronElement_swiginit", L2_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TetrahedronElement", _wrap_new_L2Pos_TetrahedronElement, METH_O, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, - { "L2Pos_TetrahedronElement_CalcShape", _wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS, "L2Pos_TetrahedronElement_CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TetrahedronElement_CalcDShape", _wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "L2Pos_TetrahedronElement_CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TetrahedronElement_ProjectDelta", _wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS, "L2Pos_TetrahedronElement_ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, + { "L2Pos_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TetrahedronElement_CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_TetrahedronElement_CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "L2Pos_TetrahedronElement_ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TetrahedronElement", _wrap_delete_L2Pos_TetrahedronElement, METH_O, "delete_L2Pos_TetrahedronElement(L2Pos_TetrahedronElement self)"}, { "L2Pos_TetrahedronElement_swigregister", L2Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "L2Pos_TetrahedronElement_swiginit", L2Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_WedgeElement", _wrap_new_L2_WedgeElement, METH_VARARGS, "L2_WedgeElement(int const p, int const btype=GaussLegendre)"}, - { "L2_WedgeElement_CalcShape", _wrap_L2_WedgeElement_CalcShape, METH_VARARGS, "L2_WedgeElement_CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_WedgeElement_CalcDShape", _wrap_L2_WedgeElement_CalcDShape, METH_VARARGS, "L2_WedgeElement_CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2_WedgeElement(int const p, int const btype=GaussLegendre) -> L2_WedgeElement"}, + { "L2_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2_WedgeElement_CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2_WedgeElement_CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2_WedgeElement", _wrap_delete_L2_WedgeElement, METH_O, "delete_L2_WedgeElement(L2_WedgeElement self)"}, { "L2_WedgeElement_swigregister", L2_WedgeElement_swigregister, METH_O, NULL}, { "L2_WedgeElement_swiginit", L2_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -52700,22 +52101,22 @@ static PyMethodDef SwigMethods[] = { { "delete_P0WedgeFiniteElement", _wrap_delete_P0WedgeFiniteElement, METH_O, "delete_P0WedgeFiniteElement(P0WedgeFiniteElement self)"}, { "P0WedgeFiniteElement_swigregister", P0WedgeFiniteElement_swigregister, METH_O, NULL}, { "P0WedgeFiniteElement_swiginit", P0WedgeFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_WedgeElement", _wrap_new_L2Pos_WedgeElement, METH_O, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, - { "L2Pos_WedgeElement_CalcShape", _wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS, "L2Pos_WedgeElement_CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_WedgeElement_CalcDShape", _wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS, "L2Pos_WedgeElement_CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, + { "L2Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_WedgeElement_CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "L2Pos_WedgeElement_CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2Pos_WedgeElement", _wrap_delete_L2Pos_WedgeElement, METH_O, "delete_L2Pos_WedgeElement(L2Pos_WedgeElement self)"}, { "L2Pos_WedgeElement_swigregister", L2Pos_WedgeElement_swigregister, METH_O, NULL}, { "L2Pos_WedgeElement_swiginit", L2Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_QuadrilateralElement", _wrap_new_RT_QuadrilateralElement, METH_VARARGS, "RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_RT_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_QuadrilateralElement"}, { "RT_QuadrilateralElement_CalcVShape", _wrap_RT_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "RT_QuadrilateralElement_CalcVShape(RT_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_QuadrilateralElement_CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_QuadrilateralElement_CalcDivShape", _wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS, "RT_QuadrilateralElement_CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_QuadrilateralElement_GetLocalInterpolation", _wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "RT_QuadrilateralElement_GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_GetLocalRestriction", _wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "RT_QuadrilateralElement_GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_QuadrilateralElement_GetTransferMatrix", _wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "RT_QuadrilateralElement_GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_QuadrilateralElement_ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_QuadrilateralElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_QuadrilateralElement_Project", _wrap_RT_QuadrilateralElement_Project, METH_VARARGS, "\n" "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52723,21 +52124,21 @@ static PyMethodDef SwigMethods[] = { "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_QuadrilateralElement_Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_QuadrilateralElement_ProjectGrad", _wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS, "RT_QuadrilateralElement_ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_QuadrilateralElement_ProjectCurl", _wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS, "RT_QuadrilateralElement_ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_QuadrilateralElement_ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_QuadrilateralElement", _wrap_delete_RT_QuadrilateralElement, METH_O, "delete_RT_QuadrilateralElement(RT_QuadrilateralElement self)"}, { "RT_QuadrilateralElement_swigregister", RT_QuadrilateralElement_swigregister, METH_O, NULL}, { "RT_QuadrilateralElement_swiginit", RT_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_HexahedronElement", _wrap_new_RT_HexahedronElement, METH_VARARGS, "RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_HexahedronElement"}, { "RT_HexahedronElement_CalcVShape", _wrap_RT_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "RT_HexahedronElement_CalcVShape(RT_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_HexahedronElement_CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_HexahedronElement_CalcDivShape", _wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS, "RT_HexahedronElement_CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_HexahedronElement_GetLocalInterpolation", _wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "RT_HexahedronElement_GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_GetLocalRestriction", _wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS, "RT_HexahedronElement_GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_HexahedronElement_GetTransferMatrix", _wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS, "RT_HexahedronElement_GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_ProjectMatrixCoefficient", _wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_HexahedronElement_ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_HexahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_HexahedronElement_Project", _wrap_RT_HexahedronElement_Project, METH_VARARGS, "\n" "RT_HexahedronElement_Project(RT_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_HexahedronElement_Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52745,20 +52146,20 @@ static PyMethodDef SwigMethods[] = { "RT_HexahedronElement_Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_HexahedronElement_Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_HexahedronElement_ProjectCurl", _wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS, "RT_HexahedronElement_ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_HexahedronElement_ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_HexahedronElement", _wrap_delete_RT_HexahedronElement, METH_O, "delete_RT_HexahedronElement(RT_HexahedronElement self)"}, { "RT_HexahedronElement_swigregister", RT_HexahedronElement_swigregister, METH_O, NULL}, { "RT_HexahedronElement_swiginit", RT_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TriangleElement", _wrap_new_RT_TriangleElement, METH_O, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, + { "new_RT_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, { "RT_TriangleElement_CalcVShape", _wrap_RT_TriangleElement_CalcVShape, METH_VARARGS, "\n" "RT_TriangleElement_CalcVShape(RT_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_TriangleElement_CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TriangleElement_CalcDivShape", _wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS, "RT_TriangleElement_CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TriangleElement_GetLocalInterpolation", _wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS, "RT_TriangleElement_GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_GetLocalRestriction", _wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS, "RT_TriangleElement_GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TriangleElement_GetTransferMatrix", _wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS, "RT_TriangleElement_GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_ProjectMatrixCoefficient", _wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_TriangleElement_ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TriangleElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TriangleElement_Project", _wrap_RT_TriangleElement_Project, METH_VARARGS, "\n" "RT_TriangleElement_Project(RT_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TriangleElement_Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52766,21 +52167,21 @@ static PyMethodDef SwigMethods[] = { "RT_TriangleElement_Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TriangleElement_Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TriangleElement_ProjectGrad", _wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS, "RT_TriangleElement_ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_TriangleElement_ProjectCurl", _wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS, "RT_TriangleElement_ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_TriangleElement_ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TriangleElement", _wrap_delete_RT_TriangleElement, METH_O, "delete_RT_TriangleElement(RT_TriangleElement self)"}, { "RT_TriangleElement_swigregister", RT_TriangleElement_swigregister, METH_O, NULL}, { "RT_TriangleElement_swiginit", RT_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TetrahedronElement", _wrap_new_RT_TetrahedronElement, METH_O, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, + { "new_RT_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, { "RT_TetrahedronElement_CalcVShape", _wrap_RT_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "RT_TetrahedronElement_CalcVShape(RT_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "RT_TetrahedronElement_CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TetrahedronElement_CalcDivShape", _wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS, "RT_TetrahedronElement_CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TetrahedronElement_GetLocalInterpolation", _wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "RT_TetrahedronElement_GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_GetLocalRestriction", _wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "RT_TetrahedronElement_GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TetrahedronElement_GetTransferMatrix", _wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "RT_TetrahedronElement_GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_ProjectMatrixCoefficient", _wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "RT_TetrahedronElement_ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TetrahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TetrahedronElement_Project", _wrap_RT_TetrahedronElement_Project, METH_VARARGS, "\n" "RT_TetrahedronElement_Project(RT_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TetrahedronElement_Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52788,20 +52189,20 @@ static PyMethodDef SwigMethods[] = { "RT_TetrahedronElement_Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "RT_TetrahedronElement_Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TetrahedronElement_ProjectCurl", _wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS, "RT_TetrahedronElement_ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "RT_TetrahedronElement_ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TetrahedronElement", _wrap_delete_RT_TetrahedronElement, METH_O, "delete_RT_TetrahedronElement(RT_TetrahedronElement self)"}, { "RT_TetrahedronElement_swigregister", RT_TetrahedronElement_swigregister, METH_O, NULL}, { "RT_TetrahedronElement_swiginit", RT_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_HexahedronElement", _wrap_new_ND_HexahedronElement, METH_VARARGS, "ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_HexahedronElement"}, { "ND_HexahedronElement_CalcVShape", _wrap_ND_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "ND_HexahedronElement_CalcVShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_HexahedronElement_CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_HexahedronElement_CalcCurlShape", _wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS, "ND_HexahedronElement_CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_HexahedronElement_GetLocalInterpolation", _wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "ND_HexahedronElement_GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_GetLocalRestriction", _wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS, "ND_HexahedronElement_GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_HexahedronElement_GetTransferMatrix", _wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS, "ND_HexahedronElement_GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_ProjectMatrixCoefficient", _wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_HexahedronElement_ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_HexahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_HexahedronElement_Project", _wrap_ND_HexahedronElement_Project, METH_VARARGS, "\n" "ND_HexahedronElement_Project(ND_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_HexahedronElement_Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52809,21 +52210,21 @@ static PyMethodDef SwigMethods[] = { "ND_HexahedronElement_Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_HexahedronElement_Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_HexahedronElement_ProjectGrad", _wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS, "ND_HexahedronElement_ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_HexahedronElement_ProjectCurl", _wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS, "ND_HexahedronElement_ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_HexahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ND_HexahedronElement_ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_HexahedronElement", _wrap_delete_ND_HexahedronElement, METH_O, "delete_ND_HexahedronElement(ND_HexahedronElement self)"}, { "ND_HexahedronElement_swigregister", ND_HexahedronElement_swigregister, METH_O, NULL}, { "ND_HexahedronElement_swiginit", ND_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_QuadrilateralElement", _wrap_new_ND_QuadrilateralElement, METH_VARARGS, "ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_ND_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_QuadrilateralElement"}, { "ND_QuadrilateralElement_CalcVShape", _wrap_ND_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "ND_QuadrilateralElement_CalcVShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_QuadrilateralElement_CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_QuadrilateralElement_CalcCurlShape", _wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS, "ND_QuadrilateralElement_CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_QuadrilateralElement_GetLocalInterpolation", _wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "ND_QuadrilateralElement_GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_GetLocalRestriction", _wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "ND_QuadrilateralElement_GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_QuadrilateralElement_GetTransferMatrix", _wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "ND_QuadrilateralElement_GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_QuadrilateralElement_ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_QuadrilateralElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_QuadrilateralElement_Project", _wrap_ND_QuadrilateralElement_Project, METH_VARARGS, "\n" "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52831,20 +52232,20 @@ static PyMethodDef SwigMethods[] = { "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_QuadrilateralElement_Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_QuadrilateralElement_ProjectGrad", _wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ND_QuadrilateralElement_ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_QuadrilateralElement_ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_QuadrilateralElement", _wrap_delete_ND_QuadrilateralElement, METH_O, "delete_ND_QuadrilateralElement(ND_QuadrilateralElement self)"}, { "ND_QuadrilateralElement_swigregister", ND_QuadrilateralElement_swigregister, METH_O, NULL}, { "ND_QuadrilateralElement_swiginit", ND_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TetrahedronElement", _wrap_new_ND_TetrahedronElement, METH_O, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, + { "new_ND_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, { "ND_TetrahedronElement_CalcVShape", _wrap_ND_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "ND_TetrahedronElement_CalcVShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_TetrahedronElement_CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TetrahedronElement_CalcCurlShape", _wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS, "ND_TetrahedronElement_CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TetrahedronElement_GetLocalInterpolation", _wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "ND_TetrahedronElement_GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_GetLocalRestriction", _wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "ND_TetrahedronElement_GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TetrahedronElement_GetTransferMatrix", _wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "ND_TetrahedronElement_GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_ProjectMatrixCoefficient", _wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_TetrahedronElement_ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TetrahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TetrahedronElement_Project", _wrap_ND_TetrahedronElement_Project, METH_VARARGS, "\n" "ND_TetrahedronElement_Project(ND_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TetrahedronElement_Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52852,21 +52253,21 @@ static PyMethodDef SwigMethods[] = { "ND_TetrahedronElement_Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TetrahedronElement_Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TetrahedronElement_ProjectGrad", _wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS, "ND_TetrahedronElement_ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_TetrahedronElement_ProjectCurl", _wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS, "ND_TetrahedronElement_ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_TetrahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ND_TetrahedronElement_ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_TetrahedronElement", _wrap_delete_ND_TetrahedronElement, METH_O, "delete_ND_TetrahedronElement(ND_TetrahedronElement self)"}, { "ND_TetrahedronElement_swigregister", ND_TetrahedronElement_swigregister, METH_O, NULL}, { "ND_TetrahedronElement_swiginit", ND_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TriangleElement", _wrap_new_ND_TriangleElement, METH_O, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, + { "new_ND_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, { "ND_TriangleElement_CalcVShape", _wrap_ND_TriangleElement_CalcVShape, METH_VARARGS, "\n" "ND_TriangleElement_CalcVShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_TriangleElement_CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TriangleElement_CalcCurlShape", _wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS, "ND_TriangleElement_CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TriangleElement_GetLocalInterpolation", _wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS, "ND_TriangleElement_GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_GetLocalRestriction", _wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS, "ND_TriangleElement_GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TriangleElement_GetTransferMatrix", _wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS, "ND_TriangleElement_GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_ProjectMatrixCoefficient", _wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_TriangleElement_ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TriangleElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TriangleElement_Project", _wrap_ND_TriangleElement_Project, METH_VARARGS, "\n" "ND_TriangleElement_Project(ND_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TriangleElement_Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52874,20 +52275,20 @@ static PyMethodDef SwigMethods[] = { "ND_TriangleElement_Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_TriangleElement_Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TriangleElement_ProjectGrad", _wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS, "ND_TriangleElement_ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_TriangleElement_ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_TriangleElement", _wrap_delete_ND_TriangleElement, METH_O, "delete_ND_TriangleElement(ND_TriangleElement self)"}, { "ND_TriangleElement_swigregister", ND_TriangleElement_swigregister, METH_O, NULL}, { "ND_TriangleElement_swiginit", ND_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_SegmentElement", _wrap_new_ND_SegmentElement, METH_VARARGS, "ND_SegmentElement(int const p, int const ob_type=GaussLegendre)"}, - { "ND_SegmentElement_CalcShape", _wrap_ND_SegmentElement_CalcShape, METH_VARARGS, "ND_SegmentElement_CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "new_ND_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_ND_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_ND_SegmentElement(int const p, int const ob_type=GaussLegendre) -> ND_SegmentElement"}, + { "ND_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, { "ND_SegmentElement_CalcVShape", _wrap_ND_SegmentElement_CalcVShape, METH_VARARGS, "\n" "ND_SegmentElement_CalcVShape(ND_SegmentElement self, IntegrationPoint ip, DenseMatrix shape)\n" "ND_SegmentElement_CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_SegmentElement_GetLocalInterpolation", _wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS, "ND_SegmentElement_GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_GetLocalRestriction", _wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS, "ND_SegmentElement_GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_SegmentElement_GetTransferMatrix", _wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS, "ND_SegmentElement_GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_ProjectMatrixCoefficient", _wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS, "ND_SegmentElement_ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_SegmentElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_SegmentElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_SegmentElement_Project", _wrap_ND_SegmentElement_Project, METH_VARARGS, "\n" "ND_SegmentElement_Project(ND_SegmentElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_SegmentElement_Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -52895,26 +52296,26 @@ static PyMethodDef SwigMethods[] = { "ND_SegmentElement_Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "ND_SegmentElement_Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_SegmentElement_ProjectGrad", _wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS, "ND_SegmentElement_ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_SegmentElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ND_SegmentElement_ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_SegmentElement", _wrap_delete_ND_SegmentElement, METH_O, "delete_ND_SegmentElement(ND_SegmentElement self)"}, { "ND_SegmentElement_swigregister", ND_SegmentElement_swigregister, METH_O, NULL}, { "ND_SegmentElement_swiginit", ND_SegmentElement_swiginit, METH_VARARGS, NULL}, { "NURBSFiniteElement_Reset", _wrap_NURBSFiniteElement_Reset, METH_O, "NURBSFiniteElement_Reset(NURBSFiniteElement self)"}, - { "NURBSFiniteElement_SetIJK", _wrap_NURBSFiniteElement_SetIJK, METH_VARARGS, "NURBSFiniteElement_SetIJK(NURBSFiniteElement self, int const * IJK)"}, + { "NURBSFiniteElement_SetIJK", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetIJK, METH_VARARGS|METH_KEYWORDS, "NURBSFiniteElement_SetIJK(NURBSFiniteElement self, int const * IJK)"}, { "NURBSFiniteElement_GetPatch", _wrap_NURBSFiniteElement_GetPatch, METH_O, "NURBSFiniteElement_GetPatch(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetPatch", _wrap_NURBSFiniteElement_SetPatch, METH_VARARGS, "NURBSFiniteElement_SetPatch(NURBSFiniteElement self, int p)"}, + { "NURBSFiniteElement_SetPatch", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetPatch, METH_VARARGS|METH_KEYWORDS, "NURBSFiniteElement_SetPatch(NURBSFiniteElement self, int p)"}, { "NURBSFiniteElement_GetElement", _wrap_NURBSFiniteElement_GetElement, METH_O, "NURBSFiniteElement_GetElement(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetElement", _wrap_NURBSFiniteElement_SetElement, METH_VARARGS, "NURBSFiniteElement_SetElement(NURBSFiniteElement self, int e)"}, + { "NURBSFiniteElement_SetElement", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetElement, METH_VARARGS|METH_KEYWORDS, "NURBSFiniteElement_SetElement(NURBSFiniteElement self, int e)"}, { "NURBSFiniteElement_KnotVectors", _wrap_NURBSFiniteElement_KnotVectors, METH_O, "NURBSFiniteElement_KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &"}, { "NURBSFiniteElement_Weights", _wrap_NURBSFiniteElement_Weights, METH_O, "NURBSFiniteElement_Weights(NURBSFiniteElement self) -> Vector"}, { "NURBSFiniteElement_SetOrder", _wrap_NURBSFiniteElement_SetOrder, METH_O, "NURBSFiniteElement_SetOrder(NURBSFiniteElement self)"}, { "delete_NURBSFiniteElement", _wrap_delete_NURBSFiniteElement, METH_O, "delete_NURBSFiniteElement(NURBSFiniteElement self)"}, { "NURBSFiniteElement_swigregister", NURBSFiniteElement_swigregister, METH_O, NULL}, - { "new_NURBS1DFiniteElement", _wrap_new_NURBS1DFiniteElement, METH_O, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, + { "new_NURBS1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_NURBS1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "NURBS1DFiniteElement_SetOrder(NURBS1DFiniteElement self)"}, - { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "NURBS1DFiniteElement_CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "NURBS1DFiniteElement_CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "NURBS1DFiniteElement_CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "NURBS1DFiniteElement_CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "NURBS1DFiniteElement_CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "NURBS1DFiniteElement_CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -52923,9 +52324,9 @@ static PyMethodDef SwigMethods[] = { "new_NURBS2DFiniteElement(int px, int py) -> NURBS2DFiniteElement\n" ""}, { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "NURBS2DFiniteElement_SetOrder(NURBS2DFiniteElement self)"}, - { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "NURBS2DFiniteElement_CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "NURBS2DFiniteElement_CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "NURBS2DFiniteElement_CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "NURBS2DFiniteElement_CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "NURBS2DFiniteElement_CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "NURBS2DFiniteElement_CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -52934,9 +52335,9 @@ static PyMethodDef SwigMethods[] = { "new_NURBS3DFiniteElement(int px, int py, int pz) -> NURBS3DFiniteElement\n" ""}, { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "NURBS3DFiniteElement_SetOrder(NURBS3DFiniteElement self)"}, - { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "NURBS3DFiniteElement_CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "NURBS3DFiniteElement_CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "NURBS3DFiniteElement_CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "NURBS3DFiniteElement_CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "NURBS3DFiniteElement_CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "NURBS3DFiniteElement_CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -52946,13 +52347,13 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "BasisType_Check", _wrap_BasisType_Check, METH_O, "Check(int b_type) -> int"}, - { "BasisType_CheckNodal", _wrap_BasisType_CheckNodal, METH_O, "CheckNodal(int b_type) -> int"}, - { "BasisType_GetQuadrature1D", _wrap_BasisType_GetQuadrature1D, METH_O, "GetQuadrature1D(int b_type) -> int"}, - { "BasisType_GetNodalBasis", _wrap_BasisType_GetNodalBasis, METH_O, "GetNodalBasis(int qpt_type) -> int"}, - { "BasisType_Name", _wrap_BasisType_Name, METH_O, "Name(int b_type) -> char const *"}, - { "BasisType_GetChar", _wrap_BasisType_GetChar, METH_O, "GetChar(int b_type) -> char"}, - { "BasisType_GetType", _wrap_BasisType_GetType, METH_O, "GetType(char b_ident) -> int"}, + { "BasisType_Check", (PyCFunction)(void(*)(void))_wrap_BasisType_Check, METH_VARARGS|METH_KEYWORDS, "Check(int b_type) -> int"}, + { "BasisType_CheckNodal", (PyCFunction)(void(*)(void))_wrap_BasisType_CheckNodal, METH_VARARGS|METH_KEYWORDS, "CheckNodal(int b_type) -> int"}, + { "BasisType_GetQuadrature1D", (PyCFunction)(void(*)(void))_wrap_BasisType_GetQuadrature1D, METH_VARARGS|METH_KEYWORDS, "GetQuadrature1D(int b_type) -> int"}, + { "BasisType_GetNodalBasis", (PyCFunction)(void(*)(void))_wrap_BasisType_GetNodalBasis, METH_VARARGS|METH_KEYWORDS, "GetNodalBasis(int qpt_type) -> int"}, + { "BasisType_Name", (PyCFunction)(void(*)(void))_wrap_BasisType_Name, METH_VARARGS|METH_KEYWORDS, "Name(int b_type) -> char const *"}, + { "BasisType_GetChar", (PyCFunction)(void(*)(void))_wrap_BasisType_GetChar, METH_VARARGS|METH_KEYWORDS, "GetChar(int b_type) -> char"}, + { "BasisType_GetType", (PyCFunction)(void(*)(void))_wrap_BasisType_GetType, METH_VARARGS|METH_KEYWORDS, "GetType(char b_ident) -> int"}, { "new_BasisType", _wrap_new_BasisType, METH_NOARGS, "new_BasisType() -> BasisType"}, { "delete_BasisType", _wrap_delete_BasisType, METH_O, "delete_BasisType(BasisType self)"}, { "BasisType_swigregister", BasisType_swigregister, METH_O, NULL}, @@ -52993,67 +52394,67 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FiniteElement_GetMapType", _wrap_FiniteElement_GetMapType, METH_O, "GetMapType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivType", _wrap_FiniteElement_GetDerivType, METH_O, "GetDerivType(FiniteElement self) -> int"}, { "FiniteElement_GetDerivMapType", _wrap_FiniteElement_GetDerivMapType, METH_O, "GetDerivMapType(FiniteElement self) -> int"}, - { "FiniteElement_CalcShape", _wrap_FiniteElement_CalcShape, METH_VARARGS, "CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "FiniteElement_CalcPhysShape", _wrap_FiniteElement_CalcPhysShape, METH_VARARGS, "CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, - { "FiniteElement_CalcDShape", _wrap_FiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "FiniteElement_CalcPhysDShape", _wrap_FiniteElement_CalcPhysDShape, METH_VARARGS, "CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, + { "FiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(FiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "FiniteElement_CalcPhysShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector shape)"}, + { "FiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(FiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "FiniteElement_CalcPhysDShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysDShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix dshape)"}, { "FiniteElement_GetNodes", _wrap_FiniteElement_GetNodes, METH_O, "GetNodes(FiniteElement self) -> IntegrationRule"}, { "FiniteElement_CalcVShape", _wrap_FiniteElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(FiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "FiniteElement_CalcPhysVShape", _wrap_FiniteElement_CalcPhysVShape, METH_VARARGS, "CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, - { "FiniteElement_CalcDivShape", _wrap_FiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "FiniteElement_CalcPhysDivShape", _wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS, "CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, - { "FiniteElement_CalcCurlShape", _wrap_FiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "FiniteElement_CalcPhysCurlShape", _wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS, "CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, - { "FiniteElement_GetFaceDofs", _wrap_FiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, - { "FiniteElement_CalcHessian", _wrap_FiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysHessian", _wrap_FiniteElement_CalcPhysHessian, METH_VARARGS, "CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, - { "FiniteElement_CalcPhysLaplacian", _wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS, "CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_CalcPhysLinLaplacian", _wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS, "CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, - { "FiniteElement_GetLocalInterpolation", _wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_GetLocalRestriction", _wrap_FiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "FiniteElement_GetTransferMatrix", _wrap_FiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "FiniteElement_ProjectMatrixCoefficient", _wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, - { "FiniteElement_ProjectDelta", _wrap_FiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, + { "FiniteElement_CalcPhysVShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysVShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysVShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)"}, + { "FiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(FiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "FiniteElement_CalcPhysDivShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysDivShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysDivShape(FiniteElement self, mfem::ElementTransformation & Trans, Vector divshape)"}, + { "FiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(FiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "FiniteElement_CalcPhysCurlShape", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcPhysCurlShape(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix curl_shape)"}, + { "FiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(FiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "FiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(FiniteElement self, IntegrationPoint ip, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysHessian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysHessian, METH_VARARGS|METH_KEYWORDS, "CalcPhysHessian(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix Hessian)"}, + { "FiniteElement_CalcPhysLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLaplacian, METH_VARARGS|METH_KEYWORDS, "CalcPhysLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_CalcPhysLinLaplacian", (PyCFunction)(void(*)(void))_wrap_FiniteElement_CalcPhysLinLaplacian, METH_VARARGS|METH_KEYWORDS, "CalcPhysLinLaplacian(FiniteElement self, mfem::ElementTransformation & Trans, Vector Laplacian)"}, + { "FiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(FiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "FiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "FiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(FiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "FiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(FiniteElement self, int vertex, Vector dofs)"}, { "FiniteElement_Project", _wrap_FiniteElement_Project, METH_VARARGS, "\n" "Project(FiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(FiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "FiniteElement_ProjectGrad", _wrap_FiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "FiniteElement_ProjectCurl", _wrap_FiniteElement_ProjectCurl, METH_VARARGS, "ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, - { "FiniteElement_ProjectDiv", _wrap_FiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, - { "FiniteElement_GetDofToQuad", _wrap_FiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "FiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "FiniteElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "FiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_FiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "ProjectDiv(FiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "FiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_FiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(FiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_FiniteElement", _wrap_delete_FiniteElement, METH_O, "delete_FiniteElement(FiniteElement self)"}, - { "FiniteElement_IsClosedType", _wrap_FiniteElement_IsClosedType, METH_O, "IsClosedType(int b_type) -> bool"}, - { "FiniteElement_IsOpenType", _wrap_FiniteElement_IsOpenType, METH_O, "IsOpenType(int b_type) -> bool"}, - { "FiniteElement_VerifyClosed", _wrap_FiniteElement_VerifyClosed, METH_O, "VerifyClosed(int b_type) -> int"}, - { "FiniteElement_VerifyOpen", _wrap_FiniteElement_VerifyOpen, METH_O, "VerifyOpen(int b_type) -> int"}, - { "FiniteElement_VerifyNodal", _wrap_FiniteElement_VerifyNodal, METH_O, "VerifyNodal(int b_type) -> int"}, + { "FiniteElement_IsClosedType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsClosedType, METH_VARARGS|METH_KEYWORDS, "IsClosedType(int b_type) -> bool"}, + { "FiniteElement_IsOpenType", (PyCFunction)(void(*)(void))_wrap_FiniteElement_IsOpenType, METH_VARARGS|METH_KEYWORDS, "IsOpenType(int b_type) -> bool"}, + { "FiniteElement_VerifyClosed", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyClosed, METH_VARARGS|METH_KEYWORDS, "VerifyClosed(int b_type) -> int"}, + { "FiniteElement_VerifyOpen", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyOpen, METH_VARARGS|METH_KEYWORDS, "VerifyOpen(int b_type) -> int"}, + { "FiniteElement_VerifyNodal", (PyCFunction)(void(*)(void))_wrap_FiniteElement_VerifyNodal, METH_VARARGS|METH_KEYWORDS, "VerifyNodal(int b_type) -> int"}, { "FiniteElement_swigregister", FiniteElement_swigregister, METH_O, NULL}, - { "ScalarFiniteElement_SetMapType", _wrap_ScalarFiniteElement_SetMapType, METH_VARARGS, "SetMapType(ScalarFiniteElement self, int M)"}, - { "ScalarFiniteElement_NodalLocalInterpolation", _wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS, "NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_ScalarLocalInterpolation", _wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS, "ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, - { "ScalarFiniteElement_GetDofToQuad", _wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "ScalarFiniteElement_SetMapType", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_SetMapType, METH_VARARGS|METH_KEYWORDS, "SetMapType(ScalarFiniteElement self, int M)"}, + { "ScalarFiniteElement_NodalLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_NodalLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "NodalLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_ScalarLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_ScalarLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "ScalarLocalInterpolation(ScalarFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I, ScalarFiniteElement fine_fe)"}, + { "ScalarFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_ScalarFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(ScalarFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_ScalarFiniteElement", _wrap_delete_ScalarFiniteElement, METH_O, "delete_ScalarFiniteElement(ScalarFiniteElement self)"}, { "ScalarFiniteElement_swigregister", ScalarFiniteElement_swigregister, METH_O, NULL}, - { "NodalFiniteElement_GetLocalInterpolation", _wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_GetLocalRestriction", _wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "NodalFiniteElement_GetTransferMatrix", _wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "NodalFiniteElement_ProjectMatrixCoefficient", _wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "NodalFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(NodalFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "NodalFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "NodalFiniteElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(NodalFiniteElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "NodalFiniteElement_Project", _wrap_NodalFiniteElement_Project, METH_VARARGS, "\n" "Project(NodalFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(NodalFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "NodalFiniteElement_ProjectGrad", _wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS, "ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "NodalFiniteElement_ProjectDiv", _wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS, "ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, + { "NodalFiniteElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "NodalFiniteElement_ProjectDiv", (PyCFunction)(void(*)(void))_wrap_NodalFiniteElement_ProjectDiv, METH_VARARGS|METH_KEYWORDS, "ProjectDiv(NodalFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix div)"}, { "delete_NodalFiniteElement", _wrap_delete_NodalFiniteElement, METH_O, "delete_NodalFiniteElement(NodalFiniteElement self)"}, { "NodalFiniteElement_swigregister", NodalFiniteElement_swigregister, METH_O, NULL}, - { "PositiveFiniteElement_GetLocalInterpolation", _wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "PositiveFiniteElement_GetTransferMatrix", _wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(PositiveFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "PositiveFiniteElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_PositiveFiniteElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(PositiveFiniteElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "PositiveFiniteElement_Project", _wrap_PositiveFiniteElement_Project, METH_VARARGS, "\n" "Project(PositiveFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(PositiveFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53064,95 +52465,95 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_PositiveFiniteElement", _wrap_delete_PositiveFiniteElement, METH_O, "delete_PositiveFiniteElement(PositiveFiniteElement self)"}, { "PositiveFiniteElement_swigregister", PositiveFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorFiniteElement", _wrap_new_VectorFiniteElement, METH_VARARGS, "VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk)"}, + { "new_VectorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorFiniteElement(int D, mfem::Geometry::Type G, int Do, int O, int M, int F=Pk) -> VectorFiniteElement"}, { "delete_VectorFiniteElement", _wrap_delete_VectorFiniteElement, METH_O, "delete_VectorFiniteElement(VectorFiniteElement self)"}, { "VectorFiniteElement_swigregister", VectorFiniteElement_swigregister, METH_O, NULL}, { "VectorFiniteElement_swiginit", VectorFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_PointFiniteElement", _wrap_new_PointFiniteElement, METH_NOARGS, "new_PointFiniteElement() -> PointFiniteElement"}, - { "PointFiniteElement_CalcShape", _wrap_PointFiniteElement_CalcShape, METH_VARARGS, "CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "PointFiniteElement_CalcDShape", _wrap_PointFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "PointFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(PointFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "PointFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_PointFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(PointFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_PointFiniteElement", _wrap_delete_PointFiniteElement, METH_O, "delete_PointFiniteElement(PointFiniteElement self)"}, { "PointFiniteElement_swigregister", PointFiniteElement_swigregister, METH_O, NULL}, { "PointFiniteElement_swiginit", PointFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear1DFiniteElement", _wrap_new_Linear1DFiniteElement, METH_NOARGS, "new_Linear1DFiniteElement() -> Linear1DFiniteElement"}, - { "Linear1DFiniteElement_CalcShape", _wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear1DFiniteElement_CalcDShape", _wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Linear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Linear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Linear1DFiniteElement", _wrap_delete_Linear1DFiniteElement, METH_O, "delete_Linear1DFiniteElement(Linear1DFiniteElement self)"}, { "Linear1DFiniteElement_swigregister", Linear1DFiniteElement_swigregister, METH_O, NULL}, { "Linear1DFiniteElement_swiginit", Linear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear2DFiniteElement", _wrap_new_Linear2DFiniteElement, METH_NOARGS, "new_Linear2DFiniteElement() -> Linear2DFiniteElement"}, - { "Linear2DFiniteElement_CalcShape", _wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear2DFiniteElement_CalcDShape", _wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear2DFiniteElement_ProjectDelta", _wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Linear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Linear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(Linear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Linear2DFiniteElement", _wrap_delete_Linear2DFiniteElement, METH_O, "delete_Linear2DFiniteElement(Linear2DFiniteElement self)"}, { "Linear2DFiniteElement_swigregister", Linear2DFiniteElement_swigregister, METH_O, NULL}, { "Linear2DFiniteElement_swiginit", Linear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiLinear2DFiniteElement", _wrap_new_BiLinear2DFiniteElement, METH_NOARGS, "new_BiLinear2DFiniteElement() -> BiLinear2DFiniteElement"}, - { "BiLinear2DFiniteElement_CalcShape", _wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiLinear2DFiniteElement_CalcDShape", _wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiLinear2DFiniteElement_CalcHessian", _wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "BiLinear2DFiniteElement_ProjectDelta", _wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiLinear2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(BiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(BiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiLinear2DFiniteElement", _wrap_delete_BiLinear2DFiniteElement, METH_O, "delete_BiLinear2DFiniteElement(BiLinear2DFiniteElement self)"}, { "BiLinear2DFiniteElement_swigregister", BiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "BiLinear2DFiniteElement_swiginit", BiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussLinear2DFiniteElement", _wrap_new_GaussLinear2DFiniteElement, METH_NOARGS, "new_GaussLinear2DFiniteElement() -> GaussLinear2DFiniteElement"}, - { "GaussLinear2DFiniteElement_CalcShape", _wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussLinear2DFiniteElement_CalcDShape", _wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussLinear2DFiniteElement_ProjectDelta", _wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(GaussLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussLinear2DFiniteElement", _wrap_delete_GaussLinear2DFiniteElement, METH_O, "delete_GaussLinear2DFiniteElement(GaussLinear2DFiniteElement self)"}, { "GaussLinear2DFiniteElement_swigregister", GaussLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussLinear2DFiniteElement_swiginit", GaussLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiLinear2DFiniteElement", _wrap_new_GaussBiLinear2DFiniteElement, METH_NOARGS, "new_GaussBiLinear2DFiniteElement() -> GaussBiLinear2DFiniteElement"}, - { "GaussBiLinear2DFiniteElement_CalcShape", _wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiLinear2DFiniteElement_CalcDShape", _wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "GaussBiLinear2DFiniteElement_ProjectDelta", _wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, + { "GaussBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiLinear2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_GaussBiLinear2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(GaussBiLinear2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_GaussBiLinear2DFiniteElement", _wrap_delete_GaussBiLinear2DFiniteElement, METH_O, "delete_GaussBiLinear2DFiniteElement(GaussBiLinear2DFiniteElement self)"}, { "GaussBiLinear2DFiniteElement_swigregister", GaussBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiLinear2DFiniteElement_swiginit", GaussBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1OnQuadFiniteElement", _wrap_new_P1OnQuadFiniteElement, METH_NOARGS, "new_P1OnQuadFiniteElement() -> P1OnQuadFiniteElement"}, - { "P1OnQuadFiniteElement_CalcShape", _wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1OnQuadFiniteElement_CalcDShape", _wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P1OnQuadFiniteElement_ProjectDelta", _wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, + { "P1OnQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P1OnQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1OnQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P1OnQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1OnQuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P1OnQuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P1OnQuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P1OnQuadFiniteElement", _wrap_delete_P1OnQuadFiniteElement, METH_O, "delete_P1OnQuadFiniteElement(P1OnQuadFiniteElement self)"}, { "P1OnQuadFiniteElement_swigregister", P1OnQuadFiniteElement_swigregister, METH_O, NULL}, { "P1OnQuadFiniteElement_swiginit", P1OnQuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad1DFiniteElement", _wrap_new_Quad1DFiniteElement, METH_NOARGS, "new_Quad1DFiniteElement() -> Quad1DFiniteElement"}, - { "Quad1DFiniteElement_CalcShape", _wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad1DFiniteElement_CalcDShape", _wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Quad1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Quad1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quad1DFiniteElement", _wrap_delete_Quad1DFiniteElement, METH_O, "delete_Quad1DFiniteElement(Quad1DFiniteElement self)"}, { "Quad1DFiniteElement_swigregister", Quad1DFiniteElement_swigregister, METH_O, NULL}, { "Quad1DFiniteElement_swiginit", Quad1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_QuadPos1DFiniteElement", _wrap_new_QuadPos1DFiniteElement, METH_NOARGS, "new_QuadPos1DFiniteElement() -> QuadPos1DFiniteElement"}, - { "QuadPos1DFiniteElement_CalcShape", _wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "QuadPos1DFiniteElement_CalcDShape", _wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "QuadPos1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(QuadPos1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "QuadPos1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_QuadPos1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(QuadPos1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_QuadPos1DFiniteElement", _wrap_delete_QuadPos1DFiniteElement, METH_O, "delete_QuadPos1DFiniteElement(QuadPos1DFiniteElement self)"}, { "QuadPos1DFiniteElement_swigregister", QuadPos1DFiniteElement_swigregister, METH_O, NULL}, { "QuadPos1DFiniteElement_swiginit", QuadPos1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quad2DFiniteElement", _wrap_new_Quad2DFiniteElement, METH_NOARGS, "new_Quad2DFiniteElement() -> Quad2DFiniteElement"}, - { "Quad2DFiniteElement_CalcShape", _wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quad2DFiniteElement_CalcDShape", _wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Quad2DFiniteElement_CalcHessian", _wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, - { "Quad2DFiniteElement_ProjectDelta", _wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, + { "Quad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Quad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quad2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(Quad2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Quad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Quad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(Quad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_Quad2DFiniteElement", _wrap_delete_Quad2DFiniteElement, METH_O, "delete_Quad2DFiniteElement(Quad2DFiniteElement self)"}, { "Quad2DFiniteElement_swigregister", Quad2DFiniteElement_swigregister, METH_O, NULL}, { "Quad2DFiniteElement_swiginit", Quad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussQuad2DFiniteElement", _wrap_new_GaussQuad2DFiniteElement, METH_NOARGS, "new_GaussQuad2DFiniteElement() -> GaussQuad2DFiniteElement"}, - { "GaussQuad2DFiniteElement_CalcShape", _wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussQuad2DFiniteElement_CalcDShape", _wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussQuad2DFiniteElement", _wrap_delete_GaussQuad2DFiniteElement, METH_O, "delete_GaussQuad2DFiniteElement(GaussQuad2DFiniteElement self)"}, { "GaussQuad2DFiniteElement_swigregister", GaussQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussQuad2DFiniteElement_swiginit", GaussQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuad2DFiniteElement", _wrap_new_BiQuad2DFiniteElement, METH_NOARGS, "new_BiQuad2DFiniteElement() -> BiQuad2DFiniteElement"}, - { "BiQuad2DFiniteElement_CalcShape", _wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuad2DFiniteElement_CalcDShape", _wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuad2DFiniteElement_ProjectDelta", _wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuad2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuad2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(BiQuad2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuad2DFiniteElement", _wrap_delete_BiQuad2DFiniteElement, METH_O, "delete_BiQuad2DFiniteElement(BiQuad2DFiniteElement self)"}, { "BiQuad2DFiniteElement_swigregister", BiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuad2DFiniteElement_swiginit", BiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiQuadPos2DFiniteElement", _wrap_new_BiQuadPos2DFiniteElement, METH_NOARGS, "new_BiQuadPos2DFiniteElement() -> BiQuadPos2DFiniteElement"}, - { "BiQuadPos2DFiniteElement_CalcShape", _wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiQuadPos2DFiniteElement_CalcDShape", _wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiQuadPos2DFiniteElement_GetLocalInterpolation", _wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "BiQuadPos2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiQuadPos2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiQuadPos2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiQuadPos2DFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(BiQuadPos2DFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "BiQuadPos2DFiniteElement_Project", _wrap_BiQuadPos2DFiniteElement_Project, METH_VARARGS, "\n" "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53160,93 +52561,93 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(BiQuadPos2DFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(BiQuadPos2DFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" ""}, - { "BiQuadPos2DFiniteElement_ProjectDelta", _wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, + { "BiQuadPos2DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_BiQuadPos2DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(BiQuadPos2DFiniteElement self, int vertex, Vector dofs)"}, { "delete_BiQuadPos2DFiniteElement", _wrap_delete_BiQuadPos2DFiniteElement, METH_O, "delete_BiQuadPos2DFiniteElement(BiQuadPos2DFiniteElement self)"}, { "BiQuadPos2DFiniteElement_swigregister", BiQuadPos2DFiniteElement_swigregister, METH_O, NULL}, { "BiQuadPos2DFiniteElement_swiginit", BiQuadPos2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_GaussBiQuad2DFiniteElement", _wrap_new_GaussBiQuad2DFiniteElement, METH_NOARGS, "new_GaussBiQuad2DFiniteElement() -> GaussBiQuad2DFiniteElement"}, - { "GaussBiQuad2DFiniteElement_CalcShape", _wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "GaussBiQuad2DFiniteElement_CalcDShape", _wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "GaussBiQuad2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "GaussBiQuad2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_GaussBiQuad2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(GaussBiQuad2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_GaussBiQuad2DFiniteElement", _wrap_delete_GaussBiQuad2DFiniteElement, METH_O, "delete_GaussBiQuad2DFiniteElement(GaussBiQuad2DFiniteElement self)"}, { "GaussBiQuad2DFiniteElement_swigregister", GaussBiQuad2DFiniteElement_swigregister, METH_O, NULL}, { "GaussBiQuad2DFiniteElement_swiginit", GaussBiQuad2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_BiCubic2DFiniteElement", _wrap_new_BiCubic2DFiniteElement, METH_NOARGS, "new_BiCubic2DFiniteElement() -> BiCubic2DFiniteElement"}, - { "BiCubic2DFiniteElement_CalcShape", _wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "BiCubic2DFiniteElement_CalcDShape", _wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "BiCubic2DFiniteElement_CalcHessian", _wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "BiCubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(BiCubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "BiCubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "BiCubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_BiCubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(BiCubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_BiCubic2DFiniteElement", _wrap_delete_BiCubic2DFiniteElement, METH_O, "delete_BiCubic2DFiniteElement(BiCubic2DFiniteElement self)"}, { "BiCubic2DFiniteElement_swigregister", BiCubic2DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic2DFiniteElement_swiginit", BiCubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic1DFiniteElement", _wrap_new_Cubic1DFiniteElement, METH_NOARGS, "new_Cubic1DFiniteElement() -> Cubic1DFiniteElement"}, - { "Cubic1DFiniteElement_CalcShape", _wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic1DFiniteElement_CalcDShape", _wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Cubic1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Cubic1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic1DFiniteElement", _wrap_delete_Cubic1DFiniteElement, METH_O, "delete_Cubic1DFiniteElement(Cubic1DFiniteElement self)"}, { "Cubic1DFiniteElement_swigregister", Cubic1DFiniteElement_swigregister, METH_O, NULL}, { "Cubic1DFiniteElement_swiginit", Cubic1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic2DFiniteElement", _wrap_new_Cubic2DFiniteElement, METH_NOARGS, "new_Cubic2DFiniteElement() -> Cubic2DFiniteElement"}, - { "Cubic2DFiniteElement_CalcShape", _wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic2DFiniteElement_CalcDShape", _wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Cubic2DFiniteElement_CalcHessian", _wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, + { "Cubic2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Cubic2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_Cubic2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(Cubic2DFiniteElement self, IntegrationPoint ip, DenseMatrix h)"}, { "delete_Cubic2DFiniteElement", _wrap_delete_Cubic2DFiniteElement, METH_O, "delete_Cubic2DFiniteElement(Cubic2DFiniteElement self)"}, { "Cubic2DFiniteElement_swigregister", Cubic2DFiniteElement_swigregister, METH_O, NULL}, { "Cubic2DFiniteElement_swiginit", Cubic2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Cubic3DFiniteElement", _wrap_new_Cubic3DFiniteElement, METH_NOARGS, "new_Cubic3DFiniteElement() -> Cubic3DFiniteElement"}, - { "Cubic3DFiniteElement_CalcShape", _wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Cubic3DFiniteElement_CalcDShape", _wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Cubic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Cubic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Cubic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Cubic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Cubic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Cubic3DFiniteElement", _wrap_delete_Cubic3DFiniteElement, METH_O, "delete_Cubic3DFiniteElement(Cubic3DFiniteElement self)"}, { "Cubic3DFiniteElement_swigregister", Cubic3DFiniteElement_swigregister, METH_O, NULL}, { "Cubic3DFiniteElement_swiginit", Cubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TriangleFiniteElement", _wrap_new_P0TriangleFiniteElement, METH_NOARGS, "new_P0TriangleFiniteElement() -> P0TriangleFiniteElement"}, - { "P0TriangleFiniteElement_CalcShape", _wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TriangleFiniteElement_CalcDShape", _wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TriangleFiniteElement_ProjectDelta", _wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, + { "P0TriangleFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0TriangleFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TriangleFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TriangleFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TriangleFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0TriangleFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TriangleFiniteElement", _wrap_delete_P0TriangleFiniteElement, METH_O, "delete_P0TriangleFiniteElement(P0TriangleFiniteElement self)"}, { "P0TriangleFiniteElement_swigregister", P0TriangleFiniteElement_swigregister, METH_O, NULL}, { "P0TriangleFiniteElement_swiginit", P0TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0QuadFiniteElement", _wrap_new_P0QuadFiniteElement, METH_NOARGS, "new_P0QuadFiniteElement() -> P0QuadFiniteElement"}, - { "P0QuadFiniteElement_CalcShape", _wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0QuadFiniteElement_CalcDShape", _wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0QuadFiniteElement_ProjectDelta", _wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, + { "P0QuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0QuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0QuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0QuadFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0QuadFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0QuadFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0QuadFiniteElement", _wrap_delete_P0QuadFiniteElement, METH_O, "delete_P0QuadFiniteElement(P0QuadFiniteElement self)"}, { "P0QuadFiniteElement_swigregister", P0QuadFiniteElement_swigregister, METH_O, NULL}, { "P0QuadFiniteElement_swiginit", P0QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Linear3DFiniteElement", _wrap_new_Linear3DFiniteElement, METH_NOARGS, "new_Linear3DFiniteElement() -> Linear3DFiniteElement"}, - { "Linear3DFiniteElement_CalcShape", _wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Linear3DFiniteElement_CalcDShape", _wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "Linear3DFiniteElement_ProjectDelta", _wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, - { "Linear3DFiniteElement_GetFaceDofs", _wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS, "GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, + { "Linear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Linear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Linear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Linear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Linear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(Linear3DFiniteElement self, int vertex, Vector dofs)"}, + { "Linear3DFiniteElement_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_Linear3DFiniteElement_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(Linear3DFiniteElement self, int face, int ** dofs, int * ndofs)"}, { "delete_Linear3DFiniteElement", _wrap_delete_Linear3DFiniteElement, METH_O, "delete_Linear3DFiniteElement(Linear3DFiniteElement self)"}, { "Linear3DFiniteElement_swigregister", Linear3DFiniteElement_swigregister, METH_O, NULL}, { "Linear3DFiniteElement_swiginit", Linear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Quadratic3DFiniteElement", _wrap_new_Quadratic3DFiniteElement, METH_NOARGS, "new_Quadratic3DFiniteElement() -> Quadratic3DFiniteElement"}, - { "Quadratic3DFiniteElement_CalcShape", _wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Quadratic3DFiniteElement_CalcDShape", _wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "Quadratic3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Quadratic3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Quadratic3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Quadratic3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Quadratic3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Quadratic3DFiniteElement", _wrap_delete_Quadratic3DFiniteElement, METH_O, "delete_Quadratic3DFiniteElement(Quadratic3DFiniteElement self)"}, { "Quadratic3DFiniteElement_swigregister", Quadratic3DFiniteElement_swigregister, METH_O, NULL}, { "Quadratic3DFiniteElement_swiginit", Quadratic3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_TriLinear3DFiniteElement", _wrap_new_TriLinear3DFiniteElement, METH_NOARGS, "new_TriLinear3DFiniteElement() -> TriLinear3DFiniteElement"}, - { "TriLinear3DFiniteElement_CalcShape", _wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "TriLinear3DFiniteElement_CalcDShape", _wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "TriLinear3DFiniteElement_ProjectDelta", _wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, + { "TriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(TriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "TriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(TriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "TriLinear3DFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_TriLinear3DFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(TriLinear3DFiniteElement self, int vertex, Vector dofs)"}, { "delete_TriLinear3DFiniteElement", _wrap_delete_TriLinear3DFiniteElement, METH_O, "delete_TriLinear3DFiniteElement(TriLinear3DFiniteElement self)"}, { "TriLinear3DFiniteElement_swigregister", TriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "TriLinear3DFiniteElement_swiginit", TriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartFiniteElement", _wrap_new_CrouzeixRaviartFiniteElement, METH_NOARGS, "new_CrouzeixRaviartFiniteElement() -> CrouzeixRaviartFiniteElement"}, - { "CrouzeixRaviartFiniteElement_CalcShape", _wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartFiniteElement_CalcDShape", _wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "CrouzeixRaviartFiniteElement_ProjectDelta", _wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, + { "CrouzeixRaviartFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(CrouzeixRaviartFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(CrouzeixRaviartFiniteElement self, int vertex, Vector dofs)"}, { "delete_CrouzeixRaviartFiniteElement", _wrap_delete_CrouzeixRaviartFiniteElement, METH_O, "delete_CrouzeixRaviartFiniteElement(CrouzeixRaviartFiniteElement self)"}, { "CrouzeixRaviartFiniteElement_swigregister", CrouzeixRaviartFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartFiniteElement_swiginit", CrouzeixRaviartFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_CrouzeixRaviartQuadFiniteElement", _wrap_new_CrouzeixRaviartQuadFiniteElement, METH_NOARGS, "new_CrouzeixRaviartQuadFiniteElement() -> CrouzeixRaviartQuadFiniteElement"}, - { "CrouzeixRaviartQuadFiniteElement_CalcShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS, "CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "CrouzeixRaviartQuadFiniteElement_CalcDShape", _wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "CrouzeixRaviartQuadFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_CrouzeixRaviartQuadFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(CrouzeixRaviartQuadFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_CrouzeixRaviartQuadFiniteElement", _wrap_delete_CrouzeixRaviartQuadFiniteElement, METH_O, "delete_CrouzeixRaviartQuadFiniteElement(CrouzeixRaviartQuadFiniteElement self)"}, { "CrouzeixRaviartQuadFiniteElement_swigregister", CrouzeixRaviartQuadFiniteElement_swigregister, METH_O, NULL}, { "CrouzeixRaviartQuadFiniteElement_swiginit", CrouzeixRaviartQuadFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_P0SegmentFiniteElement", _wrap_new_P0SegmentFiniteElement, METH_VARARGS, "P0SegmentFiniteElement(int Ord=0)"}, - { "P0SegmentFiniteElement_CalcShape", _wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0SegmentFiniteElement_CalcDShape", _wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_P0SegmentFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_P0SegmentFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_P0SegmentFiniteElement(int Ord=0) -> P0SegmentFiniteElement"}, + { "P0SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P0SegmentFiniteElement", _wrap_delete_P0SegmentFiniteElement, METH_O, "delete_P0SegmentFiniteElement(P0SegmentFiniteElement self)"}, { "P0SegmentFiniteElement_swigregister", P0SegmentFiniteElement_swigregister, METH_O, NULL}, { "P0SegmentFiniteElement_swiginit", P0SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -53255,8 +52656,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TriangleFiniteElement_CalcDivShape", _wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TriangleFiniteElement_GetLocalInterpolation", _wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TriangleFiniteElement_Project", _wrap_RT0TriangleFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53271,8 +52672,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0QuadFiniteElement_CalcDivShape", _wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0QuadFiniteElement_GetLocalInterpolation", _wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0QuadFiniteElement_Project", _wrap_RT0QuadFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53287,8 +52688,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT1TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1TriangleFiniteElement_CalcDivShape", _wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1TriangleFiniteElement_GetLocalInterpolation", _wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT1TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1TriangleFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1TriangleFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT1TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1TriangleFiniteElement_Project", _wrap_RT1TriangleFiniteElement_Project, METH_VARARGS, "\n" "Project(RT1TriangleFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT1TriangleFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53303,8 +52704,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT1QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1QuadFiniteElement_CalcDivShape", _wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1QuadFiniteElement_GetLocalInterpolation", _wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT1QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT1QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1QuadFiniteElement_Project", _wrap_RT1QuadFiniteElement_Project, METH_VARARGS, "\n" "Project(RT1QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT1QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53319,7 +52720,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT2TriangleFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT2TriangleFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2TriangleFiniteElement_CalcDivShape", _wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2TriangleFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2TriangleFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT2TriangleFiniteElement self, IntegrationPoint ip, Vector divshape)"}, { "delete_RT2TriangleFiniteElement", _wrap_delete_RT2TriangleFiniteElement, METH_O, "delete_RT2TriangleFiniteElement(RT2TriangleFiniteElement self)"}, { "RT2TriangleFiniteElement_swigregister", RT2TriangleFiniteElement_swigregister, METH_O, NULL}, { "RT2TriangleFiniteElement_swiginit", RT2TriangleFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -53328,8 +52729,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT2QuadFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT2QuadFiniteElement_CalcDivShape", _wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT2QuadFiniteElement_GetLocalInterpolation", _wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT2QuadFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT2QuadFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT2QuadFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT2QuadFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT2QuadFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT2QuadFiniteElement_Project", _wrap_RT2QuadFiniteElement_Project, METH_VARARGS, "\n" "Project(RT2QuadFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT2QuadFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53340,76 +52741,76 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "RT2QuadFiniteElement_swigregister", RT2QuadFiniteElement_swigregister, METH_O, NULL}, { "RT2QuadFiniteElement_swiginit", RT2QuadFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1SegmentFiniteElement", _wrap_new_P1SegmentFiniteElement, METH_NOARGS, "new_P1SegmentFiniteElement() -> P1SegmentFiniteElement"}, - { "P1SegmentFiniteElement_CalcShape", _wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1SegmentFiniteElement_CalcDShape", _wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P1SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P1SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1SegmentFiniteElement", _wrap_delete_P1SegmentFiniteElement, METH_O, "delete_P1SegmentFiniteElement(P1SegmentFiniteElement self)"}, { "P1SegmentFiniteElement_swigregister", P1SegmentFiniteElement_swigregister, METH_O, NULL}, { "P1SegmentFiniteElement_swiginit", P1SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P2SegmentFiniteElement", _wrap_new_P2SegmentFiniteElement, METH_NOARGS, "new_P2SegmentFiniteElement() -> P2SegmentFiniteElement"}, - { "P2SegmentFiniteElement_CalcShape", _wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P2SegmentFiniteElement_CalcDShape", _wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P2SegmentFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P2SegmentFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P2SegmentFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P2SegmentFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P2SegmentFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P2SegmentFiniteElement", _wrap_delete_P2SegmentFiniteElement, METH_O, "delete_P2SegmentFiniteElement(P2SegmentFiniteElement self)"}, { "P2SegmentFiniteElement_swigregister", P2SegmentFiniteElement_swigregister, METH_O, NULL}, { "P2SegmentFiniteElement_swiginit", P2SegmentFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_Lagrange1DFiniteElement", _wrap_new_Lagrange1DFiniteElement, METH_O, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, - { "Lagrange1DFiniteElement_CalcShape", _wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "Lagrange1DFiniteElement_CalcDShape", _wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_Lagrange1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_Lagrange1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_Lagrange1DFiniteElement(int degree) -> Lagrange1DFiniteElement"}, + { "Lagrange1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(Lagrange1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "Lagrange1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_Lagrange1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(Lagrange1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_Lagrange1DFiniteElement", _wrap_delete_Lagrange1DFiniteElement, METH_O, "delete_Lagrange1DFiniteElement(Lagrange1DFiniteElement self)"}, { "Lagrange1DFiniteElement_swigregister", Lagrange1DFiniteElement_swigregister, METH_O, NULL}, { "Lagrange1DFiniteElement_swiginit", Lagrange1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P1TetNonConfFiniteElement", _wrap_new_P1TetNonConfFiniteElement, METH_NOARGS, "new_P1TetNonConfFiniteElement() -> P1TetNonConfFiniteElement"}, - { "P1TetNonConfFiniteElement_CalcShape", _wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P1TetNonConfFiniteElement_CalcDShape", _wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P1TetNonConfFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P1TetNonConfFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P1TetNonConfFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P1TetNonConfFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_P1TetNonConfFiniteElement", _wrap_delete_P1TetNonConfFiniteElement, METH_O, "delete_P1TetNonConfFiniteElement(P1TetNonConfFiniteElement self)"}, { "P1TetNonConfFiniteElement_swigregister", P1TetNonConfFiniteElement_swigregister, METH_O, NULL}, { "P1TetNonConfFiniteElement_swiginit", P1TetNonConfFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0TetFiniteElement", _wrap_new_P0TetFiniteElement, METH_NOARGS, "new_P0TetFiniteElement() -> P0TetFiniteElement"}, - { "P0TetFiniteElement_CalcShape", _wrap_P0TetFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0TetFiniteElement_CalcDShape", _wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0TetFiniteElement_ProjectDelta", _wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, + { "P0TetFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0TetFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0TetFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0TetFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0TetFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0TetFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0TetFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0TetFiniteElement", _wrap_delete_P0TetFiniteElement, METH_O, "delete_P0TetFiniteElement(P0TetFiniteElement self)"}, { "P0TetFiniteElement_swigregister", P0TetFiniteElement_swigregister, METH_O, NULL}, { "P0TetFiniteElement_swiginit", P0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_P0HexFiniteElement", _wrap_new_P0HexFiniteElement, METH_NOARGS, "new_P0HexFiniteElement() -> P0HexFiniteElement"}, - { "P0HexFiniteElement_CalcShape", _wrap_P0HexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "P0HexFiniteElement_CalcDShape", _wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "P0HexFiniteElement_ProjectDelta", _wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS, "ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, + { "P0HexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(P0HexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "P0HexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(P0HexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "P0HexFiniteElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_P0HexFiniteElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(P0HexFiniteElement self, int vertex, Vector dofs)"}, { "delete_P0HexFiniteElement", _wrap_delete_P0HexFiniteElement, METH_O, "delete_P0HexFiniteElement(P0HexFiniteElement self)"}, { "P0HexFiniteElement_swigregister", P0HexFiniteElement_swigregister, METH_O, NULL}, { "P0HexFiniteElement_swiginit", P0HexFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_LagrangeHexFiniteElement", _wrap_new_LagrangeHexFiniteElement, METH_O, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, - { "LagrangeHexFiniteElement_CalcShape", _wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "LagrangeHexFiniteElement_CalcDShape", _wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_LagrangeHexFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_LagrangeHexFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_LagrangeHexFiniteElement(int degree) -> LagrangeHexFiniteElement"}, + { "LagrangeHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(LagrangeHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "LagrangeHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_LagrangeHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(LagrangeHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_LagrangeHexFiniteElement", _wrap_delete_LagrangeHexFiniteElement, METH_O, "delete_LagrangeHexFiniteElement(LagrangeHexFiniteElement self)"}, { "LagrangeHexFiniteElement_swigregister", LagrangeHexFiniteElement_swigregister, METH_O, NULL}, { "LagrangeHexFiniteElement_swiginit", LagrangeHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear1DFiniteElement", _wrap_new_RefinedLinear1DFiniteElement, METH_NOARGS, "new_RefinedLinear1DFiniteElement() -> RefinedLinear1DFiniteElement"}, - { "RefinedLinear1DFiniteElement_CalcShape", _wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear1DFiniteElement_CalcDShape", _wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedLinear1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear1DFiniteElement", _wrap_delete_RefinedLinear1DFiniteElement, METH_O, "delete_RefinedLinear1DFiniteElement(RefinedLinear1DFiniteElement self)"}, { "RefinedLinear1DFiniteElement_swigregister", RefinedLinear1DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear1DFiniteElement_swiginit", RefinedLinear1DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear2DFiniteElement", _wrap_new_RefinedLinear2DFiniteElement, METH_NOARGS, "new_RefinedLinear2DFiniteElement() -> RefinedLinear2DFiniteElement"}, - { "RefinedLinear2DFiniteElement_CalcShape", _wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear2DFiniteElement_CalcDShape", _wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear2DFiniteElement", _wrap_delete_RefinedLinear2DFiniteElement, METH_O, "delete_RefinedLinear2DFiniteElement(RefinedLinear2DFiniteElement self)"}, { "RefinedLinear2DFiniteElement_swigregister", RefinedLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear2DFiniteElement_swiginit", RefinedLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedLinear3DFiniteElement", _wrap_new_RefinedLinear3DFiniteElement, METH_NOARGS, "new_RefinedLinear3DFiniteElement() -> RefinedLinear3DFiniteElement"}, - { "RefinedLinear3DFiniteElement_CalcShape", _wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedLinear3DFiniteElement_CalcDShape", _wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedLinear3DFiniteElement", _wrap_delete_RefinedLinear3DFiniteElement, METH_O, "delete_RefinedLinear3DFiniteElement(RefinedLinear3DFiniteElement self)"}, { "RefinedLinear3DFiniteElement_swigregister", RefinedLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedLinear3DFiniteElement_swiginit", RefinedLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedBiLinear2DFiniteElement", _wrap_new_RefinedBiLinear2DFiniteElement, METH_NOARGS, "new_RefinedBiLinear2DFiniteElement() -> RefinedBiLinear2DFiniteElement"}, - { "RefinedBiLinear2DFiniteElement_CalcShape", _wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedBiLinear2DFiniteElement_CalcDShape", _wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedBiLinear2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedBiLinear2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedBiLinear2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedBiLinear2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedBiLinear2DFiniteElement", _wrap_delete_RefinedBiLinear2DFiniteElement, METH_O, "delete_RefinedBiLinear2DFiniteElement(RefinedBiLinear2DFiniteElement self)"}, { "RefinedBiLinear2DFiniteElement_swigregister", RefinedBiLinear2DFiniteElement_swigregister, METH_O, NULL}, { "RefinedBiLinear2DFiniteElement_swiginit", RefinedBiLinear2DFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RefinedTriLinear3DFiniteElement", _wrap_new_RefinedTriLinear3DFiniteElement, METH_NOARGS, "new_RefinedTriLinear3DFiniteElement() -> RefinedTriLinear3DFiniteElement"}, - { "RefinedTriLinear3DFiniteElement_CalcShape", _wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RefinedTriLinear3DFiniteElement_CalcDShape", _wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RefinedTriLinear3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RefinedTriLinear3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RefinedTriLinear3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RefinedTriLinear3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RefinedTriLinear3DFiniteElement", _wrap_delete_RefinedTriLinear3DFiniteElement, METH_O, "delete_RefinedTriLinear3DFiniteElement(RefinedTriLinear3DFiniteElement self)"}, { "RefinedTriLinear3DFiniteElement_swigregister", RefinedTriLinear3DFiniteElement_swigregister, METH_O, NULL}, { "RefinedTriLinear3DFiniteElement_swiginit", RefinedTriLinear3DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -53418,8 +52819,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1HexFiniteElement_CalcCurlShape", _wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1HexFiniteElement_GetLocalInterpolation", _wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1HexFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(Nedelec1HexFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(Nedelec1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1HexFiniteElement_Project", _wrap_Nedelec1HexFiniteElement_Project, METH_VARARGS, "\n" "Project(Nedelec1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(Nedelec1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53434,8 +52835,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "Nedelec1TetFiniteElement_CalcCurlShape", _wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "Nedelec1TetFiniteElement_GetLocalInterpolation", _wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "Nedelec1TetFiniteElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(Nedelec1TetFiniteElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "Nedelec1TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_Nedelec1TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(Nedelec1TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "Nedelec1TetFiniteElement_Project", _wrap_Nedelec1TetFiniteElement_Project, METH_VARARGS, "\n" "Project(Nedelec1TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(Nedelec1TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53450,8 +52851,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0HexFiniteElement_CalcDivShape", _wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0HexFiniteElement_GetLocalInterpolation", _wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0HexFiniteElement_Project", _wrap_RT0HexFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53466,8 +52867,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT1HexFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT1HexFiniteElement_CalcDivShape", _wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT1HexFiniteElement_GetLocalInterpolation", _wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT1HexFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT1HexFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT1HexFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT1HexFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT1HexFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT1HexFiniteElement_Project", _wrap_RT1HexFiniteElement_Project, METH_VARARGS, "\n" "Project(RT1HexFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT1HexFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53482,8 +52883,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "CalcVShape(RT0TetFiniteElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT0TetFiniteElement_CalcDivShape", _wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT0TetFiniteElement_GetLocalInterpolation", _wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT0TetFiniteElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT0TetFiniteElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT0TetFiniteElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT0TetFiniteElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT0TetFiniteElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "RT0TetFiniteElement_Project", _wrap_RT0TetFiniteElement_Project, METH_VARARGS, "\n" "Project(RT0TetFiniteElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT0TetFiniteElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53494,29 +52895,29 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "RT0TetFiniteElement_swigregister", RT0TetFiniteElement_swigregister, METH_O, NULL}, { "RT0TetFiniteElement_swiginit", RT0TetFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_RotTriLinearHexFiniteElement", _wrap_new_RotTriLinearHexFiniteElement, METH_NOARGS, "new_RotTriLinearHexFiniteElement() -> RotTriLinearHexFiniteElement"}, - { "RotTriLinearHexFiniteElement_CalcShape", _wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS, "CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "RotTriLinearHexFiniteElement_CalcDShape", _wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "RotTriLinearHexFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "RotTriLinearHexFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_RotTriLinearHexFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(RotTriLinearHexFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_RotTriLinearHexFiniteElement", _wrap_delete_RotTriLinearHexFiniteElement, METH_O, "delete_RotTriLinearHexFiniteElement(RotTriLinearHexFiniteElement self)"}, { "RotTriLinearHexFiniteElement_swigregister", RotTriLinearHexFiniteElement_swigregister, METH_O, NULL}, { "RotTriLinearHexFiniteElement_swiginit", RotTriLinearHexFiniteElement_swiginit, METH_VARARGS, NULL}, { "new_Poly_1D", _wrap_new_Poly_1D, METH_NOARGS, "new_Poly_1D() -> Poly_1D"}, - { "Poly_1D_Binom", _wrap_Poly_1D_Binom, METH_O, "Binom(int const p) -> int const *"}, - { "Poly_1D_GetPoints", _wrap_Poly_1D_GetPoints, METH_VARARGS, "GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, - { "Poly_1D_OpenPoints", _wrap_Poly_1D_OpenPoints, METH_VARARGS, "OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const"}, - { "Poly_1D_ClosedPoints", _wrap_Poly_1D_ClosedPoints, METH_VARARGS, "ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const"}, - { "Poly_1D_GetBasis", _wrap_Poly_1D_GetBasis, METH_VARARGS, "GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, + { "Poly_1D_Binom", (PyCFunction)(void(*)(void))_wrap_Poly_1D_Binom, METH_VARARGS|METH_KEYWORDS, "Binom(int const p) -> int const *"}, + { "Poly_1D_GetPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetPoints, METH_VARARGS|METH_KEYWORDS, "GetPoints(Poly_1D self, int const p, int const btype) -> double const *"}, + { "Poly_1D_OpenPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_OpenPoints, METH_VARARGS|METH_KEYWORDS, "OpenPoints(Poly_1D self, int const p, int const btype=GaussLegendre) -> double const *"}, + { "Poly_1D_ClosedPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ClosedPoints, METH_VARARGS|METH_KEYWORDS, "ClosedPoints(Poly_1D self, int const p, int const btype=GaussLobatto) -> double const *"}, + { "Poly_1D_GetBasis", (PyCFunction)(void(*)(void))_wrap_Poly_1D_GetBasis, METH_VARARGS|METH_KEYWORDS, "GetBasis(Poly_1D self, int const p, int const btype) -> mfem::Poly_1D::Basis &"}, { "Poly_1D_CalcBasis", _wrap_Poly_1D_CalcBasis, METH_VARARGS, "\n" "CalcBasis(int const p, double const x, double * u)\n" "CalcBasis(int const p, double const x, double * u, double * d)\n" "CalcBasis(int const p, double const x, double * u, double * d, double * dd)\n" ""}, - { "Poly_1D_CalcDelta", _wrap_Poly_1D_CalcDelta, METH_VARARGS, "CalcDelta(int const p, double const x) -> double"}, - { "Poly_1D_ChebyshevPoints", _wrap_Poly_1D_ChebyshevPoints, METH_VARARGS, "ChebyshevPoints(int const p, double * x)"}, + { "Poly_1D_CalcDelta", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDelta, METH_VARARGS|METH_KEYWORDS, "CalcDelta(int const p, double const x) -> double"}, + { "Poly_1D_ChebyshevPoints", (PyCFunction)(void(*)(void))_wrap_Poly_1D_ChebyshevPoints, METH_VARARGS|METH_KEYWORDS, "ChebyshevPoints(int const p, double * x)"}, { "Poly_1D_CalcBinomTerms", _wrap_Poly_1D_CalcBinomTerms, METH_VARARGS, "\n" "CalcBinomTerms(int const p, double const x, double const y, double * u)\n" "CalcBinomTerms(int const p, double const x, double const y, double * u, double * d)\n" ""}, - { "Poly_1D_CalcDBinomTerms", _wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS, "CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, + { "Poly_1D_CalcDBinomTerms", (PyCFunction)(void(*)(void))_wrap_Poly_1D_CalcDBinomTerms, METH_VARARGS|METH_KEYWORDS, "CalcDBinomTerms(int const p, double const x, double const y, double * d)"}, { "Poly_1D_CalcBernstein", _wrap_Poly_1D_CalcBernstein, METH_VARARGS, "\n" "CalcBernstein(int const p, double const x, double * u)\n" "CalcBernstein(int const p, double const x, double * u, double * d)\n" @@ -53528,67 +52929,67 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_Poly_1D", _wrap_delete_Poly_1D, METH_O, "delete_Poly_1D(Poly_1D self)"}, { "Poly_1D_swigregister", Poly_1D_swigregister, METH_O, NULL}, { "Poly_1D_swiginit", Poly_1D_swiginit, METH_VARARGS, NULL}, - { "new_TensorBasisElement", _wrap_new_TensorBasisElement, METH_VARARGS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, + { "new_TensorBasisElement", (PyCFunction)(void(*)(void))_wrap_new_TensorBasisElement, METH_VARARGS|METH_KEYWORDS, "new_TensorBasisElement(int const dims, int const p, int const btype, mfem::TensorBasisElement::DofMapType const dmtype) -> TensorBasisElement"}, { "TensorBasisElement_GetBasisType", _wrap_TensorBasisElement_GetBasisType, METH_O, "GetBasisType(TensorBasisElement self) -> int"}, { "TensorBasisElement_GetBasis1D", _wrap_TensorBasisElement_GetBasis1D, METH_O, "GetBasis1D(TensorBasisElement self) -> mfem::Poly_1D::Basis const &"}, { "TensorBasisElement_GetDofMap", _wrap_TensorBasisElement_GetDofMap, METH_O, "GetDofMap(TensorBasisElement self) -> intArray"}, - { "TensorBasisElement_GetTensorProductGeometry", _wrap_TensorBasisElement_GetTensorProductGeometry, METH_O, "GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, - { "TensorBasisElement_Pow", _wrap_TensorBasisElement_Pow, METH_VARARGS, "Pow(int base, int dim) -> int"}, + { "TensorBasisElement_GetTensorProductGeometry", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_GetTensorProductGeometry, METH_VARARGS|METH_KEYWORDS, "GetTensorProductGeometry(int dim) -> mfem::Geometry::Type"}, + { "TensorBasisElement_Pow", (PyCFunction)(void(*)(void))_wrap_TensorBasisElement_Pow, METH_VARARGS|METH_KEYWORDS, "Pow(int base, int dim) -> int"}, { "delete_TensorBasisElement", _wrap_delete_TensorBasisElement, METH_O, "delete_TensorBasisElement(TensorBasisElement self)"}, { "TensorBasisElement_swigregister", TensorBasisElement_swigregister, METH_O, NULL}, { "TensorBasisElement_swiginit", TensorBasisElement_swiginit, METH_VARARGS, NULL}, - { "NodalTensorFiniteElement_GetDofToQuad", _wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "NodalTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_NodalTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(NodalTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_NodalTensorFiniteElement", _wrap_delete_NodalTensorFiniteElement, METH_O, "delete_NodalTensorFiniteElement(NodalTensorFiniteElement self)"}, { "NodalTensorFiniteElement_swigregister", NodalTensorFiniteElement_swigregister, METH_O, NULL}, - { "PositiveTensorFiniteElement_GetDofToQuad", _wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "PositiveTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_PositiveTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(PositiveTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, { "delete_PositiveTensorFiniteElement", _wrap_delete_PositiveTensorFiniteElement, METH_O, "delete_PositiveTensorFiniteElement(PositiveTensorFiniteElement self)"}, { "PositiveTensorFiniteElement_swigregister", PositiveTensorFiniteElement_swigregister, METH_O, NULL}, - { "new_VectorTensorFiniteElement", _wrap_new_VectorTensorFiniteElement, METH_VARARGS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, - { "VectorTensorFiniteElement_GetDofToQuad", _wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS, "GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetDofToQuadOpen", _wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS, "GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, - { "VectorTensorFiniteElement_GetTensorDofToQuad", _wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS, "GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, + { "new_VectorTensorFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_VectorTensorFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_VectorTensorFiniteElement(int const dims, int const d, int const p, int const cbtype, int const obtype, int const M, mfem::TensorBasisElement::DofMapType const dmtype) -> VectorTensorFiniteElement"}, + { "VectorTensorFiniteElement_GetDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetDofToQuadOpen", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetDofToQuadOpen, METH_VARARGS|METH_KEYWORDS, "GetDofToQuadOpen(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode) -> DofToQuad"}, + { "VectorTensorFiniteElement_GetTensorDofToQuad", (PyCFunction)(void(*)(void))_wrap_VectorTensorFiniteElement_GetTensorDofToQuad, METH_VARARGS|METH_KEYWORDS, "GetTensorDofToQuad(VectorTensorFiniteElement self, IntegrationRule ir, mfem::DofToQuad::Mode mode, bool const closed) -> DofToQuad"}, { "delete_VectorTensorFiniteElement", _wrap_delete_VectorTensorFiniteElement, METH_O, "delete_VectorTensorFiniteElement(VectorTensorFiniteElement self)"}, { "VectorTensorFiniteElement_swigregister", VectorTensorFiniteElement_swigregister, METH_O, NULL}, { "VectorTensorFiniteElement_swiginit", VectorTensorFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_SegmentElement", _wrap_new_H1_SegmentElement, METH_VARARGS, "H1_SegmentElement(int const p, int const btype=GaussLobatto)"}, - { "H1_SegmentElement_CalcShape", _wrap_H1_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_SegmentElement_CalcDShape", _wrap_H1_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_SegmentElement_ProjectDelta", _wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1_SegmentElement(int const p, int const btype=GaussLobatto) -> H1_SegmentElement"}, + { "H1_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1_SegmentElement", _wrap_delete_H1_SegmentElement, METH_O, "delete_H1_SegmentElement(H1_SegmentElement self)"}, { "H1_SegmentElement_swigregister", H1_SegmentElement_swigregister, METH_O, NULL}, { "H1_SegmentElement_swiginit", H1_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_QuadrilateralElement", _wrap_new_H1_QuadrilateralElement, METH_VARARGS, "H1_QuadrilateralElement(int const p, int const btype=GaussLobatto)"}, - { "H1_QuadrilateralElement_CalcShape", _wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_QuadrilateralElement_CalcDShape", _wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_QuadrilateralElement_ProjectDelta", _wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1_QuadrilateralElement(int const p, int const btype=GaussLobatto) -> H1_QuadrilateralElement"}, + { "H1_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1_QuadrilateralElement", _wrap_delete_H1_QuadrilateralElement, METH_O, "delete_H1_QuadrilateralElement(H1_QuadrilateralElement self)"}, { "H1_QuadrilateralElement_swigregister", H1_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1_QuadrilateralElement_swiginit", H1_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_HexahedronElement", _wrap_new_H1_HexahedronElement, METH_VARARGS, "H1_HexahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_HexahedronElement_CalcShape", _wrap_H1_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_HexahedronElement_CalcDShape", _wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_HexahedronElement_ProjectDelta", _wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_HexahedronElement(int const p, int const btype=GaussLobatto) -> H1_HexahedronElement"}, + { "H1_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1_HexahedronElement", _wrap_delete_H1_HexahedronElement, METH_O, "delete_H1_HexahedronElement(H1_HexahedronElement self)"}, { "H1_HexahedronElement_swigregister", H1_HexahedronElement_swigregister, METH_O, NULL}, { "H1_HexahedronElement_swiginit", H1_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_SegmentElement", _wrap_new_H1Pos_SegmentElement, METH_O, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, - { "H1Pos_SegmentElement_CalcShape", _wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_SegmentElement_CalcDShape", _wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_SegmentElement_ProjectDelta", _wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_SegmentElement(int const p) -> H1Pos_SegmentElement"}, + { "H1Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_SegmentElement", _wrap_delete_H1Pos_SegmentElement, METH_O, "delete_H1Pos_SegmentElement(H1Pos_SegmentElement self)"}, { "H1Pos_SegmentElement_swigregister", H1Pos_SegmentElement_swigregister, METH_O, NULL}, { "H1Pos_SegmentElement_swiginit", H1Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_QuadrilateralElement", _wrap_new_H1Pos_QuadrilateralElement, METH_O, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, - { "H1Pos_QuadrilateralElement_CalcShape", _wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_QuadrilateralElement_CalcDShape", _wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_QuadrilateralElement_ProjectDelta", _wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_QuadrilateralElement(int const p) -> H1Pos_QuadrilateralElement"}, + { "H1Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_QuadrilateralElement", _wrap_delete_H1Pos_QuadrilateralElement, METH_O, "delete_H1Pos_QuadrilateralElement(H1Pos_QuadrilateralElement self)"}, { "H1Pos_QuadrilateralElement_swigregister", H1Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Pos_QuadrilateralElement_swiginit", H1Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Ser_QuadrilateralElement", _wrap_new_H1Ser_QuadrilateralElement, METH_O, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, - { "H1Ser_QuadrilateralElement_CalcShape", _wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Ser_QuadrilateralElement_CalcDShape", _wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Ser_QuadrilateralElement_GetLocalInterpolation", _wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "new_H1Ser_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_H1Ser_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_H1Ser_QuadrilateralElement(int const p) -> H1Ser_QuadrilateralElement"}, + { "H1Ser_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Ser_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Ser_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Ser_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_H1Ser_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(H1Ser_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, { "H1Ser_QuadrilateralElement_Project", _wrap_H1Ser_QuadrilateralElement_Project, METH_VARARGS, "\n" "Project(H1Ser_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(H1Ser_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53597,28 +52998,28 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_H1Ser_QuadrilateralElement", _wrap_delete_H1Ser_QuadrilateralElement, METH_O, "delete_H1Ser_QuadrilateralElement(H1Ser_QuadrilateralElement self)"}, { "H1Ser_QuadrilateralElement_swigregister", H1Ser_QuadrilateralElement_swigregister, METH_O, NULL}, { "H1Ser_QuadrilateralElement_swiginit", H1Ser_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_HexahedronElement", _wrap_new_H1Pos_HexahedronElement, METH_O, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, - { "H1Pos_HexahedronElement_CalcShape", _wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_HexahedronElement_CalcDShape", _wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1Pos_HexahedronElement_ProjectDelta", _wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_H1Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_HexahedronElement(int const p) -> H1Pos_HexahedronElement"}, + { "H1Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_H1Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(H1Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_H1Pos_HexahedronElement", _wrap_delete_H1Pos_HexahedronElement, METH_O, "delete_H1Pos_HexahedronElement(H1Pos_HexahedronElement self)"}, { "H1Pos_HexahedronElement_swigregister", H1Pos_HexahedronElement_swigregister, METH_O, NULL}, { "H1Pos_HexahedronElement_swiginit", H1Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TriangleElement", _wrap_new_H1_TriangleElement, METH_VARARGS, "H1_TriangleElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TriangleElement_CalcShape", _wrap_H1_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TriangleElement_CalcDShape", _wrap_H1_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TriangleElement_CalcHessian", _wrap_H1_TriangleElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TriangleElement(int const p, int const btype=GaussLobatto) -> H1_TriangleElement"}, + { "H1_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TriangleElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TriangleElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(H1_TriangleElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TriangleElement", _wrap_delete_H1_TriangleElement, METH_O, "delete_H1_TriangleElement(H1_TriangleElement self)"}, { "H1_TriangleElement_swigregister", H1_TriangleElement_swigregister, METH_O, NULL}, { "H1_TriangleElement_swiginit", H1_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_TetrahedronElement", _wrap_new_H1_TetrahedronElement, METH_VARARGS, "H1_TetrahedronElement(int const p, int const btype=GaussLobatto)"}, - { "H1_TetrahedronElement_CalcShape", _wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_TetrahedronElement_CalcDShape", _wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "H1_TetrahedronElement_CalcHessian", _wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS, "CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, + { "new_H1_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1_TetrahedronElement(int const p, int const btype=GaussLobatto) -> H1_TetrahedronElement"}, + { "H1_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "H1_TetrahedronElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_H1_TetrahedronElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(H1_TetrahedronElement self, IntegrationPoint ip, DenseMatrix ddshape)"}, { "delete_H1_TetrahedronElement", _wrap_delete_H1_TetrahedronElement, METH_O, "delete_H1_TetrahedronElement(H1_TetrahedronElement self)"}, { "H1_TetrahedronElement_swigregister", H1_TetrahedronElement_swigregister, METH_O, NULL}, { "H1_TetrahedronElement_swiginit", H1_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TriangleElement", _wrap_new_H1Pos_TriangleElement, METH_O, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, + { "new_H1Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TriangleElement(int const p) -> H1Pos_TriangleElement"}, { "H1Pos_TriangleElement_CalcShape", _wrap_H1Pos_TriangleElement_CalcShape, METH_VARARGS, "\n" "CalcShape(int const p, double const x, double const y, double * shape)\n" "CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -53630,7 +53031,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_H1Pos_TriangleElement", _wrap_delete_H1Pos_TriangleElement, METH_O, "delete_H1Pos_TriangleElement(H1Pos_TriangleElement self)"}, { "H1Pos_TriangleElement_swigregister", H1Pos_TriangleElement_swigregister, METH_O, NULL}, { "H1Pos_TriangleElement_swiginit", H1Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_TetrahedronElement", _wrap_new_H1Pos_TetrahedronElement, METH_O, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, + { "new_H1Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_TetrahedronElement(int const p) -> H1Pos_TetrahedronElement"}, { "H1Pos_TetrahedronElement_CalcShape", _wrap_H1Pos_TetrahedronElement_CalcShape, METH_VARARGS, "\n" "CalcShape(int const p, double const x, double const y, double const z, double * shape)\n" "CalcShape(IntegrationPoint ip, Vector shape)\n" @@ -53642,9 +53043,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_H1Pos_TetrahedronElement", _wrap_delete_H1Pos_TetrahedronElement, METH_O, "delete_H1Pos_TetrahedronElement(H1Pos_TetrahedronElement self)"}, { "H1Pos_TetrahedronElement_swigregister", H1Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "H1Pos_TetrahedronElement_swiginit", H1Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_H1_WedgeElement", _wrap_new_H1_WedgeElement, METH_VARARGS, "H1_WedgeElement(int const p, int const btype=GaussLobatto)"}, - { "H1_WedgeElement_CalcShape", _wrap_H1_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1_WedgeElement_CalcDShape", _wrap_H1_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1_WedgeElement(int const p, int const btype=GaussLobatto) -> H1_WedgeElement"}, + { "H1_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1_WedgeElement", _wrap_delete_H1_WedgeElement, METH_O, "delete_H1_WedgeElement(H1_WedgeElement self)"}, { "H1_WedgeElement_swigregister", H1_WedgeElement_swigregister, METH_O, NULL}, { "H1_WedgeElement_swiginit", H1_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -53660,87 +53061,87 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BiCubic3DFiniteElement", _wrap_delete_BiCubic3DFiniteElement, METH_O, "delete_BiCubic3DFiniteElement(BiCubic3DFiniteElement self)"}, { "BiCubic3DFiniteElement_swigregister", BiCubic3DFiniteElement_swigregister, METH_O, NULL}, { "BiCubic3DFiniteElement_swiginit", BiCubic3DFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_H1Pos_WedgeElement", _wrap_new_H1Pos_WedgeElement, METH_O, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, - { "H1Pos_WedgeElement_CalcShape", _wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "H1Pos_WedgeElement_CalcDShape", _wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_H1Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_H1Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_H1Pos_WedgeElement(int const p) -> H1Pos_WedgeElement"}, + { "H1Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(H1Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "H1Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_H1Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(H1Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_H1Pos_WedgeElement", _wrap_delete_H1Pos_WedgeElement, METH_O, "delete_H1Pos_WedgeElement(H1Pos_WedgeElement self)"}, { "H1Pos_WedgeElement_swigregister", H1Pos_WedgeElement_swigregister, METH_O, NULL}, { "H1Pos_WedgeElement_swiginit", H1Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_SegmentElement", _wrap_new_L2_SegmentElement, METH_VARARGS, "L2_SegmentElement(int const p, int const btype=GaussLegendre)"}, - { "L2_SegmentElement_CalcShape", _wrap_L2_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_SegmentElement_CalcDShape", _wrap_L2_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_SegmentElement_ProjectDelta", _wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2_SegmentElement(int const p, int const btype=GaussLegendre) -> L2_SegmentElement"}, + { "L2_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2_SegmentElement", _wrap_delete_L2_SegmentElement, METH_O, "delete_L2_SegmentElement(L2_SegmentElement self)"}, { "L2_SegmentElement_swigregister", L2_SegmentElement_swigregister, METH_O, NULL}, { "L2_SegmentElement_swiginit", L2_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_SegmentElement", _wrap_new_L2Pos_SegmentElement, METH_O, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, - { "L2Pos_SegmentElement_CalcShape", _wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_SegmentElement_CalcDShape", _wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_SegmentElement_ProjectDelta", _wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_SegmentElement(int const p) -> L2Pos_SegmentElement"}, + { "L2Pos_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_SegmentElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_SegmentElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_SegmentElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_SegmentElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_SegmentElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_SegmentElement", _wrap_delete_L2Pos_SegmentElement, METH_O, "delete_L2Pos_SegmentElement(L2Pos_SegmentElement self)"}, { "L2Pos_SegmentElement_swigregister", L2Pos_SegmentElement_swigregister, METH_O, NULL}, { "L2Pos_SegmentElement_swiginit", L2Pos_SegmentElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_QuadrilateralElement", _wrap_new_L2_QuadrilateralElement, METH_VARARGS, "L2_QuadrilateralElement(int const p, int const btype=GaussLegendre)"}, - { "L2_QuadrilateralElement_CalcShape", _wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_QuadrilateralElement_CalcDShape", _wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_QuadrilateralElement_ProjectDelta", _wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, - { "L2_QuadrilateralElement_ProjectCurl", _wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2_QuadrilateralElement(int const p, int const btype=GaussLegendre) -> L2_QuadrilateralElement"}, + { "L2_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "L2_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(L2_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_QuadrilateralElement", _wrap_delete_L2_QuadrilateralElement, METH_O, "delete_L2_QuadrilateralElement(L2_QuadrilateralElement self)"}, { "L2_QuadrilateralElement_swigregister", L2_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2_QuadrilateralElement_swiginit", L2_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_QuadrilateralElement", _wrap_new_L2Pos_QuadrilateralElement, METH_O, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, - { "L2Pos_QuadrilateralElement_CalcShape", _wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_QuadrilateralElement_CalcDShape", _wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_QuadrilateralElement_ProjectDelta", _wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_QuadrilateralElement(int const p) -> L2Pos_QuadrilateralElement"}, + { "L2Pos_QuadrilateralElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_QuadrilateralElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_QuadrilateralElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_QuadrilateralElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_QuadrilateralElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_QuadrilateralElement", _wrap_delete_L2Pos_QuadrilateralElement, METH_O, "delete_L2Pos_QuadrilateralElement(L2Pos_QuadrilateralElement self)"}, { "L2Pos_QuadrilateralElement_swigregister", L2Pos_QuadrilateralElement_swigregister, METH_O, NULL}, { "L2Pos_QuadrilateralElement_swiginit", L2Pos_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_HexahedronElement", _wrap_new_L2_HexahedronElement, METH_VARARGS, "L2_HexahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_HexahedronElement_CalcShape", _wrap_L2_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_HexahedronElement_CalcDShape", _wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_HexahedronElement_ProjectDelta", _wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_HexahedronElement(int const p, int const btype=GaussLegendre) -> L2_HexahedronElement"}, + { "L2_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_HexahedronElement", _wrap_delete_L2_HexahedronElement, METH_O, "delete_L2_HexahedronElement(L2_HexahedronElement self)"}, { "L2_HexahedronElement_swigregister", L2_HexahedronElement_swigregister, METH_O, NULL}, { "L2_HexahedronElement_swiginit", L2_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_HexahedronElement", _wrap_new_L2Pos_HexahedronElement, METH_O, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, - { "L2Pos_HexahedronElement_CalcShape", _wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_HexahedronElement_CalcDShape", _wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_HexahedronElement_ProjectDelta", _wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_HexahedronElement(int const p) -> L2Pos_HexahedronElement"}, + { "L2Pos_HexahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_HexahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_HexahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_HexahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_HexahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_HexahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_HexahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_HexahedronElement", _wrap_delete_L2Pos_HexahedronElement, METH_O, "delete_L2Pos_HexahedronElement(L2Pos_HexahedronElement self)"}, { "L2Pos_HexahedronElement_swigregister", L2Pos_HexahedronElement_swigregister, METH_O, NULL}, { "L2Pos_HexahedronElement_swiginit", L2Pos_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TriangleElement", _wrap_new_L2_TriangleElement, METH_VARARGS, "L2_TriangleElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TriangleElement_CalcShape", _wrap_L2_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TriangleElement_CalcDShape", _wrap_L2_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TriangleElement_ProjectDelta", _wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, - { "L2_TriangleElement_ProjectCurl", _wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "new_L2_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TriangleElement(int const p, int const btype=GaussLegendre) -> L2_TriangleElement"}, + { "L2_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_TriangleElement self, int vertex, Vector dofs)"}, + { "L2_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_L2_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(L2_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_L2_TriangleElement", _wrap_delete_L2_TriangleElement, METH_O, "delete_L2_TriangleElement(L2_TriangleElement self)"}, { "L2_TriangleElement_swigregister", L2_TriangleElement_swigregister, METH_O, NULL}, { "L2_TriangleElement_swiginit", L2_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TriangleElement", _wrap_new_L2Pos_TriangleElement, METH_O, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, - { "L2Pos_TriangleElement_CalcShape", _wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TriangleElement_CalcDShape", _wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TriangleElement_ProjectDelta", _wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TriangleElement(int const p) -> L2Pos_TriangleElement"}, + { "L2Pos_TriangleElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_TriangleElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TriangleElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_TriangleElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TriangleElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TriangleElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_TriangleElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TriangleElement", _wrap_delete_L2Pos_TriangleElement, METH_O, "delete_L2Pos_TriangleElement(L2Pos_TriangleElement self)"}, { "L2Pos_TriangleElement_swigregister", L2Pos_TriangleElement_swigregister, METH_O, NULL}, { "L2Pos_TriangleElement_swiginit", L2Pos_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_TetrahedronElement", _wrap_new_L2_TetrahedronElement, METH_VARARGS, "L2_TetrahedronElement(int const p, int const btype=GaussLegendre)"}, - { "L2_TetrahedronElement_CalcShape", _wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_TetrahedronElement_CalcDShape", _wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2_TetrahedronElement_ProjectDelta", _wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2_TetrahedronElement(int const p, int const btype=GaussLegendre) -> L2_TetrahedronElement"}, + { "L2_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2_TetrahedronElement", _wrap_delete_L2_TetrahedronElement, METH_O, "delete_L2_TetrahedronElement(L2_TetrahedronElement self)"}, { "L2_TetrahedronElement_swigregister", L2_TetrahedronElement_swigregister, METH_O, NULL}, { "L2_TetrahedronElement_swiginit", L2_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_TetrahedronElement", _wrap_new_L2Pos_TetrahedronElement, METH_O, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, - { "L2Pos_TetrahedronElement_CalcShape", _wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_TetrahedronElement_CalcDShape", _wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "L2Pos_TetrahedronElement_ProjectDelta", _wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS, "ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, + { "new_L2Pos_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_TetrahedronElement(int const p) -> L2Pos_TetrahedronElement"}, + { "L2Pos_TetrahedronElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_TetrahedronElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_TetrahedronElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "L2Pos_TetrahedronElement_ProjectDelta", (PyCFunction)(void(*)(void))_wrap_L2Pos_TetrahedronElement_ProjectDelta, METH_VARARGS|METH_KEYWORDS, "ProjectDelta(L2Pos_TetrahedronElement self, int vertex, Vector dofs)"}, { "delete_L2Pos_TetrahedronElement", _wrap_delete_L2Pos_TetrahedronElement, METH_O, "delete_L2Pos_TetrahedronElement(L2Pos_TetrahedronElement self)"}, { "L2Pos_TetrahedronElement_swigregister", L2Pos_TetrahedronElement_swigregister, METH_O, NULL}, { "L2Pos_TetrahedronElement_swiginit", L2Pos_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_L2_WedgeElement", _wrap_new_L2_WedgeElement, METH_VARARGS, "L2_WedgeElement(int const p, int const btype=GaussLegendre)"}, - { "L2_WedgeElement_CalcShape", _wrap_L2_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2_WedgeElement_CalcDShape", _wrap_L2_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2_WedgeElement(int const p, int const btype=GaussLegendre) -> L2_WedgeElement"}, + { "L2_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2_WedgeElement", _wrap_delete_L2_WedgeElement, METH_O, "delete_L2_WedgeElement(L2_WedgeElement self)"}, { "L2_WedgeElement_swigregister", L2_WedgeElement_swigregister, METH_O, NULL}, { "L2_WedgeElement_swiginit", L2_WedgeElement_swiginit, METH_VARARGS, NULL}, @@ -53748,22 +53149,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_P0WedgeFiniteElement", _wrap_delete_P0WedgeFiniteElement, METH_O, "delete_P0WedgeFiniteElement(P0WedgeFiniteElement self)"}, { "P0WedgeFiniteElement_swigregister", P0WedgeFiniteElement_swigregister, METH_O, NULL}, { "P0WedgeFiniteElement_swiginit", P0WedgeFiniteElement_swiginit, METH_VARARGS, NULL}, - { "new_L2Pos_WedgeElement", _wrap_new_L2Pos_WedgeElement, METH_O, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, - { "L2Pos_WedgeElement_CalcShape", _wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS, "CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, - { "L2Pos_WedgeElement_CalcDShape", _wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS, "CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "new_L2Pos_WedgeElement", (PyCFunction)(void(*)(void))_wrap_new_L2Pos_WedgeElement, METH_VARARGS|METH_KEYWORDS, "new_L2Pos_WedgeElement(int const p) -> L2Pos_WedgeElement"}, + { "L2Pos_WedgeElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(L2Pos_WedgeElement self, IntegrationPoint ip, Vector shape)"}, + { "L2Pos_WedgeElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_L2Pos_WedgeElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(L2Pos_WedgeElement self, IntegrationPoint ip, DenseMatrix dshape)"}, { "delete_L2Pos_WedgeElement", _wrap_delete_L2Pos_WedgeElement, METH_O, "delete_L2Pos_WedgeElement(L2Pos_WedgeElement self)"}, { "L2Pos_WedgeElement_swigregister", L2Pos_WedgeElement_swigregister, METH_O, NULL}, { "L2Pos_WedgeElement_swiginit", L2Pos_WedgeElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_QuadrilateralElement", _wrap_new_RT_QuadrilateralElement, METH_VARARGS, "RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_RT_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_RT_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_QuadrilateralElement"}, { "RT_QuadrilateralElement_CalcVShape", _wrap_RT_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_QuadrilateralElement_CalcDivShape", _wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_QuadrilateralElement_GetLocalInterpolation", _wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_GetLocalRestriction", _wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_QuadrilateralElement_GetTransferMatrix", _wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_QuadrilateralElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_QuadrilateralElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_QuadrilateralElement_Project", _wrap_RT_QuadrilateralElement_Project, METH_VARARGS, "\n" "Project(RT_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53771,21 +53172,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_QuadrilateralElement_ProjectGrad", _wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_QuadrilateralElement_ProjectCurl", _wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_QuadrilateralElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_QuadrilateralElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_QuadrilateralElement", _wrap_delete_RT_QuadrilateralElement, METH_O, "delete_RT_QuadrilateralElement(RT_QuadrilateralElement self)"}, { "RT_QuadrilateralElement_swigregister", RT_QuadrilateralElement_swigregister, METH_O, NULL}, { "RT_QuadrilateralElement_swiginit", RT_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_HexahedronElement", _wrap_new_RT_HexahedronElement, METH_VARARGS, "RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_RT_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> RT_HexahedronElement"}, { "RT_HexahedronElement_CalcVShape", _wrap_RT_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_HexahedronElement_CalcDivShape", _wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_HexahedronElement_GetLocalInterpolation", _wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_GetLocalRestriction", _wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_HexahedronElement_GetTransferMatrix", _wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_HexahedronElement_ProjectMatrixCoefficient", _wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_HexahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_HexahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_HexahedronElement_Project", _wrap_RT_HexahedronElement_Project, METH_VARARGS, "\n" "Project(RT_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53793,20 +53194,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_HexahedronElement_ProjectCurl", _wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_HexahedronElement", _wrap_delete_RT_HexahedronElement, METH_O, "delete_RT_HexahedronElement(RT_HexahedronElement self)"}, { "RT_HexahedronElement_swigregister", RT_HexahedronElement_swigregister, METH_O, NULL}, { "RT_HexahedronElement_swiginit", RT_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TriangleElement", _wrap_new_RT_TriangleElement, METH_O, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, + { "new_RT_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TriangleElement(int const p) -> RT_TriangleElement"}, { "RT_TriangleElement_CalcVShape", _wrap_RT_TriangleElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TriangleElement_CalcDivShape", _wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TriangleElement_GetLocalInterpolation", _wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_GetLocalRestriction", _wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TriangleElement_GetTransferMatrix", _wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TriangleElement_ProjectMatrixCoefficient", _wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TriangleElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_TriangleElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TriangleElement_Project", _wrap_RT_TriangleElement_Project, METH_VARARGS, "\n" "Project(RT_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53814,21 +53215,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TriangleElement_ProjectGrad", _wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "RT_TriangleElement_ProjectCurl", _wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "RT_TriangleElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TriangleElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TriangleElement", _wrap_delete_RT_TriangleElement, METH_O, "delete_RT_TriangleElement(RT_TriangleElement self)"}, { "RT_TriangleElement_swigregister", RT_TriangleElement_swigregister, METH_O, NULL}, { "RT_TriangleElement_swiginit", RT_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_RT_TetrahedronElement", _wrap_new_RT_TetrahedronElement, METH_O, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, + { "new_RT_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_RT_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_RT_TetrahedronElement(int const p) -> RT_TetrahedronElement"}, { "RT_TetrahedronElement_CalcVShape", _wrap_RT_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(RT_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "RT_TetrahedronElement_CalcDivShape", _wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS, "CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, - { "RT_TetrahedronElement_GetLocalInterpolation", _wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_GetLocalRestriction", _wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "RT_TetrahedronElement_GetTransferMatrix", _wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "RT_TetrahedronElement_ProjectMatrixCoefficient", _wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "RT_TetrahedronElement_CalcDivShape", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_CalcDivShape, METH_VARARGS|METH_KEYWORDS, "CalcDivShape(RT_TetrahedronElement self, IntegrationPoint ip, Vector divshape)"}, + { "RT_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(RT_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "RT_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "RT_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(RT_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "RT_TetrahedronElement_Project", _wrap_RT_TetrahedronElement_Project, METH_VARARGS, "\n" "Project(RT_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53836,20 +53237,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(RT_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "RT_TetrahedronElement_ProjectCurl", _wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "RT_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_RT_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(RT_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_RT_TetrahedronElement", _wrap_delete_RT_TetrahedronElement, METH_O, "delete_RT_TetrahedronElement(RT_TetrahedronElement self)"}, { "RT_TetrahedronElement_swigregister", RT_TetrahedronElement_swigregister, METH_O, NULL}, { "RT_TetrahedronElement_swiginit", RT_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_HexahedronElement", _wrap_new_ND_HexahedronElement, METH_VARARGS, "ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_HexahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_HexahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_HexahedronElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_HexahedronElement"}, { "ND_HexahedronElement_CalcVShape", _wrap_ND_HexahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_HexahedronElement_CalcCurlShape", _wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_HexahedronElement_GetLocalInterpolation", _wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_GetLocalRestriction", _wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_HexahedronElement_GetTransferMatrix", _wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_HexahedronElement_ProjectMatrixCoefficient", _wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_HexahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_HexahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_HexahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_HexahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_HexahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_HexahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_HexahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_HexahedronElement_Project", _wrap_ND_HexahedronElement_Project, METH_VARARGS, "\n" "Project(ND_HexahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53857,21 +53258,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_HexahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_HexahedronElement_ProjectGrad", _wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_HexahedronElement_ProjectCurl", _wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_HexahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_HexahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_HexahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(ND_HexahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_HexahedronElement", _wrap_delete_ND_HexahedronElement, METH_O, "delete_ND_HexahedronElement(ND_HexahedronElement self)"}, { "ND_HexahedronElement_swigregister", ND_HexahedronElement_swigregister, METH_O, NULL}, { "ND_HexahedronElement_swiginit", ND_HexahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_QuadrilateralElement", _wrap_new_ND_QuadrilateralElement, METH_VARARGS, "ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre)"}, + { "new_ND_QuadrilateralElement", (PyCFunction)(void(*)(void))_wrap_new_ND_QuadrilateralElement, METH_VARARGS|METH_KEYWORDS, "new_ND_QuadrilateralElement(int const p, int const cb_type=GaussLobatto, int const ob_type=GaussLegendre) -> ND_QuadrilateralElement"}, { "ND_QuadrilateralElement_CalcVShape", _wrap_ND_QuadrilateralElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_QuadrilateralElement_CalcCurlShape", _wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_QuadrilateralElement_GetLocalInterpolation", _wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_GetLocalRestriction", _wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_QuadrilateralElement_GetTransferMatrix", _wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_QuadrilateralElement_ProjectMatrixCoefficient", _wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_QuadrilateralElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_QuadrilateralElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_QuadrilateralElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_QuadrilateralElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_QuadrilateralElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_QuadrilateralElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_QuadrilateralElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_QuadrilateralElement_Project", _wrap_ND_QuadrilateralElement_Project, METH_VARARGS, "\n" "Project(ND_QuadrilateralElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53879,20 +53280,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_QuadrilateralElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_QuadrilateralElement_ProjectGrad", _wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_QuadrilateralElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_QuadrilateralElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_QuadrilateralElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_QuadrilateralElement", _wrap_delete_ND_QuadrilateralElement, METH_O, "delete_ND_QuadrilateralElement(ND_QuadrilateralElement self)"}, { "ND_QuadrilateralElement_swigregister", ND_QuadrilateralElement_swigregister, METH_O, NULL}, { "ND_QuadrilateralElement_swiginit", ND_QuadrilateralElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TetrahedronElement", _wrap_new_ND_TetrahedronElement, METH_O, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, + { "new_ND_TetrahedronElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TetrahedronElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TetrahedronElement(int const p) -> ND_TetrahedronElement"}, { "ND_TetrahedronElement_CalcVShape", _wrap_ND_TetrahedronElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TetrahedronElement_CalcCurlShape", _wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TetrahedronElement_GetLocalInterpolation", _wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_GetLocalRestriction", _wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TetrahedronElement_GetTransferMatrix", _wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TetrahedronElement_ProjectMatrixCoefficient", _wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TetrahedronElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_TetrahedronElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TetrahedronElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_TetrahedronElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TetrahedronElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TetrahedronElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_TetrahedronElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TetrahedronElement_Project", _wrap_ND_TetrahedronElement_Project, METH_VARARGS, "\n" "Project(ND_TetrahedronElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53900,21 +53301,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_TetrahedronElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TetrahedronElement_ProjectGrad", _wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, - { "ND_TetrahedronElement_ProjectCurl", _wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS, "ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, + { "ND_TetrahedronElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TetrahedronElement_ProjectCurl", (PyCFunction)(void(*)(void))_wrap_ND_TetrahedronElement_ProjectCurl, METH_VARARGS|METH_KEYWORDS, "ProjectCurl(ND_TetrahedronElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix curl)"}, { "delete_ND_TetrahedronElement", _wrap_delete_ND_TetrahedronElement, METH_O, "delete_ND_TetrahedronElement(ND_TetrahedronElement self)"}, { "ND_TetrahedronElement_swigregister", ND_TetrahedronElement_swigregister, METH_O, NULL}, { "ND_TetrahedronElement_swiginit", ND_TetrahedronElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_TriangleElement", _wrap_new_ND_TriangleElement, METH_O, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, + { "new_ND_TriangleElement", (PyCFunction)(void(*)(void))_wrap_new_ND_TriangleElement, METH_VARARGS|METH_KEYWORDS, "new_ND_TriangleElement(int const p) -> ND_TriangleElement"}, { "ND_TriangleElement_CalcVShape", _wrap_ND_TriangleElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_TriangleElement_CalcCurlShape", _wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS, "CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, - { "ND_TriangleElement_GetLocalInterpolation", _wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_GetLocalRestriction", _wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_TriangleElement_GetTransferMatrix", _wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_TriangleElement_ProjectMatrixCoefficient", _wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_TriangleElement_CalcCurlShape", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_CalcCurlShape, METH_VARARGS|METH_KEYWORDS, "CalcCurlShape(ND_TriangleElement self, IntegrationPoint ip, DenseMatrix curl_shape)"}, + { "ND_TriangleElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_TriangleElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_TriangleElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_TriangleElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_TriangleElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_TriangleElement_Project", _wrap_ND_TriangleElement_Project, METH_VARARGS, "\n" "Project(ND_TriangleElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53922,20 +53323,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_TriangleElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_TriangleElement_ProjectGrad", _wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_TriangleElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_TriangleElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_TriangleElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_TriangleElement", _wrap_delete_ND_TriangleElement, METH_O, "delete_ND_TriangleElement(ND_TriangleElement self)"}, { "ND_TriangleElement_swigregister", ND_TriangleElement_swigregister, METH_O, NULL}, { "ND_TriangleElement_swiginit", ND_TriangleElement_swiginit, METH_VARARGS, NULL}, - { "new_ND_SegmentElement", _wrap_new_ND_SegmentElement, METH_VARARGS, "ND_SegmentElement(int const p, int const ob_type=GaussLegendre)"}, - { "ND_SegmentElement_CalcShape", _wrap_ND_SegmentElement_CalcShape, METH_VARARGS, "CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, + { "new_ND_SegmentElement", (PyCFunction)(void(*)(void))_wrap_new_ND_SegmentElement, METH_VARARGS|METH_KEYWORDS, "new_ND_SegmentElement(int const p, int const ob_type=GaussLegendre) -> ND_SegmentElement"}, + { "ND_SegmentElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(ND_SegmentElement self, IntegrationPoint ip, Vector shape)"}, { "ND_SegmentElement_CalcVShape", _wrap_ND_SegmentElement_CalcVShape, METH_VARARGS, "\n" "CalcVShape(ND_SegmentElement self, IntegrationPoint ip, DenseMatrix shape)\n" "CalcVShape(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix shape)\n" ""}, - { "ND_SegmentElement_GetLocalInterpolation", _wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS, "GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_GetLocalRestriction", _wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS, "GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, - { "ND_SegmentElement_GetTransferMatrix", _wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS, "GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, - { "ND_SegmentElement_ProjectMatrixCoefficient", _wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS, "ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, + { "ND_SegmentElement_GetLocalInterpolation", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalInterpolation, METH_VARARGS|METH_KEYWORDS, "GetLocalInterpolation(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_GetLocalRestriction", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetLocalRestriction, METH_VARARGS|METH_KEYWORDS, "GetLocalRestriction(ND_SegmentElement self, mfem::ElementTransformation & Trans, DenseMatrix R)"}, + { "ND_SegmentElement_GetTransferMatrix", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_GetTransferMatrix, METH_VARARGS|METH_KEYWORDS, "GetTransferMatrix(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)"}, + { "ND_SegmentElement_ProjectMatrixCoefficient", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectMatrixCoefficient, METH_VARARGS|METH_KEYWORDS, "ProjectMatrixCoefficient(ND_SegmentElement self, mfem::MatrixCoefficient & mc, mfem::ElementTransformation & T, Vector dofs)"}, { "ND_SegmentElement_Project", _wrap_ND_SegmentElement_Project, METH_VARARGS, "\n" "Project(ND_SegmentElement self, mfem::Coefficient & coeff, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" @@ -53943,26 +53344,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Project(ND_SegmentElement self, mfem::VectorCoefficient & vc, mfem::ElementTransformation & Trans, Vector dofs)\n" "Project(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix I)\n" ""}, - { "ND_SegmentElement_ProjectGrad", _wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS, "ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, + { "ND_SegmentElement_ProjectGrad", (PyCFunction)(void(*)(void))_wrap_ND_SegmentElement_ProjectGrad, METH_VARARGS|METH_KEYWORDS, "ProjectGrad(ND_SegmentElement self, FiniteElement fe, mfem::ElementTransformation & Trans, DenseMatrix grad)"}, { "delete_ND_SegmentElement", _wrap_delete_ND_SegmentElement, METH_O, "delete_ND_SegmentElement(ND_SegmentElement self)"}, { "ND_SegmentElement_swigregister", ND_SegmentElement_swigregister, METH_O, NULL}, { "ND_SegmentElement_swiginit", ND_SegmentElement_swiginit, METH_VARARGS, NULL}, { "NURBSFiniteElement_Reset", _wrap_NURBSFiniteElement_Reset, METH_O, "Reset(NURBSFiniteElement self)"}, - { "NURBSFiniteElement_SetIJK", _wrap_NURBSFiniteElement_SetIJK, METH_VARARGS, "SetIJK(NURBSFiniteElement self, int const * IJK)"}, + { "NURBSFiniteElement_SetIJK", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetIJK, METH_VARARGS|METH_KEYWORDS, "SetIJK(NURBSFiniteElement self, int const * IJK)"}, { "NURBSFiniteElement_GetPatch", _wrap_NURBSFiniteElement_GetPatch, METH_O, "GetPatch(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetPatch", _wrap_NURBSFiniteElement_SetPatch, METH_VARARGS, "SetPatch(NURBSFiniteElement self, int p)"}, + { "NURBSFiniteElement_SetPatch", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetPatch, METH_VARARGS|METH_KEYWORDS, "SetPatch(NURBSFiniteElement self, int p)"}, { "NURBSFiniteElement_GetElement", _wrap_NURBSFiniteElement_GetElement, METH_O, "GetElement(NURBSFiniteElement self) -> int"}, - { "NURBSFiniteElement_SetElement", _wrap_NURBSFiniteElement_SetElement, METH_VARARGS, "SetElement(NURBSFiniteElement self, int e)"}, + { "NURBSFiniteElement_SetElement", (PyCFunction)(void(*)(void))_wrap_NURBSFiniteElement_SetElement, METH_VARARGS|METH_KEYWORDS, "SetElement(NURBSFiniteElement self, int e)"}, { "NURBSFiniteElement_KnotVectors", _wrap_NURBSFiniteElement_KnotVectors, METH_O, "KnotVectors(NURBSFiniteElement self) -> mfem::Array< mfem::KnotVector const * > &"}, { "NURBSFiniteElement_Weights", _wrap_NURBSFiniteElement_Weights, METH_O, "Weights(NURBSFiniteElement self) -> Vector"}, { "NURBSFiniteElement_SetOrder", _wrap_NURBSFiniteElement_SetOrder, METH_O, "SetOrder(NURBSFiniteElement self)"}, { "delete_NURBSFiniteElement", _wrap_delete_NURBSFiniteElement, METH_O, "delete_NURBSFiniteElement(NURBSFiniteElement self)"}, { "NURBSFiniteElement_swigregister", NURBSFiniteElement_swigregister, METH_O, NULL}, - { "new_NURBS1DFiniteElement", _wrap_new_NURBS1DFiniteElement, METH_O, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, + { "new_NURBS1DFiniteElement", (PyCFunction)(void(*)(void))_wrap_new_NURBS1DFiniteElement, METH_VARARGS|METH_KEYWORDS, "new_NURBS1DFiniteElement(int p) -> NURBS1DFiniteElement"}, { "NURBS1DFiniteElement_SetOrder", _wrap_NURBS1DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS1DFiniteElement self)"}, - { "NURBS1DFiniteElement_CalcShape", _wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS1DFiniteElement_CalcDShape", _wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS1DFiniteElement_CalcHessian", _wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS1DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(NURBS1DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS1DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS1DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS1DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(NURBS1DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS1DFiniteElement", _wrap_delete_NURBS1DFiniteElement, METH_O, "delete_NURBS1DFiniteElement(NURBS1DFiniteElement self)"}, { "NURBS1DFiniteElement_swigregister", NURBS1DFiniteElement_swigregister, METH_O, NULL}, { "NURBS1DFiniteElement_swiginit", NURBS1DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -53971,9 +53372,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_NURBS2DFiniteElement(int px, int py) -> NURBS2DFiniteElement\n" ""}, { "NURBS2DFiniteElement_SetOrder", _wrap_NURBS2DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS2DFiniteElement self)"}, - { "NURBS2DFiniteElement_CalcShape", _wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS2DFiniteElement_CalcDShape", _wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS2DFiniteElement_CalcHessian", _wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS2DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(NURBS2DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS2DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS2DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS2DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(NURBS2DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS2DFiniteElement", _wrap_delete_NURBS2DFiniteElement, METH_O, "delete_NURBS2DFiniteElement(NURBS2DFiniteElement self)"}, { "NURBS2DFiniteElement_swigregister", NURBS2DFiniteElement_swigregister, METH_O, NULL}, { "NURBS2DFiniteElement_swiginit", NURBS2DFiniteElement_swiginit, METH_VARARGS, NULL}, @@ -53982,9 +53383,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_NURBS3DFiniteElement(int px, int py, int pz) -> NURBS3DFiniteElement\n" ""}, { "NURBS3DFiniteElement_SetOrder", _wrap_NURBS3DFiniteElement_SetOrder, METH_O, "SetOrder(NURBS3DFiniteElement self)"}, - { "NURBS3DFiniteElement_CalcShape", _wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS, "CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, - { "NURBS3DFiniteElement_CalcDShape", _wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS, "CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, - { "NURBS3DFiniteElement_CalcHessian", _wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS, "CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, + { "NURBS3DFiniteElement_CalcShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcShape, METH_VARARGS|METH_KEYWORDS, "CalcShape(NURBS3DFiniteElement self, IntegrationPoint ip, Vector shape)"}, + { "NURBS3DFiniteElement_CalcDShape", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcDShape, METH_VARARGS|METH_KEYWORDS, "CalcDShape(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix dshape)"}, + { "NURBS3DFiniteElement_CalcHessian", (PyCFunction)(void(*)(void))_wrap_NURBS3DFiniteElement_CalcHessian, METH_VARARGS|METH_KEYWORDS, "CalcHessian(NURBS3DFiniteElement self, IntegrationPoint ip, DenseMatrix hessian)"}, { "delete_NURBS3DFiniteElement", _wrap_delete_NURBS3DFiniteElement, METH_O, "delete_NURBS3DFiniteElement(NURBS3DFiniteElement self)"}, { "NURBS3DFiniteElement_swigregister", NURBS3DFiniteElement_swigregister, METH_O, NULL}, { "NURBS3DFiniteElement_swiginit", NURBS3DFiniteElement_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/fespace.py b/mfem/_ser/fespace.py index d42bb59b..b3dc87d9 100644 --- a/mfem/_ser/fespace.py +++ b/mfem/_ser/fespace.py @@ -197,9 +197,9 @@ def GetElementRestriction(self, e_ordering): return _fespace.FiniteElementSpace_GetElementRestriction(self, e_ordering) GetElementRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetElementRestriction) - def GetFaceRestriction(self, *args): + def GetFaceRestriction(self, *args, **kwargs): r"""GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator""" - return _fespace.FiniteElementSpace_GetFaceRestriction(self, *args) + return _fespace.FiniteElementSpace_GetFaceRestriction(self, *args, **kwargs) GetFaceRestriction = _swig_new_instance_method(_fespace.FiniteElementSpace_GetFaceRestriction) def GetQuadratureInterpolator(self, *args): diff --git a/mfem/_ser/fespace_wrap.cxx b/mfem/_ser/fespace_wrap.cxx index aeeb4d10..c0254e4c 100644 --- a/mfem/_ser/fespace_wrap.cxx +++ b/mfem/_ser/fespace_wrap.cxx @@ -3775,7 +3775,7 @@ SWIGINTERN void mfem_FiniteElementSpace_Save__SWIG_1(mfem::FiniteElementSpace *s self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_FiniteElementSpace_Save__SWIG_3(mfem::FiniteElementSpace *self){ +SWIGINTERN void mfem_FiniteElementSpace_Save__SWIG_2(mfem::FiniteElementSpace *self){ self -> Save(std::cout); } SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_1(mfem::QuadratureSpace *self,char const *file,int precision=8){ @@ -3789,7 +3789,7 @@ SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_1(mfem::QuadratureSpace *self,ch self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_3(mfem::QuadratureSpace *self){ +SWIGINTERN void mfem_QuadratureSpace_Save__SWIG_2(mfem::QuadratureSpace *self){ self -> Save(std::cout); } @@ -3919,8 +3919,8 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_0(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; - mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; + mfem::Mesh *arg2 = (mfem::Mesh *) NULL ; + mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3929,62 +3929,7 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_1(PyObject *SWIGUNUSEDPA int res3 = 0 ; mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::Mesh *""'"); - } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,arg2,(mfem::FiniteElementCollection const *)arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); @@ -3993,287 +3938,23 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_2(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::Mesh *""'"); - } - arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::Mesh *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + arg2 = reinterpret_cast< mfem::Mesh * >(argp2); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace((mfem::FiniteElementSpace const &)*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); } { try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::FiniteElementSpace *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); - } - arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); - } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4,arg5); + result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace((mfem::FiniteElementSpace const &)*arg1,arg2,(mfem::FiniteElementCollection const *)arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4297,45 +3978,48 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_7(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; - mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; - int arg4 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; + int arg3 = (int) 1 ; + int arg4 = (int) mfem::Ordering::byNODES ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NURBSExtension, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::NURBSExtension *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FiniteElementSpace" "', argument " "2"" of type '" "mfem::FiniteElementCollection const *""'"); } - arg2 = reinterpret_cast< mfem::NURBSExtension * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); + arg2 = reinterpret_cast< mfem::FiniteElementCollection * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4); + result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,(mfem::FiniteElementCollection const *)arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4359,11 +4043,13 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_8(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::NURBSExtension *arg2 = (mfem::NURBSExtension *) 0 ; mfem::FiniteElementCollection *arg3 = (mfem::FiniteElementCollection *) 0 ; + int arg4 = (int) 1 ; + int arg5 = (int) mfem::Ordering::byNODES ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4372,7 +4058,7 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_9(PyObject *SWIGUNUSEDPA int res3 = 0 ; mfem::FiniteElementSpace *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FiniteElementSpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -4388,9 +4074,25 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace__SWIG_9(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_FiniteElementSpace" "', argument " "3"" of type '" "mfem::FiniteElementCollection const *""'"); } arg3 = reinterpret_cast< mfem::FiniteElementCollection * >(argp3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } { try { - result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3); + result = (mfem::FiniteElementSpace *)new mfem::FiniteElementSpace(arg1,arg2,(mfem::FiniteElementCollection const *)arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4425,132 +4127,31 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args if (argc == 0) { return _wrap_new_FiniteElementSpace__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_5(self, argc, argv); - } + if (argc <= 1) { + return _wrap_new_FiniteElementSpace__SWIG_1(self, argc, argv); } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { return _wrap_new_FiniteElementSpace__SWIG_1(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_9(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__NURBSExtension, 0); - _v = SWIG_CheckState(res); - if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_8(self, argc, argv); - } + return _wrap_new_FiniteElementSpace__SWIG_1(self, argc, argv); } } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -4560,6 +4161,9 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4569,6 +4173,9 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args } } if (_v) { + if (argc <= 3) { + return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4578,13 +4185,13 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args } } if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_4(self, argc, argv); + return _wrap_new_FiniteElementSpace__SWIG_2(self, argc, argv); } } } } } - if (argc == 5) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -4598,6 +4205,9 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__FiniteElementCollection, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4607,6 +4217,9 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args } } if (_v) { + if (argc <= 4) { + return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4616,7 +4229,7 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args } } if (_v) { - return _wrap_new_FiniteElementSpace__SWIG_7(self, argc, argv); + return _wrap_new_FiniteElementSpace__SWIG_3(self, argc, argv); } } } @@ -4629,14 +4242,8 @@ SWIGINTERN PyObject *_wrap_new_FiniteElementSpace(PyObject *self, PyObject *args " Possible C/C++ prototypes are:\n" " mfem::FiniteElementSpace::FiniteElementSpace()\n" " mfem::FiniteElementSpace::FiniteElementSpace(mfem::FiniteElementSpace const &,mfem::Mesh *,mfem::FiniteElementCollection const *)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::FiniteElementSpace const &,mfem::Mesh *)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::FiniteElementSpace const &)\n" " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::FiniteElementCollection const *,int,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::FiniteElementCollection const *,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::FiniteElementCollection const *)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int)\n" - " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *)\n"); + " mfem::FiniteElementSpace::FiniteElementSpace(mfem::Mesh *,mfem::NURBSExtension *,mfem::FiniteElementCollection const *,int,int)\n"); return 0; } @@ -5083,7 +4690,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetRestrictionMatrix(PyObject *SWI } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::ElementDofOrdering arg2 ; @@ -5091,16 +4698,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"e_ordering", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementRestriction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetElementRestriction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } @@ -5131,12 +4742,12 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementRestriction(PyObject *SW } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::ElementDofOrdering arg2 ; mfem::FaceType arg3 ; - mfem::L2FaceValues arg4 ; + mfem::L2FaceValues arg4 = (mfem::L2FaceValues) mfem::L2FaceValues::DoubleValued ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -5145,87 +4756,41 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(PyObjec int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"e_ordering", (char *)"arg3", (char *)"mul", NULL + }; mfem::Operator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_GetFaceRestriction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } arg3 = static_cast< mfem::FaceType >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); - } - arg4 = static_cast< mfem::L2FaceValues >(val4); - { - try { - result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::ElementDofOrdering arg2 ; - mfem::FaceType arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::Operator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); - } - arg3 = static_cast< mfem::FaceType >(val3); { try { - result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3); + result = (mfem::Operator *)((mfem::FiniteElementSpace const *)arg1)->GetFaceRestriction(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5249,72 +4814,6 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceRestriction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceRestriction", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FiniteElementSpace_GetFaceRestriction__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetFaceRestriction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType,mfem::L2FaceValues) const\n" - " mfem::FiniteElementSpace::GetFaceRestriction(mfem::ElementDofOrdering,mfem::FaceType) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -5459,7 +4958,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetQuadratureInterpolator(PyObject } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -5470,16 +4969,21 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyOb int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"type", NULL + }; mfem::FaceQuadratureInterpolator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceQuadratureInterpolator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceQuadratureInterpolator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -5487,7 +4991,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetFaceQuadratureInterpolator" "', argument " "3"" of type '" "mfem::FaceType""'"); } @@ -5559,26 +5063,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVDim(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetOrder" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5606,26 +5114,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetOrder(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetFaceOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceOrder" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6227,7 +5739,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNBE(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FaceType arg2 ; @@ -6235,16 +5747,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"type", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetNFbyType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); } @@ -6275,26 +5791,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNFbyType(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6322,7 +5842,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementType(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6331,21 +5851,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vertices", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementVertices", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementVertices" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6379,26 +5904,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVertices(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBdrElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementType" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6586,26 +6115,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementTransformation(PyObject } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::ElementTransformation *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBdrElementTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6633,26 +6166,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementTransformation(PyObje } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetAttribute" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6680,26 +6217,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetAttribute(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBdrAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrAttribute" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6727,7 +6268,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrAttribute(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6736,21 +6277,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6784,7 +6330,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementDofs(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6793,21 +6339,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUN int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetBdrElementDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetBdrElementDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6841,7 +6392,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementDofs(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6850,21 +6401,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6898,7 +6454,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceDofs(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -6907,249 +6463,36 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeDofs(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEdgeDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetEdgeDofs(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetVertexDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetVertexDofs(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementInteriorDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetElementInteriorDofs(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceInteriorDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::FiniteElementSpace const *)arg1)->GetFaceInteriorDofs(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNumElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetNumElementInteriorDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNumElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEdgeDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (int)((mfem::FiniteElementSpace const *)arg1)->GetNumElementInteriorDofs(arg2); + ((mfem::FiniteElementSpace const *)arg1)->GetEdgeDofs(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7166,14 +6509,14 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNumElementInteriorDofs(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7182,31 +6525,36 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorDofs(PyObject *SWIG int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeInteriorDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetVertexDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetVertexDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->GetEdgeInteriorDofs(arg2,*arg3); + ((mfem::FiniteElementSpace const *)arg1)->GetVertexDofs(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7230,39 +6578,45 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorDofs(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementInteriorDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetElementInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(*arg2,arg3); + ((mfem::FiniteElementSpace const *)arg1)->GetElementInteriorDofs(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7286,32 +6640,45 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceInteriorDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetFaceInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(*arg2); + ((mfem::FiniteElementSpace const *)arg1)->GetFaceInteriorDofs(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7335,46 +6702,34 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetNumElementInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetNumElementInteriorDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetNumElementInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(arg2,*arg3,arg4); + result = (int)((mfem::FiniteElementSpace const *)arg1)->GetNumElementInteriorDofs(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7391,14 +6746,14 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_2(PyObject *SWIG SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7407,30 +6762,36 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_3(PyObject *SWIG int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"dofs", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeInteriorDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEdgeInteriorDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(arg2,*arg3); + ((mfem::FiniteElementSpace const *)arg1)->GetEdgeInteriorDofs(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7454,149 +6815,41 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_3(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_DofsToVDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_2(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_DofsToVDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::DofsToVDofs(mfem::Array< int > &,int) const\n" - " mfem::FiniteElementSpace::DofsToVDofs(mfem::Array< int > &) const\n" - " mfem::FiniteElementSpace::DofsToVDofs(int,mfem::Array< int > &,int) const\n" - " mfem::FiniteElementSpace::DofsToVDofs(int,mfem::Array< int > &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - int arg3 ; - int arg4 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofToVDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { - result = (int)((mfem::FiniteElementSpace const *)arg1)->DofToVDof(arg2,arg3,arg4); + ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7613,26 +6866,28 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_0(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; - int arg3 ; + mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - int result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofToVDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { @@ -7641,15 +6896,25 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_1(PyObject *SWIGUN }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_DofsToVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - result = (int)((mfem::FiniteElementSpace const *)arg1)->DofToVDof(arg2,arg3); + ((mfem::FiniteElementSpace const *)arg1)->DofsToVDofs(arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7666,51 +6931,44 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof__SWIG_1(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofsToVDofs(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_DofToVDof", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_DofsToVDofs", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + _v = PyInt_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_FiniteElementSpace_DofToVDof__SWIG_1(self, argc, argv); + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_0(self, argc, argv); } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); @@ -7725,20 +6983,18 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *self, PyObject } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(self, argc, argv); + } { _v = PyInt_Check(argv[3]) ? 1 : 0; } if (_v) { - return _wrap_FiniteElementSpace_DofToVDof__SWIG_0(self, argc, argv); + return _wrap_FiniteElementSpace_DofsToVDofs__SWIG_1(self, argc, argv); } } } @@ -7746,34 +7002,107 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_DofToVDof'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_DofsToVDofs'.\n" " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::DofToVDof(int,int,int) const\n" - " mfem::FiniteElementSpace::DofToVDof(int,int) const\n"); + " mfem::FiniteElementSpace::DofsToVDofs(mfem::Array< int > &,int) const\n" + " mfem::FiniteElementSpace::DofsToVDofs(int,mfem::Array< int > &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_VDofToDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_DofToVDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; + int arg3 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dof", (char *)"vd", (char *)"ndofs", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_VDofToDof", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_DofToVDof", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_DofToVDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + } + arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } + { + try { + result = (int)((mfem::FiniteElementSpace const *)arg1)->DofToVDof(arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_FiniteElementSpace_VDofToDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdof", NULL + }; + int result; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_VDofToDof", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_VDofToDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7801,16 +7130,18 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_VDofToDof(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_AdjustVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_AdjustVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"vdofs", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:FiniteElementSpace_AdjustVDofs", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_AdjustVDofs" "', argument " "1"" of type '" "mfem::Array< int > &""'"); } @@ -7844,7 +7175,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_AdjustVDofs(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7853,21 +7184,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUS int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7901,7 +7237,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementVDofs(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7910,21 +7246,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGU int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBdrElementVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetBdrElementVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBdrElementVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetBdrElementVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -7958,7 +7299,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementVDofs(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -7967,21 +7308,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetFaceVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetFaceVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8015,7 +7361,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceVDofs(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -8024,21 +7370,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8072,7 +7423,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeVDofs(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -8081,21 +7432,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSE int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetVertexVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetVertexVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetVertexVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetVertexVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8129,7 +7485,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetVertexVDofs(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -8138,21 +7494,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject * int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementInteriorVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetElementInteriorVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementInteriorVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetElementInteriorVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8186,7 +7547,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementInteriorVDofs(PyObject * } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; @@ -8195,21 +7556,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeInteriorVDofs(PyObject *SWI int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeInteriorVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetEdgeInteriorVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeInteriorVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEdgeInteriorVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -8445,26 +7811,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBdrElementToDofTable(PyObject * } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetElementForDof", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetElementForDof", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetElementForDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -8492,26 +7862,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetElementForDof(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetLocalDofForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetLocalDofForDof(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetLocalDofForDof", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetLocalDofForDof", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetLocalDofForDof" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -8539,26 +7913,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetLocalDofForDof(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetFE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFE" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -8586,26 +7964,30 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFE(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetBE", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetBE", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetBE" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -8633,132 +8015,34 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetBE(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetFaceElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetFaceElement(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FiniteElement *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEdgeElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetEdgeElement(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTraceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetFaceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; int arg2 ; - mfem::Geometry::Type arg3 ; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::FiniteElement *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetTraceElement", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetFaceElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetFaceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "3"" of type '" "mfem::Geometry::Type""'"); - } - arg3 = static_cast< mfem::Geometry::Type >(val3); { try { - result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetTraceElement(arg2,arg3); + result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetFaceElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8782,50 +8066,34 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTraceElement(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEdgeElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_GetEdgeElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEdgeElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - ((mfem::FiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); + result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetEdgeElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8842,50 +8110,50 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_0(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTraceElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + int arg2 ; + mfem::Geometry::Type arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + int val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"geom_type", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetTraceElement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FiniteElementSpace_GetTraceElement" "', argument " "3"" of type '" "mfem::Geometry::Type""'"); + } + arg3 = static_cast< mfem::Geometry::Type >(val3); { try { - ((mfem::FiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3); + result = (mfem::FiniteElement *)((mfem::FiniteElementSpace const *)arg1)->GetTraceElement(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8902,116 +8170,66 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_1(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEssentialVDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialVDofs__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetEssentialVDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::GetEssentialVDofs(mfem::Array< int > const &,mfem::Array< int > &,int) const\n" - " mfem::FiniteElementSpace::GetEssentialVDofs(mfem::Array< int > const &,mfem::Array< int > &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; - int arg4 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"ess_vdofs", (char *)"component", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_GetEssentialVDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); + ((mfem::FiniteElementSpace const *)arg1)->GetEssentialVDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9035,25 +8253,33 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"ess_tdof_list", (char *)"component", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_GetEssentialTrueDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9061,7 +8287,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_1(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -9069,121 +8295,17 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_1(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetEssentialTrueDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetEssentialTrueDofs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetEssentialTrueDofs", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_FiniteElementSpace_GetEssentialTrueDofs__SWIG_0(self, argc, argv); - } - } - } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_GetEssentialTrueDofs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::GetEssentialTrueDofs(mfem::Array< int > const &,mfem::Array< int > &,int)\n" - " mfem::FiniteElementSpace::GetEssentialTrueDofs(mfem::Array< int > const &,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_MarkerToList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Array< int > *arg1 = 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_MarkerToList", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); - } - arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - mfem::FiniteElementSpace::MarkerToList((mfem::Array< int > const &)*arg1,*arg2); + (arg1)->GetEssentialTrueDofs((mfem::Array< int > const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9207,49 +8329,40 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_MarkerToList(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_MarkerToList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - int arg4 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"marker", (char *)"list", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_MarkerToList", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ListToMarker" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_MarkerToList" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - mfem::FiniteElementSpace::ListToMarker((mfem::Array< int > const &)*arg1,arg2,*arg3,arg4); + mfem::FiniteElementSpace::MarkerToList((mfem::Array< int > const &)*arg1,*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9273,18 +8386,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_0(PyObject *SWI } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; int arg2 ; mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"list", (char *)"marker_size", (char *)"marker", (char *)"mark_val", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:FiniteElementSpace_ListToMarker", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "1"" of type '" "mfem::Array< int > const &""'"); } @@ -9293,12 +8414,12 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWI } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -9306,9 +8427,17 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ListToMarker" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } { try { - mfem::FiniteElementSpace::ListToMarker((mfem::Array< int > const &)*arg1,arg2,*arg3); + mfem::FiniteElementSpace::ListToMarker((mfem::Array< int > const &)*arg1,arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9332,81 +8461,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ListToMarker(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_ListToMarker", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_ListToMarker__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_FiniteElementSpace_ListToMarker__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_ListToMarker'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::ListToMarker(mfem::Array< int > const &,int,mfem::Array< int > &,int)\n" - " mfem::FiniteElementSpace::ListToMarker(mfem::Array< int > const &,int,mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9417,15 +8472,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dofs", (char *)"cdofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_ConvertToConformingVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_ConvertToConformingVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9433,7 +8493,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ConvertToConformingVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -9467,7 +8527,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertToConformingVDofs(PyObject } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9478,15 +8538,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"cdofs", (char *)"dofs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_ConvertFromConformingVDofs", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_ConvertFromConformingVDofs", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9494,7 +8559,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_ConvertFromConformingVDofs" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -9528,7 +8593,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_ConvertFromConformingVDofs(PyObjec } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -9536,16 +8601,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"cfes", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_D2C_GlobalRestrictionMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_D2C_GlobalRestrictionMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_D2C_GlobalRestrictionMatrix" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_D2C_GlobalRestrictionMatrix" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -9576,7 +8645,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix(PyObje } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -9584,16 +8653,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"cfes", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_D2Const_GlobalRestrictionMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_D2Const_GlobalRestrictionMatrix" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_D2Const_GlobalRestrictionMatrix" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -9624,7 +8697,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix(Py } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -9632,16 +8705,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"lfes", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_H2L_GlobalRestrictionMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_H2L_GlobalRestrictionMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_H2L_GlobalRestrictionMatrix" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_H2L_GlobalRestrictionMatrix" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -9672,7 +8749,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix(PyObje } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -9683,15 +8760,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIG int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"coarse_fes", (char *)"T", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetTransferOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetTransferOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -9699,7 +8781,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetTransferOperator" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -9733,7 +8815,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTransferOperator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -9744,15 +8826,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"coarse_fes", (char *)"T", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_GetTrueTransferOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_GetTrueTransferOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "1"" of type '" "mfem::FiniteElementSpace const *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -9760,7 +8847,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "2"" of type '" "mfem::FiniteElementSpace const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_GetTrueTransferOperator" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -9794,67 +8881,36 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetTrueTransferOperator(PyObject * } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"want_transform", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:FiniteElementSpace_Update", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Update" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_Update" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->Update(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Update" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_Update" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { try { - (arg1)->Update(); + (arg1)->Update(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9878,48 +8934,6 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Update(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "FiniteElementSpace_Update", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_FiniteElementSpace_Update__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_FiniteElementSpace_Update__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_Update'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::FiniteElementSpace::Update(bool)\n" - " mfem::FiniteElementSpace::Update()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetUpdateOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; @@ -10049,7 +9063,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_GetUpdateOperator(PyObject *self, } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; bool arg2 ; @@ -10057,15 +9071,19 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *S int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"own", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_SetUpdateOperatorOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_SetUpdateOperatorOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_SetUpdateOperatorOwner" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_SetUpdateOperatorOwner" "', argument " "2"" of type '" "bool""'"); } @@ -10096,7 +9114,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorOwner(PyObject *S } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Operator::Type arg2 ; @@ -10104,15 +9122,19 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_SetUpdateOperatorType(PyObject *SW int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_SetUpdateOperatorType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FiniteElementSpace_SetUpdateOperatorType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_SetUpdateOperatorType" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FiniteElementSpace_SetUpdateOperatorType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -10290,7 +9312,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -10301,21 +9323,26 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Load(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", (char *)"input", NULL + }; mfem::FiniteElementCollection *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "FiniteElementSpace_Load", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FiniteElementSpace_Load", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Load" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_Load" "', argument " "2"" of type '" "mfem::Mesh *""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__istream, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FiniteElementSpace_Load" "', argument " "3"" of type '" "std::istream &""'"); } @@ -10356,70 +9383,16 @@ SWIGINTERN PyObject *_wrap_delete_FiniteElementSpace(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; PyObject *swig_obj[1] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Save" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FiniteElementSpace" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - mfem_FiniteElementSpace_Save__SWIG_1(arg1,(char const *)arg2,arg3); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10437,25 +9410,24 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_1(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FiniteElementSpace_Save" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); @@ -10466,9 +9438,17 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_2(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FiniteElementSpace_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_FiniteElementSpace_Save__SWIG_1(arg1,(char const *)arg2); + mfem_FiniteElementSpace_Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10494,7 +9474,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_2(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; @@ -10508,7 +9488,7 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save__SWIG_3(PyObject *SWIGUNUSEDP arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); { try { - mfem_FiniteElementSpace_Save__SWIG_3(arg1); + mfem_FiniteElementSpace_Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10546,10 +9526,10 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_FiniteElementSpace_Save__SWIG_3(self, argc, argv); + return _wrap_FiniteElementSpace_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); @@ -10558,7 +9538,20 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save(PyObject *self, PyObject *arg int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_FiniteElementSpace_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_FiniteElementSpace_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_FiniteElementSpace_Save__SWIG_1(self, argc, argv); + } } } } @@ -10582,36 +9575,12 @@ SWIGINTERN PyObject *_wrap_FiniteElementSpace_Save(PyObject *self, PyObject *arg } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__FiniteElementSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_FiniteElementSpace_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'FiniteElementSpace_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::FiniteElementSpace::Save(std::ostream &) const\n" " mfem::FiniteElementSpace::Save(char const *,int)\n" - " mfem::FiniteElementSpace::Save(char const *)\n" " mfem::FiniteElementSpace::Save()\n"); return 0; } @@ -10856,26 +9825,30 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_GetSize(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_QuadratureSpace_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureSpace_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "QuadratureSpace_GetElementIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureSpace_GetElementIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureSpace_GetElementIntRule" "', argument " "1"" of type '" "mfem::QuadratureSpace const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -10973,14 +9946,14 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureSpace_Save" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); @@ -10991,11 +9964,13 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureSpace_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -11026,55 +10001,6 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_1(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureSpace_Save" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureSpace_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_QuadratureSpace_Save__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; void *argp1 = 0 ; @@ -11088,7 +10014,7 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save__SWIG_3(PyObject *SWIGUNUSEDPARM arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); { try { - mfem_QuadratureSpace_Save__SWIG_3(arg1); + mfem_QuadratureSpace_Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11126,10 +10052,10 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_QuadratureSpace_Save__SWIG_3(self, argc, argv); + return _wrap_QuadratureSpace_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); @@ -11138,7 +10064,20 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_QuadratureSpace_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_QuadratureSpace_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_QuadratureSpace_Save__SWIG_1(self, argc, argv); + } } } } @@ -11162,36 +10101,12 @@ SWIGINTERN PyObject *_wrap_QuadratureSpace_Save(PyObject *self, PyObject *args) } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_QuadratureSpace_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureSpace_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::QuadratureSpace::Save(std::ostream &) const\n" " mfem::QuadratureSpace::Save(char const *,int)\n" - " mfem::QuadratureSpace::Save(char const *)\n" " mfem::QuadratureSpace::Save()\n"); return 0; } @@ -11248,7 +10163,7 @@ SWIGINTERN PyObject *_wrap_delete_GridTransfer(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_GridTransfer_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridTransfer_SetOperatorType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridTransfer *arg1 = (mfem::GridTransfer *) 0 ; mfem::Operator::Type arg2 ; @@ -11256,15 +10171,19 @@ SWIGINTERN PyObject *_wrap_GridTransfer_SetOperatorType(PyObject *SWIGUNUSEDPARM int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"type", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridTransfer_SetOperatorType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridTransfer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridTransfer_SetOperatorType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridTransfer, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridTransfer_SetOperatorType" "', argument " "1"" of type '" "mfem::GridTransfer *""'"); } arg1 = reinterpret_cast< mfem::GridTransfer * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridTransfer_SetOperatorType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -11466,7 +10385,7 @@ SWIGINTERN PyObject *GridTransfer_swigregister(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -11474,11 +10393,15 @@ SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"coarse_fes", (char *)"fine_fes", NULL + }; mfem::InterpolationGridTransfer *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_InterpolationGridTransfer", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_InterpolationGridTransfer", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_InterpolationGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -11486,7 +10409,7 @@ SWIGINTERN PyObject *_wrap_new_InterpolationGridTransfer(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_InterpolationGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_InterpolationGridTransfer" "', argument " "2"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -11560,83 +10483,45 @@ SWIGINTERN PyObject *_wrap_delete_InterpolationGridTransfer(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InterpolationGridTransfer *arg1 = (mfem::InterpolationGridTransfer *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; - bool arg3 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mass_integ_", (char *)"own_mass_integ_", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InterpolationGridTransfer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:InterpolationGridTransfer_SetMassIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InterpolationGridTransfer, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "1"" of type '" "mfem::InterpolationGridTransfer *""'"); } arg1 = reinterpret_cast< mfem::InterpolationGridTransfer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetMassIntegrator(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::InterpolationGridTransfer *arg1 = (mfem::InterpolationGridTransfer *) 0 ; - mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InterpolationGridTransfer, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "1"" of type '" "mfem::InterpolationGridTransfer *""'"); - } - arg1 = reinterpret_cast< mfem::InterpolationGridTransfer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InterpolationGridTransfer_SetMassIntegrator" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); { try { - (arg1)->SetMassIntegrator(arg2); + (arg1)->SetMassIntegrator(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11660,58 +10545,6 @@ SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_1(P } -SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_SetMassIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "InterpolationGridTransfer_SetMassIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__InterpolationGridTransfer, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__InterpolationGridTransfer, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_InterpolationGridTransfer_SetMassIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'InterpolationGridTransfer_SetMassIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::InterpolationGridTransfer::SetMassIntegrator(mfem::BilinearFormIntegrator *,bool)\n" - " mfem::InterpolationGridTransfer::SetMassIntegrator(mfem::BilinearFormIntegrator *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_InterpolationGridTransfer_ForwardOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::InterpolationGridTransfer *arg1 = (mfem::InterpolationGridTransfer *) 0 ; @@ -11805,7 +10638,7 @@ SWIGINTERN PyObject *InterpolationGridTransfer_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::FiniteElementSpace *arg2 = 0 ; @@ -11813,11 +10646,15 @@ SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"coarse_fes", (char *)"fine_fes", NULL + }; mfem::L2ProjectionGridTransfer *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_L2ProjectionGridTransfer", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_L2ProjectionGridTransfer", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ProjectionGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -11825,7 +10662,7 @@ SWIGINTERN PyObject *_wrap_new_L2ProjectionGridTransfer(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2ProjectionGridTransfer" "', argument " "1"" of type '" "mfem::FiniteElementSpace &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElementSpace, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_L2ProjectionGridTransfer" "', argument " "2"" of type '" "mfem::FiniteElementSpace &""'"); } @@ -11992,17 +10829,19 @@ SWIGINTERN PyObject *L2ProjectionGridTransfer_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_UsesTensorBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_UsesTensorBasis(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"fes", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:UsesTensorBasis", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UsesTensorBasis" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -12047,7 +10886,7 @@ static PyMethodDef SwigMethods[] = { "FiniteElementSpace()\n" "FiniteElementSpace(FiniteElementSpace orig, Mesh mesh=None, FiniteElementCollection fec=None)\n" "FiniteElementSpace(Mesh mesh, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" - "FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + "new_FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES) -> FiniteElementSpace\n" ""}, { "FiniteElementSpace_GetMesh", _wrap_FiniteElementSpace_GetMesh, METH_O, "FiniteElementSpace_GetMesh(FiniteElementSpace self) -> Mesh"}, { "FiniteElementSpace_GetNURBSext", _wrap_FiniteElementSpace_GetNURBSext, METH_VARARGS, "\n" @@ -12061,16 +10900,16 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetConformingRestriction", _wrap_FiniteElementSpace_GetConformingRestriction, METH_O, "FiniteElementSpace_GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix"}, { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "FiniteElementSpace_GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "FiniteElementSpace_GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, - { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "FiniteElementSpace_GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, - { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "FiniteElementSpace_GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "FiniteElementSpace_GetElementRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" "FiniteElementSpace_GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" ""}, - { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "FiniteElementSpace_GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "FiniteElementSpace_GetVDim(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "FiniteElementSpace_GetOrder(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "FiniteElementSpace_GetFaceOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetOrder, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFaceOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceOrder(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetNDofs", _wrap_FiniteElementSpace_GetNDofs, METH_O, "FiniteElementSpace_GetNDofs(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetVSize", _wrap_FiniteElementSpace_GetVSize, METH_O, "FiniteElementSpace_GetVSize(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetTrueVSize", _wrap_FiniteElementSpace_GetTrueVSize, METH_O, "FiniteElementSpace_GetTrueVSize(FiniteElementSpace self) -> int"}, @@ -12085,73 +10924,73 @@ static PyMethodDef SwigMethods[] = { { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "FiniteElementSpace_GetNE(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "FiniteElementSpace_GetNF(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "FiniteElementSpace_GetNBE(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "FiniteElementSpace_GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, - { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "FiniteElementSpace_GetElementType(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "FiniteElementSpace_GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, - { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "FiniteElementSpace_GetBdrElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, + { "FiniteElementSpace_GetElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, + { "FiniteElementSpace_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementType(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetElementTransformation", _wrap_FiniteElementSpace_GetElementTransformation, METH_VARARGS, "\n" "FiniteElementSpace_GetElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation\n" "FiniteElementSpace_GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "FiniteElementSpace_GetBdrElementTransformation", _wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS, "FiniteElementSpace_GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, - { "FiniteElementSpace_GetAttribute", _wrap_FiniteElementSpace_GetAttribute, METH_VARARGS, "FiniteElementSpace_GetAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetBdrAttribute", _wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS, "FiniteElementSpace_GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementDofs", _wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS, "FiniteElementSpace_GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetBdrElementDofs", _wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "FiniteElementSpace_GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceDofs", _wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS, "FiniteElementSpace_GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetEdgeDofs", _wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetVertexDofs", _wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS, "FiniteElementSpace_GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetElementInteriorDofs", _wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceInteriorDofs", _wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetNumElementInteriorDofs", _wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetEdgeInteriorDofs", _wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementTransformation", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, + { "FiniteElementSpace_GetAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetAttribute, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetEdgeDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetVertexDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetNumElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetEdgeInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, { "FiniteElementSpace_DofsToVDofs", _wrap_FiniteElementSpace_DofsToVDofs, METH_VARARGS, "\n" "FiniteElementSpace_DofsToVDofs(FiniteElementSpace self, intArray dofs, int ndofs=-1)\n" "FiniteElementSpace_DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)\n" ""}, - { "FiniteElementSpace_DofToVDof", _wrap_FiniteElementSpace_DofToVDof, METH_VARARGS, "FiniteElementSpace_DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, - { "FiniteElementSpace_VDofToDof", _wrap_FiniteElementSpace_VDofToDof, METH_VARARGS, "FiniteElementSpace_VDofToDof(FiniteElementSpace self, int vdof) -> int"}, - { "FiniteElementSpace_AdjustVDofs", _wrap_FiniteElementSpace_AdjustVDofs, METH_O, "FiniteElementSpace_AdjustVDofs(intArray vdofs)"}, - { "FiniteElementSpace_GetElementVDofs", _wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS, "FiniteElementSpace_GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetBdrElementVDofs", _wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS, "FiniteElementSpace_GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetFaceVDofs", _wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS, "FiniteElementSpace_GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeVDofs", _wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetVertexVDofs", _wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS, "FiniteElementSpace_GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetElementInteriorVDofs", _wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS, "FiniteElementSpace_GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeInteriorVDofs", _wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS, "FiniteElementSpace_GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_DofToVDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_DofToVDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, + { "FiniteElementSpace_VDofToDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_VDofToDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_VDofToDof(FiniteElementSpace self, int vdof) -> int"}, + { "FiniteElementSpace_AdjustVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_AdjustVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_AdjustVDofs(intArray vdofs)"}, + { "FiniteElementSpace_GetElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetBdrElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetFaceVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetVertexVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetElementInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, { "FiniteElementSpace_RebuildElementToDofTable", _wrap_FiniteElementSpace_RebuildElementToDofTable, METH_O, "FiniteElementSpace_RebuildElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_ReorderElementToDofTable", _wrap_FiniteElementSpace_ReorderElementToDofTable, METH_O, "FiniteElementSpace_ReorderElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_BuildDofToArrays", _wrap_FiniteElementSpace_BuildDofToArrays, METH_O, "FiniteElementSpace_BuildDofToArrays(FiniteElementSpace self)"}, { "FiniteElementSpace_GetElementToDofTable", _wrap_FiniteElementSpace_GetElementToDofTable, METH_O, "FiniteElementSpace_GetElementToDofTable(FiniteElementSpace self) -> Table"}, { "FiniteElementSpace_GetBdrElementToDofTable", _wrap_FiniteElementSpace_GetBdrElementToDofTable, METH_O, "FiniteElementSpace_GetBdrElementToDofTable(FiniteElementSpace self) -> Table"}, - { "FiniteElementSpace_GetElementForDof", _wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS, "FiniteElementSpace_GetElementForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetLocalDofForDof", _wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS, "FiniteElementSpace_GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFE", _wrap_FiniteElementSpace_GetFE, METH_VARARGS, "FiniteElementSpace_GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetBE", _wrap_FiniteElementSpace_GetBE, METH_VARARGS, "FiniteElementSpace_GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetFaceElement", _wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS, "FiniteElementSpace_GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetEdgeElement", _wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS, "FiniteElementSpace_GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetTraceElement", _wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS, "FiniteElementSpace_GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, - { "FiniteElementSpace_GetEssentialVDofs", _wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "FiniteElementSpace_GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, - { "FiniteElementSpace_GetEssentialTrueDofs", _wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "FiniteElementSpace_GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, - { "FiniteElementSpace_MarkerToList", _wrap_FiniteElementSpace_MarkerToList, METH_VARARGS, "FiniteElementSpace_MarkerToList(intArray marker, intArray list)"}, - { "FiniteElementSpace_ListToMarker", _wrap_FiniteElementSpace_ListToMarker, METH_VARARGS, "FiniteElementSpace_ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, - { "FiniteElementSpace_ConvertToConformingVDofs", _wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS, "FiniteElementSpace_ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, - { "FiniteElementSpace_ConvertFromConformingVDofs", _wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS, "FiniteElementSpace_ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, - { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS, "FiniteElementSpace_D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS, "FiniteElementSpace_D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS, "FiniteElementSpace_H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, - { "FiniteElementSpace_GetTransferOperator", _wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS, "FiniteElementSpace_GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_GetTrueTransferOperator", _wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "FiniteElementSpace_GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_Update", _wrap_FiniteElementSpace_Update, METH_VARARGS, "FiniteElementSpace_Update(FiniteElementSpace self, bool want_transform=True)"}, + { "FiniteElementSpace_GetElementForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetElementForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetLocalDofForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFE, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetBE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBE, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetFaceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetEdgeElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetTraceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, + { "FiniteElementSpace_GetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, + { "FiniteElementSpace_GetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "FiniteElementSpace_MarkerToList", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_MarkerToList, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_MarkerToList(intArray marker, intArray list)"}, + { "FiniteElementSpace_ListToMarker", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ListToMarker, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, + { "FiniteElementSpace_ConvertToConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, + { "FiniteElementSpace_ConvertFromConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, + { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, + { "FiniteElementSpace_GetTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_GetTrueTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_Update", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Update, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_Update(FiniteElementSpace self, bool want_transform=True)"}, { "FiniteElementSpace_GetUpdateOperator", _wrap_FiniteElementSpace_GetUpdateOperator, METH_VARARGS, "\n" "FiniteElementSpace_GetUpdateOperator(FiniteElementSpace self) -> Operator\n" "FiniteElementSpace_GetUpdateOperator(FiniteElementSpace self, OperatorHandle T)\n" ""}, - { "FiniteElementSpace_SetUpdateOperatorOwner", _wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS, "FiniteElementSpace_SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, - { "FiniteElementSpace_SetUpdateOperatorType", _wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS, "FiniteElementSpace_SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, + { "FiniteElementSpace_SetUpdateOperatorOwner", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, + { "FiniteElementSpace_SetUpdateOperatorType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, { "FiniteElementSpace_UpdatesFinished", _wrap_FiniteElementSpace_UpdatesFinished, METH_O, "FiniteElementSpace_UpdatesFinished(FiniteElementSpace self)"}, { "FiniteElementSpace_GetSequence", _wrap_FiniteElementSpace_GetSequence, METH_O, "FiniteElementSpace_GetSequence(FiniteElementSpace self) -> long"}, - { "FiniteElementSpace_Load", _wrap_FiniteElementSpace_Load, METH_VARARGS, "FiniteElementSpace_Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, + { "FiniteElementSpace_Load", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Load, METH_VARARGS|METH_KEYWORDS, "FiniteElementSpace_Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, { "delete_FiniteElementSpace", _wrap_delete_FiniteElementSpace, METH_O, "delete_FiniteElementSpace(FiniteElementSpace self)"}, { "FiniteElementSpace_Save", _wrap_FiniteElementSpace_Save, METH_VARARGS, "\n" "FiniteElementSpace_Save(FiniteElementSpace self, std::ostream & out)\n" @@ -12166,7 +11005,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_QuadratureSpace", _wrap_delete_QuadratureSpace, METH_O, "delete_QuadratureSpace(QuadratureSpace self)"}, { "QuadratureSpace_GetSize", _wrap_QuadratureSpace_GetSize, METH_O, "QuadratureSpace_GetSize(QuadratureSpace self) -> int"}, - { "QuadratureSpace_GetElementIntRule", _wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS, "QuadratureSpace_GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, + { "QuadratureSpace_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "QuadratureSpace_GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, { "QuadratureSpace_Save", _wrap_QuadratureSpace_Save, METH_VARARGS, "\n" "QuadratureSpace_Save(QuadratureSpace self, std::ostream & out)\n" "QuadratureSpace_Save(QuadratureSpace self, char const * file, int precision=8)\n" @@ -12175,26 +11014,26 @@ static PyMethodDef SwigMethods[] = { { "QuadratureSpace_swigregister", QuadratureSpace_swigregister, METH_O, NULL}, { "QuadratureSpace_swiginit", QuadratureSpace_swiginit, METH_VARARGS, NULL}, { "delete_GridTransfer", _wrap_delete_GridTransfer, METH_O, "delete_GridTransfer(GridTransfer self)"}, - { "GridTransfer_SetOperatorType", _wrap_GridTransfer_SetOperatorType, METH_VARARGS, "GridTransfer_SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, + { "GridTransfer_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_GridTransfer_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "GridTransfer_SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, { "GridTransfer_ForwardOperator", _wrap_GridTransfer_ForwardOperator, METH_O, "GridTransfer_ForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_BackwardOperator", _wrap_GridTransfer_BackwardOperator, METH_O, "GridTransfer_BackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueForwardOperator", _wrap_GridTransfer_TrueForwardOperator, METH_O, "GridTransfer_TrueForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueBackwardOperator", _wrap_GridTransfer_TrueBackwardOperator, METH_O, "GridTransfer_TrueBackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_swigregister", GridTransfer_swigregister, METH_O, NULL}, - { "new_InterpolationGridTransfer", _wrap_new_InterpolationGridTransfer, METH_VARARGS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, + { "new_InterpolationGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_InterpolationGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, { "delete_InterpolationGridTransfer", _wrap_delete_InterpolationGridTransfer, METH_O, "delete_InterpolationGridTransfer(InterpolationGridTransfer self)"}, - { "InterpolationGridTransfer_SetMassIntegrator", _wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS, "InterpolationGridTransfer_SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, + { "InterpolationGridTransfer_SetMassIntegrator", (PyCFunction)(void(*)(void))_wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS|METH_KEYWORDS, "InterpolationGridTransfer_SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, { "InterpolationGridTransfer_ForwardOperator", _wrap_InterpolationGridTransfer_ForwardOperator, METH_O, "InterpolationGridTransfer_ForwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_BackwardOperator", _wrap_InterpolationGridTransfer_BackwardOperator, METH_O, "InterpolationGridTransfer_BackwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_swigregister", InterpolationGridTransfer_swigregister, METH_O, NULL}, { "InterpolationGridTransfer_swiginit", InterpolationGridTransfer_swiginit, METH_VARARGS, NULL}, - { "new_L2ProjectionGridTransfer", _wrap_new_L2ProjectionGridTransfer, METH_VARARGS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, + { "new_L2ProjectionGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_L2ProjectionGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, { "L2ProjectionGridTransfer_ForwardOperator", _wrap_L2ProjectionGridTransfer_ForwardOperator, METH_O, "L2ProjectionGridTransfer_ForwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "L2ProjectionGridTransfer_BackwardOperator", _wrap_L2ProjectionGridTransfer_BackwardOperator, METH_O, "L2ProjectionGridTransfer_BackwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, - { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, + { "UsesTensorBasis", (PyCFunction)(void(*)(void))_wrap_UsesTensorBasis, METH_VARARGS|METH_KEYWORDS, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; @@ -12209,7 +11048,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FiniteElementSpace()\n" "FiniteElementSpace(FiniteElementSpace orig, Mesh mesh=None, FiniteElementCollection fec=None)\n" "FiniteElementSpace(Mesh mesh, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" - "FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES)\n" + "new_FiniteElementSpace(Mesh mesh, mfem::NURBSExtension * ext, FiniteElementCollection fec, int vdim=1, int ordering=byNODES) -> FiniteElementSpace\n" ""}, { "FiniteElementSpace_GetMesh", _wrap_FiniteElementSpace_GetMesh, METH_O, "GetMesh(FiniteElementSpace self) -> Mesh"}, { "FiniteElementSpace_GetNURBSext", _wrap_FiniteElementSpace_GetNURBSext, METH_VARARGS, "\n" @@ -12223,16 +11062,16 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FiniteElementSpace_GetConformingRestriction", _wrap_FiniteElementSpace_GetConformingRestriction, METH_O, "GetConformingRestriction(FiniteElementSpace self) -> SparseMatrix"}, { "FiniteElementSpace_GetProlongationMatrix", _wrap_FiniteElementSpace_GetProlongationMatrix, METH_O, "GetProlongationMatrix(FiniteElementSpace self) -> Operator"}, { "FiniteElementSpace_GetRestrictionMatrix", _wrap_FiniteElementSpace_GetRestrictionMatrix, METH_O, "GetRestrictionMatrix(FiniteElementSpace self) -> SparseMatrix"}, - { "FiniteElementSpace_GetElementRestriction", _wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS, "GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, - { "FiniteElementSpace_GetFaceRestriction", _wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS, "GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, + { "FiniteElementSpace_GetElementRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementRestriction, METH_VARARGS|METH_KEYWORDS, "GetElementRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering) -> Operator"}, + { "FiniteElementSpace_GetFaceRestriction", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceRestriction, METH_VARARGS|METH_KEYWORDS, "GetFaceRestriction(FiniteElementSpace self, mfem::ElementDofOrdering e_ordering, mfem::FaceType arg3, mfem::L2FaceValues mul=DoubleValued) -> Operator"}, { "FiniteElementSpace_GetQuadratureInterpolator", _wrap_FiniteElementSpace_GetQuadratureInterpolator, METH_VARARGS, "\n" "GetQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir) -> mfem::QuadratureInterpolator const\n" "GetQuadratureInterpolator(FiniteElementSpace self, QuadratureSpace qs) -> mfem::QuadratureInterpolator const *\n" ""}, - { "FiniteElementSpace_GetFaceQuadratureInterpolator", _wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS, "GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, + { "FiniteElementSpace_GetFaceQuadratureInterpolator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceQuadratureInterpolator, METH_VARARGS|METH_KEYWORDS, "GetFaceQuadratureInterpolator(FiniteElementSpace self, IntegrationRule ir, mfem::FaceType type) -> mfem::FaceQuadratureInterpolator const *"}, { "FiniteElementSpace_GetVDim", _wrap_FiniteElementSpace_GetVDim, METH_O, "GetVDim(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetOrder", _wrap_FiniteElementSpace_GetOrder, METH_VARARGS, "GetOrder(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFaceOrder", _wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS, "GetFaceOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetOrder, METH_VARARGS|METH_KEYWORDS, "GetOrder(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFaceOrder", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceOrder, METH_VARARGS|METH_KEYWORDS, "GetFaceOrder(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetNDofs", _wrap_FiniteElementSpace_GetNDofs, METH_O, "GetNDofs(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetVSize", _wrap_FiniteElementSpace_GetVSize, METH_O, "GetVSize(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetTrueVSize", _wrap_FiniteElementSpace_GetTrueVSize, METH_O, "GetTrueVSize(FiniteElementSpace self) -> int"}, @@ -12247,73 +11086,73 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FiniteElementSpace_GetNE", _wrap_FiniteElementSpace_GetNE, METH_O, "GetNE(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNF", _wrap_FiniteElementSpace_GetNF, METH_O, "GetNF(FiniteElementSpace self) -> int"}, { "FiniteElementSpace_GetNBE", _wrap_FiniteElementSpace_GetNBE, METH_O, "GetNBE(FiniteElementSpace self) -> int"}, - { "FiniteElementSpace_GetNFbyType", _wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS, "GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, - { "FiniteElementSpace_GetElementType", _wrap_FiniteElementSpace_GetElementType, METH_VARARGS, "GetElementType(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementVertices", _wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS, "GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, - { "FiniteElementSpace_GetBdrElementType", _wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS, "GetBdrElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "GetNFbyType(FiniteElementSpace self, mfem::FaceType type) -> int"}, + { "FiniteElementSpace_GetElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementType, METH_VARARGS|METH_KEYWORDS, "GetElementType(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "GetElementVertices(FiniteElementSpace self, int i, intArray vertices)"}, + { "FiniteElementSpace_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "GetBdrElementType(FiniteElementSpace self, int i) -> int"}, { "FiniteElementSpace_GetElementTransformation", _wrap_FiniteElementSpace_GetElementTransformation, METH_VARARGS, "\n" "GetElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation\n" "GetElementTransformation(FiniteElementSpace self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "FiniteElementSpace_GetBdrElementTransformation", _wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS, "GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, - { "FiniteElementSpace_GetAttribute", _wrap_FiniteElementSpace_GetAttribute, METH_VARARGS, "GetAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetBdrAttribute", _wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetElementDofs", _wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS, "GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetBdrElementDofs", _wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS, "GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceDofs", _wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS, "GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetEdgeDofs", _wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS, "GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetVertexDofs", _wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS, "GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetElementInteriorDofs", _wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS, "GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetFaceInteriorDofs", _wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS, "GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, - { "FiniteElementSpace_GetNumElementInteriorDofs", _wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS, "GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetEdgeInteriorDofs", _wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS, "GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementTransformation", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementTransformation, METH_VARARGS|METH_KEYWORDS, "GetBdrElementTransformation(FiniteElementSpace self, int i) -> ElementTransformation"}, + { "FiniteElementSpace_GetAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetAttribute, METH_VARARGS|METH_KEYWORDS, "GetAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "GetBdrAttribute(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementDofs, METH_VARARGS|METH_KEYWORDS, "GetElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetBdrElementDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementDofs, METH_VARARGS|METH_KEYWORDS, "GetBdrElementDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetEdgeDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetVertexDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexDofs, METH_VARARGS|METH_KEYWORDS, "GetVertexDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetElementInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetFaceInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, + { "FiniteElementSpace_GetNumElementInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetNumElementInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetNumElementInteriorDofs(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetEdgeInteriorDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeInteriorDofs(FiniteElementSpace self, int i, intArray dofs)"}, { "FiniteElementSpace_DofsToVDofs", _wrap_FiniteElementSpace_DofsToVDofs, METH_VARARGS, "\n" "DofsToVDofs(FiniteElementSpace self, intArray dofs, int ndofs=-1)\n" "DofsToVDofs(FiniteElementSpace self, int vd, intArray dofs, int ndofs=-1)\n" ""}, - { "FiniteElementSpace_DofToVDof", _wrap_FiniteElementSpace_DofToVDof, METH_VARARGS, "DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, - { "FiniteElementSpace_VDofToDof", _wrap_FiniteElementSpace_VDofToDof, METH_VARARGS, "VDofToDof(FiniteElementSpace self, int vdof) -> int"}, - { "FiniteElementSpace_AdjustVDofs", _wrap_FiniteElementSpace_AdjustVDofs, METH_O, "AdjustVDofs(intArray vdofs)"}, - { "FiniteElementSpace_GetElementVDofs", _wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS, "GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetBdrElementVDofs", _wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS, "GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetFaceVDofs", _wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS, "GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeVDofs", _wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS, "GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetVertexVDofs", _wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS, "GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetElementInteriorVDofs", _wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS, "GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, - { "FiniteElementSpace_GetEdgeInteriorVDofs", _wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS, "GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_DofToVDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_DofToVDof, METH_VARARGS|METH_KEYWORDS, "DofToVDof(FiniteElementSpace self, int dof, int vd, int ndofs=-1) -> int"}, + { "FiniteElementSpace_VDofToDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_VDofToDof, METH_VARARGS|METH_KEYWORDS, "VDofToDof(FiniteElementSpace self, int vdof) -> int"}, + { "FiniteElementSpace_AdjustVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_AdjustVDofs, METH_VARARGS|METH_KEYWORDS, "AdjustVDofs(intArray vdofs)"}, + { "FiniteElementSpace_GetElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementVDofs, METH_VARARGS|METH_KEYWORDS, "GetElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetBdrElementVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBdrElementVDofs, METH_VARARGS|METH_KEYWORDS, "GetBdrElementVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetFaceVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceVDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeVDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetVertexVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetVertexVDofs, METH_VARARGS|METH_KEYWORDS, "GetVertexVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetElementInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "GetElementInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, + { "FiniteElementSpace_GetEdgeInteriorVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeInteriorVDofs, METH_VARARGS|METH_KEYWORDS, "GetEdgeInteriorVDofs(FiniteElementSpace self, int i, intArray vdofs)"}, { "FiniteElementSpace_RebuildElementToDofTable", _wrap_FiniteElementSpace_RebuildElementToDofTable, METH_O, "RebuildElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_ReorderElementToDofTable", _wrap_FiniteElementSpace_ReorderElementToDofTable, METH_O, "ReorderElementToDofTable(FiniteElementSpace self)"}, { "FiniteElementSpace_BuildDofToArrays", _wrap_FiniteElementSpace_BuildDofToArrays, METH_O, "BuildDofToArrays(FiniteElementSpace self)"}, { "FiniteElementSpace_GetElementToDofTable", _wrap_FiniteElementSpace_GetElementToDofTable, METH_O, "GetElementToDofTable(FiniteElementSpace self) -> Table"}, { "FiniteElementSpace_GetBdrElementToDofTable", _wrap_FiniteElementSpace_GetBdrElementToDofTable, METH_O, "GetBdrElementToDofTable(FiniteElementSpace self) -> Table"}, - { "FiniteElementSpace_GetElementForDof", _wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS, "GetElementForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetLocalDofForDof", _wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS, "GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, - { "FiniteElementSpace_GetFE", _wrap_FiniteElementSpace_GetFE, METH_VARARGS, "GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetBE", _wrap_FiniteElementSpace_GetBE, METH_VARARGS, "GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetFaceElement", _wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS, "GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetEdgeElement", _wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS, "GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, - { "FiniteElementSpace_GetTraceElement", _wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS, "GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, - { "FiniteElementSpace_GetEssentialVDofs", _wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS, "GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, - { "FiniteElementSpace_GetEssentialTrueDofs", _wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS, "GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, - { "FiniteElementSpace_MarkerToList", _wrap_FiniteElementSpace_MarkerToList, METH_VARARGS, "MarkerToList(intArray marker, intArray list)"}, - { "FiniteElementSpace_ListToMarker", _wrap_FiniteElementSpace_ListToMarker, METH_VARARGS, "ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, - { "FiniteElementSpace_ConvertToConformingVDofs", _wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS, "ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, - { "FiniteElementSpace_ConvertFromConformingVDofs", _wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS, "ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, - { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS, "D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS, "D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, - { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", _wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS, "H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, - { "FiniteElementSpace_GetTransferOperator", _wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS, "GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_GetTrueTransferOperator", _wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS, "GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, - { "FiniteElementSpace_Update", _wrap_FiniteElementSpace_Update, METH_VARARGS, "Update(FiniteElementSpace self, bool want_transform=True)"}, + { "FiniteElementSpace_GetElementForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetElementForDof, METH_VARARGS|METH_KEYWORDS, "GetElementForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetLocalDofForDof", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetLocalDofForDof, METH_VARARGS|METH_KEYWORDS, "GetLocalDofForDof(FiniteElementSpace self, int i) -> int"}, + { "FiniteElementSpace_GetFE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFE, METH_VARARGS|METH_KEYWORDS, "GetFE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetBE", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetBE, METH_VARARGS|METH_KEYWORDS, "GetBE(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetFaceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetFaceElement, METH_VARARGS|METH_KEYWORDS, "GetFaceElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetEdgeElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEdgeElement, METH_VARARGS|METH_KEYWORDS, "GetEdgeElement(FiniteElementSpace self, int i) -> FiniteElement"}, + { "FiniteElementSpace_GetTraceElement", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTraceElement, METH_VARARGS|METH_KEYWORDS, "GetTraceElement(FiniteElementSpace self, int i, mfem::Geometry::Type geom_type) -> FiniteElement"}, + { "FiniteElementSpace_GetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "GetEssentialVDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_vdofs, int component=-1)"}, + { "FiniteElementSpace_GetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "GetEssentialTrueDofs(FiniteElementSpace self, intArray bdr_attr_is_ess, intArray ess_tdof_list, int component=-1)"}, + { "FiniteElementSpace_MarkerToList", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_MarkerToList, METH_VARARGS|METH_KEYWORDS, "MarkerToList(intArray marker, intArray list)"}, + { "FiniteElementSpace_ListToMarker", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ListToMarker, METH_VARARGS|METH_KEYWORDS, "ListToMarker(intArray list, int marker_size, intArray marker, int mark_val=-1)"}, + { "FiniteElementSpace_ConvertToConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertToConformingVDofs, METH_VARARGS|METH_KEYWORDS, "ConvertToConformingVDofs(FiniteElementSpace self, intArray dofs, intArray cdofs)"}, + { "FiniteElementSpace_ConvertFromConformingVDofs", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_ConvertFromConformingVDofs, METH_VARARGS|METH_KEYWORDS, "ConvertFromConformingVDofs(FiniteElementSpace self, intArray cdofs, intArray dofs)"}, + { "FiniteElementSpace_D2C_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2C_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "D2C_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_D2Const_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_D2Const_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "D2Const_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace cfes) -> SparseMatrix"}, + { "FiniteElementSpace_H2L_GlobalRestrictionMatrix", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_H2L_GlobalRestrictionMatrix, METH_VARARGS|METH_KEYWORDS, "H2L_GlobalRestrictionMatrix(FiniteElementSpace self, FiniteElementSpace lfes) -> SparseMatrix"}, + { "FiniteElementSpace_GetTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTransferOperator, METH_VARARGS|METH_KEYWORDS, "GetTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_GetTrueTransferOperator", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_GetTrueTransferOperator, METH_VARARGS|METH_KEYWORDS, "GetTrueTransferOperator(FiniteElementSpace self, FiniteElementSpace coarse_fes, OperatorHandle T)"}, + { "FiniteElementSpace_Update", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Update, METH_VARARGS|METH_KEYWORDS, "Update(FiniteElementSpace self, bool want_transform=True)"}, { "FiniteElementSpace_GetUpdateOperator", _wrap_FiniteElementSpace_GetUpdateOperator, METH_VARARGS, "\n" "GetUpdateOperator(FiniteElementSpace self) -> Operator\n" "GetUpdateOperator(FiniteElementSpace self, OperatorHandle T)\n" ""}, - { "FiniteElementSpace_SetUpdateOperatorOwner", _wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS, "SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, - { "FiniteElementSpace_SetUpdateOperatorType", _wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS, "SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, + { "FiniteElementSpace_SetUpdateOperatorOwner", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorOwner, METH_VARARGS|METH_KEYWORDS, "SetUpdateOperatorOwner(FiniteElementSpace self, bool own)"}, + { "FiniteElementSpace_SetUpdateOperatorType", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_SetUpdateOperatorType, METH_VARARGS|METH_KEYWORDS, "SetUpdateOperatorType(FiniteElementSpace self, mfem::Operator::Type tid)"}, { "FiniteElementSpace_UpdatesFinished", _wrap_FiniteElementSpace_UpdatesFinished, METH_O, "UpdatesFinished(FiniteElementSpace self)"}, { "FiniteElementSpace_GetSequence", _wrap_FiniteElementSpace_GetSequence, METH_O, "GetSequence(FiniteElementSpace self) -> long"}, - { "FiniteElementSpace_Load", _wrap_FiniteElementSpace_Load, METH_VARARGS, "Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, + { "FiniteElementSpace_Load", (PyCFunction)(void(*)(void))_wrap_FiniteElementSpace_Load, METH_VARARGS|METH_KEYWORDS, "Load(FiniteElementSpace self, Mesh m, std::istream & input) -> FiniteElementCollection"}, { "delete_FiniteElementSpace", _wrap_delete_FiniteElementSpace, METH_O, "delete_FiniteElementSpace(FiniteElementSpace self)"}, { "FiniteElementSpace_Save", _wrap_FiniteElementSpace_Save, METH_VARARGS, "\n" "Save(FiniteElementSpace self, std::ostream & out)\n" @@ -12328,7 +11167,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_QuadratureSpace", _wrap_delete_QuadratureSpace, METH_O, "delete_QuadratureSpace(QuadratureSpace self)"}, { "QuadratureSpace_GetSize", _wrap_QuadratureSpace_GetSize, METH_O, "GetSize(QuadratureSpace self) -> int"}, - { "QuadratureSpace_GetElementIntRule", _wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, + { "QuadratureSpace_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureSpace_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "GetElementIntRule(QuadratureSpace self, int idx) -> IntegrationRule"}, { "QuadratureSpace_Save", _wrap_QuadratureSpace_Save, METH_VARARGS, "\n" "Save(QuadratureSpace self, std::ostream & out)\n" "Save(QuadratureSpace self, char const * file, int precision=8)\n" @@ -12337,26 +11176,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "QuadratureSpace_swigregister", QuadratureSpace_swigregister, METH_O, NULL}, { "QuadratureSpace_swiginit", QuadratureSpace_swiginit, METH_VARARGS, NULL}, { "delete_GridTransfer", _wrap_delete_GridTransfer, METH_O, "delete_GridTransfer(GridTransfer self)"}, - { "GridTransfer_SetOperatorType", _wrap_GridTransfer_SetOperatorType, METH_VARARGS, "SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, + { "GridTransfer_SetOperatorType", (PyCFunction)(void(*)(void))_wrap_GridTransfer_SetOperatorType, METH_VARARGS|METH_KEYWORDS, "SetOperatorType(GridTransfer self, mfem::Operator::Type type)"}, { "GridTransfer_ForwardOperator", _wrap_GridTransfer_ForwardOperator, METH_O, "ForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_BackwardOperator", _wrap_GridTransfer_BackwardOperator, METH_O, "BackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueForwardOperator", _wrap_GridTransfer_TrueForwardOperator, METH_O, "TrueForwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_TrueBackwardOperator", _wrap_GridTransfer_TrueBackwardOperator, METH_O, "TrueBackwardOperator(GridTransfer self) -> Operator"}, { "GridTransfer_swigregister", GridTransfer_swigregister, METH_O, NULL}, - { "new_InterpolationGridTransfer", _wrap_new_InterpolationGridTransfer, METH_VARARGS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, + { "new_InterpolationGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_InterpolationGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_InterpolationGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> InterpolationGridTransfer"}, { "delete_InterpolationGridTransfer", _wrap_delete_InterpolationGridTransfer, METH_O, "delete_InterpolationGridTransfer(InterpolationGridTransfer self)"}, - { "InterpolationGridTransfer_SetMassIntegrator", _wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS, "SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, + { "InterpolationGridTransfer_SetMassIntegrator", (PyCFunction)(void(*)(void))_wrap_InterpolationGridTransfer_SetMassIntegrator, METH_VARARGS|METH_KEYWORDS, "SetMassIntegrator(InterpolationGridTransfer self, BilinearFormIntegrator mass_integ_, bool own_mass_integ_=True)"}, { "InterpolationGridTransfer_ForwardOperator", _wrap_InterpolationGridTransfer_ForwardOperator, METH_O, "ForwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_BackwardOperator", _wrap_InterpolationGridTransfer_BackwardOperator, METH_O, "BackwardOperator(InterpolationGridTransfer self) -> Operator"}, { "InterpolationGridTransfer_swigregister", InterpolationGridTransfer_swigregister, METH_O, NULL}, { "InterpolationGridTransfer_swiginit", InterpolationGridTransfer_swiginit, METH_VARARGS, NULL}, - { "new_L2ProjectionGridTransfer", _wrap_new_L2ProjectionGridTransfer, METH_VARARGS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, + { "new_L2ProjectionGridTransfer", (PyCFunction)(void(*)(void))_wrap_new_L2ProjectionGridTransfer, METH_VARARGS|METH_KEYWORDS, "new_L2ProjectionGridTransfer(FiniteElementSpace coarse_fes, FiniteElementSpace fine_fes) -> L2ProjectionGridTransfer"}, { "L2ProjectionGridTransfer_ForwardOperator", _wrap_L2ProjectionGridTransfer_ForwardOperator, METH_O, "ForwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "L2ProjectionGridTransfer_BackwardOperator", _wrap_L2ProjectionGridTransfer_BackwardOperator, METH_O, "BackwardOperator(L2ProjectionGridTransfer self) -> Operator"}, { "delete_L2ProjectionGridTransfer", _wrap_delete_L2ProjectionGridTransfer, METH_O, "delete_L2ProjectionGridTransfer(L2ProjectionGridTransfer self)"}, { "L2ProjectionGridTransfer_swigregister", L2ProjectionGridTransfer_swigregister, METH_O, NULL}, { "L2ProjectionGridTransfer_swiginit", L2ProjectionGridTransfer_swiginit, METH_VARARGS, NULL}, - { "UsesTensorBasis", _wrap_UsesTensorBasis, METH_O, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, + { "UsesTensorBasis", (PyCFunction)(void(*)(void))_wrap_UsesTensorBasis, METH_VARARGS|METH_KEYWORDS, "UsesTensorBasis(FiniteElementSpace fes) -> bool"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/geom_wrap.cxx b/mfem/_ser/geom_wrap.cxx index 002aa9d4..7093f272 100644 --- a/mfem/_ser/geom_wrap.cxx +++ b/mfem/_ser/geom_wrap.cxx @@ -3570,26 +3570,30 @@ SWIGINTERN PyObject *_wrap_delete_Geometry(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Geometry_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetVertices" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3617,26 +3621,30 @@ SWIGINTERN PyObject *_wrap_Geometry_GetVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Geometry_GetCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::IntegrationPoint *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetCenter" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3664,22 +3672,26 @@ SWIGINTERN PyObject *_wrap_Geometry_GetCenter(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Geometry_GetRandomPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetRandomPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; mfem::IntegrationPoint *arg2 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"GeomType", (char *)"ip", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetRandomPoint", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetRandomPoint", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Geometry_GetRandomPoint" "', argument " "2"" of type '" "mfem::IntegrationPoint &""'"); } @@ -4048,26 +4060,30 @@ SWIGINTERN PyObject *_wrap_Geometry_ProjectPoint(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_Geometry_GetGeomToPerfGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetGeomToPerfGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetGeomToPerfGeomJac", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetGeomToPerfGeomJac", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetGeomToPerfGeomJac" "', argument " "1"" of type '" "mfem::Geometry const *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4095,26 +4111,30 @@ SWIGINTERN PyObject *_wrap_Geometry_GetGeomToPerfGeomJac(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Geometry_GetPerfGeomToGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetPerfGeomToGeomJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; mfem::DenseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPerfGeomToGeomJac", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_GetPerfGeomToGeomJac", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPerfGeomToGeomJac" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4142,7 +4162,7 @@ SWIGINTERN PyObject *_wrap_Geometry_GetPerfGeomToGeomJac(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; @@ -4151,21 +4171,26 @@ SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"pm", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Geometry_GetPerfPointMat", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Geometry_GetPerfPointMat", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_GetPerfPointMat" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Geometry_GetPerfPointMat" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -4199,7 +4224,7 @@ SWIGINTERN PyObject *_wrap_Geometry_GetPerfPointMat(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; @@ -4211,21 +4236,27 @@ SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"J", (char *)"PJ", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Geometry_JacToPerfJac", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Geometry_JacToPerfJac", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_JacToPerfJac" "', argument " "1"" of type '" "mfem::Geometry const *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Geometry_JacToPerfJac" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -4233,7 +4264,7 @@ SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Geometry_JacToPerfJac" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Geometry_JacToPerfJac" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } @@ -4267,26 +4298,30 @@ SWIGINTERN PyObject *_wrap_Geometry_JacToPerfJac(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Geometry_NumBdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Geometry_NumBdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Geometry *arg1 = (mfem::Geometry *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Geometry_NumBdr", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Geometry_NumBdr", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Geometry, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Geometry_NumBdr" "', argument " "1"" of type '" "mfem::Geometry *""'"); } arg1 = reinterpret_cast< mfem::Geometry * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4686,94 +4721,51 @@ SWIGINTERN PyObject *_wrap_RefinedGeometry_Type_get(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_RefinedGeometry__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RefinedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; int arg3 ; - int arg4 ; + int arg4 = (int) 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"NPts", (char *)"NRefG", (char *)"NRefE", (char *)"NBdrE", NULL + }; mfem::RefinedGeometry *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_RefinedGeometry", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg3 = PyArray_PyIntAsInt(obj2); } - { - try { - result = (mfem::RefinedGeometry *)new mfem::RefinedGeometry(arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RefinedGeometry, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RefinedGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::RefinedGeometry *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); } { try { - result = (mfem::RefinedGeometry *)new mfem::RefinedGeometry(arg1,arg2,arg3); + result = (mfem::RefinedGeometry *)new mfem::RefinedGeometry(arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4797,102 +4789,6 @@ SWIGINTERN PyObject *_wrap_new_RefinedGeometry__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_new_RefinedGeometry(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RefinedGeometry", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RefinedGeometry__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_RefinedGeometry__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RefinedGeometry'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RefinedGeometry::RefinedGeometry(int,int,int,int)\n" - " mfem::RefinedGeometry::RefinedGeometry(int,int,int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_RefinedGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::RefinedGeometry *arg1 = (mfem::RefinedGeometry *) 0 ; @@ -4975,25 +4871,29 @@ SWIGINTERN PyObject *_wrap_new_GeometryRefiner(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_GeometryRefiner_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeometryRefiner_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeometryRefiner_SetType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeometryRefiner_SetType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_SetType" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); } arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5062,40 +4962,49 @@ SWIGINTERN PyObject *_wrap_GeometryRefiner_GetType(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; mfem::Geometry::Type arg2 ; int arg3 ; - int arg4 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Geom", (char *)"Times", (char *)"ETimes", NULL + }; mfem::RefinedGeometry *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:GeometryRefiner_Refine", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_Refine" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); } arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeometryRefiner_Refine" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { @@ -5123,7 +5032,7 @@ SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeometryRefiner_RefineInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; mfem::Geometry::Type arg2 ; @@ -5132,157 +5041,30 @@ SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine__SWIG_1(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - mfem::RefinedGeometry *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_Refine" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); - } - arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeometryRefiner_Refine" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::RefinedGeometry *)(arg1)->Refine(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RefinedGeometry, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GeometryRefiner_Refine(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Geom", (char *)"Times", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GeometryRefiner_Refine", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeometryRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GeometryRefiner_Refine__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeometryRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GeometryRefiner_Refine__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GeometryRefiner_Refine'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeometryRefiner::Refine(mfem::Geometry::Type,int,int)\n" - " mfem::GeometryRefiner::Refine(mfem::Geometry::Type,int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeometryRefiner_RefineInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GeometryRefiner *arg1 = (mfem::GeometryRefiner *) 0 ; - mfem::Geometry::Type arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[3] ; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GeometryRefiner_RefineInterior", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GeometryRefiner_RefineInterior", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeometryRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeometryRefiner_RefineInterior" "', argument " "1"" of type '" "mfem::GeometryRefiner *""'"); } arg1 = reinterpret_cast< mfem::GeometryRefiner * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GeometryRefiner_RefineInterior" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5382,9 +5164,9 @@ static PyMethodDef SwigMethods[] = { { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"}, - { "Geometry_GetVertices", _wrap_Geometry_GetVertices, METH_VARARGS, "Geometry_GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, - { "Geometry_GetCenter", _wrap_Geometry_GetCenter, METH_VARARGS, "Geometry_GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, - { "Geometry_GetRandomPoint", _wrap_Geometry_GetRandomPoint, METH_VARARGS, "Geometry_GetRandomPoint(int GeomType, IntegrationPoint ip)"}, + { "Geometry_GetVertices", (PyCFunction)(void(*)(void))_wrap_Geometry_GetVertices, METH_VARARGS|METH_KEYWORDS, "Geometry_GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, + { "Geometry_GetCenter", (PyCFunction)(void(*)(void))_wrap_Geometry_GetCenter, METH_VARARGS|METH_KEYWORDS, "Geometry_GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, + { "Geometry_GetRandomPoint", (PyCFunction)(void(*)(void))_wrap_Geometry_GetRandomPoint, METH_VARARGS|METH_KEYWORDS, "Geometry_GetRandomPoint(int GeomType, IntegrationPoint ip)"}, { "Geometry_CheckPoint", _wrap_Geometry_CheckPoint, METH_VARARGS, "\n" "Geometry_CheckPoint(int GeomType, IntegrationPoint ip) -> bool\n" "Geometry_CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool\n" @@ -5393,11 +5175,11 @@ static PyMethodDef SwigMethods[] = { "Geometry_ProjectPoint(int GeomType, IntegrationPoint beg, IntegrationPoint end) -> bool\n" "Geometry_ProjectPoint(int GeomType, IntegrationPoint ip) -> bool\n" ""}, - { "Geometry_GetGeomToPerfGeomJac", _wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS, "Geometry_GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfGeomToGeomJac", _wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS, "Geometry_GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfPointMat", _wrap_Geometry_GetPerfPointMat, METH_VARARGS, "Geometry_GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, - { "Geometry_JacToPerfJac", _wrap_Geometry_JacToPerfJac, METH_VARARGS, "Geometry_JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, - { "Geometry_NumBdr", _wrap_Geometry_NumBdr, METH_VARARGS, "Geometry_NumBdr(Geometry self, int GeomType) -> int"}, + { "Geometry_GetGeomToPerfGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS|METH_KEYWORDS, "Geometry_GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfGeomToGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS|METH_KEYWORDS, "Geometry_GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfPointMat", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfPointMat, METH_VARARGS|METH_KEYWORDS, "Geometry_GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, + { "Geometry_JacToPerfJac", (PyCFunction)(void(*)(void))_wrap_Geometry_JacToPerfJac, METH_VARARGS|METH_KEYWORDS, "Geometry_JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, + { "Geometry_NumBdr", (PyCFunction)(void(*)(void))_wrap_Geometry_NumBdr, METH_VARARGS|METH_KEYWORDS, "Geometry_NumBdr(Geometry self, int GeomType) -> int"}, { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL}, { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL}, { "RefinedGeometry_Times_set", _wrap_RefinedGeometry_Times_set, METH_VARARGS, "RefinedGeometry_Times_set(RefinedGeometry self, int Times)"}, @@ -5413,15 +5195,15 @@ static PyMethodDef SwigMethods[] = { { "RefinedGeometry_NumBdrEdges_get", _wrap_RefinedGeometry_NumBdrEdges_get, METH_O, "RefinedGeometry_NumBdrEdges_get(RefinedGeometry self) -> int"}, { "RefinedGeometry_Type_set", _wrap_RefinedGeometry_Type_set, METH_VARARGS, "RefinedGeometry_Type_set(RefinedGeometry self, int Type)"}, { "RefinedGeometry_Type_get", _wrap_RefinedGeometry_Type_get, METH_O, "RefinedGeometry_Type_get(RefinedGeometry self) -> int"}, - { "new_RefinedGeometry", _wrap_new_RefinedGeometry, METH_VARARGS, "RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0)"}, + { "new_RefinedGeometry", (PyCFunction)(void(*)(void))_wrap_new_RefinedGeometry, METH_VARARGS|METH_KEYWORDS, "new_RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0) -> RefinedGeometry"}, { "delete_RefinedGeometry", _wrap_delete_RefinedGeometry, METH_O, "delete_RefinedGeometry(RefinedGeometry self)"}, { "RefinedGeometry_swigregister", RefinedGeometry_swigregister, METH_O, NULL}, { "RefinedGeometry_swiginit", RefinedGeometry_swiginit, METH_VARARGS, NULL}, { "new_GeometryRefiner", _wrap_new_GeometryRefiner, METH_NOARGS, "new_GeometryRefiner() -> GeometryRefiner"}, - { "GeometryRefiner_SetType", _wrap_GeometryRefiner_SetType, METH_VARARGS, "GeometryRefiner_SetType(GeometryRefiner self, int const t)"}, + { "GeometryRefiner_SetType", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_SetType, METH_VARARGS|METH_KEYWORDS, "GeometryRefiner_SetType(GeometryRefiner self, int const t)"}, { "GeometryRefiner_GetType", _wrap_GeometryRefiner_GetType, METH_O, "GeometryRefiner_GetType(GeometryRefiner self) -> int"}, - { "GeometryRefiner_Refine", _wrap_GeometryRefiner_Refine, METH_VARARGS, "GeometryRefiner_Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, - { "GeometryRefiner_RefineInterior", _wrap_GeometryRefiner_RefineInterior, METH_VARARGS, "GeometryRefiner_RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, + { "GeometryRefiner_Refine", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_Refine, METH_VARARGS|METH_KEYWORDS, "GeometryRefiner_Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, + { "GeometryRefiner_RefineInterior", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_RefineInterior, METH_VARARGS|METH_KEYWORDS, "GeometryRefiner_RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, { "delete_GeometryRefiner", _wrap_delete_GeometryRefiner, METH_O, "delete_GeometryRefiner(GeometryRefiner self)"}, { "GeometryRefiner_swigregister", GeometryRefiner_swigregister, METH_O, NULL}, { "GeometryRefiner_swiginit", GeometryRefiner_swiginit, METH_VARARGS, NULL}, @@ -5435,9 +5217,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Geometry_Name_set", _wrap_Geometry_Name_set, METH_O, NULL}, { "new_Geometry", _wrap_new_Geometry, METH_NOARGS, "new_Geometry() -> Geometry"}, { "delete_Geometry", _wrap_delete_Geometry, METH_O, "delete_Geometry(Geometry self)"}, - { "Geometry_GetVertices", _wrap_Geometry_GetVertices, METH_VARARGS, "GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, - { "Geometry_GetCenter", _wrap_Geometry_GetCenter, METH_VARARGS, "GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, - { "Geometry_GetRandomPoint", _wrap_Geometry_GetRandomPoint, METH_VARARGS, "GetRandomPoint(int GeomType, IntegrationPoint ip)"}, + { "Geometry_GetVertices", (PyCFunction)(void(*)(void))_wrap_Geometry_GetVertices, METH_VARARGS|METH_KEYWORDS, "GetVertices(Geometry self, int GeomType) -> IntegrationRule"}, + { "Geometry_GetCenter", (PyCFunction)(void(*)(void))_wrap_Geometry_GetCenter, METH_VARARGS|METH_KEYWORDS, "GetCenter(Geometry self, int GeomType) -> IntegrationPoint"}, + { "Geometry_GetRandomPoint", (PyCFunction)(void(*)(void))_wrap_Geometry_GetRandomPoint, METH_VARARGS|METH_KEYWORDS, "GetRandomPoint(int GeomType, IntegrationPoint ip)"}, { "Geometry_CheckPoint", _wrap_Geometry_CheckPoint, METH_VARARGS, "\n" "CheckPoint(int GeomType, IntegrationPoint ip) -> bool\n" "CheckPoint(int GeomType, IntegrationPoint ip, double eps) -> bool\n" @@ -5446,11 +5228,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ProjectPoint(int GeomType, IntegrationPoint beg, IntegrationPoint end) -> bool\n" "ProjectPoint(int GeomType, IntegrationPoint ip) -> bool\n" ""}, - { "Geometry_GetGeomToPerfGeomJac", _wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS, "GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfGeomToGeomJac", _wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS, "GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, - { "Geometry_GetPerfPointMat", _wrap_Geometry_GetPerfPointMat, METH_VARARGS, "GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, - { "Geometry_JacToPerfJac", _wrap_Geometry_JacToPerfJac, METH_VARARGS, "JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, - { "Geometry_NumBdr", _wrap_Geometry_NumBdr, METH_VARARGS, "NumBdr(Geometry self, int GeomType) -> int"}, + { "Geometry_GetGeomToPerfGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetGeomToPerfGeomJac, METH_VARARGS|METH_KEYWORDS, "GetGeomToPerfGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfGeomToGeomJac", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfGeomToGeomJac, METH_VARARGS|METH_KEYWORDS, "GetPerfGeomToGeomJac(Geometry self, int GeomType) -> DenseMatrix"}, + { "Geometry_GetPerfPointMat", (PyCFunction)(void(*)(void))_wrap_Geometry_GetPerfPointMat, METH_VARARGS|METH_KEYWORDS, "GetPerfPointMat(Geometry self, int GeomType, DenseMatrix pm)"}, + { "Geometry_JacToPerfJac", (PyCFunction)(void(*)(void))_wrap_Geometry_JacToPerfJac, METH_VARARGS|METH_KEYWORDS, "JacToPerfJac(Geometry self, int GeomType, DenseMatrix J, DenseMatrix PJ)"}, + { "Geometry_NumBdr", (PyCFunction)(void(*)(void))_wrap_Geometry_NumBdr, METH_VARARGS|METH_KEYWORDS, "NumBdr(Geometry self, int GeomType) -> int"}, { "Geometry_swigregister", Geometry_swigregister, METH_O, NULL}, { "Geometry_swiginit", Geometry_swiginit, METH_VARARGS, NULL}, { "RefinedGeometry_Times_set", _wrap_RefinedGeometry_Times_set, METH_VARARGS, "RefinedGeometry_Times_set(RefinedGeometry self, int Times)"}, @@ -5466,15 +5248,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "RefinedGeometry_NumBdrEdges_get", _wrap_RefinedGeometry_NumBdrEdges_get, METH_O, "RefinedGeometry_NumBdrEdges_get(RefinedGeometry self) -> int"}, { "RefinedGeometry_Type_set", _wrap_RefinedGeometry_Type_set, METH_VARARGS, "RefinedGeometry_Type_set(RefinedGeometry self, int Type)"}, { "RefinedGeometry_Type_get", _wrap_RefinedGeometry_Type_get, METH_O, "RefinedGeometry_Type_get(RefinedGeometry self) -> int"}, - { "new_RefinedGeometry", _wrap_new_RefinedGeometry, METH_VARARGS, "RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0)"}, + { "new_RefinedGeometry", (PyCFunction)(void(*)(void))_wrap_new_RefinedGeometry, METH_VARARGS|METH_KEYWORDS, "new_RefinedGeometry(int NPts, int NRefG, int NRefE, int NBdrE=0) -> RefinedGeometry"}, { "delete_RefinedGeometry", _wrap_delete_RefinedGeometry, METH_O, "delete_RefinedGeometry(RefinedGeometry self)"}, { "RefinedGeometry_swigregister", RefinedGeometry_swigregister, METH_O, NULL}, { "RefinedGeometry_swiginit", RefinedGeometry_swiginit, METH_VARARGS, NULL}, { "new_GeometryRefiner", _wrap_new_GeometryRefiner, METH_NOARGS, "new_GeometryRefiner() -> GeometryRefiner"}, - { "GeometryRefiner_SetType", _wrap_GeometryRefiner_SetType, METH_VARARGS, "SetType(GeometryRefiner self, int const t)"}, + { "GeometryRefiner_SetType", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_SetType, METH_VARARGS|METH_KEYWORDS, "SetType(GeometryRefiner self, int const t)"}, { "GeometryRefiner_GetType", _wrap_GeometryRefiner_GetType, METH_O, "GetType(GeometryRefiner self) -> int"}, - { "GeometryRefiner_Refine", _wrap_GeometryRefiner_Refine, METH_VARARGS, "Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, - { "GeometryRefiner_RefineInterior", _wrap_GeometryRefiner_RefineInterior, METH_VARARGS, "RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, + { "GeometryRefiner_Refine", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_Refine, METH_VARARGS|METH_KEYWORDS, "Refine(GeometryRefiner self, mfem::Geometry::Type Geom, int Times, int ETimes=1) -> RefinedGeometry"}, + { "GeometryRefiner_RefineInterior", (PyCFunction)(void(*)(void))_wrap_GeometryRefiner_RefineInterior, METH_VARARGS|METH_KEYWORDS, "RefineInterior(GeometryRefiner self, mfem::Geometry::Type Geom, int Times) -> IntegrationRule"}, { "delete_GeometryRefiner", _wrap_delete_GeometryRefiner, METH_O, "delete_GeometryRefiner(GeometryRefiner self)"}, { "GeometryRefiner_swigregister", GeometryRefiner_swigregister, METH_O, NULL}, { "GeometryRefiner_swiginit", GeometryRefiner_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/globals.py b/mfem/_ser/globals.py index 78ab457e..cd213347 100644 --- a/mfem/_ser/globals.py +++ b/mfem/_ser/globals.py @@ -92,8 +92,8 @@ def IsEnabled(self): _globals.OutStream_swigregister(OutStream) -def MakeParFilename(*args): - return _globals.MakeParFilename(*args) +def MakeParFilename(*args, **kwargs): + return _globals.MakeParFilename(*args, **kwargs) MakeParFilename = _globals.MakeParFilename cvar = _globals.cvar diff --git a/mfem/_ser/globals_wrap.cxx b/mfem/_ser/globals_wrap.cxx index addcf9e1..d5c007a0 100644 --- a/mfem/_ser/globals_wrap.cxx +++ b/mfem/_ser/globals_wrap.cxx @@ -2934,17 +2934,19 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_OutStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_OutStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; std::ostream *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"out", NULL + }; mfem::OutStream *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__ostream, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_OutStream", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OutStream" "', argument " "1"" of type '" "std::ostream &""'"); } @@ -2975,7 +2977,7 @@ SWIGINTERN PyObject *_wrap_new_OutStream(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_OutStream_SetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OutStream_SetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OutStream *arg1 = (mfem::OutStream *) 0 ; std::ostream *arg2 = 0 ; @@ -2983,15 +2985,19 @@ SWIGINTERN PyObject *_wrap_OutStream_SetStream(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OutStream_SetStream", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OutStream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OutStream_SetStream", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OutStream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutStream_SetStream" "', argument " "1"" of type '" "mfem::OutStream *""'"); } arg1 = reinterpret_cast< mfem::OutStream * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OutStream_SetStream" "', argument " "2"" of type '" "std::ostream &""'"); } @@ -3210,12 +3216,12 @@ SWIGINTERN PyObject *Swig_var_err_get(void) { } -SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MakeParFilename(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; std::string *arg1 = 0 ; int arg2 ; - std::string arg3 ; - int arg4 ; + std::string arg3 = (std::string) (std::string)"" ; + int arg4 = (int) (int)6 ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -3224,78 +3230,17 @@ SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_0(PyObject *SWIGUNUSEDPARM(self int res3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"prefix", (char *)"myid", (char *)"suffix", (char *)"width", NULL + }; std::string result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); - } - arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MakeParFilename" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MakeParFilename" "', argument " "4"" of type '" "int""'"); - } - arg4 = static_cast< int >(val4); - { - try { - result = mfem::MakeParFilename((std::string const &)*arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj((new std::string(static_cast< const std::string& >(result))), SWIGTYPE_p_std__string, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - int arg2 ; - std::string arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - void *argp3 ; - int res3 = 0 ; - std::string result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:MakeParFilename", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); } @@ -3303,74 +3248,36 @@ SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_1(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); } arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MakeParFilename" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp3); - arg3 = *temp; - if (SWIG_IsNewObj(res3)) delete temp; - } - } - { - try { - result = mfem::MakeParFilename((std::string const &)*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "3"" of type '" "std::string const""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp3); + arg3 = *temp; + if (SWIG_IsNewObj(res3)) delete temp; + } } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj((new std::string(static_cast< const std::string& >(result))), SWIGTYPE_p_std__string, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::string *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - std::string result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MakeParFilename" "', argument " "1"" of type '" "std::string const &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "MakeParFilename" "', argument " "4"" of type '" "int""'"); + } + arg4 = static_cast< int >(val4); } - arg1 = reinterpret_cast< std::string * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MakeParFilename" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); { try { - result = mfem::MakeParFilename((std::string const &)*arg1,arg2); + result = mfem::MakeParFilename((std::string const &)*arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3391,108 +3298,33 @@ SWIGINTERN PyObject *_wrap_MakeParFilename__SWIG_2(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_MakeParFilename(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MakeParFilename", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MakeParFilename__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MakeParFilename__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MakeParFilename__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MakeParFilename'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MakeParFilename(std::string const &,int const,std::string const,int const)\n" - " mfem::MakeParFilename(std::string const &,int const,std::string const)\n" - " mfem::MakeParFilename(std::string const &,int const)\n"); - return 0; -} - - static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, - { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, + { "new_OutStream", (PyCFunction)(void(*)(void))_wrap_new_OutStream, METH_VARARGS|METH_KEYWORDS, NULL}, + { "OutStream_SetStream", (PyCFunction)(void(*)(void))_wrap_OutStream_SetStream, METH_VARARGS|METH_KEYWORDS, NULL}, { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, { "OutStream_Disable", _wrap_OutStream_Disable, METH_O, NULL}, { "OutStream_IsEnabled", _wrap_OutStream_IsEnabled, METH_O, NULL}, { "delete_OutStream", _wrap_delete_OutStream, METH_O, NULL}, { "OutStream_swigregister", OutStream_swigregister, METH_O, NULL}, { "OutStream_swiginit", OutStream_swiginit, METH_VARARGS, NULL}, - { "MakeParFilename", _wrap_MakeParFilename, METH_VARARGS, NULL}, + { "MakeParFilename", (PyCFunction)(void(*)(void))_wrap_MakeParFilename, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_OutStream", _wrap_new_OutStream, METH_O, NULL}, - { "OutStream_SetStream", _wrap_OutStream_SetStream, METH_VARARGS, NULL}, + { "new_OutStream", (PyCFunction)(void(*)(void))_wrap_new_OutStream, METH_VARARGS|METH_KEYWORDS, NULL}, + { "OutStream_SetStream", (PyCFunction)(void(*)(void))_wrap_OutStream_SetStream, METH_VARARGS|METH_KEYWORDS, NULL}, { "OutStream_Enable", _wrap_OutStream_Enable, METH_O, NULL}, { "OutStream_Disable", _wrap_OutStream_Disable, METH_O, NULL}, { "OutStream_IsEnabled", _wrap_OutStream_IsEnabled, METH_O, NULL}, { "delete_OutStream", _wrap_delete_OutStream, METH_O, NULL}, { "OutStream_swigregister", OutStream_swigregister, METH_O, NULL}, { "OutStream_swiginit", OutStream_swiginit, METH_VARARGS, NULL}, - { "MakeParFilename", _wrap_MakeParFilename, METH_VARARGS, NULL}, + { "MakeParFilename", (PyCFunction)(void(*)(void))_wrap_MakeParFilename, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/gridfunc_wrap.cxx b/mfem/_ser/gridfunc_wrap.cxx index c33ddabe..19418620 100644 --- a/mfem/_ser/gridfunc_wrap.cxx +++ b/mfem/_ser/gridfunc_wrap.cxx @@ -3836,7 +3836,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -3844,15 +3844,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -3911,17 +3915,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -3980,7 +3986,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -3988,15 +3994,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -4055,17 +4065,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -4402,7 +4414,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_Assign__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GridFunction_MakeOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_MakeOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::FiniteElementCollection *arg2 = (mfem::FiniteElementCollection *) 0 ; @@ -4410,15 +4422,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_MakeOwner(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_fec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_MakeOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_MakeOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_MakeOwner" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementCollection, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_MakeOwner" "', argument " "2"" of type '" "mfem::FiniteElementCollection *""'"); } @@ -4645,7 +4661,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetTrueVector(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_GridFunction_GetTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4653,15 +4669,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetTrueDofs(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetTrueDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetTrueDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetTrueDofs" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetTrueDofs" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4735,7 +4755,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_SetTrueVector(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4743,15 +4763,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_SetFromTrueDofs(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tv", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SetFromTrueDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_SetFromTrueDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SetFromTrueDofs" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SetFromTrueDofs" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4830,13 +4854,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_0(PyObject *SWIGUNU mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::Array< double > *arg3 = 0 ; - int arg4 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); @@ -4856,71 +4880,17 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_0(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "3"" of type '" "mfem::Array< double > &""'"); } arg3 = reinterpret_cast< mfem::Array< double > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - ((mfem::GridFunction const *)arg1)->GetNodalValues(arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Array< double > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetNodalValues" "', argument " "3"" of type '" "mfem::Array< double > &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "3"" of type '" "mfem::Array< double > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< double > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetNodalValues(arg2,*arg3); + ((mfem::GridFunction const *)arg1)->GetNodalValues(arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4944,31 +4914,38 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_GetValue__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationPoint *arg3 = 0 ; - int arg4 ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"ip", (char *)"vdim", NULL + }; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:GridFunction_GetValue", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4976,72 +4953,17 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValue__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->GetValue(arg2,(mfem::IntegrationPoint const &)*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetValue__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationPoint *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); { try { - result = (double)((mfem::GridFunction const *)arg1)->GetValue(arg2,(mfem::IntegrationPoint const &)*arg3); + result = (double)((mfem::GridFunction const *)arg1)->GetValue(arg2,(mfem::IntegrationPoint const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5065,81 +4987,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValue__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_GridFunction_GetValue(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValue", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationPoint, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetValue__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationPoint, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetValue__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValue'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &,int) const\n" - " mfem::GridFunction::GetValue(int,mfem::IntegrationPoint const &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; @@ -5151,21 +4999,27 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"ip", (char *)"val", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValue", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GridFunction_GetVectorValue", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValue" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -5173,7 +5027,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValue(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValue" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationPoint * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValue" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5213,7 +5067,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA int arg2 ; mfem::IntegrationRule *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - int arg5 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -5221,7 +5075,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA void *argp4 = 0 ; int res4 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); @@ -5249,11 +5103,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { @@ -5287,14 +5143,18 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPA int arg2 ; mfem::IntegrationRule *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); @@ -5322,9 +5182,25 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + } + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5348,27 +5224,129 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; +SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValues", 0, 6, argv))) SWIG_fail; + --argc; + if ((argc >= 4) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); + } + } + } + } + } + } + if ((argc >= 5) && (argc <= 6)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValues'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" + " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 = (int) 1 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -5379,37 +5357,31 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5433,13 +5405,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_2(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; mfem::Vector *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -5449,10 +5422,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -5463,31 +5436,39 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } { try { - ((mfem::GridFunction const *)arg1)->GetValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5511,43 +5492,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues__SWIG_3(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetValues", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetLaplacians", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetValues__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -5569,39 +5522,9 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetValues__SWIG_3(self, argc, argv); + if (argc <= 4) { + return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5611,14 +5534,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } } if (_v) { - return _wrap_GridFunction_GetValues__SWIG_0(self, argc, argv); + return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); } } } } } } - if (argc == 6) { + if ((argc >= 5) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -5644,6 +5567,9 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -5653,7 +5579,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } } if (_v) { - return _wrap_GridFunction_GetValues__SWIG_2(self, argc, argv); + return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); } } } @@ -5663,23 +5589,21 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValues(PyObject *self, PyObject *args } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetLaplacians'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetValues(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" + " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; + mfem::DenseMatrix *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -5687,10 +5611,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUS void *argp4 = 0 ; int res4 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -5701,29 +5625,31 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUS } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5747,81 +5673,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; + int arg6 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -5831,10 +5690,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUS void *argp5 = 0 ; int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -5845,115 +5704,39 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_2(PyObject *SWIGUNUS } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetLaplacians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetLaplacians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetLaplacians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5977,43 +5760,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians__SWIG_3(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetLaplacians", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetHessians", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -6032,42 +5787,12 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject * _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_3(self, argc, argv); + if (argc <= 4) { + return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6077,14 +5802,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject * } } if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_0(self, argc, argv); + return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); } } } } } } - if (argc == 6) { + if ((argc >= 5) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -6103,13 +5828,16 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject * _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6119,7 +5847,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject * } } if (_v) { - return _wrap_GridFunction_GetLaplacians__SWIG_2(self, argc, argv); + return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); } } } @@ -6129,134 +5857,96 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetLaplacians(PyObject *self, PyObject * } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetLaplacians'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetHessians'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,int) const\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &) const\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetLaplacians(int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,int) const\n" + " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; + int arg3 ; + mfem::IntegrationRule *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + int arg7 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"side", (char *)"ir", (char *)"vals", (char *)"tr", (char *)"vdim", NULL + }; + int result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:GridFunction_GetFaceValues", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg3 = PyArray_PyIntAsInt(obj2); } - { - try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); + if (obj6) { + { + if ((PyArray_PyIntAsInt(obj6) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(obj6); + } } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6273,75 +5963,61 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_1(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; + mfem::ElementTransformation *arg2 = 0 ; mfem::IntegrationRule *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } { try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + ((mfem::GridFunction const *)arg1)->GetVectorValues(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6365,7 +6041,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_2(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; @@ -6384,7 +6060,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSED if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetHessians" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { @@ -6395,31 +6071,31 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSED } res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetHessians" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetHessians(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetVectorValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6443,13 +6119,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians__SWIG_3(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[7] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetHessians", 0, 6, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValues", 0, 5, argv))) SWIG_fail; --argc; if (argc == 4) { int _v; @@ -6457,14 +6133,9 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *ar int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -6473,7 +6144,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *ar int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_1(self, argc, argv); + return _wrap_GridFunction_GetVectorValues__SWIG_0(self, argc, argv); } } } @@ -6505,176 +6176,149 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetHessians(PyObject *self, PyObject *ar int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_3(self, argc, argv); + return _wrap_GridFunction_GetVectorValues__SWIG_1(self, argc, argv); } } } } } } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetHessians__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetHessians'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetHessians(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; - int arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetVectorValues'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::GetVectorValues(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" + " mfem::GridFunction::GetVectorValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetFaceVectorValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + int arg3 ; + mfem::IntegrationRule *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + mfem::DenseMatrix *arg6 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"side", (char *)"ir", (char *)"vals", (char *)"tr", NULL + }; + int result; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:GridFunction_GetFaceVectorValues", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); } arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + try { + result = (int)((mfem::GridFunction const *)arg1)->GetFaceVectorValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::GridFunction *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"orig_func", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetValuesFrom", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6,arg7); + (arg1)->GetValuesFrom((mfem::GridFunction const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6691,76 +6335,140 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetBdrValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::GridFunction *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"orig_func", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetBdrValuesFrom", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + { + try { + (arg1)->GetBdrValuesFrom((mfem::GridFunction const &)*arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; int arg2 ; - int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + mfem::DenseMatrix *arg5 = 0 ; + int arg6 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"ir", (char *)"vals", (char *)"tr", (char *)"comp", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:GridFunction_GetVectorFieldValues", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } - arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); + } } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); + ((mfem::GridFunction const *)arg1)->GetVectorFieldValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6777,175 +6485,30 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceValues(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GridFunction_ReorderByNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetFaceValues", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetFaceValues__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetFaceValues__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetFaceValues'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetFaceValues(int,int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetFaceValues(int,int,mfem::IntegrationRule const &,mfem::Vector &,mfem::DenseMatrix &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ReorderByNodes" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); - } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - ((mfem::GridFunction const *)arg1)->GetVectorValues(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + (arg1)->ReorderByNodes(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6969,61 +6532,41 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::Vector *arg2 = 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetVectorValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetNodalValues(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7047,38 +6590,42 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[6] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorValues", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetNodalValues", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 4) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetVectorValues__SWIG_0(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_GetNodalValues__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_GridFunction_GetNodalValues__SWIG_1(self, argc, argv); + } } } } - if (argc == 5) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -7093,98 +6640,77 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorValues(PyObject *self, PyObject } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetVectorValues__SWIG_1(self, argc, argv); + if (argc <= 3) { + return _wrap_GridFunction_GetNodalValues__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } } + if (_v) { + return _wrap_GridFunction_GetNodalValues__SWIG_0(self, argc, argv); + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetVectorValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetNodalValues'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetVectorValues(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" - " mfem::GridFunction::GetVectorValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetNodalValues(int,mfem::Array< double > &,int) const\n" + " mfem::GridFunction::GetNodalValues(mfem::Vector &,int) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetFaceVectorValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldNodalValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; int arg3 ; - mfem::IntegrationRule *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - mfem::DenseMatrix *arg6 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - PyObject *swig_obj[6] ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"val", (char *)"comp", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetFaceVectorValues", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetVectorFieldNodalValues", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "4"" of type '" "mfem::IntegrationRule const &""'"); - } - arg4 = reinterpret_cast< mfem::IntegrationRule * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); + arg3 = PyArray_PyIntAsInt(obj2); } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetFaceVectorValues" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); - } - arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); { try { - result = (int)((mfem::GridFunction const *)arg1)->GetFaceVectorValues(arg2,arg3,(mfem::IntegrationRule const &)*arg4,*arg5,*arg6); + ((mfem::GridFunction const *)arg1)->GetVectorFieldNodalValues(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7201,40 +6727,54 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetFaceVectorValues(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::GridFunction *arg2 = 0 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vec_field", (char *)"comp", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetValuesFrom", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:GridFunction_ProjectVectorFieldOn", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->GetValuesFrom((mfem::GridFunction const &)*arg2); + (arg1)->ProjectVectorFieldOn(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7258,33 +6798,108 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetValuesFrom(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_GridFunction_GetBdrValuesFrom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetDerivative(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; + int arg2 ; + int arg3 ; + mfem::GridFunction *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"comp", (char *)"der_comp", (char *)"der", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GridFunction_GetDerivative", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDerivative" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); + { + try { + (arg1)->GetDerivative(arg2,arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetDivergence(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", NULL + }; + double result; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetBdrValuesFrom", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetDivergence", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDivergence" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetBdrValuesFrom" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); { try { - (arg1)->GetBdrValuesFrom((mfem::GridFunction const &)*arg2); + result = (double)((mfem::GridFunction const *)arg1)->GetDivergence(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7301,75 +6916,56 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetBdrValuesFrom(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; - int arg6 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", (char *)"curl", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetCurl", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetCurl" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetVectorFieldValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5,arg6); + ((mfem::GridFunction const *)arg1)->GetCurl(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7393,61 +6989,49 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_0(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::DenseMatrix *arg5 = 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", (char *)"grad", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetGradient", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldValues" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetVectorFieldValues(arg2,(mfem::IntegrationRule const &)*arg3,*arg4,*arg5); + ((mfem::GridFunction const *)arg1)->GetGradient(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7471,28 +7055,161 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; +SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorFieldValues", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + ((mfem::GridFunction const *)arg1)->GetGradients(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::IntegrationRule *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + } + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + { + try { + ((mfem::GridFunction const *)arg1)->GetGradients(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_GetGradients(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetGradients", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -7501,18 +7218,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetVectorFieldValues__SWIG_1(self, argc, argv); - } + return _wrap_GridFunction_GetGradients__SWIG_0(self, argc, argv); } } } } } - if (argc == 6) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -7534,22 +7246,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyO int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetVectorFieldValues__SWIG_0(self, argc, argv); - } - } + return _wrap_GridFunction_GetGradients__SWIG_1(self, argc, argv); } } } @@ -7557,31 +7254,57 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldValues(PyObject *self, PyO } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetVectorFieldValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetGradients'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetVectorFieldValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &,int) const\n" - " mfem::GridFunction::GetVectorFieldValues(int,mfem::IntegrationRule const &,mfem::DenseMatrix &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::GetGradients(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" + " mfem::GridFunction::GetGradients(int const,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ReorderByNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_GetVectorGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::ElementTransformation *arg2 = 0 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tr", (char *)"grad", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_GetVectorGradient", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ReorderByNodes" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + } + arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->ReorderByNodes(); + ((mfem::GridFunction const *)arg1)->GetVectorGradient(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7605,39 +7328,37 @@ SWIGINTERN PyObject *_wrap_GridFunction_ReorderByNodes(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_GetElementAverages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; - int arg3 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"avgs", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_GetElementAverages", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetElementAverages" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->GetNodalValues(*arg2,arg3); + ((mfem::GridFunction const *)arg1)->GetElementAverages(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7661,32 +7382,61 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + mfem::Vector *arg5 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); + } + arg5 = reinterpret_cast< mfem::Vector * >(argp5); { try { - ((mfem::GridFunction const *)arg1)->GetNodalValues(*arg2); + (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,(mfem::Vector const &)*arg4,(mfem::Vector const &)*arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7710,53 +7460,91 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues__SWIG_3(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; + double arg4 = (double) 0.0 ; + double arg5 = (double) mfem::infinity() ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } + { + try { + (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetNodalValues", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ImposeBounds", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -7771,16 +7559,39 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues(PyObject *self, PyObject } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_1(self, argc, argv); + if (argc <= 3) { + return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); + } + { + if (PyFloat_Check(argv[3])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); + } + { + if (PyFloat_Check(argv[4])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); + } + } } } } } - if (argc == 4) { + if (argc == 5) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -7795,20 +7606,17 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues(PyObject *self, PyObject } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_GetNodalValues__SWIG_0(self, argc, argv); + int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ImposeBounds__SWIG_0(self, argc, argv); + } } } } @@ -7816,50 +7624,45 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetNodalValues(PyObject *self, PyObject } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetNodalValues'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ImposeBounds'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetNodalValues(int,mfem::Array< double > &,int) const\n" - " mfem::GridFunction::GetNodalValues(int,mfem::Array< double > &) const\n" - " mfem::GridFunction::GetNodalValues(mfem::Vector &,int) const\n" - " mfem::GridFunction::GetNodalValues(mfem::Vector &) const\n"); + " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,mfem::Vector const &,mfem::Vector const &)\n" + " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,double,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldNodalValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Vector *arg2 = 0 ; - int arg3 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"src", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorFieldNodalValues", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_ProjectGridFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectGridFunction" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorFieldNodalValues" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->GetVectorFieldNodalValues(*arg2,arg3); + (arg1)->ProjectGridFunction((mfem::GridFunction const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7883,39 +7686,32 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorFieldNodalValues(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; - int arg3 ; + mfem::Coefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - (arg1)->ProjectVectorFieldOn(*arg2,arg3); + (arg1)->ProjectCoefficient(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7939,32 +7735,52 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_0(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectVectorFieldOn" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - (arg1)->ProjectVectorFieldOn(*arg2); + (arg1)->ProjectCoefficient(*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7988,154 +7804,32 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn__SWIG_1(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectVectorFieldOn(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectVectorFieldOn", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectVectorFieldOn__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_ProjectVectorFieldOn__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectVectorFieldOn'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectVectorFieldOn(mfem::GridFunction &,int)\n" - " mfem::GridFunction::ProjectVectorFieldOn(mfem::GridFunction &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetDerivative(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - int arg3 ; - mfem::GridFunction *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetDerivative", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDerivative" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDerivative" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - { - try { - (arg1)->GetDerivative(arg2,arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetDivergence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; - double result; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetDivergence", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetDivergence" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetDivergence" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - result = (double)((mfem::GridFunction const *)arg1)->GetDivergence(*arg2); + (arg1)->ProjectCoefficient(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8152,51 +7846,50 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetDivergence(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_GetCurl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetCurl", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetCurl" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetCurl" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->GetCurl(*arg2,*arg3); + (arg1)->ProjectCoefficient(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8220,44 +7913,29 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetCurl(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_GridFunction_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Coefficient **arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetGradient", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); - } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradient" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); { try { - ((mfem::GridFunction const *)arg1)->GetGradient(*arg2,*arg3); + (arg1)->ProjectCoefficient(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8281,198 +7959,102 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetGradient(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; +SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectCoefficient", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_0(self, argc, argv); + } + } } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_2(self, argc, argv); + } + } } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_4(self, argc, argv); + } + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->GetGradients(*arg2,(mfem::IntegrationRule const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetGradients__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::IntegrationRule *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetGradients" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "3"" of type '" "mfem::IntegrationRule const &""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetGradients" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->GetGradients(arg2,(mfem::IntegrationRule const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_GetGradients(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_GetGradients", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ElementTransformation, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_GetGradients__SWIG_0(self, argc, argv); - } + return _wrap_GridFunction_ProjectCoefficient__SWIG_3(self, argc, argv); } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__IntegrationRule, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + if (argc <= 3) { + return _wrap_GridFunction_ProjectCoefficient__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_GridFunction_GetGradients__SWIG_1(self, argc, argv); + return _wrap_GridFunction_ProjectCoefficient__SWIG_1(self, argc, argv); } } } @@ -8480,52 +8062,43 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetGradients(PyObject *self, PyObject *a } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_GetGradients'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectCoefficient'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::GetGradients(mfem::ElementTransformation &,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n" - " mfem::GridFunction::GetGradients(int const,mfem::IntegrationRule const &,mfem::DenseMatrix &) const\n"); + " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &,int)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" + " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient *[])\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_GetVectorGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::ElementTransformation *arg2 = 0 ; - mfem::DenseMatrix *arg3 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetVectorGradient", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetVectorGradient" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); - } - arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetVectorGradient" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - ((mfem::GridFunction const *)arg1)->GetVectorGradient(*arg2,*arg3); + (arg1)->ProjectDiscCoefficient(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8549,33 +8122,40 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetVectorGradient(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_GridFunction_GetElementAverages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; + mfem::Coefficient *arg2 = 0 ; + mfem::GridFunction::AvgType arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + int val3 ; + int ecode3 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_GetElementAverages", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_GetElementAverages" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_GetElementAverages" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); + } + arg3 = static_cast< mfem::GridFunction::AvgType >(val3); { try { - ((mfem::GridFunction const *)arg1)->GetElementAverages(*arg2); + (arg1)->ProjectDiscCoefficient(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8599,61 +8179,40 @@ SWIGINTERN PyObject *_wrap_GridFunction_GetElementAverages(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::GridFunction::AvgType arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "mfem::Vector const &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "mfem::Vector const &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); + } + arg3 = static_cast< mfem::GridFunction::AvgType >(val3); { try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,(mfem::Vector const &)*arg4,(mfem::Vector const &)*arg5); + (arg1)->ProjectDiscCoefficient(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8677,55 +8236,116 @@ SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectDiscCoefficient", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectDiscCoefficient'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &)\n" + " mfem::GridFunction::ProjectDiscCoefficient(mfem::Coefficient &,mfem::GridFunction::AvgType)\n" + " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &,mfem::GridFunction::AvgType)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - double arg5 ; + mfem::Coefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ImposeBounds" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,arg4,arg5); + (arg1)->ProjectBdrCoefficient(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8749,47 +8369,43 @@ SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ImposeBounds" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3,arg4); + (arg1)->ProjectBdrCoefficient(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8813,39 +8429,40 @@ SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_2(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; + mfem::Coefficient **arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ImposeBounds" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ImposeBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ImposeBounds(arg2,(mfem::Vector const &)*arg3); + (arg1)->ProjectBdrCoefficient(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8869,13 +8486,13 @@ SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds__SWIG_3(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[6] = { + PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ImposeBounds", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficient", 0, 3, argv))) SWIG_fail; --argc; if (argc == 3) { int _v; @@ -8883,215 +8500,111 @@ SWIGINTERN PyObject *_wrap_GridFunction_ImposeBounds(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_3(self, argc, argv); + return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(self, argc, argv); } } } } - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_2(self, argc, argv); - } + return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(self, argc, argv); } } } } - if (argc == 5) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[4], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if (PyFloat_Check(argv[3])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[4])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_GridFunction_ImposeBounds__SWIG_1(self, argc, argv); - } - } + return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ImposeBounds'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectBdrCoefficient'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,mfem::Vector const &,mfem::Vector const &)\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,double,double)\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &,double)\n" - " mfem::GridFunction::ImposeBounds(int,mfem::Vector const &)\n"); + " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient &,mfem::Array< int > &)\n" + " mfem::GridFunction::ProjectBdrCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" + " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient *[],mfem::Array< int > &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::GridFunction *arg2 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vcoeff", (char *)"bdr_attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ProjectGridFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_ProjectBdrCoefficientNormal", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectGridFunction" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectGridFunction" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - (arg1)->ProjectGridFunction((mfem::GridFunction const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectCoefficient(*arg2); + (arg1)->ProjectBdrCoefficientNormal(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9115,50 +8628,49 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_0(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientTangent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; - int arg4 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vcoeff", (char *)"bdr_attr", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_ProjectBdrCoefficientTangent", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } { try { - (arg1)->ProjectCoefficient(*arg2,*arg3,arg4); + (arg1)->ProjectBdrCoefficientTangent(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9182,43 +8694,55 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectCoefficient(*arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9235,39 +8759,59 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_2(PyObject *SWI SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; + mfem::Coefficient **arg2 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - (arg1)->ProjectCoefficient(*arg2); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(arg2,(mfem::IntegrationRule const *(*))arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9284,50 +8828,72 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_3(PyObject *SWI SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; + mfem::Array< int > *arg4 = (mfem::Array< int > *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeL2Error" "', argument " "4"" of type '" "mfem::Array< int > *""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectCoefficient(*arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9344,68 +8910,22 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_4(PyObject *SWI SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - try { - (arg1)->ProjectCoefficient(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectCoefficient", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL2Error", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -9415,100 +8935,65 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient(PyObject *self, PyObj int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL2Error__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_4(self, argc, argv); + return _wrap_GridFunction_ComputeL2Error__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL2Error__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_2(self, argc, argv); + return _wrap_GridFunction_ComputeL2Error__SWIG_1(self, argc, argv); } } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (argc <= 3) { + return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectCoefficient__SWIG_1(self, argc, argv); + return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); } } } @@ -9516,44 +9001,79 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectCoefficient(PyObject *self, PyObj } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectCoefficient'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL2Error'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &,int)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectCoefficient(mfem::Coefficient *[])\n"); + " mfem::GridFunction::ComputeL2Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeL2Error(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[],mfem::Array< int > *) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeH1Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; + mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; + mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; + double arg5 ; + int arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"exsol", (char *)"exgrad", (char *)"ell_coef", (char *)"Nu", (char *)"norm_type", NULL + }; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:GridFunction_ComputeH1Error", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeH1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeH1Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeH1Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); + } + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeH1Error" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ComputeH1Error" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - (arg1)->ProjectDiscCoefficient(*arg2); + result = (double)((mfem::GridFunction const *)arg1)->ComputeH1Error(arg2,arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9570,47 +9090,62 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction::AvgType arg3 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); - } - arg3 = static_cast< mfem::GridFunction::AvgType >(val3); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } { try { - (arg1)->ProjectDiscCoefficient(*arg2,arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9627,47 +9162,59 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction::AvgType arg3 ; + mfem::Coefficient **arg2 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridFunction_ProjectDiscCoefficient" "', argument " "3"" of type '" "mfem::GridFunction::AvgType""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); } - arg3 = static_cast< mfem::GridFunction::AvgType >(val3); + arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } { try { - (arg1)->ProjectDiscCoefficient(*arg2,arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(arg2,(mfem::IntegrationRule const *(*))arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9684,56 +9231,138 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectDiscCoefficient", 0, 3, argv))) SWIG_fail; +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double result; + + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + } + arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } + { + try { + result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeMaxError", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_1(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_ComputeMaxError__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeMaxError__SWIG_0(self, argc, argv); + } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_GridFunction_ComputeMaxError__SWIG_1(self, argc, argv); + } { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); + _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_2(self, argc, argv); + return _wrap_GridFunction_ComputeMaxError__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -9743,64 +9372,78 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectDiscCoefficient(PyObject *self, P int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_GridFunction_ComputeMaxError__SWIG_2(self, argc, argv); + } { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); + _v = PyList_Check(argv[2]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ProjectDiscCoefficient__SWIG_3(self, argc, argv); + return _wrap_GridFunction_ComputeMaxError__SWIG_2(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectDiscCoefficient'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeMaxError'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &)\n" - " mfem::GridFunction::ProjectDiscCoefficient(mfem::Coefficient &,mfem::GridFunction::AvgType)\n" - " mfem::GridFunction::ProjectDiscCoefficient(mfem::VectorCoefficient &,mfem::GridFunction::AvgType)\n"); + " mfem::GridFunction::ComputeMaxError(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeMaxError(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeMaxError(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficient(*arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9817,50 +9460,93 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(PyObject * SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; + mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; + int arg4 ; + mfem::Array< int > *arg5 = (mfem::Array< int > *) NULL ; + mfem::IntegrationRule **arg6 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"exsol", (char *)"exgrad", (char *)"norm_type", (char *)"elems", (char *)"irs", NULL + }; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OO:GridFunction_ComputeW11Error", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeW11Error" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + } + if (obj5) { + { + if (PyList_Check(obj5)) { + int size = PyList_Size(obj5); + int i = 0; + arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(obj5,i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg6[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficient(*arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9877,47 +9563,62 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(PyObject * SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - mfem::Array< int > *arg3 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + mfem::IntegrationRule **arg3 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficient" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); + if (swig_obj[2]) { + { + if (PyList_Check(swig_obj[2])) { + int size = PyList_Size(swig_obj[2]); + int i = 0; + arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[2],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg3[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficient(arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9934,22 +9635,22 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(PyObject * SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficient", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL1Error", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -9959,16 +9660,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient(PyObject *self, Py int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL1Error__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; + } if (_v) { - return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_0(self, argc, argv); + return _wrap_GridFunction_ComputeL1Error__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -9978,83 +9682,95 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficient(PyObject *self, Py int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_1(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_ComputeL1Error__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[2]) ? 1 : 0; } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ProjectBdrCoefficient__SWIG_2(self, argc, argv); + return _wrap_GridFunction_ComputeL1Error__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ProjectBdrCoefficient'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL1Error'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectBdrCoefficient(mfem::VectorCoefficient &,mfem::Array< int > &)\n" - " mfem::GridFunction::ProjectBdrCoefficient(mfem::Coefficient *[],mfem::Array< int > &)\n"); + " mfem::GridFunction::ComputeL1Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeL1Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientNormal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + double arg2 ; + mfem::Coefficient *arg3 = 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; + mfem::IntegrationRule **arg5 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; + double result; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficientNormal", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientNormal" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); + } + if (swig_obj[4]) { + { + if (PyList_Check(swig_obj[4])) { + int size = PyList_Size(swig_obj[4]); + int i = 0; + arg5 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[4],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg5[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficientNormal(*arg2,*arg3); + result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,(mfem::IntegrationRule const *(*))arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10071,51 +9787,90 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientNormal(PyObject *SW SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientTangent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + double arg2 ; + mfem::Coefficient *arg3 = 0 ; + mfem::GridFunction *arg4 = 0 ; + mfem::Coefficient *arg5 = (mfem::Coefficient *) NULL ; + mfem::IntegrationRule **arg6 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ProjectBdrCoefficientTangent", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ProjectBdrCoefficientTangent" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); + } + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); + } + arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); + if (swig_obj[4]) { + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); + } + arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); + } + if (swig_obj[5]) { + { + if (PyList_Check(swig_obj[5])) { + int size = PyList_Size(swig_obj[5]); + int i = 0; + arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[5],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg6[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ProjectBdrCoefficientTangent(*arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,(mfem::IntegrationRule const *(*))arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10139,53 +9894,65 @@ SWIGINTERN PyObject *_wrap_GridFunction_ProjectBdrCoefficientTangent(PyObject *S } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10202,40 +9969,72 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_0(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::Coefficient *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2); + ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10252,57 +10051,72 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_1(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - mfem::IntegrationRule **arg3 ; + mfem::Coefficient *arg2 = 0 ; + mfem::GridFunction *arg3 = 0 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double result; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + } + arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + } + arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); } - arg3[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; } } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(arg2,(mfem::IntegrationRule const *(*))arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10319,37 +10133,90 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_2(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; + double arg2 ; + mfem::VectorCoefficient *arg3 = 0 ; + mfem::Coefficient *arg4 = (mfem::Coefficient *) NULL ; + mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) NULL ; + mfem::IntegrationRule **arg6 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); + } + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); + } + arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); + } + if (swig_obj[4]) { + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); + } + arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); + } + if (swig_obj[5]) { + { + if (PyList_Check(swig_obj[5])) { + int size = PyList_Size(swig_obj[5]); + int i = 0; + arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[5],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg6[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } + } { try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(arg2); + result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10373,3394 +10240,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_3(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - mfem::Array< int > *arg4 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeL2Error" "', argument " "4"" of type '" "mfem::Array< int > *""'"); - } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2,(mfem::IntegrationRule const *(*))arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL2Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL2Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL2Error(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL2Error(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL2Error", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL2Error__SWIG_4(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL2Error'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::Coefficient *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[],mfem::Array< int > *) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL2Error(mfem::VectorCoefficient &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeH1Error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - double arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - PyObject *swig_obj[6] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "GridFunction_ComputeH1Error", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeH1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeH1Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeH1Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeH1Error" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridFunction_ComputeH1Error" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeH1Error(arg2,arg3,arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(arg2,(mfem::IntegrationRule const *(*))arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient **arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::Coefficient *[]""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient ** >(argp2); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2,(mfem::IntegrationRule const *(*))arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeMaxError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeMaxError" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeMaxError(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeMaxError(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeMaxError", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeMaxError__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeMaxError'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient *[],mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::Coefficient *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeMaxError(mfem::VectorCoefficient &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; - int arg4 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - mfem::IntegrationRule **arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeW11Error" "', argument " "5"" of type '" "mfem::Array< int > *""'"); - } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if (PyList_Check(swig_obj[5])) { - int size = PyList_Size(swig_obj[5]); - int i = 0; - arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[5],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg6[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; - int arg4 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeW11Error" "', argument " "5"" of type '" "mfem::Array< int > *""'"); - } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg3 = (mfem::VectorCoefficient *) 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeW11Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeW11Error" "', argument " "2"" of type '" "mfem::Coefficient *""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeW11Error" "', argument " "3"" of type '" "mfem::VectorCoefficient *""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeW11Error(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeW11Error(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeW11Error", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_ComputeW11Error__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeW11Error__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[5]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeW11Error__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeW11Error'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeW11Error(mfem::Coefficient *,mfem::VectorCoefficient *,int,mfem::Array< int > *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeW11Error(mfem::Coefficient *,mfem::VectorCoefficient *,int,mfem::Array< int > *) const\n" - " mfem::GridFunction::ComputeW11Error(mfem::Coefficient *,mfem::VectorCoefficient *,int) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::IntegrationRule **arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - if (PyList_Check(swig_obj[2])) { - int size = PyList_Size(swig_obj[2]); - int i = 0; - arg3 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[2],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg3[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2,(mfem::IntegrationRule const *(*))arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeL1Error" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeL1Error" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeL1Error(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeL1Error(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeL1Error", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeL1Error__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeL1Error'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeL1Error(mfem::Coefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL1Error(mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeL1Error(mfem::VectorCoefficient &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeL1Error(mfem::VectorCoefficient &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::IntegrationRule **arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - { - if (PyList_Check(swig_obj[4])) { - int size = PyList_Size(swig_obj[4]); - int i = 0; - arg5 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[4],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg5[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,(mfem::IntegrationRule const *(*))arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - mfem::IntegrationRule **arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - { - if (PyList_Check(swig_obj[5])) { - int size = PyList_Size(swig_obj[5]); - int i = 0; - arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[5],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg6[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,(mfem::IntegrationRule const *(*))arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::Coefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::Coefficient &""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::Coefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) 0 ; - mfem::IntegrationRule **arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); - } - arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); - { - if (PyList_Check(swig_obj[5])) { - int size = PyList_Size(swig_obj[5]); - int i = 0; - arg6 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[5],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg6[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,arg5,(mfem::IntegrationRule const *(*))arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg5 = (mfem::VectorCoefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeLpError" "', argument " "5"" of type '" "mfem::VectorCoefficient *""'"); - } - arg5 = reinterpret_cast< mfem::VectorCoefficient * >(argp5); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::Coefficient *arg4 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeLpError" "', argument " "4"" of type '" "mfem::Coefficient *""'"); - } - arg4 = reinterpret_cast< mfem::Coefficient * >(argp4); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeLpError" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeLpError" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeLpError" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - { - try { - result = (double)((mfem::GridFunction const *)arg1)->ComputeLpError(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeLpError", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_6(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_5(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[4]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_4(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[5]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeLpError__SWIG_3(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeLpError'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg6 = (mfem::VectorCoefficient *) 0 ; - mfem::IntegrationRule **arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "6"" of type '" "mfem::VectorCoefficient *""'"); - } - arg6 = reinterpret_cast< mfem::VectorCoefficient * >(argp6); - { - if (PyList_Check(swig_obj[6])) { - int size = PyList_Size(swig_obj[6]); - int i = 0; - arg7 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[6],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg7[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,arg6,(mfem::IntegrationRule const *(*))arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - mfem::VectorCoefficient *arg6 = (mfem::VectorCoefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "6"" of type '" "mfem::VectorCoefficient *""'"); - } - arg6 = reinterpret_cast< mfem::VectorCoefficient * >(argp6); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - mfem::Coefficient *arg5 = (mfem::Coefficient *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); - } - arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - double arg2 ; - mfem::VectorCoefficient *arg3 = 0 ; - mfem::GridFunction *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); - } - arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); - } - arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeLpError(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[8] = { + PyObject *argv[7] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementLpErrors", 0, 7, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeLpError", 0, 6, argv))) SWIG_fail; --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_6(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_5(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { + if ((argc >= 3) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -13778,98 +10266,28 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors(PyObject *self, P int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); - } + if (argc <= 3) { + return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[5]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); - } + if (argc <= 4) { + return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[4]) ? 1 : 0; } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); - _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_4(self, argc, argv); - } + return _wrap_GridFunction_ComputeLpError__SWIG_0(self, argc, argv); } } } } } } - if (argc == 7) { + if ((argc >= 3) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -13887,24 +10305,28 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors(PyObject *self, P int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); - _v = SWIG_CheckState(res); + if (argc <= 5) { + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[5]) ? 1 : 0; + } if (_v) { - { - _v = PyList_Check(argv[6]) ? 1 : 0; - } - if (_v) { - return _wrap_GridFunction_ComputeElementLpErrors__SWIG_3(self, argc, argv); - } + return _wrap_GridFunction_ComputeLpError__SWIG_1(self, argc, argv); } } } @@ -13914,136 +10336,101 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors(PyObject *self, P } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementLpErrors'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeLpError'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::VectorCoefficient *) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *) const\n" - " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); + " mfem::GridFunction::ComputeLpError(double const,mfem::Coefficient &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeLpError(double const,mfem::VectorCoefficient &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; + double arg2 ; + mfem::VectorCoefficient *arg3 = 0 ; + mfem::GridFunction *arg4 = 0 ; + mfem::Coefficient *arg5 = (mfem::Coefficient *) NULL ; + mfem::VectorCoefficient *arg6 = (mfem::VectorCoefficient *) NULL ; + mfem::IntegrationRule **arg7 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + double val2 ; + int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; - } - arg4[i] = reinterpret_cast(temp); - } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "3"" of type '" "mfem::VectorCoefficient &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + arg3 = reinterpret_cast< mfem::VectorCoefficient * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "4"" of type '" "mfem::GridFunction &""'"); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + arg4 = reinterpret_cast< mfem::GridFunction * >(argp4); + if (swig_obj[4]) { + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "5"" of type '" "mfem::Coefficient *""'"); + } + arg5 = reinterpret_cast< mfem::Coefficient * >(argp5); } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + if (swig_obj[5]) { + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__VectorCoefficient, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "GridFunction_ComputeElementLpErrors" "', argument " "6"" of type '" "mfem::VectorCoefficient *""'"); + } + arg6 = reinterpret_cast< mfem::VectorCoefficient * >(argp6); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + if (swig_obj[6]) { + { + if (PyList_Check(swig_obj[6])) { + int size = PyList_Size(swig_obj[6]); + int i = 0; + arg7 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[6],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg7[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementLpErrors(arg2,*arg3,*arg4,arg5,arg6,(mfem::IntegrationRule const *(*))arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14067,95 +10454,105 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_3(PyObject } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementLpErrors(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[8] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL1Errors", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementLpErrors", 0, 7, argv))) SWIG_fail; --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { + if ((argc >= 4) && (argc <= 6)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_3(self, argc, argv); + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; } } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_2(self, argc, argv); + if (argc <= 4) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[5]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_0(self, argc, argv); + } + } } } } } } - if (argc == 4) { + if ((argc >= 4) && (argc <= 7)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - _v = PyList_Check(argv[3]) ? 1 : 0; - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeElementL1Errors__SWIG_0(self, argc, argv); + if (argc <= 4) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 5) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 6) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[6]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementLpErrors__SWIG_1(self, argc, argv); + } + } + } } } } @@ -14163,22 +10560,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors(PyObject *self, P } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL1Errors'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementLpErrors'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL1Errors(mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); + " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::Coefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementLpErrors(double const,mfem::VectorCoefficient &,mfem::GridFunction &,mfem::Coefficient *,mfem::VectorCoefficient *,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -14186,110 +10581,52 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_2(PyObject void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL1Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); } - arg4[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementL1Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14313,15 +10650,15 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_3(PyObject } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL1Errors(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL2Errors", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL1Errors", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 3) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -14335,73 +10672,41 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors(PyObject *self, P int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_0(self, argc, argv); + } { _v = PyList_Check(argv[3]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_2(self, argc, argv); + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_0(self, argc, argv); } } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_1(self, argc, argv); + } { _v = PyList_Check(argv[3]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ComputeElementL2Errors__SWIG_0(self, argc, argv); + return _wrap_GridFunction_ComputeElementL1Errors__SWIG_1(self, argc, argv); } } } @@ -14409,22 +10714,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors(PyObject *self, P } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL2Errors'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL1Errors'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementL2Errors(mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); + " mfem::GridFunction::ComputeElementL1Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementL1Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::VectorCoefficient *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - mfem::IntegrationRule **arg4 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -14432,110 +10735,52 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_2(PyObject void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementL2Errors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - { - if (PyList_Check(swig_obj[3])) { - int size = PyList_Size(swig_obj[3]); - int i = 0; - arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); - for (i = 0; i < size; i++) { - PyObject *o = PyList_GetItem(swig_obj[3],i); - void *temp; - if (SWIG_ConvertPtr(o, &temp, - SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ - return NULL; + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); } - arg4[i] = reinterpret_cast(temp); + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; } - } else { - PyErr_SetString(PyExc_TypeError,"not a list"); - return NULL; - } - } - { - try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); { try { - ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3); + ((mfem::GridFunction const *)arg1)->ComputeElementL2Errors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14559,95 +10804,63 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_3(PyObject } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementL2Errors(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[5] = { 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementMaxErrors", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementL2Errors", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_0(self, argc, argv); + } { _v = PyList_Check(argv[3]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_2(self, argc, argv); + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_0(self, argc, argv); } } } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_1(self, argc, argv); + } { _v = PyList_Check(argv[3]) ? 1 : 0; } if (_v) { - return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(self, argc, argv); + return _wrap_GridFunction_ComputeElementL2Errors__SWIG_1(self, argc, argv); } } } @@ -14655,68 +10868,73 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors(PyObject *self, } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementMaxErrors'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementL2Errors'.\n" " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::Coefficient &,mfem::GridFunction &) const\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" - " mfem::GridFunction::ComputeElementMaxErrors(mfem::VectorCoefficient &,mfem::GridFunction &) const\n"); + " mfem::GridFunction::ComputeElementL2Errors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementL2Errors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::BilinearFormIntegrator *arg2 = 0 ; + mfem::VectorCoefficient *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; - bool arg4 ; - int arg5 ; + mfem::IntegrationRule **arg4 = (mfem::IntegrationRule **) (mfem::IntegrationRule **)NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::GridFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeElementMaxErrors" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[3]) { + { + if (PyList_Check(swig_obj[3])) { + int size = PyList_Size(swig_obj[3]); + int i = 0; + arg4 = (mfem::IntegrationRule **) malloc((size)*sizeof(mfem::IntegrationRule *)); + for (i = 0; i < size; i++) { + PyObject *o = PyList_GetItem(swig_obj[3],i); + void *temp; + if (SWIG_ConvertPtr(o, &temp, + SWIGTYPE_p_mfem__IntegrationRule,SWIG_POINTER_EXCEPTION) == -1){ + return NULL; + } + arg4[i] = reinterpret_cast(temp); + } + } else { + PyErr_SetString(PyExc_TypeError,"not a list"); + return NULL; + } + } } { try { - (arg1)->ComputeFlux(*arg2,*arg3,arg4,arg5); + ((mfem::GridFunction const *)arg1)->ComputeElementMaxErrors(*arg2,*arg3,(mfem::IntegrationRule const *(*))arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14740,93 +10958,109 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - mfem::BilinearFormIntegrator *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - bool val4 ; - int ecode4 = 0 ; +SWIGINTERN PyObject *_wrap_GridFunction_ComputeElementMaxErrors(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - (arg1)->ComputeFlux(*arg2,*arg3,arg4); + if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeElementMaxErrors", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_0(self, argc, argv); + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if ((argc >= 3) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(self, argc, argv); + } + { + _v = PyList_Check(argv[3]) ? 1 : 0; + } + if (_v) { + return _wrap_GridFunction_ComputeElementMaxErrors__SWIG_1(self, argc, argv); + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeElementMaxErrors'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GridFunction::ComputeElementMaxErrors(mfem::Coefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n" + " mfem::GridFunction::ComputeElementMaxErrors(mfem::VectorCoefficient &,mfem::GridFunction &,mfem::IntegrationRule const *[]) const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::BilinearFormIntegrator *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; + bool arg4 = (bool) true ; + int arg5 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blfi", (char *)"flux", (char *)"wcoef", (char *)"subdomain", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:GridFunction_ComputeFlux", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_ComputeFlux" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -14834,7 +11068,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_2(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg2 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } @@ -14842,9 +11076,24 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_2(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GridFunction_ComputeFlux" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "GridFunction_ComputeFlux" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } + } { try { - (arg1)->ComputeFlux(*arg2,*arg3); + (arg1)->ComputeFlux(*arg2,*arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14863,106 +11112,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux__SWIG_2(PyObject *SWIGUNUSED } resultobj = SWIG_Py_Void(); return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_ComputeFlux(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_ComputeFlux", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GridFunction_ComputeFlux__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GridFunction_ComputeFlux__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_ComputeFlux__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_ComputeFlux'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool,int)\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &,bool)\n" - " mfem::GridFunction::ComputeFlux(mfem::BilinearFormIntegrator &,mfem::GridFunction &)\n"); - return 0; +fail: + return NULL; } @@ -15280,7 +11431,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_FESpace(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -15288,15 +11439,19 @@ SWIGINTERN PyObject *_wrap_GridFunction_SetSpace(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SetSpace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_SetSpace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SetSpace" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SetSpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -15934,7 +12089,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; std::ostream *arg2 = 0 ; @@ -15946,16 +12101,22 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), std::ofstream out2 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", (char *)"field_name", (char *)"ref", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SaveVTK", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GridFunction_SaveVTK", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveVTK" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } @@ -15969,7 +12130,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), arg2 = &out2; } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_std__string, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_std__string, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridFunction_SaveVTK" "', argument " "3"" of type '" "std::string const &""'"); } @@ -15978,10 +12139,10 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), } arg3 = reinterpret_cast< std::string * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -16019,24 +12180,30 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveVTK(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; std::ostream *arg2 = 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", (char *)"TimesToRefine", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:GridFunction_SaveSTL", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveSTL" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } @@ -16050,81 +12217,17 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL__SWIG_0(PyObject *SWIGUNUSEDPARM arg2 = &out2; } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->SaveSTL(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveSTL" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } { try { - (arg1)->SaveSTL(*arg2); + (arg1)->SaveSTL(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16158,74 +12261,6 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GridFunction_SaveSTL(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_SaveSTL", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_SaveSTL__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_SaveSTL__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_SaveSTL'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GridFunction::SaveSTL(std::ostream &,int)\n" - " mfem::GridFunction::SaveSTL(std::ostream &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_GridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; @@ -16505,7 +12540,7 @@ SWIGINTERN PyObject *_wrap_new_GridFunction(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_GridFunction_SaveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_SaveToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; char *arg2 = (char *) 0 ; @@ -16515,24 +12550,29 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveToFile(PyObject *SWIGUNUSEDPARM(self int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf_file", (char *)"precision", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_SaveToFile", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GridFunction_SaveToFile", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_SaveToFile" "', argument " "1"" of type '" "mfem::GridFunction const *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_SaveToFile" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -16562,7 +12602,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_SaveToFile(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_GridFunction_iadd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_iadd(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; mfem::GridFunction *arg2 = 0 ; @@ -16570,16 +12610,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_iadd(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::GridFunction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_iadd", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_iadd", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_iadd" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_iadd" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } @@ -16760,7 +12804,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_isub(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_GridFunction_imul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_imul(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; double arg2 ; @@ -16768,16 +12812,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_imul(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::GridFunction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_imul", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_imul", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_imul" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_imul" "', argument " "2"" of type '" "double""'"); } @@ -16808,7 +12856,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_imul(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_GridFunction_idiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GridFunction_idiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; double arg2 ; @@ -16816,16 +12864,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_idiv(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::GridFunction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "GridFunction_idiv", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GridFunction_idiv", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_idiv" "', argument " "1"" of type '" "mfem::GridFunction *""'"); } arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridFunction_idiv" "', argument " "2"" of type '" "double""'"); } @@ -16860,14 +12912,14 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(se PyObject *resultobj = 0; mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Save" "', argument " "1"" of type '" "mfem::GridFunction *""'"); @@ -16878,64 +12930,17 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_GridFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GridFunction_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GridFunction *arg1 = (mfem::GridFunction *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridFunction_Save" "', argument " "1"" of type '" "mfem::GridFunction *""'"); - } - arg1 = reinterpret_cast< mfem::GridFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridFunction_Save" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_GridFunction_Save__SWIG_1(arg1,(char const *)arg2); + mfem_GridFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16969,7 +12974,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "GridFunction_Save", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); @@ -16978,7 +12983,20 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_GridFunction_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_GridFunction_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GridFunction_Save__SWIG_1(self, argc, argv); + } } } } @@ -16997,31 +13015,8 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save(PyObject *self, PyObject *args) { _v = 1; } } - if (_v) { - return _wrap_GridFunction_Save__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GridFunction_Save__SWIG_1(self, argc, argv); - } + if (_v) { + return _wrap_GridFunction_Save__SWIG_0(self, argc, argv); } } } @@ -17030,8 +13025,7 @@ SWIGINTERN PyObject *_wrap_GridFunction_Save(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GridFunction_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::GridFunction::Save(std::ostream &) const\n" - " mfem::GridFunction::Save(char const *,int)\n" - " mfem::GridFunction::Save(char const *)\n"); + " mfem::GridFunction::Save(char const *,int)\n"); return 0; } @@ -17195,22 +13189,24 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_1(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; mfem::QuadratureFunction *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); } arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -17239,56 +13235,17 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_2(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::QuadratureFunction *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - { - try { - result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; double *arg2 = (double *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; mfem::QuadratureFunction *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); @@ -17299,62 +13256,17 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_4(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureFunction" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureSpace *arg1 = (mfem::QuadratureSpace *) 0 ; - double *arg2 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::QuadratureFunction *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureSpace *""'"); } - arg1 = reinterpret_cast< mfem::QuadratureSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_QuadratureFunction" "', argument " "2"" of type '" "double *""'"); - } - arg2 = reinterpret_cast< double * >(argp2); { try { - result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1,arg2); + result = (mfem::QuadratureFunction *)new mfem::QuadratureFunction(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17378,7 +13290,7 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_5(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_QuadratureFunction__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; std::istream *arg2 = 0 ; @@ -17447,35 +13359,15 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args return _wrap_new_QuadratureFunction__SWIG_1(self, argc, argv); } } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureFunction__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureFunction__SWIG_5(self, argc, argv); + if (argc <= 1) { + return _wrap_new_QuadratureFunction__SWIG_2(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -17489,21 +13381,7 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args } } } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_QuadratureFunction__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); @@ -17513,6 +13391,9 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_QuadratureFunction__SWIG_3(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -17522,11 +13403,25 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args } } if (_v) { - return _wrap_new_QuadratureFunction__SWIG_4(self, argc, argv); + return _wrap_new_QuadratureFunction__SWIG_3(self, argc, argv); } } } } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_QuadratureFunction__SWIG_4(self, argc, argv); + } + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_QuadratureFunction'.\n" @@ -17534,9 +13429,7 @@ SWIGINTERN PyObject *_wrap_new_QuadratureFunction(PyObject *self, PyObject *args " mfem::QuadratureFunction::QuadratureFunction()\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureFunction const &)\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *,int)\n" - " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *)\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *,double *,int)\n" - " mfem::QuadratureFunction::QuadratureFunction(mfem::QuadratureSpace *,double *)\n" " mfem::QuadratureFunction::QuadratureFunction(mfem::Mesh *,std::istream &)\n"); return 0; } @@ -17548,111 +13441,17 @@ SWIGINTERN PyObject *_wrap_delete_QuadratureFunction(PyObject *SWIGUNUSEDPARM(se void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::QuadratureSpace *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - try { - result = (mfem::QuadratureSpace *)((mfem::QuadratureFunction const *)arg1)->GetSpace(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_SetSpace" "', argument " "2"" of type '" "mfem::QuadratureSpace *""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_QuadratureFunction" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } + arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { try { - (arg1)->SetSpace(arg2,arg3); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17676,29 +13475,24 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_0(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyObject *swig_obj[1] ; + mfem::QuadratureSpace *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_SetSpace" "', argument " "2"" of type '" "mfem::QuadratureSpace *""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); { try { - (arg1)->SetSpace(arg2); + result = (mfem::QuadratureSpace *)((mfem::QuadratureFunction const *)arg1)->GetSpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17715,27 +13509,24 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_1(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__QuadratureSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; - double *arg3 = (double *) 0 ; - int arg4 ; + int arg3 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); @@ -17746,20 +13537,17 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_2(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_SetSpace" "', argument " "2"" of type '" "mfem::QuadratureSpace *""'"); } arg2 = reinterpret_cast< mfem::QuadratureSpace * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_SetSpace" "', argument " "3"" of type '" "double *""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { - (arg1)->SetSpace(arg2,arg3,arg4); + (arg1)->SetSpace(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17783,11 +13571,12 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_2(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; mfem::QuadratureSpace *arg2 = (mfem::QuadratureSpace *) 0 ; double *arg3 = (double *) 0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -17795,7 +13584,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_3(PyObject *SWIGUNU void *argp3 = 0 ; int res3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); @@ -17811,9 +13600,17 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace__SWIG_3(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_SetSpace" "', argument " "3"" of type '" "double *""'"); } arg3 = reinterpret_cast< double * >(argp3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } { try { - (arg1)->SetSpace(arg2,arg3); + (arg1)->SetSpace(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17845,21 +13642,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_SetSpace", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_SetSpace__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); @@ -17869,25 +13652,9 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_SetSpace__SWIG_3(self, argc, argv); + if (argc <= 2) { + return _wrap_QuadratureFunction_SetSpace__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__QuadratureSpace, 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -17902,7 +13669,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); @@ -17916,6 +13683,9 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_QuadratureFunction_SetSpace__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -17925,7 +13695,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject } } if (_v) { - return _wrap_QuadratureFunction_SetSpace__SWIG_2(self, argc, argv); + return _wrap_QuadratureFunction_SetSpace__SWIG_1(self, argc, argv); } } } @@ -17936,9 +13706,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetSpace(PyObject *self, PyObject SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_SetSpace'.\n" " Possible C/C++ prototypes are:\n" " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,int)\n" - " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *)\n" - " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,double *,int)\n" - " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,double *)\n"); + " mfem::QuadratureFunction::SetSpace(mfem::QuadratureSpace *,double *,int)\n"); return 0; } @@ -17984,25 +13752,29 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetVDim(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_SetVDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vdim_", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunction_SetVDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureFunction_SetVDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetVDim" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -18071,7 +13843,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_OwnsSpace(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_QuadratureFunction_SetOwnsSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_SetOwnsSpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; bool arg2 ; @@ -18079,181 +13851,26 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_SetOwnsSpace(PyObject *SWIGUNUSEDP int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"own", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunction_SetOwnsSpace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureFunction_SetOwnsSpace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_SetOwnsSpace" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunction_SetOwnsSpace" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetOwnsSpace(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::IntegrationRule *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunction_GetElementIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementIntRule" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::IntegrationRule *) &((mfem::QuadratureFunction const *)arg1)->GetElementIntRule(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - (arg1)->GetElementValues(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); - } - arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunction_SetOwnsSpace" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - ((mfem::QuadratureFunction const *)arg1)->GetElementValues(arg2,*arg3); + (arg1)->SetOwnsSpace(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18277,39 +13894,34 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; + mfem::IntegrationRule *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:QuadratureFunction_GetElementIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementIntRule" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - (arg1)->GetElementValues(arg2,*arg3); + result = (mfem::IntegrationRule *) &((mfem::QuadratureFunction const *)arg1)->GetElementIntRule(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18326,18 +13938,18 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_2(PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -18346,7 +13958,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { @@ -18355,17 +13967,17 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::QuadratureFunction const *)arg1)->GetElementValues(arg2,*arg3); + (arg1)->GetElementValues(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18389,155 +14001,39 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject } -SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_GetElementValues", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_QuadratureFunction_GetElementValues__SWIG_3(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_GetElementValues'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &)\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &) const\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &)\n" - " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - std::ostream *arg2 = 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::QuadratureFunction const *)arg1)->Save(*arg2); + ((mfem::QuadratureFunction const *)arg1)->GetElementValues(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18555,53 +14051,45 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_0(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - mfem_QuadratureFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); + (arg1)->GetElementValues(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18619,38 +14107,45 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_1(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; - char *arg2 = (char *) 0 ; + int arg2 ; + mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_GetElementValues" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_Save" "', argument " "2"" of type '" "char const *""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg2 = reinterpret_cast< char * >(buf2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QuadratureFunction_GetElementValues" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - mfem_QuadratureFunction_Save__SWIG_1(arg1,(char const *)arg2); + ((mfem::QuadratureFunction const *)arg1)->GetElementValues(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18668,44 +14163,52 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_2(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_GetElementValues(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_Save", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_GetElementValues", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_QuadratureFunction_Save__SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_QuadratureFunction_GetElementValues__SWIG_0(self, argc, argv); + } } } } - if (argc == 2) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); _v = SWIG_CheckState(res); if (_v) { { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); _v = 0; } else { @@ -18713,7 +14216,12 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *arg } } if (_v) { - return _wrap_QuadratureFunction_Save__SWIG_0(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_QuadratureFunction_GetElementValues__SWIG_1(self, argc, argv); + } } } } @@ -18723,245 +14231,93 @@ SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *arg int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_QuadratureFunction_Save__SWIG_1(self, argc, argv); + return _wrap_QuadratureFunction_GetElementValues__SWIG_2(self, argc, argv); } } } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_Save'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::QuadratureFunction::Save(std::ostream &) const\n" - " mfem::QuadratureFunction::Save(char const *,int)\n" - " mfem::QuadratureFunction::Save(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *QuadratureFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__QuadratureFunction, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *QuadratureFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - std::ostream *arg1 = 0 ; - mfem::QuadratureFunction *arg2 = 0 ; - PyMFEM::wFILE *temp1 = 0 ; - std::ofstream out1 ; - void *argp2 = 0 ; - int res2 = 0 ; - std::ostream *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp1->isSTDOUT() == 1) { - arg1 = &std::cout; - } - else { - out1.open(temp1->getFilename()); - out1.precision(temp1->getPrecision()); - arg1 = &out1; - } - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); - } - arg2 = reinterpret_cast< mfem::QuadratureFunction * >(argp2); - { - try { - result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::QuadratureFunction const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } - return resultobj; -fail: - { - if (temp1->isSTDOUT() != 1) { - out1.close(); - } - } - PyErr_Clear(); - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; -} - - -SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { + if (argc == 3) { int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); + _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap___lshift____SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - void *ptr; - if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); if (_v) { - return _wrap___lshift____SWIG_2(self, argc, argv); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_QuadratureFunction_GetElementValues__SWIG_3(self, argc, argv); + } } } } fail: - Py_INCREF(Py_NotImplemented); - return Py_NotImplemented; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_GetElementValues'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &)\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::Vector &) const\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &)\n" + " mfem::QuadratureFunction::GetElementValues(int,mfem::DenseMatrix &) const\n"); + return 0; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - int arg6 ; - bool arg7 ; + mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - bool val7 ; - int ecode7 = 0 ; - double result; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction const *""'"); } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ZZErrorEstimator" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7); + ((mfem::QuadratureFunction const *)arg1)->Save(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -18978,80 +14334,56 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - int arg6 ; + mfem::QuadratureFunction *arg1 = (mfem::QuadratureFunction *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunction_Save" "', argument " "1"" of type '" "mfem::QuadratureFunction *""'"); } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + arg1 = reinterpret_cast< mfem::QuadratureFunction * >(argp1); + res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QuadratureFunction_Save" "', argument " "2"" of type '" "char const *""'"); } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6); + mfem_QuadratureFunction_Save__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19068,73 +14400,127 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_1(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return resultobj; fail: + if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_QuadratureFunction_Save(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "QuadratureFunction_Save", 0, 3, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_QuadratureFunction_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_QuadratureFunction_Save__SWIG_1(self, argc, argv); + } + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__QuadratureFunction, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_QuadratureFunction_Save__SWIG_0(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QuadratureFunction_Save'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::QuadratureFunction::Save(std::ostream &) const\n" + " mfem::QuadratureFunction::Save(char const *,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *QuadratureFunction_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__QuadratureFunction, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *QuadratureFunction_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap___lshift____SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::BilinearFormIntegrator *arg1 = 0 ; - mfem::GridFunction *arg2 = 0 ; - mfem::GridFunction *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Array< int > *arg5 = (mfem::Array< int > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + std::ostream *arg1 = 0 ; + mfem::QuadratureFunction *arg2 = 0 ; + PyMFEM::wFILE *temp1 = 0 ; + std::ofstream out1 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - double result; + std::ostream *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); - } - arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + { + if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp1->isSTDOUT() == 1) { + arg1 = &std::cout; + } + else { + out1.open(temp1->getFilename()); + out1.precision(temp1->getPrecision()); + arg1 = &out1; + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__QuadratureFunction, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__lshift__" "', argument " "2"" of type '" "mfem::QuadratureFunction const &""'"); } - arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + arg2 = reinterpret_cast< mfem::QuadratureFunction * >(argp2); { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5); + result = (std::ostream *) &mfem::operator <<(*arg1,(mfem::QuadratureFunction const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19151,19 +14537,87 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_2(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 | 0 ); + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } return resultobj; fail: - return NULL; + { + if (temp1->isSTDOUT() != 1) { + out1.close(); + } + } + PyErr_Clear(); + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; +} + + +SWIGINTERN PyObject *_wrap___lshift__(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "__lshift__", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap___lshift____SWIG_1(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + { + void *ptr; + if (SWIG_ConvertPtr(argv[0], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__QuadratureFunction, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap___lshift____SWIG_2(self, argc, argv); + } + } + } + +fail: + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BilinearFormIntegrator *arg1 = 0 ; mfem::GridFunction *arg2 = 0 ; mfem::GridFunction *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + mfem::Array< int > *arg5 = (mfem::Array< int > *) NULL ; + int arg6 = (int) 1 ; + bool arg7 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -19172,10 +14626,24 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + bool val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"blfi", (char *)"u", (char *)"flux", (char *)"error_estimates", (char *)"aniso_flags", (char *)"with_subdomains", (char *)"with_coeff", NULL + }; double result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOO:ZZErrorEstimator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } @@ -19183,7 +14651,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "1"" of type '" "mfem::BilinearFormIntegrator &""'"); } arg1 = reinterpret_cast< mfem::BilinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } @@ -19191,7 +14659,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } @@ -19199,7 +14667,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -19207,9 +14675,31 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZZErrorEstimator" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ZZErrorEstimator" "', argument " "5"" of type '" "mfem::Array< int > *""'"); + } + arg5 = reinterpret_cast< mfem::Array< int > * >(argp5); + } + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); + } + } + if (obj6) { + ecode7 = SWIG_AsVal_bool(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ZZErrorEstimator" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); + } { try { - result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4); + result = (double)mfem::ZZErrorEstimator(*arg1,*arg2,*arg3,*arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -19233,164 +14723,7 @@ SWIGINTERN PyObject *_wrap_ZZErrorEstimator__SWIG_3(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ZZErrorEstimator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ZZErrorEstimator", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__BilinearFormIntegrator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_ZZErrorEstimator__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ZZErrorEstimator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int,bool)\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *,int)\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &,mfem::Array< int > *)\n" - " mfem::ZZErrorEstimator(mfem::BilinearFormIntegrator &,mfem::GridFunction &,mfem::GridFunction &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double arg1 ; int arg2 ; @@ -19402,22 +14735,28 @@ SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(sel int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"p", (char *)"i", (char *)"gf1", (char *)"gf2", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ComputeElementLpDistance", 4, 4, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ComputeElementLpDistance", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ComputeElementLpDistance" "', argument " "1"" of type '" "double""'"); } arg1 = static_cast< double >(val1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ComputeElementLpDistance" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } @@ -19425,7 +14764,7 @@ SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ComputeElementLpDistance" "', argument " "3"" of type '" "mfem::GridFunction &""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__GridFunction, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ComputeElementLpDistance" "', argument " "4"" of type '" "mfem::GridFunction &""'"); } @@ -19459,7 +14798,7 @@ SWIGINTERN PyObject *_wrap_ComputeElementLpDistance(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::Coefficient *arg2 = 0 ; @@ -19468,16 +14807,21 @@ SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"m", (char *)"s", (char *)"_n", NULL + }; mfem::ExtrudeCoefficient *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ExtrudeCoefficient", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_ExtrudeCoefficient", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ExtrudeCoefficient" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExtrudeCoefficient" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } @@ -19486,10 +14830,10 @@ SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self) } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -19517,7 +14861,7 @@ SWIGINTERN PyObject *_wrap_new_ExtrudeCoefficient(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ExtrudeCoefficient *arg1 = (mfem::ExtrudeCoefficient *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -19528,16 +14872,21 @@ SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"T", (char *)"ip", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "ExtrudeCoefficient_Eval", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ExtrudeCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ExtrudeCoefficient_Eval", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ExtrudeCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExtrudeCoefficient_Eval" "', argument " "1"" of type '" "mfem::ExtrudeCoefficient *""'"); } arg1 = reinterpret_cast< mfem::ExtrudeCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExtrudeCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -19545,7 +14894,7 @@ SWIGINTERN PyObject *_wrap_ExtrudeCoefficient_Eval(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ExtrudeCoefficient_Eval" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } arg2 = reinterpret_cast< mfem::ElementTransformation * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ExtrudeCoefficient_Eval" "', argument " "3"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -19630,7 +14979,7 @@ SWIGINTERN PyObject *ExtrudeCoefficient_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -19642,30 +14991,36 @@ SWIGINTERN PyObject *_wrap_Extrude1DGridFunction(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"mesh2d", (char *)"sol", (char *)"ny", NULL + }; mfem::GridFunction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Extrude1DGridFunction", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Extrude1DGridFunction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude1DGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Extrude1DGridFunction" "', argument " "2"" of type '" "mfem::Mesh *""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Extrude1DGridFunction" "', argument " "3"" of type '" "mfem::GridFunction *""'"); } arg3 = reinterpret_cast< mfem::GridFunction * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -19698,33 +15053,33 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, - { "GridFunction_MakeOwner", _wrap_GridFunction_MakeOwner, METH_VARARGS, "GridFunction_MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, + { "GridFunction_MakeOwner", (PyCFunction)(void(*)(void))_wrap_GridFunction_MakeOwner, METH_VARARGS|METH_KEYWORDS, "GridFunction_MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, { "GridFunction_OwnFEC", _wrap_GridFunction_OwnFEC, METH_O, "GridFunction_OwnFEC(GridFunction self) -> FiniteElementCollection"}, { "GridFunction_VectorDim", _wrap_GridFunction_VectorDim, METH_O, "GridFunction_VectorDim(GridFunction self) -> int"}, { "GridFunction_GetTrueVector", _wrap_GridFunction_GetTrueVector, METH_VARARGS, "\n" "GridFunction_GetTrueVector(GridFunction self) -> Vector\n" "GridFunction_GetTrueVector(GridFunction self) -> Vector\n" ""}, - { "GridFunction_GetTrueDofs", _wrap_GridFunction_GetTrueDofs, METH_VARARGS, "GridFunction_GetTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_GetTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetTrueDofs, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetTrueVector", _wrap_GridFunction_SetTrueVector, METH_O, "GridFunction_SetTrueVector(GridFunction self)"}, - { "GridFunction_SetFromTrueDofs", _wrap_GridFunction_SetFromTrueDofs, METH_VARARGS, "GridFunction_SetFromTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetFromTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetFromTrueDofs, METH_VARARGS|METH_KEYWORDS, "GridFunction_SetFromTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetFromTrueVector", _wrap_GridFunction_SetFromTrueVector, METH_O, "GridFunction_SetFromTrueVector(GridFunction self)"}, - { "GridFunction_GetValue", _wrap_GridFunction_GetValue, METH_VARARGS, "GridFunction_GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, - { "GridFunction_GetVectorValue", _wrap_GridFunction_GetVectorValue, METH_VARARGS, "GridFunction_GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, + { "GridFunction_GetValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValue, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, + { "GridFunction_GetVectorValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorValue, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, { "GridFunction_GetValues", _wrap_GridFunction_GetValues, METH_VARARGS, "\n" "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" "GridFunction_GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" @@ -19737,37 +15092,37 @@ static PyMethodDef SwigMethods[] = { "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" "GridFunction_GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" ""}, - { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GridFunction_GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, + { "GridFunction_GetFaceValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" "GridFunction_GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" "GridFunction_GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr)\n" ""}, - { "GridFunction_GetFaceVectorValues", _wrap_GridFunction_GetFaceVectorValues, METH_VARARGS, "GridFunction_GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, - { "GridFunction_GetValuesFrom", _wrap_GridFunction_GetValuesFrom, METH_VARARGS, "GridFunction_GetValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetBdrValuesFrom", _wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS, "GridFunction_GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetVectorFieldValues", _wrap_GridFunction_GetVectorFieldValues, METH_VARARGS, "GridFunction_GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, + { "GridFunction_GetFaceVectorValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceVectorValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, + { "GridFunction_GetValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValuesFrom, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetBdrValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetVectorFieldValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, { "GridFunction_ReorderByNodes", _wrap_GridFunction_ReorderByNodes, METH_O, "GridFunction_ReorderByNodes(GridFunction self)"}, { "GridFunction_GetNodalValues", _wrap_GridFunction_GetNodalValues, METH_VARARGS, "\n" "GridFunction_GetNodalValues(GridFunction self, int i, doubleArray nval, int vdim=1)\n" "GridFunction_GetNodalValues(GridFunction self, Vector nval, int vdim=1)\n" ""}, - { "GridFunction_GetVectorFieldNodalValues", _wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS, "GridFunction_GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, - { "GridFunction_ProjectVectorFieldOn", _wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS, "GridFunction_ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, - { "GridFunction_GetDerivative", _wrap_GridFunction_GetDerivative, METH_VARARGS, "GridFunction_GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, - { "GridFunction_GetDivergence", _wrap_GridFunction_GetDivergence, METH_VARARGS, "GridFunction_GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, - { "GridFunction_GetCurl", _wrap_GridFunction_GetCurl, METH_VARARGS, "GridFunction_GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, - { "GridFunction_GetGradient", _wrap_GridFunction_GetGradient, METH_VARARGS, "GridFunction_GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, + { "GridFunction_GetVectorFieldNodalValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, + { "GridFunction_ProjectVectorFieldOn", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, + { "GridFunction_GetDerivative", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDerivative, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, + { "GridFunction_GetDivergence", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDivergence, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, + { "GridFunction_GetCurl", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetCurl, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, + { "GridFunction_GetGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetGradient, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, { "GridFunction_GetGradients", _wrap_GridFunction_GetGradients, METH_VARARGS, "\n" "GridFunction_GetGradients(GridFunction self, ElementTransformation tr, IntegrationRule ir, DenseMatrix grad)\n" "GridFunction_GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad)\n" ""}, - { "GridFunction_GetVectorGradient", _wrap_GridFunction_GetVectorGradient, METH_VARARGS, "GridFunction_GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, - { "GridFunction_GetElementAverages", _wrap_GridFunction_GetElementAverages, METH_VARARGS, "GridFunction_GetElementAverages(GridFunction self, GridFunction avgs)"}, + { "GridFunction_GetVectorGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorGradient, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, + { "GridFunction_GetElementAverages", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetElementAverages, METH_VARARGS|METH_KEYWORDS, "GridFunction_GetElementAverages(GridFunction self, GridFunction avgs)"}, { "GridFunction_ImposeBounds", _wrap_GridFunction_ImposeBounds, METH_VARARGS, "\n" "GridFunction_ImposeBounds(GridFunction self, int i, Vector weights, Vector _lo, Vector _hi)\n" "GridFunction_ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity())\n" ""}, - { "GridFunction_ProjectGridFunction", _wrap_GridFunction_ProjectGridFunction, METH_VARARGS, "GridFunction_ProjectGridFunction(GridFunction self, GridFunction src)"}, + { "GridFunction_ProjectGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectGridFunction, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectGridFunction(GridFunction self, GridFunction src)"}, { "GridFunction_ProjectCoefficient", _wrap_GridFunction_ProjectCoefficient, METH_VARARGS, "\n" "GridFunction_ProjectCoefficient(GridFunction self, Coefficient coeff)\n" "GridFunction_ProjectCoefficient(GridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" @@ -19785,20 +15140,20 @@ static PyMethodDef SwigMethods[] = { "GridFunction_ProjectBdrCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray attr)\n" "GridFunction_ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" ""}, - { "GridFunction_ProjectBdrCoefficientNormal", _wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS, "GridFunction_ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, - { "GridFunction_ProjectBdrCoefficientTangent", _wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "GridFunction_ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientNormal", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientTangent", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS|METH_KEYWORDS, "GridFunction_ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, { "GridFunction_ComputeL2Error", _wrap_GridFunction_ComputeL2Error, METH_VARARGS, "\n" "GridFunction_ComputeL2Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeL2Error(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double\n" ""}, - { "GridFunction_ComputeH1Error", _wrap_GridFunction_ComputeH1Error, METH_VARARGS, "GridFunction_ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, + { "GridFunction_ComputeH1Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeH1Error, METH_VARARGS|METH_KEYWORDS, "GridFunction_ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, { "GridFunction_ComputeMaxError", _wrap_GridFunction_ComputeMaxError, METH_VARARGS, "\n" "GridFunction_ComputeMaxError(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeMaxError(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" ""}, - { "GridFunction_ComputeW11Error", _wrap_GridFunction_ComputeW11Error, METH_VARARGS, "GridFunction_ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, + { "GridFunction_ComputeW11Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeW11Error, METH_VARARGS|METH_KEYWORDS, "GridFunction_ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, { "GridFunction_ComputeL1Error", _wrap_GridFunction_ComputeL1Error, METH_VARARGS, "\n" "GridFunction_ComputeL1Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "GridFunction_ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" @@ -19823,7 +15178,7 @@ static PyMethodDef SwigMethods[] = { "GridFunction_ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" "GridFunction_ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" ""}, - { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "GridFunction_ComputeFlux", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeFlux, METH_VARARGS|METH_KEYWORDS, "GridFunction_ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" "GridFunction_Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" "GridFunction_Assign(GridFunction self, double value) -> GridFunction\n" @@ -19834,7 +15189,7 @@ static PyMethodDef SwigMethods[] = { "GridFunction_FESpace(GridFunction self) -> FiniteElementSpace\n" "GridFunction_FESpace(GridFunction self) -> FiniteElementSpace\n" ""}, - { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "GridFunction_SetSpace(GridFunction self, FiniteElementSpace f)"}, + { "GridFunction_SetSpace", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetSpace, METH_VARARGS|METH_KEYWORDS, "GridFunction_SetSpace(GridFunction self, FiniteElementSpace f)"}, { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" "GridFunction_MakeRef(GridFunction self, Vector base, int offset, int size)\n" "GridFunction_MakeRef(GridFunction self, Vector base, int offset)\n" @@ -19845,8 +15200,8 @@ static PyMethodDef SwigMethods[] = { "GridFunction_MakeTRef(GridFunction self, FiniteElementSpace f, double * tv)\n" "GridFunction_MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset)\n" ""}, - { "GridFunction_SaveVTK", _wrap_GridFunction_SaveVTK, METH_VARARGS, "GridFunction_SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, - { "GridFunction_SaveSTL", _wrap_GridFunction_SaveSTL, METH_VARARGS, "GridFunction_SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, + { "GridFunction_SaveVTK", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveVTK, METH_VARARGS|METH_KEYWORDS, "GridFunction_SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, + { "GridFunction_SaveSTL", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveSTL, METH_VARARGS|METH_KEYWORDS, "GridFunction_SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, { "delete_GridFunction", _wrap_delete_GridFunction, METH_O, "delete_GridFunction(GridFunction self)"}, { "new_GridFunction", _wrap_new_GridFunction, METH_VARARGS, "\n" "GridFunction()\n" @@ -19858,14 +15213,14 @@ static PyMethodDef SwigMethods[] = { "GridFunction(Mesh m, char const * grid_file)\n" "new_GridFunction(FiniteElementSpace fes, Vector v, int offset) -> GridFunction\n" ""}, - { "GridFunction_SaveToFile", _wrap_GridFunction_SaveToFile, METH_VARARGS, "GridFunction_SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, - { "GridFunction_iadd", _wrap_GridFunction_iadd, METH_VARARGS, "GridFunction_iadd(GridFunction self, GridFunction c) -> GridFunction"}, + { "GridFunction_SaveToFile", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveToFile, METH_VARARGS|METH_KEYWORDS, "GridFunction_SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, + { "GridFunction_iadd", (PyCFunction)(void(*)(void))_wrap_GridFunction_iadd, METH_VARARGS|METH_KEYWORDS, "GridFunction_iadd(GridFunction self, GridFunction c) -> GridFunction"}, { "GridFunction_isub", _wrap_GridFunction_isub, METH_VARARGS, "\n" "GridFunction_isub(GridFunction self, GridFunction c) -> GridFunction\n" "GridFunction_isub(GridFunction self, double c) -> GridFunction\n" ""}, - { "GridFunction_imul", _wrap_GridFunction_imul, METH_VARARGS, "GridFunction_imul(GridFunction self, double c) -> GridFunction"}, - { "GridFunction_idiv", _wrap_GridFunction_idiv, METH_VARARGS, "GridFunction_idiv(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_imul", (PyCFunction)(void(*)(void))_wrap_GridFunction_imul, METH_VARARGS|METH_KEYWORDS, "GridFunction_imul(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_idiv", (PyCFunction)(void(*)(void))_wrap_GridFunction_idiv, METH_VARARGS|METH_KEYWORDS, "GridFunction_idiv(GridFunction self, double c) -> GridFunction"}, { "GridFunction_Save", _wrap_GridFunction_Save, METH_VARARGS, "\n" "GridFunction_Save(GridFunction self, std::ostream & out)\n" "GridFunction_Save(GridFunction self, char const * file, int precision=8)\n" @@ -19886,10 +15241,10 @@ static PyMethodDef SwigMethods[] = { "QuadratureFunction_SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1)\n" ""}, { "QuadratureFunction_GetVDim", _wrap_QuadratureFunction_GetVDim, METH_O, "QuadratureFunction_GetVDim(QuadratureFunction self) -> int"}, - { "QuadratureFunction_SetVDim", _wrap_QuadratureFunction_SetVDim, METH_VARARGS, "QuadratureFunction_SetVDim(QuadratureFunction self, int vdim_)"}, + { "QuadratureFunction_SetVDim", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetVDim, METH_VARARGS|METH_KEYWORDS, "QuadratureFunction_SetVDim(QuadratureFunction self, int vdim_)"}, { "QuadratureFunction_OwnsSpace", _wrap_QuadratureFunction_OwnsSpace, METH_O, "QuadratureFunction_OwnsSpace(QuadratureFunction self) -> bool"}, - { "QuadratureFunction_SetOwnsSpace", _wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS, "QuadratureFunction_SetOwnsSpace(QuadratureFunction self, bool own)"}, - { "QuadratureFunction_GetElementIntRule", _wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS, "QuadratureFunction_GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, + { "QuadratureFunction_SetOwnsSpace", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS|METH_KEYWORDS, "QuadratureFunction_SetOwnsSpace(QuadratureFunction self, bool own)"}, + { "QuadratureFunction_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "QuadratureFunction_GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, { "QuadratureFunction_GetElementValues", _wrap_QuadratureFunction_GetElementValues, METH_VARARGS, "\n" "QuadratureFunction_GetElementValues(QuadratureFunction self, int idx, Vector values)\n" "QuadratureFunction_GetElementValues(QuadratureFunction self, int idx, Vector values)\n" @@ -19907,14 +15262,14 @@ static PyMethodDef SwigMethods[] = { "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" ""}, - { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, - { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, - { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, - { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "ExtrudeCoefficient_Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "ZZErrorEstimator", (PyCFunction)(void(*)(void))_wrap_ZZErrorEstimator, METH_VARARGS|METH_KEYWORDS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, + { "ComputeElementLpDistance", (PyCFunction)(void(*)(void))_wrap_ComputeElementLpDistance, METH_VARARGS|METH_KEYWORDS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, + { "new_ExtrudeCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ExtrudeCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, + { "ExtrudeCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ExtrudeCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "ExtrudeCoefficient_Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ExtrudeCoefficient", _wrap_delete_ExtrudeCoefficient, METH_O, "delete_ExtrudeCoefficient(ExtrudeCoefficient self)"}, { "ExtrudeCoefficient_swigregister", ExtrudeCoefficient_swigregister, METH_O, NULL}, { "ExtrudeCoefficient_swiginit", ExtrudeCoefficient_swiginit, METH_VARARGS, NULL}, - { "Extrude1DGridFunction", _wrap_Extrude1DGridFunction, METH_VARARGS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, + { "Extrude1DGridFunction", (PyCFunction)(void(*)(void))_wrap_Extrude1DGridFunction, METH_VARARGS|METH_KEYWORDS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, { NULL, NULL, 0, NULL } }; @@ -19923,33 +15278,33 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, - { "GridFunction_MakeOwner", _wrap_GridFunction_MakeOwner, METH_VARARGS, "MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, + { "GridFunction_MakeOwner", (PyCFunction)(void(*)(void))_wrap_GridFunction_MakeOwner, METH_VARARGS|METH_KEYWORDS, "MakeOwner(GridFunction self, FiniteElementCollection _fec)"}, { "GridFunction_OwnFEC", _wrap_GridFunction_OwnFEC, METH_O, "OwnFEC(GridFunction self) -> FiniteElementCollection"}, { "GridFunction_VectorDim", _wrap_GridFunction_VectorDim, METH_O, "VectorDim(GridFunction self) -> int"}, { "GridFunction_GetTrueVector", _wrap_GridFunction_GetTrueVector, METH_VARARGS, "\n" "GetTrueVector(GridFunction self) -> Vector\n" "GetTrueVector(GridFunction self) -> Vector\n" ""}, - { "GridFunction_GetTrueDofs", _wrap_GridFunction_GetTrueDofs, METH_VARARGS, "GetTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_GetTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetTrueDofs, METH_VARARGS|METH_KEYWORDS, "GetTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetTrueVector", _wrap_GridFunction_SetTrueVector, METH_O, "SetTrueVector(GridFunction self)"}, - { "GridFunction_SetFromTrueDofs", _wrap_GridFunction_SetFromTrueDofs, METH_VARARGS, "SetFromTrueDofs(GridFunction self, Vector tv)"}, + { "GridFunction_SetFromTrueDofs", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetFromTrueDofs, METH_VARARGS|METH_KEYWORDS, "SetFromTrueDofs(GridFunction self, Vector tv)"}, { "GridFunction_SetFromTrueVector", _wrap_GridFunction_SetFromTrueVector, METH_O, "SetFromTrueVector(GridFunction self)"}, - { "GridFunction_GetValue", _wrap_GridFunction_GetValue, METH_VARARGS, "GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, - { "GridFunction_GetVectorValue", _wrap_GridFunction_GetVectorValue, METH_VARARGS, "GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, + { "GridFunction_GetValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValue, METH_VARARGS|METH_KEYWORDS, "GetValue(GridFunction self, int i, IntegrationPoint ip, int vdim=1) -> double"}, + { "GridFunction_GetVectorValue", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorValue, METH_VARARGS|METH_KEYWORDS, "GetVectorValue(GridFunction self, int i, IntegrationPoint ip, Vector val)"}, { "GridFunction_GetValues", _wrap_GridFunction_GetValues, METH_VARARGS, "\n" "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, int vdim=1)\n" "GetValues(GridFunction self, int i, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1)\n" @@ -19962,37 +15317,37 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, int vdim=1)\n" "GetHessians(GridFunction self, int i, IntegrationRule ir, DenseMatrix hess, DenseMatrix tr, int vdim=1)\n" ""}, - { "GridFunction_GetFaceValues", _wrap_GridFunction_GetFaceValues, METH_VARARGS, "GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, + { "GridFunction_GetFaceValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceValues, METH_VARARGS|METH_KEYWORDS, "GetFaceValues(GridFunction self, int i, int side, IntegrationRule ir, Vector vals, DenseMatrix tr, int vdim=1) -> int"}, { "GridFunction_GetVectorValues", _wrap_GridFunction_GetVectorValues, METH_VARARGS, "\n" "GetVectorValues(GridFunction self, ElementTransformation T, IntegrationRule ir, DenseMatrix vals)\n" "GetVectorValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr)\n" ""}, - { "GridFunction_GetFaceVectorValues", _wrap_GridFunction_GetFaceVectorValues, METH_VARARGS, "GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, - { "GridFunction_GetValuesFrom", _wrap_GridFunction_GetValuesFrom, METH_VARARGS, "GetValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetBdrValuesFrom", _wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS, "GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, - { "GridFunction_GetVectorFieldValues", _wrap_GridFunction_GetVectorFieldValues, METH_VARARGS, "GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, + { "GridFunction_GetFaceVectorValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetFaceVectorValues, METH_VARARGS|METH_KEYWORDS, "GetFaceVectorValues(GridFunction self, int i, int side, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr) -> int"}, + { "GridFunction_GetValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetValuesFrom, METH_VARARGS|METH_KEYWORDS, "GetValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetBdrValuesFrom", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetBdrValuesFrom, METH_VARARGS|METH_KEYWORDS, "GetBdrValuesFrom(GridFunction self, GridFunction orig_func)"}, + { "GridFunction_GetVectorFieldValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldValues, METH_VARARGS|METH_KEYWORDS, "GetVectorFieldValues(GridFunction self, int i, IntegrationRule ir, DenseMatrix vals, DenseMatrix tr, int comp=0)"}, { "GridFunction_ReorderByNodes", _wrap_GridFunction_ReorderByNodes, METH_O, "ReorderByNodes(GridFunction self)"}, { "GridFunction_GetNodalValues", _wrap_GridFunction_GetNodalValues, METH_VARARGS, "\n" "GetNodalValues(GridFunction self, int i, doubleArray nval, int vdim=1)\n" "GetNodalValues(GridFunction self, Vector nval, int vdim=1)\n" ""}, - { "GridFunction_GetVectorFieldNodalValues", _wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS, "GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, - { "GridFunction_ProjectVectorFieldOn", _wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS, "ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, - { "GridFunction_GetDerivative", _wrap_GridFunction_GetDerivative, METH_VARARGS, "GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, - { "GridFunction_GetDivergence", _wrap_GridFunction_GetDivergence, METH_VARARGS, "GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, - { "GridFunction_GetCurl", _wrap_GridFunction_GetCurl, METH_VARARGS, "GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, - { "GridFunction_GetGradient", _wrap_GridFunction_GetGradient, METH_VARARGS, "GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, + { "GridFunction_GetVectorFieldNodalValues", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorFieldNodalValues, METH_VARARGS|METH_KEYWORDS, "GetVectorFieldNodalValues(GridFunction self, Vector val, int comp)"}, + { "GridFunction_ProjectVectorFieldOn", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectVectorFieldOn, METH_VARARGS|METH_KEYWORDS, "ProjectVectorFieldOn(GridFunction self, GridFunction vec_field, int comp=0)"}, + { "GridFunction_GetDerivative", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDerivative, METH_VARARGS|METH_KEYWORDS, "GetDerivative(GridFunction self, int comp, int der_comp, GridFunction der)"}, + { "GridFunction_GetDivergence", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetDivergence, METH_VARARGS|METH_KEYWORDS, "GetDivergence(GridFunction self, ElementTransformation tr) -> double"}, + { "GridFunction_GetCurl", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetCurl, METH_VARARGS|METH_KEYWORDS, "GetCurl(GridFunction self, ElementTransformation tr, Vector curl)"}, + { "GridFunction_GetGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(GridFunction self, ElementTransformation tr, Vector grad)"}, { "GridFunction_GetGradients", _wrap_GridFunction_GetGradients, METH_VARARGS, "\n" "GetGradients(GridFunction self, ElementTransformation tr, IntegrationRule ir, DenseMatrix grad)\n" "GetGradients(GridFunction self, int const elem, IntegrationRule ir, DenseMatrix grad)\n" ""}, - { "GridFunction_GetVectorGradient", _wrap_GridFunction_GetVectorGradient, METH_VARARGS, "GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, - { "GridFunction_GetElementAverages", _wrap_GridFunction_GetElementAverages, METH_VARARGS, "GetElementAverages(GridFunction self, GridFunction avgs)"}, + { "GridFunction_GetVectorGradient", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetVectorGradient, METH_VARARGS|METH_KEYWORDS, "GetVectorGradient(GridFunction self, ElementTransformation tr, DenseMatrix grad)"}, + { "GridFunction_GetElementAverages", (PyCFunction)(void(*)(void))_wrap_GridFunction_GetElementAverages, METH_VARARGS|METH_KEYWORDS, "GetElementAverages(GridFunction self, GridFunction avgs)"}, { "GridFunction_ImposeBounds", _wrap_GridFunction_ImposeBounds, METH_VARARGS, "\n" "ImposeBounds(GridFunction self, int i, Vector weights, Vector _lo, Vector _hi)\n" "ImposeBounds(GridFunction self, int i, Vector weights, double _min=0.0, double _max=mfem::infinity())\n" ""}, - { "GridFunction_ProjectGridFunction", _wrap_GridFunction_ProjectGridFunction, METH_VARARGS, "ProjectGridFunction(GridFunction self, GridFunction src)"}, + { "GridFunction_ProjectGridFunction", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectGridFunction, METH_VARARGS|METH_KEYWORDS, "ProjectGridFunction(GridFunction self, GridFunction src)"}, { "GridFunction_ProjectCoefficient", _wrap_GridFunction_ProjectCoefficient, METH_VARARGS, "\n" "ProjectCoefficient(GridFunction self, Coefficient coeff)\n" "ProjectCoefficient(GridFunction self, Coefficient coeff, intArray dofs, int vd=0)\n" @@ -20010,20 +15365,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ProjectBdrCoefficient(GridFunction self, VectorCoefficient vcoeff, intArray attr)\n" "ProjectBdrCoefficient(GridFunction self, mfem::Coefficient *[] coeff, intArray attr)\n" ""}, - { "GridFunction_ProjectBdrCoefficientNormal", _wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS, "ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, - { "GridFunction_ProjectBdrCoefficientTangent", _wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS, "ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientNormal", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientNormal, METH_VARARGS|METH_KEYWORDS, "ProjectBdrCoefficientNormal(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, + { "GridFunction_ProjectBdrCoefficientTangent", (PyCFunction)(void(*)(void))_wrap_GridFunction_ProjectBdrCoefficientTangent, METH_VARARGS|METH_KEYWORDS, "ProjectBdrCoefficientTangent(GridFunction self, VectorCoefficient vcoeff, intArray bdr_attr)"}, { "GridFunction_ComputeL2Error", _wrap_GridFunction_ComputeL2Error, METH_VARARGS, "\n" "ComputeL2Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeL2Error(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeL2Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0, intArray elems=None) -> double\n" ""}, - { "GridFunction_ComputeH1Error", _wrap_GridFunction_ComputeH1Error, METH_VARARGS, "ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, + { "GridFunction_ComputeH1Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeH1Error, METH_VARARGS|METH_KEYWORDS, "ComputeH1Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, Coefficient ell_coef, double Nu, int norm_type) -> double"}, { "GridFunction_ComputeMaxError", _wrap_GridFunction_ComputeMaxError, METH_VARARGS, "\n" "ComputeMaxError(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeMaxError(GridFunction self, mfem::Coefficient *[] exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeMaxError(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" ""}, - { "GridFunction_ComputeW11Error", _wrap_GridFunction_ComputeW11Error, METH_VARARGS, "ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, + { "GridFunction_ComputeW11Error", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeW11Error, METH_VARARGS|METH_KEYWORDS, "ComputeW11Error(GridFunction self, Coefficient exsol, VectorCoefficient exgrad, int norm_type, intArray elems=None, mfem::IntegrationRule const *[] irs=0) -> double"}, { "GridFunction_ComputeL1Error", _wrap_GridFunction_ComputeL1Error, METH_VARARGS, "\n" "ComputeL1Error(GridFunction self, Coefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" "ComputeL1Error(GridFunction self, VectorCoefficient exsol, mfem::IntegrationRule const *[] irs=0) -> double\n" @@ -20048,7 +15403,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "ComputeElementMaxErrors(GridFunction self, Coefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" "ComputeElementMaxErrors(GridFunction self, VectorCoefficient exsol, GridFunction error, mfem::IntegrationRule const *[] irs=0)\n" ""}, - { "GridFunction_ComputeFlux", _wrap_GridFunction_ComputeFlux, METH_VARARGS, "ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, + { "GridFunction_ComputeFlux", (PyCFunction)(void(*)(void))_wrap_GridFunction_ComputeFlux, METH_VARARGS|METH_KEYWORDS, "ComputeFlux(GridFunction self, BilinearFormIntegrator blfi, GridFunction flux, bool wcoef=True, int subdomain=-1)"}, { "GridFunction_Assign", _wrap_GridFunction_Assign, METH_VARARGS, "\n" "Assign(GridFunction self, GridFunction rhs) -> GridFunction\n" "Assign(GridFunction self, double value) -> GridFunction\n" @@ -20059,7 +15414,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FESpace(GridFunction self) -> FiniteElementSpace\n" "FESpace(GridFunction self) -> FiniteElementSpace\n" ""}, - { "GridFunction_SetSpace", _wrap_GridFunction_SetSpace, METH_VARARGS, "SetSpace(GridFunction self, FiniteElementSpace f)"}, + { "GridFunction_SetSpace", (PyCFunction)(void(*)(void))_wrap_GridFunction_SetSpace, METH_VARARGS|METH_KEYWORDS, "SetSpace(GridFunction self, FiniteElementSpace f)"}, { "GridFunction_MakeRef", _wrap_GridFunction_MakeRef, METH_VARARGS, "\n" "MakeRef(GridFunction self, Vector base, int offset, int size)\n" "MakeRef(GridFunction self, Vector base, int offset)\n" @@ -20070,8 +15425,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MakeTRef(GridFunction self, FiniteElementSpace f, double * tv)\n" "MakeTRef(GridFunction self, FiniteElementSpace f, Vector tv, int tv_offset)\n" ""}, - { "GridFunction_SaveVTK", _wrap_GridFunction_SaveVTK, METH_VARARGS, "SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, - { "GridFunction_SaveSTL", _wrap_GridFunction_SaveSTL, METH_VARARGS, "SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, + { "GridFunction_SaveVTK", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveVTK, METH_VARARGS|METH_KEYWORDS, "SaveVTK(GridFunction self, std::ostream & out, std::string const & field_name, int ref)"}, + { "GridFunction_SaveSTL", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveSTL, METH_VARARGS|METH_KEYWORDS, "SaveSTL(GridFunction self, std::ostream & out, int TimesToRefine=1)"}, { "delete_GridFunction", _wrap_delete_GridFunction, METH_O, "delete_GridFunction(GridFunction self)"}, { "new_GridFunction", _wrap_new_GridFunction, METH_VARARGS, "\n" "GridFunction()\n" @@ -20083,14 +15438,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GridFunction(Mesh m, char const * grid_file)\n" "new_GridFunction(FiniteElementSpace fes, Vector v, int offset) -> GridFunction\n" ""}, - { "GridFunction_SaveToFile", _wrap_GridFunction_SaveToFile, METH_VARARGS, "SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, - { "GridFunction_iadd", _wrap_GridFunction_iadd, METH_VARARGS, "iadd(GridFunction self, GridFunction c) -> GridFunction"}, + { "GridFunction_SaveToFile", (PyCFunction)(void(*)(void))_wrap_GridFunction_SaveToFile, METH_VARARGS|METH_KEYWORDS, "SaveToFile(GridFunction self, char const * gf_file, int const precision)"}, + { "GridFunction_iadd", (PyCFunction)(void(*)(void))_wrap_GridFunction_iadd, METH_VARARGS|METH_KEYWORDS, "iadd(GridFunction self, GridFunction c) -> GridFunction"}, { "GridFunction_isub", _wrap_GridFunction_isub, METH_VARARGS, "\n" "isub(GridFunction self, GridFunction c) -> GridFunction\n" "isub(GridFunction self, double c) -> GridFunction\n" ""}, - { "GridFunction_imul", _wrap_GridFunction_imul, METH_VARARGS, "imul(GridFunction self, double c) -> GridFunction"}, - { "GridFunction_idiv", _wrap_GridFunction_idiv, METH_VARARGS, "idiv(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_imul", (PyCFunction)(void(*)(void))_wrap_GridFunction_imul, METH_VARARGS|METH_KEYWORDS, "imul(GridFunction self, double c) -> GridFunction"}, + { "GridFunction_idiv", (PyCFunction)(void(*)(void))_wrap_GridFunction_idiv, METH_VARARGS|METH_KEYWORDS, "idiv(GridFunction self, double c) -> GridFunction"}, { "GridFunction_Save", _wrap_GridFunction_Save, METH_VARARGS, "\n" "Save(GridFunction self, std::ostream & out)\n" "Save(GridFunction self, char const * file, int precision=8)\n" @@ -20111,10 +15466,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSpace(QuadratureFunction self, QuadratureSpace qspace_, double * qf_data, int vdim_=-1)\n" ""}, { "QuadratureFunction_GetVDim", _wrap_QuadratureFunction_GetVDim, METH_O, "GetVDim(QuadratureFunction self) -> int"}, - { "QuadratureFunction_SetVDim", _wrap_QuadratureFunction_SetVDim, METH_VARARGS, "SetVDim(QuadratureFunction self, int vdim_)"}, + { "QuadratureFunction_SetVDim", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetVDim, METH_VARARGS|METH_KEYWORDS, "SetVDim(QuadratureFunction self, int vdim_)"}, { "QuadratureFunction_OwnsSpace", _wrap_QuadratureFunction_OwnsSpace, METH_O, "OwnsSpace(QuadratureFunction self) -> bool"}, - { "QuadratureFunction_SetOwnsSpace", _wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS, "SetOwnsSpace(QuadratureFunction self, bool own)"}, - { "QuadratureFunction_GetElementIntRule", _wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS, "GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, + { "QuadratureFunction_SetOwnsSpace", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_SetOwnsSpace, METH_VARARGS|METH_KEYWORDS, "SetOwnsSpace(QuadratureFunction self, bool own)"}, + { "QuadratureFunction_GetElementIntRule", (PyCFunction)(void(*)(void))_wrap_QuadratureFunction_GetElementIntRule, METH_VARARGS|METH_KEYWORDS, "GetElementIntRule(QuadratureFunction self, int idx) -> IntegrationRule"}, { "QuadratureFunction_GetElementValues", _wrap_QuadratureFunction_GetElementValues, METH_VARARGS, "\n" "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" "GetElementValues(QuadratureFunction self, int idx, Vector values)\n" @@ -20132,14 +15487,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__lshift__(std::ostream & out, GridFunction sol) -> std::ostream\n" "__lshift__(std::ostream & out, QuadratureFunction qf) -> std::ostream &\n" ""}, - { "ZZErrorEstimator", _wrap_ZZErrorEstimator, METH_VARARGS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, - { "ComputeElementLpDistance", _wrap_ComputeElementLpDistance, METH_VARARGS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, - { "new_ExtrudeCoefficient", _wrap_new_ExtrudeCoefficient, METH_VARARGS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, - { "ExtrudeCoefficient_Eval", _wrap_ExtrudeCoefficient_Eval, METH_VARARGS, "Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, + { "ZZErrorEstimator", (PyCFunction)(void(*)(void))_wrap_ZZErrorEstimator, METH_VARARGS|METH_KEYWORDS, "ZZErrorEstimator(BilinearFormIntegrator blfi, GridFunction u, GridFunction flux, Vector error_estimates, intArray aniso_flags=None, int with_subdomains=1, bool with_coeff=False) -> double"}, + { "ComputeElementLpDistance", (PyCFunction)(void(*)(void))_wrap_ComputeElementLpDistance, METH_VARARGS|METH_KEYWORDS, "ComputeElementLpDistance(double p, int i, GridFunction gf1, GridFunction gf2) -> double"}, + { "new_ExtrudeCoefficient", (PyCFunction)(void(*)(void))_wrap_new_ExtrudeCoefficient, METH_VARARGS|METH_KEYWORDS, "new_ExtrudeCoefficient(Mesh m, Coefficient s, int _n) -> ExtrudeCoefficient"}, + { "ExtrudeCoefficient_Eval", (PyCFunction)(void(*)(void))_wrap_ExtrudeCoefficient_Eval, METH_VARARGS|METH_KEYWORDS, "Eval(ExtrudeCoefficient self, ElementTransformation T, IntegrationPoint ip) -> double"}, { "delete_ExtrudeCoefficient", _wrap_delete_ExtrudeCoefficient, METH_O, "delete_ExtrudeCoefficient(ExtrudeCoefficient self)"}, { "ExtrudeCoefficient_swigregister", ExtrudeCoefficient_swigregister, METH_O, NULL}, { "ExtrudeCoefficient_swiginit", ExtrudeCoefficient_swiginit, METH_VARARGS, NULL}, - { "Extrude1DGridFunction", _wrap_Extrude1DGridFunction, METH_VARARGS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, + { "Extrude1DGridFunction", (PyCFunction)(void(*)(void))_wrap_Extrude1DGridFunction, METH_VARARGS|METH_KEYWORDS, "Extrude1DGridFunction(Mesh mesh, Mesh mesh2d, GridFunction sol, int const ny) -> GridFunction"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/handle_wrap.cxx b/mfem/_ser/handle_wrap.cxx index aa8bff69..d7ee8e09 100644 --- a/mfem/_ser/handle_wrap.cxx +++ b/mfem/_ser/handle_wrap.cxx @@ -3802,67 +3802,36 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_OwnsOperator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"own", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:OperatorHandle_SetOperatorOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetOperatorOwner(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OperatorHandle_SetOperatorOwner" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); { try { - (arg1)->SetOperatorOwner(); + (arg1)->SetOperatorOwner(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3886,48 +3855,6 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_OperatorHandle_SetOperatorOwner(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_SetOperatorOwner", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_OperatorHandle_SetOperatorOwner__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_OperatorHandle_SetOperatorOwner__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_SetOperatorOwner'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::OperatorHandle::SetOperatorOwner(bool)\n" - " mfem::OperatorHandle::SetOperatorOwner()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OperatorHandle_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -3968,7 +3895,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Clear(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Operator::Type arg2 ; @@ -3976,15 +3903,19 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tid", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_SetType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_SetType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_SetType" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OperatorHandle_SetType" "', argument " "2"" of type '" "mfem::Operator::Type""'"); } @@ -4015,7 +3946,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_SetType(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4026,15 +3957,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MakePtAP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_MakePtAP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MakePtAP" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_MakePtAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } @@ -4042,7 +3978,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MakePtAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_MakePtAP" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -4076,7 +4012,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakePtAP(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4090,15 +4026,21 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self) int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Rt", (char *)"A", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MakeRAP", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OperatorHandle_MakeRAP", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MakeRAP" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_MakeRAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } @@ -4106,7 +4048,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MakeRAP" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_MakeRAP" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } @@ -4114,7 +4056,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MakeRAP(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MakeRAP" "', argument " "3"" of type '" "mfem::OperatorHandle &""'"); } arg3 = reinterpret_cast< mfem::OperatorHandle * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_MakeRAP" "', argument " "4"" of type '" "mfem::OperatorHandle &""'"); } @@ -4197,7 +4139,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4208,15 +4150,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"ess_dof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_EliminateRowsCols", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_EliminateRowsCols", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } @@ -4224,7 +4171,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "2"" of type '" "mfem::OperatorHandle &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_EliminateRowsCols" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -4258,7 +4205,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateRowsCols(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::OperatorHandle *arg2 = 0 ; @@ -4275,15 +4222,22 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A_e", (char *)"ess_dof_list", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_EliminateBC", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:OperatorHandle_EliminateBC", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_EliminateBC" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_EliminateBC" "', argument " "2"" of type '" "mfem::OperatorHandle const &""'"); } @@ -4291,7 +4245,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateBC" "', argument " "2"" of type '" "mfem::OperatorHandle const &""'"); } arg2 = reinterpret_cast< mfem::OperatorHandle * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -4299,7 +4253,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateBC" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -4307,7 +4261,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_EliminateBC(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_EliminateBC" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_EliminateBC" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -4423,7 +4377,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Is(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::SparseMatrix **arg2 = 0 ; @@ -4431,15 +4385,19 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_Get", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_Get", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Get" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__SparseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Get" "', argument " "2"" of type '" "mfem::SparseMatrix *&""'"); } @@ -4473,83 +4431,45 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Get(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_OperatorHandle_Reset__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_Reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::SparseMatrix *arg2 = (mfem::SparseMatrix *) 0 ; - bool arg3 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; bool val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", (char *)"own_A", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:OperatorHandle_Reset", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Reset" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Reset" "', argument " "2"" of type '" "mfem::SparseMatrix *""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OperatorHandle_Reset" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR Reset< mfem::SparseMatrix >(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_Reset__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - mfem::SparseMatrix *arg2 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Reset" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Reset" "', argument " "2"" of type '" "mfem::SparseMatrix *""'"); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "OperatorHandle_Reset" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); { try { - (arg1)->SWIGTEMPLATEDISAMBIGUATOR Reset< mfem::SparseMatrix >(arg2); + (arg1)->SWIGTEMPLATEDISAMBIGUATOR Reset< mfem::SparseMatrix >(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4573,58 +4493,6 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Reset__SWIG_3(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_OperatorHandle_Reset(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_Reset", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_OperatorHandle_Reset__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_OperatorHandle_Reset__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_Reset'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::OperatorHandle::Reset< mfem::SparseMatrix >(mfem::SparseMatrix *,bool)\n" - " mfem::OperatorHandle::Reset< mfem::SparseMatrix >(mfem::SparseMatrix *)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -4717,7 +4585,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_ConvertFrom(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -4743,30 +4611,40 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Po", (char *)"Ri", (char *)"Pi", (char *)"x", (char *)"b", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_InitTVectors", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:OperatorHandle_InitTVectors", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_InitTVectors" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -4774,7 +4652,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -4782,7 +4660,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -4790,7 +4668,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_InitTVectors(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -5029,7 +4907,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetMemoryClass(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5040,15 +4918,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_Mult" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5056,7 +4939,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5090,7 +4973,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5101,15 +4984,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_MultTranspose" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5117,7 +5005,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5151,7 +5039,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_MultTranspose(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_OperatorHandle_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5159,16 +5047,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetGradient(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_GetGradient" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5366,7 +5258,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_GetOutputRestriction(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5375,7 +5267,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI mfem::Operator **arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5390,14 +5282,25 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", (char *)"copy_interior", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO|O:OperatorHandle_FormLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5405,7 +5308,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5413,7 +5316,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5421,7 +5324,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } @@ -5429,7 +5332,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -5437,7 +5340,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -5445,11 +5348,13 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + if (obj7) { + { + if ((PyArray_PyIntAsInt(obj7) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(obj7); + } } { try { @@ -5477,15 +5382,16 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_0(PyObject *SWI } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::Array< int > *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - mfem::Operator **arg5 = 0 ; - mfem::Vector *arg6 = 0 ; + mfem::Vector *arg5 = 0 ; + mfem::Operator **arg6 = 0 ; mfem::Vector *arg7 = 0 ; + mfem::Vector *arg8 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5500,64 +5406,85 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_1(PyObject *SWI int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; + void *argp8 = 0 ; + int res8 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:OperatorHandle_FormRectangularLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } - arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + arg5 = reinterpret_cast< mfem::Vector * >(argp5); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + arg6 = reinterpret_cast< mfem::Operator ** >(argp6); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res8)) { + SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + if (!argp8) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); + } + arg8 = reinterpret_cast< mfem::Vector * >(argp8); { try { - (*arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (*arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5581,227 +5508,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormLinearSystem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_FormLinearSystem", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_OperatorHandle_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_FormLinearSystem__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_FormLinearSystem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Vector *arg5 = 0 ; - mfem::Operator **arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - mfem::Vector *arg8 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - void *argp8 = 0 ; - int res8 = 0 ; - PyObject *swig_obj[8] ; - - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); - } - arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); - } - arg6 = reinterpret_cast< mfem::Operator ** >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res8)) { - SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); - } - if (!argp8) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); - } - arg8 = reinterpret_cast< mfem::Vector * >(argp8); - { - try { - (*arg1)->FormRectangularLinearSystem((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4,*arg5,*arg6,*arg7,*arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5815,15 +5522,21 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"X", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_RecoverFEMSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OperatorHandle_RecoverFEMSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5831,7 +5544,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -5839,7 +5552,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_RecoverFEMSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -5873,7 +5586,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_RecoverFEMSolution(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5884,15 +5597,20 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorHandle_FormSystemOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5900,7 +5618,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); } @@ -5934,7 +5652,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormSystemOperator(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5948,15 +5666,21 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:OperatorHandle_FormRectangularSystemOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5964,7 +5688,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -5972,7 +5696,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "OperatorHandle_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); } @@ -6006,7 +5730,7 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormRectangularSystemOperator(PyObject } -SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; mfem::Operator **arg2 = 0 ; @@ -6014,15 +5738,19 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorHandle_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorHandle_FormDiscreteOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::OperatorHandle *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorHandle_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); } @@ -6056,104 +5784,32 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_FormDiscreteOperator(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_PrintMatlab" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (*arg1)->PrintMatlab(*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + int arg3 = (int) 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", (char *)"n", (char *)"m", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:OperatorHandle_PrintMatlab", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_PrintMatlab" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); } arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } @@ -6167,81 +5823,25 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_1(PyObject *SWIGUNUS arg2 = &out2; } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (*arg1)->PrintMatlab(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorHandle, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle_PrintMatlab" "', argument " "1"" of type '" "mfem::OperatorHandle const *""'"); - } - arg1 = reinterpret_cast< mfem::OperatorHandle * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } } { try { - (*arg1)->PrintMatlab(*arg2); + (*arg1)->PrintMatlab(*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6275,115 +5875,6 @@ SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab__SWIG_2(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OperatorHandle_PrintMatlab(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "OperatorHandle_PrintMatlab", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_PrintMatlab__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_PrintMatlab__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__OperatorHandle, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_OperatorHandle_PrintMatlab__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'OperatorHandle_PrintMatlab'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Operator::PrintMatlab(std::ostream &,int,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OperatorHandle_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::OperatorHandle *arg1 = (mfem::OperatorHandle *) 0 ; @@ -6449,41 +5940,41 @@ static PyMethodDef SwigMethods[] = { { "OperatorHandle___ref__", _wrap_OperatorHandle___ref__, METH_O, "OperatorHandle___ref__(OperatorHandle self) -> Operator"}, { "OperatorHandle_Type", _wrap_OperatorHandle_Type, METH_O, "OperatorHandle_Type(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_OwnsOperator", _wrap_OperatorHandle_OwnsOperator, METH_O, "OperatorHandle_OwnsOperator(OperatorHandle self) -> bool"}, - { "OperatorHandle_SetOperatorOwner", _wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS, "OperatorHandle_SetOperatorOwner(OperatorHandle self, bool own=True)"}, + { "OperatorHandle_SetOperatorOwner", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_SetOperatorOwner(OperatorHandle self, bool own=True)"}, { "OperatorHandle_Clear", _wrap_OperatorHandle_Clear, METH_O, "OperatorHandle_Clear(OperatorHandle self)"}, - { "OperatorHandle_SetType", _wrap_OperatorHandle_SetType, METH_VARARGS, "OperatorHandle_SetType(OperatorHandle self, mfem::Operator::Type tid)"}, - { "OperatorHandle_MakePtAP", _wrap_OperatorHandle_MakePtAP, METH_VARARGS, "OperatorHandle_MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_MakeRAP", _wrap_OperatorHandle_MakeRAP, METH_VARARGS, "OperatorHandle_MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_EliminateRowsCols", _wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS, "OperatorHandle_EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, - { "OperatorHandle_EliminateBC", _wrap_OperatorHandle_EliminateBC, METH_VARARGS, "OperatorHandle_EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, + { "OperatorHandle_SetType", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetType, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_SetType(OperatorHandle self, mfem::Operator::Type tid)"}, + { "OperatorHandle_MakePtAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakePtAP, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_MakeRAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeRAP, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_EliminateRowsCols", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, + { "OperatorHandle_EliminateBC", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateBC, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, { "OperatorHandle_As", _wrap_OperatorHandle_As, METH_O, "OperatorHandle_As(OperatorHandle self) -> mfem::SparseMatrix *"}, { "OperatorHandle_Is", _wrap_OperatorHandle_Is, METH_O, "OperatorHandle_Is(OperatorHandle self) -> mfem::SparseMatrix *"}, - { "OperatorHandle_Get", _wrap_OperatorHandle_Get, METH_VARARGS, "OperatorHandle_Get(OperatorHandle self, mfem::SparseMatrix *& A)"}, - { "OperatorHandle_Reset", _wrap_OperatorHandle_Reset, METH_VARARGS, "OperatorHandle_Reset(OperatorHandle self, mfem::SparseMatrix * A, bool own_A=True)"}, + { "OperatorHandle_Get", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Get, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_Get(OperatorHandle self, mfem::SparseMatrix *& A)"}, + { "OperatorHandle_Reset", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Reset, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_Reset(OperatorHandle self, mfem::SparseMatrix * A, bool own_A=True)"}, { "OperatorHandle_ConvertFrom", _wrap_OperatorHandle_ConvertFrom, METH_VARARGS, "\n" "OperatorHandle_ConvertFrom(OperatorHandle self, OperatorHandle A)\n" "OperatorHandle_ConvertFrom(OperatorHandle self, mfem::SparseMatrix * A)\n" ""}, - { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "OperatorHandle_InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "OperatorHandle_InitTVectors", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_InitTVectors, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "OperatorHandle_Height(OperatorHandle self) -> int"}, { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "OperatorHandle_NumRows(OperatorHandle self) -> int"}, { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "OperatorHandle_Width(OperatorHandle self) -> int"}, { "OperatorHandle_NumCols", _wrap_OperatorHandle_NumCols, METH_O, "OperatorHandle_NumCols(OperatorHandle self) -> int"}, { "OperatorHandle_GetMemoryClass", _wrap_OperatorHandle_GetMemoryClass, METH_O, "OperatorHandle_GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass"}, - { "OperatorHandle_Mult", _wrap_OperatorHandle_Mult, METH_VARARGS, "OperatorHandle_Mult(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_MultTranspose", _wrap_OperatorHandle_MultTranspose, METH_VARARGS, "OperatorHandle_MultTranspose(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "OperatorHandle_GetGradient(OperatorHandle self, Vector x) -> Operator"}, + { "OperatorHandle_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Mult, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_Mult(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_MultTranspose", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MultTranspose, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_MultTranspose(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_GetGradient", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_GetGradient, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_GetGradient(OperatorHandle self, Vector x) -> Operator"}, { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "OperatorHandle_GetProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "OperatorHandle_GetRestriction(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "OperatorHandle_GetOutputProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "OperatorHandle_GetOutputRestriction(OperatorHandle self) -> Operator"}, - { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "OperatorHandle_FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "OperatorHandle_FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "OperatorHandle_RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, - { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "OperatorHandle_FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "OperatorHandle_FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "OperatorHandle_FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, - { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "OperatorHandle_PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, + { "OperatorHandle_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "OperatorHandle_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, + { "OperatorHandle_PrintMatlab", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_PrintMatlab, METH_VARARGS|METH_KEYWORDS, "OperatorHandle_PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "OperatorHandle_GetType(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, { "OperatorHandle_swiginit", OperatorHandle_swiginit, METH_VARARGS, NULL}, @@ -6503,41 +5994,41 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "OperatorHandle___ref__", _wrap_OperatorHandle___ref__, METH_O, "__ref__(OperatorHandle self) -> Operator"}, { "OperatorHandle_Type", _wrap_OperatorHandle_Type, METH_O, "Type(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_OwnsOperator", _wrap_OperatorHandle_OwnsOperator, METH_O, "OwnsOperator(OperatorHandle self) -> bool"}, - { "OperatorHandle_SetOperatorOwner", _wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS, "SetOperatorOwner(OperatorHandle self, bool own=True)"}, + { "OperatorHandle_SetOperatorOwner", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetOperatorOwner, METH_VARARGS|METH_KEYWORDS, "SetOperatorOwner(OperatorHandle self, bool own=True)"}, { "OperatorHandle_Clear", _wrap_OperatorHandle_Clear, METH_O, "Clear(OperatorHandle self)"}, - { "OperatorHandle_SetType", _wrap_OperatorHandle_SetType, METH_VARARGS, "SetType(OperatorHandle self, mfem::Operator::Type tid)"}, - { "OperatorHandle_MakePtAP", _wrap_OperatorHandle_MakePtAP, METH_VARARGS, "MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_MakeRAP", _wrap_OperatorHandle_MakeRAP, METH_VARARGS, "MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, - { "OperatorHandle_EliminateRowsCols", _wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS, "EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, - { "OperatorHandle_EliminateBC", _wrap_OperatorHandle_EliminateBC, METH_VARARGS, "EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, + { "OperatorHandle_SetType", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_SetType, METH_VARARGS|METH_KEYWORDS, "SetType(OperatorHandle self, mfem::Operator::Type tid)"}, + { "OperatorHandle_MakePtAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakePtAP, METH_VARARGS|METH_KEYWORDS, "MakePtAP(OperatorHandle self, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_MakeRAP", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MakeRAP, METH_VARARGS|METH_KEYWORDS, "MakeRAP(OperatorHandle self, OperatorHandle Rt, OperatorHandle A, OperatorHandle P)"}, + { "OperatorHandle_EliminateRowsCols", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateRowsCols, METH_VARARGS|METH_KEYWORDS, "EliminateRowsCols(OperatorHandle self, OperatorHandle A, intArray ess_dof_list)"}, + { "OperatorHandle_EliminateBC", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_EliminateBC, METH_VARARGS|METH_KEYWORDS, "EliminateBC(OperatorHandle self, OperatorHandle A_e, intArray ess_dof_list, Vector X, Vector B)"}, { "OperatorHandle_As", _wrap_OperatorHandle_As, METH_O, "As(OperatorHandle self) -> mfem::SparseMatrix *"}, { "OperatorHandle_Is", _wrap_OperatorHandle_Is, METH_O, "Is(OperatorHandle self) -> mfem::SparseMatrix *"}, - { "OperatorHandle_Get", _wrap_OperatorHandle_Get, METH_VARARGS, "Get(OperatorHandle self, mfem::SparseMatrix *& A)"}, - { "OperatorHandle_Reset", _wrap_OperatorHandle_Reset, METH_VARARGS, "Reset(OperatorHandle self, mfem::SparseMatrix * A, bool own_A=True)"}, + { "OperatorHandle_Get", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Get, METH_VARARGS|METH_KEYWORDS, "Get(OperatorHandle self, mfem::SparseMatrix *& A)"}, + { "OperatorHandle_Reset", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Reset, METH_VARARGS|METH_KEYWORDS, "Reset(OperatorHandle self, mfem::SparseMatrix * A, bool own_A=True)"}, { "OperatorHandle_ConvertFrom", _wrap_OperatorHandle_ConvertFrom, METH_VARARGS, "\n" "ConvertFrom(OperatorHandle self, OperatorHandle A)\n" "ConvertFrom(OperatorHandle self, mfem::SparseMatrix * A)\n" ""}, - { "OperatorHandle_InitTVectors", _wrap_OperatorHandle_InitTVectors, METH_VARARGS, "InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "OperatorHandle_InitTVectors", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_InitTVectors, METH_VARARGS|METH_KEYWORDS, "InitTVectors(OperatorHandle self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "OperatorHandle_Height", _wrap_OperatorHandle_Height, METH_O, "Height(OperatorHandle self) -> int"}, { "OperatorHandle_NumRows", _wrap_OperatorHandle_NumRows, METH_O, "NumRows(OperatorHandle self) -> int"}, { "OperatorHandle_Width", _wrap_OperatorHandle_Width, METH_O, "Width(OperatorHandle self) -> int"}, { "OperatorHandle_NumCols", _wrap_OperatorHandle_NumCols, METH_O, "NumCols(OperatorHandle self) -> int"}, { "OperatorHandle_GetMemoryClass", _wrap_OperatorHandle_GetMemoryClass, METH_O, "GetMemoryClass(OperatorHandle self) -> mfem::MemoryClass"}, - { "OperatorHandle_Mult", _wrap_OperatorHandle_Mult, METH_VARARGS, "Mult(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_MultTranspose", _wrap_OperatorHandle_MultTranspose, METH_VARARGS, "MultTranspose(OperatorHandle self, Vector x, Vector y)"}, - { "OperatorHandle_GetGradient", _wrap_OperatorHandle_GetGradient, METH_VARARGS, "GetGradient(OperatorHandle self, Vector x) -> Operator"}, + { "OperatorHandle_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_MultTranspose", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(OperatorHandle self, Vector x, Vector y)"}, + { "OperatorHandle_GetGradient", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(OperatorHandle self, Vector x) -> Operator"}, { "OperatorHandle_GetProlongation", _wrap_OperatorHandle_GetProlongation, METH_O, "GetProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetRestriction", _wrap_OperatorHandle_GetRestriction, METH_O, "GetRestriction(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputProlongation", _wrap_OperatorHandle_GetOutputProlongation, METH_O, "GetOutputProlongation(OperatorHandle self) -> Operator"}, { "OperatorHandle_GetOutputRestriction", _wrap_OperatorHandle_GetOutputRestriction, METH_O, "GetOutputRestriction(OperatorHandle self) -> Operator"}, - { "OperatorHandle_FormLinearSystem", _wrap_OperatorHandle_FormLinearSystem, METH_VARARGS, "FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "OperatorHandle_FormRectangularLinearSystem", _wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "OperatorHandle_RecoverFEMSolution", _wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, - { "OperatorHandle_FormSystemOperator", _wrap_OperatorHandle_FormSystemOperator, METH_VARARGS, "FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormRectangularSystemOperator", _wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "OperatorHandle_FormDiscreteOperator", _wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, - { "OperatorHandle_PrintMatlab", _wrap_OperatorHandle_PrintMatlab, METH_VARARGS, "PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, + { "OperatorHandle_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormLinearSystem(OperatorHandle self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "OperatorHandle_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormRectangularLinearSystem(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "OperatorHandle_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "RecoverFEMSolution(OperatorHandle self, Vector X, Vector b, Vector x)"}, + { "OperatorHandle_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormSystemOperator(OperatorHandle self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormRectangularSystemOperator(OperatorHandle self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "OperatorHandle_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "FormDiscreteOperator(OperatorHandle self, mfem::Operator *& A)"}, + { "OperatorHandle_PrintMatlab", (PyCFunction)(void(*)(void))_wrap_OperatorHandle_PrintMatlab, METH_VARARGS|METH_KEYWORDS, "PrintMatlab(OperatorHandle self, std::ostream & out, int n=0, int m=0)"}, { "OperatorHandle_GetType", _wrap_OperatorHandle_GetType, METH_O, "GetType(OperatorHandle self) -> mfem::Operator::Type"}, { "OperatorHandle_swigregister", OperatorHandle_swigregister, METH_O, NULL}, { "OperatorHandle_swiginit", OperatorHandle_swiginit, METH_VARARGS, NULL}, @@ -7508,9 +6999,9 @@ SWIG_init(void) { SWIG_Python_SetConstant(d, "MFEM_VERSION_MAJOR",SWIG_From_int(static_cast< int >(((40100)/10000)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_MINOR",SWIG_From_int(static_cast< int >((((40100)/100)%100)))); SWIG_Python_SetConstant(d, "MFEM_VERSION_PATCH",SWIG_From_int(static_cast< int >(((40100)%100)))); - SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/src/mfem")); - SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/p/rf/sshiraiw/twopi_roots/20200327/mfem/ser")); - SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(2))); + SWIG_Python_SetConstant(d, "MFEM_SOURCE_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/src/mfem")); + SWIG_Python_SetConstant(d, "MFEM_INSTALL_DIR",SWIG_FromCharPtr("/usr/local/Cellar/twopi/0.9.2/mfem/ser")); + SWIG_Python_SetConstant(d, "MFEM_TIMER_TYPE",SWIG_From_int(static_cast< int >(4))); import_array(); diff --git a/mfem/_ser/hash_wrap.cxx b/mfem/_ser/hash_wrap.cxx index edf4b001..6cab7bc7 100644 --- a/mfem/_ser/hash_wrap.cxx +++ b/mfem/_ser/hash_wrap.cxx @@ -3292,7 +3292,7 @@ SWIGINTERN PyObject *Hashed4_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject * return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -3303,10 +3303,15 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "sort3", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:sort3", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort3" "', argument " "1"" of type '" "int &""'"); } @@ -3314,7 +3319,7 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort3" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort3" "', argument " "2"" of type '" "int &""'"); } @@ -3322,7 +3327,7 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort3" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort3" "', argument " "3"" of type '" "int &""'"); } @@ -3353,7 +3358,7 @@ SWIGINTERN PyObject *_wrap_sort3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -3367,10 +3372,16 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "sort4", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:sort4", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort4" "', argument " "1"" of type '" "int &""'"); } @@ -3378,7 +3389,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort4" "', argument " "2"" of type '" "int &""'"); } @@ -3386,7 +3397,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort4" "', argument " "3"" of type '" "int &""'"); } @@ -3394,7 +3405,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4" "', argument " "3"" of type '" "int &""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sort4" "', argument " "4"" of type '" "int &""'"); } @@ -3425,7 +3436,7 @@ SWIGINTERN PyObject *_wrap_sort4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -3439,10 +3450,16 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "sort4_ext", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:sort4_ext", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); } @@ -3450,7 +3467,7 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); } @@ -3458,7 +3475,7 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); } @@ -3466,7 +3483,7 @@ SWIGINTERN PyObject *_wrap_sort4_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *a SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sort4_ext" "', argument " "3"" of type '" "int &""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "sort4_ext" "', argument " "4"" of type '" "int &""'"); } @@ -3522,9 +3539,9 @@ static PyMethodDef SwigMethods[] = { { "delete_Hashed4", _wrap_delete_Hashed4, METH_O, "delete_Hashed4(Hashed4 self)"}, { "Hashed4_swigregister", Hashed4_swigregister, METH_O, NULL}, { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, - { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, - { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, - { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, + { "sort3", (PyCFunction)(void(*)(void))_wrap_sort3, METH_VARARGS|METH_KEYWORDS, "sort3(int & a, int & b, int & c)"}, + { "sort4", (PyCFunction)(void(*)(void))_wrap_sort4, METH_VARARGS|METH_KEYWORDS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", (PyCFunction)(void(*)(void))_wrap_sort4_ext, METH_VARARGS|METH_KEYWORDS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; @@ -3553,9 +3570,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_Hashed4", _wrap_delete_Hashed4, METH_O, "delete_Hashed4(Hashed4 self)"}, { "Hashed4_swigregister", Hashed4_swigregister, METH_O, NULL}, { "Hashed4_swiginit", Hashed4_swiginit, METH_VARARGS, NULL}, - { "sort3", _wrap_sort3, METH_VARARGS, "sort3(int & a, int & b, int & c)"}, - { "sort4", _wrap_sort4, METH_VARARGS, "sort4(int & a, int & b, int & c, int & d)"}, - { "sort4_ext", _wrap_sort4_ext, METH_VARARGS, "sort4_ext(int & a, int & b, int & c, int & d)"}, + { "sort3", (PyCFunction)(void(*)(void))_wrap_sort3, METH_VARARGS|METH_KEYWORDS, "sort3(int & a, int & b, int & c)"}, + { "sort4", (PyCFunction)(void(*)(void))_wrap_sort4, METH_VARARGS|METH_KEYWORDS, "sort4(int & a, int & b, int & c, int & d)"}, + { "sort4_ext", (PyCFunction)(void(*)(void))_wrap_sort4_ext, METH_VARARGS|METH_KEYWORDS, "sort4_ext(int & a, int & b, int & c, int & d)"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/hybridization_wrap.cxx b/mfem/_ser/hybridization_wrap.cxx index 32620cc5..7011113a 100644 --- a/mfem/_ser/hybridization_wrap.cxx +++ b/mfem/_ser/hybridization_wrap.cxx @@ -3287,7 +3287,7 @@ namespace swig { #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_Hybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Hybridization(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; @@ -3295,16 +3295,20 @@ SWIGINTERN PyObject *_wrap_new_Hybridization(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"fespace", (char *)"c_fespace", NULL + }; mfem::Hybridization *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_Hybridization", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_Hybridization", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Hybridization" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Hybridization" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -3375,7 +3379,7 @@ SWIGINTERN PyObject *_wrap_delete_Hybridization(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::BilinearFormIntegrator *arg2 = (mfem::BilinearFormIntegrator *) 0 ; @@ -3383,15 +3387,19 @@ SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c_integ", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_SetConstraintIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Hybridization_SetConstraintIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_SetConstraintIntegrator" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BilinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_SetConstraintIntegrator" "', argument " "2"" of type '" "mfem::BilinearFormIntegrator *""'"); } @@ -3422,7 +3430,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_SetConstraintIntegrator(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -3430,15 +3438,19 @@ SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Hybridization_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_Init" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_Init" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -3472,7 +3484,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; int arg2 ; @@ -3481,21 +3493,26 @@ SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_AssembleMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Hybridization_AssembleMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_AssembleMatrix" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_AssembleMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -3529,7 +3546,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_AssembleMatrix(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Hybridization_AssembleBdrMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_AssembleBdrMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; int arg2 ; @@ -3538,21 +3555,26 @@ SWIGINTERN PyObject *_wrap_Hybridization_AssembleBdrMatrix(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_el", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_AssembleBdrMatrix", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Hybridization_AssembleBdrMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_AssembleBdrMatrix" "', argument " "1"" of type '" "mfem::Hybridization *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_AssembleBdrMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -3667,7 +3689,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_GetMatrix(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3678,15 +3700,20 @@ SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"b_r", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_ReduceRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Hybridization_ReduceRHS", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_ReduceRHS" "', argument " "1"" of type '" "mfem::Hybridization const *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_ReduceRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3694,7 +3721,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hybridization_ReduceRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_ReduceRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3728,7 +3755,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ReduceRHS(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Hybridization *arg1 = (mfem::Hybridization *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3742,15 +3769,21 @@ SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPAR int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"sol_r", (char *)"sol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Hybridization_ComputeSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Hybridization_ComputeSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Hybridization, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Hybridization_ComputeSolution" "', argument " "1"" of type '" "mfem::Hybridization const *""'"); } arg1 = reinterpret_cast< mfem::Hybridization * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Hybridization_ComputeSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3758,7 +3791,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hybridization_ComputeSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Hybridization_ComputeSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -3766,7 +3799,7 @@ SWIGINTERN PyObject *_wrap_Hybridization_ComputeSolution(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Hybridization_ComputeSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Hybridization_ComputeSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -3854,16 +3887,16 @@ SWIGINTERN PyObject *Hybridization_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, + { "new_Hybridization", (PyCFunction)(void(*)(void))_wrap_new_Hybridization, METH_VARARGS|METH_KEYWORDS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, - { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "Hybridization_SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, - { "Hybridization_Init", _wrap_Hybridization_Init, METH_VARARGS, "Hybridization_Init(Hybridization self, intArray ess_tdof_list)"}, - { "Hybridization_AssembleMatrix", _wrap_Hybridization_AssembleMatrix, METH_VARARGS, "Hybridization_AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, - { "Hybridization_AssembleBdrMatrix", _wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS, "Hybridization_AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, + { "Hybridization_SetConstraintIntegrator", (PyCFunction)(void(*)(void))_wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS|METH_KEYWORDS, "Hybridization_SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, + { "Hybridization_Init", (PyCFunction)(void(*)(void))_wrap_Hybridization_Init, METH_VARARGS|METH_KEYWORDS, "Hybridization_Init(Hybridization self, intArray ess_tdof_list)"}, + { "Hybridization_AssembleMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleMatrix, METH_VARARGS|METH_KEYWORDS, "Hybridization_AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, + { "Hybridization_AssembleBdrMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS|METH_KEYWORDS, "Hybridization_AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, { "Hybridization_Finalize", _wrap_Hybridization_Finalize, METH_O, "Hybridization_Finalize(Hybridization self)"}, { "Hybridization_GetMatrix", _wrap_Hybridization_GetMatrix, METH_O, "Hybridization_GetMatrix(Hybridization self) -> SparseMatrix"}, - { "Hybridization_ReduceRHS", _wrap_Hybridization_ReduceRHS, METH_VARARGS, "Hybridization_ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, - { "Hybridization_ComputeSolution", _wrap_Hybridization_ComputeSolution, METH_VARARGS, "Hybridization_ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, + { "Hybridization_ReduceRHS", (PyCFunction)(void(*)(void))_wrap_Hybridization_ReduceRHS, METH_VARARGS|METH_KEYWORDS, "Hybridization_ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, + { "Hybridization_ComputeSolution", (PyCFunction)(void(*)(void))_wrap_Hybridization_ComputeSolution, METH_VARARGS|METH_KEYWORDS, "Hybridization_ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, { "Hybridization_Reset", _wrap_Hybridization_Reset, METH_O, "Hybridization_Reset(Hybridization self)"}, { "Hybridization_swigregister", Hybridization_swigregister, METH_O, NULL}, { "Hybridization_swiginit", Hybridization_swiginit, METH_VARARGS, NULL}, @@ -3873,16 +3906,16 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_Hybridization", _wrap_new_Hybridization, METH_VARARGS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, + { "new_Hybridization", (PyCFunction)(void(*)(void))_wrap_new_Hybridization, METH_VARARGS|METH_KEYWORDS, "new_Hybridization(FiniteElementSpace fespace, FiniteElementSpace c_fespace) -> Hybridization"}, { "delete_Hybridization", _wrap_delete_Hybridization, METH_O, "delete_Hybridization(Hybridization self)"}, - { "Hybridization_SetConstraintIntegrator", _wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS, "SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, - { "Hybridization_Init", _wrap_Hybridization_Init, METH_VARARGS, "Init(Hybridization self, intArray ess_tdof_list)"}, - { "Hybridization_AssembleMatrix", _wrap_Hybridization_AssembleMatrix, METH_VARARGS, "AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, - { "Hybridization_AssembleBdrMatrix", _wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS, "AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, + { "Hybridization_SetConstraintIntegrator", (PyCFunction)(void(*)(void))_wrap_Hybridization_SetConstraintIntegrator, METH_VARARGS|METH_KEYWORDS, "SetConstraintIntegrator(Hybridization self, BilinearFormIntegrator c_integ)"}, + { "Hybridization_Init", (PyCFunction)(void(*)(void))_wrap_Hybridization_Init, METH_VARARGS|METH_KEYWORDS, "Init(Hybridization self, intArray ess_tdof_list)"}, + { "Hybridization_AssembleMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleMatrix(Hybridization self, int el, DenseMatrix A)"}, + { "Hybridization_AssembleBdrMatrix", (PyCFunction)(void(*)(void))_wrap_Hybridization_AssembleBdrMatrix, METH_VARARGS|METH_KEYWORDS, "AssembleBdrMatrix(Hybridization self, int bdr_el, DenseMatrix A)"}, { "Hybridization_Finalize", _wrap_Hybridization_Finalize, METH_O, "Finalize(Hybridization self)"}, { "Hybridization_GetMatrix", _wrap_Hybridization_GetMatrix, METH_O, "GetMatrix(Hybridization self) -> SparseMatrix"}, - { "Hybridization_ReduceRHS", _wrap_Hybridization_ReduceRHS, METH_VARARGS, "ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, - { "Hybridization_ComputeSolution", _wrap_Hybridization_ComputeSolution, METH_VARARGS, "ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, + { "Hybridization_ReduceRHS", (PyCFunction)(void(*)(void))_wrap_Hybridization_ReduceRHS, METH_VARARGS|METH_KEYWORDS, "ReduceRHS(Hybridization self, Vector b, Vector b_r)"}, + { "Hybridization_ComputeSolution", (PyCFunction)(void(*)(void))_wrap_Hybridization_ComputeSolution, METH_VARARGS|METH_KEYWORDS, "ComputeSolution(Hybridization self, Vector b, Vector sol_r, Vector sol)"}, { "Hybridization_Reset", _wrap_Hybridization_Reset, METH_O, "Reset(Hybridization self)"}, { "Hybridization_swigregister", Hybridization_swigregister, METH_O, NULL}, { "Hybridization_swiginit", Hybridization_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/intrules.py b/mfem/_ser/intrules.py index fd76756c..b5f89711 100644 --- a/mfem/_ser/intrules.py +++ b/mfem/_ser/intrules.py @@ -500,9 +500,9 @@ class IntegrationRules(object): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(IntegrationRules self, int Ref=0, int type=GaussLegendre) -> IntegrationRules""" - _intrules.IntegrationRules_swiginit(self, _intrules.new_IntegrationRules(*args)) + _intrules.IntegrationRules_swiginit(self, _intrules.new_IntegrationRules(*args, **kwargs)) def Get(self, GeomType, Order): r"""Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule""" diff --git a/mfem/_ser/intrules_wrap.cxx b/mfem/_ser/intrules_wrap.cxx index 751a9430..5df2be11 100644 --- a/mfem/_ser/intrules_wrap.cxx +++ b/mfem/_ser/intrules_wrap.cxx @@ -3556,7 +3556,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_OwnsData(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_StealData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; mfem::IntegrationPoint **arg2 = (mfem::IntegrationPoint **) 0 ; @@ -3564,15 +3564,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_StealData(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_StealData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_StealData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_StealData" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_p_mfem__IntegrationPoint, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPointArray_StealData" "', argument " "2"" of type '" "mfem::IntegrationPoint **""'"); } @@ -3972,7 +3976,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Capacity(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Reserve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -3980,15 +3984,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Reserve(PyObject *SWIGUNUSEDPAR int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"capacity", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Reserve", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_Reserve", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Reserve" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Reserve" "', argument " "2"" of type '" "int""'"); } @@ -4227,7 +4235,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Append(PyObject *self, PyObject } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; mfem::IntegrationPoint *arg2 = 0 ; @@ -4235,16 +4243,20 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Prepend(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Prepend", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_Prepend", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Prepend" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPointArray_Prepend" "', argument " "2"" of type '" "mfem::IntegrationPoint const &""'"); } @@ -4457,7 +4469,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_DeleteAll(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; mfem::Array< mfem::IntegrationPoint > *arg2 = 0 ; @@ -4465,15 +4477,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Copy(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Copy" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPointArray_Copy" "', argument " "2"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); } @@ -4652,7 +4668,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_MakeRef(PyObject *self, PyObjec } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_GetSubArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -4666,25 +4682,31 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_GetSubArray(PyObject *SWIGUNUSE int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"offset", (char *)"sa_size", (char *)"sa", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray_GetSubArray", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IntegrationPointArray_GetSubArray", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntegrationPointArray_GetSubArray" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); } @@ -5012,66 +5034,37 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_MemoryUsage(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; mfem::IntegrationPoint *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:IntegrationPointArray_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Read" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::IntegrationPoint *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Read" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); { try { - result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->Read(); + result = (mfem::IntegrationPoint *)((mfem::Array< mfem::IntegrationPoint > const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5092,48 +5085,6 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_IntegrationPointArray_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_IntegrationPointArray_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::Read(bool) const\n" - " mfem::Array< mfem::IntegrationPoint >::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5172,66 +5123,37 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostRead(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; mfem::IntegrationPoint *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:IntegrationPointArray_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Write" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::IntegrationPoint *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::IntegrationPoint *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_Write" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); { try { - result = (mfem::IntegrationPoint *)(arg1)->Write(); + result = (mfem::IntegrationPoint *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5252,48 +5174,6 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_IntegrationPointArray_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_IntegrationPointArray_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::Write(bool)\n" - " mfem::Array< mfem::IntegrationPoint >::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5332,66 +5212,37 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostWrite(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; mfem::IntegrationPoint *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:IntegrationPointArray_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::IntegrationPoint *)(arg1)->ReadWrite(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::IntegrationPoint *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); { try { - result = (mfem::IntegrationPoint *)(arg1)->ReadWrite(); + result = (mfem::IntegrationPoint *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5412,48 +5263,6 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_IntegrationPointArray_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "IntegrationPointArray_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_IntegrationPointArray_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_IntegrationPointArray_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntegrationPointArray_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Array< mfem::IntegrationPoint >::ReadWrite(bool)\n" - " mfem::Array< mfem::IntegrationPoint >::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; @@ -5492,7 +5301,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray_HostReadWrite(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -5503,21 +5312,26 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSE int ecode2 = 0 ; void *argp3 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegrationPointArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray___setitem__" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray___setitem__" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntegrationPointArray___setitem__" "', argument " "3"" of type '" "mfem::IntegrationPoint const""'"); } @@ -5552,7 +5366,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray___setitem__(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_IntegrationPointArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPointArray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< mfem::IntegrationPoint > *arg1 = (mfem::Array< mfem::IntegrationPoint > *) 0 ; int arg2 ; @@ -5560,16 +5374,20 @@ SWIGINTERN PyObject *_wrap_IntegrationPointArray___getitem__(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; mfem::IntegrationPoint *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPointArray___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPointArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPointArray___getitem__" "', argument " "1"" of type '" "mfem::Array< mfem::IntegrationPoint > const *""'"); } arg1 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPointArray___getitem__" "', argument " "2"" of type '" "int""'"); } @@ -5996,7 +5814,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_index_get(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; int arg2 ; @@ -6004,15 +5822,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Init(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPoint_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Init" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationPoint_Init" "', argument " "2"" of type '" "int""'"); } @@ -6091,7 +5913,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Set__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; double *arg2 = (double *) 0 ; @@ -6102,20 +5924,25 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Get(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", (char *)"dim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Get", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegrationPoint_Get", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Get" "', argument " "1"" of type '" "mfem::IntegrationPoint const *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPoint_Get" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationPoint_Get" "', argument " "3"" of type '" "int""'"); } @@ -6281,7 +6108,7 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Set(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_IntegrationPoint_Set3w(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationPoint_Set3w(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationPoint *arg1 = (mfem::IntegrationPoint *) 0 ; double *arg2 = (double *) 0 ; @@ -6289,15 +6116,19 @@ SWIGINTERN PyObject *_wrap_IntegrationPoint_Set3w(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationPoint_Set3w", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationPoint_Set3w", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationPoint, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationPoint_Set3w" "', argument " "1"" of type '" "mfem::IntegrationPoint *""'"); } arg1 = reinterpret_cast< mfem::IntegrationPoint * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegrationPoint_Set3w" "', argument " "2"" of type '" "double const *""'"); } @@ -7296,7 +7127,7 @@ SWIGINTERN PyObject *_wrap_IntegrationRule_GetOrder(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_IntegrationRule_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRule_SetOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRule *arg1 = (mfem::IntegrationRule *) 0 ; int arg2 ; @@ -7304,15 +7135,19 @@ SWIGINTERN PyObject *_wrap_IntegrationRule_SetOrder(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"order", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRule_SetOrder", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationRule_SetOrder", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRule_SetOrder" "', argument " "1"" of type '" "mfem::IntegrationRule *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRule * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRule_SetOrder" "', argument " "2"" of type '" "int""'"); } @@ -7600,7 +7435,7 @@ SWIGINTERN PyObject *IntegrationRule_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7611,20 +7446,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNU int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_GaussLegendre", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_GaussLegendre", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_GaussLegendre" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_GaussLegendre" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_GaussLegendre" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7652,7 +7492,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLegendre(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7663,20 +7503,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUS int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_GaussLobatto", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_GaussLobatto", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_GaussLobatto" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_GaussLobatto" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_GaussLobatto" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7704,7 +7549,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GaussLobatto(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7715,20 +7560,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSE int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_OpenUniform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_OpenUniform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_OpenUniform" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_OpenUniform" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_OpenUniform" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7756,7 +7606,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenUniform(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7767,20 +7617,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNU int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_ClosedUniform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_ClosedUniform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_ClosedUniform" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_ClosedUniform" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_ClosedUniform" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7808,7 +7663,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_ClosedUniform(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7819,20 +7674,25 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGU int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_OpenHalfUniform", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:QuadratureFunctions1D_OpenHalfUniform", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_OpenHalfUniform" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_OpenHalfUniform" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_OpenHalfUniform" "', argument " "3"" of type '" "mfem::IntegrationRule *""'"); } @@ -7860,7 +7720,7 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_OpenHalfUniform(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GivePolyPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GivePolyPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::QuadratureFunctions1D *arg1 = (mfem::QuadratureFunctions1D *) 0 ; int arg2 ; @@ -7874,25 +7734,31 @@ SWIGINTERN PyObject *_wrap_QuadratureFunctions1D_GivePolyPoints(PyObject *SWIGUN int res3 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"np", (char *)"pts", (char *)"type", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "QuadratureFunctions1D_GivePolyPoints", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:QuadratureFunctions1D_GivePolyPoints", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__QuadratureFunctions1D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "1"" of type '" "mfem::QuadratureFunctions1D *""'"); } arg1 = reinterpret_cast< mfem::QuadratureFunctions1D * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "3"" of type '" "double *""'"); } arg3 = reinterpret_cast< double * >(argp3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "QuadratureFunctions1D_GivePolyPoints" "', argument " "4"" of type '" "int""'"); } @@ -7996,17 +7862,19 @@ SWIGINTERN PyObject *QuadratureFunctions1D_swiginit(PyObject *SWIGUNUSEDPARM(sel return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_Quadrature1D_CheckClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadrature1D_CheckClosed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Quadrature1D_CheckClosed", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Quadrature1D_CheckClosed" "', argument " "1"" of type '" "int""'"); } @@ -8034,17 +7902,19 @@ SWIGINTERN PyObject *_wrap_Quadrature1D_CheckClosed(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Quadrature1D_CheckOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Quadrature1D_CheckOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"type", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Quadrature1D_CheckOpen", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Quadrature1D_CheckOpen" "', argument " "1"" of type '" "int""'"); } @@ -8148,94 +8018,39 @@ SWIGINTERN PyObject *Quadrature1D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_IntegrationRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + int arg1 = (int) 0 ; + int arg2 = (int) mfem::Quadrature1D::GaussLegendre ; int val1 ; int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"Ref", (char *)"type", NULL + }; mfem::IntegrationRules *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationRules" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntegrationRules" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - { - try { - result = (mfem::IntegrationRules *)new mfem::IntegrationRules(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_IntegrationRules", kwnames, &obj0, &obj1)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationRules" "', argument " "1"" of type '" "int""'"); + } + arg1 = static_cast< int >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRules, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int val1 ; - int ecode1 = 0 ; - mfem::IntegrationRules *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntegrationRules" "', argument " "1"" of type '" "int""'"); - } - arg1 = static_cast< int >(val1); - { - try { - result = (mfem::IntegrationRules *)new mfem::IntegrationRules(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (obj1) { + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntegrationRules" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__IntegrationRules, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::IntegrationRules *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::IntegrationRules *)new mfem::IntegrationRules(); + result = (mfem::IntegrationRules *)new mfem::IntegrationRules(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8256,55 +8071,7 @@ SWIGINTERN PyObject *_wrap_new_IntegrationRules__SWIG_2(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_new_IntegrationRules(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntegrationRules", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_IntegrationRules__SWIG_2(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_IntegrationRules__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_int(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_IntegrationRules__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntegrationRules'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::IntegrationRules::IntegrationRules(int,int)\n" - " mfem::IntegrationRules::IntegrationRules(int)\n" - " mfem::IntegrationRules::IntegrationRules()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRules *arg1 = (mfem::IntegrationRules *) 0 ; int arg2 ; @@ -8315,21 +8082,26 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Order", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRules_Get", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegrationRules_Get", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRules_Get" "', argument " "1"" of type '" "mfem::IntegrationRules *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRules * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRules_Get" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationRules_Get" "', argument " "3"" of type '" "int""'"); } @@ -8357,7 +8129,7 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Get(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRules *arg1 = (mfem::IntegrationRules *) 0 ; int arg2 ; @@ -8371,25 +8143,31 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), int ecode3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"GeomType", (char *)"Order", (char *)"IntRule", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRules_Set", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IntegrationRules_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRules_Set" "', argument " "1"" of type '" "mfem::IntegrationRules *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRules * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRules_Set" "', argument " "2"" of type '" "int""'"); } arg2 = static_cast< int >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntegrationRules_Set" "', argument " "3"" of type '" "int""'"); } arg3 = static_cast< int >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IntegrationRule, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntegrationRules_Set" "', argument " "4"" of type '" "mfem::IntegrationRule &""'"); } @@ -8420,7 +8198,7 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_Set(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IntegrationRules_SetOwnRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegrationRules_SetOwnRules(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegrationRules *arg1 = (mfem::IntegrationRules *) 0 ; int arg2 ; @@ -8428,15 +8206,19 @@ SWIGINTERN PyObject *_wrap_IntegrationRules_SetOwnRules(PyObject *SWIGUNUSEDPARM int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"o", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegrationRules_SetOwnRules", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegrationRules_SetOwnRules", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegrationRules, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegrationRules_SetOwnRules" "', argument " "1"" of type '" "mfem::IntegrationRules *""'"); } arg1 = reinterpret_cast< mfem::IntegrationRules * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntegrationRules_SetOwnRules" "', argument " "2"" of type '" "int""'"); } @@ -8561,7 +8343,7 @@ static PyMethodDef SwigMethods[] = { ""}, { "IntegrationPointArray_UseDevice", _wrap_IntegrationPointArray_UseDevice, METH_O, "IntegrationPointArray_UseDevice(IntegrationPointArray self) -> bool"}, { "IntegrationPointArray_OwnsData", _wrap_IntegrationPointArray_OwnsData, METH_O, "IntegrationPointArray_OwnsData(IntegrationPointArray self) -> bool"}, - { "IntegrationPointArray_StealData", _wrap_IntegrationPointArray_StealData, METH_VARARGS, "IntegrationPointArray_StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, + { "IntegrationPointArray_StealData", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_StealData, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, { "IntegrationPointArray_LoseData", _wrap_IntegrationPointArray_LoseData, METH_O, "IntegrationPointArray_LoseData(IntegrationPointArray self)"}, { "IntegrationPointArray_MakeDataOwner", _wrap_IntegrationPointArray_MakeDataOwner, METH_O, "IntegrationPointArray_MakeDataOwner(IntegrationPointArray self)"}, { "IntegrationPointArray_Size", _wrap_IntegrationPointArray_Size, METH_O, "IntegrationPointArray_Size(IntegrationPointArray self) -> int"}, @@ -8571,25 +8353,25 @@ static PyMethodDef SwigMethods[] = { "IntegrationPointArray_SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "IntegrationPointArray_Capacity", _wrap_IntegrationPointArray_Capacity, METH_O, "IntegrationPointArray_Capacity(IntegrationPointArray self) -> int"}, - { "IntegrationPointArray_Reserve", _wrap_IntegrationPointArray_Reserve, METH_VARARGS, "IntegrationPointArray_Reserve(IntegrationPointArray self, int capacity)"}, + { "IntegrationPointArray_Reserve", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Reserve, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Reserve(IntegrationPointArray self, int capacity)"}, { "IntegrationPointArray_Append", _wrap_IntegrationPointArray_Append, METH_VARARGS, "\n" "IntegrationPointArray_Append(IntegrationPointArray self, IntegrationPoint el) -> int\n" "IntegrationPointArray_Append(IntegrationPointArray self, IntegrationPoint els, int nels) -> int\n" "IntegrationPointArray_Append(IntegrationPointArray self, IntegrationPointArray els) -> int\n" ""}, - { "IntegrationPointArray_Prepend", _wrap_IntegrationPointArray_Prepend, METH_VARARGS, "IntegrationPointArray_Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, + { "IntegrationPointArray_Prepend", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Prepend, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, { "IntegrationPointArray_Last", _wrap_IntegrationPointArray_Last, METH_VARARGS, "\n" "IntegrationPointArray_Last(IntegrationPointArray self) -> IntegrationPoint\n" "IntegrationPointArray_Last(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_DeleteLast", _wrap_IntegrationPointArray_DeleteLast, METH_O, "IntegrationPointArray_DeleteLast(IntegrationPointArray self)"}, { "IntegrationPointArray_DeleteAll", _wrap_IntegrationPointArray_DeleteAll, METH_O, "IntegrationPointArray_DeleteAll(IntegrationPointArray self)"}, - { "IntegrationPointArray_Copy", _wrap_IntegrationPointArray_Copy, METH_VARARGS, "IntegrationPointArray_Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, + { "IntegrationPointArray_Copy", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Copy, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, { "IntegrationPointArray_MakeRef", _wrap_IntegrationPointArray_MakeRef, METH_VARARGS, "\n" "IntegrationPointArray_MakeRef(IntegrationPointArray self, IntegrationPoint arg2, int arg3)\n" "IntegrationPointArray_MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" ""}, - { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "IntegrationPointArray_GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, + { "IntegrationPointArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" "IntegrationPointArray_begin(IntegrationPointArray self) -> IntegrationPoint\n" @@ -8599,14 +8381,14 @@ static PyMethodDef SwigMethods[] = { "IntegrationPointArray_end(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "IntegrationPointArray_MemoryUsage(IntegrationPointArray self) -> long"}, - { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "IntegrationPointArray_Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Read", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Read, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "IntegrationPointArray_HostRead(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_Write", _wrap_IntegrationPointArray_Write, METH_VARARGS, "IntegrationPointArray_Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Write", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Write, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostWrite", _wrap_IntegrationPointArray_HostWrite, METH_O, "IntegrationPointArray_HostWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_ReadWrite", _wrap_IntegrationPointArray_ReadWrite, METH_VARARGS, "IntegrationPointArray_ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray_ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostReadWrite", _wrap_IntegrationPointArray_HostReadWrite, METH_O, "IntegrationPointArray_HostReadWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray___setitem__", _wrap_IntegrationPointArray___setitem__, METH_VARARGS, "IntegrationPointArray___setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, - { "IntegrationPointArray___getitem__", _wrap_IntegrationPointArray___getitem__, METH_VARARGS, "IntegrationPointArray___getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, + { "IntegrationPointArray___setitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___setitem__, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray___setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, + { "IntegrationPointArray___getitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___getitem__, METH_VARARGS|METH_KEYWORDS, "IntegrationPointArray___getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, { "IntegrationPointArray_Assign", _wrap_IntegrationPointArray_Assign, METH_VARARGS, "\n" "IntegrationPointArray_Assign(IntegrationPointArray self, IntegrationPoint arg2)\n" "IntegrationPointArray_Assign(IntegrationPointArray self, IntegrationPoint a)\n" @@ -8624,13 +8406,13 @@ static PyMethodDef SwigMethods[] = { { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, - { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "IntegrationPoint_Init(IntegrationPoint self, int const i)"}, - { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "IntegrationPoint_Get(IntegrationPoint self, double * p, int const dim)"}, + { "IntegrationPoint_Init", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Init, METH_VARARGS|METH_KEYWORDS, "IntegrationPoint_Init(IntegrationPoint self, int const i)"}, + { "IntegrationPoint_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Get, METH_VARARGS|METH_KEYWORDS, "IntegrationPoint_Get(IntegrationPoint self, double * p, int const dim)"}, { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" "IntegrationPoint_Set(IntegrationPoint self, double const * p, int const dim)\n" "IntegrationPoint_Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w)\n" ""}, - { "IntegrationPoint_Set3w", _wrap_IntegrationPoint_Set3w, METH_VARARGS, "IntegrationPoint_Set3w(IntegrationPoint self, double const * p)"}, + { "IntegrationPoint_Set3w", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Set3w, METH_VARARGS|METH_KEYWORDS, "IntegrationPoint_Set3w(IntegrationPoint self, double const * p)"}, { "IntegrationPoint_Set3", _wrap_IntegrationPoint_Set3, METH_VARARGS, "\n" "IntegrationPoint_Set3(IntegrationPoint self, double const x1, double const x2, double const x3)\n" "IntegrationPoint_Set3(IntegrationPoint self, double const * p)\n" @@ -8658,7 +8440,7 @@ static PyMethodDef SwigMethods[] = { "new_IntegrationRule(IntegrationRule irx, IntegrationRule iry, IntegrationRule irz) -> IntegrationRule\n" ""}, { "IntegrationRule_GetOrder", _wrap_IntegrationRule_GetOrder, METH_O, "IntegrationRule_GetOrder(IntegrationRule self) -> int"}, - { "IntegrationRule_SetOrder", _wrap_IntegrationRule_SetOrder, METH_VARARGS, "IntegrationRule_SetOrder(IntegrationRule self, int const order)"}, + { "IntegrationRule_SetOrder", (PyCFunction)(void(*)(void))_wrap_IntegrationRule_SetOrder, METH_VARARGS|METH_KEYWORDS, "IntegrationRule_SetOrder(IntegrationRule self, int const order)"}, { "IntegrationRule_GetNPoints", _wrap_IntegrationRule_GetNPoints, METH_O, "IntegrationRule_GetNPoints(IntegrationRule self) -> int"}, { "IntegrationRule_IntPoint", _wrap_IntegrationRule_IntPoint, METH_VARARGS, "\n" "IntegrationRule_IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" @@ -8668,26 +8450,26 @@ static PyMethodDef SwigMethods[] = { { "delete_IntegrationRule", _wrap_delete_IntegrationRule, METH_O, "delete_IntegrationRule(IntegrationRule self)"}, { "IntegrationRule_swigregister", IntegrationRule_swigregister, METH_O, NULL}, { "IntegrationRule_swiginit", IntegrationRule_swiginit, METH_VARARGS, NULL}, - { "QuadratureFunctions1D_GaussLegendre", _wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS, "QuadratureFunctions1D_GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GaussLobatto", _wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS, "QuadratureFunctions1D_GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenUniform", _wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS, "QuadratureFunctions1D_OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_ClosedUniform", _wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS, "QuadratureFunctions1D_ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenHalfUniform", _wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS, "QuadratureFunctions1D_OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GivePolyPoints", _wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS, "QuadratureFunctions1D_GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, + { "QuadratureFunctions1D_GaussLegendre", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GaussLobatto", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_ClosedUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenHalfUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GivePolyPoints", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS|METH_KEYWORDS, "QuadratureFunctions1D_GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, { "new_QuadratureFunctions1D", _wrap_new_QuadratureFunctions1D, METH_NOARGS, "new_QuadratureFunctions1D() -> QuadratureFunctions1D"}, { "delete_QuadratureFunctions1D", _wrap_delete_QuadratureFunctions1D, METH_O, "delete_QuadratureFunctions1D(QuadratureFunctions1D self)"}, { "QuadratureFunctions1D_swigregister", QuadratureFunctions1D_swigregister, METH_O, NULL}, { "QuadratureFunctions1D_swiginit", QuadratureFunctions1D_swiginit, METH_VARARGS, NULL}, - { "Quadrature1D_CheckClosed", _wrap_Quadrature1D_CheckClosed, METH_O, "Quadrature1D_CheckClosed(int type) -> int"}, - { "Quadrature1D_CheckOpen", _wrap_Quadrature1D_CheckOpen, METH_O, "Quadrature1D_CheckOpen(int type) -> int"}, + { "Quadrature1D_CheckClosed", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckClosed, METH_VARARGS|METH_KEYWORDS, "Quadrature1D_CheckClosed(int type) -> int"}, + { "Quadrature1D_CheckOpen", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckOpen, METH_VARARGS|METH_KEYWORDS, "Quadrature1D_CheckOpen(int type) -> int"}, { "new_Quadrature1D", _wrap_new_Quadrature1D, METH_NOARGS, "new_Quadrature1D() -> Quadrature1D"}, { "delete_Quadrature1D", _wrap_delete_Quadrature1D, METH_O, "delete_Quadrature1D(Quadrature1D self)"}, { "Quadrature1D_swigregister", Quadrature1D_swigregister, METH_O, NULL}, { "Quadrature1D_swiginit", Quadrature1D_swiginit, METH_VARARGS, NULL}, - { "new_IntegrationRules", _wrap_new_IntegrationRules, METH_VARARGS, "IntegrationRules(int Ref=0, int type=GaussLegendre)"}, - { "IntegrationRules_Get", _wrap_IntegrationRules_Get, METH_VARARGS, "IntegrationRules_Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, - { "IntegrationRules_Set", _wrap_IntegrationRules_Set, METH_VARARGS, "IntegrationRules_Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, - { "IntegrationRules_SetOwnRules", _wrap_IntegrationRules_SetOwnRules, METH_VARARGS, "IntegrationRules_SetOwnRules(IntegrationRules self, int o)"}, + { "new_IntegrationRules", (PyCFunction)(void(*)(void))_wrap_new_IntegrationRules, METH_VARARGS|METH_KEYWORDS, "new_IntegrationRules(int Ref=0, int type=GaussLegendre) -> IntegrationRules"}, + { "IntegrationRules_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Get, METH_VARARGS|METH_KEYWORDS, "IntegrationRules_Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, + { "IntegrationRules_Set", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Set, METH_VARARGS|METH_KEYWORDS, "IntegrationRules_Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, + { "IntegrationRules_SetOwnRules", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_SetOwnRules, METH_VARARGS|METH_KEYWORDS, "IntegrationRules_SetOwnRules(IntegrationRules self, int o)"}, { "delete_IntegrationRules", _wrap_delete_IntegrationRules, METH_O, "delete_IntegrationRules(IntegrationRules self)"}, { "IntegrationRules_swigregister", IntegrationRules_swigregister, METH_O, NULL}, { "IntegrationRules_swiginit", IntegrationRules_swiginit, METH_VARARGS, NULL}, @@ -8715,7 +8497,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "IntegrationPointArray_UseDevice", _wrap_IntegrationPointArray_UseDevice, METH_O, "UseDevice(IntegrationPointArray self) -> bool"}, { "IntegrationPointArray_OwnsData", _wrap_IntegrationPointArray_OwnsData, METH_O, "OwnsData(IntegrationPointArray self) -> bool"}, - { "IntegrationPointArray_StealData", _wrap_IntegrationPointArray_StealData, METH_VARARGS, "StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, + { "IntegrationPointArray_StealData", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_StealData, METH_VARARGS|METH_KEYWORDS, "StealData(IntegrationPointArray self, mfem::IntegrationPoint ** p)"}, { "IntegrationPointArray_LoseData", _wrap_IntegrationPointArray_LoseData, METH_O, "LoseData(IntegrationPointArray self)"}, { "IntegrationPointArray_MakeDataOwner", _wrap_IntegrationPointArray_MakeDataOwner, METH_O, "MakeDataOwner(IntegrationPointArray self)"}, { "IntegrationPointArray_Size", _wrap_IntegrationPointArray_Size, METH_O, "Size(IntegrationPointArray self) -> int"}, @@ -8725,25 +8507,25 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(IntegrationPointArray self, int nsize, mfem::MemoryType mt)\n" ""}, { "IntegrationPointArray_Capacity", _wrap_IntegrationPointArray_Capacity, METH_O, "Capacity(IntegrationPointArray self) -> int"}, - { "IntegrationPointArray_Reserve", _wrap_IntegrationPointArray_Reserve, METH_VARARGS, "Reserve(IntegrationPointArray self, int capacity)"}, + { "IntegrationPointArray_Reserve", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Reserve, METH_VARARGS|METH_KEYWORDS, "Reserve(IntegrationPointArray self, int capacity)"}, { "IntegrationPointArray_Append", _wrap_IntegrationPointArray_Append, METH_VARARGS, "\n" "Append(IntegrationPointArray self, IntegrationPoint el) -> int\n" "Append(IntegrationPointArray self, IntegrationPoint els, int nels) -> int\n" "Append(IntegrationPointArray self, IntegrationPointArray els) -> int\n" ""}, - { "IntegrationPointArray_Prepend", _wrap_IntegrationPointArray_Prepend, METH_VARARGS, "Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, + { "IntegrationPointArray_Prepend", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Prepend, METH_VARARGS|METH_KEYWORDS, "Prepend(IntegrationPointArray self, IntegrationPoint el) -> int"}, { "IntegrationPointArray_Last", _wrap_IntegrationPointArray_Last, METH_VARARGS, "\n" "Last(IntegrationPointArray self) -> IntegrationPoint\n" "Last(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_DeleteLast", _wrap_IntegrationPointArray_DeleteLast, METH_O, "DeleteLast(IntegrationPointArray self)"}, { "IntegrationPointArray_DeleteAll", _wrap_IntegrationPointArray_DeleteAll, METH_O, "DeleteAll(IntegrationPointArray self)"}, - { "IntegrationPointArray_Copy", _wrap_IntegrationPointArray_Copy, METH_VARARGS, "Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, + { "IntegrationPointArray_Copy", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(IntegrationPointArray self, IntegrationPointArray copy)"}, { "IntegrationPointArray_MakeRef", _wrap_IntegrationPointArray_MakeRef, METH_VARARGS, "\n" "MakeRef(IntegrationPointArray self, IntegrationPoint arg2, int arg3)\n" "MakeRef(IntegrationPointArray self, IntegrationPointArray master)\n" ""}, - { "IntegrationPointArray_GetSubArray", _wrap_IntegrationPointArray_GetSubArray, METH_VARARGS, "GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, + { "IntegrationPointArray_GetSubArray", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_GetSubArray, METH_VARARGS|METH_KEYWORDS, "GetSubArray(IntegrationPointArray self, int offset, int sa_size, IntegrationPointArray sa)"}, { "IntegrationPointArray_begin", _wrap_IntegrationPointArray_begin, METH_VARARGS, "\n" "begin(IntegrationPointArray self) -> IntegrationPoint\n" "begin(IntegrationPointArray self) -> IntegrationPoint\n" @@ -8753,14 +8535,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { "end(IntegrationPointArray self) -> IntegrationPoint\n" ""}, { "IntegrationPointArray_MemoryUsage", _wrap_IntegrationPointArray_MemoryUsage, METH_O, "MemoryUsage(IntegrationPointArray self) -> long"}, - { "IntegrationPointArray_Read", _wrap_IntegrationPointArray_Read, METH_VARARGS, "Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Read", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Read, METH_VARARGS|METH_KEYWORDS, "Read(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostRead", _wrap_IntegrationPointArray_HostRead, METH_O, "HostRead(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_Write", _wrap_IntegrationPointArray_Write, METH_VARARGS, "Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_Write", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_Write, METH_VARARGS|METH_KEYWORDS, "Write(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostWrite", _wrap_IntegrationPointArray_HostWrite, METH_O, "HostWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray_ReadWrite", _wrap_IntegrationPointArray_ReadWrite, METH_VARARGS, "ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, + { "IntegrationPointArray_ReadWrite", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(IntegrationPointArray self, bool on_dev=True) -> IntegrationPoint"}, { "IntegrationPointArray_HostReadWrite", _wrap_IntegrationPointArray_HostReadWrite, METH_O, "HostReadWrite(IntegrationPointArray self) -> IntegrationPoint"}, - { "IntegrationPointArray___setitem__", _wrap_IntegrationPointArray___setitem__, METH_VARARGS, "__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, - { "IntegrationPointArray___getitem__", _wrap_IntegrationPointArray___getitem__, METH_VARARGS, "__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, + { "IntegrationPointArray___setitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(IntegrationPointArray self, int i, IntegrationPoint v)"}, + { "IntegrationPointArray___getitem__", (PyCFunction)(void(*)(void))_wrap_IntegrationPointArray___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(IntegrationPointArray self, int const i) -> IntegrationPoint"}, { "IntegrationPointArray_Assign", _wrap_IntegrationPointArray_Assign, METH_VARARGS, "\n" "Assign(IntegrationPointArray self, IntegrationPoint arg2)\n" "Assign(IntegrationPointArray self, IntegrationPoint a)\n" @@ -8778,13 +8560,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "IntegrationPoint_weight_get", _wrap_IntegrationPoint_weight_get, METH_O, "IntegrationPoint_weight_get(IntegrationPoint self) -> double"}, { "IntegrationPoint_index_set", _wrap_IntegrationPoint_index_set, METH_VARARGS, "IntegrationPoint_index_set(IntegrationPoint self, int index)"}, { "IntegrationPoint_index_get", _wrap_IntegrationPoint_index_get, METH_O, "IntegrationPoint_index_get(IntegrationPoint self) -> int"}, - { "IntegrationPoint_Init", _wrap_IntegrationPoint_Init, METH_VARARGS, "Init(IntegrationPoint self, int const i)"}, - { "IntegrationPoint_Get", _wrap_IntegrationPoint_Get, METH_VARARGS, "Get(IntegrationPoint self, double * p, int const dim)"}, + { "IntegrationPoint_Init", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Init, METH_VARARGS|METH_KEYWORDS, "Init(IntegrationPoint self, int const i)"}, + { "IntegrationPoint_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Get, METH_VARARGS|METH_KEYWORDS, "Get(IntegrationPoint self, double * p, int const dim)"}, { "IntegrationPoint_Set", _wrap_IntegrationPoint_Set, METH_VARARGS, "\n" "Set(IntegrationPoint self, double const * p, int const dim)\n" "Set(IntegrationPoint self, double const x1, double const x2, double const x3, double const w)\n" ""}, - { "IntegrationPoint_Set3w", _wrap_IntegrationPoint_Set3w, METH_VARARGS, "Set3w(IntegrationPoint self, double const * p)"}, + { "IntegrationPoint_Set3w", (PyCFunction)(void(*)(void))_wrap_IntegrationPoint_Set3w, METH_VARARGS|METH_KEYWORDS, "Set3w(IntegrationPoint self, double const * p)"}, { "IntegrationPoint_Set3", _wrap_IntegrationPoint_Set3, METH_VARARGS, "\n" "Set3(IntegrationPoint self, double const x1, double const x2, double const x3)\n" "Set3(IntegrationPoint self, double const * p)\n" @@ -8812,7 +8594,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "new_IntegrationRule(IntegrationRule irx, IntegrationRule iry, IntegrationRule irz) -> IntegrationRule\n" ""}, { "IntegrationRule_GetOrder", _wrap_IntegrationRule_GetOrder, METH_O, "GetOrder(IntegrationRule self) -> int"}, - { "IntegrationRule_SetOrder", _wrap_IntegrationRule_SetOrder, METH_VARARGS, "SetOrder(IntegrationRule self, int const order)"}, + { "IntegrationRule_SetOrder", (PyCFunction)(void(*)(void))_wrap_IntegrationRule_SetOrder, METH_VARARGS|METH_KEYWORDS, "SetOrder(IntegrationRule self, int const order)"}, { "IntegrationRule_GetNPoints", _wrap_IntegrationRule_GetNPoints, METH_O, "GetNPoints(IntegrationRule self) -> int"}, { "IntegrationRule_IntPoint", _wrap_IntegrationRule_IntPoint, METH_VARARGS, "\n" "IntPoint(IntegrationRule self, int i) -> IntegrationPoint\n" @@ -8822,26 +8604,26 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_IntegrationRule", _wrap_delete_IntegrationRule, METH_O, "delete_IntegrationRule(IntegrationRule self)"}, { "IntegrationRule_swigregister", IntegrationRule_swigregister, METH_O, NULL}, { "IntegrationRule_swiginit", IntegrationRule_swiginit, METH_VARARGS, NULL}, - { "QuadratureFunctions1D_GaussLegendre", _wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS, "GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GaussLobatto", _wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS, "GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenUniform", _wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS, "OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_ClosedUniform", _wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS, "ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_OpenHalfUniform", _wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS, "OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, - { "QuadratureFunctions1D_GivePolyPoints", _wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS, "GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, + { "QuadratureFunctions1D_GaussLegendre", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLegendre, METH_VARARGS|METH_KEYWORDS, "GaussLegendre(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GaussLobatto", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GaussLobatto, METH_VARARGS|METH_KEYWORDS, "GaussLobatto(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenUniform, METH_VARARGS|METH_KEYWORDS, "OpenUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_ClosedUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_ClosedUniform, METH_VARARGS|METH_KEYWORDS, "ClosedUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_OpenHalfUniform", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_OpenHalfUniform, METH_VARARGS|METH_KEYWORDS, "OpenHalfUniform(QuadratureFunctions1D self, int const np, IntegrationRule ir)"}, + { "QuadratureFunctions1D_GivePolyPoints", (PyCFunction)(void(*)(void))_wrap_QuadratureFunctions1D_GivePolyPoints, METH_VARARGS|METH_KEYWORDS, "GivePolyPoints(QuadratureFunctions1D self, int const np, double * pts, int const type)"}, { "new_QuadratureFunctions1D", _wrap_new_QuadratureFunctions1D, METH_NOARGS, "new_QuadratureFunctions1D() -> QuadratureFunctions1D"}, { "delete_QuadratureFunctions1D", _wrap_delete_QuadratureFunctions1D, METH_O, "delete_QuadratureFunctions1D(QuadratureFunctions1D self)"}, { "QuadratureFunctions1D_swigregister", QuadratureFunctions1D_swigregister, METH_O, NULL}, { "QuadratureFunctions1D_swiginit", QuadratureFunctions1D_swiginit, METH_VARARGS, NULL}, - { "Quadrature1D_CheckClosed", _wrap_Quadrature1D_CheckClosed, METH_O, "CheckClosed(int type) -> int"}, - { "Quadrature1D_CheckOpen", _wrap_Quadrature1D_CheckOpen, METH_O, "CheckOpen(int type) -> int"}, + { "Quadrature1D_CheckClosed", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckClosed, METH_VARARGS|METH_KEYWORDS, "CheckClosed(int type) -> int"}, + { "Quadrature1D_CheckOpen", (PyCFunction)(void(*)(void))_wrap_Quadrature1D_CheckOpen, METH_VARARGS|METH_KEYWORDS, "CheckOpen(int type) -> int"}, { "new_Quadrature1D", _wrap_new_Quadrature1D, METH_NOARGS, "new_Quadrature1D() -> Quadrature1D"}, { "delete_Quadrature1D", _wrap_delete_Quadrature1D, METH_O, "delete_Quadrature1D(Quadrature1D self)"}, { "Quadrature1D_swigregister", Quadrature1D_swigregister, METH_O, NULL}, { "Quadrature1D_swiginit", Quadrature1D_swiginit, METH_VARARGS, NULL}, - { "new_IntegrationRules", _wrap_new_IntegrationRules, METH_VARARGS, "IntegrationRules(int Ref=0, int type=GaussLegendre)"}, - { "IntegrationRules_Get", _wrap_IntegrationRules_Get, METH_VARARGS, "Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, - { "IntegrationRules_Set", _wrap_IntegrationRules_Set, METH_VARARGS, "Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, - { "IntegrationRules_SetOwnRules", _wrap_IntegrationRules_SetOwnRules, METH_VARARGS, "SetOwnRules(IntegrationRules self, int o)"}, + { "new_IntegrationRules", (PyCFunction)(void(*)(void))_wrap_new_IntegrationRules, METH_VARARGS|METH_KEYWORDS, "new_IntegrationRules(int Ref=0, int type=GaussLegendre) -> IntegrationRules"}, + { "IntegrationRules_Get", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Get, METH_VARARGS|METH_KEYWORDS, "Get(IntegrationRules self, int GeomType, int Order) -> IntegrationRule"}, + { "IntegrationRules_Set", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_Set, METH_VARARGS|METH_KEYWORDS, "Set(IntegrationRules self, int GeomType, int Order, IntegrationRule IntRule)"}, + { "IntegrationRules_SetOwnRules", (PyCFunction)(void(*)(void))_wrap_IntegrationRules_SetOwnRules, METH_VARARGS|METH_KEYWORDS, "SetOwnRules(IntegrationRules self, int o)"}, { "delete_IntegrationRules", _wrap_delete_IntegrationRules, METH_O, "delete_IntegrationRules(IntegrationRules self)"}, { "IntegrationRules_swigregister", IntegrationRules_swigregister, METH_O, NULL}, { "IntegrationRules_swiginit", IntegrationRules_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/io_stream_wrap.cxx b/mfem/_ser/io_stream_wrap.cxx index 9b6364f4..1c114dad 100644 --- a/mfem/_ser/io_stream_wrap.cxx +++ b/mfem/_ser/io_stream_wrap.cxx @@ -3101,7 +3101,7 @@ SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; char *arg1 = (char *) 0 ; - int arg2 ; + int arg2 = (int) 8 ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -3109,42 +3109,20 @@ SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ int ecode2 = 0 ; PyMFEM::wFILE *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_wFILE" "', argument " "1"" of type '" "char const *""'"); } arg1 = reinterpret_cast< char * >(buf1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_wFILE" "', argument " "2"" of type '" "int""'"); - } - arg2 = static_cast< int >(val2); - result = (PyMFEM::wFILE *)new PyMFEM::wFILE((char const *)arg1,arg2); - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyMFEM__wFILE, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return resultobj; -fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_wFILE__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - PyMFEM::wFILE *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_wFILE" "', argument " "1"" of type '" "char const *""'"); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_wFILE" "', argument " "2"" of type '" "int""'"); + } + arg2 = static_cast< int >(val2); } - arg1 = reinterpret_cast< char * >(buf1); - result = (PyMFEM::wFILE *)new PyMFEM::wFILE((char const *)arg1); + result = (PyMFEM::wFILE *)new PyMFEM::wFILE((char const *)arg1,arg2); resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_PyMFEM__wFILE, SWIG_POINTER_NEW | 0 ); if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return resultobj; @@ -3165,19 +3143,14 @@ SWIGINTERN PyObject *_wrap_new_wFILE(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_wFILE__SWIG_0(self, argc, argv); } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_wFILE__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_wFILE__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); @@ -3192,8 +3165,7 @@ SWIGINTERN PyObject *_wrap_new_wFILE(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_wFILE'.\n" " Possible C/C++ prototypes are:\n" " PyMFEM::wFILE::wFILE()\n" - " PyMFEM::wFILE::wFILE(char const *,int)\n" - " PyMFEM::wFILE::wFILE(char const *)\n"); + " PyMFEM::wFILE::wFILE(char const *,int)\n"); return 0; } @@ -3267,7 +3239,7 @@ SWIGINTERN PyObject *_wrap_wFILE_getPrecision(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_wFILE_setPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_wFILE_setPrecision(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyMFEM::wFILE *arg1 = (PyMFEM::wFILE *) 0 ; int arg2 ; @@ -3275,15 +3247,19 @@ SWIGINTERN PyObject *_wrap_wFILE_setPrecision(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"precision", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "wFILE_setPrecision", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_PyMFEM__wFILE, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:wFILE_setPrecision", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_PyMFEM__wFILE, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wFILE_setPrecision" "', argument " "1"" of type '" "PyMFEM::wFILE *""'"); } arg1 = reinterpret_cast< PyMFEM::wFILE * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wFILE_setPrecision" "', argument " "2"" of type '" "int""'"); } @@ -3334,12 +3310,12 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" "wFILE()\n" - "wFILE(char const * filename, int precision=8)\n" + "new_wFILE(char const * filename, int precision=8) -> wFILE\n" ""}, { "wFILE_isSTDOUT", _wrap_wFILE_isSTDOUT, METH_O, "wFILE_isSTDOUT(wFILE self) -> int"}, { "wFILE_getFilename", _wrap_wFILE_getFilename, METH_O, "wFILE_getFilename(wFILE self) -> char *"}, { "wFILE_getPrecision", _wrap_wFILE_getPrecision, METH_O, "wFILE_getPrecision(wFILE self) -> int"}, - { "wFILE_setPrecision", _wrap_wFILE_setPrecision, METH_VARARGS, "wFILE_setPrecision(wFILE self, int precision)"}, + { "wFILE_setPrecision", (PyCFunction)(void(*)(void))_wrap_wFILE_setPrecision, METH_VARARGS|METH_KEYWORDS, "wFILE_setPrecision(wFILE self, int precision)"}, { "delete_wFILE", _wrap_delete_wFILE, METH_O, "delete_wFILE(wFILE self)"}, { "wFILE_swigregister", wFILE_swigregister, METH_O, NULL}, { "wFILE_swiginit", wFILE_swiginit, METH_VARARGS, NULL}, @@ -3351,12 +3327,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_wFILE", _wrap_new_wFILE, METH_VARARGS, "\n" "wFILE()\n" - "wFILE(char const * filename, int precision=8)\n" + "new_wFILE(char const * filename, int precision=8) -> wFILE\n" ""}, { "wFILE_isSTDOUT", _wrap_wFILE_isSTDOUT, METH_O, "isSTDOUT(wFILE self) -> int"}, { "wFILE_getFilename", _wrap_wFILE_getFilename, METH_O, "getFilename(wFILE self) -> char *"}, { "wFILE_getPrecision", _wrap_wFILE_getPrecision, METH_O, "getPrecision(wFILE self) -> int"}, - { "wFILE_setPrecision", _wrap_wFILE_setPrecision, METH_VARARGS, "setPrecision(wFILE self, int precision)"}, + { "wFILE_setPrecision", (PyCFunction)(void(*)(void))_wrap_wFILE_setPrecision, METH_VARARGS|METH_KEYWORDS, "setPrecision(wFILE self, int precision)"}, { "delete_wFILE", _wrap_delete_wFILE, METH_O, "delete_wFILE(wFILE self)"}, { "wFILE_swigregister", wFILE_swigregister, METH_O, NULL}, { "wFILE_swiginit", wFILE_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/linearform_wrap.cxx b/mfem/_ser/linearform_wrap.cxx index bc4fcbe7..5c6db2b9 100644 --- a/mfem/_ser/linearform_wrap.cxx +++ b/mfem/_ser/linearform_wrap.cxx @@ -3476,7 +3476,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -3484,15 +3484,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -3551,17 +3555,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -3620,7 +3626,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -3628,15 +3634,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -3695,17 +3705,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -4108,7 +4120,7 @@ SWIGINTERN PyObject *_wrap_LinearForm_FESpace(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearForm *arg1 = (mfem::LinearForm *) 0 ; mfem::LinearFormIntegrator *arg2 = (mfem::LinearFormIntegrator *) 0 ; @@ -4116,15 +4128,19 @@ SWIGINTERN PyObject *_wrap_LinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"lfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::LinearForm *""'"); } arg1 = reinterpret_cast< mfem::LinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::LinearFormIntegrator *""'"); } @@ -4967,7 +4983,7 @@ SWIGINTERN PyObject *_wrap_LinearForm_Update(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_LinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearForm___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearForm *arg1 = (mfem::LinearForm *) 0 ; mfem::GridFunction *arg2 = 0 ; @@ -4975,16 +4991,20 @@ SWIGINTERN PyObject *_wrap_LinearForm___call__(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"gf", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "LinearForm___call__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearForm___call__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearForm___call__" "', argument " "1"" of type '" "mfem::LinearForm const *""'"); } arg1 = reinterpret_cast< mfem::LinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearForm___call__" "', argument " "2"" of type '" "mfem::GridFunction const &""'"); } @@ -5074,18 +5094,18 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "new_LinearForm", _wrap_new_LinearForm, METH_VARARGS, "\n" @@ -5099,7 +5119,7 @@ static PyMethodDef SwigMethods[] = { "LinearForm_FESpace(LinearForm self) -> FiniteElementSpace\n" "LinearForm_FESpace(LinearForm self) -> FiniteElementSpace\n" ""}, - { "LinearForm_AddDomainIntegrator", _wrap_LinearForm_AddDomainIntegrator, METH_VARARGS, "LinearForm_AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, + { "LinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_LinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "LinearForm_AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, { "LinearForm_AddBoundaryIntegrator", _wrap_LinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "LinearForm_AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" "LinearForm_AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" @@ -5120,7 +5140,7 @@ static PyMethodDef SwigMethods[] = { "LinearForm_Update(LinearForm self, FiniteElementSpace f)\n" "LinearForm_Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset)\n" ""}, - { "LinearForm___call__", _wrap_LinearForm___call__, METH_VARARGS, "LinearForm___call__(LinearForm self, GridFunction gf) -> double"}, + { "LinearForm___call__", (PyCFunction)(void(*)(void))_wrap_LinearForm___call__, METH_VARARGS|METH_KEYWORDS, "LinearForm___call__(LinearForm self, GridFunction gf) -> double"}, { "delete_LinearForm", _wrap_delete_LinearForm, METH_O, "delete_LinearForm(LinearForm self)"}, { "LinearForm_swigregister", LinearForm_swigregister, METH_O, NULL}, { "LinearForm_swiginit", LinearForm_swiginit, METH_VARARGS, NULL}, @@ -5132,18 +5152,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "new_LinearForm", _wrap_new_LinearForm, METH_VARARGS, "\n" @@ -5157,7 +5177,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FESpace(LinearForm self) -> FiniteElementSpace\n" "FESpace(LinearForm self) -> FiniteElementSpace\n" ""}, - { "LinearForm_AddDomainIntegrator", _wrap_LinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, + { "LinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_LinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(LinearForm self, LinearFormIntegrator lfi)"}, { "LinearForm_AddBoundaryIntegrator", _wrap_LinearForm_AddBoundaryIntegrator, METH_VARARGS, "\n" "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi)\n" "AddBoundaryIntegrator(LinearForm self, LinearFormIntegrator lfi, intArray bdr_attr_marker)\n" @@ -5178,7 +5198,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Update(LinearForm self, FiniteElementSpace f)\n" "Update(LinearForm self, FiniteElementSpace f, Vector v, int v_offset)\n" ""}, - { "LinearForm___call__", _wrap_LinearForm___call__, METH_VARARGS, "__call__(LinearForm self, GridFunction gf) -> double"}, + { "LinearForm___call__", (PyCFunction)(void(*)(void))_wrap_LinearForm___call__, METH_VARARGS|METH_KEYWORDS, "__call__(LinearForm self, GridFunction gf) -> double"}, { "delete_LinearForm", _wrap_delete_LinearForm, METH_O, "delete_LinearForm(LinearForm self)"}, { "LinearForm_swigregister", LinearForm_swigregister, METH_O, NULL}, { "LinearForm_swiginit", LinearForm_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/lininteg_wrap.cxx b/mfem/_ser/lininteg_wrap.cxx index dea4b2ca..24ac280a 100644 --- a/mfem/_ser/lininteg_wrap.cxx +++ b/mfem/_ser/lininteg_wrap.cxx @@ -3615,7 +3615,7 @@ SWIGINTERN PyObject *_wrap_LinearFormIntegrator_AssembleRHSElementVect(PyObject } -SWIGINTERN PyObject *_wrap_LinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_LinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::LinearFormIntegrator *arg1 = (mfem::LinearFormIntegrator *) 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -3623,15 +3623,19 @@ SWIGINTERN PyObject *_wrap_LinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "LinearFormIntegrator_SetIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:LinearFormIntegrator_SetIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__LinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LinearFormIntegrator_SetIntRule" "', argument " "1"" of type '" "mfem::LinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::LinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LinearFormIntegrator_SetIntRule" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } @@ -3791,7 +3795,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_IsDelta(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaLFIntegrator *arg1 = (mfem::DeltaLFIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3799,15 +3803,19 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSED int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"center", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaLFIntegrator_GetDeltaCenter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DeltaLFIntegrator_GetDeltaCenter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaLFIntegrator_GetDeltaCenter" "', argument " "1"" of type '" "mfem::DeltaLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DeltaLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaLFIntegrator_GetDeltaCenter" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3841,7 +3849,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_GetDeltaCenter(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DeltaLFIntegrator *arg1 = (mfem::DeltaLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -3855,15 +3863,21 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DeltaLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DeltaLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DeltaLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::DeltaLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DeltaLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -3871,7 +3885,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -3879,7 +3893,7 @@ SWIGINTERN PyObject *_wrap_DeltaLFIntegrator_AssembleDeltaElementVect(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DeltaLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -3963,13 +3977,13 @@ SWIGINTERN PyObject *DeltaLFIntegrator_swigregister(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 2 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; mfem::DomainLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -3978,112 +3992,25 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DomainLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DomainLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DomainLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DomainLFIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DomainLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1); + result = (mfem::DomainLFIntegrator *)new mfem::DomainLFIntegrator(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4107,7 +4034,7 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -4165,35 +4092,15 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator(PyObject *self, PyObject *args if (!(argc = SWIG_Python_UnpackTuple(args, "new_DomainLFIntegrator", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_DomainLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_DomainLFIntegrator__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_new_DomainLFIntegrator__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4203,25 +4110,9 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator(PyObject *self, PyObject *args } } if (_v) { - return _wrap_new_DomainLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_DomainLFIntegrator__SWIG_0(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4236,13 +4127,25 @@ SWIGINTERN PyObject *_wrap_new_DomainLFIntegrator(PyObject *self, PyObject *args } } } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_DomainLFIntegrator__SWIG_1(self, argc, argv); + } + } + } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DomainLFIntegrator'.\n" " Possible C/C++ prototypes are:\n" " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &,int,int)\n" - " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &,int)\n" - " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &)\n" " mfem::DomainLFIntegrator::DomainLFIntegrator(mfem::Coefficient &,mfem::IntegrationRule const *)\n"); return 0; } @@ -4319,7 +4222,7 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleRHSElementVect__SWIG_0(PyO } -SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DomainLFIntegrator *arg1 = (mfem::DomainLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4333,15 +4236,21 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DomainLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DomainLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:DomainLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DomainLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::DomainLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::DomainLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4349,7 +4258,7 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4357,7 +4266,7 @@ SWIGINTERN PyObject *_wrap_DomainLFIntegrator_AssembleDeltaElementVect(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DomainLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -4577,17 +4486,23 @@ SWIGINTERN PyObject *DomainLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 1 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"QG", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_BoundaryLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -4595,17 +4510,21 @@ SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { @@ -4633,32 +4552,54 @@ SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - int arg2 ; + mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::ElementTransformation *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::BoundaryLFIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + } + arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); + } + arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - result = (mfem::BoundaryLFIntegrator *)new mfem::BoundaryLFIntegrator(*arg1,arg2); + (arg1)->AssembleRHSElementVect((mfem::FiniteElement const &)*arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4675,226 +4616,37 @@ SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_1(PyObject *SWIGUNUSED SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryLFIntegrator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; + mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; + mfem::FiniteElement *arg2 = 0 ; + mfem::FaceElementTransformations *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::BoundaryLFIntegrator *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - { - try { - result = (mfem::BoundaryLFIntegrator *)new mfem::BoundaryLFIntegrator(*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryLFIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BoundaryLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BoundaryLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BoundaryLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BoundaryLFIntegrator::BoundaryLFIntegrator(mfem::Coefficient &,int,int)\n" - " mfem::BoundaryLFIntegrator::BoundaryLFIntegrator(mfem::Coefficient &,int)\n" - " mfem::BoundaryLFIntegrator::BoundaryLFIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::ElementTransformation *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); - } - arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - (arg1)->AssembleRHSElementVect((mfem::FiniteElement const &)*arg2,*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BoundaryLFIntegrator_AssembleRHSElementVect__SWIG_1_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BoundaryLFIntegrator *arg1 = (mfem::BoundaryLFIntegrator *) 0 ; - mfem::FiniteElement *arg2 = 0 ; - mfem::FaceElementTransformations *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BoundaryLFIntegrator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "1"" of type '" "mfem::BoundaryLFIntegrator *""'"); - } - arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); + arg1 = reinterpret_cast< mfem::BoundaryLFIntegrator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } if (!argp2) { SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BoundaryLFIntegrator_AssembleRHSElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); @@ -5057,17 +4809,23 @@ SWIGINTERN PyObject *BoundaryLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 1 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"QG", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryNormalLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_BoundaryNormalLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -5075,112 +4833,25 @@ SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_0(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryNormalLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryNormalLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryNormalLFIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryNormalLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); { try { - result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1); + result = (mfem::BoundaryNormalLFIntegrator *)new mfem::BoundaryNormalLFIntegrator(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5204,82 +4875,6 @@ SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator__SWIG_2(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_new_BoundaryNormalLFIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BoundaryNormalLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BoundaryNormalLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryNormalLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryNormalLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BoundaryNormalLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BoundaryNormalLFIntegrator::BoundaryNormalLFIntegrator(mfem::VectorCoefficient &,int,int)\n" - " mfem::BoundaryNormalLFIntegrator::BoundaryNormalLFIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::BoundaryNormalLFIntegrator::BoundaryNormalLFIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BoundaryNormalLFIntegrator *arg1 = (mfem::BoundaryNormalLFIntegrator *) 0 ; @@ -5537,120 +5132,23 @@ SWIGINTERN PyObject *BoundaryNormalLFIntegrator_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryTangentialLFIntegrator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::VectorCoefficient *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::BoundaryTangentialLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); - } - arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BoundaryTangentialLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; + int arg2 = (int) 1 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"QG", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryTangentialLFIntegrator *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_BoundaryTangentialLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -5658,9 +5156,25 @@ SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryTangentialLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1); + result = (mfem::BoundaryTangentialLFIntegrator *)new mfem::BoundaryTangentialLFIntegrator(*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5684,82 +5198,6 @@ SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(PyObject * } -SWIGINTERN PyObject *_wrap_new_BoundaryTangentialLFIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_BoundaryTangentialLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BoundaryTangentialLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryTangentialLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BoundaryTangentialLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BoundaryTangentialLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BoundaryTangentialLFIntegrator::BoundaryTangentialLFIntegrator(mfem::VectorCoefficient &,int,int)\n" - " mfem::BoundaryTangentialLFIntegrator::BoundaryTangentialLFIntegrator(mfem::VectorCoefficient &,int)\n" - " mfem::BoundaryTangentialLFIntegrator::BoundaryTangentialLFIntegrator(mfem::VectorCoefficient &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::BoundaryTangentialLFIntegrator *arg1 = (mfem::BoundaryTangentialLFIntegrator *) 0 ; @@ -6017,17 +5455,19 @@ SWIGINTERN PyObject *BoundaryTangentialLFIntegrator_swiginit(PyObject *SWIGUNUSE return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"QF", NULL + }; mfem::VectorDomainLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorDomainLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorDomainLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -6132,7 +5572,7 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleRHSElementVect__SWIG } -SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorDomainLFIntegrator *arg1 = (mfem::VectorDomainLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6146,15 +5586,21 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyO int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorDomainLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorDomainLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorDomainLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorDomainLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::VectorDomainLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorDomainLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6162,7 +5608,7 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6170,7 +5616,7 @@ SWIGINTERN PyObject *_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -6390,17 +5836,19 @@ SWIGINTERN PyObject *VectorDomainLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM( return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorBoundaryLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorBoundaryLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"QG", NULL + }; mfem::VectorBoundaryLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorBoundaryLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -6691,17 +6139,19 @@ SWIGINTERN PyObject *VectorBoundaryLFIntegrator_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEDomainLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"F", NULL + }; mfem::VectorFEDomainLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorFEDomainLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEDomainLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -6806,7 +6256,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect__SW } -SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorFEDomainLFIntegrator *arg1 = (mfem::VectorFEDomainLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6820,15 +6270,21 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fe", (char *)"Trans", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:VectorFEDomainLFIntegrator_AssembleDeltaElementVect", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorFEDomainLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "1"" of type '" "mfem::VectorFEDomainLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorFEDomainLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6836,7 +6292,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6844,7 +6300,7 @@ SWIGINTERN PyObject *_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorFEDomainLFIntegrator_AssembleDeltaElementVect" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7064,21 +6520,27 @@ SWIGINTERN PyObject *VectorFEDomainLFIntegrator_swiginit(PyObject *SWIGUNUSEDPAR return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; - double arg2 ; - mfem::IntegrationRule *arg3 = (mfem::IntegrationRule *) 0 ; + double arg2 = (double) 1.0 ; + mfem::IntegrationRule *arg3 = (mfem::IntegrationRule *) NULL ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"f", (char *)"s", (char *)"ir", NULL + }; mfem::VectorBoundaryFluxLFIntegrator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:new_VectorBoundaryFluxLFIntegrator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -7086,111 +6548,23 @@ SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "3"" of type '" "mfem::IntegrationRule const *""'"); - } - arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); - { - try { - result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1,arg2,(mfem::IntegrationRule const *)arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::VectorBoundaryFluxLFIntegrator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "3"" of type '" "mfem::IntegrationRule const *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__VectorBoundaryFluxLFIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::VectorBoundaryFluxLFIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_VectorBoundaryFluxLFIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); + arg3 = reinterpret_cast< mfem::IntegrationRule * >(argp3); } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); { try { - result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1); + result = (mfem::VectorBoundaryFluxLFIntegrator *)new mfem::VectorBoundaryFluxLFIntegrator(*arg1,arg2,(mfem::IntegrationRule const *)arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7214,69 +6588,6 @@ SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_2(PyObject * } -SWIGINTERN PyObject *_wrap_new_VectorBoundaryFluxLFIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_VectorBoundaryFluxLFIntegrator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_VectorBoundaryFluxLFIntegrator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_VectorBoundaryFluxLFIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::VectorBoundaryFluxLFIntegrator::VectorBoundaryFluxLFIntegrator(mfem::Coefficient &,double,mfem::IntegrationRule const *)\n" - " mfem::VectorBoundaryFluxLFIntegrator::VectorBoundaryFluxLFIntegrator(mfem::Coefficient &,double)\n" - " mfem::VectorBoundaryFluxLFIntegrator::VectorBoundaryFluxLFIntegrator(mfem::Coefficient &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::VectorBoundaryFluxLFIntegrator *arg1 = (mfem::VectorBoundaryFluxLFIntegrator *) 0 ; @@ -7894,17 +7205,19 @@ SWIGINTERN PyObject *VectorFEBoundaryFluxLFIntegrator_swiginit(PyObject *SWIGUNU return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryTangentLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_VectorFEBoundaryTangentLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"QG", NULL + }; mfem::VectorFEBoundaryTangentLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_VectorFEBoundaryTangentLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_VectorFEBoundaryTangentLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -8195,7 +7508,7 @@ SWIGINTERN PyObject *VectorFEBoundaryTangentLFIntegrator_swiginit(PyObject *SWIG return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::VectorCoefficient *arg2 = 0 ; @@ -8209,11 +7522,17 @@ SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(s int ecode3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"_f", (char *)"_u", (char *)"a", (char *)"b", NULL + }; mfem::BoundaryFlowIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_BoundaryFlowIntegrator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_BoundaryFlowIntegrator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BoundaryFlowIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -8221,7 +7540,7 @@ SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryFlowIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_BoundaryFlowIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } @@ -8229,12 +7548,12 @@ SWIGINTERN PyObject *_wrap_new_BoundaryFlowIntegrator(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BoundaryFlowIntegrator" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BoundaryFlowIntegrator" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_BoundaryFlowIntegrator" "', argument " "4"" of type '" "double""'"); } @@ -9067,7 +8386,7 @@ SWIGINTERN PyObject *DGDirichletLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorCoefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; @@ -9084,11 +8403,18 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU int ecode4 = 0 ; double val5 ; int ecode5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"uD_", (char *)"lambda_", (char *)"mu_", (char *)"alpha_", (char *)"kappa_", NULL + }; mfem::DGElasticityDirichletLFIntegrator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_DGElasticityDirichletLFIntegrator", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:new_DGElasticityDirichletLFIntegrator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } @@ -9096,7 +8422,7 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "1"" of type '" "mfem::VectorCoefficient &""'"); } arg1 = reinterpret_cast< mfem::VectorCoefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } @@ -9104,7 +8430,7 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } @@ -9112,12 +8438,12 @@ SWIGINTERN PyObject *_wrap_new_DGElasticityDirichletLFIntegrator(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "3"" of type '" "mfem::Coefficient &""'"); } arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_double(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_DGElasticityDirichletLFIntegrator" "', argument " "5"" of type '" "double""'"); } @@ -9412,20 +8738,20 @@ static PyMethodDef SwigMethods[] = { "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "LinearFormIntegrator_AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" ""}, - { "LinearFormIntegrator_SetIntRule", _wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS, "LinearFormIntegrator_SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, + { "LinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "LinearFormIntegrator_SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, { "LinearFormIntegrator_GetIntRule", _wrap_LinearFormIntegrator_GetIntRule, METH_O, "LinearFormIntegrator_GetIntRule(LinearFormIntegrator self) -> IntegrationRule"}, { "delete_LinearFormIntegrator", _wrap_delete_LinearFormIntegrator, METH_O, "delete_LinearFormIntegrator(LinearFormIntegrator self)"}, { "LinearFormIntegrator_swigregister", LinearFormIntegrator_swigregister, METH_O, NULL}, { "DeltaLFIntegrator_IsDelta", _wrap_DeltaLFIntegrator_IsDelta, METH_O, "DeltaLFIntegrator_IsDelta(DeltaLFIntegrator self) -> bool"}, - { "DeltaLFIntegrator_GetDeltaCenter", _wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS, "DeltaLFIntegrator_GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, - { "DeltaLFIntegrator_AssembleDeltaElementVect", _wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "DeltaLFIntegrator_AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DeltaLFIntegrator_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "DeltaLFIntegrator_GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, + { "DeltaLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "DeltaLFIntegrator_AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "delete_DeltaLFIntegrator", _wrap_delete_DeltaLFIntegrator, METH_O, "delete_DeltaLFIntegrator(DeltaLFIntegrator self)"}, { "DeltaLFIntegrator_swigregister", DeltaLFIntegrator_swigregister, METH_O, NULL}, { "new_DomainLFIntegrator", _wrap_new_DomainLFIntegrator, METH_VARARGS, "\n" "DomainLFIntegrator(Coefficient QF, int a=2, int b=0)\n" "new_DomainLFIntegrator(Coefficient QF, IntegrationRule ir) -> DomainLFIntegrator\n" ""}, - { "DomainLFIntegrator_AssembleDeltaElementVect", _wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "DomainLFIntegrator_AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "DomainLFIntegrator_AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "DomainLFIntegrator_AssembleRHSElementVect", _wrap_DomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "DomainLFIntegrator_AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "DomainLFIntegrator_AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9433,7 +8759,7 @@ static PyMethodDef SwigMethods[] = { { "delete_DomainLFIntegrator", _wrap_delete_DomainLFIntegrator, METH_O, "delete_DomainLFIntegrator(DomainLFIntegrator self)"}, { "DomainLFIntegrator_swigregister", DomainLFIntegrator_swigregister, METH_O, NULL}, { "DomainLFIntegrator_swiginit", DomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryLFIntegrator", _wrap_new_BoundaryLFIntegrator, METH_VARARGS, "BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1)"}, + { "new_BoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1) -> BoundaryLFIntegrator"}, { "BoundaryLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryLFIntegrator_AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryLFIntegrator_AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9441,7 +8767,7 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryLFIntegrator", _wrap_delete_BoundaryLFIntegrator, METH_O, "delete_BoundaryLFIntegrator(BoundaryLFIntegrator self)"}, { "BoundaryLFIntegrator_swigregister", BoundaryLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryLFIntegrator_swiginit", BoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryNormalLFIntegrator", _wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS, "BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryNormalLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryNormalLFIntegrator"}, { "BoundaryNormalLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryNormalLFIntegrator_AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryNormalLFIntegrator_AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9449,7 +8775,7 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryNormalLFIntegrator", _wrap_delete_BoundaryNormalLFIntegrator, METH_O, "delete_BoundaryNormalLFIntegrator(BoundaryNormalLFIntegrator self)"}, { "BoundaryNormalLFIntegrator_swigregister", BoundaryNormalLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryNormalLFIntegrator_swiginit", BoundaryNormalLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryTangentialLFIntegrator", _wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS, "BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryTangentialLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryTangentialLFIntegrator"}, { "BoundaryTangentialLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryTangentialLFIntegrator_AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryTangentialLFIntegrator_AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9457,8 +8783,8 @@ static PyMethodDef SwigMethods[] = { { "delete_BoundaryTangentialLFIntegrator", _wrap_delete_BoundaryTangentialLFIntegrator, METH_O, "delete_BoundaryTangentialLFIntegrator(BoundaryTangentialLFIntegrator self)"}, { "BoundaryTangentialLFIntegrator_swigregister", BoundaryTangentialLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryTangentialLFIntegrator_swiginit", BoundaryTangentialLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorDomainLFIntegrator", _wrap_new_VectorDomainLFIntegrator, METH_O, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, - { "VectorDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "VectorDomainLFIntegrator_AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, + { "VectorDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "VectorDomainLFIntegrator_AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorDomainLFIntegrator_AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorDomainLFIntegrator_AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9466,7 +8792,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorDomainLFIntegrator", _wrap_delete_VectorDomainLFIntegrator, METH_O, "delete_VectorDomainLFIntegrator(VectorDomainLFIntegrator self)"}, { "VectorDomainLFIntegrator_swigregister", VectorDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorDomainLFIntegrator_swiginit", VectorDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryLFIntegrator", _wrap_new_VectorBoundaryLFIntegrator, METH_O, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, + { "new_VectorBoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, { "VectorBoundaryLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorBoundaryLFIntegrator_AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorBoundaryLFIntegrator_AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9474,8 +8800,8 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorBoundaryLFIntegrator", _wrap_delete_VectorBoundaryLFIntegrator, METH_O, "delete_VectorBoundaryLFIntegrator(VectorBoundaryLFIntegrator self)"}, { "VectorBoundaryLFIntegrator_swigregister", VectorBoundaryLFIntegrator_swigregister, METH_O, NULL}, { "VectorBoundaryLFIntegrator_swiginit", VectorBoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEDomainLFIntegrator", _wrap_new_VectorFEDomainLFIntegrator, METH_O, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, - { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "VectorFEDomainLFIntegrator_AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorFEDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, + { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "VectorFEDomainLFIntegrator_AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorFEDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorFEDomainLFIntegrator_AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorFEDomainLFIntegrator_AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9483,7 +8809,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFEDomainLFIntegrator", _wrap_delete_VectorFEDomainLFIntegrator, METH_O, "delete_VectorFEDomainLFIntegrator(VectorFEDomainLFIntegrator self)"}, { "VectorFEDomainLFIntegrator_swigregister", VectorFEDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEDomainLFIntegrator_swiginit", VectorFEDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryFluxLFIntegrator", _wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS, "VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None)"}, + { "new_VectorBoundaryFluxLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None) -> VectorBoundaryFluxLFIntegrator"}, { "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9502,7 +8828,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFEBoundaryFluxLFIntegrator", _wrap_delete_VectorFEBoundaryFluxLFIntegrator, METH_O, "delete_VectorFEBoundaryFluxLFIntegrator(VectorFEBoundaryFluxLFIntegrator self)"}, { "VectorFEBoundaryFluxLFIntegrator_swigregister", VectorFEBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryFluxLFIntegrator_swiginit", VectorFEBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEBoundaryTangentLFIntegrator", _wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_O, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, + { "new_VectorFEBoundaryTangentLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, { "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9510,7 +8836,7 @@ static PyMethodDef SwigMethods[] = { { "delete_VectorFEBoundaryTangentLFIntegrator", _wrap_delete_VectorFEBoundaryTangentLFIntegrator, METH_O, "delete_VectorFEBoundaryTangentLFIntegrator(VectorFEBoundaryTangentLFIntegrator self)"}, { "VectorFEBoundaryTangentLFIntegrator_swigregister", VectorFEBoundaryTangentLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryTangentLFIntegrator_swiginit", VectorFEBoundaryTangentLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryFlowIntegrator", _wrap_new_BoundaryFlowIntegrator, METH_VARARGS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, + { "new_BoundaryFlowIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryFlowIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, { "BoundaryFlowIntegrator_AssembleRHSElementVect", _wrap_BoundaryFlowIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "BoundaryFlowIntegrator_AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "BoundaryFlowIntegrator_AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9530,7 +8856,7 @@ static PyMethodDef SwigMethods[] = { { "delete_DGDirichletLFIntegrator", _wrap_delete_DGDirichletLFIntegrator, METH_O, "delete_DGDirichletLFIntegrator(DGDirichletLFIntegrator self)"}, { "DGDirichletLFIntegrator_swigregister", DGDirichletLFIntegrator_swigregister, METH_O, NULL}, { "DGDirichletLFIntegrator_swiginit", DGDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DGElasticityDirichletLFIntegrator", _wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, + { "new_DGElasticityDirichletLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, { "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGElasticityDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9548,20 +8874,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(LinearFormIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" ""}, - { "LinearFormIntegrator_SetIntRule", _wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, + { "LinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_LinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "SetIntRule(LinearFormIntegrator self, IntegrationRule ir)"}, { "LinearFormIntegrator_GetIntRule", _wrap_LinearFormIntegrator_GetIntRule, METH_O, "GetIntRule(LinearFormIntegrator self) -> IntegrationRule"}, { "delete_LinearFormIntegrator", _wrap_delete_LinearFormIntegrator, METH_O, "delete_LinearFormIntegrator(LinearFormIntegrator self)"}, { "LinearFormIntegrator_swigregister", LinearFormIntegrator_swigregister, METH_O, NULL}, { "DeltaLFIntegrator_IsDelta", _wrap_DeltaLFIntegrator_IsDelta, METH_O, "IsDelta(DeltaLFIntegrator self) -> bool"}, - { "DeltaLFIntegrator_GetDeltaCenter", _wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS, "GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, - { "DeltaLFIntegrator_AssembleDeltaElementVect", _wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DeltaLFIntegrator_GetDeltaCenter", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_GetDeltaCenter, METH_VARARGS|METH_KEYWORDS, "GetDeltaCenter(DeltaLFIntegrator self, Vector center)"}, + { "DeltaLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DeltaLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(DeltaLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "delete_DeltaLFIntegrator", _wrap_delete_DeltaLFIntegrator, METH_O, "delete_DeltaLFIntegrator(DeltaLFIntegrator self)"}, { "DeltaLFIntegrator_swigregister", DeltaLFIntegrator_swigregister, METH_O, NULL}, { "new_DomainLFIntegrator", _wrap_new_DomainLFIntegrator, METH_VARARGS, "\n" "DomainLFIntegrator(Coefficient QF, int a=2, int b=0)\n" "new_DomainLFIntegrator(Coefficient QF, IntegrationRule ir) -> DomainLFIntegrator\n" ""}, - { "DomainLFIntegrator_AssembleDeltaElementVect", _wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "DomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_DomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(DomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "DomainLFIntegrator_AssembleRHSElementVect", _wrap_DomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(DomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9569,7 +8895,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_DomainLFIntegrator", _wrap_delete_DomainLFIntegrator, METH_O, "delete_DomainLFIntegrator(DomainLFIntegrator self)"}, { "DomainLFIntegrator_swigregister", DomainLFIntegrator_swigregister, METH_O, NULL}, { "DomainLFIntegrator_swiginit", DomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryLFIntegrator", _wrap_new_BoundaryLFIntegrator, METH_VARARGS, "BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1)"}, + { "new_BoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryLFIntegrator(Coefficient QG, int a=1, int b=1) -> BoundaryLFIntegrator"}, { "BoundaryLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9577,7 +8903,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryLFIntegrator", _wrap_delete_BoundaryLFIntegrator, METH_O, "delete_BoundaryLFIntegrator(BoundaryLFIntegrator self)"}, { "BoundaryLFIntegrator_swigregister", BoundaryLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryLFIntegrator_swiginit", BoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryNormalLFIntegrator", _wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS, "BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryNormalLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryNormalLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryNormalLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryNormalLFIntegrator"}, { "BoundaryNormalLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryNormalLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryNormalLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9585,7 +8911,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryNormalLFIntegrator", _wrap_delete_BoundaryNormalLFIntegrator, METH_O, "delete_BoundaryNormalLFIntegrator(BoundaryNormalLFIntegrator self)"}, { "BoundaryNormalLFIntegrator_swigregister", BoundaryNormalLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryNormalLFIntegrator_swiginit", BoundaryNormalLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryTangentialLFIntegrator", _wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS, "BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1)"}, + { "new_BoundaryTangentialLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryTangentialLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryTangentialLFIntegrator(VectorCoefficient QG, int a=1, int b=1) -> BoundaryTangentialLFIntegrator"}, { "BoundaryTangentialLFIntegrator_AssembleRHSElementVect", _wrap_BoundaryTangentialLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryTangentialLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9593,8 +8919,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_BoundaryTangentialLFIntegrator", _wrap_delete_BoundaryTangentialLFIntegrator, METH_O, "delete_BoundaryTangentialLFIntegrator(BoundaryTangentialLFIntegrator self)"}, { "BoundaryTangentialLFIntegrator_swigregister", BoundaryTangentialLFIntegrator_swigregister, METH_O, NULL}, { "BoundaryTangentialLFIntegrator_swiginit", BoundaryTangentialLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorDomainLFIntegrator", _wrap_new_VectorDomainLFIntegrator, METH_O, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, - { "VectorDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorDomainLFIntegrator(VectorCoefficient QF) -> VectorDomainLFIntegrator"}, + { "VectorDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(VectorDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9602,7 +8928,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorDomainLFIntegrator", _wrap_delete_VectorDomainLFIntegrator, METH_O, "delete_VectorDomainLFIntegrator(VectorDomainLFIntegrator self)"}, { "VectorDomainLFIntegrator_swigregister", VectorDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorDomainLFIntegrator_swiginit", VectorDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryLFIntegrator", _wrap_new_VectorBoundaryLFIntegrator, METH_O, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, + { "new_VectorBoundaryLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryLFIntegrator(VectorCoefficient QG) -> VectorBoundaryLFIntegrator"}, { "VectorBoundaryLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorBoundaryLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9610,8 +8936,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorBoundaryLFIntegrator", _wrap_delete_VectorBoundaryLFIntegrator, METH_O, "delete_VectorBoundaryLFIntegrator(VectorBoundaryLFIntegrator self)"}, { "VectorBoundaryLFIntegrator_swigregister", VectorBoundaryLFIntegrator_swigregister, METH_O, NULL}, { "VectorBoundaryLFIntegrator_swiginit", VectorBoundaryLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEDomainLFIntegrator", _wrap_new_VectorFEDomainLFIntegrator, METH_O, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, - { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS, "AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, + { "new_VectorFEDomainLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEDomainLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEDomainLFIntegrator(VectorCoefficient F) -> VectorFEDomainLFIntegrator"}, + { "VectorFEDomainLFIntegrator_AssembleDeltaElementVect", (PyCFunction)(void(*)(void))_wrap_VectorFEDomainLFIntegrator_AssembleDeltaElementVect, METH_VARARGS|METH_KEYWORDS, "AssembleDeltaElementVect(VectorFEDomainLFIntegrator self, FiniteElement fe, ElementTransformation Trans, Vector elvect)"}, { "VectorFEDomainLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEDomainLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorFEDomainLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9619,7 +8945,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFEDomainLFIntegrator", _wrap_delete_VectorFEDomainLFIntegrator, METH_O, "delete_VectorFEDomainLFIntegrator(VectorFEDomainLFIntegrator self)"}, { "VectorFEDomainLFIntegrator_swigregister", VectorFEDomainLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEDomainLFIntegrator_swiginit", VectorFEDomainLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorBoundaryFluxLFIntegrator", _wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS, "VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None)"}, + { "new_VectorBoundaryFluxLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorBoundaryFluxLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorBoundaryFluxLFIntegrator(Coefficient f, double s=1.0, IntegrationRule ir=None) -> VectorBoundaryFluxLFIntegrator"}, { "VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect", _wrap_VectorBoundaryFluxLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorBoundaryFluxLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9638,7 +8964,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFEBoundaryFluxLFIntegrator", _wrap_delete_VectorFEBoundaryFluxLFIntegrator, METH_O, "delete_VectorFEBoundaryFluxLFIntegrator(VectorFEBoundaryFluxLFIntegrator self)"}, { "VectorFEBoundaryFluxLFIntegrator_swigregister", VectorFEBoundaryFluxLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryFluxLFIntegrator_swiginit", VectorFEBoundaryFluxLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_VectorFEBoundaryTangentLFIntegrator", _wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_O, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, + { "new_VectorFEBoundaryTangentLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_VectorFEBoundaryTangentLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_VectorFEBoundaryTangentLFIntegrator(VectorCoefficient QG) -> VectorFEBoundaryTangentLFIntegrator"}, { "VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect", _wrap_VectorFEBoundaryTangentLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(VectorFEBoundaryTangentLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9646,7 +8972,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_VectorFEBoundaryTangentLFIntegrator", _wrap_delete_VectorFEBoundaryTangentLFIntegrator, METH_O, "delete_VectorFEBoundaryTangentLFIntegrator(VectorFEBoundaryTangentLFIntegrator self)"}, { "VectorFEBoundaryTangentLFIntegrator_swigregister", VectorFEBoundaryTangentLFIntegrator_swigregister, METH_O, NULL}, { "VectorFEBoundaryTangentLFIntegrator_swiginit", VectorFEBoundaryTangentLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_BoundaryFlowIntegrator", _wrap_new_BoundaryFlowIntegrator, METH_VARARGS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, + { "new_BoundaryFlowIntegrator", (PyCFunction)(void(*)(void))_wrap_new_BoundaryFlowIntegrator, METH_VARARGS|METH_KEYWORDS, "new_BoundaryFlowIntegrator(Coefficient _f, VectorCoefficient _u, double a, double b) -> BoundaryFlowIntegrator"}, { "BoundaryFlowIntegrator_AssembleRHSElementVect", _wrap_BoundaryFlowIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(BoundaryFlowIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" @@ -9666,7 +8992,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_DGDirichletLFIntegrator", _wrap_delete_DGDirichletLFIntegrator, METH_O, "delete_DGDirichletLFIntegrator(DGDirichletLFIntegrator self)"}, { "DGDirichletLFIntegrator_swigregister", DGDirichletLFIntegrator_swigregister, METH_O, NULL}, { "DGDirichletLFIntegrator_swiginit", DGDirichletLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_DGElasticityDirichletLFIntegrator", _wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, + { "new_DGElasticityDirichletLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_DGElasticityDirichletLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_DGElasticityDirichletLFIntegrator(VectorCoefficient uD_, Coefficient lambda_, Coefficient mu_, double alpha_, double kappa_) -> DGElasticityDirichletLFIntegrator"}, { "DGElasticityDirichletLFIntegrator_AssembleRHSElementVect", _wrap_DGElasticityDirichletLFIntegrator_AssembleRHSElementVect, METH_VARARGS, "\n" "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elvect)\n" "AssembleRHSElementVect(DGElasticityDirichletLFIntegrator self, FiniteElement el, FaceElementTransformations Tr, Vector elvect)\n" diff --git a/mfem/_ser/matrix_wrap.cxx b/mfem/_ser/matrix_wrap.cxx index f420eaf5..5e978953 100644 --- a/mfem/_ser/matrix_wrap.cxx +++ b/mfem/_ser/matrix_wrap.cxx @@ -3339,7 +3339,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Matrix_Print__SWIG_3(mfem::Matrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Matrix_Print__SWIG_1(mfem::Matrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3671,25 +3671,29 @@ SWIGINTERN PyObject *_wrap_Matrix_Inverse(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Matrix_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Matrix_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Matrix_Finalize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Matrix_Finalize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Finalize" "', argument " "1"" of type '" "mfem::Matrix *""'"); } arg1 = reinterpret_cast< mfem::Matrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3720,109 +3724,48 @@ SWIGINTERN PyObject *_wrap_Matrix_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObj SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix const *""'"); } arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::Matrix const *)arg1)->Print(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix const *""'"); - } - arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } { try { - ((mfem::Matrix const *)arg1)->Print(*arg2); + ((mfem::Matrix const *)arg1)->Print(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3856,44 +3799,6 @@ SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix const *""'"); - } - arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - { - try { - ((mfem::Matrix const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_delete_Matrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; @@ -3934,18 +3839,18 @@ SWIGINTERN PyObject *_wrap_delete_Matrix(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix *""'"); @@ -3956,64 +3861,17 @@ SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Matrix_Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Matrix_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Matrix *arg1 = (mfem::Matrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Matrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Matrix_Print" "', argument " "1"" of type '" "mfem::Matrix *""'"); } - arg1 = reinterpret_cast< mfem::Matrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Matrix_Print" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Matrix_Print__SWIG_3(arg1,(char const *)arg2); + mfem_Matrix_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4047,34 +3905,15 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Matrix_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Matrix_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Matrix_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_Matrix_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -4085,19 +3924,9 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Matrix_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Matrix_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4107,27 +3936,23 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Matrix_Print__SWIG_3(self, argc, argv); + return _wrap_Matrix_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Matrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Matrix_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4137,7 +3962,7 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Matrix_Print__SWIG_0(self, argc, argv); + return _wrap_Matrix_Print__SWIG_1(self, argc, argv); } } } @@ -4147,10 +3972,7 @@ SWIGINTERN PyObject *_wrap_Matrix_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Matrix_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Matrix::Print(std::ostream &,int) const\n" - " mfem::Matrix::Print(std::ostream &) const\n" - " mfem::Matrix::Print() const\n" - " mfem::Matrix::Print(char const *,int)\n" - " mfem::Matrix::Print(char const *)\n"); + " mfem::Matrix::Print(char const *,int)\n"); return 0; } @@ -4250,7 +4072,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_NumNonZeroElems(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; int arg2 ; @@ -4262,22 +4084,28 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_GetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AbstractSparseMatrix_GetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_GetRow" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -4285,7 +4113,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "AbstractSparseMatrix_GetRow" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -4319,67 +4147,36 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - double arg2 ; + double arg2 = (double) (double)1e-12 ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"threshold", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:AbstractSparseMatrix_EliminateZeroRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->EliminateZeroRows(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AbstractSparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); { try { - (arg1)->EliminateZeroRows(); + (arg1)->EliminateZeroRows(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4403,49 +4200,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_1(PyObje } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_EliminateZeroRows(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_EliminateZeroRows", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_AbstractSparseMatrix_EliminateZeroRows__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AbstractSparseMatrix_EliminateZeroRows'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::AbstractSparseMatrix::EliminateZeroRows(double const)\n" - " mfem::AbstractSparseMatrix::EliminateZeroRows()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4456,15 +4211,20 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AbstractSparseMatrix_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_Mult" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4472,7 +4232,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4506,12 +4266,12 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1. ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4520,14 +4280,21 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:AbstractSparseMatrix_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4535,7 +4302,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4543,11 +4310,13 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { ((mfem::AbstractSparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); @@ -4574,7 +4343,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4585,135 +4354,20 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult__SWIG_1(PyObject *SWIGUN int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::AbstractSparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_AbstractSparseMatrix_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_AbstractSparseMatrix_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AbstractSparseMatrix_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::AbstractSparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::AbstractSparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:AbstractSparseMatrix_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4721,7 +4375,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4755,12 +4409,12 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_MultTranspose(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1. ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4769,14 +4423,21 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObjec int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"val", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:AbstractSparseMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4784,7 +4445,7 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4792,74 +4453,16 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::AbstractSparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AbstractSparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::AbstractSparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::AbstractSparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4883,66 +4486,6 @@ SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_1(PyObjec } -SWIGINTERN PyObject *_wrap_AbstractSparseMatrix_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "AbstractSparseMatrix_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_AbstractSparseMatrix_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AbstractSparseMatrix_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::AbstractSparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::AbstractSparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_AbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = (mfem::AbstractSparseMatrix *) 0 ; @@ -4999,7 +4542,7 @@ static PyMethodDef SwigMethods[] = { "Matrix_Elem(Matrix self, int i, int j) -> double const &\n" ""}, { "Matrix_Inverse", _wrap_Matrix_Inverse, METH_O, "Matrix_Inverse(Matrix self) -> MatrixInverse"}, - { "Matrix_Finalize", _wrap_Matrix_Finalize, METH_VARARGS, "Matrix_Finalize(Matrix self, int arg2)"}, + { "Matrix_Finalize", (PyCFunction)(void(*)(void))_wrap_Matrix_Finalize, METH_VARARGS|METH_KEYWORDS, "Matrix_Finalize(Matrix self, int arg2)"}, { "delete_Matrix", _wrap_delete_Matrix, METH_O, "delete_Matrix(Matrix self)"}, { "Matrix_Print", _wrap_Matrix_Print, METH_VARARGS, "\n" "Matrix_Print(Matrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -5009,12 +4552,12 @@ static PyMethodDef SwigMethods[] = { { "delete_MatrixInverse", _wrap_delete_MatrixInverse, METH_O, "delete_MatrixInverse(MatrixInverse self)"}, { "MatrixInverse_swigregister", MatrixInverse_swigregister, METH_O, NULL}, { "AbstractSparseMatrix_NumNonZeroElems", _wrap_AbstractSparseMatrix_NumNonZeroElems, METH_O, "AbstractSparseMatrix_NumNonZeroElems(AbstractSparseMatrix self) -> int"}, - { "AbstractSparseMatrix_GetRow", _wrap_AbstractSparseMatrix_GetRow, METH_VARARGS, "AbstractSparseMatrix_GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "AbstractSparseMatrix_EliminateZeroRows", _wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS, "AbstractSparseMatrix_EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, - { "AbstractSparseMatrix_Mult", _wrap_AbstractSparseMatrix_Mult, METH_VARARGS, "AbstractSparseMatrix_Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMult", _wrap_AbstractSparseMatrix_AddMult, METH_VARARGS, "AbstractSparseMatrix_AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, - { "AbstractSparseMatrix_MultTranspose", _wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS, "AbstractSparseMatrix_MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMultTranspose", _wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS, "AbstractSparseMatrix_AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "AbstractSparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, + { "AbstractSparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AbstractSparseMatrix_AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_AbstractSparseMatrix", _wrap_delete_AbstractSparseMatrix, METH_O, "delete_AbstractSparseMatrix(AbstractSparseMatrix self)"}, { "AbstractSparseMatrix_swigregister", AbstractSparseMatrix_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } @@ -5029,7 +4572,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Elem(Matrix self, int i, int j) -> double const &\n" ""}, { "Matrix_Inverse", _wrap_Matrix_Inverse, METH_O, "Inverse(Matrix self) -> MatrixInverse"}, - { "Matrix_Finalize", _wrap_Matrix_Finalize, METH_VARARGS, "Finalize(Matrix self, int arg2)"}, + { "Matrix_Finalize", (PyCFunction)(void(*)(void))_wrap_Matrix_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(Matrix self, int arg2)"}, { "delete_Matrix", _wrap_delete_Matrix, METH_O, "delete_Matrix(Matrix self)"}, { "Matrix_Print", _wrap_Matrix_Print, METH_VARARGS, "\n" "Print(Matrix self, std::ostream & out=mfem::out, int width_=4)\n" @@ -5039,12 +4582,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_MatrixInverse", _wrap_delete_MatrixInverse, METH_O, "delete_MatrixInverse(MatrixInverse self)"}, { "MatrixInverse_swigregister", MatrixInverse_swigregister, METH_O, NULL}, { "AbstractSparseMatrix_NumNonZeroElems", _wrap_AbstractSparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(AbstractSparseMatrix self) -> int"}, - { "AbstractSparseMatrix_GetRow", _wrap_AbstractSparseMatrix_GetRow, METH_VARARGS, "GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "AbstractSparseMatrix_EliminateZeroRows", _wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, - { "AbstractSparseMatrix_Mult", _wrap_AbstractSparseMatrix_Mult, METH_VARARGS, "Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMult", _wrap_AbstractSparseMatrix_AddMult, METH_VARARGS, "AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, - { "AbstractSparseMatrix_MultTranspose", _wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, - { "AbstractSparseMatrix_AddMultTranspose", _wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(AbstractSparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "AbstractSparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "EliminateZeroRows(AbstractSparseMatrix self, double const threshold=1e-12)"}, + { "AbstractSparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, + { "AbstractSparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(AbstractSparseMatrix self, Vector x, Vector y)"}, + { "AbstractSparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_AbstractSparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(AbstractSparseMatrix self, Vector x, Vector y, double const val=1.)"}, { "delete_AbstractSparseMatrix", _wrap_delete_AbstractSparseMatrix, METH_O, "delete_AbstractSparseMatrix(AbstractSparseMatrix self)"}, { "AbstractSparseMatrix_swigregister", AbstractSparseMatrix_swigregister, METH_O, NULL}, { NULL, NULL, 0, NULL } diff --git a/mfem/_ser/mem_manager.py b/mfem/_ser/mem_manager.py index 61f282ee..e50daf44 100644 --- a/mfem/_ser/mem_manager.py +++ b/mfem/_ser/mem_manager.py @@ -127,12 +127,12 @@ def RegisterCheck(self, h_ptr): return _mem_manager.MemoryManager_RegisterCheck(self, h_ptr) RegisterCheck = _swig_new_instance_method(_mem_manager.MemoryManager_RegisterCheck) - def PrintPtrs(self, *args): - return _mem_manager.MemoryManager_PrintPtrs(self, *args) + def PrintPtrs(self, *args, **kwargs): + return _mem_manager.MemoryManager_PrintPtrs(self, *args, **kwargs) PrintPtrs = _swig_new_instance_method(_mem_manager.MemoryManager_PrintPtrs) - def PrintAliases(self, *args): - return _mem_manager.MemoryManager_PrintAliases(self, *args) + def PrintAliases(self, *args, **kwargs): + return _mem_manager.MemoryManager_PrintAliases(self, *args, **kwargs) PrintAliases = _swig_new_instance_method(_mem_manager.MemoryManager_PrintAliases) @staticmethod diff --git a/mfem/_ser/mem_manager_wrap.cxx b/mfem/_ser/mem_manager_wrap.cxx index af5ea2e1..045ad5d2 100644 --- a/mfem/_ser/mem_manager_wrap.cxx +++ b/mfem/_ser/mem_manager_wrap.cxx @@ -3102,17 +3102,19 @@ SWIGINTERN PyObject *Swig_var_MemoryTypeName_get(void) { } -SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"mt", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsHostMemory", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsHostMemory" "', argument " "1"" of type '" "mfem::MemoryType""'"); } @@ -3140,17 +3142,19 @@ SWIGINTERN PyObject *_wrap_IsHostMemory(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryType arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"mt", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsDeviceMemory", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsDeviceMemory" "', argument " "1"" of type '" "mfem::MemoryType""'"); } @@ -3178,17 +3182,19 @@ SWIGINTERN PyObject *_wrap_IsDeviceMemory(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryClass arg1 ; int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"mc", NULL + }; mfem::MemoryType result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:GetMemoryType", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "GetMemoryType" "', argument " "1"" of type '" "mfem::MemoryClass""'"); } @@ -3216,7 +3222,7 @@ SWIGINTERN PyObject *_wrap_GetMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryClass arg1 ; mfem::MemoryClass arg2 ; @@ -3224,16 +3230,20 @@ SWIGINTERN PyObject *_wrap___mul__(PyObject *SWIGUNUSEDPARM(self), PyObject *arg int ecode1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"mc1", (char *)"mc2", NULL + }; mfem::MemoryClass result; - if (!SWIG_Python_UnpackTuple(args, "__mul__", 2, 2, swig_obj)) SWIG_fail; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:__mul__", kwnames, &obj0, &obj1)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__mul__" "', argument " "1"" of type '" "mfem::MemoryClass""'"); } arg1 = static_cast< mfem::MemoryClass >(val1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__mul__" "', argument " "2"" of type '" "mfem::MemoryClass""'"); } @@ -3365,7 +3375,7 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; mfem::MemoryType arg2 ; @@ -3376,20 +3386,25 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Configure(PyObject *SWIGUNUSEDPARM(self int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_mt", (char *)"d_mt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_Configure", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MemoryManager_Configure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_Configure" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MemoryManager_Configure" "', argument " "2"" of type '" "mfem::MemoryType""'"); } arg2 = static_cast< mfem::MemoryType >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryManager_Configure" "', argument " "3"" of type '" "mfem::MemoryType""'"); } @@ -3454,23 +3469,27 @@ SWIGINTERN PyObject *_wrap_MemoryManager_Destroy(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_ptr", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsKnown", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MemoryManager_IsKnown", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsKnown" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsKnown" "', argument " "2"" of type '" "void const *""'"); } @@ -3497,23 +3516,27 @@ SWIGINTERN PyObject *_wrap_MemoryManager_IsKnown(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_ptr", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_IsAlias", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MemoryManager_IsAlias", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_IsAlias" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_IsAlias" "', argument " "2"" of type '" "void const *""'"); } @@ -3540,22 +3563,26 @@ SWIGINTERN PyObject *_wrap_MemoryManager_IsAlias(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; void *arg2 = (void *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_ptr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MemoryManager_RegisterCheck", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MemoryManager_RegisterCheck", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_RegisterCheck" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_RegisterCheck" "', argument " "2"" of type '" "void *""'"); } @@ -3582,69 +3609,41 @@ SWIGINTERN PyObject *_wrap_MemoryManager_RegisterCheck(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MemoryManager_PrintPtrs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - { - try { - result = (int)(arg1)->PrintPtrs(*arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintPtrs" "', argument " "2"" of type '" "std::ostream &""'"); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int result; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintPtrs" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + arg2 = reinterpret_cast< std::ostream * >(argp2); } - arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); { try { - result = (int)(arg1)->PrintPtrs(); + result = (int)(arg1)->PrintPtrs(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3665,110 +3664,41 @@ SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintPtrs(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintPtrs", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintPtrs__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintPtrs__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintPtrs'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MemoryManager::PrintPtrs(std::ostream &)\n" - " mfem::MemoryManager::PrintPtrs()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:MemoryManager_PrintAliases", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); } arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__ostream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); - } - arg2 = reinterpret_cast< std::ostream * >(argp2); - { - try { - result = (int)(arg1)->PrintAliases(*arg2); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__ostream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryManager_PrintAliases" "', argument " "2"" of type '" "std::ostream &""'"); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::MemoryManager *arg1 = (mfem::MemoryManager *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int result; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MemoryManager, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryManager_PrintAliases" "', argument " "1"" of type '" "mfem::MemoryManager *""'"); + arg2 = reinterpret_cast< std::ostream * >(argp2); } - arg1 = reinterpret_cast< mfem::MemoryManager * >(argp1); { try { - result = (int)(arg1)->PrintAliases(); + result = (int)(arg1)->PrintAliases(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3789,47 +3719,6 @@ SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_MemoryManager_PrintAliases(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MemoryManager_PrintAliases", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintAliases__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__MemoryManager, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ostream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MemoryManager_PrintAliases__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MemoryManager_PrintAliases'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::MemoryManager::PrintAliases(std::ostream &)\n" - " mfem::MemoryManager::PrintAliases()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_MemoryManager_GetHostMemoryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::MemoryType result; @@ -3897,16 +3786,18 @@ SWIGINTERN PyObject *MemoryManager_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_MemoryPrintFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MemoryPrintFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; unsigned int arg1 ; unsigned int val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"flags", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:MemoryPrintFlags", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MemoryPrintFlags" "', argument " "1"" of type '" "unsigned int""'"); } @@ -3967,50 +3858,50 @@ SWIGINTERN PyObject *Swig_var_mm_get(void) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, - { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, - { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, - { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, + { "IsHostMemory", (PyCFunction)(void(*)(void))_wrap_IsHostMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "IsDeviceMemory", (PyCFunction)(void(*)(void))_wrap_IsDeviceMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "GetMemoryType", (PyCFunction)(void(*)(void))_wrap_GetMemoryType, METH_VARARGS|METH_KEYWORDS, NULL}, + { "__mul__", (PyCFunction)(void(*)(void))_wrap___mul__, METH_VARARGS|METH_KEYWORDS, NULL}, { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, - { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, + { "MemoryManager_Configure", (PyCFunction)(void(*)(void))_wrap_MemoryManager_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, - { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, - { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, - { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, - { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, - { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_IsKnown", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsKnown, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_IsAlias", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsAlias, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_RegisterCheck", (PyCFunction)(void(*)(void))_wrap_MemoryManager_RegisterCheck, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintPtrs", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintPtrs, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintAliases", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintAliases, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, - { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, + { "MemoryPrintFlags", (PyCFunction)(void(*)(void))_wrap_MemoryPrintFlags, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IsHostMemory", _wrap_IsHostMemory, METH_O, NULL}, - { "IsDeviceMemory", _wrap_IsDeviceMemory, METH_O, NULL}, - { "GetMemoryType", _wrap_GetMemoryType, METH_O, NULL}, - { "__mul__", _wrap___mul__, METH_VARARGS, NULL}, + { "IsHostMemory", (PyCFunction)(void(*)(void))_wrap_IsHostMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "IsDeviceMemory", (PyCFunction)(void(*)(void))_wrap_IsDeviceMemory, METH_VARARGS|METH_KEYWORDS, NULL}, + { "GetMemoryType", (PyCFunction)(void(*)(void))_wrap_GetMemoryType, METH_VARARGS|METH_KEYWORDS, NULL}, + { "__mul__", (PyCFunction)(void(*)(void))_wrap___mul__, METH_VARARGS|METH_KEYWORDS, NULL}, { "new_MemoryManager", _wrap_new_MemoryManager, METH_NOARGS, NULL}, { "delete_MemoryManager", _wrap_delete_MemoryManager, METH_O, NULL}, { "MemoryManager_Init", _wrap_MemoryManager_Init, METH_O, NULL}, - { "MemoryManager_Configure", _wrap_MemoryManager_Configure, METH_VARARGS, NULL}, + { "MemoryManager_Configure", (PyCFunction)(void(*)(void))_wrap_MemoryManager_Configure, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_Destroy", _wrap_MemoryManager_Destroy, METH_O, NULL}, - { "MemoryManager_IsKnown", _wrap_MemoryManager_IsKnown, METH_VARARGS, NULL}, - { "MemoryManager_IsAlias", _wrap_MemoryManager_IsAlias, METH_VARARGS, NULL}, - { "MemoryManager_RegisterCheck", _wrap_MemoryManager_RegisterCheck, METH_VARARGS, NULL}, - { "MemoryManager_PrintPtrs", _wrap_MemoryManager_PrintPtrs, METH_VARARGS, NULL}, - { "MemoryManager_PrintAliases", _wrap_MemoryManager_PrintAliases, METH_VARARGS, NULL}, + { "MemoryManager_IsKnown", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsKnown, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_IsAlias", (PyCFunction)(void(*)(void))_wrap_MemoryManager_IsAlias, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_RegisterCheck", (PyCFunction)(void(*)(void))_wrap_MemoryManager_RegisterCheck, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintPtrs", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintPtrs, METH_VARARGS|METH_KEYWORDS, NULL}, + { "MemoryManager_PrintAliases", (PyCFunction)(void(*)(void))_wrap_MemoryManager_PrintAliases, METH_VARARGS|METH_KEYWORDS, NULL}, { "MemoryManager_GetHostMemoryType", _wrap_MemoryManager_GetHostMemoryType, METH_NOARGS, NULL}, { "MemoryManager_GetDeviceMemoryType", _wrap_MemoryManager_GetDeviceMemoryType, METH_NOARGS, NULL}, { "MemoryManager_swigregister", MemoryManager_swigregister, METH_O, NULL}, { "MemoryManager_swiginit", MemoryManager_swiginit, METH_VARARGS, NULL}, - { "MemoryPrintFlags", _wrap_MemoryPrintFlags, METH_O, NULL}, + { "MemoryPrintFlags", (PyCFunction)(void(*)(void))_wrap_MemoryPrintFlags, METH_VARARGS|METH_KEYWORDS, NULL}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/mesh.py b/mfem/_ser/mesh.py index 7c850ff9..d132d739 100644 --- a/mfem/_ser/mesh.py +++ b/mfem/_ser/mesh.py @@ -760,7 +760,7 @@ def CartesianPartitioning(self, nxyz): CartesianPartitioning = _swig_new_instance_method(_mesh.Mesh_CartesianPartitioning) def GeneratePartitioning(self, nparts, part_method=1): - r"""GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int""" + r"""GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int *""" return _mesh.Mesh_GeneratePartitioning(self, nparts, part_method) GeneratePartitioning = _swig_new_instance_method(_mesh.Mesh_GeneratePartitioning) @@ -1035,9 +1035,9 @@ def PrintElementsByGeometry(dim, num_elems_by_geom, out): return _mesh.Mesh_PrintElementsByGeometry(dim, num_elems_by_geom, out) PrintElementsByGeometry = _swig_new_static_method(_mesh.Mesh_PrintElementsByGeometry) - def PrintCharacteristics(self, *args): + def PrintCharacteristics(self, *args, **kwargs): r"""PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)""" - return _mesh.Mesh_PrintCharacteristics(self, *args) + return _mesh.Mesh_PrintCharacteristics(self, *args, **kwargs) PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) def FindPoints(self, pp): diff --git a/mfem/_ser/mesh_operators.py b/mfem/_ser/mesh_operators.py index 19989790..a4af89bc 100644 --- a/mfem/_ser/mesh_operators.py +++ b/mfem/_ser/mesh_operators.py @@ -212,9 +212,9 @@ def __init__(self, est): r"""__init__(ThresholdRefiner self, ErrorEstimator est) -> ThresholdRefiner""" _mesh_operators.ThresholdRefiner_swiginit(self, _mesh_operators.new_ThresholdRefiner(est)) - def SetTotalErrorNormP(self, *args): + def SetTotalErrorNormP(self, *args, **kwargs): r"""SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())""" - return _mesh_operators.ThresholdRefiner_SetTotalErrorNormP(self, *args) + return _mesh_operators.ThresholdRefiner_SetTotalErrorNormP(self, *args, **kwargs) SetTotalErrorNormP = _swig_new_instance_method(_mesh_operators.ThresholdRefiner_SetTotalErrorNormP) def SetTotalErrorGoal(self, err_goal): diff --git a/mfem/_ser/mesh_operators_wrap.cxx b/mfem/_ser/mesh_operators_wrap.cxx index 5c23ef6e..b0e816e4 100644 --- a/mfem/_ser/mesh_operators_wrap.cxx +++ b/mfem/_ser/mesh_operators_wrap.cxx @@ -3354,7 +3354,7 @@ SWIG_AsVal_long (PyObject *obj, long* val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_MeshOperator_Apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MeshOperator_Apply(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MeshOperator *arg1 = (mfem::MeshOperator *) 0 ; mfem::Mesh *arg2 = 0 ; @@ -3362,16 +3362,20 @@ SWIGINTERN PyObject *_wrap_MeshOperator_Apply(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mesh", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "MeshOperator_Apply", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MeshOperator_Apply", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshOperator_Apply" "', argument " "1"" of type '" "mfem::MeshOperator *""'"); } arg1 = reinterpret_cast< mfem::MeshOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Mesh, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshOperator_Apply" "', argument " "2"" of type '" "mfem::Mesh &""'"); } @@ -3870,7 +3874,7 @@ SWIGINTERN PyObject *_wrap_delete_MeshOperatorSequence(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_MeshOperatorSequence_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MeshOperatorSequence_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::MeshOperatorSequence *arg1 = (mfem::MeshOperatorSequence *) 0 ; mfem::MeshOperator *arg2 = (mfem::MeshOperator *) 0 ; @@ -3878,15 +3882,19 @@ SWIGINTERN PyObject *_wrap_MeshOperatorSequence_Append(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mc", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MeshOperatorSequence_Append", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MeshOperatorSequence, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MeshOperatorSequence_Append", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MeshOperatorSequence, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MeshOperatorSequence_Append" "', argument " "1"" of type '" "mfem::MeshOperatorSequence *""'"); } arg1 = reinterpret_cast< mfem::MeshOperatorSequence * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__MeshOperator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MeshOperatorSequence_Append" "', argument " "2"" of type '" "mfem::MeshOperator *""'"); } @@ -4009,17 +4017,19 @@ SWIGINTERN PyObject *MeshOperatorSequence_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ThresholdRefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ThresholdRefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ErrorEstimator *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"est", NULL + }; mfem::ThresholdRefiner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ThresholdRefiner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThresholdRefiner" "', argument " "1"" of type '" "mfem::ErrorEstimator &""'"); } @@ -4053,67 +4063,36 @@ SWIGINTERN PyObject *_wrap_new_ThresholdRefiner(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; - double arg2 ; + double arg2 = (double) mfem::infinity() ; void *argp1 = 0 ; int res1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"norm_p", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ThresholdRefiner_SetTotalErrorNormP", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->SetTotalErrorNormP(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorNormP" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); { try { - (arg1)->SetTotalErrorNormP(); + (arg1)->SetTotalErrorNormP(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4137,52 +4116,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_1(PyObject } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorNormP(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetTotalErrorNormP", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ThresholdRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__ThresholdRefiner, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_ThresholdRefiner_SetTotalErrorNormP__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ThresholdRefiner_SetTotalErrorNormP'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ThresholdRefiner::SetTotalErrorNormP(double)\n" - " mfem::ThresholdRefiner::SetTotalErrorNormP()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; double arg2 ; @@ -4190,15 +4124,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUS int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"err_goal", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetTotalErrorGoal", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetTotalErrorGoal", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorGoal" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorGoal" "', argument " "2"" of type '" "double""'"); } @@ -4229,7 +4167,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorGoal(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; double arg2 ; @@ -4237,15 +4175,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIG int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fraction", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetTotalErrorFraction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetTotalErrorFraction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetTotalErrorFraction" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetTotalErrorFraction" "', argument " "2"" of type '" "double""'"); } @@ -4276,7 +4218,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetTotalErrorFraction(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; double arg2 ; @@ -4284,15 +4226,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUS int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"err_goal", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetLocalErrorGoal", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetLocalErrorGoal", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetLocalErrorGoal" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetLocalErrorGoal" "', argument " "2"" of type '" "double""'"); } @@ -4323,7 +4269,7 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetLocalErrorGoal(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetMaxElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetMaxElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; long arg2 ; @@ -4331,15 +4277,19 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetMaxElements(PyObject *SWIGUNUSEDP int res1 = 0 ; long val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_elem", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetMaxElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetMaxElements", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetMaxElements" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); - ecode2 = SWIG_AsVal_long(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_long(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdRefiner_SetMaxElements" "', argument " "2"" of type '" "long""'"); } @@ -4450,25 +4400,29 @@ SWIGINTERN PyObject *_wrap_ThresholdRefiner_PreferConformingRefinement(PyObject } -SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdRefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdRefiner *arg1 = (mfem::ThresholdRefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nc_limit", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdRefiner_SetNCLimit", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdRefiner_SetNCLimit", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdRefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdRefiner_SetNCLimit" "', argument " "1"" of type '" "mfem::ThresholdRefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdRefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4669,17 +4623,19 @@ SWIGINTERN PyObject *ThresholdRefiner_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ThresholdDerefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ThresholdDerefiner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ErrorEstimator *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"est", NULL + }; mfem::ThresholdDerefiner *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ThresholdDerefiner", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ErrorEstimator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ThresholdDerefiner" "', argument " "1"" of type '" "mfem::ErrorEstimator &""'"); } @@ -4713,7 +4669,7 @@ SWIGINTERN PyObject *_wrap_new_ThresholdDerefiner(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdDerefiner *arg1 = (mfem::ThresholdDerefiner *) 0 ; double arg2 ; @@ -4721,15 +4677,19 @@ SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDP int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"thresh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdDerefiner_SetThreshold", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdDerefiner_SetThreshold", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdDerefiner_SetThreshold" "', argument " "1"" of type '" "mfem::ThresholdDerefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdDerefiner * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ThresholdDerefiner_SetThreshold" "', argument " "2"" of type '" "double""'"); } @@ -4760,25 +4720,29 @@ SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetThreshold(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetOp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdDerefiner *arg1 = (mfem::ThresholdDerefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdDerefiner_SetOp", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdDerefiner_SetOp", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdDerefiner_SetOp" "', argument " "1"" of type '" "mfem::ThresholdDerefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdDerefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4806,25 +4770,29 @@ SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetOp(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ThresholdDerefiner_SetNCLimit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ThresholdDerefiner *arg1 = (mfem::ThresholdDerefiner *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nc_limit", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ThresholdDerefiner_SetNCLimit", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ThresholdDerefiner_SetNCLimit", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ThresholdDerefiner, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ThresholdDerefiner_SetNCLimit" "', argument " "1"" of type '" "mfem::ThresholdDerefiner *""'"); } arg1 = reinterpret_cast< mfem::ThresholdDerefiner * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5068,7 +5036,7 @@ SWIGINTERN PyObject *Rebalancer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "MeshOperator_Apply(MeshOperator self, Mesh mesh) -> bool"}, + { "MeshOperator_Apply", (PyCFunction)(void(*)(void))_wrap_MeshOperator_Apply, METH_VARARGS|METH_KEYWORDS, "MeshOperator_Apply(MeshOperator self, Mesh mesh) -> bool"}, { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "MeshOperator_Stop(MeshOperator self) -> bool"}, { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "MeshOperator_Repeat(MeshOperator self) -> bool"}, { "MeshOperator_Continue", _wrap_MeshOperator_Continue, METH_O, "MeshOperator_Continue(MeshOperator self) -> bool"}, @@ -5081,30 +5049,30 @@ static PyMethodDef SwigMethods[] = { { "MeshOperator_swigregister", MeshOperator_swigregister, METH_O, NULL}, { "new_MeshOperatorSequence", _wrap_new_MeshOperatorSequence, METH_VARARGS, NULL}, { "delete_MeshOperatorSequence", _wrap_delete_MeshOperatorSequence, METH_O, "delete_MeshOperatorSequence(MeshOperatorSequence self)"}, - { "MeshOperatorSequence_Append", _wrap_MeshOperatorSequence_Append, METH_VARARGS, "MeshOperatorSequence_Append(MeshOperatorSequence self, MeshOperator mc)"}, + { "MeshOperatorSequence_Append", (PyCFunction)(void(*)(void))_wrap_MeshOperatorSequence_Append, METH_VARARGS|METH_KEYWORDS, "MeshOperatorSequence_Append(MeshOperatorSequence self, MeshOperator mc)"}, { "MeshOperatorSequence_GetSequence", _wrap_MeshOperatorSequence_GetSequence, METH_O, "MeshOperatorSequence_GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &"}, { "MeshOperatorSequence_Reset", _wrap_MeshOperatorSequence_Reset, METH_O, "MeshOperatorSequence_Reset(MeshOperatorSequence self)"}, { "MeshOperatorSequence_swigregister", MeshOperatorSequence_swigregister, METH_O, NULL}, { "MeshOperatorSequence_swiginit", MeshOperatorSequence_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdRefiner", _wrap_new_ThresholdRefiner, METH_O, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, - { "ThresholdRefiner_SetTotalErrorNormP", _wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS, "ThresholdRefiner_SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, - { "ThresholdRefiner_SetTotalErrorGoal", _wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS, "ThresholdRefiner_SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetTotalErrorFraction", _wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS, "ThresholdRefiner_SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, - { "ThresholdRefiner_SetLocalErrorGoal", _wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS, "ThresholdRefiner_SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetMaxElements", _wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS, "ThresholdRefiner_SetMaxElements(ThresholdRefiner self, long max_elem)"}, + { "new_ThresholdRefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdRefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, + { "ThresholdRefiner_SetTotalErrorNormP", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, + { "ThresholdRefiner_SetTotalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetTotalErrorFraction", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, + { "ThresholdRefiner_SetLocalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetMaxElements", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetMaxElements(ThresholdRefiner self, long max_elem)"}, { "ThresholdRefiner_PreferNonconformingRefinement", _wrap_ThresholdRefiner_PreferNonconformingRefinement, METH_O, "ThresholdRefiner_PreferNonconformingRefinement(ThresholdRefiner self)"}, { "ThresholdRefiner_PreferConformingRefinement", _wrap_ThresholdRefiner_PreferConformingRefinement, METH_O, "ThresholdRefiner_PreferConformingRefinement(ThresholdRefiner self)"}, - { "ThresholdRefiner_SetNCLimit", _wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS, "ThresholdRefiner_SetNCLimit(ThresholdRefiner self, int nc_limit)"}, + { "ThresholdRefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "ThresholdRefiner_SetNCLimit(ThresholdRefiner self, int nc_limit)"}, { "ThresholdRefiner_GetNumMarkedElements", _wrap_ThresholdRefiner_GetNumMarkedElements, METH_O, "ThresholdRefiner_GetNumMarkedElements(ThresholdRefiner self) -> long"}, { "ThresholdRefiner_GetThreshold", _wrap_ThresholdRefiner_GetThreshold, METH_O, "ThresholdRefiner_GetThreshold(ThresholdRefiner self) -> double"}, { "ThresholdRefiner_Reset", _wrap_ThresholdRefiner_Reset, METH_O, "ThresholdRefiner_Reset(ThresholdRefiner self)"}, { "delete_ThresholdRefiner", _wrap_delete_ThresholdRefiner, METH_O, "delete_ThresholdRefiner(ThresholdRefiner self)"}, { "ThresholdRefiner_swigregister", ThresholdRefiner_swigregister, METH_O, NULL}, { "ThresholdRefiner_swiginit", ThresholdRefiner_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdDerefiner", _wrap_new_ThresholdDerefiner, METH_O, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, - { "ThresholdDerefiner_SetThreshold", _wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS, "ThresholdDerefiner_SetThreshold(ThresholdDerefiner self, double thresh)"}, - { "ThresholdDerefiner_SetOp", _wrap_ThresholdDerefiner_SetOp, METH_VARARGS, "ThresholdDerefiner_SetOp(ThresholdDerefiner self, int op)"}, - { "ThresholdDerefiner_SetNCLimit", _wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS, "ThresholdDerefiner_SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, + { "new_ThresholdDerefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdDerefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, + { "ThresholdDerefiner_SetThreshold", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS|METH_KEYWORDS, "ThresholdDerefiner_SetThreshold(ThresholdDerefiner self, double thresh)"}, + { "ThresholdDerefiner_SetOp", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetOp, METH_VARARGS|METH_KEYWORDS, "ThresholdDerefiner_SetOp(ThresholdDerefiner self, int op)"}, + { "ThresholdDerefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "ThresholdDerefiner_SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, { "ThresholdDerefiner_Reset", _wrap_ThresholdDerefiner_Reset, METH_O, "ThresholdDerefiner_Reset(ThresholdDerefiner self)"}, { "delete_ThresholdDerefiner", _wrap_delete_ThresholdDerefiner, METH_O, "delete_ThresholdDerefiner(ThresholdDerefiner self)"}, { "ThresholdDerefiner_swigregister", ThresholdDerefiner_swigregister, METH_O, NULL}, @@ -5120,7 +5088,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "MeshOperator_Apply", _wrap_MeshOperator_Apply, METH_VARARGS, "Apply(MeshOperator self, Mesh mesh) -> bool"}, + { "MeshOperator_Apply", (PyCFunction)(void(*)(void))_wrap_MeshOperator_Apply, METH_VARARGS|METH_KEYWORDS, "Apply(MeshOperator self, Mesh mesh) -> bool"}, { "MeshOperator_Stop", _wrap_MeshOperator_Stop, METH_O, "Stop(MeshOperator self) -> bool"}, { "MeshOperator_Repeat", _wrap_MeshOperator_Repeat, METH_O, "Repeat(MeshOperator self) -> bool"}, { "MeshOperator_Continue", _wrap_MeshOperator_Continue, METH_O, "Continue(MeshOperator self) -> bool"}, @@ -5133,30 +5101,30 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "MeshOperator_swigregister", MeshOperator_swigregister, METH_O, NULL}, { "new_MeshOperatorSequence", _wrap_new_MeshOperatorSequence, METH_VARARGS, NULL}, { "delete_MeshOperatorSequence", _wrap_delete_MeshOperatorSequence, METH_O, "delete_MeshOperatorSequence(MeshOperatorSequence self)"}, - { "MeshOperatorSequence_Append", _wrap_MeshOperatorSequence_Append, METH_VARARGS, "Append(MeshOperatorSequence self, MeshOperator mc)"}, + { "MeshOperatorSequence_Append", (PyCFunction)(void(*)(void))_wrap_MeshOperatorSequence_Append, METH_VARARGS|METH_KEYWORDS, "Append(MeshOperatorSequence self, MeshOperator mc)"}, { "MeshOperatorSequence_GetSequence", _wrap_MeshOperatorSequence_GetSequence, METH_O, "GetSequence(MeshOperatorSequence self) -> mfem::Array< mfem::MeshOperator * > &"}, { "MeshOperatorSequence_Reset", _wrap_MeshOperatorSequence_Reset, METH_O, "Reset(MeshOperatorSequence self)"}, { "MeshOperatorSequence_swigregister", MeshOperatorSequence_swigregister, METH_O, NULL}, { "MeshOperatorSequence_swiginit", MeshOperatorSequence_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdRefiner", _wrap_new_ThresholdRefiner, METH_O, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, - { "ThresholdRefiner_SetTotalErrorNormP", _wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS, "SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, - { "ThresholdRefiner_SetTotalErrorGoal", _wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS, "SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetTotalErrorFraction", _wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS, "SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, - { "ThresholdRefiner_SetLocalErrorGoal", _wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS, "SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, - { "ThresholdRefiner_SetMaxElements", _wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS, "SetMaxElements(ThresholdRefiner self, long max_elem)"}, + { "new_ThresholdRefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdRefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdRefiner(ErrorEstimator est) -> ThresholdRefiner"}, + { "ThresholdRefiner_SetTotalErrorNormP", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorNormP, METH_VARARGS|METH_KEYWORDS, "SetTotalErrorNormP(ThresholdRefiner self, double norm_p=mfem::infinity())"}, + { "ThresholdRefiner_SetTotalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorGoal, METH_VARARGS|METH_KEYWORDS, "SetTotalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetTotalErrorFraction", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetTotalErrorFraction, METH_VARARGS|METH_KEYWORDS, "SetTotalErrorFraction(ThresholdRefiner self, double fraction)"}, + { "ThresholdRefiner_SetLocalErrorGoal", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetLocalErrorGoal, METH_VARARGS|METH_KEYWORDS, "SetLocalErrorGoal(ThresholdRefiner self, double err_goal)"}, + { "ThresholdRefiner_SetMaxElements", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetMaxElements, METH_VARARGS|METH_KEYWORDS, "SetMaxElements(ThresholdRefiner self, long max_elem)"}, { "ThresholdRefiner_PreferNonconformingRefinement", _wrap_ThresholdRefiner_PreferNonconformingRefinement, METH_O, "PreferNonconformingRefinement(ThresholdRefiner self)"}, { "ThresholdRefiner_PreferConformingRefinement", _wrap_ThresholdRefiner_PreferConformingRefinement, METH_O, "PreferConformingRefinement(ThresholdRefiner self)"}, - { "ThresholdRefiner_SetNCLimit", _wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdRefiner self, int nc_limit)"}, + { "ThresholdRefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdRefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "SetNCLimit(ThresholdRefiner self, int nc_limit)"}, { "ThresholdRefiner_GetNumMarkedElements", _wrap_ThresholdRefiner_GetNumMarkedElements, METH_O, "GetNumMarkedElements(ThresholdRefiner self) -> long"}, { "ThresholdRefiner_GetThreshold", _wrap_ThresholdRefiner_GetThreshold, METH_O, "GetThreshold(ThresholdRefiner self) -> double"}, { "ThresholdRefiner_Reset", _wrap_ThresholdRefiner_Reset, METH_O, "Reset(ThresholdRefiner self)"}, { "delete_ThresholdRefiner", _wrap_delete_ThresholdRefiner, METH_O, "delete_ThresholdRefiner(ThresholdRefiner self)"}, { "ThresholdRefiner_swigregister", ThresholdRefiner_swigregister, METH_O, NULL}, { "ThresholdRefiner_swiginit", ThresholdRefiner_swiginit, METH_VARARGS, NULL}, - { "new_ThresholdDerefiner", _wrap_new_ThresholdDerefiner, METH_O, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, - { "ThresholdDerefiner_SetThreshold", _wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS, "SetThreshold(ThresholdDerefiner self, double thresh)"}, - { "ThresholdDerefiner_SetOp", _wrap_ThresholdDerefiner_SetOp, METH_VARARGS, "SetOp(ThresholdDerefiner self, int op)"}, - { "ThresholdDerefiner_SetNCLimit", _wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS, "SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, + { "new_ThresholdDerefiner", (PyCFunction)(void(*)(void))_wrap_new_ThresholdDerefiner, METH_VARARGS|METH_KEYWORDS, "new_ThresholdDerefiner(ErrorEstimator est) -> ThresholdDerefiner"}, + { "ThresholdDerefiner_SetThreshold", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetThreshold, METH_VARARGS|METH_KEYWORDS, "SetThreshold(ThresholdDerefiner self, double thresh)"}, + { "ThresholdDerefiner_SetOp", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetOp, METH_VARARGS|METH_KEYWORDS, "SetOp(ThresholdDerefiner self, int op)"}, + { "ThresholdDerefiner_SetNCLimit", (PyCFunction)(void(*)(void))_wrap_ThresholdDerefiner_SetNCLimit, METH_VARARGS|METH_KEYWORDS, "SetNCLimit(ThresholdDerefiner self, int nc_limit)"}, { "ThresholdDerefiner_Reset", _wrap_ThresholdDerefiner_Reset, METH_O, "Reset(ThresholdDerefiner self)"}, { "delete_ThresholdDerefiner", _wrap_delete_ThresholdDerefiner, METH_O, "delete_ThresholdDerefiner(ThresholdDerefiner self)"}, { "ThresholdDerefiner_swigregister", ThresholdDerefiner_swigregister, METH_O, NULL}, diff --git a/mfem/_ser/mesh_wrap.cxx b/mfem/_ser/mesh_wrap.cxx index e68eabd6..a4c7fa5d 100644 --- a/mfem/_ser/mesh_wrap.cxx +++ b/mfem/_ser/mesh_wrap.cxx @@ -3705,7 +3705,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) #define SWIG_From_long PyInt_FromLong -SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_32(int nx,int ny,int nz,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0,double sz=1.0){ +SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_12(int nx,int ny,int nz,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0,double sz=1.0){ mfem::Mesh *mesh; if (std::strcmp(type, "POINT")) { mesh = new mfem::Mesh(nx, ny, nz, mfem::Element::POINT, @@ -3741,7 +3741,7 @@ SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_32(int nx,int ny,int nz,char const *t } return mesh; } -SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_37(int nx,int ny,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0){ +SWIGINTERN mfem::Mesh *new_mfem_Mesh__SWIG_13(int nx,int ny,char const *type,int generate_edges=0,double sx=1.0,double sy=1.0){ mfem::Mesh *mesh; if (std::strcmp(type, "POINT")) { mesh = new mfem::Mesh(nx, ny, mfem::Element::POINT, @@ -3865,7 +3865,7 @@ SWIGINTERN PyObject *mfem_Mesh_GetDomainArray(mfem::Mesh const *self,int idx){ } return array; } -SWIGINTERN void mfem_Mesh_PrintInfo__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_PrintInfo__SWIG_1(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3876,7 +3876,7 @@ SWIGINTERN void mfem_Mesh_PrintInfo__SWIG_2(mfem::Mesh *self,char const *file,in self -> PrintInfo(ofile); ofile.close(); } -SWIGINTERN void mfem_Mesh_Print__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_Print__SWIG_1(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3887,7 +3887,7 @@ SWIGINTERN void mfem_Mesh_Print__SWIG_2(mfem::Mesh *self,char const *file,int pr self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_Mesh_PrintXG__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_PrintXG__SWIG_1(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3898,7 +3898,7 @@ SWIGINTERN void mfem_Mesh_PrintXG__SWIG_2(mfem::Mesh *self,char const *file,int self -> PrintXG(ofile); ofile.close(); } -SWIGINTERN void mfem_Mesh_PrintVTK__SWIG_3(mfem::Mesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Mesh_PrintVTK__SWIG_2(mfem::Mesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3955,7 +3955,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -3963,15 +3963,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -4030,17 +4034,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -4099,7 +4105,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -4107,15 +4113,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -4174,17 +4184,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -4532,14 +4544,14 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_s SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; mfem::Mesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Mesh, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); @@ -4548,11 +4560,13 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (mfem::Mesh *)new mfem::Mesh((mfem::Mesh const &)*arg1,arg2); @@ -4580,48 +4594,6 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_s SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Mesh, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh const &""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Mesh *)new mfem::Mesh((mfem::Mesh const &)*arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; @@ -4634,7 +4606,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s int *arg9 = (int *) 0 ; int arg10 ; int arg11 ; - int arg12 ; + int arg12 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; @@ -4651,7 +4623,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s int res9 = 0 ; mfem::Mesh *result = 0 ; - if ((nobjs < 12) || (nobjs > 12)) SWIG_fail; + if ((nobjs < 11) || (nobjs > 12)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "double *""'"); @@ -4711,11 +4683,13 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s }; arg11 = PyArray_PyIntAsInt(swig_obj[10]); } - { - if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg12 = PyArray_PyIntAsInt(swig_obj[11]); + if (swig_obj[11]) { + { + if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg12 = PyArray_PyIntAsInt(swig_obj[11]); + } } { try { @@ -4743,98 +4717,53 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - double *arg1 = (double *) 0 ; + int arg1 ; int arg2 ; - int *arg3 = (int *) 0 ; - mfem::Geometry::Type arg4 ; - int *arg5 = (int *) 0 ; - int arg6 ; - int *arg7 = (int *) 0 ; - mfem::Geometry::Type arg8 ; - int *arg9 = (int *) 0 ; - int arg10 ; - int arg11 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - int val4 ; - int ecode4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - int val8 ; - int ecode8 = 0 ; - void *argp9 = 0 ; - int res9 = 0 ; + int arg3 ; + int arg4 = (int) 0 ; + int arg5 = (int) -1 ; mfem::Mesh *result = 0 ; - if ((nobjs < 11) || (nobjs > 11)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "double *""'"); - } - arg1 = reinterpret_cast< double * >(argp1); + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "int *""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Geometry::Type""'"); - } - arg4 = static_cast< mfem::Geometry::Type >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_Mesh" "', argument " "5"" of type '" "int *""'"); + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - arg5 = reinterpret_cast< int * >(argp5); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "new_Mesh" "', argument " "7"" of type '" "int *""'"); - } - arg7 = reinterpret_cast< int * >(argp7); - ecode8 = SWIG_AsVal_int(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "mfem::Geometry::Type""'"); - } - arg8 = static_cast< mfem::Geometry::Type >(val8); - res9 = SWIG_ConvertPtr(swig_obj[8], &argp9,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res9)) { - SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "new_Mesh" "', argument " "9"" of type '" "int *""'"); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg9 = reinterpret_cast< int * >(argp9); { - if ((PyArray_PyIntAsInt(swig_obj[9]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg10 = PyArray_PyIntAsInt(swig_obj[9]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - { - if ((PyArray_PyIntAsInt(swig_obj[10]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg11 = PyArray_PyIntAsInt(swig_obj[10]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4858,49 +4787,34 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_s } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_NewElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - int arg4 ; - int arg5 ; - mfem::Mesh *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", NULL + }; + mfem::Element *result = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_NewElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); + result = (mfem::Element *)(arg1)->NewElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4917,49 +4831,55 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - int arg4 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = (double *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_AddVertex", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + int i; + if (!PyList_Check(obj1)) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(obj1); + arg2 = (double *) malloc((l)*sizeof(double)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(obj1,i); + if (PyInt_Check(s)) { + arg2[i] = (double)PyFloat_AsDouble(s); + } else if (PyFloat_Check(s)) { + arg2[i] = (double)PyFloat_AsDouble(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer/float"); + return NULL; + } + } } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4); + (arg1)->AddVertex((double const *)arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4976,42 +4896,65 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddSegment", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + int i; + if (!PyList_Check(obj1)) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(obj1); + arg2 = (int *) malloc((l)*sizeof(int)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(obj1,i); + if (PyInt_Check(s)) { + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); + return NULL; + } + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); + (arg1)->AddSegment((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5028,37 +4971,65 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_NewElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_AddTri(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_NewElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddTri", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTri" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + int i; + if (!PyList_Check(obj1)) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(obj1); + arg2 = (int *) malloc((l)*sizeof(int)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(obj1,i); + if (PyInt_Check(s)) { + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); + } else { + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); + return NULL; + } + } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - result = (mfem::Element *)(arg1)->NewElement(arg2); + (arg1)->AddTri((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5075,51 +5046,65 @@ SWIGINTERN PyObject *_wrap_Mesh_NewElement(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_AddTriangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = (double *) 0 ; + int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_AddVertex", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddTriangle", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); - arg2 = (double *) malloc((l)*sizeof(double)); + int l = PyList_Size(obj1); + arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { - arg2[i] = (double)PyFloat_AsDouble(s); - } else if (PyFloat_Check(s)) { - arg2[i] = (double)PyFloat_AsDouble(s); + arg2[i] = (int)PyInt_AsLong(s); + } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { + arg2[i] = PyArray_PyIntAsInt(s); } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer/float"); + free(arg2); + PyErr_SetString(PyExc_ValueError, "List items must be integer"); return NULL; } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddVertex((double const *)arg2); + (arg1)->AddTriangle((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5143,30 +5128,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddVertex(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5178,15 +5169,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddSegment((int const *)arg2,arg3); + (arg1)->AddQuad((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5210,29 +5203,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddTet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddTet", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTet" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5244,9 +5244,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddSegment((int const *)arg2); + (arg1)->AddTet((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5270,86 +5278,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Mesh_AddSegment(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddSegment", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddSegment__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddSegment__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddSegment'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddSegment(int const *,int)\n" - " mfem::Mesh::AddSegment(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddWedge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddWedge", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTri" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddWedge" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5361,15 +5319,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddTri((int const *)arg2,arg3); + (arg1)->AddWedge((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5393,29 +5353,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddHex", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTri" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHex" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5427,9 +5394,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddTri((int const *)arg2); + (arg1)->AddHex((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5453,86 +5428,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTri__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTri(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddTri", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddTri__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddTri__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddTri'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddTri(int const *,int)\n" - " mfem::Mesh::AddTri(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddHexAsTets", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsTets" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5544,15 +5469,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddTriangle((int const *)arg2,arg3); + (arg1)->AddHexAsTets((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5576,29 +5503,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddHexAsWedges", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsWedges" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5610,9 +5544,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddTriangle((int const *)arg2); + (arg1)->AddHexAsWedges((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5636,106 +5578,34 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Mesh_AddTriangle(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddTriangle", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddTriangle__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddTriangle__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddTriangle'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddTriangle(int const *,int)\n" - " mfem::Mesh::AddTriangle(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + mfem::Element *arg2 = (mfem::Element *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"elem", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_AddElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddElement" "', argument " "2"" of type '" "mfem::Element *""'"); } + arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddQuad((int const *)arg2,arg3); + (arg1)->AddElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5759,43 +5629,34 @@ SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + mfem::Element *arg2 = (mfem::Element *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"elem", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_AddBdrElement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddBdrElement" "', argument " "2"" of type '" "mfem::Element *""'"); } + arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddQuad((int const *)arg2); + (arg1)->AddBdrElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5819,86 +5680,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddQuad(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddQuad", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddQuad__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddQuad__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddQuad'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddQuad(int const *,int)\n" - " mfem::Mesh::AddQuad(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrSegment", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTet" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5910,15 +5721,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddTet((int const *)arg2,arg3); + (arg1)->AddBdrSegment((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5942,29 +5755,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrTriangle", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddTet" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -5976,9 +5796,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddTet((int const *)arg2); + (arg1)->AddBdrTriangle((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6002,86 +5830,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddTet__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddTet(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddTet", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddTet__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddTet__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddTet'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddTet(int const *,int)\n" - " mfem::Mesh::AddTet(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; - int arg3 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrQuad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddWedge" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -6093,15 +5871,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - (arg1)->AddWedge((int const *)arg2,arg3); + (arg1)->AddBdrQuad((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6125,29 +5905,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int *arg2 = (int *) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vi", (char *)"attr", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_AddBdrQuadAsTriangles", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddWedge" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuadAsTriangles" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { int i; - if (!PyList_Check(swig_obj[1])) { + if (!PyList_Check(obj1)) { PyErr_SetString(PyExc_ValueError, "Expecting a list"); return NULL; } - int l = PyList_Size(swig_obj[1]); + int l = PyList_Size(obj1); arg2 = (int *) malloc((l)*sizeof(int)); for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (PyInt_Check(s)) { arg2[i] = (int)PyInt_AsLong(s); } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { @@ -6159,9 +5946,17 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } } } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->AddWedge((int const *)arg2); + (arg1)->AddBdrQuadAsTriangles((int const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6185,106 +5980,96 @@ SWIGINTERN PyObject *_wrap_Mesh_AddWedge__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_AddWedge(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_GenerateBoundaryElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddWedge", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddWedge__SWIG_1(self, argc, argv); - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GenerateBoundaryElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddWedge__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + (arg1)->GenerateBoundaryElements(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddWedge'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddWedge(int const *,int)\n" - " mfem::Mesh::AddWedge(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeTriMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTriMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->AddHex((int const *)arg2,arg3); + (arg1)->FinalizeTriMesh(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6308,43 +6093,56 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeQuadMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { - (arg1)->AddHex((int const *)arg2); + (arg1)->FinalizeQuadMesh(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6368,106 +6166,56 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_AddHex(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddHex", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddHex__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddHex__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddHex'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddHex(int const *,int)\n" - " mfem::Mesh::AddHex(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeTetMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsTets" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTetMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->AddHexAsTets((int const *)arg2,arg3); + (arg1)->FinalizeTetMesh(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6491,43 +6239,56 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeWedgeMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsTets" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { - (arg1)->AddHexAsTets((int const *)arg2); + (arg1)->FinalizeWedgeMesh(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6551,106 +6312,56 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsTets(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddHexAsTets", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddHexAsTets__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddHexAsTets__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddHexAsTets'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddHexAsTets(int const *,int)\n" - " mfem::Mesh::AddHexAsTets(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_FinalizeHexMesh", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsWedges" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeHexMesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->AddHexAsWedges((int const *)arg2,arg3); + (arg1)->FinalizeHexMesh(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6674,43 +6385,46 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + int arg2 = (int) 0 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Mesh_FinalizeMesh", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddHexAsWedges" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_FinalizeMesh" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } { try { - (arg1)->AddHexAsWedges((int const *)arg2); + (arg1)->FinalizeMesh(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6734,86 +6448,100 @@ SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges__SWIG_1(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Mesh_AddHexAsWedges(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 = (bool) true ; + void *argp1 = 0 ; + int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"generate_bdr", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddHexAsWedges", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddHexAsWedges__SWIG_1(self, argc, argv); - } - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_FinalizeTopology", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddHexAsWedges__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_FinalizeTopology" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } + { + try { + (arg1)->FinalizeTopology(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddHexAsWedges'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddHexAsWedges(int const *,int)\n" - " mfem::Mesh::AddHexAsWedges(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Element *arg2 = (mfem::Element *) 0 ; + bool arg2 = (bool) false ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + bool val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refine", (char *)"fix_orientation", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_AddElement", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:Mesh_Finalize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddElement" "', argument " "2"" of type '" "mfem::Element *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_Finalize" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddElement(arg2); + (arg1)->Finalize(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6837,30 +6565,23 @@ SWIGINTERN PyObject *_wrap_Mesh_AddElement(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Element *arg2 = (mfem::Element *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_AddBdrElement", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttributes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Element, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_AddBdrElement" "', argument " "2"" of type '" "mfem::Element *""'"); - } - arg2 = reinterpret_cast< mfem::Element * >(argp2); { try { - (arg1)->AddBdrElement(arg2); + (arg1)->SetAttributes(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6884,50 +6605,37 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrElement(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + mfem::Array< int > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ordering", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetHilbertElementOrdering", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - (arg1)->AddBdrSegment((int const *)arg2,arg3); + (arg1)->GetHilbertElementOrdering(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6951,43 +6659,48 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ReorderElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + mfem::Array< int > *arg2 = 0 ; + bool arg3 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ordering", (char *)"reorder_vertices", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_ReorderElements", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrSegment" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorderElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_ReorderElements" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } { try { - (arg1)->AddBdrSegment((int const *)arg2); + (arg1)->ReorderElements((mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7011,106 +6724,186 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrSegment(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + int arg1 ; + int arg2 ; + int arg3 ; + mfem::Element::Type arg4 ; + bool arg5 = (bool) false ; + double arg6 = (double) 1.0 ; + double arg7 = (double) 1.0 ; + double arg8 = (double) 1.0 ; + bool arg9 = (bool) true ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + bool val9 ; + int ecode9 = 0 ; + mfem::Mesh *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrSegment", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrSegment__SWIG_1(self, argc, argv); - } - } + if ((nobjs < 4) || (nobjs > 9)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrSegment__SWIG_0(self, argc, argv); - } - } + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); + } + arg4 = static_cast< mfem::Element::Type >(val4); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + } + if (swig_obj[8]) { + ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Mesh" "', argument " "9"" of type '" "bool""'"); + } + arg9 = static_cast< bool >(val9); + } + { + try { + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrSegment'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrSegment(int const *,int)\n" - " mfem::Mesh::AddBdrSegment(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; + int arg1 ; + int arg2 ; + mfem::Element::Type arg3 ; + bool arg4 = (bool) false ; + double arg5 = (double) 1.0 ; + double arg6 = (double) 1.0 ; + bool arg7 = (bool) true ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + bool val7 ; + int ecode7 = 0 ; + mfem::Mesh *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if ((nobjs < 3) || (nobjs > 7)) SWIG_fail; { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); + } + arg3 = static_cast< mfem::Element::Type >(val3); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "bool""'"); + } + arg7 = static_cast< bool >(val7); } { try { - (arg1)->AddBdrTriangle((int const *)arg2,arg3); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7127,50 +6920,38 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; + int arg1 ; + double arg2 = (double) 1.0 ; + double val2 ; + int ecode2 = 0 ; + mfem::Mesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrTriangle" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } { try { - (arg1)->AddBdrTriangle((int const *)arg2); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7187,113 +6968,130 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrTriangle(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + char *arg1 = (char *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 1 ; + bool arg4 = (bool) true ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + mfem::Mesh *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrTriangle", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrTriangle__SWIG_1(self, argc, argv); - } + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); + } + arg1 = reinterpret_cast< char * >(buf1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrTriangle__SWIG_0(self, argc, argv); - } - } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } - + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + { + try { + result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrTriangle'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrTriangle(int const *,int)\n" - " mfem::Mesh::AddBdrTriangle(int const *)\n"); - return 0; + if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - int arg3 ; + std::istream *arg1 = 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 1 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val4 ; + int ecode4 = 0 ; + mfem::Mesh *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + } + arg1 = reinterpret_cast< std::istream * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->AddBdrQuad((int const *)arg2,arg3); + result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7310,50 +7108,36 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad__SWIG_0(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + mfem::Mesh **arg1 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Mesh *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuad" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *[]""'"); + } + arg1 = reinterpret_cast< mfem::Mesh ** >(argp1); { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - (arg1)->AddBdrQuad((int const *)arg2); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7370,103 +7154,33 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad__SWIG_1(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuad(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrQuad", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrQuad__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrQuad__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrQuad'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrQuad(int const *,int)\n" - " mfem::Mesh::AddBdrQuad(int const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Mesh *result = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuadAsTriangles" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } - } + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { @@ -7476,7 +7190,7 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_0(PyObject *SWIGUNUS } { try { - (arg1)->AddBdrQuadAsTriangles((int const *)arg2,arg3); + result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7493,50 +7207,75 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_0(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; + std::istream *arg2 = 0 ; + int arg3 = (int) 0 ; + int arg4 = (int) 1 ; + bool arg5 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"input", (char *)"generate_edges", (char *)"refine", (char *)"fix_orientation", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Mesh_Load", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_AddBdrQuadAsTriangles" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int i; - if (!PyList_Check(swig_obj[1])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[1]); - arg2 = (int *) malloc((l)*sizeof(int)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); - if (PyInt_Check(s)) { - arg2[i] = (int)PyInt_AsLong(s); - } else if ((PyArray_PyIntAsInt(s) != -1) || !PyErr_Occurred()) { - arg2[i] = PyArray_PyIntAsInt(s); - } else { - free(arg2); - PyErr_SetString(PyExc_ValueError, "List items must be integer"); - return NULL; - } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); } } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_Load" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } { try { - (arg1)->AddBdrQuadAsTriangles((int const *)arg2); + (arg1)->Load(*arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7560,79 +7299,64 @@ SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Mesh_AddBdrQuadAsTriangles(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_AddBdrQuadAsTriangles", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_AddBdrQuadAsTriangles__SWIG_1(self, argc, argv); - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Clear" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyList_Check(argv[1]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_AddBdrQuadAsTriangles__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + (arg1)->Clear(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_AddBdrQuadAsTriangles'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::AddBdrQuadAsTriangles(int const *,int)\n" - " mfem::Mesh::AddBdrQuadAsTriangles(int const *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GenerateBoundaryElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_MeshGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; + int result; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GenerateBoundaryElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MeshGenerator" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->GenerateBoundaryElements(); + result = (int)(arg1)->MeshGenerator(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7649,50 +7373,72 @@ SWIGINTERN PyObject *_wrap_Mesh_GenerateBoundaryElements(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNV" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + result = (int)((mfem::Mesh const *)arg1)->GetNV(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTriMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeTriMesh(arg2,arg3,arg4); + result = (int)((mfem::Mesh const *)arg1)->GetNE(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7709,42 +7455,72 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNBE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + result = (int)((mfem::Mesh const *)arg1)->GetNBE(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeTriMesh(arg2,arg3); + result = (int)((mfem::Mesh const *)arg1)->GetNEdges(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7761,35 +7537,31 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - (arg1)->FinalizeTriMesh(arg2); + result = (int)((mfem::Mesh const *)arg1)->GetNFaces(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7806,28 +7578,31 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_2(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNumFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTriMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeTriMesh(); + result = (int)((mfem::Mesh const *)arg1)->GetNumFaces(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7844,162 +7619,134 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh__SWIG_3(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTriMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::FaceType arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + int val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"type", NULL }; + int result; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTriMesh", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_2(self, argc, argv); - } - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetNFbyType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFbyType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_1(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_int(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); + } + arg2 = static_cast< mfem::FaceType >(val2); + { + try { + result = (int)((mfem::Mesh const *)arg1)->GetNFbyType(arg2); } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeTriMesh__SWIG_0(self, argc, argv); - } - } - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTriMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeTriMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeTriMesh(int,int)\n" - " mfem::Mesh::FinalizeTriMesh(int)\n" - " mfem::Mesh::FinalizeTriMesh()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; + long result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_ReduceInt", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReduceInt" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + try { + result = (long)((mfem::Mesh const *)arg1)->ReduceInt(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + resultobj = SWIG_From_long(static_cast< long >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetGlobalNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + long result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGlobalNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeQuadMesh(arg2,arg3,arg4); + result = (long)((mfem::Mesh const *)arg1)->GetGlobalNE(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8016,42 +7763,53 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::IntegrationRule *arg2 = 0 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"flags", NULL + }; + mfem::GeometricFactors *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetGeometricFactors", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { - (arg1)->FinalizeQuadMesh(arg2,arg3); + result = (mfem::GeometricFactors *)(arg1)->GetGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8068,35 +7826,62 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::IntegrationRule *arg2 = 0 ; + int arg3 ; + mfem::FaceType arg4 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + int val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", (char *)"flags", (char *)"type", NULL + }; + mfem::FaceGeometricFactors *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceGeometricFactors", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); + } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(obj2); } + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); + } + arg4 = static_cast< mfem::FaceType >(val4); { try { - (arg1)->FinalizeQuadMesh(arg2); + result = (mfem::FaceGeometricFactors *)(arg1)->GetFaceGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8113,28 +7898,30 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_2(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_DeleteGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeQuadMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DeleteGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeQuadMesh(); + (arg1)->DeleteGeometricFactors(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8158,155 +7945,65 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh__SWIG_3(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeQuadMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeQuadMesh", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_2(self, argc, argv); - } - } +SWIGINTERN PyObject *_wrap_Mesh_EulerNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_1(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (int)((mfem::Mesh const *)arg1)->EulerNumber(); } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeQuadMesh__SWIG_0(self, argc, argv); - } - } - } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeQuadMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeQuadMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeQuadMesh(int,int)\n" - " mfem::Mesh::FinalizeQuadMesh(int)\n" - " mfem::Mesh::FinalizeQuadMesh()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_EulerNumber2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber2D" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeTetMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - (arg1)->FinalizeTetMesh(arg2,arg3,arg4); + result = (int)((mfem::Mesh const *)arg1)->EulerNumber2D(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8323,42 +8020,72 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Dimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Dimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + result = (int)((mfem::Mesh const *)arg1)->Dimension(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_SpaceDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SpaceDimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - (arg1)->FinalizeTetMesh(arg2,arg3); + result = (int)((mfem::Mesh const *)arg1)->SpaceDimension(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8375,24 +8102,25 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -8403,7 +8131,7 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_2(PyObject *SWIGUNUSEDPARM } { try { - (arg1)->FinalizeTetMesh(arg2); + result = (double *)((mfem::Mesh const *)arg1)->GetVertex(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8420,28 +8148,36 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_2(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - (arg1)->FinalizeTetMesh(); + result = (double *)(arg1)->GetVertex(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8458,30 +8194,21 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh__SWIG_3(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertex(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTetMesh", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetVertex", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_3(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; @@ -8497,11 +8224,11 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_2(self, argc, argv); + return _wrap_Mesh_GetVertex__SWIG_1(self, argc, argv); } } } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -8516,104 +8243,71 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTetMesh(PyObject *self, PyObject *args) } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeTetMesh__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_GetVertex__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTetMesh'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetVertex'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeTetMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeTetMesh(int,int)\n" - " mfem::Mesh::FinalizeTetMesh(int)\n" - " mfem::Mesh::FinalizeTetMesh()\n"); + " mfem::Mesh::GetVertex(int) const\n" + " mfem::Mesh::GetVertex(int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - bool arg4 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", (char *)"elem_vtx", (char *)"attr", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetElementData", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->FinalizeWedgeMesh(arg2,arg3,arg4); + ((mfem::Mesh const *)arg1)->GetElementData(arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8637,35 +8331,127 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", (char *)"bdr_elem_vtx", (char *)"bdr_attr", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetBdrElementData", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + try { + ((mfem::Mesh const *)arg1)->GetBdrElementData(arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double *arg2 = (double *) 0 ; + int arg3 ; + bool arg4 = (bool) false ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertices", (char *)"len_vertices", (char *)"zerocopy", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_ChangeVertexDataOwnership", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "2"" of type '" "double *""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); + } + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } { try { - (arg1)->FinalizeWedgeMesh(arg2,arg3); + (arg1)->ChangeVertexDataOwnership(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8689,17 +8475,59 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementsArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Element **result = 0 ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementsArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (mfem::Element **)((mfem::Mesh const *)arg1)->GetElementsArray(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_mfem__Element, 0 | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Element *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -8710,7 +8538,7 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_2(PyObject *SWIGUNUSEDPA } { try { - (arg1)->FinalizeWedgeMesh(arg2); + result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8727,28 +8555,36 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_2(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Element *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeWedgeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } { try { - (arg1)->FinalizeWedgeMesh(); + result = (mfem::Element *)(arg1)->GetElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8765,30 +8601,21 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh__SWIG_3(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElement(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeWedgeMesh", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElement", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_3(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; @@ -8804,11 +8631,11 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *self, PyObject *args } } if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_2(self, argc, argv); + return _wrap_Mesh_GetElement__SWIG_1(self, argc, argv); } } } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -8823,139 +8650,32 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeWedgeMesh(PyObject *self, PyObject *args } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeWedgeMesh__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_GetElement__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeWedgeMesh'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElement'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeWedgeMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeWedgeMesh(int,int)\n" - " mfem::Mesh::FinalizeWedgeMesh(int)\n" - " mfem::Mesh::FinalizeWedgeMesh()\n"); + " mfem::Mesh::GetElement(int) const\n" + " mfem::Mesh::GetElement(int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_FinalizeHexMesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - (arg1)->FinalizeHexMesh(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Element *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -8964,15 +8684,9 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_1(PyObject *SWIGUNUSEDPARM }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - (arg1)->FinalizeHexMesh(arg2,arg3); + result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetBdrElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8989,24 +8703,25 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_1(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + mfem::Element *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -9017,45 +8732,7 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_2(PyObject *SWIGUNUSEDPARM } { try { - (arg1)->FinalizeHexMesh(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeHexMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->FinalizeHexMesh(); + result = (mfem::Element *)(arg1)->GetBdrElement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9072,30 +8749,21 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh__SWIG_3(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[5] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeHexMesh", 0, 4, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElement", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_3(self, argc, argv); - } - } if (argc == 2) { int _v; void *vptr = 0; @@ -9111,40 +8779,11 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_1(self, argc, argv); - } + return _wrap_Mesh_GetBdrElement__SWIG_1(self, argc, argv); } } } - if (argc == 4) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -9159,68 +8798,48 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeHexMesh(PyObject *self, PyObject *args) } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeHexMesh__SWIG_0(self, argc, argv); - } - } + return _wrap_Mesh_GetBdrElement__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeHexMesh'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElement'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeHexMesh(int,int,bool)\n" - " mfem::Mesh::FinalizeHexMesh(int,int)\n" - " mfem::Mesh::FinalizeHexMesh(int)\n" - " mfem::Mesh::FinalizeHexMesh()\n"); + " mfem::Mesh::GetBdrElement(int) const\n" + " mfem::Mesh::GetBdrElement(int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Element *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_FinalizeMesh" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); { try { - (arg1)->FinalizeMesh(arg2,arg3); + result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetFace(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9237,35 +8856,41 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Geometry::Type result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFaceBaseGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - (arg1)->FinalizeMesh(arg2); + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceBaseGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9282,28 +8907,41 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Geometry::Type result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetElementBaseGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->FinalizeMesh(); + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetElementBaseGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9320,108 +8958,93 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL }; + mfem::Geometry::Type result; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeMesh", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeMesh__SWIG_2(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrElementBaseGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_FinalizeMesh__SWIG_1(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeMesh__SWIG_0(self, argc, argv); - } - } + { + try { + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetBdrElementBaseGeometry(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_From_int(static_cast< int >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeMesh(int,bool)\n" - " mfem::Mesh::FinalizeMesh(int)\n" - " mfem::Mesh::FinalizeMesh()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_HasGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; + mfem::Geometry::Type arg2 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; + int val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"geom", NULL + }; + bool result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_HasGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_HasGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_FinalizeTopology" "', argument " "2"" of type '" "bool""'"); + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_HasGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } - arg2 = static_cast< bool >(val2); + arg2 = static_cast< mfem::Geometry::Type >(val2); { try { - (arg1)->FinalizeTopology(arg2); + result = (bool)((mfem::Mesh const *)arg1)->HasGeometry(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9438,28 +9061,41 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNumGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; + int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetNumGeometries", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FinalizeTopology" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->FinalizeTopology(); + result = (int)((mfem::Mesh const *)arg1)->GetNumGeometries(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9476,86 +9112,52 @@ SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FinalizeTopology(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FinalizeTopology", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FinalizeTopology__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FinalizeTopology__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FinalizeTopology'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FinalizeTopology(bool)\n" - " mfem::Mesh::FinalizeTopology()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - bool arg3 ; + int arg2 ; + mfem::Array< mfem::Geometry::Type > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", (char *)"el_geoms", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetGeometries", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_Finalize" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< mfem::Geometry::Type > * >(argp3); { try { - (arg1)->Finalize(arg2,arg3); + ((mfem::Mesh const *)arg1)->GetGeometries(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9579,29 +9181,45 @@ SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetElementVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_Finalize" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->Finalize(arg2); + ((mfem::Mesh const *)arg1)->GetElementVertices(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9625,21 +9243,45 @@ SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetBdrElementVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Finalize" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->Finalize(); + ((mfem::Mesh const *)arg1)->GetBdrElementVertices(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9663,87 +9305,131 @@ SWIGINTERN PyObject *_wrap_Mesh_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_GetElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"edges", (char *)"cor", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Finalize", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Finalize__SWIG_2(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetElementEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_Finalize__SWIG_1(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_Finalize__SWIG_0(self, argc, argv); - } - } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + { + try { + ((mfem::Mesh const *)arg1)->GetElementEdges(arg2,*arg3,*arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Finalize(bool,bool)\n" - " mfem::Mesh::Finalize(bool)\n" - " mfem::Mesh::Finalize()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"edges", (char *)"cor", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetBdrElementEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttributes" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->SetAttributes(); + ((mfem::Mesh const *)arg1)->GetBdrElementEdges(arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9767,33 +9453,57 @@ SWIGINTERN PyObject *_wrap_Mesh_SetAttributes(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"arg3", (char *)"arg4", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetHilbertElementOrdering", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceEdges", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetHilbertElementOrdering" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - (arg1)->GetHilbertElementOrdering(*arg2); + ((mfem::Mesh const *)arg1)->GetFaceEdges(arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9817,40 +9527,45 @@ SWIGINTERN PyObject *_wrap_Mesh_GetHilbertElementOrdering(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - bool arg3 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vert", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetFaceVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorderElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_ReorderElements" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ReorderElements((mfem::Array< int > const &)*arg2,arg3); + ((mfem::Mesh const *)arg1)->GetFaceVertices(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9874,32 +9589,45 @@ SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; + int arg2 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"vert", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetEdgeVertices", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorderElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_ReorderElements" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - (arg1)->ReorderElements((mfem::Array< int > const &)*arg2); + ((mfem::Mesh const *)arg1)->GetEdgeVertices(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9923,133 +9651,65 @@ SWIGINTERN PyObject *_wrap_Mesh_ReorderElements__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_Mesh_ReorderElements(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_ReorderElements", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_ReorderElements__SWIG_1(self, argc, argv); - } - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_ReorderElements__SWIG_0(self, argc, argv); - } - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceEdgeTable(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_ReorderElements'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::ReorderElements(mfem::Array< int > const &,bool)\n" - " mfem::Mesh::ReorderElements(mfem::Array< int > const &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertexTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - bool arg9 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - bool val9 ; - int ecode9 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertexTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - ecode9 = SWIG_AsVal_bool(swig_obj[8], &val9); - if (!SWIG_IsOK(ecode9)) { - SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_Mesh" "', argument " "9"" of type '" "bool""'"); - } - arg9 = static_cast< bool >(val9); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetEdgeVertexTable(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10066,82 +9726,64 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"arg3", (char *)"arg4", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetElementFaces", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + ((mfem::Mesh const *)arg1)->GetElementFaces(arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10158,74 +9800,51 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_10(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - double arg7 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; + int *arg3 = (int *) 0 ; + int *arg4 = (int *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementFace" "', argument " "3"" of type '" "int *""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementFace" "', argument " "4"" of type '" "int *""'"); + } + arg4 = reinterpret_cast< int * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + ((mfem::Mesh const *)arg1)->GetBdrElementFace(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10242,66 +9861,41 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_11(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdgeIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - double arg6 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + int result; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrElementEdgeIndex", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdgeIndex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6); + result = (int)((mfem::Mesh const *)arg1)->GetBdrElementEdgeIndex(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10318,58 +9912,64 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementAdjacentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - bool arg5 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; + int *arg3 = 0 ; + int *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_el", (char *)"el", (char *)"info", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetBdrElementAdjacentElement", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); + } + arg4 = reinterpret_cast< int * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); + ((mfem::Mesh const *)arg1)->GetBdrElementAdjacentElement(arg2,*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10386,50 +9986,41 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - mfem::Element::Type arg4 ; - int val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Element::Type result; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "mfem::Element::Type""'"); - } - arg4 = static_cast< mfem::Element::Type >(val4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4); + result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetElementType(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10446,75 +10037,41 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_14(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_15(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - double arg5 ; - double arg6 ; - bool arg7 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - bool val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + mfem::Element::Type result; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_bool(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "bool""'"); - } - arg7 = static_cast< bool >(val7); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetBdrElementType(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10531,67 +10088,52 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_15(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_16(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - double arg5 ; - double arg6 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"pointmat", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetPointMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5,arg6); + ((mfem::Mesh const *)arg1)->GetPointMatrix(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10608,59 +10150,52 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_16(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_17(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - double arg5 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; + mfem::DenseMatrix *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"pointmat", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetBdrPointMatrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4,arg5); + ((mfem::Mesh const *)arg1)->GetBdrPointMatrix(arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10677,51 +10212,33 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_17(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_18(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetTransformationFEforElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::Element::Type arg3 ; - bool arg4 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Element::Type arg1 ; + int val1 ; + int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"arg1", NULL + }; + mfem::FiniteElement *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Mesh_GetTransformationFEforElementType", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_int(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Mesh_GetTransformationFEforElementType" "', argument " "1"" of type '" "mfem::Element::Type""'"); } - arg4 = static_cast< bool >(val4); + arg1 = static_cast< mfem::Element::Type >(val1); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3,arg4); + result = (mfem::FiniteElement *)mfem::Mesh::GetTransformationFEforElementType(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10738,43 +10255,43 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_18(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_19(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Element::Type arg3 ; - int val3 ; - int ecode3 = 0 ; - mfem::Mesh *result = 0 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Mesh" "', argument " "3"" of type '" "mfem::Element::Type""'"); - } - arg3 = static_cast< mfem::Element::Type >(val3); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + } + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); + (arg1)->GetElementTransformation(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10791,36 +10308,36 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_19(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_20(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - double val2 ; - int ecode2 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::ElementTransformation *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Mesh" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); + result = (mfem::ElementTransformation *)(arg1)->GetElementTransformation(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10837,28 +10354,54 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_20(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_21(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::Vector *arg3 = 0 ; + mfem::IsoparametricTransformation *arg4 = (mfem::IsoparametricTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation *""'"); } + arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1); + (arg1)->GetElementTransformation(arg2,(mfem::Vector const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10875,52 +10418,126 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_21(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_22(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementTransformation", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetElementTransformation__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetElementTransformation__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetElementTransformation__SWIG_2(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementTransformation'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetElementTransformation(int,mfem::IsoparametricTransformation *)\n" + " mfem::Mesh::GetElementTransformation(int)\n" + " mfem::Mesh::GetElementTransformation(int,mfem::Vector const &,mfem::IsoparametricTransformation *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - bool arg4 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::ElementTransformation *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< char * >(buf1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2,arg3,arg4); + result = (mfem::ElementTransformation *)(arg1)->GetBdrElementTransformation(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10937,46 +10554,43 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_22(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_23(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::Mesh *result = 0 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< char * >(buf1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); } + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2,arg3); + (arg1)->GetBdrElementTransformation(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10993,39 +10607,104 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_23(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_24(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int arg2 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); +SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementTransformation", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetBdrElementTransformation__SWIG_0(self, argc, argv); + } + } } - arg1 = reinterpret_cast< char * >(buf1); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetBdrElementTransformation__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementTransformation'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetBdrElementTransformation(int)\n" + " mfem::Mesh::GetBdrElementTransformation(int,mfem::IsoparametricTransformation *)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + } + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1,arg2); + (arg1)->GetFaceTransformation(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11042,32 +10721,68 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_24(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_25(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetLocalFaceTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - char *arg1 = (char *) 0 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::Mesh *result = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 ; + mfem::IsoparametricTransformation *arg4 = 0 ; + int arg5 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face_type", (char *)"elem_type", (char *)"Transf", (char *)"info", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:Mesh_GetLocalFaceTransformation", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "char const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__IsoparametricTransformation, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); + } + arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); } - arg1 = reinterpret_cast< char * >(buf1); { try { - result = (mfem::Mesh *)new mfem::Mesh((char const *)arg1); + (arg1)->GetLocalFaceTransformation(arg2,arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11084,56 +10799,36 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_25(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; + resultobj = SWIG_Py_Void(); return resultobj; fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_26(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - std::istream *arg1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; - bool arg4 ; void *argp1 = 0 ; int res1 = 0 ; - bool val4 ; - int ecode4 = 0 ; - mfem::Mesh *result = 0 ; + mfem::ElementTransformation *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< std::istream * >(argp1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Mesh" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2,arg3,arg4); + result = (mfem::ElementTransformation *)(arg1)->GetFaceTransformation(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11150,46 +10845,104 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_26(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_27(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetFaceTransformation", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetFaceTransformation__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetFaceTransformation__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetFaceTransformation'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetFaceTransformation(int,mfem::IsoparametricTransformation *)\n" + " mfem::Mesh::GetFaceTransformation(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - std::istream *arg1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; + mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< std::istream * >(argp1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); } + arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2,arg3); + (arg1)->GetEdgeTransformation(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11206,30 +10959,27 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_27(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_28(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - std::istream *arg1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + mfem::ElementTransformation *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg1 = reinterpret_cast< std::istream * >(argp1); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -11238,7 +10988,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_28(PyObject *SWIGUNUSEDPARM(self), Py_ } { try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1,arg2); + result = (mfem::ElementTransformation *)(arg1)->GetEdgeTransformation(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11255,32 +11005,112 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_28(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_29(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetEdgeTransformation", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetEdgeTransformation__SWIG_1(self, argc, argv); + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetEdgeTransformation__SWIG_0(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetEdgeTransformation'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetEdgeTransformation(int,mfem::IsoparametricTransformation *)\n" + " mfem::Mesh::GetEdgeTransformation(int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - std::istream *arg1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 = (int) 31 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FaceNo", (char *)"mask", NULL + }; + mfem::FaceElementTransformations *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__istream, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_GetFaceElementTransformations", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Mesh" "', argument " "1"" of type '" "std::istream &""'"); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - arg1 = reinterpret_cast< std::istream * >(argp1); { try { - result = (mfem::Mesh *)new mfem::Mesh(*arg1); + result = (mfem::FaceElementTransformations *)(arg1)->GetFaceElementTransformations(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11297,36 +11127,41 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_29(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_30(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetInteriorFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Mesh **arg1 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FaceNo", NULL + }; + mfem::FaceElementTransformations *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetInteriorFaceTransformations", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *[]""'"); - } - arg1 = reinterpret_cast< mfem::Mesh ** >(argp1); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetInteriorFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2); + result = (mfem::FaceElementTransformations *)(arg1)->GetInteriorFaceTransformations(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11343,43 +11178,41 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_30(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_31(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Mesh *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"BdrElemNo", NULL + }; + mfem::FaceElementTransformations *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrFaceTransformations", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - result = (mfem::Mesh *)new mfem::Mesh(arg1,arg2,arg3); + result = (mfem::FaceElementTransformations *)(arg1)->GetBdrFaceTransformations(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11396,61 +11229,41 @@ SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_31(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FaceIsInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; - int arg4 ; - bool arg5 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val5 ; - int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"FaceNo", NULL + }; + bool result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_FaceIsInterior", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FaceIsInterior" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_Load" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); { try { - (arg1)->Load(*arg2,arg3,arg4,arg5); + result = (bool)((mfem::Mesh const *)arg1)->FaceIsInterior(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11467,53 +11280,58 @@ SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; - int arg4 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int *arg4 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", (char *)"Elem1", (char *)"Elem2", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceElements", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElements" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceElements" "', argument " "3"" of type '" "int *""'"); + } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceElements" "', argument " "4"" of type '" "int *""'"); } + arg4 = reinterpret_cast< int * >(argp4); { try { - (arg1)->Load(*arg2,arg3,arg4); + ((mfem::Mesh const *)arg1)->GetFaceElements(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11537,39 +11355,51 @@ SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceInfos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; - int arg3 ; + int arg2 ; + int *arg3 = (int *) 0 ; + int *arg4 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", (char *)"Inf1", (char *)"Inf2", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Mesh_GetFaceInfos", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceInfos" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceInfos" "', argument " "3"" of type '" "int *""'"); } + arg3 = reinterpret_cast< int * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceInfos" "', argument " "4"" of type '" "int *""'"); + } + arg4 = reinterpret_cast< int * >(argp4); { try { - (arg1)->Load(*arg2,arg3); + ((mfem::Mesh const *)arg1)->GetFaceInfos(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11593,32 +11423,34 @@ SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", NULL + }; + mfem::Geometry::Type result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFaceGeometryType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Load" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometryType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Load" "', argument " "2"" of type '" "std::istream &""'"); - } - arg2 = reinterpret_cast< std::istream * >(argp2); { - try { - (arg1)->Load(*arg2); + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + try { + result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceGeometryType(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11635,162 +11467,41 @@ SWIGINTERN PyObject *_wrap_Mesh_Load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Load(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Load", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Load__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Load__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_Load__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_Load__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Load'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Load(std::istream &,int,int,bool)\n" - " mfem::Mesh::Load(std::istream &,int,int)\n" - " mfem::Mesh::Load(std::istream &,int)\n" - " mfem::Mesh::Load(std::istream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Face", NULL + }; + mfem::Element::Type result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetFaceElementType", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Clear" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - (arg1)->Clear(); + result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetFaceElementType(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11807,31 +11518,44 @@ SWIGINTERN PyObject *_wrap_Mesh_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_MeshGenerator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fix_it", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_CheckElementOrientation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MeshGenerator" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckElementOrientation" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int)(arg1)->MeshGenerator(); + result = (int)(arg1)->CheckElementOrientation(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11855,24 +11579,37 @@ SWIGINTERN PyObject *_wrap_Mesh_MeshGenerator(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_GetNV(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fix_it", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_CheckBdrElementOrientation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNV" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNV(); + result = (int)(arg1)->CheckBdrElementOrientation(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11896,24 +11633,34 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNV(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Mesh_GetNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNE(); + result = (int)((mfem::Mesh const *)arg1)->GetAttribute(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11937,24 +11684,41 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNE(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Mesh_GetNBE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"attr", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_SetAttribute", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNBE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttribute" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNBE(); + (arg1)->SetAttribute(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -11971,31 +11735,41 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNBE(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrAttribute", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNEdges(); + result = (int)((mfem::Mesh const *)arg1)->GetBdrAttribute(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12019,24 +11793,24 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Mesh_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_ElementToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int result; + mfem::Table *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (int)((mfem::Mesh const *)arg1)->GetNFaces(); + result = (mfem::Table *) &(arg1)->ElementToElementTable(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12053,31 +11827,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNumFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_ElementToFaceTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - int result; + mfem::Table *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToFaceTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (int)((mfem::Mesh const *)arg1)->GetNumFaces(); + result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToFaceTable(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12094,38 +11868,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNumFaces(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_ElementToEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FaceType arg2 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - int result; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNFbyType", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNFbyType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_GetNFbyType" "', argument " "2"" of type '" "mfem::FaceType""'"); - } - arg2 = static_cast< mfem::FaceType >(val2); { try { - result = (int)((mfem::Mesh const *)arg1)->GetNFbyType(arg2); + result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToEdgeTable(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12142,37 +11909,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNFbyType(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertexToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - long result; + PyObject *swig_obj[1] ; + mfem::Table *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_ReduceInt", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReduceInt" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (long)((mfem::Mesh const *)arg1)->ReduceInt(arg2); + result = (mfem::Table *)(arg1)->GetVertexToElementTable(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12189,31 +11950,31 @@ SWIGINTERN PyObject *_wrap_Mesh_ReduceInt(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_long(static_cast< long >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetGlobalNE(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetFaceToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyObject *swig_obj[1] ; - long result; + mfem::Table *result = 0 ; if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGlobalNE" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceToElementTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (long)((mfem::Mesh const *)arg1)->GetGlobalNE(); + result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceToElementTable(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12230,48 +11991,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetGlobalNE(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_long(static_cast< long >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_ReorientTetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::IntegrationRule *arg2 = 0 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[3] ; - mfem::GeometricFactors *result = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetGeometricFactors", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorientTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (mfem::GeometricFactors *)(arg1)->GetGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3); + (arg1)->ReorientTetMesh(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12288,56 +12031,42 @@ SWIGINTERN PyObject *_wrap_Mesh_GetGeometricFactors(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeometricFactors, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CartesianPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::IntegrationRule *arg2 = 0 ; - int arg3 ; - mfem::FaceType arg4 ; + int *arg2 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - int val4 ; - int ecode4 = 0 ; - PyObject *swig_obj[4] ; - mfem::FaceGeometricFactors *result = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nxyz", NULL + }; + int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_CartesianPartitioning", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CartesianPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_GetFaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CartesianPartitioning" "', argument " "2"" of type '" "int []""'"); } - arg4 = static_cast< mfem::FaceType >(val4); + arg2 = reinterpret_cast< int * >(argp2); { try { - result = (mfem::FaceGeometricFactors *)(arg1)->GetFaceGeometricFactors((mfem::IntegrationRule const &)*arg2,arg3,arg4); + result = (int *)(arg1)->CartesianPartitioning(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12354,30 +12083,51 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometricFactors(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceGeometricFactors, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_DeleteGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nparts", (char *)"part_method", NULL + }; + int *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_GeneratePartitioning", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DeleteGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneratePartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + } { try { - (arg1)->DeleteGeometricFactors(); + result = (int *)(arg1)->GeneratePartitioning(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12394,31 +12144,41 @@ SWIGINTERN PyObject *_wrap_Mesh_DeleteGeometricFactors(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_EulerNumber(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CheckPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int *arg2 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"partitioning", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_CheckPartitioning", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckPartitioning" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); { try { - result = (int)((mfem::Mesh const *)arg1)->EulerNumber(); + (arg1)->CheckPartitioning(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12435,31 +12195,56 @@ SWIGINTERN PyObject *_wrap_Mesh_EulerNumber(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_EulerNumber2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_CheckDisplacements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; + double *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"displacements", (char *)"tmax", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_CheckDisplacements", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EulerNumber2D" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckDisplacements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); + } + arg3 = reinterpret_cast< double * >(argp3); { try { - result = (int)((mfem::Mesh const *)arg1)->EulerNumber2D(); + (arg1)->CheckDisplacements((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12476,31 +12261,44 @@ SWIGINTERN PyObject *_wrap_Mesh_EulerNumber2D(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_Dimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_MoveVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"displacements", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_MoveVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Dimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (int)((mfem::Mesh const *)arg1)->Dimension(); + (arg1)->MoveVertices((mfem::Vector const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12517,31 +12315,44 @@ SWIGINTERN PyObject *_wrap_Mesh_Dimension(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_SpaceDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vert_coord", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SpaceDimension" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (int)((mfem::Mesh const *)arg1)->SpaceDimension(); + ((mfem::Mesh const *)arg1)->GetVertices(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12558,36 +12369,44 @@ SWIGINTERN PyObject *_wrap_Mesh_SpaceDimension(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vert_coord", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (double *)((mfem::Mesh const *)arg1)->GetVertex(arg2); + (arg1)->SetVertices((mfem::Vector const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12604,36 +12423,49 @@ SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + double *arg3 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - double *result = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"coord", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_GetNode", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetNode" "', argument " "3"" of type '" "double *""'"); } + arg3 = reinterpret_cast< double * >(argp3); { try { - result = (double *)(arg1)->GetVertex(arg2); + ((mfem::Mesh const *)arg1)->GetNode(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12650,114 +12482,63 @@ SWIGINTERN PyObject *_wrap_Mesh_GetVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetVertex(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetVertex", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetVertex__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetVertex__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetVertex'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetVertex(int) const\n" - " mfem::Mesh::GetVertex(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + double *arg3 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"coord", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementData", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_SetNode", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNode" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + { + int i; + if (!PyList_Check(obj2)) { + PyErr_SetString(PyExc_ValueError, "Expecting a list"); + return NULL; + } + int l = PyList_Size(obj2); + arg3 = (double *) malloc((l)*sizeof(double)); + for (i = 0; i < l; i++) { + PyObject *s = PyList_GetItem(obj2,i); + if (PyInt_Check(s)) { + arg3[i] = (double)PyFloat_AsDouble(s); + } else if (PyFloat_Check(s)) { + arg3[i] = (double)PyFloat_AsDouble(s); + } else { + free(arg3); + PyErr_SetString(PyExc_ValueError, "List items must be integer/float"); + return NULL; + } + } } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetElementData(arg2,*arg3,*arg4); + (arg1)->SetNode(arg2,(double const *)arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12781,51 +12562,37 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementData(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_MoveNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"displacements", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementData", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_MoveNodes", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementData" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementData" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementData(arg2,*arg3,*arg4); + (arg1)->MoveNodes((mfem::Vector const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12849,44 +12616,32 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementData(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = (double *) 0 ; - int arg3 ; - bool arg4 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - bool val4 ; - int ecode4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "2"" of type '" "double *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); } - arg2 = reinterpret_cast< double * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->ChangeVertexDataOwnership(arg2,arg3,arg4); + ((mfem::Mesh const *)arg1)->GetNodes(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12910,36 +12665,37 @@ SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership__SWIG_0(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = (double *) 0 ; - int arg3 ; + mfem::Vector *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"node_coord", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetNodes", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_ChangeVertexDataOwnership" "', argument " "2"" of type '" "double *""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< double * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - (arg1)->ChangeVertexDataOwnership(arg2,arg3); + (arg1)->SetNodes((mfem::Vector const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12963,96 +12719,61 @@ SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership__SWIG_1(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Mesh_ChangeVertexDataOwnership(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + mfem::GridFunction *result = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_ChangeVertexDataOwnership", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_ChangeVertexDataOwnership__SWIG_1(self, argc, argv); - } - } + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + try { + result = (mfem::GridFunction *)(arg1)->GetNodes(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_ChangeVertexDataOwnership__SWIG_0(self, argc, argv); - } - } - } - } - } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_ChangeVertexDataOwnership'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::ChangeVertexDataOwnership(double *,int,bool)\n" - " mfem::Mesh::ChangeVertexDataOwnership(double *,int)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementsArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Element **result = 0 ; + mfem::GridFunction *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementsArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Element **)((mfem::Mesh const *)arg1)->GetElementsArray(); + result = (mfem::GridFunction *)((mfem::Mesh const *)arg1)->GetNodes(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13069,36 +12790,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementsArray(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_OwnsNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + PyObject *swig_obj[1] ; + bool result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_OwnsNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetElement(arg2); + result = (bool)((mfem::Mesh const *)arg1)->OwnsNodes(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13115,36 +12831,41 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SetNodesOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + bool arg2 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes_owner", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetNodesOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodesOwner" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_SetNodesOwner" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); { try { - result = (mfem::Element *)(arg1)->GetElement(arg2); + (arg1)->SetNodesOwner(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13161,92 +12882,115 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_NewNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::GridFunction *arg2 = 0 ; + bool arg3 = (bool) false ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes", (char *)"make_owner", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElement__SWIG_1(self, argc, argv); - } - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_NewNodes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElement__SWIG_0(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_NewNodes" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } + { + try { + (arg1)->NewNodes(*arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElement(int) const\n" - " mfem::Mesh::GetElement(int)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_SwapNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::GridFunction **arg2 = 0 ; + int *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + mfem::GridFunction *Pnodes2 ; + int own_nodes3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes", (char *)"own_nodes_", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_SwapNodes", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SwapNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + int res2 = 0; + res2 = SWIG_ConvertPtr(obj1, (void **) &Pnodes2, SWIGTYPE_p_mfem__GridFunction, 0); + if (!SWIG_IsOK(res2)){ + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SwapNodes" "', argument " "2"" of type '" "*mfem::GridFunction""'"); + } + arg2 = &Pnodes2; + } + { + own_nodes3 = (int)PyInt_AsLong(obj2); + arg3 = &own_nodes3; } { try { - result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetBdrElement(arg2); + (arg1)->SwapNodes(*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13263,36 +13007,47 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); + { + Py_XDECREF(resultobj); + resultobj = PyList_New(0); + resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_mfem__GridFunction, 0 | 0 )); + } + { + resultobj = SWIG_Python_AppendOutput(resultobj, PyLong_FromLong((long)*arg3)); + } return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::GridFunction *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::Element *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElement" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); { try { - result = (mfem::Element *)(arg1)->GetBdrElement(arg2); + ((mfem::Mesh const *)arg1)->GetNodes(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13309,93 +13064,107 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElement(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodes(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElement", 0, 2, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetNodes", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetBdrElement__SWIG_1(self, argc, argv); - } + return _wrap_Mesh_GetNodes__SWIG_1(self, argc, argv); } } - if (argc == 2) { + if (argc == 1) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + return _wrap_Mesh_GetNodes__SWIG_2(self, argc, argv); + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetNodes__SWIG_3(self, argc, argv); } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetBdrElement__SWIG_0(self, argc, argv); + return _wrap_Mesh_GetNodes__SWIG_0(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElement'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetNodes'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBdrElement(int) const\n" - " mfem::Mesh::GetBdrElement(int)\n"); + " mfem::Mesh::GetNodes(mfem::Vector &) const\n" + " mfem::Mesh::GetNodes()\n" + " mfem::Mesh::GetNodes() const\n" + " mfem::Mesh::GetNodes(mfem::GridFunction &) const\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetFace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nfes", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_SetNodalFESpace", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalFESpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); } + arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); { try { - result = (mfem::Element *)((mfem::Mesh const *)arg1)->GetFace(arg2); + (arg1)->SetNodalFESpace(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13412,37 +13181,52 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFace(PyObject *SWIGUNUSEDPARM(self), PyObject SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Element, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + void *argp2 = 0 ; + int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nodes", (char *)"make_owner", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceBaseGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_SetNodalGridFunction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); + } + arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetNodalGridFunction" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } { try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceBaseGeometry(arg2); + (arg1)->SetNodalGridFunction(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13459,37 +13243,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceBaseGeometry(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + PyObject *swig_obj[1] ; + mfem::FiniteElementSpace *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementBaseGeometry", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetElementBaseGeometry(arg2); + result = (mfem::FiniteElementSpace *)((mfem::Mesh const *)arg1)->GetNodalFESpace(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13506,37 +13284,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementBaseGeometry(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementBaseGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_EnsureNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementBaseGeometry", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementBaseGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetBdrElementBaseGeometry(arg2); + (arg1)->EnsureNodes(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13553,38 +13324,71 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementBaseGeometry(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_HasGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_SetCurvature(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Geometry::Type arg2 ; + int arg2 ; + bool arg3 = (bool) false ; + int arg4 = (int) -1 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - bool result; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"order", (char *)"discont", (char *)"space_dim", (char *)"ordering", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_HasGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Mesh_SetCurvature", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_HasGeometry" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_HasGeometry" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); - } - arg2 = static_cast< mfem::Geometry::Type >(val2); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } + } + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } + } { try { - result = (bool)((mfem::Mesh const *)arg1)->HasGeometry(arg2); + (arg1)->SetCurvature(arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13601,37 +13405,42 @@ SWIGINTERN PyObject *_wrap_Mesh_HasGeometry(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetNumGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ref_algo", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNumGeometries", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_UniformRefinement", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNumGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_UniformRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { - result = (int)((mfem::Mesh const *)arg1)->GetNumGeometries(arg2); + (arg1)->UniformRefinement(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13648,47 +13457,57 @@ SWIGINTERN PyObject *_wrap_Mesh_GetNumGeometries(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetGeometries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< mfem::Geometry::Type > *arg3 = 0 ; + mfem::Array< mfem::Refinement > *arg2 = 0 ; + int arg3 = (int) -1 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetGeometries", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetGeometries" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetGeometries" "', argument " "3"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); + arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - arg3 = reinterpret_cast< mfem::Array< mfem::Geometry::Type > * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetGeometries(arg2,*arg3); + (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13712,40 +13531,50 @@ SWIGINTERN PyObject *_wrap_Mesh_GetGeometries(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Mesh_GetElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 = (int) -1 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVertices", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetElementVertices(arg2,*arg3); + (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13769,40 +13598,151 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementVertices", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); +SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GeneralRefinement", 0, 4, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); + } + { + _v = PyInt_Check(argv[2]) ? 1 : 0; + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); + } + } + } + } + } + if ((argc >= 2) && (argc <= 4)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); + } + { + _v = PyInt_Check(argv[2]) ? 1 : 0; + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GeneralRefinement'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &,int,int)\n" + " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &,int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double arg2 ; + bool arg3 = (bool) false ; + int arg4 = (int) -1 ; + int arg5 = (int) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"prob", (char *)"aniso", (char *)"nonconforming", (char *)"nc_limit", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:Mesh_RandomRefinement", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementVertices(arg2,*arg3); + (arg1)->RandomRefinement(arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13826,51 +13766,58 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementVertices(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_Mesh_GetElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + mfem::Vertex *arg2 = 0 ; + double arg3 = (double) 0.0 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vert", (char *)"eps", (char *)"nonconforming", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementEdges", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:Mesh_RefineAtVertex", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + arg2 = reinterpret_cast< mfem::Vertex * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineAtVertex" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetElementEdges(arg2,*arg3,*arg4); + (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13894,51 +13841,59 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementEdges(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + mfem::Array< double > *arg2 = 0 ; + double arg3 ; + int arg4 = (int) -1 ; + int arg5 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementEdges", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementEdges(arg2,*arg3,*arg4); + result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13955,58 +13910,66 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdges(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; + mfem::Vector *arg2 = 0 ; + double arg3 ; + int arg4 = (int) -1 ; + int arg5 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceEdges", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdges" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceEdges" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetFaceEdges(arg2,*arg3,*arg4); + result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14023,104 +13986,170 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdges(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; +SWIGINTERN PyObject *_wrap_Mesh_RefineByError(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceVertices", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetFaceVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::Mesh const *)arg1)->GetFaceVertices(arg2,*arg3); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RefineByError", 0, 5, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); + } + { + _v = PyInt_Check(argv[3]) ? 1 : 0; + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); + } + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); + } + { + _v = PyInt_Check(argv[3]) ? 1 : 0; + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RefineByError'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::RefineByError(mfem::Array< double > const &,double,int,int)\n" + " mfem::Mesh::RefineByError(mfem::Vector const &,double,int,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; + mfem::Array< double > *arg2 = 0 ; + double arg3 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetEdgeVertices", 3, 3, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetEdgeVertices" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetEdgeVertices(arg2,*arg3); + result = (bool)(arg1)->DerefineByError(*arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14137,72 +14166,66 @@ SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = 0 ; + double arg3 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceEdgeTable(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertexTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeVertexTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetEdgeVertexTable(); + result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14219,58 +14242,154 @@ SWIGINTERN PyObject *_wrap_Mesh_GetEdgeVertexTable(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementFaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< int > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; +SWIGINTERN PyObject *_wrap_Mesh_DerefineByError(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[6] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DerefineByError", 0, 5, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); + } + } + } + } + } + } + if ((argc >= 3) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if (PyFloat_Check(argv[2])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_DerefineByError'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::DerefineByError(mfem::Array< double > &,double,int,int)\n" + " mfem::Mesh::DerefineByError(mfem::Vector const &,double,int,int)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Array< mfem::KnotVector * > *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementFaces", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementFaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementFaces" "', argument " "4"" of type '" "mfem::Array< int > &""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); } - arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); + arg2 = reinterpret_cast< mfem::Array< mfem::KnotVector * > * >(argp2); { try { - ((mfem::Mesh const *)arg1)->GetElementFaces(arg2,*arg3,*arg4); + (arg1)->KnotInsert(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14294,44 +14413,32 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementFaces(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int *arg3 = (int *) 0 ; - int *arg4 = (int *) 0 ; + mfem::Array< mfem::Vector * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementFace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementFace" "', argument " "3"" of type '" "int *""'"); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementFace" "', argument " "4"" of type '" "int *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); } - arg4 = reinterpret_cast< int * >(argp4); + arg2 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp2); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementFace(arg2,arg3,arg4); + (arg1)->KnotInsert(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14355,30 +14462,89 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementFace__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdgeIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[3] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 0, 2, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_0(self, argc, argv); + } + } + } + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_KnotInsert__SWIG_1(self, argc, argv); + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_KnotInsert'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::KnotVector * > &)\n" + " mfem::Mesh::KnotInsert(mfem::Array< mfem::Vector * > &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + int arg3 = (int) 16 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rel_degree", (char *)"degree", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementEdgeIndex", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_DegreeElevate", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementEdgeIndex" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); + } + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } { try { - result = (int)((mfem::Mesh const *)arg1)->GetBdrElementEdgeIndex(arg2); + (arg1)->DegreeElevate(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14395,58 +14561,43 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementEdgeIndex(PyObject *SWIGUNUSEDPARM( SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementAdjacentElement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int *arg3 = 0 ; - int *arg4 = 0 ; + bool arg2 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"simplices_nonconforming", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementAdjacentElement", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Mesh_EnsureNCMesh", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNCMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "3"" of type '" "int &""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrElementAdjacentElement" "', argument " "4"" of type '" "int &""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_EnsureNCMesh" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg4 = reinterpret_cast< int * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetBdrElementAdjacentElement(arg2,*arg3,*arg4); + (arg1)->EnsureNCMesh(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14470,30 +14621,24 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementAdjacentElement(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Mesh_GetElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Conforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element::Type result; + PyObject *swig_obj[1] ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementType", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Conforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetElementType(arg2); + result = (bool)((mfem::Mesh const *)arg1)->Conforming(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14510,37 +14655,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementType(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Nonconforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element::Type result; + PyObject *swig_obj[1] ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementType", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Nonconforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetBdrElementType(arg2); + result = (bool)((mfem::Mesh const *)arg1)->Nonconforming(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14557,47 +14696,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementType(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetRefinementTransforms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; + mfem::CoarseFineTransformations *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetPointMatrix", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetRefinementTransforms" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetPointMatrix(arg2,*arg3); + result = (mfem::CoarseFineTransformations *) &(arg1)->GetRefinementTransforms(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14614,47 +14737,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetPointMatrix(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrPointMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetLastOperation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::DenseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; + mfem::Mesh::Operation result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrPointMatrix", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLastOperation" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBdrPointMatrix" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetBdrPointMatrix(arg2,*arg3); + result = (mfem::Mesh::Operation)((mfem::Mesh const *)arg1)->GetLastOperation(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14671,31 +14778,31 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrPointMatrix(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetTransformationFEforElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Element::Type arg1 ; - int val1 ; - int ecode1 = 0 ; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; PyObject *swig_obj[1] ; - mfem::FiniteElement *result = 0 ; + long result; if (!args) SWIG_fail; swig_obj[0] = args; - ecode1 = SWIG_AsVal_int(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Mesh_GetTransformationFEforElementType" "', argument " "1"" of type '" "mfem::Element::Type""'"); - } - arg1 = static_cast< mfem::Element::Type >(val1); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetSequence" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::FiniteElement *)mfem::Mesh::GetTransformationFEforElementType(arg1); + result = (long)((mfem::Mesh const *)arg1)->GetSequence(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14712,43 +14819,49 @@ SWIGINTERN PyObject *_wrap_Mesh_GetTransformationFEforElementType(PyObject *SWIG SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElement, 0 | 0 ); + resultobj = SWIG_From_long(static_cast< long >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - (arg1)->GetElementTransformation(arg2,arg3); + ((mfem::Mesh const *)arg1)->PrintXG(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14766,35 +14879,58 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_0(PyObject *SWIGU } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } } { try { - result = (mfem::ElementTransformation *)(arg1)->GetElementTransformation(arg2); + ((mfem::Mesh const *)arg1)->Print(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14811,54 +14947,56 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_1(PyObject *SWIGU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::IsoparametricTransformation *arg4 = (mfem::IsoparametricTransformation *) 0 ; + std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementTransformation" "', argument " "3"" of type '" "mfem::Vector const &""'"); + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetElementTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation *""'"); - } - arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); { try { - (arg1)->GetElementTransformation(arg2,(mfem::Vector const &)*arg3,arg4); + (arg1)->PrintVTK(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14876,125 +15014,71 @@ SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation__SWIG_2(PyObject *SWIGU } } resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementTransformation", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementTransformation__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementTransformation__SWIG_0(self, argc, argv); - } - } + { + if (temp2->isSTDOUT() != 1) { + out2.close(); } } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementTransformation__SWIG_2(self, argc, argv); - } - } - } + return resultobj; +fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementTransformation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementTransformation(int,mfem::IsoparametricTransformation *)\n" - " mfem::Mesh::GetElementTransformation(int)\n" - " mfem::Mesh::GetElementTransformation(int,mfem::Vector const &,mfem::IsoparametricTransformation *)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + std::ostream *arg2 = 0 ; + int arg3 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } { try { - result = (mfem::ElementTransformation *)(arg1)->GetBdrElementTransformation(arg2); + (arg1)->PrintVTK(*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15011,43 +15095,94 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_0(PyObject *SW SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + std::ostream *arg2 = 0 ; + int arg3 = (int) 1 ; + mfem::VTKFormat arg4 = (mfem::VTKFormat) mfem::VTKFormat::ASCII ; + bool arg5 = (bool) false ; + int arg6 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + int val4 ; + int ecode4 = 0 ; + bool val5 ; + int ecode5 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBdrElementTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); + } + arg4 = static_cast< mfem::VTKFormat >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - (arg1)->GetBdrElementTransformation(arg2,arg3); + (arg1)->PrintVTU(*arg2,arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15065,47 +15200,166 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation__SWIG_1(PyObject *SW } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + std::string arg2 ; + mfem::VTKFormat arg3 = (mfem::VTKFormat) mfem::VTKFormat::ASCII ; + bool arg4 = (bool) false ; + int arg5 = (int) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 ; + int res2 = 0 ; + int val3 ; + int ecode3 = 0 ; + bool val4 ; + int ecode4 = 0 ; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBdrElementTransformation", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetBdrElementTransformation__SWIG_0(self, argc, argv); - } - } + if ((nobjs < 2) || (nobjs > 5)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); + } else { + std::string * temp = reinterpret_cast< std::string * >(argp2); + arg2 = *temp; + if (SWIG_IsNewObj(res2)) delete temp; + } + } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); + } + arg3 = static_cast< mfem::VTKFormat >(val3); + } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + { + try { + (arg1)->PrintVTU(arg2,arg3,arg4,arg5); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_PrintVTU(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[7] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTU", 0, 6, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 5)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 3) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); + } + } + } + } + } + } + if ((argc >= 2) && (argc <= 6)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + void *ptr; + if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { PyErr_Clear(); _v = 0; } else { @@ -15113,55 +15367,105 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrElementTransformation(PyObject *self, PyOb } } if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); + if (argc <= 2) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - return _wrap_Mesh_GetBdrElementTransformation__SWIG_1(self, argc, argv); + if (argc <= 3) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 4) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[4], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 5) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); + } + } + } } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBdrElementTransformation'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTU'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBdrElementTransformation(int)\n" - " mfem::Mesh::GetBdrElementTransformation(int,mfem::IsoparametricTransformation *)\n"); + " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool,int)\n" + " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + mfem::Array< int > *arg2 = 0 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"colors", (char *)"el0", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mesh_GetElementColoring", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (obj2) { + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); { try { - (arg1)->GetFaceTransformation(arg2,arg3); + (arg1)->GetElementColoring(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15185,54 +15489,63 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Mesh_GetLocalFaceTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - mfem::IsoparametricTransformation *arg4 = 0 ; - int arg5 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[5] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"partitioning", (char *)"out", (char *)"elem_attr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetLocalFaceTransformation", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_PrintWithPartitioning", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); } + arg2 = reinterpret_cast< int * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__IsoparametricTransformation, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetLocalFaceTransformation" "', argument " "4"" of type '" "mfem::IsoparametricTransformation &""'"); + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg4 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - (arg1)->GetLocalFaceTransformation(arg2,arg3,*arg4,arg5); + ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15250,35 +15563,79 @@ SWIGINTERN PyObject *_wrap_Mesh_GetLocalFaceTransformation(PyObject *SWIGUNUSEDP } } resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + int *arg2 = (int *) 0 ; + std::ostream *arg3 = 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"partitioning", (char *)"out", (char *)"interior_faces", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_PrintElementsWithPartitioning", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); + } + arg2 = reinterpret_cast< int * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } + } + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (mfem::ElementTransformation *)(arg1)->GetFaceTransformation(arg2); + (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15295,104 +15652,185 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 +SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Table *arg2 = 0 ; + std::ostream *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Aface_face", (char *)"out", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetFaceTransformation", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetFaceTransformation__SWIG_1(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_PrintSurfaces", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + } + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); + } + arg2 = reinterpret_cast< mfem::Table * >(argp2); + { + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetFaceTransformation__SWIG_0(self, argc, argv); - } - } + { + try { + ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); } } - + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetFaceTransformation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetFaceTransformation(int,mfem::IsoparametricTransformation *)\n" - " mfem::Mesh::GetFaceTransformation(int)\n"); - return 0; + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::IsoparametricTransformation *arg3 = (mfem::IsoparametricTransformation *) 0 ; + double arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sf", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_ScaleSubdomains", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + try { + (arg1)->ScaleSubdomains(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__IsoparametricTransformation, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetEdgeTransformation" "', argument " "3"" of type '" "mfem::IsoparametricTransformation *""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sf", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_ScaleElements", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); } - arg3 = reinterpret_cast< mfem::IsoparametricTransformation * >(argp3); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); { try { - (arg1)->GetEdgeTransformation(arg2,arg3); + (arg1)->ScaleElements(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15416,29 +15854,28 @@ SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - mfem::ElementTransformation *result = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetEdgeTransformation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + if (!SWIG_IsOK(res)) { + SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); + } } { try { - result = (mfem::ElementTransformation *)(arg1)->GetEdgeTransformation(arg2); + (arg1)->Transform(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15455,150 +15892,39 @@ SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation__SWIG_1(PyObject *SWIGUNUS SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ElementTransformation, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetEdgeTransformation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetEdgeTransformation", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetEdgeTransformation__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__IsoparametricTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetEdgeTransformation__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetEdgeTransformation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetEdgeTransformation(int,mfem::IsoparametricTransformation *)\n" - " mfem::Mesh::GetEdgeTransformation(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FaceElementTransformations *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::FaceElementTransformations *)(arg1)->GetFaceElementTransformations(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::FaceElementTransformations *result = 0 ; +SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::VectorCoefficient *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); } + arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetFaceElementTransformations(arg2); + (arg1)->Transform(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15615,20 +15941,20 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations__SWIG_1(PyObject * SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[4] = { + PyObject *argv[3] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetFaceElementTransformations", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v; @@ -15636,82 +15962,55 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementTransformations(PyObject *self, Py int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *ptr = 0; + int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_GetFaceElementTransformations__SWIG_1(self, argc, argv); + return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); } } } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetFaceElementTransformations__SWIG_0(self, argc, argv); - } + return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetFaceElementTransformations'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetFaceElementTransformations(int,int)\n" - " mfem::Mesh::GetFaceElementTransformations(int)\n"); + " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" + " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_GetInteriorFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FaceElementTransformations *result = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetInteriorFaceTransformations", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetInteriorFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetInteriorFaceTransformations(arg2); + (arg1)->RemoveUnusedVertices(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15728,37 +16027,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetInteriorFaceTransformations(PyObject *SWIGUNU SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrFaceTransformations(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::FaceElementTransformations *result = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrFaceTransformations", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrFaceTransformations" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (mfem::FaceElementTransformations *)(arg1)->GetBdrFaceTransformations(arg2); + (arg1)->RemoveInternalBoundaries(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15775,26 +16067,26 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrFaceTransformations(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FaceElementTransformations, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_FaceIsInterior(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; + int arg3 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - bool result; + double result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_FaceIsInterior", 2, 2, swig_obj)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FaceIsInterior" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -15803,9 +16095,17 @@ SWIGINTERN PyObject *_wrap_Mesh_FaceIsInterior(PyObject *SWIGUNUSEDPARM(self), P }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - result = (bool)((mfem::Mesh const *)arg1)->FaceIsInterior(arg2); + result = (double)(arg1)->GetElementSize(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15822,31 +16122,28 @@ SWIGINTERN PyObject *_wrap_Mesh_FaceIsInterior(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; - int *arg3 = (int *) 0 ; - int *arg4 = (int *) 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + double result; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceElements", 4, 4, swig_obj)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElements" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { @@ -15855,19 +16152,17 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceElements(PyObject *SWIGUNUSEDPARM(self), }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceElements" "', argument " "3"" of type '" "int *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceElements" "', argument " "4"" of type '" "int *""'"); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - arg4 = reinterpret_cast< int * >(argp4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::Mesh const *)arg1)->GetFaceElements(arg2,arg3,arg4); + result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15884,52 +16179,114 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceElements(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceInfos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int *arg3 = (int *) 0 ; - int *arg4 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; +SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceInfos", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; + --argc; + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::GetElementSize(int,int)\n" + " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; + double result; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetElementVolume", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceInfos" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetFaceInfos" "', argument " "3"" of type '" "int *""'"); - } - arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetFaceInfos" "', argument " "4"" of type '" "int *""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg4 = reinterpret_cast< int * >(argp4); { try { - ((mfem::Mesh const *)arg1)->GetFaceInfos(arg2,arg3,arg4); + result = (double)(arg1)->GetElementVolume(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15946,37 +16303,66 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceInfos(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometryType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 = (int) 2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Geometry::Type result; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"min", (char *)"max", (char *)"ref", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceGeometryType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Mesh_GetBoundingBox", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceGeometryType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } { try { - result = (mfem::Geometry::Type)((mfem::Mesh const *)arg1)->GetFaceGeometryType(arg2); + (arg1)->GetBoundingBox(*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15993,37 +16379,102 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceGeometryType(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; + double *arg2 = 0 ; + double *arg3 = 0 ; + double *arg4 = 0 ; + double *arg5 = 0 ; + mfem::Vector *arg6 = (mfem::Vector *) NULL ; + mfem::Vector *arg7 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - mfem::Element::Type result; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"h_min", (char *)"h_max", (char *)"kappa_min", (char *)"kappa_max", (char *)"Vh", (char *)"Vk", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetFaceElementType", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|OO:Mesh_GetCharacteristics", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceElementType" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); + } + arg2 = reinterpret_cast< double * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); + } + arg3 = reinterpret_cast< double * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); + } + arg4 = reinterpret_cast< double * >(argp4); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); + } + arg5 = reinterpret_cast< double * >(argp5); + if (obj5) { + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); + } + arg6 = reinterpret_cast< mfem::Vector * >(argp6); + } + if (obj6) { + res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); + } + arg7 = reinterpret_cast< mfem::Vector * >(argp7); } { try { - result = (mfem::Element::Type)((mfem::Mesh const *)arg1)->GetFaceElementType(arg2); + (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16040,37 +16491,62 @@ SWIGINTERN PyObject *_wrap_Mesh_GetFaceElementType(PyObject *SWIGUNUSEDPARM(self SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - int result; + int arg1 ; + mfem::Array< int > *arg2 = 0 ; + std::ostream *arg3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyMFEM::wFILE *temp3 = 0 ; + std::ofstream out3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"num_elems_by_geom", (char *)"out", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_PrintElementsByGeometry", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); + } + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + { + if (SWIG_ConvertPtr(obj2, (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp3->isSTDOUT() == 1) { + arg3 = &std::cout; + } + else { + out3.open(temp3->getFilename()); + out3.precision(temp3->getPrecision()); + arg3 = &out3; + } } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckElementOrientation" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); { try { - result = (int)(arg1)->CheckElementOrientation(arg2); + mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16087,29 +16563,86 @@ SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation__SWIG_0(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } return resultobj; fail: - return NULL; -} - + { + if (temp3->isSTDOUT() != 1) { + out3.close(); + } + } + return NULL; +} + -SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::Vector *arg2 = (mfem::Vector *) NULL ; + mfem::Vector *arg3 = (mfem::Vector *) NULL ; + std::ostream &arg4_defvalue = mfem::out ; + std::ostream *arg4 = (std::ostream *) &arg4_defvalue ; void *argp1 = 0 ; int res1 = 0 ; - int result; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyMFEM::wFILE *temp4 = 0 ; + std::ofstream out4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Vh", (char *)"Vk", (char *)"out", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:Mesh_PrintCharacteristics", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + } + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + } + if (obj3) { + { + if (SWIG_ConvertPtr(obj3, (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp4->isSTDOUT() == 1) { + arg4 = &std::cout; + } + else { + out4.open(temp4->getFilename()); + out4.precision(temp4->getPrecision()); + arg4 = &out4; + } + } + } { try { - result = (int)(arg1)->CheckElementOrientation(); + (arg1)->PrintCharacteristics(arg2,arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16126,79 +16659,59 @@ SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation__SWIG_1(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_CheckElementOrientation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_CheckElementOrientation", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_CheckElementOrientation__SWIG_1(self, argc, argv); + resultobj = SWIG_Py_Void(); + { + if (temp4->isSTDOUT() != 1) { + out4.close(); } } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_CheckElementOrientation__SWIG_0(self, argc, argv); - } + return resultobj; +fail: + { + if (temp4->isSTDOUT() != 1) { + out4.close(); } } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_CheckElementOrientation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::CheckElementOrientation(bool)\n" - " mfem::Mesh::CheckElementOrientation()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - int result; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - result = (int)(arg1)->CheckBdrElementOrientation(arg2); + (arg1)->PrintInfo(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16215,29 +16728,101 @@ SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation__SWIG_0(PyObject *SWI SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + mfem::DenseMatrix *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; + bool arg5 = (bool) true ; + mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) NULL ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + bool val5 ; + int ecode5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"point_mat", (char *)"elem_ids", (char *)"ips", (char *)"warn", (char *)"inv_trans", NULL + }; int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OO:Mesh_FindPoints", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckBdrElementOrientation" "', argument " "1"" of type '" "mfem::Mesh *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); + } + arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); + } + arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_bool(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); + } + arg5 = static_cast< bool >(val5); + } + if (obj5) { + res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); + } + arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); + } { try { - result = (int)(arg1)->CheckBdrElementOrientation(); + result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16261,72 +16846,23 @@ SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation__SWIG_1(PyObject *SWI } -SWIGINTERN PyObject *_wrap_Mesh_CheckBdrElementOrientation(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_CheckBdrElementOrientation", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_CheckBdrElementOrientation__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_CheckBdrElementOrientation__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_CheckBdrElementOrientation'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::CheckBdrElementOrientation(bool)\n" - " mfem::Mesh::CheckBdrElementOrientation()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (int)((mfem::Mesh const *)arg1)->GetAttribute(arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16343,28 +16879,41 @@ SWIGINTERN PyObject *_wrap_Mesh_GetAttribute(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_int(static_cast< int >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_12(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg1 ; int arg2 ; int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[3] ; + char *arg4 = (char *) 0 ; + int arg5 = (int) 0 ; + double arg6 = (double) 1.0 ; + double arg7 = (double) 1.0 ; + double arg8 = (double) 1.0 ; + int res4 ; + char *buf4 = 0 ; + int alloc4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + mfem::Mesh *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetAttribute", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetAttribute" "', argument " "1"" of type '" "mfem::Mesh *""'"); + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -16377,9 +16926,43 @@ SWIGINTERN PyObject *_wrap_Mesh_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyO }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); + } + arg4 = reinterpret_cast< char * >(buf4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + } { try { - (arg1)->SetAttribute(arg2,arg3); + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_12(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16396,201 +16979,75 @@ SWIGINTERN PyObject *_wrap_Mesh_SetAttribute(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return resultobj; fail: + if (alloc4 == SWIG_NEWOBJ) delete[] buf4; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttribute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_13(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; + int arg1 ; int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - int result; + char *arg3 = (char *) 0 ; + int arg4 = (int) 0 ; + double arg5 = (double) 1.0 ; + double arg6 = (double) 1.0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + double val5 ; + int ecode5 = 0 ; + double val6 ; + int ecode6 = 0 ; + mfem::Mesh *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrAttribute", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrAttribute" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + if ((nobjs < 3) || (nobjs > 6)) SWIG_fail; + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - result = (int)((mfem::Mesh const *)arg1)->GetBdrAttribute(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ElementToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Table *) &(arg1)->ElementToElementTable(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ElementToFaceTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToFaceTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToFaceTable(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + arg3 = reinterpret_cast< char * >(buf3); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ElementToEdgeTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ElementToEdgeTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Table *) &((mfem::Mesh const *)arg1)->ElementToEdgeTable(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetVertexToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexToElementTable" "', argument " "1"" of type '" "mfem::Mesh *""'"); + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { try { - result = (mfem::Table *)(arg1)->GetVertexToElementTable(); + result = (mfem::Mesh *)new_mfem_Mesh__SWIG_13(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16607,10384 +17064,52 @@ SWIGINTERN PyObject *_wrap_Mesh_GetVertexToElementTable(PyObject *SWIGUNUSEDPARM SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return resultobj; fail: + if (alloc3 == SWIG_NEWOBJ) delete[] buf3; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_GetFaceToElementTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Table *result = 0 ; +SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[13] = { + 0 + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetFaceToElementTable" "', argument " "1"" of type '" "mfem::Mesh const *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; + --argc; + if (argc == 0) { + return _wrap_new_Mesh__SWIG_1(self, argc, argv); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Table *)((mfem::Mesh const *)arg1)->GetFaceToElementTable(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if ((argc >= 1) && (argc <= 2)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_2(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_Mesh__SWIG_2(self, argc, argv); + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ReorientTetMesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ReorientTetMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->ReorientTetMesh(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_CartesianPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - int *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_CartesianPartitioning", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CartesianPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CartesianPartitioning" "', argument " "2"" of type '" "int []""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - try { - result = (int *)(arg1)->CartesianPartitioning(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneratePartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (int *)(arg1)->GeneratePartitioning(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneratePartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (int *)(arg1)->GeneratePartitioning(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneratePartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GeneratePartitioning", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneratePartitioning__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneratePartitioning__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GeneratePartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GeneratePartitioning(int,int)\n" - " mfem::Mesh::GeneratePartitioning(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_CheckPartitioning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_CheckPartitioning", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - try { - (arg1)->CheckPartitioning(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_CheckDisplacements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_CheckDisplacements", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_CheckDisplacements" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_CheckDisplacements" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - { - try { - (arg1)->CheckDisplacements((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_MoveVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_MoveVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->MoveVertices((mfem::Vector const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertices" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetVertices" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - ((mfem::Mesh const *)arg1)->GetVertices(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetVertices" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->SetVertices((mfem::Vector const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - double *arg3 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetNode", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNode" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetNode" "', argument " "3"" of type '" "double *""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - { - try { - ((mfem::Mesh const *)arg1)->GetNode(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - double *arg3 = (double *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNode", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNode" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - int i; - if (!PyList_Check(swig_obj[2])) { - PyErr_SetString(PyExc_ValueError, "Expecting a list"); - return NULL; - } - int l = PyList_Size(swig_obj[2]); - arg3 = (double *) malloc((l)*sizeof(double)); - for (i = 0; i < l; i++) { - PyObject *s = PyList_GetItem(swig_obj[2],i); - if (PyInt_Check(s)) { - arg3[i] = (double)PyFloat_AsDouble(s); - } else if (PyFloat_Check(s)) { - arg3[i] = (double)PyFloat_AsDouble(s); - } else { - free(arg3); - PyErr_SetString(PyExc_ValueError, "List items must be integer/float"); - return NULL; - } - } - } - { - try { - (arg1)->SetNode(arg2,(double const *)arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_MoveNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_MoveNodes", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_MoveNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_MoveNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->MoveNodes((mfem::Vector const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - ((mfem::Mesh const *)arg1)->GetNodes(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNodes", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_SetNodes" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->SetNodes((mfem::Vector const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::GridFunction *)(arg1)->GetNodes(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunction *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::GridFunction *)((mfem::Mesh const *)arg1)->GetNodes(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_OwnsNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_OwnsNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (bool)((mfem::Mesh const *)arg1)->OwnsNodes(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodesOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNodesOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodesOwner" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_SetNodesOwner" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->SetNodesOwner(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_NewNodes__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_NewNodes" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->NewNodes(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_NewNodes__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_NewNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_NewNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - (arg1)->NewNodes(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_NewNodes(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_NewNodes", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_NewNodes__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_NewNodes__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_NewNodes'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::NewNodes(mfem::GridFunction &,bool)\n" - " mfem::Mesh::NewNodes(mfem::GridFunction &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SwapNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction **arg2 = 0 ; - int *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GridFunction *Pnodes2 ; - int own_nodes3 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SwapNodes", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SwapNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int res2 = 0; - res2 = SWIG_ConvertPtr(swig_obj[1], (void **) &Pnodes2, SWIGTYPE_p_mfem__GridFunction, 0); - if (!SWIG_IsOK(res2)){ - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SwapNodes" "', argument " "2"" of type '" "*mfem::GridFunction""'"); - } - arg2 = &Pnodes2; - } - { - own_nodes3 = (int)PyInt_AsLong(swig_obj[2]); - arg3 = &own_nodes3; - } - { - try { - (arg1)->SwapNodes(*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - Py_XDECREF(resultobj); - resultobj = PyList_New(0); - resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj(SWIG_as_voidptr(*arg2), SWIGTYPE_p_mfem__GridFunction, 0 | 0 )); - } - { - resultobj = SWIG_Python_AppendOutput(resultobj, PyLong_FromLong((long)*arg3)); - } - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodes" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__GridFunction, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetNodes" "', argument " "2"" of type '" "mfem::GridFunction &""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - ((mfem::Mesh const *)arg1)->GetNodes(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodes(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetNodes", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_1(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetNodes__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetNodes'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetNodes(mfem::Vector &) const\n" - " mfem::Mesh::GetNodes()\n" - " mfem::Mesh::GetNodes() const\n" - " mfem::Mesh::GetNodes(mfem::GridFunction &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::FiniteElementSpace *arg2 = (mfem::FiniteElementSpace *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_SetNodalFESpace", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalFESpace" "', argument " "2"" of type '" "mfem::FiniteElementSpace *""'"); - } - arg2 = reinterpret_cast< mfem::FiniteElementSpace * >(argp2); - { - try { - (arg1)->SetNodalFESpace(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetNodalGridFunction" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetNodalGridFunction(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::GridFunction *arg2 = (mfem::GridFunction *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetNodalGridFunction" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__GridFunction, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_SetNodalGridFunction" "', argument " "2"" of type '" "mfem::GridFunction *""'"); - } - arg2 = reinterpret_cast< mfem::GridFunction * >(argp2); - { - try { - (arg1)->SetNodalGridFunction(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetNodalGridFunction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_SetNodalGridFunction", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_SetNodalGridFunction__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__GridFunction, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_SetNodalGridFunction__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_SetNodalGridFunction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::SetNodalGridFunction(mfem::GridFunction *,bool)\n" - " mfem::Mesh::SetNodalGridFunction(mfem::GridFunction *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetNodalFESpace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::FiniteElementSpace *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetNodalFESpace" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::FiniteElementSpace *)((mfem::Mesh const *)arg1)->GetNodalFESpace(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNodes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNodes" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->EnsureNodes(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - bool arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->SetCurvature(arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - bool arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->SetCurvature(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_SetCurvature" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->SetCurvature(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_SetCurvature" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetCurvature(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_SetCurvature(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_SetCurvature", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_SetCurvature__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_SetCurvature'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::SetCurvature(int,bool,int,int)\n" - " mfem::Mesh::SetCurvature(int,bool,int)\n" - " mfem::Mesh::SetCurvature(int,bool)\n" - " mfem::Mesh::SetCurvature(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_UniformRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->UniformRefinement(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_UniformRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->UniformRefinement(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_UniformRefinement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_UniformRefinement", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_UniformRefinement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_UniformRefinement__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_UniformRefinement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::UniformRefinement(int)\n" - " mfem::Mesh::UniformRefinement()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Refinement > *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Refinement > *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Refinement > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Refinement > * >(argp2); - { - try { - (arg1)->GeneralRefinement((mfem::Array< mfem::Refinement > const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GeneralRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GeneralRefinement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->GeneralRefinement((mfem::Array< int > const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GeneralRefinement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GeneralRefinement", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_5(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_0(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - _v = PyInt_Check(argv[2]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GeneralRefinement__SWIG_3(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GeneralRefinement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &,int,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< mfem::Refinement > const &)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &,int,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &,int)\n" - " mfem::Mesh::GeneralRefinement(mfem::Array< int > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - bool arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->RandomRefinement(arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - bool arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->RandomRefinement(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RandomRefinement" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->RandomRefinement(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RandomRefinement" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_RandomRefinement" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->RandomRefinement(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RandomRefinement(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RandomRefinement", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_RandomRefinement__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RandomRefinement'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::RandomRefinement(double,bool,int,int)\n" - " mfem::Mesh::RandomRefinement(double,bool,int)\n" - " mfem::Mesh::RandomRefinement(double,bool)\n" - " mfem::Mesh::RandomRefinement(double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vertex *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - arg2 = reinterpret_cast< mfem::Vertex * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineAtVertex" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vertex *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - arg2 = reinterpret_cast< mfem::Vertex * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineAtVertex" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vertex *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineAtVertex" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vertex, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineAtVertex" "', argument " "2"" of type '" "mfem::Vertex const &""'"); - } - arg2 = reinterpret_cast< mfem::Vertex * >(argp2); - { - try { - (arg1)->RefineAtVertex((mfem::Vertex const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineAtVertex(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RefineAtVertex", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vertex, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_RefineAtVertex__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vertex, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_Mesh_RefineAtVertex__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vertex, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RefineAtVertex__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RefineAtVertex'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::RefineAtVertex(mfem::Vertex const &,double,int)\n" - " mfem::Mesh::RefineAtVertex(mfem::Vertex const &,double)\n" - " mfem::Mesh::RefineAtVertex(mfem::Vertex const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Array< double > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->RefineByError((mfem::Array< double > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_RefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_RefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->RefineByError((mfem::Vector const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RefineByError(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_RefineByError", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - _v = PyInt_Check(argv[3]) ? 1 : 0; - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_RefineByError__SWIG_3(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_RefineByError'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::RefineByError(mfem::Array< double > const &,double,int,int)\n" - " mfem::Mesh::RefineByError(mfem::Array< double > const &,double,int)\n" - " mfem::Mesh::RefineByError(mfem::Array< double > const &,double)\n" - " mfem::Mesh::RefineByError(mfem::Vector const &,double,int,int)\n" - " mfem::Mesh::RefineByError(mfem::Vector const &,double,int)\n" - " mfem::Mesh::RefineByError(mfem::Vector const &,double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->DerefineByError(*arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->DerefineByError(*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< double > *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_double_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Array< double > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< double > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->DerefineByError(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - bool result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DerefineByError" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_DerefineByError" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_DerefineByError" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (bool)(arg1)->DerefineByError((mfem::Vector const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DerefineByError(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DerefineByError", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_double_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_0(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DerefineByError__SWIG_3(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_DerefineByError'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::DerefineByError(mfem::Array< double > &,double,int,int)\n" - " mfem::Mesh::DerefineByError(mfem::Array< double > &,double,int)\n" - " mfem::Mesh::DerefineByError(mfem::Array< double > &,double)\n" - " mfem::Mesh::DerefineByError(mfem::Vector const &,double,int,int)\n" - " mfem::Mesh::DerefineByError(mfem::Vector const &,double,int)\n" - " mfem::Mesh::DerefineByError(mfem::Vector const &,double)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::KnotVector * > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::KnotVector * > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::KnotVector * > * >(argp2); - { - try { - (arg1)->KnotInsert(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< mfem::Vector * > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_KnotInsert" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_KnotInsert" "', argument " "2"" of type '" "mfem::Array< mfem::Vector * > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< mfem::Vector * > * >(argp2); - { - try { - (arg1)->KnotInsert(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_KnotInsert(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_KnotInsert", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__KnotVector_p_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_KnotInsert__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_KnotInsert__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_KnotInsert'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::KnotInsert(mfem::Array< mfem::KnotVector * > &)\n" - " mfem::Mesh::KnotInsert(mfem::Array< mfem::Vector * > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->DegreeElevate(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_DegreeElevate" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->DegreeElevate(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_DegreeElevate(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_DegreeElevate", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DegreeElevate__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_DegreeElevate__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_DegreeElevate'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::DegreeElevate(int,int)\n" - " mfem::Mesh::DegreeElevate(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNCMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_EnsureNCMesh" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - (arg1)->EnsureNCMesh(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_EnsureNCMesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->EnsureNCMesh(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_EnsureNCMesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_EnsureNCMesh", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_EnsureNCMesh__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_EnsureNCMesh__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_EnsureNCMesh'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::EnsureNCMesh(bool)\n" - " mfem::Mesh::EnsureNCMesh()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Conforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Conforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (bool)((mfem::Mesh const *)arg1)->Conforming(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Nonconforming(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Nonconforming" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (bool)((mfem::Mesh const *)arg1)->Nonconforming(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetRefinementTransforms(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::CoarseFineTransformations *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetRefinementTransforms" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::CoarseFineTransformations *) &(arg1)->GetRefinementTransforms(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetLastOperation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - mfem::Mesh::Operation result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetLastOperation" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::Mesh::Operation)((mfem::Mesh const *)arg1)->GetLastOperation(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetSequence(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - long result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetSequence" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (long)((mfem::Mesh const *)arg1)->GetSequence(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_long(static_cast< long >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::Mesh const *)arg1)->PrintXG(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - ((mfem::Mesh const *)arg1)->PrintXG(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::Mesh const *)arg1)->Print(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - ((mfem::Mesh const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->PrintVTK(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->PrintVTK(*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->PrintVTK(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - mfem::VTKFormat arg4 ; - bool arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); - } - arg4 = static_cast< mfem::VTKFormat >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - (arg1)->PrintVTU(*arg2,arg3,arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - mfem::VTKFormat arg4 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val4 ; - int ecode4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); - } - arg4 = static_cast< mfem::VTKFormat >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_PrintVTU" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - (arg1)->PrintVTU(*arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - mfem::VTKFormat arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - int val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "mfem::VTKFormat""'"); - } - arg4 = static_cast< mfem::VTKFormat >(val4); - { - try { - (arg1)->PrintVTU(*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->PrintVTU(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->PrintVTU(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - mfem::VTKFormat arg3 ; - bool arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); - } - arg3 = static_cast< mfem::VTKFormat >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - (arg1)->PrintVTU(arg2,arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - mfem::VTKFormat arg3 ; - bool arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - bool val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); - } - arg3 = static_cast< mfem::VTKFormat >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Mesh_PrintVTU" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - (arg1)->PrintVTU(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - mfem::VTKFormat arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - int val3 ; - int ecode3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Mesh_PrintVTU" "', argument " "3"" of type '" "mfem::VTKFormat""'"); - } - arg3 = static_cast< mfem::VTKFormat >(val3); - { - try { - (arg1)->PrintVTU(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::string arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTU" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__string, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintVTU" "', argument " "2"" of type '" "std::string""'"); - } else { - std::string * temp = reinterpret_cast< std::string * >(argp2); - arg2 = *temp; - if (SWIG_IsNewObj(res2)) delete temp; - } - } - { - try { - (arg1)->PrintVTU(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTU(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTU", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_8(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_7(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_6(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_std__string, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_5(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTU__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintVTU'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool,int)\n" - " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat,bool)\n" - " mfem::Mesh::PrintVTU(std::ostream &,int,mfem::VTKFormat)\n" - " mfem::Mesh::PrintVTU(std::ostream &,int)\n" - " mfem::Mesh::PrintVTU(std::ostream &)\n" - " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool,int)\n" - " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat,bool)\n" - " mfem::Mesh::PrintVTU(std::string,mfem::VTKFormat)\n" - " mfem::Mesh::PrintVTU(std::string)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - (arg1)->GetElementColoring(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementColoring" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementColoring" "', argument " "2"" of type '" "mfem::Array< int > &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->GetElementColoring(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementColoring(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementColoring", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementColoring__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementColoring'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &,int)\n" - " mfem::Mesh::GetElementColoring(mfem::Array< int > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - ((mfem::Mesh const *)arg1)->PrintWithPartitioning(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &,int) const\n" - " mfem::Mesh::PrintWithPartitioning(int *,std::ostream &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int *arg2 = (int *) 0 ; - std::ostream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsWithPartitioning" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - (arg1)->PrintElementsWithPartitioning(arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsWithPartitioning(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsWithPartitioning", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[2], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintElementsWithPartitioning__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintElementsWithPartitioning'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &,int)\n" - " mfem::Mesh::PrintElementsWithPartitioning(int *,std::ostream &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintSurfaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Table *arg2 = 0 ; - std::ostream *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintSurfaces", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintSurfaces" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintSurfaces" "', argument " "2"" of type '" "mfem::Table const &""'"); - } - arg2 = reinterpret_cast< mfem::Table * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - ((mfem::Mesh const *)arg1)->PrintSurfaces((mfem::Table const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ScaleSubdomains(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleSubdomains", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleSubdomains" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleSubdomains" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->ScaleSubdomains(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_ScaleElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_ScaleElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_ScaleElements" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Mesh_ScaleElements" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->ScaleElements(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void (*arg2)(mfem::Vector const &,mfem::Vector &) = (void (*)(mfem::Vector const &,mfem::Vector &)) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); - if (!SWIG_IsOK(res)) { - SWIG_exception_fail(SWIG_ArgError(res), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "void (*)(mfem::Vector const &,mfem::Vector &)""'"); - } - } - { - try { - (arg1)->Transform(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::VectorCoefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Transform" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__VectorCoefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_Transform" "', argument " "2"" of type '" "mfem::VectorCoefficient &""'"); - } - arg2 = reinterpret_cast< mfem::VectorCoefficient * >(argp2); - { - try { - (arg1)->Transform(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Transform(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Transform", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *ptr = 0; - int res = SWIG_ConvertFunctionPtr(argv[1], &ptr, SWIGTYPE_p_f_r_q_const__mfem__Vector_r_mfem__Vector__void); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Transform__SWIG_0(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__VectorCoefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Transform__SWIG_1(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Transform'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::Transform(void (*)(mfem::Vector const &,mfem::Vector &))\n" - " mfem::Mesh::Transform(mfem::VectorCoefficient &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveUnusedVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveUnusedVertices" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveUnusedVertices(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_RemoveInternalBoundaries(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_RemoveInternalBoundaries" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->RemoveInternalBoundaries(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (double)(arg1)->GetElementSize(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double result; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double)(arg1)->GetElementSize(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double result; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementSize" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetElementSize" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - result = (double)(arg1)->GetElementSize(arg2,(mfem::Vector const &)*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementSize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetElementSize", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetElementSize__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetElementSize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetElementSize(int,int)\n" - " mfem::Mesh::GetElementSize(int)\n" - " mfem::Mesh::GetElementSize(int,mfem::Vector const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetElementVolume(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetElementVolume", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetElementVolume" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (double)(arg1)->GetElementVolume(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->GetBoundingBox(*arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBoundingBox" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetBoundingBox" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - (arg1)->GetBoundingBox(*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetBoundingBox(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetBoundingBox", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_GetBoundingBox__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetBoundingBox'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Mesh::GetBoundingBox(mfem::Vector &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - mfem::Vector *arg7 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Mesh_GetCharacteristics" "', argument " "7"" of type '" "mfem::Vector *""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - mfem::Vector *arg6 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_GetCharacteristics" "', argument " "6"" of type '" "mfem::Vector *""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - double *arg2 = 0 ; - double *arg3 = 0 ; - double *arg4 = 0 ; - double *arg5 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "2"" of type '" "double &""'"); - } - arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "3"" of type '" "double &""'"); - } - arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "4"" of type '" "double &""'"); - } - arg4 = reinterpret_cast< double * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_GetCharacteristics" "', argument " "5"" of type '" "double &""'"); - } - arg5 = reinterpret_cast< double * >(argp5); - { - try { - (arg1)->GetCharacteristics(*arg2,*arg3,*arg4,*arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_GetCharacteristics(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_GetCharacteristics", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_GetCharacteristics__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_GetCharacteristics'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &,mfem::Vector *)\n" - " mfem::Mesh::GetCharacteristics(double &,double &,double &,double &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintElementsByGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Array< int > *arg2 = 0 ; - std::ostream *arg3 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyMFEM::wFILE *temp3 = 0 ; - std::ofstream out3 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintElementsByGeometry", 3, 3, swig_obj)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_PrintElementsByGeometry" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - if (SWIG_ConvertPtr(swig_obj[2], (void **) &temp3, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp3->isSTDOUT() == 1) { - arg3 = &std::cout; - } - else { - out3.open(temp3->getFilename()); - out3.precision(temp3->getPrecision()); - arg3 = &out3; - } - } - { - try { - mfem::Mesh::PrintElementsByGeometry(arg1,(mfem::Array< int > const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return resultobj; -fail: - { - if (temp3->isSTDOUT() != 1) { - out3.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - std::ostream *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyMFEM::wFILE *temp4 = 0 ; - std::ofstream out4 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if (SWIG_ConvertPtr(swig_obj[3], (void **) &temp4, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp4->isSTDOUT() == 1) { - arg4 = &std::cout; - } - else { - out4.open(temp4->getFilename()); - out4.precision(temp4->getPrecision()); - arg4 = &out4; - } - } - { - try { - (arg1)->PrintCharacteristics(arg2,arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } - return resultobj; -fail: - { - if (temp4->isSTDOUT() != 1) { - out4.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_PrintCharacteristics" "', argument " "3"" of type '" "mfem::Vector *""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - (arg1)->PrintCharacteristics(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::Vector *arg2 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintCharacteristics" "', argument " "2"" of type '" "mfem::Vector *""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - { - try { - (arg1)->PrintCharacteristics(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintCharacteristics" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->PrintCharacteristics(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintCharacteristics(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintCharacteristics", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[3], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintCharacteristics__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintCharacteristics'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *,std::ostream &)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *,mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics(mfem::Vector *)\n" - " mfem::Mesh::PrintCharacteristics()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->PrintInfo(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - (arg1)->PrintInfo(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - mfem::InverseElementTransformation *arg6 = (mfem::InverseElementTransformation *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - int result; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_mfem__InverseElementTransformation, 0 | 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Mesh_FindPoints" "', argument " "6"" of type '" "mfem::InverseElementTransformation *""'"); - } - arg6 = reinterpret_cast< mfem::InverseElementTransformation * >(argp6); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - bool arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - bool val5 ; - int ecode5 = 0 ; - int result; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Mesh_FindPoints" "', argument " "5"" of type '" "bool""'"); - } - arg5 = static_cast< bool >(val5); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - mfem::DenseMatrix *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::Array< mfem::IntegrationPoint > *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int result; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_FindPoints" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "2"" of type '" "mfem::DenseMatrix &""'"); - } - arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mesh_FindPoints" "', argument " "4"" of type '" "mfem::Array< mfem::IntegrationPoint > &""'"); - } - arg4 = reinterpret_cast< mfem::Array< mfem::IntegrationPoint > * >(argp4); - { - try { - result = (int)(arg1)->FindPoints(*arg2,*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_FindPoints(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[7] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_FindPoints", 0, 6, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_2(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_1(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__IntegrationPoint_t, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__InverseElementTransformation, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_FindPoints__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_FindPoints'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool,mfem::InverseElementTransformation *)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &,bool)\n" - " mfem::Mesh::FindPoints(mfem::DenseMatrix &,mfem::Array< int > &,mfem::Array< mfem::IntegrationPoint > &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_delete_Mesh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Mesh" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_32(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - double arg8 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_Mesh" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7,arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_33(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - double arg7 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_Mesh" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_34(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - double arg6 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_35(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int arg5 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_36(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - int arg3 ; - char *arg4 = (char *) 0 ; - int res4 ; - char *buf4 = 0 ; - int alloc4 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Mesh" "', argument " "4"" of type '" "char const *""'"); - } - arg4 = reinterpret_cast< char * >(buf4); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_32(arg1,arg2,arg3,(char const *)arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return resultobj; -fail: - if (alloc4 == SWIG_NEWOBJ) delete[] buf4; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_37(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - double arg6 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - double val6 ; - int ecode6 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_Mesh" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_38(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - double arg5 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - double val5 ; - int ecode5 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Mesh" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_39(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int arg4 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh__SWIG_40(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - char *arg3 = (char *) 0 ; - int res3 ; - char *buf3 = 0 ; - int alloc3 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Mesh" "', argument " "3"" of type '" "char const *""'"); - } - arg3 = reinterpret_cast< char * >(buf3); - { - try { - result = (mfem::Mesh *)new_mfem_Mesh__SWIG_37(arg1,arg2,(char const *)arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NEW | 0 ); - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return resultobj; -fail: - if (alloc3 == SWIG_NEWOBJ) delete[] buf3; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[13] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_Mesh", 0, 12, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_Mesh__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_3(self, argc, argv); - } - } - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_29(self, argc, argv); - } - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_21(self, argc, argv); - } - } - if (argc == 1) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_25(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_28(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Mesh, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_2(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_30(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_20(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_24(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_27(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_31(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_8(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_40(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_23(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - return _wrap_new_Mesh__SWIG_19(self, argc, argv); - } - } - if (argc == 4) { + if ((argc >= 1) && (argc <= 4)) { int _v; void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_26(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_7(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_Mesh__SWIG_36(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_39(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_22(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - return _wrap_new_Mesh__SWIG_14(self, argc, argv); - } - } - if (argc == 4) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_18(self, argc, argv); - } - } - } - if (argc == 5) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__istream, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -26994,6 +17119,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -27003,32 +17131,21 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_9(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_6(self, argc, argv); - } + return _wrap_new_Mesh__SWIG_9(self, argc, argv); } } } } } - if (argc == 5) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -27039,6 +17156,29 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_7(self, argc, argv); + } + { + if (PyFloat_Check(argv[1])){ + _v = 1; + } else { + _v = 0; + } + } + if (_v) { + return _wrap_new_Mesh__SWIG_7(self, argc, argv); + } + } + } + if ((argc >= 1) && (argc <= 4)) { + int _v; + int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 1) { + return _wrap_new_Mesh__SWIG_8(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -27048,6 +17188,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_Mesh__SWIG_8(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -27057,35 +17200,25 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_8(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[3], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_35(self, argc, argv); - } + return _wrap_new_Mesh__SWIG_8(self, argc, argv); } } } } } - if (argc == 5) { + if (argc == 2) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { @@ -27096,73 +17229,40 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if (PyFloat_Check(argv[4])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_38(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_Mesh__SWIG_13(self, argc, argv); + return _wrap_new_Mesh__SWIG_10(self, argc, argv); } } } - if (argc == 5) { + if (argc == 3) { int _v; - { - _v = 0; // ignore this pattern - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { { - if (PyFloat_Check(argv[4])){ - _v = 1; - } else { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); _v = 0; + } else { + _v = 1; } } if (_v) { - return _wrap_new_Mesh__SWIG_17(self, argc, argv); + return _wrap_new_Mesh__SWIG_11(self, argc, argv); } } } } - if (argc == 6) { + if ((argc >= 3) && (argc <= 5)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -27191,9 +17291,21 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_4(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_4(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -27203,23 +17315,14 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - { - if (PyFloat_Check(argv[5])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_34(self, argc, argv); - } + return _wrap_new_Mesh__SWIG_4(self, argc, argv); } } } } } } - if (argc == 6) { + if ((argc >= 3) && (argc <= 6)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -27242,137 +17345,32 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_13(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); _v = 0; } else { _v = 1; - } - } - if (_v) { - { - if (PyFloat_Check(argv[4])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[5])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_37(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 6) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if (PyFloat_Check(argv[4])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[5])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_16(self, argc, argv); - } - } - } - } - } - if (argc == 6) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if (PyFloat_Check(argv[5])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_12(self, argc, argv); - } - } - } - } - if (argc == 7) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + } } - } - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); - _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_13(self, argc, argv); + } { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; + if (PyFloat_Check(argv[4])){ + _v = 1; } else { - _v = 1; + _v = 0; } } if (_v) { + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_13(self, argc, argv); + } { if (PyFloat_Check(argv[5])){ _v = 1; @@ -27381,16 +17379,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - { - if (PyFloat_Check(argv[6])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_33(self, argc, argv); - } + return _wrap_new_Mesh__SWIG_13(self, argc, argv); } } } @@ -27398,17 +17387,23 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 7) { + if ((argc >= 3) && (argc <= 7)) { int _v; { _v = 0; // ignore this pattern } if (_v) { + if (argc <= 3) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { if (PyFloat_Check(argv[4])){ _v = 1; @@ -27417,6 +17412,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { if (PyFloat_Check(argv[5])){ _v = 1; @@ -27425,52 +17423,22 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 6) { + return _wrap_new_Mesh__SWIG_6(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[6], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Mesh__SWIG_15(self, argc, argv); - } - } - } - } - } - } - if (argc == 7) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if (PyFloat_Check(argv[5])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[6])){ - _v = 1; - } else { - _v = 0; + return _wrap_new_Mesh__SWIG_6(self, argc, argv); } } - if (_v) { - return _wrap_new_Mesh__SWIG_11(self, argc, argv); - } } } } } - if (argc == 8) { + if ((argc >= 4) && (argc <= 8)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -27502,6 +17470,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -27511,6 +17482,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { if (PyFloat_Check(argv[5])){ _v = 1; @@ -27519,6 +17493,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 6) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { if (PyFloat_Check(argv[6])){ _v = 1; @@ -27527,6 +17504,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 7) { + return _wrap_new_Mesh__SWIG_12(self, argc, argv); + } { if (PyFloat_Check(argv[7])){ _v = 1; @@ -27535,7 +17515,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Mesh__SWIG_32(self, argc, argv); + return _wrap_new_Mesh__SWIG_12(self, argc, argv); } } } @@ -27545,59 +17525,23 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 8) { + if ((argc >= 4) && (argc <= 9)) { int _v; { _v = 0; // ignore this pattern } if (_v) { - { - int res = SWIG_AsVal_bool(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if (PyFloat_Check(argv[5])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[6])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[7])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_new_Mesh__SWIG_10(self, argc, argv); - } - } - } + if (argc <= 4) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); } - } - } - if (argc == 9) { - int _v; - { - _v = 0; // ignore this pattern - } - if (_v) { { int res = SWIG_AsVal_bool(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 5) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } { if (PyFloat_Check(argv[5])){ _v = 1; @@ -27606,6 +17550,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 6) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } { if (PyFloat_Check(argv[6])){ _v = 1; @@ -27614,6 +17561,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 7) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } { if (PyFloat_Check(argv[7])){ _v = 1; @@ -27622,12 +17572,15 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 8) { + return _wrap_new_Mesh__SWIG_5(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[8], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Mesh__SWIG_9(self, argc, argv); + return _wrap_new_Mesh__SWIG_5(self, argc, argv); } } } @@ -27635,7 +17588,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } } - if (argc == 11) { + if ((argc >= 11) && (argc <= 12)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); @@ -27703,87 +17656,9 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Mesh__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - } - } - } - } - if (argc == 12) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_double, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[8], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[9]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[10]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 11) { + return _wrap_new_Mesh__SWIG_3(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[11]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -27793,7 +17668,7 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Mesh__SWIG_4(self, argc, argv); + return _wrap_new_Mesh__SWIG_3(self, argc, argv); } } } @@ -27813,49 +17688,22 @@ SWIGINTERN PyObject *_wrap_new_Mesh(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::Mesh::Mesh()\n" " mfem::Mesh::Mesh(mfem::Mesh const &,bool)\n" - " mfem::Mesh::Mesh(mfem::Mesh const &)\n" " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int,int)\n" - " mfem::Mesh::Mesh(double *,int,int *,mfem::Geometry::Type,int *,int,int *,mfem::Geometry::Type,int *,int,int)\n" " mfem::Mesh::Mesh(int,int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int,int)\n" - " mfem::Mesh::Mesh(int,int,int)\n" " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,int,mfem::Element::Type)\n" " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool,double)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type,bool)\n" - " mfem::Mesh::Mesh(int,int,mfem::Element::Type)\n" " mfem::Mesh::Mesh(int,double)\n" - " mfem::Mesh::Mesh(int)\n" " mfem::Mesh::Mesh(char const *,int,int,bool)\n" - " mfem::Mesh::Mesh(char const *,int,int)\n" - " mfem::Mesh::Mesh(char const *,int)\n" - " mfem::Mesh::Mesh(char const *)\n" " mfem::Mesh::Mesh(std::istream &,int,int,bool)\n" - " mfem::Mesh::Mesh(std::istream &,int,int)\n" - " mfem::Mesh::Mesh(std::istream &,int)\n" - " mfem::Mesh::Mesh(std::istream &)\n" " mfem::Mesh::Mesh(mfem::Mesh *[],int)\n" " mfem::Mesh::Mesh(mfem::Mesh *,int,int)\n" " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,int,char const *)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int,double)\n" - " mfem::Mesh::Mesh(int,int,char const *,int)\n" - " mfem::Mesh::Mesh(int,int,char const *)\n"); + " mfem::Mesh::Mesh(int,int,char const *,int,double,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; @@ -27865,24 +17713,29 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintToFile(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mesh_file", (char *)"precision", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Mesh_PrintToFile", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Mesh_PrintToFile", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintToFile" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintToFile" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -27953,26 +17806,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetAttributeArray(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetVertexArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetVertexArray", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetVertexArray", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetVertexArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -28153,26 +18010,30 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrAttributeArray(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetBdrArray", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetBdrArray", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetBdrArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -28200,84 +18061,34 @@ SWIGINTERN PyObject *_wrap_Mesh_GetBdrArray(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Mesh_GetDomainArray(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"idx", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Mesh_GetDomainArray", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Mesh_GetDomainArray", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_GetDomainArray" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (PyObject *)mfem_Mesh_GetDomainArray((mfem::Mesh const *)arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = result; - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); + arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2,arg3); + result = (PyObject *)mfem_Mesh_GetDomainArray((mfem::Mesh const *)arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28294,26 +18105,25 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; + resultobj = result; return resultobj; fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; return NULL; } -SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintInfo" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -28324,9 +18134,17 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_Mesh_PrintInfo__SWIG_2(arg1,(char const *)arg2); + mfem_Mesh_PrintInfo__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28360,34 +18178,15 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintInfo", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_Mesh_PrintInfo__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -28402,7 +18201,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -28411,6 +18210,9 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -28420,7 +18222,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_PrintInfo__SWIG_2(self, argc, argv); + return _wrap_Mesh_PrintInfo__SWIG_1(self, argc, argv); } } } @@ -28430,25 +18232,23 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintInfo(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintInfo'.\n" " Possible C/C++ prototypes are:\n" " mfem::Mesh::PrintInfo(std::ostream &)\n" - " mfem::Mesh::PrintInfo()\n" - " mfem::Mesh::PrintInfo(char const *,int)\n" - " mfem::Mesh::PrintInfo(char const *)\n"); + " mfem::Mesh::PrintInfo(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -28459,64 +18259,17 @@ SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_Print" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Mesh_Print__SWIG_2(arg1,(char const *)arg2); + mfem_Mesh_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28550,34 +18303,15 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_Print__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_Mesh_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -28592,7 +18326,7 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -28601,6 +18335,9 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Mesh_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -28610,7 +18347,7 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_Print__SWIG_2(self, argc, argv); + return _wrap_Mesh_Print__SWIG_1(self, argc, argv); } } } @@ -28620,25 +18357,23 @@ SWIGINTERN PyObject *_wrap_Mesh_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Mesh::Print(std::ostream &) const\n" - " mfem::Mesh::Print() const\n" - " mfem::Mesh::Print(char const *,int)\n" - " mfem::Mesh::Print(char const *)\n"); + " mfem::Mesh::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -28649,64 +18384,17 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintXG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintXG" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintXG" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Mesh_PrintXG__SWIG_2(arg1,(char const *)arg2); + mfem_Mesh_PrintXG__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28740,34 +18428,15 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintXG", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -28777,113 +18446,59 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintXG(PyObject *self, PyObject *args) { _v = 1; } } - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintXG__SWIG_2(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintXG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mesh::PrintXG(std::ostream &) const\n" - " mfem::Mesh::PrintXG() const\n" - " mfem::Mesh::PrintXG(char const *,int)\n" - " mfem::Mesh::PrintXG(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2,arg3); + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_0(self, argc, argv); + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 2) { + return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Mesh_PrintXG__SWIG_1(self, argc, argv); + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; + fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mesh_PrintXG'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Mesh::PrintXG(std::ostream &) const\n" + " mfem::Mesh::PrintXG(char const *,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mesh_PrintVTK" "', argument " "1"" of type '" "mfem::Mesh *""'"); @@ -28894,9 +18509,17 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK__SWIG_4(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mesh_PrintVTK" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_Mesh_PrintVTK__SWIG_3(arg1,(char const *)arg2); + mfem_Mesh_PrintVTK__SWIG_2(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -28930,7 +18553,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Mesh_PrintVTK", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -28939,39 +18562,9 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -28981,12 +18574,12 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_3(self, argc, argv); + return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); } } } } - if (argc == 3) { + if (argc == 2) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -29002,21 +18595,11 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Mesh_PrintVTK__SWIG_2(self, argc, argv); - } + return _wrap_Mesh_PrintVTK__SWIG_0(self, argc, argv); } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); @@ -29041,6 +18624,9 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 3) { + return _wrap_Mesh_PrintVTK__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -29062,9 +18648,7 @@ SWIGINTERN PyObject *_wrap_Mesh_PrintVTK(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::Mesh::PrintVTK(std::ostream &)\n" " mfem::Mesh::PrintVTK(std::ostream &,int,int)\n" - " mfem::Mesh::PrintVTK(std::ostream &,int)\n" - " mfem::Mesh::PrintVTK(char const *,int)\n" - " mfem::Mesh::PrintVTK(char const *)\n"); + " mfem::Mesh::PrintVTK(char const *,int)\n"); return 0; } @@ -29341,7 +18925,7 @@ SWIGINTERN PyObject *_wrap_GeometricFactors_computed_factors_get(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -29350,16 +18934,21 @@ SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"ir", (char *)"flags", NULL + }; mfem::GeometricFactors *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_GeometricFactors", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_GeometricFactors", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_GeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -29368,10 +18957,10 @@ SWIGINTERN PyObject *_wrap_new_GeometricFactors(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -29813,7 +19402,7 @@ SWIGINTERN PyObject *_wrap_FaceGeometricFactors_type_get(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -29825,16 +19414,22 @@ SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; int val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"ir", (char *)"flags", (char *)"type", NULL + }; mfem::FaceGeometricFactors *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_FaceGeometricFactors", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_FaceGeometricFactors", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_FaceGeometricFactors" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_FaceGeometricFactors" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -29843,12 +19438,12 @@ SWIGINTERN PyObject *_wrap_new_FaceGeometricFactors(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_int(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FaceGeometricFactors" "', argument " "4"" of type '" "mfem::FaceType""'"); } @@ -30138,25 +19733,29 @@ SWIGINTERN PyObject *FaceGeometricFactors_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_NodeExtrudeCoefficient_SetLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NodeExtrudeCoefficient_SetLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NodeExtrudeCoefficient *arg1 = (mfem::NodeExtrudeCoefficient *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"l", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NodeExtrudeCoefficient_SetLayer", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NodeExtrudeCoefficient, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NodeExtrudeCoefficient_SetLayer", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NodeExtrudeCoefficient, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NodeExtrudeCoefficient_SetLayer" "', argument " "1"" of type '" "mfem::NodeExtrudeCoefficient *""'"); } arg1 = reinterpret_cast< mfem::NodeExtrudeCoefficient * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -30532,42 +20131,51 @@ SWIGINTERN PyObject *NodeExtrudeCoefficient_swigregister(PyObject *SWIGUNUSEDPAR return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Extrude1D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; double arg3 ; - bool arg4 ; + bool arg4 = (bool) (bool)false ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"ny", (char *)"sy", (char *)"closed", NULL + }; mfem::Mesh *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Extrude1D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude1D" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Extrude1D" "', argument " "3"" of type '" "double""'"); } arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Extrude1D" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Extrude1D" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { result = (mfem::Mesh *)mfem::Extrude1D(arg1,arg2,arg3,arg4); @@ -30594,7 +20202,7 @@ SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; int arg2 ; @@ -30603,156 +20211,27 @@ SWIGINTERN PyObject *_wrap_Extrude1D__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ int res1 = 0 ; double val3 ; int ecode3 = 0 ; - mfem::Mesh *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude1D" "', argument " "1"" of type '" "mfem::Mesh *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Extrude1D" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::Mesh *)mfem::Extrude1D(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Extrude1D(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"mesh", (char *)"nz", (char *)"sz", NULL }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Extrude1D", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - return _wrap_Extrude1D__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if (PyFloat_Check(argv[2])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Extrude1D__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Extrude1D'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Extrude1D(mfem::Mesh *,int const,double const,bool const)\n" - " mfem::Extrude1D(mfem::Mesh *,int const,double const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - int arg2 ; - double arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; mfem::Mesh *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Extrude2D", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Extrude2D", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Extrude2D" "', argument " "1"" of type '" "mfem::Mesh *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Extrude2D" "', argument " "3"" of type '" "double""'"); } @@ -30783,7 +20262,7 @@ SWIGINTERN PyObject *_wrap_Extrude2D(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = 0 ; int *arg2 = 0 ; @@ -30794,10 +20273,15 @@ SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject * int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"a", (char *)"b", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ShiftRight", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_int, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ShiftRight", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } @@ -30805,7 +20289,7 @@ SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "1"" of type '" "int &""'"); } arg1 = reinterpret_cast< int * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_int, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } @@ -30813,7 +20297,7 @@ SWIGINTERN PyObject *_wrap_ShiftRight(PyObject *SWIGUNUSEDPARM(self), PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ShiftRight" "', argument " "2"" of type '" "int &""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_int, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ShiftRight" "', argument " "3"" of type '" "int &""'"); } @@ -30852,18 +20336,18 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "Mesh_attributes_get", _wrap_Mesh_attributes_get, METH_O, "Mesh_attributes_get(Mesh self) -> intArray"}, @@ -30878,36 +20362,36 @@ static PyMethodDef SwigMethods[] = { { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, - { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "Mesh_NewElement(Mesh self, int geom) -> Element"}, - { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "Mesh_AddVertex(Mesh self, double const * arg2)"}, - { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "Mesh_AddSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "Mesh_AddTri(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "Mesh_AddTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "Mesh_AddQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTet", _wrap_Mesh_AddTet, METH_VARARGS, "Mesh_AddTet(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddWedge", _wrap_Mesh_AddWedge, METH_VARARGS, "Mesh_AddWedge(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHex", _wrap_Mesh_AddHex, METH_VARARGS, "Mesh_AddHex(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsTets", _wrap_Mesh_AddHexAsTets, METH_VARARGS, "Mesh_AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsWedges", _wrap_Mesh_AddHexAsWedges, METH_VARARGS, "Mesh_AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddElement", _wrap_Mesh_AddElement, METH_VARARGS, "Mesh_AddElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrElement", _wrap_Mesh_AddBdrElement, METH_VARARGS, "Mesh_AddBdrElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrSegment", _wrap_Mesh_AddBdrSegment, METH_VARARGS, "Mesh_AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrTriangle", _wrap_Mesh_AddBdrTriangle, METH_VARARGS, "Mesh_AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuad", _wrap_Mesh_AddBdrQuad, METH_VARARGS, "Mesh_AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuadAsTriangles", _wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS, "Mesh_AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_NewElement", (PyCFunction)(void(*)(void))_wrap_Mesh_NewElement, METH_VARARGS|METH_KEYWORDS, "Mesh_NewElement(Mesh self, int geom) -> Element"}, + { "Mesh_AddVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddVertex, METH_VARARGS|METH_KEYWORDS, "Mesh_AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddSegment, METH_VARARGS|METH_KEYWORDS, "Mesh_AddSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTri", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTri, METH_VARARGS|METH_KEYWORDS, "Mesh_AddTri(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTriangle, METH_VARARGS|METH_KEYWORDS, "Mesh_AddTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddQuad, METH_VARARGS|METH_KEYWORDS, "Mesh_AddQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTet", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTet, METH_VARARGS|METH_KEYWORDS, "Mesh_AddTet(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddWedge", (PyCFunction)(void(*)(void))_wrap_Mesh_AddWedge, METH_VARARGS|METH_KEYWORDS, "Mesh_AddWedge(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHex, METH_VARARGS|METH_KEYWORDS, "Mesh_AddHex(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsTets", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsTets, METH_VARARGS|METH_KEYWORDS, "Mesh_AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsWedges", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsWedges, METH_VARARGS|METH_KEYWORDS, "Mesh_AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddElement, METH_VARARGS|METH_KEYWORDS, "Mesh_AddElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrElement, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrSegment, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrTriangle, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuad, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuadAsTriangles", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS|METH_KEYWORDS, "Mesh_AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, { "Mesh_GenerateBoundaryElements", _wrap_Mesh_GenerateBoundaryElements, METH_O, "Mesh_GenerateBoundaryElements(Mesh self)"}, - { "Mesh_FinalizeTriMesh", _wrap_Mesh_FinalizeTriMesh, METH_VARARGS, "Mesh_FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeQuadMesh", _wrap_Mesh_FinalizeQuadMesh, METH_VARARGS, "Mesh_FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTetMesh", _wrap_Mesh_FinalizeTetMesh, METH_VARARGS, "Mesh_FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "Mesh_FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "Mesh_FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "Mesh_FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "Mesh_FinalizeTopology(Mesh self, bool generate_bdr=True)"}, - { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Mesh_Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, + { "Mesh_FinalizeTriMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTriMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeQuadMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeQuadMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTetMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTetMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeWedgeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeHexMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeHexMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTopology", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTopology, METH_VARARGS|METH_KEYWORDS, "Mesh_FinalizeTopology(Mesh self, bool generate_bdr=True)"}, + { "Mesh_Finalize", (PyCFunction)(void(*)(void))_wrap_Mesh_Finalize, METH_VARARGS|METH_KEYWORDS, "Mesh_Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "Mesh_SetAttributes(Mesh self)"}, - { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "Mesh_GetHilbertElementOrdering(Mesh self, intArray ordering)"}, - { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "Mesh_ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, - { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Mesh_Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "Mesh_GetHilbertElementOrdering", (PyCFunction)(void(*)(void))_wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS|METH_KEYWORDS, "Mesh_GetHilbertElementOrdering(Mesh self, intArray ordering)"}, + { "Mesh_ReorderElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ReorderElements, METH_VARARGS|METH_KEYWORDS, "Mesh_ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, + { "Mesh_Load", (PyCFunction)(void(*)(void))_wrap_Mesh_Load, METH_VARARGS|METH_KEYWORDS, "Mesh_Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Mesh_Clear(Mesh self)"}, { "Mesh_MeshGenerator", _wrap_Mesh_MeshGenerator, METH_O, "Mesh_MeshGenerator(Mesh self) -> int"}, { "Mesh_GetNV", _wrap_Mesh_GetNV, METH_O, "Mesh_GetNV(Mesh self) -> int"}, @@ -30916,11 +20400,11 @@ static PyMethodDef SwigMethods[] = { { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "Mesh_GetNEdges(Mesh self) -> int"}, { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "Mesh_GetNFaces(Mesh self) -> int"}, { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "Mesh_GetNumFaces(Mesh self) -> int"}, - { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "Mesh_GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, - { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "Mesh_ReduceInt(Mesh self, int value) -> long"}, + { "Mesh_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, + { "Mesh_ReduceInt", (PyCFunction)(void(*)(void))_wrap_Mesh_ReduceInt, METH_VARARGS|METH_KEYWORDS, "Mesh_ReduceInt(Mesh self, int value) -> long"}, { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "Mesh_GetGlobalNE(Mesh self) -> long"}, - { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "Mesh_GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, - { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "Mesh_GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "Mesh_GetGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometricFactors, METH_VARARGS|METH_KEYWORDS, "Mesh_GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "Mesh_DeleteGeometricFactors(Mesh self)"}, { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "Mesh_EulerNumber(Mesh self) -> int"}, { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "Mesh_EulerNumber2D(Mesh self) -> int"}, @@ -30930,9 +20414,9 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetVertex(Mesh self, int i) -> double const\n" "Mesh_GetVertex(Mesh self, int i) -> double *\n" ""}, - { "Mesh_GetElementData", _wrap_Mesh_GetElementData, METH_VARARGS, "Mesh_GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, - { "Mesh_GetBdrElementData", _wrap_Mesh_GetBdrElementData, METH_VARARGS, "Mesh_GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, - { "Mesh_ChangeVertexDataOwnership", _wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS, "Mesh_ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, + { "Mesh_GetElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementData, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, + { "Mesh_GetBdrElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementData, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, + { "Mesh_ChangeVertexDataOwnership", (PyCFunction)(void(*)(void))_wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS|METH_KEYWORDS, "Mesh_ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, { "Mesh_GetElementsArray", _wrap_Mesh_GetElementsArray, METH_O, "Mesh_GetElementsArray(Mesh self) -> mfem::Element const *const *"}, { "Mesh_GetElement", _wrap_Mesh_GetElement, METH_VARARGS, "\n" "Mesh_GetElement(Mesh self, int i) -> Element\n" @@ -30942,30 +20426,30 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetBdrElement(Mesh self, int i) -> Element\n" "Mesh_GetBdrElement(Mesh self, int i) -> Element\n" ""}, - { "Mesh_GetFace", _wrap_Mesh_GetFace, METH_VARARGS, "Mesh_GetFace(Mesh self, int i) -> Element"}, - { "Mesh_GetFaceBaseGeometry", _wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS, "Mesh_GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetElementBaseGeometry", _wrap_Mesh_GetElementBaseGeometry, METH_VARARGS, "Mesh_GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetBdrElementBaseGeometry", _wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS, "Mesh_GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_HasGeometry", _wrap_Mesh_HasGeometry, METH_VARARGS, "Mesh_HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, - { "Mesh_GetNumGeometries", _wrap_Mesh_GetNumGeometries, METH_VARARGS, "Mesh_GetNumGeometries(Mesh self, int dim) -> int"}, - { "Mesh_GetGeometries", _wrap_Mesh_GetGeometries, METH_VARARGS, "Mesh_GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, - { "Mesh_GetElementVertices", _wrap_Mesh_GetElementVertices, METH_VARARGS, "Mesh_GetElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetBdrElementVertices", _wrap_Mesh_GetBdrElementVertices, METH_VARARGS, "Mesh_GetBdrElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetElementEdges", _wrap_Mesh_GetElementEdges, METH_VARARGS, "Mesh_GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetBdrElementEdges", _wrap_Mesh_GetBdrElementEdges, METH_VARARGS, "Mesh_GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetFaceEdges", _wrap_Mesh_GetFaceEdges, METH_VARARGS, "Mesh_GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetFaceVertices", _wrap_Mesh_GetFaceVertices, METH_VARARGS, "Mesh_GetFaceVertices(Mesh self, int i, intArray vert)"}, - { "Mesh_GetEdgeVertices", _wrap_Mesh_GetEdgeVertices, METH_VARARGS, "Mesh_GetEdgeVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetFace", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFace, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFace(Mesh self, int i) -> Element"}, + { "Mesh_GetFaceBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetBdrElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_HasGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_HasGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, + { "Mesh_GetNumGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNumGeometries, METH_VARARGS|METH_KEYWORDS, "Mesh_GetNumGeometries(Mesh self, int dim) -> int"}, + { "Mesh_GetGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometries, METH_VARARGS|METH_KEYWORDS, "Mesh_GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, + { "Mesh_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetBdrElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementEdges, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetBdrElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdges, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetFaceEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceEdges, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetEdgeVertices(Mesh self, int i, intArray vert)"}, { "Mesh_GetFaceEdgeTable", _wrap_Mesh_GetFaceEdgeTable, METH_O, "Mesh_GetFaceEdgeTable(Mesh self) -> Table"}, { "Mesh_GetEdgeVertexTable", _wrap_Mesh_GetEdgeVertexTable, METH_O, "Mesh_GetEdgeVertexTable(Mesh self) -> Table"}, - { "Mesh_GetElementFaces", _wrap_Mesh_GetElementFaces, METH_VARARGS, "Mesh_GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetBdrElementEdgeIndex", _wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS, "Mesh_GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, - { "Mesh_GetBdrElementAdjacentElement", _wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS, "Mesh_GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, - { "Mesh_GetElementType", _wrap_Mesh_GetElementType, METH_VARARGS, "Mesh_GetElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetBdrElementType", _wrap_Mesh_GetBdrElementType, METH_VARARGS, "Mesh_GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetPointMatrix", _wrap_Mesh_GetPointMatrix, METH_VARARGS, "Mesh_GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetBdrPointMatrix", _wrap_Mesh_GetBdrPointMatrix, METH_VARARGS, "Mesh_GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetTransformationFEforElementType", _wrap_Mesh_GetTransformationFEforElementType, METH_O, "Mesh_GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, + { "Mesh_GetElementFaces", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementFaces, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetBdrElementEdgeIndex", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, + { "Mesh_GetBdrElementAdjacentElement", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, + { "Mesh_GetElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetPointMatrix, METH_VARARGS|METH_KEYWORDS, "Mesh_GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetBdrPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrPointMatrix, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetTransformationFEforElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetTransformationFEforElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, { "Mesh_GetElementTransformation", _wrap_Mesh_GetElementTransformation, METH_VARARGS, "\n" "Mesh_GetElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" "Mesh_GetElementTransformation(Mesh self, int i) -> ElementTransformation\n" @@ -30975,7 +20459,7 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetBdrElementTransformation(Mesh self, int i) -> ElementTransformation\n" "Mesh_GetBdrElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "Mesh_GetLocalFaceTransformation", _wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS, "Mesh_GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, + { "Mesh_GetLocalFaceTransformation", (PyCFunction)(void(*)(void))_wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS|METH_KEYWORDS, "Mesh_GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, { "Mesh_GetFaceTransformation", _wrap_Mesh_GetFaceTransformation, METH_VARARGS, "\n" "Mesh_GetFaceTransformation(Mesh self, int i, IsoparametricTransformation FTr)\n" "Mesh_GetFaceTransformation(Mesh self, int FaceNo) -> ElementTransformation\n" @@ -30984,58 +20468,58 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetEdgeTransformation(Mesh self, int i, IsoparametricTransformation EdTr)\n" "Mesh_GetEdgeTransformation(Mesh self, int EdgeNo) -> ElementTransformation\n" ""}, - { "Mesh_GetFaceElementTransformations", _wrap_Mesh_GetFaceElementTransformations, METH_VARARGS, "Mesh_GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, - { "Mesh_GetInteriorFaceTransformations", _wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS, "Mesh_GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, - { "Mesh_GetBdrFaceTransformations", _wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS, "Mesh_GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, - { "Mesh_FaceIsInterior", _wrap_Mesh_FaceIsInterior, METH_VARARGS, "Mesh_FaceIsInterior(Mesh self, int FaceNo) -> bool"}, - { "Mesh_GetFaceElements", _wrap_Mesh_GetFaceElements, METH_VARARGS, "Mesh_GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, - { "Mesh_GetFaceInfos", _wrap_Mesh_GetFaceInfos, METH_VARARGS, "Mesh_GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, - { "Mesh_GetFaceGeometryType", _wrap_Mesh_GetFaceGeometryType, METH_VARARGS, "Mesh_GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, - { "Mesh_GetFaceElementType", _wrap_Mesh_GetFaceElementType, METH_VARARGS, "Mesh_GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, - { "Mesh_CheckElementOrientation", _wrap_Mesh_CheckElementOrientation, METH_VARARGS, "Mesh_CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_CheckBdrElementOrientation", _wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS, "Mesh_CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_GetAttribute", _wrap_Mesh_GetAttribute, METH_VARARGS, "Mesh_GetAttribute(Mesh self, int i) -> int"}, - { "Mesh_SetAttribute", _wrap_Mesh_SetAttribute, METH_VARARGS, "Mesh_SetAttribute(Mesh self, int i, int attr)"}, - { "Mesh_GetBdrAttribute", _wrap_Mesh_GetBdrAttribute, METH_VARARGS, "Mesh_GetBdrAttribute(Mesh self, int i) -> int"}, + { "Mesh_GetFaceElementTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementTransformations, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, + { "Mesh_GetInteriorFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS|METH_KEYWORDS, "Mesh_GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, + { "Mesh_GetBdrFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, + { "Mesh_FaceIsInterior", (PyCFunction)(void(*)(void))_wrap_Mesh_FaceIsInterior, METH_VARARGS|METH_KEYWORDS, "Mesh_FaceIsInterior(Mesh self, int FaceNo) -> bool"}, + { "Mesh_GetFaceElements", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElements, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, + { "Mesh_GetFaceInfos", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceInfos, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, + { "Mesh_GetFaceGeometryType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometryType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, + { "Mesh_GetFaceElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementType, METH_VARARGS|METH_KEYWORDS, "Mesh_GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, + { "Mesh_CheckElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckElementOrientation, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_CheckBdrElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_GetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetAttribute, METH_VARARGS|METH_KEYWORDS, "Mesh_GetAttribute(Mesh self, int i) -> int"}, + { "Mesh_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_SetAttribute, METH_VARARGS|METH_KEYWORDS, "Mesh_SetAttribute(Mesh self, int i, int attr)"}, + { "Mesh_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrAttribute(Mesh self, int i) -> int"}, { "Mesh_ElementToElementTable", _wrap_Mesh_ElementToElementTable, METH_O, "Mesh_ElementToElementTable(Mesh self) -> Table"}, { "Mesh_ElementToFaceTable", _wrap_Mesh_ElementToFaceTable, METH_O, "Mesh_ElementToFaceTable(Mesh self) -> Table"}, { "Mesh_ElementToEdgeTable", _wrap_Mesh_ElementToEdgeTable, METH_O, "Mesh_ElementToEdgeTable(Mesh self) -> Table"}, { "Mesh_GetVertexToElementTable", _wrap_Mesh_GetVertexToElementTable, METH_O, "Mesh_GetVertexToElementTable(Mesh self) -> Table"}, { "Mesh_GetFaceToElementTable", _wrap_Mesh_GetFaceToElementTable, METH_O, "Mesh_GetFaceToElementTable(Mesh self) -> Table"}, { "Mesh_ReorientTetMesh", _wrap_Mesh_ReorientTetMesh, METH_O, "Mesh_ReorientTetMesh(Mesh self)"}, - { "Mesh_CartesianPartitioning", _wrap_Mesh_CartesianPartitioning, METH_VARARGS, "Mesh_CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, - { "Mesh_GeneratePartitioning", _wrap_Mesh_GeneratePartitioning, METH_VARARGS, "Mesh_GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int"}, - { "Mesh_CheckPartitioning", _wrap_Mesh_CheckPartitioning, METH_VARARGS, "Mesh_CheckPartitioning(Mesh self, int * partitioning)"}, - { "Mesh_CheckDisplacements", _wrap_Mesh_CheckDisplacements, METH_VARARGS, "Mesh_CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, - { "Mesh_MoveVertices", _wrap_Mesh_MoveVertices, METH_VARARGS, "Mesh_MoveVertices(Mesh self, Vector displacements)"}, - { "Mesh_GetVertices", _wrap_Mesh_GetVertices, METH_VARARGS, "Mesh_GetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_SetVertices", _wrap_Mesh_SetVertices, METH_VARARGS, "Mesh_SetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_GetNode", _wrap_Mesh_GetNode, METH_VARARGS, "Mesh_GetNode(Mesh self, int i, double * coord)"}, - { "Mesh_SetNode", _wrap_Mesh_SetNode, METH_VARARGS, "Mesh_SetNode(Mesh self, int i, double const * coord)"}, - { "Mesh_MoveNodes", _wrap_Mesh_MoveNodes, METH_VARARGS, "Mesh_MoveNodes(Mesh self, Vector displacements)"}, - { "Mesh_SetNodes", _wrap_Mesh_SetNodes, METH_VARARGS, "Mesh_SetNodes(Mesh self, Vector node_coord)"}, + { "Mesh_CartesianPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CartesianPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, + { "Mesh_GeneratePartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_GeneratePartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int *"}, + { "Mesh_CheckPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckPartitioning(Mesh self, int * partitioning)"}, + { "Mesh_CheckDisplacements", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckDisplacements, METH_VARARGS|METH_KEYWORDS, "Mesh_CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, + { "Mesh_MoveVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_MoveVertices(Mesh self, Vector displacements)"}, + { "Mesh_GetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_GetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_SetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_SetVertices, METH_VARARGS|METH_KEYWORDS, "Mesh_SetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_GetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNode, METH_VARARGS|METH_KEYWORDS, "Mesh_GetNode(Mesh self, int i, double * coord)"}, + { "Mesh_SetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNode, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNode(Mesh self, int i, double const * coord)"}, + { "Mesh_MoveNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_MoveNodes(Mesh self, Vector displacements)"}, + { "Mesh_SetNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodes(Mesh self, Vector node_coord)"}, { "Mesh_OwnsNodes", _wrap_Mesh_OwnsNodes, METH_O, "Mesh_OwnsNodes(Mesh self) -> bool"}, - { "Mesh_SetNodesOwner", _wrap_Mesh_SetNodesOwner, METH_VARARGS, "Mesh_SetNodesOwner(Mesh self, bool nodes_owner)"}, - { "Mesh_NewNodes", _wrap_Mesh_NewNodes, METH_VARARGS, "Mesh_NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, - { "Mesh_SwapNodes", _wrap_Mesh_SwapNodes, METH_VARARGS, "Mesh_SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, + { "Mesh_SetNodesOwner", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodesOwner, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodesOwner(Mesh self, bool nodes_owner)"}, + { "Mesh_NewNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_NewNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SwapNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SwapNodes, METH_VARARGS|METH_KEYWORDS, "Mesh_SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, { "Mesh_GetNodes", _wrap_Mesh_GetNodes, METH_VARARGS, "\n" "Mesh_GetNodes(Mesh self, Vector node_coord)\n" "Mesh_GetNodes(Mesh self) -> GridFunction\n" "Mesh_GetNodes(Mesh self) -> GridFunction\n" "Mesh_GetNodes(Mesh self, GridFunction nodes)\n" ""}, - { "Mesh_SetNodalFESpace", _wrap_Mesh_SetNodalFESpace, METH_VARARGS, "Mesh_SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, - { "Mesh_SetNodalGridFunction", _wrap_Mesh_SetNodalGridFunction, METH_VARARGS, "Mesh_SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SetNodalFESpace", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalFESpace, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, + { "Mesh_SetNodalGridFunction", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalGridFunction, METH_VARARGS|METH_KEYWORDS, "Mesh_SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, { "Mesh_GetNodalFESpace", _wrap_Mesh_GetNodalFESpace, METH_O, "Mesh_GetNodalFESpace(Mesh self) -> FiniteElementSpace"}, { "Mesh_EnsureNodes", _wrap_Mesh_EnsureNodes, METH_O, "Mesh_EnsureNodes(Mesh self)"}, - { "Mesh_SetCurvature", _wrap_Mesh_SetCurvature, METH_VARARGS, "Mesh_SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, - { "Mesh_UniformRefinement", _wrap_Mesh_UniformRefinement, METH_VARARGS, "Mesh_UniformRefinement(Mesh self, int ref_algo=0)"}, + { "Mesh_SetCurvature", (PyCFunction)(void(*)(void))_wrap_Mesh_SetCurvature, METH_VARARGS|METH_KEYWORDS, "Mesh_SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "Mesh_UniformRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_UniformRefinement, METH_VARARGS|METH_KEYWORDS, "Mesh_UniformRefinement(Mesh self, int ref_algo=0)"}, { "Mesh_GeneralRefinement", _wrap_Mesh_GeneralRefinement, METH_VARARGS, "\n" "Mesh_GeneralRefinement(Mesh self, mfem::Array< mfem::Refinement > const & refinements, int nonconforming=-1, int nc_limit=0)\n" "Mesh_GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0)\n" ""}, - { "Mesh_RandomRefinement", _wrap_Mesh_RandomRefinement, METH_VARARGS, "Mesh_RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, - { "Mesh_RefineAtVertex", _wrap_Mesh_RefineAtVertex, METH_VARARGS, "Mesh_RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, + { "Mesh_RandomRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_RandomRefinement, METH_VARARGS|METH_KEYWORDS, "Mesh_RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, + { "Mesh_RefineAtVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_RefineAtVertex, METH_VARARGS|METH_KEYWORDS, "Mesh_RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, { "Mesh_RefineByError", _wrap_Mesh_RefineByError, METH_VARARGS, "\n" "Mesh_RefineByError(Mesh self, doubleArray elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" "Mesh_RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" @@ -31048,8 +20532,8 @@ static PyMethodDef SwigMethods[] = { "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" "Mesh_KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" ""}, - { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "Mesh_DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, - { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "Mesh_EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, + { "Mesh_DegreeElevate", (PyCFunction)(void(*)(void))_wrap_Mesh_DegreeElevate, METH_VARARGS|METH_KEYWORDS, "Mesh_DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, + { "Mesh_EnsureNCMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_EnsureNCMesh, METH_VARARGS|METH_KEYWORDS, "Mesh_EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Mesh_Conforming(Mesh self) -> bool"}, { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Mesh_Nonconforming(Mesh self) -> bool"}, { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "Mesh_GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, @@ -31059,12 +20543,12 @@ static PyMethodDef SwigMethods[] = { "Mesh_PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" "Mesh_PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" ""}, - { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "Mesh_GetElementColoring(Mesh self, intArray colors, int el0=0)"}, - { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "Mesh_PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, - { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "Mesh_PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, - { "Mesh_PrintSurfaces", _wrap_Mesh_PrintSurfaces, METH_VARARGS, "Mesh_PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, - { "Mesh_ScaleSubdomains", _wrap_Mesh_ScaleSubdomains, METH_VARARGS, "Mesh_ScaleSubdomains(Mesh self, double sf)"}, - { "Mesh_ScaleElements", _wrap_Mesh_ScaleElements, METH_VARARGS, "Mesh_ScaleElements(Mesh self, double sf)"}, + { "Mesh_GetElementColoring", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementColoring, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementColoring(Mesh self, intArray colors, int el0=0)"}, + { "Mesh_PrintWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintWithPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, + { "Mesh_PrintElementsWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, + { "Mesh_PrintSurfaces", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintSurfaces, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, + { "Mesh_ScaleSubdomains", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleSubdomains, METH_VARARGS|METH_KEYWORDS, "Mesh_ScaleSubdomains(Mesh self, double sf)"}, + { "Mesh_ScaleElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleElements, METH_VARARGS|METH_KEYWORDS, "Mesh_ScaleElements(Mesh self, double sf)"}, { "Mesh_Transform", _wrap_Mesh_Transform, METH_VARARGS, "\n" "Mesh_Transform(Mesh self, void (*)(mfem::Vector const &,mfem::Vector &) f)\n" "Mesh_Transform(Mesh self, VectorCoefficient deformation)\n" @@ -31075,12 +20559,12 @@ static PyMethodDef SwigMethods[] = { "Mesh_GetElementSize(Mesh self, int i, int type=0) -> double\n" "Mesh_GetElementSize(Mesh self, int i, Vector dir) -> double\n" ""}, - { "Mesh_GetElementVolume", _wrap_Mesh_GetElementVolume, METH_VARARGS, "Mesh_GetElementVolume(Mesh self, int i) -> double"}, - { "Mesh_GetBoundingBox", _wrap_Mesh_GetBoundingBox, METH_VARARGS, "Mesh_GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, - { "Mesh_GetCharacteristics", _wrap_Mesh_GetCharacteristics, METH_VARARGS, "Mesh_GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, - { "Mesh_PrintElementsByGeometry", _wrap_Mesh_PrintElementsByGeometry, METH_VARARGS, "Mesh_PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, - { "Mesh_PrintCharacteristics", _wrap_Mesh_PrintCharacteristics, METH_VARARGS, "Mesh_PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, - { "Mesh_FindPoints", _wrap_Mesh_FindPoints, METH_VARARGS, "Mesh_FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "Mesh_GetElementVolume", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVolume, METH_VARARGS|METH_KEYWORDS, "Mesh_GetElementVolume(Mesh self, int i) -> double"}, + { "Mesh_GetBoundingBox", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBoundingBox, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, + { "Mesh_GetCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_GetCharacteristics, METH_VARARGS|METH_KEYWORDS, "Mesh_GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, + { "Mesh_PrintElementsByGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsByGeometry, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, + { "Mesh_PrintCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintCharacteristics, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, + { "Mesh_FindPoints", (PyCFunction)(void(*)(void))_wrap_Mesh_FindPoints, METH_VARARGS|METH_KEYWORDS, "Mesh_FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, { "delete_Mesh", _wrap_delete_Mesh, METH_O, "delete_Mesh(Mesh self)"}, { "new_Mesh", _wrap_new_Mesh, METH_VARARGS, "\n" "Mesh()\n" @@ -31095,18 +20579,18 @@ static PyMethodDef SwigMethods[] = { "Mesh(mfem::Mesh *[] mesh_array, int num_pieces)\n" "Mesh(Mesh orig_mesh, int ref_factor, int ref_type)\n" "Mesh(int nx, int ny, int nz, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0, double sz=1.0)\n" - "Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0)\n" + "new_Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0) -> Mesh\n" ""}, - { "Mesh_PrintToFile", _wrap_Mesh_PrintToFile, METH_VARARGS, "Mesh_PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, + { "Mesh_PrintToFile", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintToFile, METH_VARARGS|METH_KEYWORDS, "Mesh_PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, { "Mesh_GetAttributeArray", _wrap_Mesh_GetAttributeArray, METH_O, "Mesh_GetAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetVertexArray", _wrap_Mesh_GetVertexArray, METH_VARARGS, "Mesh_GetVertexArray(Mesh self, int i) -> PyObject *"}, + { "Mesh_GetVertexArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertexArray, METH_VARARGS|METH_KEYWORDS, "Mesh_GetVertexArray(Mesh self, int i) -> PyObject *"}, { "Mesh_GetBdrElementFace", _wrap_Mesh_GetBdrElementFace, METH_VARARGS, "\n" "Mesh_GetBdrElementFace(Mesh self, int i, int * arg3, int * arg4)\n" "Mesh_GetBdrElementFace(Mesh self, int i) -> PyObject *\n" ""}, { "Mesh_GetBdrAttributeArray", _wrap_Mesh_GetBdrAttributeArray, METH_O, "Mesh_GetBdrAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetBdrArray", _wrap_Mesh_GetBdrArray, METH_VARARGS, "Mesh_GetBdrArray(Mesh self, int idx) -> PyObject *"}, - { "Mesh_GetDomainArray", _wrap_Mesh_GetDomainArray, METH_VARARGS, "Mesh_GetDomainArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetBdrArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrArray, METH_VARARGS|METH_KEYWORDS, "Mesh_GetBdrArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetDomainArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetDomainArray, METH_VARARGS|METH_KEYWORDS, "Mesh_GetDomainArray(Mesh self, int idx) -> PyObject *"}, { "Mesh_PrintInfo", _wrap_Mesh_PrintInfo, METH_VARARGS, "\n" "Mesh_PrintInfo(Mesh self, std::ostream & out=mfem::out)\n" "Mesh_PrintInfo(Mesh self, char const * file, int precision=8)\n" @@ -31137,7 +20621,7 @@ static PyMethodDef SwigMethods[] = { { "GeometricFactors_IntRule_get", _wrap_GeometricFactors_IntRule_get, METH_O, "GeometricFactors_IntRule_get(GeometricFactors self) -> IntegrationRule"}, { "GeometricFactors_computed_factors_set", _wrap_GeometricFactors_computed_factors_set, METH_VARARGS, "GeometricFactors_computed_factors_set(GeometricFactors self, int computed_factors)"}, { "GeometricFactors_computed_factors_get", _wrap_GeometricFactors_computed_factors_get, METH_O, "GeometricFactors_computed_factors_get(GeometricFactors self) -> int"}, - { "new_GeometricFactors", _wrap_new_GeometricFactors, METH_VARARGS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, + { "new_GeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_GeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, { "GeometricFactors_X_set", _wrap_GeometricFactors_X_set, METH_VARARGS, "GeometricFactors_X_set(GeometricFactors self, Vector X)"}, { "GeometricFactors_X_get", _wrap_GeometricFactors_X_get, METH_O, "GeometricFactors_X_get(GeometricFactors self) -> Vector"}, { "GeometricFactors_J_set", _wrap_GeometricFactors_J_set, METH_VARARGS, "GeometricFactors_J_set(GeometricFactors self, Vector J)"}, @@ -31155,7 +20639,7 @@ static PyMethodDef SwigMethods[] = { { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, - { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "new_FaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_FaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, @@ -31167,7 +20651,7 @@ static PyMethodDef SwigMethods[] = { { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, - { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "NodeExtrudeCoefficient_SetLayer(NodeExtrudeCoefficient self, int const l)"}, + { "NodeExtrudeCoefficient_SetLayer", (PyCFunction)(void(*)(void))_wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS|METH_KEYWORDS, "NodeExtrudeCoefficient_SetLayer(NodeExtrudeCoefficient self, int const l)"}, { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" "NodeExtrudeCoefficient_Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "NodeExtrudeCoefficient_Eval(NodeExtrudeCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -31175,9 +20659,9 @@ static PyMethodDef SwigMethods[] = { ""}, { "delete_NodeExtrudeCoefficient", _wrap_delete_NodeExtrudeCoefficient, METH_O, "delete_NodeExtrudeCoefficient(NodeExtrudeCoefficient self)"}, { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, - { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, - { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, - { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, + { "Extrude1D", (PyCFunction)(void(*)(void))_wrap_Extrude1D, METH_VARARGS|METH_KEYWORDS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, + { "Extrude2D", (PyCFunction)(void(*)(void))_wrap_Extrude2D, METH_VARARGS|METH_KEYWORDS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, + { "ShiftRight", (PyCFunction)(void(*)(void))_wrap_ShiftRight, METH_VARARGS|METH_KEYWORDS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; @@ -31186,18 +20670,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, NULL}, { "delete_intp", _wrap_delete_intp, METH_O, NULL}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, NULL}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_value", _wrap_intp_value, METH_O, NULL}, { "intp_cast", _wrap_intp_cast, METH_O, NULL}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, NULL}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, NULL}, { "delete_doublep", _wrap_delete_doublep, METH_O, NULL}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, NULL}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_value", _wrap_doublep_value, METH_O, NULL}, { "doublep_cast", _wrap_doublep_cast, METH_O, NULL}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, NULL}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, NULL}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "Mesh_attributes_get", _wrap_Mesh_attributes_get, METH_O, "Mesh_attributes_get(Mesh self) -> intArray"}, @@ -31212,36 +20696,36 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Mesh_face_geom_factors_get", _wrap_Mesh_face_geom_factors_get, METH_O, "Mesh_face_geom_factors_get(Mesh self) -> mfem::Array< mfem::FaceGeometricFactors * > *"}, { "Mesh_remove_unused_vertices_get", _wrap_Mesh_remove_unused_vertices_get, METH_VARARGS, NULL}, { "Mesh_remove_unused_vertices_set", _wrap_Mesh_remove_unused_vertices_set, METH_O, NULL}, - { "Mesh_NewElement", _wrap_Mesh_NewElement, METH_VARARGS, "NewElement(Mesh self, int geom) -> Element"}, - { "Mesh_AddVertex", _wrap_Mesh_AddVertex, METH_VARARGS, "AddVertex(Mesh self, double const * arg2)"}, - { "Mesh_AddSegment", _wrap_Mesh_AddSegment, METH_VARARGS, "AddSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTri", _wrap_Mesh_AddTri, METH_VARARGS, "AddTri(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTriangle", _wrap_Mesh_AddTriangle, METH_VARARGS, "AddTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddQuad", _wrap_Mesh_AddQuad, METH_VARARGS, "AddQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddTet", _wrap_Mesh_AddTet, METH_VARARGS, "AddTet(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddWedge", _wrap_Mesh_AddWedge, METH_VARARGS, "AddWedge(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHex", _wrap_Mesh_AddHex, METH_VARARGS, "AddHex(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsTets", _wrap_Mesh_AddHexAsTets, METH_VARARGS, "AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddHexAsWedges", _wrap_Mesh_AddHexAsWedges, METH_VARARGS, "AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddElement", _wrap_Mesh_AddElement, METH_VARARGS, "AddElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrElement", _wrap_Mesh_AddBdrElement, METH_VARARGS, "AddBdrElement(Mesh self, Element elem)"}, - { "Mesh_AddBdrSegment", _wrap_Mesh_AddBdrSegment, METH_VARARGS, "AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrTriangle", _wrap_Mesh_AddBdrTriangle, METH_VARARGS, "AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuad", _wrap_Mesh_AddBdrQuad, METH_VARARGS, "AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, - { "Mesh_AddBdrQuadAsTriangles", _wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS, "AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_NewElement", (PyCFunction)(void(*)(void))_wrap_Mesh_NewElement, METH_VARARGS|METH_KEYWORDS, "NewElement(Mesh self, int geom) -> Element"}, + { "Mesh_AddVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddVertex, METH_VARARGS|METH_KEYWORDS, "AddVertex(Mesh self, double const * arg2)"}, + { "Mesh_AddSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddSegment, METH_VARARGS|METH_KEYWORDS, "AddSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTri", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTri, METH_VARARGS|METH_KEYWORDS, "AddTri(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTriangle, METH_VARARGS|METH_KEYWORDS, "AddTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddQuad, METH_VARARGS|METH_KEYWORDS, "AddQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddTet", (PyCFunction)(void(*)(void))_wrap_Mesh_AddTet, METH_VARARGS|METH_KEYWORDS, "AddTet(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddWedge", (PyCFunction)(void(*)(void))_wrap_Mesh_AddWedge, METH_VARARGS|METH_KEYWORDS, "AddWedge(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHex", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHex, METH_VARARGS|METH_KEYWORDS, "AddHex(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsTets", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsTets, METH_VARARGS|METH_KEYWORDS, "AddHexAsTets(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddHexAsWedges", (PyCFunction)(void(*)(void))_wrap_Mesh_AddHexAsWedges, METH_VARARGS|METH_KEYWORDS, "AddHexAsWedges(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddElement, METH_VARARGS|METH_KEYWORDS, "AddElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrElement", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrElement, METH_VARARGS|METH_KEYWORDS, "AddBdrElement(Mesh self, Element elem)"}, + { "Mesh_AddBdrSegment", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrSegment, METH_VARARGS|METH_KEYWORDS, "AddBdrSegment(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrTriangle", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrTriangle, METH_VARARGS|METH_KEYWORDS, "AddBdrTriangle(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuad", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuad, METH_VARARGS|METH_KEYWORDS, "AddBdrQuad(Mesh self, int const * vi, int attr=1)"}, + { "Mesh_AddBdrQuadAsTriangles", (PyCFunction)(void(*)(void))_wrap_Mesh_AddBdrQuadAsTriangles, METH_VARARGS|METH_KEYWORDS, "AddBdrQuadAsTriangles(Mesh self, int const * vi, int attr=1)"}, { "Mesh_GenerateBoundaryElements", _wrap_Mesh_GenerateBoundaryElements, METH_O, "GenerateBoundaryElements(Mesh self)"}, - { "Mesh_FinalizeTriMesh", _wrap_Mesh_FinalizeTriMesh, METH_VARARGS, "FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeQuadMesh", _wrap_Mesh_FinalizeQuadMesh, METH_VARARGS, "FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTetMesh", _wrap_Mesh_FinalizeTetMesh, METH_VARARGS, "FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeWedgeMesh", _wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS, "FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeHexMesh", _wrap_Mesh_FinalizeHexMesh, METH_VARARGS, "FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeMesh", _wrap_Mesh_FinalizeMesh, METH_VARARGS, "FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, - { "Mesh_FinalizeTopology", _wrap_Mesh_FinalizeTopology, METH_VARARGS, "FinalizeTopology(Mesh self, bool generate_bdr=True)"}, - { "Mesh_Finalize", _wrap_Mesh_Finalize, METH_VARARGS, "Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, + { "Mesh_FinalizeTriMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTriMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeTriMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeQuadMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeQuadMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeQuadMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTetMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTetMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeTetMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeWedgeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeWedgeMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeWedgeMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeHexMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeHexMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeHexMesh(Mesh self, int generate_edges=0, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeMesh, METH_VARARGS|METH_KEYWORDS, "FinalizeMesh(Mesh self, int refine=0, bool fix_orientation=True)"}, + { "Mesh_FinalizeTopology", (PyCFunction)(void(*)(void))_wrap_Mesh_FinalizeTopology, METH_VARARGS|METH_KEYWORDS, "FinalizeTopology(Mesh self, bool generate_bdr=True)"}, + { "Mesh_Finalize", (PyCFunction)(void(*)(void))_wrap_Mesh_Finalize, METH_VARARGS|METH_KEYWORDS, "Finalize(Mesh self, bool refine=False, bool fix_orientation=False)"}, { "Mesh_SetAttributes", _wrap_Mesh_SetAttributes, METH_O, "SetAttributes(Mesh self)"}, - { "Mesh_GetHilbertElementOrdering", _wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS, "GetHilbertElementOrdering(Mesh self, intArray ordering)"}, - { "Mesh_ReorderElements", _wrap_Mesh_ReorderElements, METH_VARARGS, "ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, - { "Mesh_Load", _wrap_Mesh_Load, METH_VARARGS, "Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, + { "Mesh_GetHilbertElementOrdering", (PyCFunction)(void(*)(void))_wrap_Mesh_GetHilbertElementOrdering, METH_VARARGS|METH_KEYWORDS, "GetHilbertElementOrdering(Mesh self, intArray ordering)"}, + { "Mesh_ReorderElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ReorderElements, METH_VARARGS|METH_KEYWORDS, "ReorderElements(Mesh self, intArray ordering, bool reorder_vertices=True)"}, + { "Mesh_Load", (PyCFunction)(void(*)(void))_wrap_Mesh_Load, METH_VARARGS|METH_KEYWORDS, "Load(Mesh self, std::istream & input, int generate_edges=0, int refine=1, bool fix_orientation=True)"}, { "Mesh_Clear", _wrap_Mesh_Clear, METH_O, "Clear(Mesh self)"}, { "Mesh_MeshGenerator", _wrap_Mesh_MeshGenerator, METH_O, "MeshGenerator(Mesh self) -> int"}, { "Mesh_GetNV", _wrap_Mesh_GetNV, METH_O, "GetNV(Mesh self) -> int"}, @@ -31250,11 +20734,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Mesh_GetNEdges", _wrap_Mesh_GetNEdges, METH_O, "GetNEdges(Mesh self) -> int"}, { "Mesh_GetNFaces", _wrap_Mesh_GetNFaces, METH_O, "GetNFaces(Mesh self) -> int"}, { "Mesh_GetNumFaces", _wrap_Mesh_GetNumFaces, METH_O, "GetNumFaces(Mesh self) -> int"}, - { "Mesh_GetNFbyType", _wrap_Mesh_GetNFbyType, METH_VARARGS, "GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, - { "Mesh_ReduceInt", _wrap_Mesh_ReduceInt, METH_VARARGS, "ReduceInt(Mesh self, int value) -> long"}, + { "Mesh_GetNFbyType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNFbyType, METH_VARARGS|METH_KEYWORDS, "GetNFbyType(Mesh self, mfem::FaceType type) -> int"}, + { "Mesh_ReduceInt", (PyCFunction)(void(*)(void))_wrap_Mesh_ReduceInt, METH_VARARGS|METH_KEYWORDS, "ReduceInt(Mesh self, int value) -> long"}, { "Mesh_GetGlobalNE", _wrap_Mesh_GetGlobalNE, METH_O, "GetGlobalNE(Mesh self) -> long"}, - { "Mesh_GetGeometricFactors", _wrap_Mesh_GetGeometricFactors, METH_VARARGS, "GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, - { "Mesh_GetFaceGeometricFactors", _wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS, "GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "Mesh_GetGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometricFactors, METH_VARARGS|METH_KEYWORDS, "GetGeometricFactors(Mesh self, IntegrationRule ir, int const flags) -> GeometricFactors"}, + { "Mesh_GetFaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "GetFaceGeometricFactors(Mesh self, IntegrationRule ir, int const flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "Mesh_DeleteGeometricFactors", _wrap_Mesh_DeleteGeometricFactors, METH_O, "DeleteGeometricFactors(Mesh self)"}, { "Mesh_EulerNumber", _wrap_Mesh_EulerNumber, METH_O, "EulerNumber(Mesh self) -> int"}, { "Mesh_EulerNumber2D", _wrap_Mesh_EulerNumber2D, METH_O, "EulerNumber2D(Mesh self) -> int"}, @@ -31264,9 +20748,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetVertex(Mesh self, int i) -> double const\n" "GetVertex(Mesh self, int i) -> double *\n" ""}, - { "Mesh_GetElementData", _wrap_Mesh_GetElementData, METH_VARARGS, "GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, - { "Mesh_GetBdrElementData", _wrap_Mesh_GetBdrElementData, METH_VARARGS, "GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, - { "Mesh_ChangeVertexDataOwnership", _wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS, "ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, + { "Mesh_GetElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementData, METH_VARARGS|METH_KEYWORDS, "GetElementData(Mesh self, int geom, intArray elem_vtx, intArray attr)"}, + { "Mesh_GetBdrElementData", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementData, METH_VARARGS|METH_KEYWORDS, "GetBdrElementData(Mesh self, int geom, intArray bdr_elem_vtx, intArray bdr_attr)"}, + { "Mesh_ChangeVertexDataOwnership", (PyCFunction)(void(*)(void))_wrap_Mesh_ChangeVertexDataOwnership, METH_VARARGS|METH_KEYWORDS, "ChangeVertexDataOwnership(Mesh self, double * vertices, int len_vertices, bool zerocopy=False)"}, { "Mesh_GetElementsArray", _wrap_Mesh_GetElementsArray, METH_O, "GetElementsArray(Mesh self) -> mfem::Element const *const *"}, { "Mesh_GetElement", _wrap_Mesh_GetElement, METH_VARARGS, "\n" "GetElement(Mesh self, int i) -> Element\n" @@ -31276,30 +20760,30 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetBdrElement(Mesh self, int i) -> Element\n" "GetBdrElement(Mesh self, int i) -> Element\n" ""}, - { "Mesh_GetFace", _wrap_Mesh_GetFace, METH_VARARGS, "GetFace(Mesh self, int i) -> Element"}, - { "Mesh_GetFaceBaseGeometry", _wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS, "GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetElementBaseGeometry", _wrap_Mesh_GetElementBaseGeometry, METH_VARARGS, "GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_GetBdrElementBaseGeometry", _wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS, "GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, - { "Mesh_HasGeometry", _wrap_Mesh_HasGeometry, METH_VARARGS, "HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, - { "Mesh_GetNumGeometries", _wrap_Mesh_GetNumGeometries, METH_VARARGS, "GetNumGeometries(Mesh self, int dim) -> int"}, - { "Mesh_GetGeometries", _wrap_Mesh_GetGeometries, METH_VARARGS, "GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, - { "Mesh_GetElementVertices", _wrap_Mesh_GetElementVertices, METH_VARARGS, "GetElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetBdrElementVertices", _wrap_Mesh_GetBdrElementVertices, METH_VARARGS, "GetBdrElementVertices(Mesh self, int i, intArray v)"}, - { "Mesh_GetElementEdges", _wrap_Mesh_GetElementEdges, METH_VARARGS, "GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetBdrElementEdges", _wrap_Mesh_GetBdrElementEdges, METH_VARARGS, "GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, - { "Mesh_GetFaceEdges", _wrap_Mesh_GetFaceEdges, METH_VARARGS, "GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetFaceVertices", _wrap_Mesh_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Mesh self, int i, intArray vert)"}, - { "Mesh_GetEdgeVertices", _wrap_Mesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetFace", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFace, METH_VARARGS|METH_KEYWORDS, "GetFace(Mesh self, int i) -> Element"}, + { "Mesh_GetFaceBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceBaseGeometry, METH_VARARGS|METH_KEYWORDS, "GetFaceBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "GetElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_GetBdrElementBaseGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementBaseGeometry, METH_VARARGS|METH_KEYWORDS, "GetBdrElementBaseGeometry(Mesh self, int i) -> mfem::Geometry::Type"}, + { "Mesh_HasGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_HasGeometry, METH_VARARGS|METH_KEYWORDS, "HasGeometry(Mesh self, mfem::Geometry::Type geom) -> bool"}, + { "Mesh_GetNumGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNumGeometries, METH_VARARGS|METH_KEYWORDS, "GetNumGeometries(Mesh self, int dim) -> int"}, + { "Mesh_GetGeometries", (PyCFunction)(void(*)(void))_wrap_Mesh_GetGeometries, METH_VARARGS|METH_KEYWORDS, "GetGeometries(Mesh self, int dim, mfem::Array< mfem::Geometry::Type > & el_geoms)"}, + { "Mesh_GetElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVertices, METH_VARARGS|METH_KEYWORDS, "GetElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetBdrElementVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementVertices, METH_VARARGS|METH_KEYWORDS, "GetBdrElementVertices(Mesh self, int i, intArray v)"}, + { "Mesh_GetElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementEdges, METH_VARARGS|METH_KEYWORDS, "GetElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetBdrElementEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdges, METH_VARARGS|METH_KEYWORDS, "GetBdrElementEdges(Mesh self, int i, intArray edges, intArray cor)"}, + { "Mesh_GetFaceEdges", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceEdges, METH_VARARGS|METH_KEYWORDS, "GetFaceEdges(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Mesh self, int i, intArray vert)"}, + { "Mesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Mesh self, int i, intArray vert)"}, { "Mesh_GetFaceEdgeTable", _wrap_Mesh_GetFaceEdgeTable, METH_O, "GetFaceEdgeTable(Mesh self) -> Table"}, { "Mesh_GetEdgeVertexTable", _wrap_Mesh_GetEdgeVertexTable, METH_O, "GetEdgeVertexTable(Mesh self) -> Table"}, - { "Mesh_GetElementFaces", _wrap_Mesh_GetElementFaces, METH_VARARGS, "GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, - { "Mesh_GetBdrElementEdgeIndex", _wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS, "GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, - { "Mesh_GetBdrElementAdjacentElement", _wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS, "GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, - { "Mesh_GetElementType", _wrap_Mesh_GetElementType, METH_VARARGS, "GetElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetBdrElementType", _wrap_Mesh_GetBdrElementType, METH_VARARGS, "GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, - { "Mesh_GetPointMatrix", _wrap_Mesh_GetPointMatrix, METH_VARARGS, "GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetBdrPointMatrix", _wrap_Mesh_GetBdrPointMatrix, METH_VARARGS, "GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, - { "Mesh_GetTransformationFEforElementType", _wrap_Mesh_GetTransformationFEforElementType, METH_O, "GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, + { "Mesh_GetElementFaces", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementFaces, METH_VARARGS|METH_KEYWORDS, "GetElementFaces(Mesh self, int i, intArray arg3, intArray arg4)"}, + { "Mesh_GetBdrElementEdgeIndex", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementEdgeIndex, METH_VARARGS|METH_KEYWORDS, "GetBdrElementEdgeIndex(Mesh self, int i) -> int"}, + { "Mesh_GetBdrElementAdjacentElement", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementAdjacentElement, METH_VARARGS|METH_KEYWORDS, "GetBdrElementAdjacentElement(Mesh self, int bdr_el, int & el, int & info)"}, + { "Mesh_GetElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementType, METH_VARARGS|METH_KEYWORDS, "GetElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetBdrElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrElementType, METH_VARARGS|METH_KEYWORDS, "GetBdrElementType(Mesh self, int i) -> mfem::Element::Type"}, + { "Mesh_GetPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetPointMatrix, METH_VARARGS|METH_KEYWORDS, "GetPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetBdrPointMatrix", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrPointMatrix, METH_VARARGS|METH_KEYWORDS, "GetBdrPointMatrix(Mesh self, int i, DenseMatrix pointmat)"}, + { "Mesh_GetTransformationFEforElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetTransformationFEforElementType, METH_VARARGS|METH_KEYWORDS, "GetTransformationFEforElementType(mfem::Element::Type arg1) -> FiniteElement"}, { "Mesh_GetElementTransformation", _wrap_Mesh_GetElementTransformation, METH_VARARGS, "\n" "GetElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" "GetElementTransformation(Mesh self, int i) -> ElementTransformation\n" @@ -31309,7 +20793,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetBdrElementTransformation(Mesh self, int i) -> ElementTransformation\n" "GetBdrElementTransformation(Mesh self, int i, IsoparametricTransformation ElTr)\n" ""}, - { "Mesh_GetLocalFaceTransformation", _wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS, "GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, + { "Mesh_GetLocalFaceTransformation", (PyCFunction)(void(*)(void))_wrap_Mesh_GetLocalFaceTransformation, METH_VARARGS|METH_KEYWORDS, "GetLocalFaceTransformation(Mesh self, int face_type, int elem_type, IsoparametricTransformation Transf, int info)"}, { "Mesh_GetFaceTransformation", _wrap_Mesh_GetFaceTransformation, METH_VARARGS, "\n" "GetFaceTransformation(Mesh self, int i, IsoparametricTransformation FTr)\n" "GetFaceTransformation(Mesh self, int FaceNo) -> ElementTransformation\n" @@ -31318,58 +20802,58 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetEdgeTransformation(Mesh self, int i, IsoparametricTransformation EdTr)\n" "GetEdgeTransformation(Mesh self, int EdgeNo) -> ElementTransformation\n" ""}, - { "Mesh_GetFaceElementTransformations", _wrap_Mesh_GetFaceElementTransformations, METH_VARARGS, "GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, - { "Mesh_GetInteriorFaceTransformations", _wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS, "GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, - { "Mesh_GetBdrFaceTransformations", _wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS, "GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, - { "Mesh_FaceIsInterior", _wrap_Mesh_FaceIsInterior, METH_VARARGS, "FaceIsInterior(Mesh self, int FaceNo) -> bool"}, - { "Mesh_GetFaceElements", _wrap_Mesh_GetFaceElements, METH_VARARGS, "GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, - { "Mesh_GetFaceInfos", _wrap_Mesh_GetFaceInfos, METH_VARARGS, "GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, - { "Mesh_GetFaceGeometryType", _wrap_Mesh_GetFaceGeometryType, METH_VARARGS, "GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, - { "Mesh_GetFaceElementType", _wrap_Mesh_GetFaceElementType, METH_VARARGS, "GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, - { "Mesh_CheckElementOrientation", _wrap_Mesh_CheckElementOrientation, METH_VARARGS, "CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_CheckBdrElementOrientation", _wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS, "CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, - { "Mesh_GetAttribute", _wrap_Mesh_GetAttribute, METH_VARARGS, "GetAttribute(Mesh self, int i) -> int"}, - { "Mesh_SetAttribute", _wrap_Mesh_SetAttribute, METH_VARARGS, "SetAttribute(Mesh self, int i, int attr)"}, - { "Mesh_GetBdrAttribute", _wrap_Mesh_GetBdrAttribute, METH_VARARGS, "GetBdrAttribute(Mesh self, int i) -> int"}, + { "Mesh_GetFaceElementTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementTransformations, METH_VARARGS|METH_KEYWORDS, "GetFaceElementTransformations(Mesh self, int FaceNo, int mask=31) -> FaceElementTransformations"}, + { "Mesh_GetInteriorFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetInteriorFaceTransformations, METH_VARARGS|METH_KEYWORDS, "GetInteriorFaceTransformations(Mesh self, int FaceNo) -> FaceElementTransformations"}, + { "Mesh_GetBdrFaceTransformations", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrFaceTransformations, METH_VARARGS|METH_KEYWORDS, "GetBdrFaceTransformations(Mesh self, int BdrElemNo) -> FaceElementTransformations"}, + { "Mesh_FaceIsInterior", (PyCFunction)(void(*)(void))_wrap_Mesh_FaceIsInterior, METH_VARARGS|METH_KEYWORDS, "FaceIsInterior(Mesh self, int FaceNo) -> bool"}, + { "Mesh_GetFaceElements", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElements, METH_VARARGS|METH_KEYWORDS, "GetFaceElements(Mesh self, int Face, int * Elem1, int * Elem2)"}, + { "Mesh_GetFaceInfos", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceInfos, METH_VARARGS|METH_KEYWORDS, "GetFaceInfos(Mesh self, int Face, int * Inf1, int * Inf2)"}, + { "Mesh_GetFaceGeometryType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceGeometryType, METH_VARARGS|METH_KEYWORDS, "GetFaceGeometryType(Mesh self, int Face) -> mfem::Geometry::Type"}, + { "Mesh_GetFaceElementType", (PyCFunction)(void(*)(void))_wrap_Mesh_GetFaceElementType, METH_VARARGS|METH_KEYWORDS, "GetFaceElementType(Mesh self, int Face) -> mfem::Element::Type"}, + { "Mesh_CheckElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckElementOrientation, METH_VARARGS|METH_KEYWORDS, "CheckElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_CheckBdrElementOrientation", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckBdrElementOrientation, METH_VARARGS|METH_KEYWORDS, "CheckBdrElementOrientation(Mesh self, bool fix_it=True) -> int"}, + { "Mesh_GetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetAttribute, METH_VARARGS|METH_KEYWORDS, "GetAttribute(Mesh self, int i) -> int"}, + { "Mesh_SetAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_SetAttribute, METH_VARARGS|METH_KEYWORDS, "SetAttribute(Mesh self, int i, int attr)"}, + { "Mesh_GetBdrAttribute", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrAttribute, METH_VARARGS|METH_KEYWORDS, "GetBdrAttribute(Mesh self, int i) -> int"}, { "Mesh_ElementToElementTable", _wrap_Mesh_ElementToElementTable, METH_O, "ElementToElementTable(Mesh self) -> Table"}, { "Mesh_ElementToFaceTable", _wrap_Mesh_ElementToFaceTable, METH_O, "ElementToFaceTable(Mesh self) -> Table"}, { "Mesh_ElementToEdgeTable", _wrap_Mesh_ElementToEdgeTable, METH_O, "ElementToEdgeTable(Mesh self) -> Table"}, { "Mesh_GetVertexToElementTable", _wrap_Mesh_GetVertexToElementTable, METH_O, "GetVertexToElementTable(Mesh self) -> Table"}, { "Mesh_GetFaceToElementTable", _wrap_Mesh_GetFaceToElementTable, METH_O, "GetFaceToElementTable(Mesh self) -> Table"}, { "Mesh_ReorientTetMesh", _wrap_Mesh_ReorientTetMesh, METH_O, "ReorientTetMesh(Mesh self)"}, - { "Mesh_CartesianPartitioning", _wrap_Mesh_CartesianPartitioning, METH_VARARGS, "CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, - { "Mesh_GeneratePartitioning", _wrap_Mesh_GeneratePartitioning, METH_VARARGS, "GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int"}, - { "Mesh_CheckPartitioning", _wrap_Mesh_CheckPartitioning, METH_VARARGS, "CheckPartitioning(Mesh self, int * partitioning)"}, - { "Mesh_CheckDisplacements", _wrap_Mesh_CheckDisplacements, METH_VARARGS, "CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, - { "Mesh_MoveVertices", _wrap_Mesh_MoveVertices, METH_VARARGS, "MoveVertices(Mesh self, Vector displacements)"}, - { "Mesh_GetVertices", _wrap_Mesh_GetVertices, METH_VARARGS, "GetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_SetVertices", _wrap_Mesh_SetVertices, METH_VARARGS, "SetVertices(Mesh self, Vector vert_coord)"}, - { "Mesh_GetNode", _wrap_Mesh_GetNode, METH_VARARGS, "GetNode(Mesh self, int i, double * coord)"}, - { "Mesh_SetNode", _wrap_Mesh_SetNode, METH_VARARGS, "SetNode(Mesh self, int i, double const * coord)"}, - { "Mesh_MoveNodes", _wrap_Mesh_MoveNodes, METH_VARARGS, "MoveNodes(Mesh self, Vector displacements)"}, - { "Mesh_SetNodes", _wrap_Mesh_SetNodes, METH_VARARGS, "SetNodes(Mesh self, Vector node_coord)"}, + { "Mesh_CartesianPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CartesianPartitioning, METH_VARARGS|METH_KEYWORDS, "CartesianPartitioning(Mesh self, int [] nxyz) -> int *"}, + { "Mesh_GeneratePartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_GeneratePartitioning, METH_VARARGS|METH_KEYWORDS, "GeneratePartitioning(Mesh self, int nparts, int part_method=1) -> int *"}, + { "Mesh_CheckPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckPartitioning, METH_VARARGS|METH_KEYWORDS, "CheckPartitioning(Mesh self, int * partitioning)"}, + { "Mesh_CheckDisplacements", (PyCFunction)(void(*)(void))_wrap_Mesh_CheckDisplacements, METH_VARARGS|METH_KEYWORDS, "CheckDisplacements(Mesh self, Vector displacements, double & tmax)"}, + { "Mesh_MoveVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveVertices, METH_VARARGS|METH_KEYWORDS, "MoveVertices(Mesh self, Vector displacements)"}, + { "Mesh_GetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertices, METH_VARARGS|METH_KEYWORDS, "GetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_SetVertices", (PyCFunction)(void(*)(void))_wrap_Mesh_SetVertices, METH_VARARGS|METH_KEYWORDS, "SetVertices(Mesh self, Vector vert_coord)"}, + { "Mesh_GetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_GetNode, METH_VARARGS|METH_KEYWORDS, "GetNode(Mesh self, int i, double * coord)"}, + { "Mesh_SetNode", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNode, METH_VARARGS|METH_KEYWORDS, "SetNode(Mesh self, int i, double const * coord)"}, + { "Mesh_MoveNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_MoveNodes, METH_VARARGS|METH_KEYWORDS, "MoveNodes(Mesh self, Vector displacements)"}, + { "Mesh_SetNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodes, METH_VARARGS|METH_KEYWORDS, "SetNodes(Mesh self, Vector node_coord)"}, { "Mesh_OwnsNodes", _wrap_Mesh_OwnsNodes, METH_O, "OwnsNodes(Mesh self) -> bool"}, - { "Mesh_SetNodesOwner", _wrap_Mesh_SetNodesOwner, METH_VARARGS, "SetNodesOwner(Mesh self, bool nodes_owner)"}, - { "Mesh_NewNodes", _wrap_Mesh_NewNodes, METH_VARARGS, "NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, - { "Mesh_SwapNodes", _wrap_Mesh_SwapNodes, METH_VARARGS, "SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, + { "Mesh_SetNodesOwner", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodesOwner, METH_VARARGS|METH_KEYWORDS, "SetNodesOwner(Mesh self, bool nodes_owner)"}, + { "Mesh_NewNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_NewNodes, METH_VARARGS|METH_KEYWORDS, "NewNodes(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SwapNodes", (PyCFunction)(void(*)(void))_wrap_Mesh_SwapNodes, METH_VARARGS|METH_KEYWORDS, "SwapNodes(Mesh self, mfem::GridFunction *& nodes, int & own_nodes_)"}, { "Mesh_GetNodes", _wrap_Mesh_GetNodes, METH_VARARGS, "\n" "GetNodes(Mesh self, Vector node_coord)\n" "GetNodes(Mesh self) -> GridFunction\n" "GetNodes(Mesh self) -> GridFunction\n" "GetNodes(Mesh self, GridFunction nodes)\n" ""}, - { "Mesh_SetNodalFESpace", _wrap_Mesh_SetNodalFESpace, METH_VARARGS, "SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, - { "Mesh_SetNodalGridFunction", _wrap_Mesh_SetNodalGridFunction, METH_VARARGS, "SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, + { "Mesh_SetNodalFESpace", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalFESpace, METH_VARARGS|METH_KEYWORDS, "SetNodalFESpace(Mesh self, FiniteElementSpace nfes)"}, + { "Mesh_SetNodalGridFunction", (PyCFunction)(void(*)(void))_wrap_Mesh_SetNodalGridFunction, METH_VARARGS|METH_KEYWORDS, "SetNodalGridFunction(Mesh self, GridFunction nodes, bool make_owner=False)"}, { "Mesh_GetNodalFESpace", _wrap_Mesh_GetNodalFESpace, METH_O, "GetNodalFESpace(Mesh self) -> FiniteElementSpace"}, { "Mesh_EnsureNodes", _wrap_Mesh_EnsureNodes, METH_O, "EnsureNodes(Mesh self)"}, - { "Mesh_SetCurvature", _wrap_Mesh_SetCurvature, METH_VARARGS, "SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, - { "Mesh_UniformRefinement", _wrap_Mesh_UniformRefinement, METH_VARARGS, "UniformRefinement(Mesh self, int ref_algo=0)"}, + { "Mesh_SetCurvature", (PyCFunction)(void(*)(void))_wrap_Mesh_SetCurvature, METH_VARARGS|METH_KEYWORDS, "SetCurvature(Mesh self, int order, bool discont=False, int space_dim=-1, int ordering=1)"}, + { "Mesh_UniformRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_UniformRefinement, METH_VARARGS|METH_KEYWORDS, "UniformRefinement(Mesh self, int ref_algo=0)"}, { "Mesh_GeneralRefinement", _wrap_Mesh_GeneralRefinement, METH_VARARGS, "\n" "GeneralRefinement(Mesh self, mfem::Array< mfem::Refinement > const & refinements, int nonconforming=-1, int nc_limit=0)\n" "GeneralRefinement(Mesh self, intArray el_to_refine, int nonconforming=-1, int nc_limit=0)\n" ""}, - { "Mesh_RandomRefinement", _wrap_Mesh_RandomRefinement, METH_VARARGS, "RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, - { "Mesh_RefineAtVertex", _wrap_Mesh_RefineAtVertex, METH_VARARGS, "RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, + { "Mesh_RandomRefinement", (PyCFunction)(void(*)(void))_wrap_Mesh_RandomRefinement, METH_VARARGS|METH_KEYWORDS, "RandomRefinement(Mesh self, double prob, bool aniso=False, int nonconforming=-1, int nc_limit=0)"}, + { "Mesh_RefineAtVertex", (PyCFunction)(void(*)(void))_wrap_Mesh_RefineAtVertex, METH_VARARGS|METH_KEYWORDS, "RefineAtVertex(Mesh self, Vertex vert, double eps=0.0, int nonconforming=-1)"}, { "Mesh_RefineByError", _wrap_Mesh_RefineByError, METH_VARARGS, "\n" "RefineByError(Mesh self, doubleArray elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" "RefineByError(Mesh self, Vector elem_error, double threshold, int nonconforming=-1, int nc_limit=0) -> bool\n" @@ -31382,8 +20866,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "KnotInsert(Mesh self, mfem::Array< mfem::KnotVector * > & kv)\n" "KnotInsert(Mesh self, mfem::Array< mfem::Vector * > & kv)\n" ""}, - { "Mesh_DegreeElevate", _wrap_Mesh_DegreeElevate, METH_VARARGS, "DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, - { "Mesh_EnsureNCMesh", _wrap_Mesh_EnsureNCMesh, METH_VARARGS, "EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, + { "Mesh_DegreeElevate", (PyCFunction)(void(*)(void))_wrap_Mesh_DegreeElevate, METH_VARARGS|METH_KEYWORDS, "DegreeElevate(Mesh self, int rel_degree, int degree=16)"}, + { "Mesh_EnsureNCMesh", (PyCFunction)(void(*)(void))_wrap_Mesh_EnsureNCMesh, METH_VARARGS|METH_KEYWORDS, "EnsureNCMesh(Mesh self, bool simplices_nonconforming=False)"}, { "Mesh_Conforming", _wrap_Mesh_Conforming, METH_O, "Conforming(Mesh self) -> bool"}, { "Mesh_Nonconforming", _wrap_Mesh_Nonconforming, METH_O, "Nonconforming(Mesh self) -> bool"}, { "Mesh_GetRefinementTransforms", _wrap_Mesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(Mesh self) -> CoarseFineTransformations"}, @@ -31393,12 +20877,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { "PrintVTU(Mesh self, std::ostream & out, int ref=1, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" "PrintVTU(Mesh self, std::string fname, mfem::VTKFormat format=ASCII, bool high_order_output=False, int compression_level=0)\n" ""}, - { "Mesh_GetElementColoring", _wrap_Mesh_GetElementColoring, METH_VARARGS, "GetElementColoring(Mesh self, intArray colors, int el0=0)"}, - { "Mesh_PrintWithPartitioning", _wrap_Mesh_PrintWithPartitioning, METH_VARARGS, "PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, - { "Mesh_PrintElementsWithPartitioning", _wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS, "PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, - { "Mesh_PrintSurfaces", _wrap_Mesh_PrintSurfaces, METH_VARARGS, "PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, - { "Mesh_ScaleSubdomains", _wrap_Mesh_ScaleSubdomains, METH_VARARGS, "ScaleSubdomains(Mesh self, double sf)"}, - { "Mesh_ScaleElements", _wrap_Mesh_ScaleElements, METH_VARARGS, "ScaleElements(Mesh self, double sf)"}, + { "Mesh_GetElementColoring", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementColoring, METH_VARARGS|METH_KEYWORDS, "GetElementColoring(Mesh self, intArray colors, int el0=0)"}, + { "Mesh_PrintWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintWithPartitioning, METH_VARARGS|METH_KEYWORDS, "PrintWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int elem_attr=0)"}, + { "Mesh_PrintElementsWithPartitioning", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsWithPartitioning, METH_VARARGS|METH_KEYWORDS, "PrintElementsWithPartitioning(Mesh self, int * partitioning, std::ostream & out, int interior_faces=0)"}, + { "Mesh_PrintSurfaces", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintSurfaces, METH_VARARGS|METH_KEYWORDS, "PrintSurfaces(Mesh self, Table Aface_face, std::ostream & out)"}, + { "Mesh_ScaleSubdomains", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleSubdomains, METH_VARARGS|METH_KEYWORDS, "ScaleSubdomains(Mesh self, double sf)"}, + { "Mesh_ScaleElements", (PyCFunction)(void(*)(void))_wrap_Mesh_ScaleElements, METH_VARARGS|METH_KEYWORDS, "ScaleElements(Mesh self, double sf)"}, { "Mesh_Transform", _wrap_Mesh_Transform, METH_VARARGS, "\n" "Transform(Mesh self, void (*)(mfem::Vector const &,mfem::Vector &) f)\n" "Transform(Mesh self, VectorCoefficient deformation)\n" @@ -31409,12 +20893,12 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetElementSize(Mesh self, int i, int type=0) -> double\n" "GetElementSize(Mesh self, int i, Vector dir) -> double\n" ""}, - { "Mesh_GetElementVolume", _wrap_Mesh_GetElementVolume, METH_VARARGS, "GetElementVolume(Mesh self, int i) -> double"}, - { "Mesh_GetBoundingBox", _wrap_Mesh_GetBoundingBox, METH_VARARGS, "GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, - { "Mesh_GetCharacteristics", _wrap_Mesh_GetCharacteristics, METH_VARARGS, "GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, - { "Mesh_PrintElementsByGeometry", _wrap_Mesh_PrintElementsByGeometry, METH_VARARGS, "PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, - { "Mesh_PrintCharacteristics", _wrap_Mesh_PrintCharacteristics, METH_VARARGS, "PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, - { "Mesh_FindPoints", _wrap_Mesh_FindPoints, METH_VARARGS, "FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, + { "Mesh_GetElementVolume", (PyCFunction)(void(*)(void))_wrap_Mesh_GetElementVolume, METH_VARARGS|METH_KEYWORDS, "GetElementVolume(Mesh self, int i) -> double"}, + { "Mesh_GetBoundingBox", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBoundingBox, METH_VARARGS|METH_KEYWORDS, "GetBoundingBox(Mesh self, Vector min, Vector max, int ref=2)"}, + { "Mesh_GetCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_GetCharacteristics, METH_VARARGS|METH_KEYWORDS, "GetCharacteristics(Mesh self, double & h_min, double & h_max, double & kappa_min, double & kappa_max, Vector Vh=None, Vector Vk=None)"}, + { "Mesh_PrintElementsByGeometry", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintElementsByGeometry, METH_VARARGS|METH_KEYWORDS, "PrintElementsByGeometry(int dim, intArray num_elems_by_geom, std::ostream & out)"}, + { "Mesh_PrintCharacteristics", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintCharacteristics, METH_VARARGS|METH_KEYWORDS, "PrintCharacteristics(Mesh self, Vector Vh=None, Vector Vk=None, std::ostream & out=mfem::out)"}, + { "Mesh_FindPoints", (PyCFunction)(void(*)(void))_wrap_Mesh_FindPoints, METH_VARARGS|METH_KEYWORDS, "FindPoints(Mesh self, DenseMatrix point_mat, intArray elem_ids, IntegrationPointArray ips, bool warn=True, InverseElementTransformation inv_trans=None) -> int"}, { "delete_Mesh", _wrap_delete_Mesh, METH_O, "delete_Mesh(Mesh self)"}, { "new_Mesh", _wrap_new_Mesh, METH_VARARGS, "\n" "Mesh()\n" @@ -31429,18 +20913,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Mesh(mfem::Mesh *[] mesh_array, int num_pieces)\n" "Mesh(Mesh orig_mesh, int ref_factor, int ref_type)\n" "Mesh(int nx, int ny, int nz, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0, double sz=1.0)\n" - "Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0)\n" + "new_Mesh(int nx, int ny, char const * type, int generate_edges=0, double sx=1.0, double sy=1.0) -> Mesh\n" ""}, - { "Mesh_PrintToFile", _wrap_Mesh_PrintToFile, METH_VARARGS, "PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, + { "Mesh_PrintToFile", (PyCFunction)(void(*)(void))_wrap_Mesh_PrintToFile, METH_VARARGS|METH_KEYWORDS, "PrintToFile(Mesh self, char const * mesh_file, int const precision)"}, { "Mesh_GetAttributeArray", _wrap_Mesh_GetAttributeArray, METH_O, "GetAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetVertexArray", _wrap_Mesh_GetVertexArray, METH_VARARGS, "GetVertexArray(Mesh self, int i) -> PyObject *"}, + { "Mesh_GetVertexArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetVertexArray, METH_VARARGS|METH_KEYWORDS, "GetVertexArray(Mesh self, int i) -> PyObject *"}, { "Mesh_GetBdrElementFace", _wrap_Mesh_GetBdrElementFace, METH_VARARGS, "\n" "GetBdrElementFace(Mesh self, int i, int * arg3, int * arg4)\n" "GetBdrElementFace(Mesh self, int i) -> PyObject *\n" ""}, { "Mesh_GetBdrAttributeArray", _wrap_Mesh_GetBdrAttributeArray, METH_O, "GetBdrAttributeArray(Mesh self) -> PyObject *"}, - { "Mesh_GetBdrArray", _wrap_Mesh_GetBdrArray, METH_VARARGS, "GetBdrArray(Mesh self, int idx) -> PyObject *"}, - { "Mesh_GetDomainArray", _wrap_Mesh_GetDomainArray, METH_VARARGS, "GetDomainArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetBdrArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetBdrArray, METH_VARARGS|METH_KEYWORDS, "GetBdrArray(Mesh self, int idx) -> PyObject *"}, + { "Mesh_GetDomainArray", (PyCFunction)(void(*)(void))_wrap_Mesh_GetDomainArray, METH_VARARGS|METH_KEYWORDS, "GetDomainArray(Mesh self, int idx) -> PyObject *"}, { "Mesh_PrintInfo", _wrap_Mesh_PrintInfo, METH_VARARGS, "\n" "PrintInfo(Mesh self, std::ostream & out=mfem::out)\n" "PrintInfo(Mesh self, char const * file, int precision=8)\n" @@ -31471,7 +20955,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "GeometricFactors_IntRule_get", _wrap_GeometricFactors_IntRule_get, METH_O, "GeometricFactors_IntRule_get(GeometricFactors self) -> IntegrationRule"}, { "GeometricFactors_computed_factors_set", _wrap_GeometricFactors_computed_factors_set, METH_VARARGS, "GeometricFactors_computed_factors_set(GeometricFactors self, int computed_factors)"}, { "GeometricFactors_computed_factors_get", _wrap_GeometricFactors_computed_factors_get, METH_O, "GeometricFactors_computed_factors_get(GeometricFactors self) -> int"}, - { "new_GeometricFactors", _wrap_new_GeometricFactors, METH_VARARGS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, + { "new_GeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_GeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_GeometricFactors(Mesh mesh, IntegrationRule ir, int flags) -> GeometricFactors"}, { "GeometricFactors_X_set", _wrap_GeometricFactors_X_set, METH_VARARGS, "GeometricFactors_X_set(GeometricFactors self, Vector X)"}, { "GeometricFactors_X_get", _wrap_GeometricFactors_X_get, METH_O, "GeometricFactors_X_get(GeometricFactors self) -> Vector"}, { "GeometricFactors_J_set", _wrap_GeometricFactors_J_set, METH_VARARGS, "GeometricFactors_J_set(GeometricFactors self, Vector J)"}, @@ -31489,7 +20973,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "FaceGeometricFactors_computed_factors_get", _wrap_FaceGeometricFactors_computed_factors_get, METH_O, "FaceGeometricFactors_computed_factors_get(FaceGeometricFactors self) -> int"}, { "FaceGeometricFactors_type_set", _wrap_FaceGeometricFactors_type_set, METH_VARARGS, "FaceGeometricFactors_type_set(FaceGeometricFactors self, mfem::FaceType type)"}, { "FaceGeometricFactors_type_get", _wrap_FaceGeometricFactors_type_get, METH_O, "FaceGeometricFactors_type_get(FaceGeometricFactors self) -> mfem::FaceType"}, - { "new_FaceGeometricFactors", _wrap_new_FaceGeometricFactors, METH_VARARGS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, + { "new_FaceGeometricFactors", (PyCFunction)(void(*)(void))_wrap_new_FaceGeometricFactors, METH_VARARGS|METH_KEYWORDS, "new_FaceGeometricFactors(Mesh mesh, IntegrationRule ir, int flags, mfem::FaceType type) -> FaceGeometricFactors"}, { "FaceGeometricFactors_X_set", _wrap_FaceGeometricFactors_X_set, METH_VARARGS, "FaceGeometricFactors_X_set(FaceGeometricFactors self, Vector X)"}, { "FaceGeometricFactors_X_get", _wrap_FaceGeometricFactors_X_get, METH_O, "FaceGeometricFactors_X_get(FaceGeometricFactors self) -> Vector"}, { "FaceGeometricFactors_J_set", _wrap_FaceGeometricFactors_J_set, METH_VARARGS, "FaceGeometricFactors_J_set(FaceGeometricFactors self, Vector J)"}, @@ -31501,7 +20985,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_FaceGeometricFactors", _wrap_delete_FaceGeometricFactors, METH_O, "delete_FaceGeometricFactors(FaceGeometricFactors self)"}, { "FaceGeometricFactors_swigregister", FaceGeometricFactors_swigregister, METH_O, NULL}, { "FaceGeometricFactors_swiginit", FaceGeometricFactors_swiginit, METH_VARARGS, NULL}, - { "NodeExtrudeCoefficient_SetLayer", _wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS, "SetLayer(NodeExtrudeCoefficient self, int const l)"}, + { "NodeExtrudeCoefficient_SetLayer", (PyCFunction)(void(*)(void))_wrap_NodeExtrudeCoefficient_SetLayer, METH_VARARGS|METH_KEYWORDS, "SetLayer(NodeExtrudeCoefficient self, int const l)"}, { "NodeExtrudeCoefficient_Eval", _wrap_NodeExtrudeCoefficient_Eval, METH_VARARGS, "\n" "Eval(NodeExtrudeCoefficient self, Vector V, ElementTransformation T, IntegrationPoint ip)\n" "Eval(NodeExtrudeCoefficient self, DenseMatrix M, ElementTransformation T, IntegrationRule ir)\n" @@ -31509,9 +20993,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "delete_NodeExtrudeCoefficient", _wrap_delete_NodeExtrudeCoefficient, METH_O, "delete_NodeExtrudeCoefficient(NodeExtrudeCoefficient self)"}, { "NodeExtrudeCoefficient_swigregister", NodeExtrudeCoefficient_swigregister, METH_O, NULL}, - { "Extrude1D", _wrap_Extrude1D, METH_VARARGS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, - { "Extrude2D", _wrap_Extrude2D, METH_VARARGS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, - { "ShiftRight", _wrap_ShiftRight, METH_VARARGS, "ShiftRight(int & a, int & b, int & c)"}, + { "Extrude1D", (PyCFunction)(void(*)(void))_wrap_Extrude1D, METH_VARARGS|METH_KEYWORDS, "Extrude1D(Mesh mesh, int const ny, double const sy, bool const closed=False) -> Mesh"}, + { "Extrude2D", (PyCFunction)(void(*)(void))_wrap_Extrude2D, METH_VARARGS|METH_KEYWORDS, "Extrude2D(Mesh mesh, int const nz, double const sz) -> Mesh"}, + { "ShiftRight", (PyCFunction)(void(*)(void))_wrap_ShiftRight, METH_VARARGS|METH_KEYWORDS, "ShiftRight(int & a, int & b, int & c)"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/ncmesh_wrap.cxx b/mfem/_ser/ncmesh_wrap.cxx index ac80e880..373a9032 100644 --- a/mfem/_ser/ncmesh_wrap.cxx +++ b/mfem/_ser/ncmesh_wrap.cxx @@ -3647,7 +3647,7 @@ SWIGINTERN void mfem_NCMesh_PrintVertexParents__SWIG_1(mfem::NCMesh *self,char c self -> PrintVertexParents(ofile); ofile.close(); } -SWIGINTERN void mfem_NCMesh_PrintVertexParents__SWIG_3(mfem::NCMesh *self){ +SWIGINTERN void mfem_NCMesh_PrintVertexParents__SWIG_2(mfem::NCMesh *self){ self -> PrintVertexParents(std::cout); } SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_1(mfem::NCMesh *self,char const *file,int precision=8){ @@ -3661,10 +3661,10 @@ SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_1(mfem::NCMesh *self,char self -> PrintCoarseElements(ofile); ofile.close(); } -SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_3(mfem::NCMesh *self){ +SWIGINTERN void mfem_NCMesh_PrintCoarseElements__SWIG_2(mfem::NCMesh *self){ self -> PrintCoarseElements(std::cout); } -SWIGINTERN void mfem_NCMesh_PrintStats__SWIG_2(mfem::NCMesh *self,char const *file,int precision=8){ +SWIGINTERN void mfem_NCMesh_PrintStats__SWIG_1(mfem::NCMesh *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3721,7 +3721,7 @@ SWIGINTERN PyObject *_wrap_delete_intp(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; intp *arg1 = (intp *) 0 ; int arg2 ; @@ -3729,15 +3729,19 @@ SWIGINTERN PyObject *_wrap_intp_assign(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "intp_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intp, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intp_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intp, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_assign" "', argument " "1"" of type '" "intp *""'"); } arg1 = reinterpret_cast< intp * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intp_assign" "', argument " "2"" of type '" "int""'"); } @@ -3796,17 +3800,19 @@ SWIGINTERN PyObject *_wrap_intp_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *a } -SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_intp_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; intp *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_int, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intp_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intp_frompointer" "', argument " "1"" of type '" "int *""'"); } @@ -3865,7 +3871,7 @@ SWIGINTERN PyObject *_wrap_delete_doublep(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; doublep *arg1 = (doublep *) 0 ; double arg2 ; @@ -3873,15 +3879,19 @@ SWIGINTERN PyObject *_wrap_doublep_assign(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"value", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "doublep_assign", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doublep, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doublep_assign", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doublep, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_assign" "', argument " "1"" of type '" "doublep *""'"); } arg1 = reinterpret_cast< doublep * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doublep_assign" "', argument " "2"" of type '" "double""'"); } @@ -3940,17 +3950,19 @@ SWIGINTERN PyObject *_wrap_doublep_cast(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_doublep_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"t", NULL + }; doublep *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doublep_frompointer", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doublep_frompointer" "', argument " "1"" of type '" "double *""'"); } @@ -4111,63 +4123,27 @@ SWIGINTERN PyObject *_wrap_new_Refinement__SWIG_0(PyObject *SWIGUNUSEDPARM(self) SWIGINTERN PyObject *_wrap_new_Refinement__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 7 ; mfem::Refinement *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::Refinement *)new mfem::Refinement(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Refinement, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Refinement__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Refinement *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::Refinement *)new mfem::Refinement(arg1); + result = (mfem::Refinement *)new mfem::Refinement(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4202,7 +4178,7 @@ SWIGINTERN PyObject *_wrap_new_Refinement(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Refinement__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -4213,20 +4189,9 @@ SWIGINTERN PyObject *_wrap_new_Refinement(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Refinement__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_Refinement__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4245,8 +4210,7 @@ SWIGINTERN PyObject *_wrap_new_Refinement(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Refinement'.\n" " Possible C/C++ prototypes are:\n" " mfem::Refinement::Refinement()\n" - " mfem::Refinement::Refinement(int,int)\n" - " mfem::Refinement::Refinement(int)\n"); + " mfem::Refinement::Refinement(int,int)\n"); return 0; } @@ -4438,63 +4402,27 @@ SWIGINTERN PyObject *_wrap_new_Embedding__SWIG_0(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_Embedding__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 0 ; mfem::Embedding *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::Embedding *)new mfem::Embedding(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Embedding, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Embedding__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Embedding *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::Embedding *)new mfem::Embedding(arg1); + result = (mfem::Embedding *)new mfem::Embedding(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4529,7 +4457,7 @@ SWIGINTERN PyObject *_wrap_new_Embedding(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Embedding__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -4540,20 +4468,9 @@ SWIGINTERN PyObject *_wrap_new_Embedding(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Embedding__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_Embedding__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4572,8 +4489,7 @@ SWIGINTERN PyObject *_wrap_new_Embedding(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Embedding'.\n" " Possible C/C++ prototypes are:\n" " mfem::Embedding::Embedding()\n" - " mfem::Embedding::Embedding(int,int)\n" - " mfem::Embedding::Embedding(int)\n"); + " mfem::Embedding::Embedding(int,int)\n"); return 0; } @@ -4711,7 +4627,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_embeddings_get(PyObject *SW } -SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::CoarseFineTransformations *arg1 = (mfem::CoarseFineTransformations *) 0 ; mfem::Mesh *arg2 = 0 ; @@ -4731,15 +4647,23 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fine_mesh", (char *)"coarse_to_fine", (char *)"coarse_to_ref_type", (char *)"ref_type_to_matrix", (char *)"ref_type_to_geom", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CoarseFineTransformations_GetCoarseToFineMap", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:CoarseFineTransformations_GetCoarseToFineMap", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CoarseFineTransformations, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "1"" of type '" "mfem::CoarseFineTransformations const *""'"); } arg1 = reinterpret_cast< mfem::CoarseFineTransformations * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } @@ -4747,7 +4671,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Table, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "3"" of type '" "mfem::Table &""'"); } @@ -4755,7 +4679,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "3"" of type '" "mfem::Table &""'"); } arg3 = reinterpret_cast< mfem::Table * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -4763,7 +4687,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } arg4 = reinterpret_cast< mfem::Array< int > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Table, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "5"" of type '" "mfem::Table &""'"); } @@ -4771,7 +4695,7 @@ SWIGINTERN PyObject *_wrap_CoarseFineTransformations_GetCoarseToFineMap(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "5"" of type '" "mfem::Table &""'"); } arg5 = reinterpret_cast< mfem::Table * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Geometry__Type_t, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "CoarseFineTransformations_GetCoarseToFineMap" "', argument " "6"" of type '" "mfem::Array< mfem::Geometry::Type > &""'"); } @@ -5012,24 +4936,26 @@ SWIGINTERN PyObject *CoarseFineTransformations_swiginit(PyObject *SWIGUNUSEDPARM SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - std::istream *arg2 = (std::istream *) 0 ; + std::istream *arg2 = (std::istream *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; mfem::NCMesh *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NCMesh" "', argument " "1"" of type '" "mfem::Mesh const *""'"); } arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__istream, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NCMesh" "', argument " "2"" of type '" "std::istream *""'"); + if (swig_obj[1]) { + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_std__istream, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NCMesh" "', argument " "2"" of type '" "std::istream *""'"); + } + arg2 = reinterpret_cast< std::istream * >(argp2); } - arg2 = reinterpret_cast< std::istream * >(argp2); { try { result = (mfem::NCMesh *)new mfem::NCMesh((mfem::Mesh const *)arg1,arg2); @@ -5057,45 +4983,6 @@ SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Mesh *arg1 = (mfem::Mesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::NCMesh *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NCMesh" "', argument " "1"" of type '" "mfem::Mesh const *""'"); - } - arg1 = reinterpret_cast< mfem::Mesh * >(argp1); - { - try { - result = (mfem::NCMesh *)new mfem::NCMesh((mfem::Mesh const *)arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NCMesh, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NCMesh__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = 0 ; void *argp1 = 0 ; @@ -5145,13 +5032,21 @@ SWIGINTERN PyObject *_wrap_new_NCMesh(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_NCMesh", 0, 2, argv))) SWIG_fail; --argc; - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_NCMesh__SWIG_1(self, argc, argv); + if (argc <= 1) { + return _wrap_new_NCMesh__SWIG_0(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_new_NCMesh__SWIG_0(self, argc, argv); + } } } if (argc == 1) { @@ -5159,21 +5054,7 @@ SWIGINTERN PyObject *_wrap_new_NCMesh(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__NCMesh, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_NCMesh__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Mesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__istream, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_NCMesh__SWIG_0(self, argc, argv); - } + return _wrap_new_NCMesh__SWIG_1(self, argc, argv); } } @@ -5181,7 +5062,6 @@ SWIGINTERN PyObject *_wrap_new_NCMesh(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NCMesh'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::NCMesh(mfem::Mesh const *,std::istream *)\n" - " mfem::NCMesh::NCMesh(mfem::Mesh const *)\n" " mfem::NCMesh::NCMesh(mfem::NCMesh const &)\n"); return 0; } @@ -5432,7 +5312,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetNFaces(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< mfem::Refinement > *arg2 = 0 ; @@ -5440,15 +5320,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"refinements", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_Refine", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_Refine", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_Refine" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Refinement_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_Refine" "', argument " "2"" of type '" "mfem::Array< mfem::Refinement > const &""'"); } @@ -5482,25 +5366,29 @@ SWIGINTERN PyObject *_wrap_NCMesh_Refine(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_NCMesh_LimitNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_LimitNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_nc_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_LimitNCLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_LimitNCLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_LimitNCLevel" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5569,7 +5457,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetDerefinementTable(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Table *arg2 = 0 ; @@ -5581,15 +5469,21 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"deref_table", (char *)"level_ok", (char *)"max_nc_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_CheckDerefinementNCLevel", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_CheckDerefinementNCLevel", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "2"" of type '" "mfem::Table const &""'"); } @@ -5597,7 +5491,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "2"" of type '" "mfem::Table const &""'"); } arg2 = reinterpret_cast< mfem::Table * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_CheckDerefinementNCLevel" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -5606,10 +5500,10 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -5637,7 +5531,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_CheckDerefinementNCLevel(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -5645,15 +5539,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_Derefine(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"derefs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_Derefine", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_Derefine", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_Derefine" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_Derefine" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -5810,26 +5708,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetVertexList(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NCMesh_GetNCList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetNCList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"entity", NULL + }; mfem::NCMesh::NCList *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetNCList", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetNCList", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetNCList" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6019,29 +5921,34 @@ SWIGINTERN PyObject *_wrap_NCMesh_ClearTransforms(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; mfem::Array< int > *arg3 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"width", (char *)"height", (char *)"coords", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GridSfcOrdering2D", 3, 3, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NCMesh_GridSfcOrdering2D", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GridSfcOrdering2D" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6075,7 +5982,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering2D(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -6083,28 +5990,34 @@ SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(sel mfem::Array< int > *arg4 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"width", (char *)"height", (char *)"depth", (char *)"coords", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GridSfcOrdering3D", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_GridSfcOrdering3D", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GridSfcOrdering3D" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -6138,12 +6051,12 @@ SWIGINTERN PyObject *_wrap_NCMesh_GridSfcOrdering3D(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; int *arg3 ; - bool arg4 ; + bool arg4 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -6152,14 +6065,21 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPA int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"edge_id", (char *)"vert_index", (char *)"oriented", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:NCMesh_GetEdgeVertices", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -6167,16 +6087,18 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetEdgeVertices" "', argument " "3"" of type '" "int [2]""'"); } arg3 = reinterpret_cast< int * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NCMesh_GetEdgeVertices" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NCMesh_GetEdgeVertices" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { ((mfem::NCMesh const *)arg1)->GetEdgeVertices((mfem::NCMesh::MeshId const &)*arg2,arg3,arg4); @@ -6203,40 +6125,38 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeNCOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; - int *arg3 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"edge_id", NULL + }; + int result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetEdgeNCOrientation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeVertices" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeVertices" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetEdgeVertices" "', argument " "3"" of type '" "int [2]""'"); - } - arg3 = reinterpret_cast< int * >(argp3); { try { - ((mfem::NCMesh const *)arg1)->GetEdgeVertices((mfem::NCMesh::MeshId const &)*arg2,arg3); + result = (int)((mfem::NCMesh const *)arg1)->GetEdgeNCOrientation((mfem::NCMesh::MeshId const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6253,125 +6173,14 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeVertices(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "NCMesh_GetEdgeVertices", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__NCMesh__MeshId, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NCMesh_GetEdgeVertices__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__NCMesh__MeshId, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_NCMesh_GetEdgeVertices__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_GetEdgeVertices'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NCMesh::GetEdgeVertices(mfem::NCMesh::MeshId const &,int [2],bool) const\n" - " mfem::NCMesh::GetEdgeVertices(mfem::NCMesh::MeshId const &,int [2]) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeNCOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - mfem::NCMesh::MeshId *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - int result; - - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetEdgeNCOrientation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetEdgeNCOrientation" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); - } - arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - { - try { - result = (int)((mfem::NCMesh const *)arg1)->GetEdgeNCOrientation((mfem::NCMesh::MeshId const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::NCMesh::MeshId *arg2 = 0 ; @@ -6388,16 +6197,23 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"face_id", (char *)"vert_index", (char *)"edge_index", (char *)"edge_orientation", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceVerticesEdges", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NCMesh_GetFaceVerticesEdges", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__NCMesh__MeshId, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } @@ -6405,17 +6221,17 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "2"" of type '" "mfem::NCMesh::MeshId const &""'"); } arg2 = reinterpret_cast< mfem::NCMesh::MeshId * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "3"" of type '" "int [4]""'"); } arg3 = reinterpret_cast< int * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_int, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "4"" of type '" "int [4]""'"); } arg4 = reinterpret_cast< int * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NCMesh_GetFaceVerticesEdges" "', argument " "5"" of type '" "int [4]""'"); } @@ -6446,33 +6262,38 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetFaceVerticesEdges(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeMaster(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v1", (char *)"v2", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetEdgeMaster", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NCMesh_GetEdgeMaster", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetEdgeMaster" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -6500,7 +6321,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetEdgeMaster(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -6514,15 +6335,21 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"bdr_vertices", (char *)"bdr_edges", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetBoundaryClosure", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_GetBoundaryClosure", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -6530,7 +6357,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetBoundaryClosure" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6538,7 +6365,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetBoundaryClosure" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetBoundaryClosure" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -6572,26 +6399,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetBoundaryClosure(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"index", NULL + }; mfem::Geometry::Type result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetElementGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6619,26 +6450,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementGeometry(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_GetFaceGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetFaceGeometry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"index", NULL + }; mfem::Geometry::Type result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetFaceGeometry", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetFaceGeometry", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetFaceGeometry" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6707,26 +6542,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetNumRootElements(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementDepth", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetElementDepth", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementDepth" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6754,26 +6593,30 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementDepth(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementSizeReduction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_GetElementSizeReduction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementSizeReduction" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -6801,7 +6644,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementSizeReduction(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; int arg2 ; @@ -6813,21 +6656,27 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSED int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"faces", (char *)"fattr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_GetElementFacesAttributes", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NCMesh_GetElementFacesAttributes", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -6835,7 +6684,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_GetElementFacesAttributes(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NCMesh_GetElementFacesAttributes" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -7001,7 +6850,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_0(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; std::istream *arg2 = 0 ; @@ -7009,15 +6858,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"input", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_LoadVertexParents", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_LoadVertexParents", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_LoadVertexParents" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_LoadVertexParents" "', argument " "2"" of type '" "std::istream &""'"); } @@ -7051,7 +6904,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadVertexParents(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; std::istream *arg2 = 0 ; @@ -7059,15 +6912,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"input", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_LoadCoarseElements", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_LoadCoarseElements", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_LoadCoarseElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_LoadCoarseElements" "', argument " "2"" of type '" "std::istream &""'"); } @@ -7101,7 +6958,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_LoadCoarseElements(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_SetVertexPositions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NCMesh_SetVertexPositions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; mfem::Array< mfem::Vertex > *arg2 = 0 ; @@ -7109,15 +6966,19 @@ SWIGINTERN PyObject *_wrap_NCMesh_SetVertexPositions(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"vertices", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NCMesh_SetVertexPositions", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NCMesh_SetVertexPositions", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_SetVertexPositions" "', argument " "1"" of type '" "mfem::NCMesh *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__Vertex_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_SetVertexPositions" "', argument " "2"" of type '" "mfem::Array< mfem::Vertex > const &""'"); } @@ -7276,31 +7137,34 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintMemoryDetail(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); } arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -7339,56 +7203,18 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh const *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - { - try { - ((mfem::NCMesh const *)arg1)->PrintStats(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintVertexParents" "', argument " "1"" of type '" "mfem::NCMesh *""'"); @@ -7399,11 +7225,13 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintVertexParents" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -7434,55 +7262,6 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_1(PyObject *SWIGUNUSE SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintVertexParents" "', argument " "1"" of type '" "mfem::NCMesh *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintVertexParents" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_NCMesh_PrintVertexParents__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; void *argp1 = 0 ; @@ -7496,7 +7275,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents__SWIG_3(PyObject *SWIGUNUSE arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { try { - mfem_NCMesh_PrintVertexParents__SWIG_3(arg1); + mfem_NCMesh_PrintVertexParents__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7534,10 +7313,10 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents(PyObject *self, PyObject *a int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintVertexParents__SWIG_3(self, argc, argv); + return _wrap_NCMesh_PrintVertexParents__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); @@ -7546,7 +7325,20 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents(PyObject *self, PyObject *a int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintVertexParents__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_NCMesh_PrintVertexParents__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_NCMesh_PrintVertexParents__SWIG_1(self, argc, argv); + } } } } @@ -7570,36 +7362,12 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintVertexParents(PyObject *self, PyObject *a } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_NCMesh_PrintVertexParents__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_PrintVertexParents'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::PrintVertexParents(std::ostream &) const\n" " mfem::NCMesh::PrintVertexParents(char const *,int)\n" - " mfem::NCMesh::PrintVertexParents(char const *)\n" " mfem::NCMesh::PrintVertexParents()\n"); return 0; } @@ -7609,14 +7377,14 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_1(PyObject *SWIGUNUS PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintCoarseElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); @@ -7627,11 +7395,13 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_1(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintCoarseElements" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -7662,55 +7432,6 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_1(PyObject *SWIGUNUS SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintCoarseElements" "', argument " "1"" of type '" "mfem::NCMesh *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintCoarseElements" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_NCMesh_PrintCoarseElements__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; void *argp1 = 0 ; @@ -7724,7 +7445,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements__SWIG_3(PyObject *SWIGUNUS arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); { try { - mfem_NCMesh_PrintCoarseElements__SWIG_3(arg1); + mfem_NCMesh_PrintCoarseElements__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7762,10 +7483,10 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintCoarseElements__SWIG_3(self, argc, argv); + return _wrap_NCMesh_PrintCoarseElements__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); @@ -7774,7 +7495,20 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements(PyObject *self, PyObject * int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_NCMesh_PrintCoarseElements__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_NCMesh_PrintCoarseElements__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_NCMesh_PrintCoarseElements__SWIG_1(self, argc, argv); + } } } } @@ -7798,53 +7532,29 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintCoarseElements(PyObject *self, PyObject * } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_NCMesh_PrintCoarseElements__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_PrintCoarseElements'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::PrintCoarseElements(std::ostream &) const\n" " mfem::NCMesh::PrintCoarseElements(char const *,int)\n" - " mfem::NCMesh::PrintCoarseElements(char const *)\n" " mfem::NCMesh::PrintCoarseElements()\n"); return 0; } -SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh *""'"); @@ -7855,64 +7565,17 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_2(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintStats" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_NCMesh_PrintStats__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NCMesh_PrintStats__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NCMesh *arg1 = (mfem::NCMesh *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NCMesh, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NCMesh_PrintStats" "', argument " "1"" of type '" "mfem::NCMesh *""'"); - } - arg1 = reinterpret_cast< mfem::NCMesh * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NCMesh_PrintStats" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_NCMesh_PrintStats__SWIG_2(arg1,(char const *)arg2); + mfem_NCMesh_PrintStats__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7946,34 +7609,15 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "NCMesh_PrintStats", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NCMesh_PrintStats__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NCMesh_PrintStats__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_NCMesh_PrintStats__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -7988,7 +7632,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NCMesh, 0); @@ -7997,6 +7641,9 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_NCMesh_PrintStats__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8006,7 +7653,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_NCMesh_PrintStats__SWIG_2(self, argc, argv); + return _wrap_NCMesh_PrintStats__SWIG_1(self, argc, argv); } } } @@ -8016,9 +7663,7 @@ SWIGINTERN PyObject *_wrap_NCMesh_PrintStats(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NCMesh_PrintStats'.\n" " Possible C/C++ prototypes are:\n" " mfem::NCMesh::PrintStats(std::ostream &) const\n" - " mfem::NCMesh::PrintStats() const\n" - " mfem::NCMesh::PrintStats(char const *,int)\n" - " mfem::NCMesh::PrintStats(char const *)\n"); + " mfem::NCMesh::PrintStats(char const *,int)\n"); return 0; } @@ -8039,18 +7684,18 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, "intp_assign(intp self, int value)"}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, "intp_assign(intp self, int value)"}, { "intp_value", _wrap_intp_value, METH_O, "intp_value(intp self) -> int"}, { "intp_cast", _wrap_intp_cast, METH_O, "intp_cast(intp self) -> int *"}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, "intp_frompointer(int * t) -> intp"}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, "intp_frompointer(int * t) -> intp"}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "doublep_assign(doublep self, double value)"}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, "doublep_assign(doublep self, double value)"}, { "doublep_value", _wrap_doublep_value, METH_O, "doublep_value(doublep self) -> double"}, { "doublep_cast", _wrap_doublep_cast, METH_O, "doublep_cast(doublep self) -> double *"}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "doublep_frompointer(double * t) -> doublep"}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, "doublep_frompointer(double * t) -> doublep"}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "Refinement_index_set", _wrap_Refinement_index_set, METH_VARARGS, "Refinement_index_set(Refinement self, int index)"}, @@ -8059,7 +7704,7 @@ static PyMethodDef SwigMethods[] = { { "Refinement_ref_type_get", _wrap_Refinement_ref_type_get, METH_O, "Refinement_ref_type_get(Refinement self) -> char"}, { "new_Refinement", _wrap_new_Refinement, METH_VARARGS, "\n" "Refinement()\n" - "Refinement(int index, int type=7)\n" + "new_Refinement(int index, int type=7) -> Refinement\n" ""}, { "delete_Refinement", _wrap_delete_Refinement, METH_O, "delete_Refinement(Refinement self)"}, { "Refinement_swigregister", Refinement_swigregister, METH_O, NULL}, @@ -8070,7 +7715,7 @@ static PyMethodDef SwigMethods[] = { { "Embedding_matrix_get", _wrap_Embedding_matrix_get, METH_O, "Embedding_matrix_get(Embedding self) -> int"}, { "new_Embedding", _wrap_new_Embedding, METH_VARARGS, "\n" "Embedding()\n" - "Embedding(int elem, int matrix=0)\n" + "new_Embedding(int elem, int matrix=0) -> Embedding\n" ""}, { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, @@ -8078,7 +7723,7 @@ static PyMethodDef SwigMethods[] = { { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, - { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "CoarseFineTransformations_GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, + { "CoarseFineTransformations_GetCoarseToFineMap", (PyCFunction)(void(*)(void))_wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS|METH_KEYWORDS, "CoarseFineTransformations_GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "CoarseFineTransformations_Clear(CoarseFineTransformations self)"}, { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "CoarseFineTransformations_IsInitialized(CoarseFineTransformations self) -> bool"}, { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "CoarseFineTransformations_MemoryUsage(CoarseFineTransformations self) -> long"}, @@ -8096,35 +7741,35 @@ static PyMethodDef SwigMethods[] = { { "NCMesh_GetNVertices", _wrap_NCMesh_GetNVertices, METH_O, "NCMesh_GetNVertices(NCMesh self) -> int"}, { "NCMesh_GetNEdges", _wrap_NCMesh_GetNEdges, METH_O, "NCMesh_GetNEdges(NCMesh self) -> int"}, { "NCMesh_GetNFaces", _wrap_NCMesh_GetNFaces, METH_O, "NCMesh_GetNFaces(NCMesh self) -> int"}, - { "NCMesh_Refine", _wrap_NCMesh_Refine, METH_VARARGS, "NCMesh_Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, - { "NCMesh_LimitNCLevel", _wrap_NCMesh_LimitNCLevel, METH_VARARGS, "NCMesh_LimitNCLevel(NCMesh self, int max_nc_level)"}, + { "NCMesh_Refine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Refine, METH_VARARGS|METH_KEYWORDS, "NCMesh_Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "NCMesh_LimitNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_LimitNCLevel, METH_VARARGS|METH_KEYWORDS, "NCMesh_LimitNCLevel(NCMesh self, int max_nc_level)"}, { "NCMesh_GetDerefinementTable", _wrap_NCMesh_GetDerefinementTable, METH_O, "NCMesh_GetDerefinementTable(NCMesh self) -> Table"}, - { "NCMesh_CheckDerefinementNCLevel", _wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS, "NCMesh_CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, - { "NCMesh_Derefine", _wrap_NCMesh_Derefine, METH_VARARGS, "NCMesh_Derefine(NCMesh self, intArray derefs)"}, + { "NCMesh_CheckDerefinementNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS|METH_KEYWORDS, "NCMesh_CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "NCMesh_Derefine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Derefine, METH_VARARGS|METH_KEYWORDS, "NCMesh_Derefine(NCMesh self, intArray derefs)"}, { "NCMesh_GetFaceList", _wrap_NCMesh_GetFaceList, METH_O, "NCMesh_GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetEdgeList", _wrap_NCMesh_GetEdgeList, METH_O, "NCMesh_GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetVertexList", _wrap_NCMesh_GetVertexList, METH_O, "NCMesh_GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &"}, - { "NCMesh_GetNCList", _wrap_NCMesh_GetNCList, METH_VARARGS, "NCMesh_GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetNCList", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetNCList, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, { "NCMesh_MarkCoarseLevel", _wrap_NCMesh_MarkCoarseLevel, METH_O, "NCMesh_MarkCoarseLevel(NCMesh self)"}, { "NCMesh_GetRefinementTransforms", _wrap_NCMesh_GetRefinementTransforms, METH_O, "NCMesh_GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_GetDerefinementTransforms", _wrap_NCMesh_GetDerefinementTransforms, METH_O, "NCMesh_GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_ClearTransforms", _wrap_NCMesh_ClearTransforms, METH_O, "NCMesh_ClearTransforms(NCMesh self)"}, - { "NCMesh_GridSfcOrdering2D", _wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS, "NCMesh_GridSfcOrdering2D(int width, int height, intArray coords)"}, - { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, - { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "NCMesh_GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, - { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "NCMesh_GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, - { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, - { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "NCMesh_GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, - { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "NCMesh_GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, - { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "NCMesh_GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, - { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "NCMesh_GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GridSfcOrdering2D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS|METH_KEYWORDS, "NCMesh_GridSfcOrdering2D(int width, int height, intArray coords)"}, + { "NCMesh_GridSfcOrdering3D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS|METH_KEYWORDS, "NCMesh_GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, + { "NCMesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, + { "NCMesh_GetEdgeNCOrientation", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, + { "NCMesh_GetFaceVerticesEdges", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, + { "NCMesh_GetEdgeMaster", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeMaster, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, + { "NCMesh_GetBoundaryClosure", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetBoundaryClosure, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "NCMesh_GetElementGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementGeometry, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceGeometry, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "NCMesh_GetNumRootElements(NCMesh self) -> int"}, - { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "NCMesh_GetElementDepth(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "NCMesh_GetElementSizeReduction(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "NCMesh_GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, - { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "NCMesh_LoadVertexParents(NCMesh self, std::istream & input)"}, - { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "NCMesh_LoadCoarseElements(NCMesh self, std::istream & input)"}, - { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "NCMesh_SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, + { "NCMesh_GetElementDepth", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementDepth, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementSizeReduction, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS|METH_KEYWORDS, "NCMesh_GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, + { "NCMesh_LoadVertexParents", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadVertexParents, METH_VARARGS|METH_KEYWORDS, "NCMesh_LoadVertexParents(NCMesh self, std::istream & input)"}, + { "NCMesh_LoadCoarseElements", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadCoarseElements, METH_VARARGS|METH_KEYWORDS, "NCMesh_LoadCoarseElements(NCMesh self, std::istream & input)"}, + { "NCMesh_SetVertexPositions", (PyCFunction)(void(*)(void))_wrap_NCMesh_SetVertexPositions, METH_VARARGS|METH_KEYWORDS, "NCMesh_SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, { "NCMesh_Trim", _wrap_NCMesh_Trim, METH_O, "NCMesh_Trim(NCMesh self)"}, { "NCMesh_MemoryUsage", _wrap_NCMesh_MemoryUsage, METH_O, "NCMesh_MemoryUsage(NCMesh self) -> long"}, { "NCMesh_PrintMemoryDetail", _wrap_NCMesh_PrintMemoryDetail, METH_O, "NCMesh_PrintMemoryDetail(NCMesh self) -> int"}, @@ -8152,18 +7797,18 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_intp", _wrap_new_intp, METH_NOARGS, "new_intp() -> intp"}, { "delete_intp", _wrap_delete_intp, METH_O, "delete_intp(intp self)"}, - { "intp_assign", _wrap_intp_assign, METH_VARARGS, "assign(intp self, int value)"}, + { "intp_assign", (PyCFunction)(void(*)(void))_wrap_intp_assign, METH_VARARGS|METH_KEYWORDS, "assign(intp self, int value)"}, { "intp_value", _wrap_intp_value, METH_O, "value(intp self) -> int"}, { "intp_cast", _wrap_intp_cast, METH_O, "cast(intp self) -> int *"}, - { "intp_frompointer", _wrap_intp_frompointer, METH_O, "frompointer(int * t) -> intp"}, + { "intp_frompointer", (PyCFunction)(void(*)(void))_wrap_intp_frompointer, METH_VARARGS|METH_KEYWORDS, "frompointer(int * t) -> intp"}, { "intp_swigregister", intp_swigregister, METH_O, NULL}, { "intp_swiginit", intp_swiginit, METH_VARARGS, NULL}, { "new_doublep", _wrap_new_doublep, METH_NOARGS, "new_doublep() -> doublep"}, { "delete_doublep", _wrap_delete_doublep, METH_O, "delete_doublep(doublep self)"}, - { "doublep_assign", _wrap_doublep_assign, METH_VARARGS, "assign(doublep self, double value)"}, + { "doublep_assign", (PyCFunction)(void(*)(void))_wrap_doublep_assign, METH_VARARGS|METH_KEYWORDS, "assign(doublep self, double value)"}, { "doublep_value", _wrap_doublep_value, METH_O, "value(doublep self) -> double"}, { "doublep_cast", _wrap_doublep_cast, METH_O, "cast(doublep self) -> double *"}, - { "doublep_frompointer", _wrap_doublep_frompointer, METH_O, "frompointer(double * t) -> doublep"}, + { "doublep_frompointer", (PyCFunction)(void(*)(void))_wrap_doublep_frompointer, METH_VARARGS|METH_KEYWORDS, "frompointer(double * t) -> doublep"}, { "doublep_swigregister", doublep_swigregister, METH_O, NULL}, { "doublep_swiginit", doublep_swiginit, METH_VARARGS, NULL}, { "Refinement_index_set", _wrap_Refinement_index_set, METH_VARARGS, "Refinement_index_set(Refinement self, int index)"}, @@ -8172,7 +7817,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Refinement_ref_type_get", _wrap_Refinement_ref_type_get, METH_O, "Refinement_ref_type_get(Refinement self) -> char"}, { "new_Refinement", _wrap_new_Refinement, METH_VARARGS, "\n" "Refinement()\n" - "Refinement(int index, int type=7)\n" + "new_Refinement(int index, int type=7) -> Refinement\n" ""}, { "delete_Refinement", _wrap_delete_Refinement, METH_O, "delete_Refinement(Refinement self)"}, { "Refinement_swigregister", Refinement_swigregister, METH_O, NULL}, @@ -8183,7 +7828,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Embedding_matrix_get", _wrap_Embedding_matrix_get, METH_O, "Embedding_matrix_get(Embedding self) -> int"}, { "new_Embedding", _wrap_new_Embedding, METH_VARARGS, "\n" "Embedding()\n" - "Embedding(int elem, int matrix=0)\n" + "new_Embedding(int elem, int matrix=0) -> Embedding\n" ""}, { "delete_Embedding", _wrap_delete_Embedding, METH_O, "delete_Embedding(Embedding self)"}, { "Embedding_swigregister", Embedding_swigregister, METH_O, NULL}, @@ -8191,7 +7836,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "CoarseFineTransformations_point_matrices_set", _wrap_CoarseFineTransformations_point_matrices_set, METH_VARARGS, "CoarseFineTransformations_point_matrices_set(CoarseFineTransformations self, DenseTensor point_matrices)"}, { "CoarseFineTransformations_point_matrices_get", _wrap_CoarseFineTransformations_point_matrices_get, METH_O, "CoarseFineTransformations_point_matrices_get(CoarseFineTransformations self) -> DenseTensor"}, { "CoarseFineTransformations_embeddings_get", _wrap_CoarseFineTransformations_embeddings_get, METH_O, "CoarseFineTransformations_embeddings_get(CoarseFineTransformations self) -> mfem::Array< mfem::Embedding > *"}, - { "CoarseFineTransformations_GetCoarseToFineMap", _wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS, "GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, + { "CoarseFineTransformations_GetCoarseToFineMap", (PyCFunction)(void(*)(void))_wrap_CoarseFineTransformations_GetCoarseToFineMap, METH_VARARGS|METH_KEYWORDS, "GetCoarseToFineMap(CoarseFineTransformations self, Mesh fine_mesh, Table coarse_to_fine, intArray coarse_to_ref_type, Table ref_type_to_matrix, mfem::Array< mfem::Geometry::Type > & ref_type_to_geom)"}, { "CoarseFineTransformations_Clear", _wrap_CoarseFineTransformations_Clear, METH_O, "Clear(CoarseFineTransformations self)"}, { "CoarseFineTransformations_IsInitialized", _wrap_CoarseFineTransformations_IsInitialized, METH_O, "IsInitialized(CoarseFineTransformations self) -> bool"}, { "CoarseFineTransformations_MemoryUsage", _wrap_CoarseFineTransformations_MemoryUsage, METH_O, "MemoryUsage(CoarseFineTransformations self) -> long"}, @@ -8209,35 +7854,35 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "NCMesh_GetNVertices", _wrap_NCMesh_GetNVertices, METH_O, "GetNVertices(NCMesh self) -> int"}, { "NCMesh_GetNEdges", _wrap_NCMesh_GetNEdges, METH_O, "GetNEdges(NCMesh self) -> int"}, { "NCMesh_GetNFaces", _wrap_NCMesh_GetNFaces, METH_O, "GetNFaces(NCMesh self) -> int"}, - { "NCMesh_Refine", _wrap_NCMesh_Refine, METH_VARARGS, "Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, - { "NCMesh_LimitNCLevel", _wrap_NCMesh_LimitNCLevel, METH_VARARGS, "LimitNCLevel(NCMesh self, int max_nc_level)"}, + { "NCMesh_Refine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Refine, METH_VARARGS|METH_KEYWORDS, "Refine(NCMesh self, mfem::Array< mfem::Refinement > const & refinements)"}, + { "NCMesh_LimitNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_LimitNCLevel, METH_VARARGS|METH_KEYWORDS, "LimitNCLevel(NCMesh self, int max_nc_level)"}, { "NCMesh_GetDerefinementTable", _wrap_NCMesh_GetDerefinementTable, METH_O, "GetDerefinementTable(NCMesh self) -> Table"}, - { "NCMesh_CheckDerefinementNCLevel", _wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS, "CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, - { "NCMesh_Derefine", _wrap_NCMesh_Derefine, METH_VARARGS, "Derefine(NCMesh self, intArray derefs)"}, + { "NCMesh_CheckDerefinementNCLevel", (PyCFunction)(void(*)(void))_wrap_NCMesh_CheckDerefinementNCLevel, METH_VARARGS|METH_KEYWORDS, "CheckDerefinementNCLevel(NCMesh self, Table deref_table, intArray level_ok, int max_nc_level)"}, + { "NCMesh_Derefine", (PyCFunction)(void(*)(void))_wrap_NCMesh_Derefine, METH_VARARGS|METH_KEYWORDS, "Derefine(NCMesh self, intArray derefs)"}, { "NCMesh_GetFaceList", _wrap_NCMesh_GetFaceList, METH_O, "GetFaceList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetEdgeList", _wrap_NCMesh_GetEdgeList, METH_O, "GetEdgeList(NCMesh self) -> mfem::NCMesh::NCList const &"}, { "NCMesh_GetVertexList", _wrap_NCMesh_GetVertexList, METH_O, "GetVertexList(NCMesh self) -> mfem::NCMesh::NCList const &"}, - { "NCMesh_GetNCList", _wrap_NCMesh_GetNCList, METH_VARARGS, "GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, + { "NCMesh_GetNCList", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetNCList, METH_VARARGS|METH_KEYWORDS, "GetNCList(NCMesh self, int entity) -> mfem::NCMesh::NCList const &"}, { "NCMesh_MarkCoarseLevel", _wrap_NCMesh_MarkCoarseLevel, METH_O, "MarkCoarseLevel(NCMesh self)"}, { "NCMesh_GetRefinementTransforms", _wrap_NCMesh_GetRefinementTransforms, METH_O, "GetRefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_GetDerefinementTransforms", _wrap_NCMesh_GetDerefinementTransforms, METH_O, "GetDerefinementTransforms(NCMesh self) -> CoarseFineTransformations"}, { "NCMesh_ClearTransforms", _wrap_NCMesh_ClearTransforms, METH_O, "ClearTransforms(NCMesh self)"}, - { "NCMesh_GridSfcOrdering2D", _wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS, "GridSfcOrdering2D(int width, int height, intArray coords)"}, - { "NCMesh_GridSfcOrdering3D", _wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS, "GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, - { "NCMesh_GetEdgeVertices", _wrap_NCMesh_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, - { "NCMesh_GetEdgeNCOrientation", _wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS, "GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, - { "NCMesh_GetFaceVerticesEdges", _wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS, "GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, - { "NCMesh_GetEdgeMaster", _wrap_NCMesh_GetEdgeMaster, METH_VARARGS, "GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, - { "NCMesh_GetBoundaryClosure", _wrap_NCMesh_GetBoundaryClosure, METH_VARARGS, "GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, - { "NCMesh_GetElementGeometry", _wrap_NCMesh_GetElementGeometry, METH_VARARGS, "GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, - { "NCMesh_GetFaceGeometry", _wrap_NCMesh_GetFaceGeometry, METH_VARARGS, "GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GridSfcOrdering2D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering2D, METH_VARARGS|METH_KEYWORDS, "GridSfcOrdering2D(int width, int height, intArray coords)"}, + { "NCMesh_GridSfcOrdering3D", (PyCFunction)(void(*)(void))_wrap_NCMesh_GridSfcOrdering3D, METH_VARARGS|METH_KEYWORDS, "GridSfcOrdering3D(int width, int height, int depth, intArray coords)"}, + { "NCMesh_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(NCMesh self, mfem::NCMesh::MeshId const & edge_id, int [2] vert_index, bool oriented=True)"}, + { "NCMesh_GetEdgeNCOrientation", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeNCOrientation, METH_VARARGS|METH_KEYWORDS, "GetEdgeNCOrientation(NCMesh self, mfem::NCMesh::MeshId const & edge_id) -> int"}, + { "NCMesh_GetFaceVerticesEdges", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceVerticesEdges, METH_VARARGS|METH_KEYWORDS, "GetFaceVerticesEdges(NCMesh self, mfem::NCMesh::MeshId const & face_id, int [4] vert_index, int [4] edge_index, int [4] edge_orientation) -> int"}, + { "NCMesh_GetEdgeMaster", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetEdgeMaster, METH_VARARGS|METH_KEYWORDS, "GetEdgeMaster(NCMesh self, int v1, int v2) -> int"}, + { "NCMesh_GetBoundaryClosure", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetBoundaryClosure, METH_VARARGS|METH_KEYWORDS, "GetBoundaryClosure(NCMesh self, intArray bdr_attr_is_ess, intArray bdr_vertices, intArray bdr_edges)"}, + { "NCMesh_GetElementGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementGeometry, METH_VARARGS|METH_KEYWORDS, "GetElementGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, + { "NCMesh_GetFaceGeometry", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetFaceGeometry, METH_VARARGS|METH_KEYWORDS, "GetFaceGeometry(NCMesh self, int index) -> mfem::Geometry::Type"}, { "NCMesh_GetNumRootElements", _wrap_NCMesh_GetNumRootElements, METH_O, "GetNumRootElements(NCMesh self) -> int"}, - { "NCMesh_GetElementDepth", _wrap_NCMesh_GetElementDepth, METH_VARARGS, "GetElementDepth(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementSizeReduction", _wrap_NCMesh_GetElementSizeReduction, METH_VARARGS, "GetElementSizeReduction(NCMesh self, int i) -> int"}, - { "NCMesh_GetElementFacesAttributes", _wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS, "GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, - { "NCMesh_LoadVertexParents", _wrap_NCMesh_LoadVertexParents, METH_VARARGS, "LoadVertexParents(NCMesh self, std::istream & input)"}, - { "NCMesh_LoadCoarseElements", _wrap_NCMesh_LoadCoarseElements, METH_VARARGS, "LoadCoarseElements(NCMesh self, std::istream & input)"}, - { "NCMesh_SetVertexPositions", _wrap_NCMesh_SetVertexPositions, METH_VARARGS, "SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, + { "NCMesh_GetElementDepth", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementDepth, METH_VARARGS|METH_KEYWORDS, "GetElementDepth(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementSizeReduction", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementSizeReduction, METH_VARARGS|METH_KEYWORDS, "GetElementSizeReduction(NCMesh self, int i) -> int"}, + { "NCMesh_GetElementFacesAttributes", (PyCFunction)(void(*)(void))_wrap_NCMesh_GetElementFacesAttributes, METH_VARARGS|METH_KEYWORDS, "GetElementFacesAttributes(NCMesh self, int i, intArray faces, intArray fattr)"}, + { "NCMesh_LoadVertexParents", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadVertexParents, METH_VARARGS|METH_KEYWORDS, "LoadVertexParents(NCMesh self, std::istream & input)"}, + { "NCMesh_LoadCoarseElements", (PyCFunction)(void(*)(void))_wrap_NCMesh_LoadCoarseElements, METH_VARARGS|METH_KEYWORDS, "LoadCoarseElements(NCMesh self, std::istream & input)"}, + { "NCMesh_SetVertexPositions", (PyCFunction)(void(*)(void))_wrap_NCMesh_SetVertexPositions, METH_VARARGS|METH_KEYWORDS, "SetVertexPositions(NCMesh self, mfem::Array< mfem::Vertex > const & vertices)"}, { "NCMesh_Trim", _wrap_NCMesh_Trim, METH_O, "Trim(NCMesh self)"}, { "NCMesh_MemoryUsage", _wrap_NCMesh_MemoryUsage, METH_O, "MemoryUsage(NCMesh self) -> long"}, { "NCMesh_PrintMemoryDetail", _wrap_NCMesh_PrintMemoryDetail, METH_O, "PrintMemoryDetail(NCMesh self) -> int"}, diff --git a/mfem/_ser/nonlinearform_wrap.cxx b/mfem/_ser/nonlinearform_wrap.cxx index d8980a08..d34edfe9 100644 --- a/mfem/_ser/nonlinearform_wrap.cxx +++ b/mfem/_ser/nonlinearform_wrap.cxx @@ -3401,17 +3401,19 @@ SWIGINTERN mfem::SparseMatrix *mfem_NonlinearForm_GetGradientMatrix(mfem::Nonlin #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = (mfem::FiniteElementSpace *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"f", NULL + }; mfem::NonlinearForm *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_NonlinearForm", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NonlinearForm" "', argument " "1"" of type '" "mfem::FiniteElementSpace *""'"); } @@ -3442,7 +3444,7 @@ SWIGINTERN PyObject *_wrap_new_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::AssemblyLevel arg2 ; @@ -3450,15 +3452,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetAssemblyLevel(PyObject *SWIGUNUSEDPA int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"assembly_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetAssemblyLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_SetAssemblyLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NonlinearForm_SetAssemblyLevel" "', argument " "2"" of type '" "mfem::AssemblyLevel""'"); } @@ -3603,7 +3609,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_FESpace(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::NonlinearFormIntegrator *arg2 = (mfem::NonlinearFormIntegrator *) 0 ; @@ -3611,15 +3617,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::NonlinearFormIntegrator *""'"); } @@ -3691,7 +3701,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetDNFI(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::NonlinearFormIntegrator *arg2 = (mfem::NonlinearFormIntegrator *) 0 ; @@ -3699,15 +3709,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddInteriorFaceIntegrator(PyObject *SWI int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_AddInteriorFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_AddInteriorFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_AddInteriorFaceIntegrator" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_AddInteriorFaceIntegrator" "', argument " "2"" of type '" "mfem::NonlinearFormIntegrator *""'"); } @@ -3892,25 +3906,31 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_AddBdrFaceIntegrator(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"rhs", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:NonlinearForm_SetEssentialBC", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -3918,11 +3938,13 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "3"" of type '" "mfem::Vector *""'"); + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "3"" of type '" "mfem::Vector *""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { (arg1)->SetEssentialBC((mfem::Array< int > const &)*arg2,arg3); @@ -3949,7 +3971,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -3957,113 +3979,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC__SWIG_1(PyObject *SWIGUN int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); - } - arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearForm_SetEssentialBC" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->SetEssentialBC((mfem::Array< int > const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialBC(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_vdofs_list", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "NonlinearForm_SetEssentialBC", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NonlinearForm_SetEssentialBC__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NonlinearForm, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NonlinearForm_SetEssentialBC__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NonlinearForm_SetEssentialBC'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NonlinearForm::SetEssentialBC(mfem::Array< int > const &,mfem::Vector *)\n" - " mfem::NonlinearForm::SetEssentialBC(mfem::Array< int > const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialVDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetEssentialVDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_SetEssentialVDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialVDofs" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialVDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -4097,7 +4025,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialVDofs(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialTrueDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -4105,15 +4033,19 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_SetEssentialTrueDofs(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_SetEssentialTrueDofs", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_SetEssentialTrueDofs", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_SetEssentialTrueDofs" "', argument " "1"" of type '" "mfem::NonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_SetEssentialTrueDofs" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -4188,7 +4120,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetEssentialTrueDofs(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4196,16 +4128,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetGridFunctionEnergy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetGridFunctionEnergy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetGridFunctionEnergy" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetGridFunctionEnergy" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4239,7 +4175,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGridFunctionEnergy(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4247,16 +4183,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetEnergy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetEnergy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetEnergy" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetEnergy" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4290,7 +4230,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4301,15 +4241,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NonlinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_Mult" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4317,7 +4262,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4351,7 +4296,7 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4359,16 +4304,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetGradient" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4604,7 +4553,7 @@ SWIGINTERN PyObject *_wrap_delete_NonlinearForm(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradientMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradientMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearForm *arg1 = (mfem::NonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4612,16 +4561,20 @@ SWIGINTERN PyObject *_wrap_NonlinearForm_GetGradientMatrix(PyObject *SWIGUNUSEDP int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "NonlinearForm_GetGradientMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearForm_GetGradientMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearForm_GetGradientMatrix" "', argument " "1"" of type '" "mfem::NonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearForm_GetGradientMatrix" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4968,16 +4921,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_FESpace(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Array< mfem::FiniteElementSpace * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_SetSpaces", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_SetSpaces", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_SetSpaces" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } @@ -4985,12 +4942,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM { // List/Tuple -> mfem::FiniteElementSpace * int res = 0; - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); arg2 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::FiniteElementSpace * ttt; - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -5003,12 +4960,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetSpaces(PyObject *SWIGUNUSEDPARM } arg2[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); arg2 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::FiniteElementSpace * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -5145,7 +5102,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetBlockTrueOffsets(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::BlockNonlinearFormIntegrator *arg2 = (mfem::BlockNonlinearFormIntegrator *) 0 ; @@ -5153,15 +5110,19 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIG int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_AddDomainIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_AddDomainIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_AddDomainIntegrator" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_AddDomainIntegrator" "', argument " "2"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } @@ -5192,7 +5153,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddDomainIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::BlockNonlinearFormIntegrator *arg2 = (mfem::BlockNonlinearFormIntegrator *) 0 ; @@ -5200,15 +5161,19 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator(PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nlfi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_AddInteriorFaceIntegrator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_AddInteriorFaceIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_AddInteriorFaceIntegrator" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_AddInteriorFaceIntegrator" "', argument " "2"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } @@ -5393,17 +5358,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_AddBdrFaceIntegrator(PyObject *sel } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Array< mfem::Array< int > * > *arg2 = 0 ; mfem::Array< mfem::Vector * > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"bdr_attr_is_ess", (char *)"rhs", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_SetEssentialBC", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockNonlinearForm_SetEssentialBC", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_SetEssentialBC" "', argument " "1"" of type '" "mfem::BlockNonlinearForm *""'"); } @@ -5411,12 +5381,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE { // List/Tuple -> mfem::Array * int res = 0; - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); arg2 = new mfem::Array *>(ll); for (int i = 0; i < ll; i++) { mfem::Array * ttt; - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -5429,12 +5399,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE } arg2[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); arg2 = new mfem::Array *>(ll); for (int i = 0; i < ll; i++) { mfem::Array * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); if (s == Py_None){ ttt = NULL; } else { @@ -5456,12 +5426,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE { // List/Tuple -> mfem::Vector * int res = 0; - if (PyList_Check(swig_obj[2])) { - int ll = PyList_Size(swig_obj[2]); + if (PyList_Check(obj2)) { + int ll = PyList_Size(obj2); arg3 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::Vector * ttt; - PyObject *s = PyList_GetItem(swig_obj[2],i); + PyObject *s = PyList_GetItem(obj2,i); if (s == Py_None){ ttt = NULL; } else { @@ -5474,12 +5444,12 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE } arg3[0][i] = ttt; } - } else if (PyTuple_Check(swig_obj[2])) { - int ll = PyTuple_Size(swig_obj[2]); + } else if (PyTuple_Check(obj2)) { + int ll = PyTuple_Size(obj2); arg3 = new mfem::Array(ll); for (int i = 0; i < ll; i++) { mfem::Vector * ttt; - PyObject *s = PyTuple_GetItem(swig_obj[2],i); + PyObject *s = PyTuple_GetItem(obj2,i); if (s == Py_None){ ttt = NULL; } else { @@ -5544,7 +5514,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_SetEssentialBC(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5552,16 +5522,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_GetEnergy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_GetEnergy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_GetEnergy" "', argument " "1"" of type '" "mfem::BlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_GetEnergy" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5595,7 +5569,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetEnergy(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5606,15 +5580,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockNonlinearForm_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_Mult" "', argument " "1"" of type '" "mfem::BlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5622,7 +5601,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearForm_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearForm_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -5656,7 +5635,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_Mult(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearForm *arg1 = (mfem::BlockNonlinearForm *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5664,16 +5643,20 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearForm_GetGradient(PyObject *SWIGUNUSEDPA int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearForm_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockNonlinearForm_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearForm, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearForm_GetGradient" "', argument " "1"" of type '" "mfem::BlockNonlinearForm const *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearForm_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5761,33 +5744,33 @@ SWIGINTERN PyObject *BlockNonlinearForm_swiginit(PyObject *SWIGUNUSEDPARM(self), static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, - { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "NonlinearForm_SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "new_NonlinearForm", (PyCFunction)(void(*)(void))_wrap_new_NonlinearForm, METH_VARARGS|METH_KEYWORDS, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" "NonlinearForm_FESpace(NonlinearForm self) -> FiniteElementSpace\n" ""}, - { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "NonlinearForm_AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "NonlinearForm_GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, - { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "NonlinearForm_AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "NonlinearForm_AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" "NonlinearForm_AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nfi, intArray bdr_marker)\n" ""}, - { "NonlinearForm_SetEssentialBC", _wrap_NonlinearForm_SetEssentialBC, METH_VARARGS, "NonlinearForm_SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, - { "NonlinearForm_SetEssentialVDofs", _wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS, "NonlinearForm_SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, - { "NonlinearForm_SetEssentialTrueDofs", _wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS, "NonlinearForm_SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, + { "NonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, + { "NonlinearForm_SetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, + { "NonlinearForm_SetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, { "NonlinearForm_GetEssentialTrueDofs", _wrap_NonlinearForm_GetEssentialTrueDofs, METH_O, "NonlinearForm_GetEssentialTrueDofs(NonlinearForm self) -> intArray"}, - { "NonlinearForm_GetGridFunctionEnergy", _wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS, "NonlinearForm_GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_GetEnergy", _wrap_NonlinearForm_GetEnergy, METH_VARARGS, "NonlinearForm_GetEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "NonlinearForm_Mult(NonlinearForm self, Vector x, Vector y)"}, - { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "NonlinearForm_GetGradient(NonlinearForm self, Vector x) -> Operator"}, + { "NonlinearForm_GetGridFunctionEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_Mult(NonlinearForm self, Vector x, Vector y)"}, + { "NonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetGradient(NonlinearForm self, Vector x) -> Operator"}, { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "NonlinearForm_Update(NonlinearForm self)"}, { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "NonlinearForm_Setup(NonlinearForm self)"}, { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "NonlinearForm_GetProlongation(NonlinearForm self) -> Operator"}, { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "NonlinearForm_GetRestriction(NonlinearForm self) -> Operator"}, { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, - { "NonlinearForm_GetGradientMatrix", _wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS, "NonlinearForm_GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, + { "NonlinearForm_GetGradientMatrix", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS|METH_KEYWORDS, "NonlinearForm_GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, { "NonlinearForm_swigregister", NonlinearForm_swigregister, METH_O, NULL}, { "NonlinearForm_swiginit", NonlinearForm_swiginit, METH_VARARGS, NULL}, { "new_BlockNonlinearForm", _wrap_new_BlockNonlinearForm, METH_VARARGS, "\n" @@ -5798,19 +5781,19 @@ static PyMethodDef SwigMethods[] = { "BlockNonlinearForm_FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" "BlockNonlinearForm_FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" ""}, - { "BlockNonlinearForm_SetSpaces", _wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS, "BlockNonlinearForm_SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, + { "BlockNonlinearForm_SetSpaces", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, { "BlockNonlinearForm_GetBlockOffsets", _wrap_BlockNonlinearForm_GetBlockOffsets, METH_O, "BlockNonlinearForm_GetBlockOffsets(BlockNonlinearForm self) -> intArray"}, { "BlockNonlinearForm_GetBlockTrueOffsets", _wrap_BlockNonlinearForm_GetBlockTrueOffsets, METH_O, "BlockNonlinearForm_GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray"}, - { "BlockNonlinearForm_AddDomainIntegrator", _wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS, "BlockNonlinearForm_AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, - { "BlockNonlinearForm_AddInteriorFaceIntegrator", _wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "BlockNonlinearForm_AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, { "BlockNonlinearForm_AddBdrFaceIntegrator", _wrap_BlockNonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "BlockNonlinearForm_AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)\n" "BlockNonlinearForm_AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi, intArray bdr_marker)\n" ""}, - { "BlockNonlinearForm_SetEssentialBC", _wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS, "BlockNonlinearForm_SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, - { "BlockNonlinearForm_GetEnergy", _wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS, "BlockNonlinearForm_GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, - { "BlockNonlinearForm_Mult", _wrap_BlockNonlinearForm_Mult, METH_VARARGS, "BlockNonlinearForm_Mult(BlockNonlinearForm self, Vector x, Vector y)"}, - { "BlockNonlinearForm_GetGradient", _wrap_BlockNonlinearForm_GetGradient, METH_VARARGS, "BlockNonlinearForm_GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, + { "BlockNonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "BlockNonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, + { "BlockNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_Mult(BlockNonlinearForm self, Vector x, Vector y)"}, + { "BlockNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearForm_GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, { "delete_BlockNonlinearForm", _wrap_delete_BlockNonlinearForm, METH_O, "delete_BlockNonlinearForm(BlockNonlinearForm self)"}, { "BlockNonlinearForm_swigregister", BlockNonlinearForm_swigregister, METH_O, NULL}, { "BlockNonlinearForm_swiginit", BlockNonlinearForm_swiginit, METH_VARARGS, NULL}, @@ -5820,33 +5803,33 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearForm", _wrap_new_NonlinearForm, METH_O, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, - { "NonlinearForm_SetAssemblyLevel", _wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS, "SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, + { "new_NonlinearForm", (PyCFunction)(void(*)(void))_wrap_new_NonlinearForm, METH_VARARGS|METH_KEYWORDS, "new_NonlinearForm(FiniteElementSpace f) -> NonlinearForm"}, + { "NonlinearForm_SetAssemblyLevel", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetAssemblyLevel, METH_VARARGS|METH_KEYWORDS, "SetAssemblyLevel(NonlinearForm self, mfem::AssemblyLevel assembly_level)"}, { "NonlinearForm_FESpace", _wrap_NonlinearForm_FESpace, METH_VARARGS, "\n" "FESpace(NonlinearForm self) -> FiniteElementSpace\n" "FESpace(NonlinearForm self) -> FiniteElementSpace\n" ""}, - { "NonlinearForm_AddDomainIntegrator", _wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_GetDNFI", _wrap_NonlinearForm_GetDNFI, METH_O, "GetDNFI(NonlinearForm self) -> mfem::Array< mfem::NonlinearFormIntegrator * > *"}, - { "NonlinearForm_AddInteriorFaceIntegrator", _wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, + { "NonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddInteriorFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)"}, { "NonlinearForm_AddBdrFaceIntegrator", _wrap_NonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nlfi)\n" "AddBdrFaceIntegrator(NonlinearForm self, NonlinearFormIntegrator nfi, intArray bdr_marker)\n" ""}, - { "NonlinearForm_SetEssentialBC", _wrap_NonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, - { "NonlinearForm_SetEssentialVDofs", _wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS, "SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, - { "NonlinearForm_SetEssentialTrueDofs", _wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS, "SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, + { "NonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "SetEssentialBC(NonlinearForm self, intArray bdr_attr_is_ess, Vector rhs=None)"}, + { "NonlinearForm_SetEssentialVDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialVDofs, METH_VARARGS|METH_KEYWORDS, "SetEssentialVDofs(NonlinearForm self, intArray ess_vdofs_list)"}, + { "NonlinearForm_SetEssentialTrueDofs", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_SetEssentialTrueDofs, METH_VARARGS|METH_KEYWORDS, "SetEssentialTrueDofs(NonlinearForm self, intArray ess_tdof_list)"}, { "NonlinearForm_GetEssentialTrueDofs", _wrap_NonlinearForm_GetEssentialTrueDofs, METH_O, "GetEssentialTrueDofs(NonlinearForm self) -> intArray"}, - { "NonlinearForm_GetGridFunctionEnergy", _wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS, "GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_GetEnergy", _wrap_NonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(NonlinearForm self, Vector x) -> double"}, - { "NonlinearForm_Mult", _wrap_NonlinearForm_Mult, METH_VARARGS, "Mult(NonlinearForm self, Vector x, Vector y)"}, - { "NonlinearForm_GetGradient", _wrap_NonlinearForm_GetGradient, METH_VARARGS, "GetGradient(NonlinearForm self, Vector x) -> Operator"}, + { "NonlinearForm_GetGridFunctionEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGridFunctionEnergy, METH_VARARGS|METH_KEYWORDS, "GetGridFunctionEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "GetEnergy(NonlinearForm self, Vector x) -> double"}, + { "NonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(NonlinearForm self, Vector x, Vector y)"}, + { "NonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(NonlinearForm self, Vector x) -> Operator"}, { "NonlinearForm_Update", _wrap_NonlinearForm_Update, METH_O, "Update(NonlinearForm self)"}, { "NonlinearForm_Setup", _wrap_NonlinearForm_Setup, METH_O, "Setup(NonlinearForm self)"}, { "NonlinearForm_GetProlongation", _wrap_NonlinearForm_GetProlongation, METH_O, "GetProlongation(NonlinearForm self) -> Operator"}, { "NonlinearForm_GetRestriction", _wrap_NonlinearForm_GetRestriction, METH_O, "GetRestriction(NonlinearForm self) -> Operator"}, { "delete_NonlinearForm", _wrap_delete_NonlinearForm, METH_O, "delete_NonlinearForm(NonlinearForm self)"}, - { "NonlinearForm_GetGradientMatrix", _wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS, "GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, + { "NonlinearForm_GetGradientMatrix", (PyCFunction)(void(*)(void))_wrap_NonlinearForm_GetGradientMatrix, METH_VARARGS|METH_KEYWORDS, "GetGradientMatrix(NonlinearForm self, Vector x) -> SparseMatrix"}, { "NonlinearForm_swigregister", NonlinearForm_swigregister, METH_O, NULL}, { "NonlinearForm_swiginit", NonlinearForm_swiginit, METH_VARARGS, NULL}, { "new_BlockNonlinearForm", _wrap_new_BlockNonlinearForm, METH_VARARGS, "\n" @@ -5857,19 +5840,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" "FESpace(BlockNonlinearForm self, int k) -> FiniteElementSpace\n" ""}, - { "BlockNonlinearForm_SetSpaces", _wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS, "SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, + { "BlockNonlinearForm_SetSpaces", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetSpaces, METH_VARARGS|METH_KEYWORDS, "SetSpaces(BlockNonlinearForm self, mfem::Array< mfem::FiniteElementSpace * > & f)"}, { "BlockNonlinearForm_GetBlockOffsets", _wrap_BlockNonlinearForm_GetBlockOffsets, METH_O, "GetBlockOffsets(BlockNonlinearForm self) -> intArray"}, { "BlockNonlinearForm_GetBlockTrueOffsets", _wrap_BlockNonlinearForm_GetBlockTrueOffsets, METH_O, "GetBlockTrueOffsets(BlockNonlinearForm self) -> intArray"}, - { "BlockNonlinearForm_AddDomainIntegrator", _wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS, "AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, - { "BlockNonlinearForm_AddInteriorFaceIntegrator", _wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS, "AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddDomainIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddDomainIntegrator, METH_VARARGS|METH_KEYWORDS, "AddDomainIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, + { "BlockNonlinearForm_AddInteriorFaceIntegrator", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_AddInteriorFaceIntegrator, METH_VARARGS|METH_KEYWORDS, "AddInteriorFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)"}, { "BlockNonlinearForm_AddBdrFaceIntegrator", _wrap_BlockNonlinearForm_AddBdrFaceIntegrator, METH_VARARGS, "\n" "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi)\n" "AddBdrFaceIntegrator(BlockNonlinearForm self, BlockNonlinearFormIntegrator nlfi, intArray bdr_marker)\n" ""}, - { "BlockNonlinearForm_SetEssentialBC", _wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS, "SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, - { "BlockNonlinearForm_GetEnergy", _wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS, "GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, - { "BlockNonlinearForm_Mult", _wrap_BlockNonlinearForm_Mult, METH_VARARGS, "Mult(BlockNonlinearForm self, Vector x, Vector y)"}, - { "BlockNonlinearForm_GetGradient", _wrap_BlockNonlinearForm_GetGradient, METH_VARARGS, "GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, + { "BlockNonlinearForm_SetEssentialBC", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_SetEssentialBC, METH_VARARGS|METH_KEYWORDS, "SetEssentialBC(BlockNonlinearForm self, mfem::Array< mfem::Array< int > * > const & bdr_attr_is_ess, mfem::Array< mfem::Vector * > & rhs)"}, + { "BlockNonlinearForm_GetEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetEnergy, METH_VARARGS|METH_KEYWORDS, "GetEnergy(BlockNonlinearForm self, Vector x) -> double"}, + { "BlockNonlinearForm_Mult", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockNonlinearForm self, Vector x, Vector y)"}, + { "BlockNonlinearForm_GetGradient", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearForm_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(BlockNonlinearForm self, Vector x) -> Operator"}, { "delete_BlockNonlinearForm", _wrap_delete_BlockNonlinearForm, METH_O, "delete_BlockNonlinearForm(BlockNonlinearForm self)"}, { "BlockNonlinearForm_swigregister", BlockNonlinearForm_swigregister, METH_O, NULL}, { "BlockNonlinearForm_swiginit", BlockNonlinearForm_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/nonlininteg_wrap.cxx b/mfem/_ser/nonlininteg_wrap.cxx index 8047b191..05673738 100644 --- a/mfem/_ser/nonlininteg_wrap.cxx +++ b/mfem/_ser/nonlininteg_wrap.cxx @@ -3650,66 +3650,33 @@ SwigDirector_NonlinearFormIntegrator::~SwigDirector_NonlinearFormIntegrator() { #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; + mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) NULL ; void *argp2 = 0 ; int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_self", (char *)"ir", NULL + }; mfem::NonlinearFormIntegrator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonlinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); - } - arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::NonlinearFormIntegrator *)new SwigDirector_NonlinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_NonlinearFormIntegrator", kwnames, &obj0, &obj1)) SWIG_fail; + arg1 = obj0; + if (obj1) { + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NonlinearFormIntegrator" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + arg2 = reinterpret_cast< mfem::IntegrationRule * >(argp2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NonlinearFormIntegrator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::NonlinearFormIntegrator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::NonlinearFormIntegrator *)new SwigDirector_NonlinearFormIntegrator(arg1); + result = (mfem::NonlinearFormIntegrator *)new SwigDirector_NonlinearFormIntegrator(arg1,(mfem::IntegrationRule const *)arg2); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -3738,44 +3705,7 @@ SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_NonlinearFormIntegrator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_NonlinearFormIntegrator", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_NonlinearFormIntegrator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - _v = (argv[0] != 0); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__IntegrationRule, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_NonlinearFormIntegrator__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NonlinearFormIntegrator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NonlinearFormIntegrator::NonlinearFormIntegrator(mfem::IntegrationRule const *)\n" - " mfem::NonlinearFormIntegrator::NonlinearFormIntegrator(PyObject *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::IntegrationRule *arg2 = (mfem::IntegrationRule *) 0 ; @@ -3783,15 +3713,19 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ir", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_SetIntRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearFormIntegrator_SetIntRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_SetIntRule" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__IntegrationRule, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_SetIntRule" "', argument " "2"" of type '" "mfem::IntegrationRule const *""'"); } @@ -3822,7 +3756,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntRule(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::IntegrationRule *arg2 = 0 ; @@ -3830,15 +3764,19 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"irule", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_SetIntegrationRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NonlinearFormIntegrator_SetIntegrationRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_SetIntegrationRule" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegrationRule, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_SetIntegrationRule" "', argument " "2"" of type '" "mfem::IntegrationRule const &""'"); } @@ -3872,7 +3810,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_SetIntegrationRule(PyObject * } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -3889,17 +3827,24 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NonlinearFormIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -3907,7 +3852,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -3915,7 +3860,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -3923,7 +3868,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -3932,7 +3877,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec } arg5 = reinterpret_cast< mfem::Vector * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -3967,7 +3912,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementVector(PyObjec } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -3987,17 +3932,25 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleFaceVector", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:NonlinearFormIntegrator_AssembleFaceVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4005,7 +3958,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -4013,7 +3966,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -4021,7 +3974,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Vector const &""'"); } @@ -4029,7 +3982,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Vector const &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NonlinearFormIntegrator_AssembleFaceVector" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -4038,7 +3991,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * } arg6 = reinterpret_cast< mfem::Vector * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4073,7 +4026,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceVector(PyObject * } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4090,17 +4043,24 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NonlinearFormIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4108,7 +4068,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4116,7 +4076,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -4124,7 +4084,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -4133,7 +4093,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject } arg5 = reinterpret_cast< mfem::DenseMatrix * >(argp5); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4168,7 +4128,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleElementGrad(PyObject } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4188,17 +4148,25 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elmat", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:NonlinearFormIntegrator_AssembleFaceGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4206,7 +4174,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } @@ -4214,7 +4182,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::FiniteElement const &""'"); } arg3 = reinterpret_cast< mfem::FiniteElement * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -4222,7 +4190,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } @@ -4230,7 +4198,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Vector const &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "NonlinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::DenseMatrix &""'"); } @@ -4239,7 +4207,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW } arg6 = reinterpret_cast< mfem::DenseMatrix * >(argp6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4274,7 +4242,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssembleFaceGrad(PyObject *SW } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -4288,18 +4256,24 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; Swig::Director *director = 0; bool upcall = false; double result; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:NonlinearFormIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -4307,7 +4281,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4315,7 +4289,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "NonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -4324,7 +4298,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_GetElementEnergy(PyObject *SW } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4540,7 +4514,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AssemblePA(PyObject *self, Py } -SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4551,17 +4525,22 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "NonlinearFormIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NonlinearFormIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::NonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4569,7 +4548,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NonlinearFormIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4578,7 +4557,7 @@ SWIGINTERN PyObject *_wrap_NonlinearFormIntegrator_AddMultPA(PyObject *SWIGUNUSE } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -4653,16 +4632,18 @@ SWIGINTERN PyObject *_wrap_delete_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_disown_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_NonlinearFormIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NonlinearFormIntegrator *arg1 = (mfem::NonlinearFormIntegrator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_NonlinearFormIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_NonlinearFormIntegrator" "', argument " "1"" of type '" "mfem::NonlinearFormIntegrator *""'"); } @@ -4690,7 +4671,7 @@ SWIGINTERN PyObject *NonlinearFormIntegrator_swiginit(PyObject *SWIGUNUSEDPARM(s return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4704,16 +4685,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BlockNonlinearFormIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4721,7 +4708,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4729,7 +4716,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4763,7 +4750,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_GetElementEnergy(PyObjec } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4780,15 +4767,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BlockNonlinearFormIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4796,7 +4790,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4804,7 +4798,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4812,7 +4806,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); } @@ -4846,7 +4840,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementVector(Py } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4866,15 +4860,23 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleFaceVector", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:BlockNonlinearFormIntegrator_AssembleFaceVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4882,7 +4884,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4890,7 +4892,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg3 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -4898,7 +4900,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4906,7 +4908,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg5 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceVector" "', argument " "6"" of type '" "mfem::Array< mfem::Vector * > const &""'"); } @@ -4940,7 +4942,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector(PyObj } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -4957,15 +4959,22 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmats", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:BlockNonlinearFormIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -4973,7 +4982,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -4981,7 +4990,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -4989,7 +4998,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); } @@ -5023,7 +5032,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad(PyOb } -SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockNonlinearFormIntegrator *arg1 = (mfem::BlockNonlinearFormIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -5043,15 +5052,23 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec int res5 = 0 ; void *argp6 = 0 ; int res6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el1", (char *)"el2", (char *)"Tr", (char *)"elfun", (char *)"elmats", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockNonlinearFormIntegrator_AssembleFaceGrad", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:BlockNonlinearFormIntegrator_AssembleFaceGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockNonlinearFormIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "1"" of type '" "mfem::BlockNonlinearFormIntegrator *""'"); } arg1 = reinterpret_cast< mfem::BlockNonlinearFormIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -5059,7 +5076,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -5067,7 +5084,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "3"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg3 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__FaceElementTransformations, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } @@ -5075,7 +5092,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "4"" of type '" "mfem::FaceElementTransformations &""'"); } arg4 = reinterpret_cast< mfem::FaceElementTransformations * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -5083,7 +5100,7 @@ SWIGINTERN PyObject *_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "5"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg5 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BlockNonlinearFormIntegrator_AssembleFaceGrad" "', argument " "6"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); } @@ -5239,7 +5256,7 @@ SWIGINTERN PyObject *_wrap_delete_HyperelasticModel(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -5247,15 +5264,19 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_Ttr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_SetTransformation", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyperelasticModel_SetTransformation", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_SetTransformation" "', argument " "1"" of type '" "mfem::HyperelasticModel *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_SetTransformation" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -5289,7 +5310,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_SetTransformation(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5297,16 +5318,20 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Jpt", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_EvalW", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HyperelasticModel_EvalW", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_EvalW" "', argument " "1"" of type '" "mfem::HyperelasticModel const *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_EvalW" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5340,7 +5365,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalW(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5351,15 +5376,20 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Jpt", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_EvalP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HyperelasticModel_EvalP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_EvalP" "', argument " "1"" of type '" "mfem::HyperelasticModel const *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5367,7 +5397,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticModel_EvalP" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5401,7 +5431,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_EvalP(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5418,15 +5448,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM( int ecode4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Jpt", (char *)"DS", (char *)"weight", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticModel_AssembleH", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HyperelasticModel_AssembleH", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticModel_AssembleH" "', argument " "1"" of type '" "mfem::HyperelasticModel const *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5434,7 +5471,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5442,12 +5479,12 @@ SWIGINTERN PyObject *_wrap_HyperelasticModel_AssembleH(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "HyperelasticModel_AssembleH" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HyperelasticModel_AssembleH" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -5488,7 +5525,7 @@ SWIGINTERN PyObject *HyperelasticModel_swigregister(PyObject *SWIGUNUSEDPARM(sel return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseHarmonicModel *arg1 = (mfem::InverseHarmonicModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5496,16 +5533,20 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "InverseHarmonicModel_EvalW", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:InverseHarmonicModel_EvalW", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseHarmonicModel_EvalW" "', argument " "1"" of type '" "mfem::InverseHarmonicModel const *""'"); } arg1 = reinterpret_cast< mfem::InverseHarmonicModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseHarmonicModel_EvalW" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5539,7 +5580,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalW(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseHarmonicModel *arg1 = (mfem::InverseHarmonicModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5550,15 +5591,20 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseHarmonicModel_EvalP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:InverseHarmonicModel_EvalP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseHarmonicModel_EvalP" "', argument " "1"" of type '" "mfem::InverseHarmonicModel const *""'"); } arg1 = reinterpret_cast< mfem::InverseHarmonicModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseHarmonicModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5566,7 +5612,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseHarmonicModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseHarmonicModel_EvalP" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -5600,7 +5646,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_EvalP(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::InverseHarmonicModel *arg1 = (mfem::InverseHarmonicModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -5617,15 +5663,22 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPA int ecode4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"DS", (char *)"weight", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "InverseHarmonicModel_AssembleH", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:InverseHarmonicModel_AssembleH", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__InverseHarmonicModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "1"" of type '" "mfem::InverseHarmonicModel const *""'"); } arg1 = reinterpret_cast< mfem::InverseHarmonicModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5633,7 +5686,7 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseHarmonicModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -5641,12 +5694,12 @@ SWIGINTERN PyObject *_wrap_InverseHarmonicModel_AssembleH(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InverseHarmonicModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "InverseHarmonicModel_AssembleH" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -5766,7 +5819,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( PyObject *resultobj = 0; double arg1 ; double arg2 ; - double arg3 ; + double arg3 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; double val2 ; @@ -5775,7 +5828,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( int ecode3 = 0 ; mfem::NeoHookeanModel *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "double""'"); @@ -5786,11 +5839,13 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } { try { result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(arg1,arg2,arg3); @@ -5818,57 +5873,10 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_0(PyObject *SWIGUNUSEDPARM( SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - double arg1 ; - double arg2 ; - double val1 ; - int ecode1 = 0 ; - double val2 ; - int ecode2 = 0 ; - mfem::NeoHookeanModel *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NeoHookeanModel, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; mfem::Coefficient *arg2 = 0 ; - mfem::Coefficient *arg3 = (mfem::Coefficient *) 0 ; + mfem::Coefficient *arg3 = (mfem::Coefficient *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5877,7 +5885,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_2(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; mfem::NeoHookeanModel *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "mfem::Coefficient &""'"); @@ -5894,67 +5902,16 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_2(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "mfem::Coefficient &""'"); } arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "mfem::Coefficient *""'"); - } - arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); - { - try { - result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(*arg1,*arg2,arg3); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Coefficient, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_NeoHookeanModel" "', argument " "3"" of type '" "mfem::Coefficient *""'"); } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NeoHookeanModel, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_NeoHookeanModel__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Coefficient *arg1 = 0 ; - mfem::Coefficient *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::NeoHookeanModel *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NeoHookeanModel" "', argument " "1"" of type '" "mfem::Coefficient &""'"); - } - arg1 = reinterpret_cast< mfem::Coefficient * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Coefficient, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "mfem::Coefficient &""'"); + arg3 = reinterpret_cast< mfem::Coefficient * >(argp3); } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_NeoHookeanModel" "', argument " "2"" of type '" "mfem::Coefficient &""'"); - } - arg2 = reinterpret_cast< mfem::Coefficient * >(argp2); { try { - result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(*arg1,*arg2); + result = (mfem::NeoHookeanModel *)new mfem::NeoHookeanModel(*arg1,*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5986,7 +5943,7 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_NeoHookeanModel", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); @@ -5996,52 +5953,19 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_NeoHookeanModel__SWIG_3(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if (PyFloat_Check(argv[0])){ - _v = 1; - } else { - _v = 0; - } - } - if (_v) { - { - if (PyFloat_Check(argv[1])){ - _v = 1; - } else { - _v = 0; + if (argc <= 2) { + return _wrap_new_NeoHookeanModel__SWIG_1(self, argc, argv); } - } - if (_v) { - return _wrap_new_NeoHookeanModel__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Coefficient, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Coefficient, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_NeoHookeanModel__SWIG_2(self, argc, argv); + return _wrap_new_NeoHookeanModel__SWIG_1(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if (PyFloat_Check(argv[0])){ @@ -6059,6 +5983,9 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_NeoHookeanModel__SWIG_0(self, argc, argv); + } { if (PyFloat_Check(argv[2])){ _v = 1; @@ -6077,14 +6004,12 @@ SWIGINTERN PyObject *_wrap_new_NeoHookeanModel(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NeoHookeanModel'.\n" " Possible C/C++ prototypes are:\n" " mfem::NeoHookeanModel::NeoHookeanModel(double,double,double)\n" - " mfem::NeoHookeanModel::NeoHookeanModel(double,double)\n" - " mfem::NeoHookeanModel::NeoHookeanModel(mfem::Coefficient &,mfem::Coefficient &,mfem::Coefficient *)\n" - " mfem::NeoHookeanModel::NeoHookeanModel(mfem::Coefficient &,mfem::Coefficient &)\n"); + " mfem::NeoHookeanModel::NeoHookeanModel(mfem::Coefficient &,mfem::Coefficient &,mfem::Coefficient *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NeoHookeanModel *arg1 = (mfem::NeoHookeanModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -6092,16 +6017,20 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NeoHookeanModel_EvalW", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NeoHookeanModel_EvalW", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NeoHookeanModel_EvalW" "', argument " "1"" of type '" "mfem::NeoHookeanModel const *""'"); } arg1 = reinterpret_cast< mfem::NeoHookeanModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NeoHookeanModel_EvalW" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6135,7 +6064,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalW(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NeoHookeanModel *arg1 = (mfem::NeoHookeanModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -6146,15 +6075,20 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"P", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NeoHookeanModel_EvalP", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NeoHookeanModel_EvalP", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NeoHookeanModel_EvalP" "', argument " "1"" of type '" "mfem::NeoHookeanModel const *""'"); } arg1 = reinterpret_cast< mfem::NeoHookeanModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NeoHookeanModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6162,7 +6096,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NeoHookeanModel_EvalP" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NeoHookeanModel_EvalP" "', argument " "3"" of type '" "mfem::DenseMatrix &""'"); } @@ -6196,7 +6130,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_EvalP(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NeoHookeanModel *arg1 = (mfem::NeoHookeanModel *) 0 ; mfem::DenseMatrix *arg2 = 0 ; @@ -6213,15 +6147,22 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(se int ecode4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"J", (char *)"DS", (char *)"weight", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NeoHookeanModel_AssembleH", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NeoHookeanModel_AssembleH", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NeoHookeanModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NeoHookeanModel_AssembleH" "', argument " "1"" of type '" "mfem::NeoHookeanModel const *""'"); } arg1 = reinterpret_cast< mfem::NeoHookeanModel * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NeoHookeanModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6229,7 +6170,7 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NeoHookeanModel_AssembleH" "', argument " "2"" of type '" "mfem::DenseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::DenseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NeoHookeanModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } @@ -6237,12 +6178,12 @@ SWIGINTERN PyObject *_wrap_NeoHookeanModel_AssembleH(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NeoHookeanModel_AssembleH" "', argument " "3"" of type '" "mfem::DenseMatrix const &""'"); } arg3 = reinterpret_cast< mfem::DenseMatrix * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "NeoHookeanModel_AssembleH" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "NeoHookeanModel_AssembleH" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -6327,17 +6268,19 @@ SWIGINTERN PyObject *NeoHookeanModel_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HyperelasticNLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_HyperelasticNLFIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticModel *arg1 = (mfem::HyperelasticModel *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"m", NULL + }; mfem::HyperelasticNLFIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_HyperelasticNLFIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticModel, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HyperelasticNLFIntegrator" "', argument " "1"" of type '" "mfem::HyperelasticModel *""'"); } @@ -6368,7 +6311,7 @@ SWIGINTERN PyObject *_wrap_new_HyperelasticNLFIntegrator(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticNLFIntegrator *arg1 = (mfem::HyperelasticNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6382,16 +6325,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Ttr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticNLFIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:HyperelasticNLFIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::HyperelasticNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6399,7 +6348,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6407,7 +6356,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HyperelasticNLFIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -6441,7 +6390,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_GetElementEnergy(PyObject * } -SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticNLFIntegrator *arg1 = (mfem::HyperelasticNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6458,15 +6407,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Ttr", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticNLFIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HyperelasticNLFIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::HyperelasticNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6474,7 +6430,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6482,7 +6438,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -6490,7 +6446,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HyperelasticNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -6524,7 +6480,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementVector(PyObj } -SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::HyperelasticNLFIntegrator *arg1 = (mfem::HyperelasticNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -6541,15 +6497,22 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Ttr", (char *)"elfun", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "HyperelasticNLFIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:HyperelasticNLFIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__HyperelasticNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::HyperelasticNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::HyperelasticNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -6557,7 +6520,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6565,7 +6528,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -6573,7 +6536,7 @@ SWIGINTERN PyObject *_wrap_HyperelasticNLFIntegrator_AssembleElementGrad(PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "HyperelasticNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -6658,17 +6621,19 @@ SWIGINTERN PyObject *HyperelasticNLFIntegrator_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Coefficient *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_mu", NULL + }; mfem::IncompressibleNeoHookeanIntegrator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_IncompressibleNeoHookeanIntegrator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Coefficient, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IncompressibleNeoHookeanIntegrator" "', argument " "1"" of type '" "mfem::Coefficient &""'"); } @@ -6702,7 +6667,7 @@ SWIGINTERN PyObject *_wrap_new_IncompressibleNeoHookeanIntegrator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -6716,16 +6681,22 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_GetElementEnergy", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:IncompressibleNeoHookeanIntegrator_GetElementEnergy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); } arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -6733,7 +6704,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6741,7 +6712,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_GetElementEnergy" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -6775,7 +6746,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy(P } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -6792,15 +6763,22 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elvec", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:IncompressibleNeoHookeanIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); } arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -6808,7 +6786,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6816,7 +6794,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -6824,7 +6802,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Array< mfem::Vector * > const &""'"); } @@ -6858,7 +6836,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVec } -SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IncompressibleNeoHookeanIntegrator *arg1 = (mfem::IncompressibleNeoHookeanIntegrator *) 0 ; mfem::Array< mfem::FiniteElement const * > *arg2 = 0 ; @@ -6875,15 +6853,22 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"Tr", (char *)"elfun", (char *)"elmats", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:IncompressibleNeoHookeanIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IncompressibleNeoHookeanIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::IncompressibleNeoHookeanIntegrator *""'"); } arg1 = reinterpret_cast< mfem::IncompressibleNeoHookeanIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_mfem__FiniteElement_const_p_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } @@ -6891,7 +6876,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::Array< mfem::FiniteElement const * > const &""'"); } arg2 = reinterpret_cast< mfem::Array< mfem::FiniteElement const * > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -6899,7 +6884,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_mfem__Vector_const_p_t, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } @@ -6907,7 +6892,7 @@ SWIGINTERN PyObject *_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGra SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Array< mfem::Vector const * > const &""'"); } arg4 = reinterpret_cast< mfem::Array< mfem::Vector const * > * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Array2DT_mfem__DenseMatrix_p_t, 0 | 0); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "IncompressibleNeoHookeanIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::Array2D< mfem::DenseMatrix * > const &""'"); } @@ -7095,7 +7080,7 @@ SWIGINTERN PyObject *_wrap_new_VectorConvectionNLFIntegrator(PyObject *self, PyO } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElement *arg1 = 0 ; mfem::ElementTransformation *arg2 = 0 ; @@ -7103,11 +7088,15 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"fe", (char *)"T", NULL + }; mfem::IntegrationRule *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_GetRule", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:VectorConvectionNLFIntegrator_GetRule", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } @@ -7115,7 +7104,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "1"" of type '" "mfem::FiniteElement const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElement * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_GetRule" "', argument " "2"" of type '" "mfem::ElementTransformation &""'"); } @@ -7149,7 +7138,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_GetRule(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7166,15 +7155,22 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"trans", (char *)"elfun", (char *)"elvect", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementVector", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorConvectionNLFIntegrator_AssembleElementVector", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7182,7 +7178,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7190,7 +7186,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -7198,7 +7194,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementVector" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -7232,7 +7228,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementVector(P } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; mfem::FiniteElement *arg2 = 0 ; @@ -7249,15 +7245,22 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO int res4 = 0 ; void *argp5 = 0 ; int res5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"el", (char *)"trans", (char *)"elfun", (char *)"elmat", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AssembleElementGrad", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:VectorConvectionNLFIntegrator_AssembleElementGrad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator *""'"); } arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__FiniteElement, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } @@ -7265,7 +7268,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "2"" of type '" "mfem::FiniteElement const &""'"); } arg2 = reinterpret_cast< mfem::FiniteElement * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ElementTransformation, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } @@ -7273,7 +7276,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "3"" of type '" "mfem::ElementTransformation &""'"); } arg3 = reinterpret_cast< mfem::ElementTransformation * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -7281,7 +7284,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad(PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "4"" of type '" "mfem::Vector const &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "VectorConvectionNLFIntegrator_AssembleElementGrad" "', argument " "5"" of type '" "mfem::DenseMatrix &""'"); } @@ -7535,7 +7538,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AssemblePA(PyObject *se } -SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::VectorConvectionNLFIntegrator *arg1 = (mfem::VectorConvectionNLFIntegrator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7546,15 +7549,20 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWI int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "VectorConvectionNLFIntegrator_AddMultPA", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:VectorConvectionNLFIntegrator_AddMultPA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__VectorConvectionNLFIntegrator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "1"" of type '" "mfem::VectorConvectionNLFIntegrator const *""'"); } arg1 = reinterpret_cast< mfem::VectorConvectionNLFIntegrator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7562,7 +7570,7 @@ SWIGINTERN PyObject *_wrap_VectorConvectionNLFIntegrator_AddMultPA(PyObject *SWI SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "VectorConvectionNLFIntegrator_AddMultPA" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7650,66 +7658,66 @@ SWIGINTERN PyObject *VectorConvectionNLFIntegrator_swiginit(PyObject *SWIGUNUSED static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, - { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, - { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "NonlinearFormIntegrator_SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, - { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "NonlinearFormIntegrator_AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "NonlinearFormIntegrator_GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "new_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_NonlinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> NonlinearFormIntegrator"}, + { "NonlinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, + { "NonlinearFormIntegrator_SetIntegrationRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, + { "NonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" "NonlinearFormIntegrator_AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "NonlinearFormIntegrator_AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, + { "NonlinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "NonlinearFormIntegrator_AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, - { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, + { "disown_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "BlockNonlinearFormIntegrator_GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, - { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "BlockNonlinearFormIntegrator_AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "BlockNonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, + { "BlockNonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "BlockNonlinearFormIntegrator_AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, - { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "HyperelasticModel_SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, - { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "HyperelasticModel_EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, - { "HyperelasticModel_EvalP", _wrap_HyperelasticModel_EvalP, METH_VARARGS, "HyperelasticModel_EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, - { "HyperelasticModel_AssembleH", _wrap_HyperelasticModel_AssembleH, METH_VARARGS, "HyperelasticModel_AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "HyperelasticModel_SetTransformation", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_SetTransformation, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, + { "HyperelasticModel_EvalW", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalW, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, + { "HyperelasticModel_EvalP", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalP, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, + { "HyperelasticModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "HyperelasticModel_AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "HyperelasticModel_swigregister", HyperelasticModel_swigregister, METH_O, NULL}, - { "InverseHarmonicModel_EvalW", _wrap_InverseHarmonicModel_EvalW, METH_VARARGS, "InverseHarmonicModel_EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, - { "InverseHarmonicModel_EvalP", _wrap_InverseHarmonicModel_EvalP, METH_VARARGS, "InverseHarmonicModel_EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, - { "InverseHarmonicModel_AssembleH", _wrap_InverseHarmonicModel_AssembleH, METH_VARARGS, "InverseHarmonicModel_AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "InverseHarmonicModel_EvalW", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalW, METH_VARARGS|METH_KEYWORDS, "InverseHarmonicModel_EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, + { "InverseHarmonicModel_EvalP", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalP, METH_VARARGS|METH_KEYWORDS, "InverseHarmonicModel_EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, + { "InverseHarmonicModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "InverseHarmonicModel_AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "new_InverseHarmonicModel", _wrap_new_InverseHarmonicModel, METH_NOARGS, "new_InverseHarmonicModel() -> InverseHarmonicModel"}, { "delete_InverseHarmonicModel", _wrap_delete_InverseHarmonicModel, METH_O, "delete_InverseHarmonicModel(InverseHarmonicModel self)"}, { "InverseHarmonicModel_swigregister", InverseHarmonicModel_swigregister, METH_O, NULL}, { "InverseHarmonicModel_swiginit", InverseHarmonicModel_swiginit, METH_VARARGS, NULL}, { "new_NeoHookeanModel", _wrap_new_NeoHookeanModel, METH_VARARGS, "\n" "NeoHookeanModel(double _mu, double _K, double _g=1.0)\n" - "NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None)\n" + "new_NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None) -> NeoHookeanModel\n" ""}, - { "NeoHookeanModel_EvalW", _wrap_NeoHookeanModel_EvalW, METH_VARARGS, "NeoHookeanModel_EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, - { "NeoHookeanModel_EvalP", _wrap_NeoHookeanModel_EvalP, METH_VARARGS, "NeoHookeanModel_EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, - { "NeoHookeanModel_AssembleH", _wrap_NeoHookeanModel_AssembleH, METH_VARARGS, "NeoHookeanModel_AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "NeoHookeanModel_EvalW", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalW, METH_VARARGS|METH_KEYWORDS, "NeoHookeanModel_EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, + { "NeoHookeanModel_EvalP", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalP, METH_VARARGS|METH_KEYWORDS, "NeoHookeanModel_EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, + { "NeoHookeanModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "NeoHookeanModel_AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "delete_NeoHookeanModel", _wrap_delete_NeoHookeanModel, METH_O, "delete_NeoHookeanModel(NeoHookeanModel self)"}, { "NeoHookeanModel_swigregister", NeoHookeanModel_swigregister, METH_O, NULL}, { "NeoHookeanModel_swiginit", NeoHookeanModel_swiginit, METH_VARARGS, NULL}, - { "new_HyperelasticNLFIntegrator", _wrap_new_HyperelasticNLFIntegrator, METH_O, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, - { "HyperelasticNLFIntegrator_GetElementEnergy", _wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS, "HyperelasticNLFIntegrator_GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, - { "HyperelasticNLFIntegrator_AssembleElementVector", _wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS, "HyperelasticNLFIntegrator_AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, - { "HyperelasticNLFIntegrator_AssembleElementGrad", _wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS, "HyperelasticNLFIntegrator_AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, + { "new_HyperelasticNLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_HyperelasticNLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, + { "HyperelasticNLFIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "HyperelasticNLFIntegrator_GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, + { "HyperelasticNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "HyperelasticNLFIntegrator_AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, + { "HyperelasticNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "HyperelasticNLFIntegrator_AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, { "delete_HyperelasticNLFIntegrator", _wrap_delete_HyperelasticNLFIntegrator, METH_O, "delete_HyperelasticNLFIntegrator(HyperelasticNLFIntegrator self)"}, { "HyperelasticNLFIntegrator_swigregister", HyperelasticNLFIntegrator_swigregister, METH_O, NULL}, { "HyperelasticNLFIntegrator_swiginit", HyperelasticNLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_IncompressibleNeoHookeanIntegrator", _wrap_new_IncompressibleNeoHookeanIntegrator, METH_O, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, - { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", _wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS, "IncompressibleNeoHookeanIntegrator_GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS, "IncompressibleNeoHookeanIntegrator_AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "new_IncompressibleNeoHookeanIntegrator", (PyCFunction)(void(*)(void))_wrap_new_IncompressibleNeoHookeanIntegrator, METH_VARARGS|METH_KEYWORDS, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, + { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "IncompressibleNeoHookeanIntegrator_GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "IncompressibleNeoHookeanIntegrator_AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "IncompressibleNeoHookeanIntegrator_AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, @@ -7717,15 +7725,15 @@ static PyMethodDef SwigMethods[] = { "VectorConvectionNLFIntegrator(Coefficient q)\n" "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" ""}, - { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, - { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, - { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "VectorConvectionNLFIntegrator_AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" "VectorConvectionNLFIntegrator_AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" ""}, - { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "VectorConvectionNLFIntegrator_AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "VectorConvectionNLFIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "VectorConvectionNLFIntegrator_AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, @@ -7735,66 +7743,66 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_NonlinearFormIntegrator", _wrap_new_NonlinearFormIntegrator, METH_VARARGS, "NonlinearFormIntegrator(IntegrationRule ir=None)"}, - { "NonlinearFormIntegrator_SetIntRule", _wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS, "SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, - { "NonlinearFormIntegrator_SetIntegrationRule", _wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS, "SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, - { "NonlinearFormIntegrator_AssembleElementVector", _wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleFaceVector", _wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, - { "NonlinearFormIntegrator_AssembleElementGrad", _wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_AssembleFaceGrad", _wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, - { "NonlinearFormIntegrator_GetElementEnergy", _wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, + { "new_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_new_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, "new_NonlinearFormIntegrator(PyObject * _self, IntegrationRule ir=None) -> NonlinearFormIntegrator"}, + { "NonlinearFormIntegrator_SetIntRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntRule, METH_VARARGS|METH_KEYWORDS, "SetIntRule(NonlinearFormIntegrator self, IntegrationRule ir)"}, + { "NonlinearFormIntegrator_SetIntegrationRule", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_SetIntegrationRule, METH_VARARGS|METH_KEYWORDS, "SetIntegrationRule(NonlinearFormIntegrator self, IntegrationRule irule)"}, + { "NonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "AssembleFaceVector(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, Vector elvect)"}, + { "NonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "AssembleFaceGrad(NonlinearFormIntegrator self, FiniteElement el1, FiniteElement el2, FaceElementTransformations Tr, Vector elfun, DenseMatrix elmat)"}, + { "NonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(NonlinearFormIntegrator self, FiniteElement el, ElementTransformation Tr, Vector elfun) -> double"}, { "NonlinearFormIntegrator_AssemblePA", _wrap_NonlinearFormIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace fes)\n" "AssemblePA(NonlinearFormIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" ""}, - { "NonlinearFormIntegrator_AddMultPA", _wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, + { "NonlinearFormIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_NonlinearFormIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(NonlinearFormIntegrator self, Vector x, Vector y)"}, { "delete_NonlinearFormIntegrator", _wrap_delete_NonlinearFormIntegrator, METH_O, "delete_NonlinearFormIntegrator(NonlinearFormIntegrator self)"}, - { "disown_NonlinearFormIntegrator", _wrap_disown_NonlinearFormIntegrator, METH_O, NULL}, + { "disown_NonlinearFormIntegrator", (PyCFunction)(void(*)(void))_wrap_disown_NonlinearFormIntegrator, METH_VARARGS|METH_KEYWORDS, NULL}, { "NonlinearFormIntegrator_swigregister", NonlinearFormIntegrator_swigregister, METH_O, NULL}, { "NonlinearFormIntegrator_swiginit", NonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, - { "BlockNonlinearFormIntegrator_GetElementEnergy", _wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "BlockNonlinearFormIntegrator_AssembleElementVector", _wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceVector", _wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS, "AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, - { "BlockNonlinearFormIntegrator_AssembleElementGrad", _wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, - { "BlockNonlinearFormIntegrator_AssembleFaceGrad", _wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS, "AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "BlockNonlinearFormIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceVector", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceVector, METH_VARARGS|METH_KEYWORDS, "AssembleFaceVector(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvect)"}, + { "BlockNonlinearFormIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "BlockNonlinearFormIntegrator_AssembleFaceGrad", (PyCFunction)(void(*)(void))_wrap_BlockNonlinearFormIntegrator_AssembleFaceGrad, METH_VARARGS|METH_KEYWORDS, "AssembleFaceGrad(BlockNonlinearFormIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el1, mfem::Array< mfem::FiniteElement const * > const & el2, FaceElementTransformations Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_BlockNonlinearFormIntegrator", _wrap_delete_BlockNonlinearFormIntegrator, METH_O, "delete_BlockNonlinearFormIntegrator(BlockNonlinearFormIntegrator self)"}, { "new_BlockNonlinearFormIntegrator", _wrap_new_BlockNonlinearFormIntegrator, METH_NOARGS, "new_BlockNonlinearFormIntegrator() -> BlockNonlinearFormIntegrator"}, { "BlockNonlinearFormIntegrator_swigregister", BlockNonlinearFormIntegrator_swigregister, METH_O, NULL}, { "BlockNonlinearFormIntegrator_swiginit", BlockNonlinearFormIntegrator_swiginit, METH_VARARGS, NULL}, { "delete_HyperelasticModel", _wrap_delete_HyperelasticModel, METH_O, "delete_HyperelasticModel(HyperelasticModel self)"}, - { "HyperelasticModel_SetTransformation", _wrap_HyperelasticModel_SetTransformation, METH_VARARGS, "SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, - { "HyperelasticModel_EvalW", _wrap_HyperelasticModel_EvalW, METH_VARARGS, "EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, - { "HyperelasticModel_EvalP", _wrap_HyperelasticModel_EvalP, METH_VARARGS, "EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, - { "HyperelasticModel_AssembleH", _wrap_HyperelasticModel_AssembleH, METH_VARARGS, "AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "HyperelasticModel_SetTransformation", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_SetTransformation, METH_VARARGS|METH_KEYWORDS, "SetTransformation(HyperelasticModel self, ElementTransformation _Ttr)"}, + { "HyperelasticModel_EvalW", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalW, METH_VARARGS|METH_KEYWORDS, "EvalW(HyperelasticModel self, DenseMatrix Jpt) -> double"}, + { "HyperelasticModel_EvalP", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_EvalP, METH_VARARGS|METH_KEYWORDS, "EvalP(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix P)"}, + { "HyperelasticModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_HyperelasticModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "AssembleH(HyperelasticModel self, DenseMatrix Jpt, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "HyperelasticModel_swigregister", HyperelasticModel_swigregister, METH_O, NULL}, - { "InverseHarmonicModel_EvalW", _wrap_InverseHarmonicModel_EvalW, METH_VARARGS, "EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, - { "InverseHarmonicModel_EvalP", _wrap_InverseHarmonicModel_EvalP, METH_VARARGS, "EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, - { "InverseHarmonicModel_AssembleH", _wrap_InverseHarmonicModel_AssembleH, METH_VARARGS, "AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "InverseHarmonicModel_EvalW", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalW, METH_VARARGS|METH_KEYWORDS, "EvalW(InverseHarmonicModel self, DenseMatrix J) -> double"}, + { "InverseHarmonicModel_EvalP", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_EvalP, METH_VARARGS|METH_KEYWORDS, "EvalP(InverseHarmonicModel self, DenseMatrix J, DenseMatrix P)"}, + { "InverseHarmonicModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_InverseHarmonicModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "AssembleH(InverseHarmonicModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "new_InverseHarmonicModel", _wrap_new_InverseHarmonicModel, METH_NOARGS, "new_InverseHarmonicModel() -> InverseHarmonicModel"}, { "delete_InverseHarmonicModel", _wrap_delete_InverseHarmonicModel, METH_O, "delete_InverseHarmonicModel(InverseHarmonicModel self)"}, { "InverseHarmonicModel_swigregister", InverseHarmonicModel_swigregister, METH_O, NULL}, { "InverseHarmonicModel_swiginit", InverseHarmonicModel_swiginit, METH_VARARGS, NULL}, { "new_NeoHookeanModel", _wrap_new_NeoHookeanModel, METH_VARARGS, "\n" "NeoHookeanModel(double _mu, double _K, double _g=1.0)\n" - "NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None)\n" + "new_NeoHookeanModel(Coefficient _mu, Coefficient _K, Coefficient _g=None) -> NeoHookeanModel\n" ""}, - { "NeoHookeanModel_EvalW", _wrap_NeoHookeanModel_EvalW, METH_VARARGS, "EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, - { "NeoHookeanModel_EvalP", _wrap_NeoHookeanModel_EvalP, METH_VARARGS, "EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, - { "NeoHookeanModel_AssembleH", _wrap_NeoHookeanModel_AssembleH, METH_VARARGS, "AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, + { "NeoHookeanModel_EvalW", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalW, METH_VARARGS|METH_KEYWORDS, "EvalW(NeoHookeanModel self, DenseMatrix J) -> double"}, + { "NeoHookeanModel_EvalP", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_EvalP, METH_VARARGS|METH_KEYWORDS, "EvalP(NeoHookeanModel self, DenseMatrix J, DenseMatrix P)"}, + { "NeoHookeanModel_AssembleH", (PyCFunction)(void(*)(void))_wrap_NeoHookeanModel_AssembleH, METH_VARARGS|METH_KEYWORDS, "AssembleH(NeoHookeanModel self, DenseMatrix J, DenseMatrix DS, double const weight, DenseMatrix A)"}, { "delete_NeoHookeanModel", _wrap_delete_NeoHookeanModel, METH_O, "delete_NeoHookeanModel(NeoHookeanModel self)"}, { "NeoHookeanModel_swigregister", NeoHookeanModel_swigregister, METH_O, NULL}, { "NeoHookeanModel_swiginit", NeoHookeanModel_swiginit, METH_VARARGS, NULL}, - { "new_HyperelasticNLFIntegrator", _wrap_new_HyperelasticNLFIntegrator, METH_O, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, - { "HyperelasticNLFIntegrator_GetElementEnergy", _wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, - { "HyperelasticNLFIntegrator_AssembleElementVector", _wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, - { "HyperelasticNLFIntegrator_AssembleElementGrad", _wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, + { "new_HyperelasticNLFIntegrator", (PyCFunction)(void(*)(void))_wrap_new_HyperelasticNLFIntegrator, METH_VARARGS|METH_KEYWORDS, "new_HyperelasticNLFIntegrator(HyperelasticModel m) -> HyperelasticNLFIntegrator"}, + { "HyperelasticNLFIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun) -> double"}, + { "HyperelasticNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, Vector elvect)"}, + { "HyperelasticNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_HyperelasticNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(HyperelasticNLFIntegrator self, FiniteElement el, ElementTransformation Ttr, Vector elfun, DenseMatrix elmat)"}, { "delete_HyperelasticNLFIntegrator", _wrap_delete_HyperelasticNLFIntegrator, METH_O, "delete_HyperelasticNLFIntegrator(HyperelasticNLFIntegrator self)"}, { "HyperelasticNLFIntegrator_swigregister", HyperelasticNLFIntegrator_swigregister, METH_O, NULL}, { "HyperelasticNLFIntegrator_swiginit", HyperelasticNLFIntegrator_swiginit, METH_VARARGS, NULL}, - { "new_IncompressibleNeoHookeanIntegrator", _wrap_new_IncompressibleNeoHookeanIntegrator, METH_O, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, - { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", _wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS, "GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, - { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", _wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, + { "new_IncompressibleNeoHookeanIntegrator", (PyCFunction)(void(*)(void))_wrap_new_IncompressibleNeoHookeanIntegrator, METH_VARARGS|METH_KEYWORDS, "new_IncompressibleNeoHookeanIntegrator(Coefficient _mu) -> IncompressibleNeoHookeanIntegrator"}, + { "IncompressibleNeoHookeanIntegrator_GetElementEnergy", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_GetElementEnergy, METH_VARARGS|METH_KEYWORDS, "GetElementEnergy(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun) -> double"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array< mfem::Vector * > const & elvec)"}, + { "IncompressibleNeoHookeanIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_IncompressibleNeoHookeanIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(IncompressibleNeoHookeanIntegrator self, mfem::Array< mfem::FiniteElement const * > const & el, ElementTransformation Tr, mfem::Array< mfem::Vector const * > const & elfun, mfem::Array2D< mfem::DenseMatrix * > const & elmats)"}, { "delete_IncompressibleNeoHookeanIntegrator", _wrap_delete_IncompressibleNeoHookeanIntegrator, METH_O, "delete_IncompressibleNeoHookeanIntegrator(IncompressibleNeoHookeanIntegrator self)"}, { "IncompressibleNeoHookeanIntegrator_swigregister", IncompressibleNeoHookeanIntegrator_swigregister, METH_O, NULL}, { "IncompressibleNeoHookeanIntegrator_swiginit", IncompressibleNeoHookeanIntegrator_swiginit, METH_VARARGS, NULL}, @@ -7802,15 +7810,15 @@ static PyMethodDef SwigMethods_proxydocs[] = { "VectorConvectionNLFIntegrator(Coefficient q)\n" "new_VectorConvectionNLFIntegrator() -> VectorConvectionNLFIntegrator\n" ""}, - { "VectorConvectionNLFIntegrator_GetRule", _wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS, "GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, - { "VectorConvectionNLFIntegrator_AssembleElementVector", _wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS, "AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, - { "VectorConvectionNLFIntegrator_AssembleElementGrad", _wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS, "AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, + { "VectorConvectionNLFIntegrator_GetRule", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_GetRule, METH_VARARGS|METH_KEYWORDS, "GetRule(FiniteElement fe, ElementTransformation T) -> IntegrationRule"}, + { "VectorConvectionNLFIntegrator_AssembleElementVector", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementVector, METH_VARARGS|METH_KEYWORDS, "AssembleElementVector(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, Vector elvect)"}, + { "VectorConvectionNLFIntegrator_AssembleElementGrad", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AssembleElementGrad, METH_VARARGS|METH_KEYWORDS, "AssembleElementGrad(VectorConvectionNLFIntegrator self, FiniteElement el, ElementTransformation trans, Vector elfun, DenseMatrix elmat)"}, { "VectorConvectionNLFIntegrator_AssemblePA", _wrap_VectorConvectionNLFIntegrator_AssemblePA, METH_VARARGS, "\n" "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace trial_fes, FiniteElementSpace test_fes)\n" "AssemblePA(VectorConvectionNLFIntegrator self, FiniteElementSpace fes)\n" ""}, - { "VectorConvectionNLFIntegrator_AddMultPA", _wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS, "AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, + { "VectorConvectionNLFIntegrator_AddMultPA", (PyCFunction)(void(*)(void))_wrap_VectorConvectionNLFIntegrator_AddMultPA, METH_VARARGS|METH_KEYWORDS, "AddMultPA(VectorConvectionNLFIntegrator self, Vector x, Vector y)"}, { "delete_VectorConvectionNLFIntegrator", _wrap_delete_VectorConvectionNLFIntegrator, METH_O, "delete_VectorConvectionNLFIntegrator(VectorConvectionNLFIntegrator self)"}, { "VectorConvectionNLFIntegrator_swigregister", VectorConvectionNLFIntegrator_swigregister, METH_O, NULL}, { "VectorConvectionNLFIntegrator_swiginit", VectorConvectionNLFIntegrator_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/ode.py b/mfem/_ser/ode.py index 24005df9..f1dc0b44 100644 --- a/mfem/_ser/ode.py +++ b/mfem/_ser/ode.py @@ -128,9 +128,9 @@ class RK2Solver(ODESolver): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(RK2Solver self, double const _a=2./3.) -> RK2Solver""" - _ode.RK2Solver_swiginit(self, _ode.new_RK2Solver(*args)) + _ode.RK2Solver_swiginit(self, _ode.new_RK2Solver(*args, **kwargs)) def Init(self, _f): r"""Init(RK2Solver self, TimeDependentOperator _f)""" @@ -701,9 +701,9 @@ def __init__(self, beta_=0.25, gamma_=0.5): r"""__init__(NewmarkSolver self, double beta_=0.25, double gamma_=0.5) -> NewmarkSolver""" _ode.NewmarkSolver_swiginit(self, _ode.new_NewmarkSolver(beta_, gamma_)) - def PrintProperties(self, *args): + def PrintProperties(self, *args, **kwargs): r"""PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)""" - return _ode.NewmarkSolver_PrintProperties(self, *args) + return _ode.NewmarkSolver_PrintProperties(self, *args, **kwargs) PrintProperties = _swig_new_instance_method(_ode.NewmarkSolver_PrintProperties) def Init(self, _f): @@ -772,9 +772,9 @@ def __init__(self, rho_inf=1.0): r"""__init__(GeneralizedAlpha2Solver self, double rho_inf=1.0) -> GeneralizedAlpha2Solver""" _ode.GeneralizedAlpha2Solver_swiginit(self, _ode.new_GeneralizedAlpha2Solver(rho_inf)) - def PrintProperties(self, *args): + def PrintProperties(self, *args, **kwargs): r"""PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)""" - return _ode.GeneralizedAlpha2Solver_PrintProperties(self, *args) + return _ode.GeneralizedAlpha2Solver_PrintProperties(self, *args, **kwargs) PrintProperties = _swig_new_instance_method(_ode.GeneralizedAlpha2Solver_PrintProperties) def Init(self, _f): diff --git a/mfem/_ser/ode_wrap.cxx b/mfem/_ser/ode_wrap.cxx index b1b58a3b..28ddae6e 100644 --- a/mfem/_ser/ode_wrap.cxx +++ b/mfem/_ser/ode_wrap.cxx @@ -3290,7 +3290,7 @@ SWIG_AsVal_double (PyObject *obj, double *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ODESolver *arg1 = (mfem::ODESolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -3298,15 +3298,19 @@ SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ODESolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ODESolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ODESolver_Init" "', argument " "1"" of type '" "mfem::ODESolver *""'"); } arg1 = reinterpret_cast< mfem::ODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ODESolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -3340,7 +3344,7 @@ SWIGINTERN PyObject *_wrap_ODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ODESolver *arg1 = (mfem::ODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3352,15 +3356,21 @@ SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ODESolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ODESolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ODESolver_Step" "', argument " "1"" of type '" "mfem::ODESolver *""'"); } arg1 = reinterpret_cast< mfem::ODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3369,11 +3379,11 @@ SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -3408,7 +3418,7 @@ SWIGINTERN PyObject *_wrap_ODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ODESolver *arg1 = (mfem::ODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3423,15 +3433,22 @@ SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec double dtemp4 ; double val5 ; int ecode5 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", (char *)"tf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ODESolver_Run", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:ODESolver_Run", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ODESolver_Run" "', argument " "1"" of type '" "mfem::ODESolver *""'"); } arg1 = reinterpret_cast< mfem::ODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3440,14 +3457,14 @@ SWIGINTERN PyObject *_wrap_ODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_double(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ODESolver_Run" "', argument " "5"" of type '" "double""'"); } @@ -3531,7 +3548,7 @@ SWIGINTERN PyObject *ODESolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ForwardEulerSolver *arg1 = (mfem::ForwardEulerSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -3539,15 +3556,19 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ForwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ForwardEulerSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::ForwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::ForwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -3581,7 +3602,7 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ForwardEulerSolver *arg1 = (mfem::ForwardEulerSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3593,15 +3614,21 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ForwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ForwardEulerSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ForwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ForwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::ForwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::ForwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ForwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3610,11 +3637,11 @@ SWIGINTERN PyObject *_wrap_ForwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -3731,53 +3758,28 @@ SWIGINTERN PyObject *ForwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RK2Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RK2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) (double)2./3. ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_a", NULL + }; mfem::RK2Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RK2Solver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::RK2Solver *)new mfem::RK2Solver(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_RK2Solver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RK2Solver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RK2Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RK2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::RK2Solver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::RK2Solver *)new mfem::RK2Solver(); + result = (mfem::RK2Solver *)new mfem::RK2Solver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3801,38 +3803,7 @@ SWIGINTERN PyObject *_wrap_new_RK2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_RK2Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RK2Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_RK2Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_RK2Solver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RK2Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RK2Solver::RK2Solver(double const)\n" - " mfem::RK2Solver::RK2Solver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK2Solver *arg1 = (mfem::RK2Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -3840,15 +3811,19 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK2Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RK2Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK2Solver_Init" "', argument " "1"" of type '" "mfem::RK2Solver *""'"); } arg1 = reinterpret_cast< mfem::RK2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK2Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -3882,7 +3857,7 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK2Solver *arg1 = (mfem::RK2Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3894,15 +3869,21 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK2Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RK2Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK2Solver_Step" "', argument " "1"" of type '" "mfem::RK2Solver *""'"); } arg1 = reinterpret_cast< mfem::RK2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -3911,11 +3892,11 @@ SWIGINTERN PyObject *_wrap_RK2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -4001,7 +3982,7 @@ SWIGINTERN PyObject *RK2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK3SSPSolver *arg1 = (mfem::RK3SSPSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -4009,15 +3990,19 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK3SSPSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RK3SSPSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK3SSPSolver_Init" "', argument " "1"" of type '" "mfem::RK3SSPSolver *""'"); } arg1 = reinterpret_cast< mfem::RK3SSPSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK3SSPSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -4051,7 +4036,7 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK3SSPSolver *arg1 = (mfem::RK3SSPSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4063,15 +4048,21 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK3SSPSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RK3SSPSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK3SSPSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK3SSPSolver_Step" "', argument " "1"" of type '" "mfem::RK3SSPSolver *""'"); } arg1 = reinterpret_cast< mfem::RK3SSPSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK3SSPSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4080,11 +4071,11 @@ SWIGINTERN PyObject *_wrap_RK3SSPSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyO } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -4201,7 +4192,7 @@ SWIGINTERN PyObject *RK3SSPSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK4Solver *arg1 = (mfem::RK4Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -4209,15 +4200,19 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK4Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:RK4Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK4Solver_Init" "', argument " "1"" of type '" "mfem::RK4Solver *""'"); } arg1 = reinterpret_cast< mfem::RK4Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK4Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -4251,7 +4246,7 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RK4Solver *arg1 = (mfem::RK4Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4263,15 +4258,21 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RK4Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:RK4Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RK4Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RK4Solver_Step" "', argument " "1"" of type '" "mfem::RK4Solver *""'"); } arg1 = reinterpret_cast< mfem::RK4Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RK4Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4280,11 +4281,11 @@ SWIGINTERN PyObject *_wrap_RK4Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -4401,7 +4402,7 @@ SWIGINTERN PyObject *RK4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; @@ -4413,27 +4414,33 @@ SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"_s", (char *)"_a", (char *)"_b", (char *)"_c", NULL + }; mfem::ExplicitRKSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ExplicitRKSolver", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_ExplicitRKSolver", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ExplicitRKSolver" "', argument " "2"" of type '" "double const *""'"); } arg2 = reinterpret_cast< double * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_double, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_ExplicitRKSolver" "', argument " "3"" of type '" "double const *""'"); } arg3 = reinterpret_cast< double * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_double, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_ExplicitRKSolver" "', argument " "4"" of type '" "double const *""'"); } @@ -4464,7 +4471,7 @@ SWIGINTERN PyObject *_wrap_new_ExplicitRKSolver(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ExplicitRKSolver *arg1 = (mfem::ExplicitRKSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -4472,15 +4479,19 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ExplicitRKSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ExplicitRKSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExplicitRKSolver_Init" "', argument " "1"" of type '" "mfem::ExplicitRKSolver *""'"); } arg1 = reinterpret_cast< mfem::ExplicitRKSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExplicitRKSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -4514,7 +4525,7 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Init(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ExplicitRKSolver *arg1 = (mfem::ExplicitRKSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4526,15 +4537,21 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ExplicitRKSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ExplicitRKSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ExplicitRKSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ExplicitRKSolver_Step" "', argument " "1"" of type '" "mfem::ExplicitRKSolver *""'"); } arg1 = reinterpret_cast< mfem::ExplicitRKSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ExplicitRKSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4543,11 +4560,11 @@ SWIGINTERN PyObject *_wrap_ExplicitRKSolver_Step(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -4797,23 +4814,27 @@ SWIGINTERN PyObject *RK8Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_s", (char *)"_a", NULL + }; mfem::AdamsBashforthSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_AdamsBashforthSolver", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_AdamsBashforthSolver", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsBashforthSolver" "', argument " "2"" of type '" "double const *""'"); } @@ -4844,7 +4865,7 @@ SWIGINTERN PyObject *_wrap_new_AdamsBashforthSolver(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -4852,15 +4873,19 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:AdamsBashforthSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Init" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -4894,7 +4919,7 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Init(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsBashforthSolver *arg1 = (mfem::AdamsBashforthSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4906,15 +4931,21 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsBashforthSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AdamsBashforthSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsBashforthSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsBashforthSolver_Step" "', argument " "1"" of type '" "mfem::AdamsBashforthSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsBashforthSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsBashforthSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -4923,11 +4954,11 @@ SWIGINTERN PyObject *_wrap_AdamsBashforthSolver_Step(PyObject *SWIGUNUSEDPARM(se } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -5423,23 +5454,27 @@ SWIGINTERN PyObject *AB5Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; double *arg2 = (double *) 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"_s", (char *)"_a", NULL + }; mfem::AdamsMoultonSolver *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_AdamsMoultonSolver", 2, 2, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_AdamsMoultonSolver", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_AdamsMoultonSolver" "', argument " "2"" of type '" "double const *""'"); } @@ -5470,7 +5505,7 @@ SWIGINTERN PyObject *_wrap_new_AdamsMoultonSolver(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -5478,15 +5513,19 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:AdamsMoultonSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Init" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -5520,7 +5559,7 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Init(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AdamsMoultonSolver *arg1 = (mfem::AdamsMoultonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5532,15 +5571,21 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "AdamsMoultonSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:AdamsMoultonSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__AdamsMoultonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AdamsMoultonSolver_Step" "', argument " "1"" of type '" "mfem::AdamsMoultonSolver *""'"); } arg1 = reinterpret_cast< mfem::AdamsMoultonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AdamsMoultonSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -5549,11 +5594,11 @@ SWIGINTERN PyObject *_wrap_AdamsMoultonSolver_Step(PyObject *SWIGUNUSEDPARM(self } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6049,7 +6094,7 @@ SWIGINTERN PyObject *AM4Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6057,15 +6102,19 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BackwardEulerSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Init" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6099,7 +6148,7 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Init(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BackwardEulerSolver *arg1 = (mfem::BackwardEulerSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6111,15 +6160,21 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BackwardEulerSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:BackwardEulerSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BackwardEulerSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BackwardEulerSolver_Step" "', argument " "1"" of type '" "mfem::BackwardEulerSolver *""'"); } arg1 = reinterpret_cast< mfem::BackwardEulerSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BackwardEulerSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6128,11 +6183,11 @@ SWIGINTERN PyObject *_wrap_BackwardEulerSolver_Step(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6249,7 +6304,7 @@ SWIGINTERN PyObject *BackwardEulerSolver_swiginit(PyObject *SWIGUNUSEDPARM(self) return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6257,15 +6312,19 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ImplicitMidpointSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Init" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6299,7 +6358,7 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Init(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ImplicitMidpointSolver *arg1 = (mfem::ImplicitMidpointSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6311,15 +6370,21 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ImplicitMidpointSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ImplicitMidpointSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ImplicitMidpointSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImplicitMidpointSolver_Step" "', argument " "1"" of type '" "mfem::ImplicitMidpointSolver *""'"); } arg1 = reinterpret_cast< mfem::ImplicitMidpointSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ImplicitMidpointSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6328,11 +6393,11 @@ SWIGINTERN PyObject *_wrap_ImplicitMidpointSolver_Step(PyObject *SWIGUNUSEDPARM( } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6449,52 +6514,27 @@ SWIGINTERN PyObject *ImplicitMidpointSolver_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; + int arg1 = (int) 1 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"gamma_opt", NULL + }; mfem::SDIRK23Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_SDIRK23Solver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(obj0); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SDIRK23Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::SDIRK23Solver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(); + result = (mfem::SDIRK23Solver *)new mfem::SDIRK23Solver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6518,42 +6558,7 @@ SWIGINTERN PyObject *_wrap_new_SDIRK23Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_new_SDIRK23Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_SDIRK23Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_SDIRK23Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SDIRK23Solver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SDIRK23Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SDIRK23Solver::SDIRK23Solver(int)\n" - " mfem::SDIRK23Solver::SDIRK23Solver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6561,15 +6566,19 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SDIRK23Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6603,7 +6612,7 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK23Solver *arg1 = (mfem::SDIRK23Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6615,15 +6624,21 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK23Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SDIRK23Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK23Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK23Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK23Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK23Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK23Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6632,11 +6647,11 @@ SWIGINTERN PyObject *_wrap_SDIRK23Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6722,7 +6737,7 @@ SWIGINTERN PyObject *SDIRK23Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6730,15 +6745,19 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SDIRK34Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6772,7 +6791,7 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK34Solver *arg1 = (mfem::SDIRK34Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6784,15 +6803,21 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK34Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SDIRK34Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK34Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK34Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK34Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK34Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK34Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6801,11 +6826,11 @@ SWIGINTERN PyObject *_wrap_SDIRK34Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -6922,7 +6947,7 @@ SWIGINTERN PyObject *SDIRK34Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -6930,15 +6955,19 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SDIRK33Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Init" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -6972,7 +7001,7 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Init(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SDIRK33Solver *arg1 = (mfem::SDIRK33Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6984,15 +7013,21 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SDIRK33Solver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SDIRK33Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SDIRK33Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SDIRK33Solver_Step" "', argument " "1"" of type '" "mfem::SDIRK33Solver *""'"); } arg1 = reinterpret_cast< mfem::SDIRK33Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SDIRK33Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7001,11 +7036,11 @@ SWIGINTERN PyObject *_wrap_SDIRK33Solver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -7122,53 +7157,28 @@ SWIGINTERN PyObject *SDIRK33Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyOb return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"rho", NULL + }; mfem::GeneralizedAlphaSolver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_GeneralizedAlphaSolver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlphaSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::GeneralizedAlphaSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(); + result = (mfem::GeneralizedAlphaSolver *)new mfem::GeneralizedAlphaSolver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7192,38 +7202,7 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver__SWIG_1(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GeneralizedAlphaSolver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver(double)\n" - " mfem::GeneralizedAlphaSolver::GeneralizedAlphaSolver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; mfem::TimeDependentOperator *arg2 = 0 ; @@ -7231,15 +7210,19 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeneralizedAlphaSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Init" "', argument " "2"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -7273,7 +7256,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Init(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlphaSolver *arg1 = (mfem::GeneralizedAlphaSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7285,15 +7268,21 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; double temp3 ; double dtemp4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlphaSolver_Step", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GeneralizedAlphaSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlphaSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlphaSolver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlphaSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlphaSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7302,11 +7291,11 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlphaSolver_Step(PyObject *SWIGUNUSEDPARM( } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - temp3 = PyFloat_AsDouble(swig_obj[2]); + temp3 = PyFloat_AsDouble(obj2); arg3 = &temp3; } { - dtemp4 = PyFloat_AsDouble(swig_obj[3]); + dtemp4 = PyFloat_AsDouble(obj3); arg4 = &dtemp4; } { @@ -7392,7 +7381,7 @@ SWIGINTERN PyObject *GeneralizedAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(se return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -7403,15 +7392,20 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"P", (char *)"F", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Init", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SIASolver_Init", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Init" "', argument " "1"" of type '" "mfem::SIASolver *""'"); } arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); } @@ -7419,7 +7413,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Init" "', argument " "2"" of type '" "mfem::Operator &""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__TimeDependentOperator, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Init" "', argument " "3"" of type '" "mfem::TimeDependentOperator &""'"); } @@ -7453,7 +7447,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7468,15 +7462,22 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIASolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Step" "', argument " "1"" of type '" "mfem::SIASolver *""'"); } arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7484,7 +7485,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7493,11 +7494,11 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7532,7 +7533,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIASolver *arg1 = (mfem::SIASolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7550,15 +7551,23 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec double dtemp5 ; double val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", (char *)"tf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIASolver_Run", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:SIASolver_Run", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIASolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIASolver_Run" "', argument " "1"" of type '" "mfem::SIASolver *""'"); } arg1 = reinterpret_cast< mfem::SIASolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7566,7 +7575,7 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIASolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIASolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7575,14 +7584,14 @@ SWIGINTERN PyObject *_wrap_SIASolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObjec } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_double(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SIASolver_Run" "', argument " "6"" of type '" "double""'"); } @@ -7697,7 +7706,7 @@ SWIGINTERN PyObject *_wrap_new_SIA1Solver(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIA1Solver *arg1 = (mfem::SIA1Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7712,15 +7721,22 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIA1Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIA1Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIA1Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA1Solver_Step" "', argument " "1"" of type '" "mfem::SIA1Solver *""'"); } arg1 = reinterpret_cast< mfem::SIA1Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7728,7 +7744,7 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA1Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA1Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7737,11 +7753,11 @@ SWIGINTERN PyObject *_wrap_SIA1Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7858,7 +7874,7 @@ SWIGINTERN PyObject *_wrap_new_SIA2Solver(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIA2Solver *arg1 = (mfem::SIA2Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7873,15 +7889,22 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIA2Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIA2Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIA2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIA2Solver_Step" "', argument " "1"" of type '" "mfem::SIA2Solver *""'"); } arg1 = reinterpret_cast< mfem::SIA2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -7889,7 +7912,7 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIA2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIA2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7898,11 +7921,11 @@ SWIGINTERN PyObject *_wrap_SIA2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -7988,19 +8011,21 @@ SWIGINTERN PyObject *SIA2Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"order", NULL + }; mfem::SIAVSolver *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_SIAVSolver", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -8028,7 +8053,7 @@ SWIGINTERN PyObject *_wrap_new_SIAVSolver(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SIAVSolver *arg1 = (mfem::SIAVSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8043,15 +8068,22 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"q", (char *)"p", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SIAVSolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SIAVSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SIAVSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SIAVSolver_Step" "', argument " "1"" of type '" "mfem::SIAVSolver *""'"); } arg1 = reinterpret_cast< mfem::SIAVSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8059,7 +8091,7 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SIAVSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SIAVSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8068,11 +8100,11 @@ SWIGINTERN PyObject *_wrap_SIAVSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObj } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -8158,7 +8190,7 @@ SWIGINTERN PyObject *SIAVSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; @@ -8166,15 +8198,19 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SecondOrderODESolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Init" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); } arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); } @@ -8208,7 +8244,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Init(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8223,15 +8259,22 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SecondOrderODESolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Step" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); } arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8239,7 +8282,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8248,11 +8291,11 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -8287,7 +8330,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Step(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SecondOrderODESolver *arg1 = (mfem::SecondOrderODESolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8305,15 +8348,23 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(sel double dtemp5 ; double val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", (char *)"tf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SecondOrderODESolver_Run", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:SecondOrderODESolver_Run", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SecondOrderODESolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SecondOrderODESolver_Run" "', argument " "1"" of type '" "mfem::SecondOrderODESolver *""'"); } arg1 = reinterpret_cast< mfem::SecondOrderODESolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8321,7 +8372,7 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SecondOrderODESolver_Run" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SecondOrderODESolver_Run" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8330,14 +8381,14 @@ SWIGINTERN PyObject *_wrap_SecondOrderODESolver_Run(PyObject *SWIGUNUSEDPARM(sel } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_double(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SecondOrderODESolver_Run" "', argument " "6"" of type '" "double""'"); } @@ -8421,27 +8472,36 @@ SWIGINTERN PyObject *SecondOrderODESolver_swigregister(PyObject *SWIGUNUSEDPARM( return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_NewmarkSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; - double arg2 ; + double arg1 = (double) 0.25 ; + double arg2 = (double) 0.5 ; double val1 ; int ecode1 = 0 ; double val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"beta_", (char *)"gamma_", NULL + }; mfem::NewmarkSolver *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewmarkSolver" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_NewmarkSolver", kwnames, &obj0, &obj1)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); + } + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NewmarkSolver" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + } { try { result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1,arg2); @@ -8468,22 +8528,47 @@ SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; - double val1 ; - int ecode1 = 0 ; - mfem::NewmarkSolver *result = 0 ; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + void *argp1 = 0 ; + int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NewmarkSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:NewmarkSolver_PrintProperties", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + if (obj1) { + { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(arg1); + (arg1)->PrintProperties(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8500,21 +8585,54 @@ SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { +SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::NewmarkSolver *result = 0 ; + mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; + mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewmarkSolver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Init" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); + } + arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); + } + arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); { try { - result = (mfem::NewmarkSolver *)new mfem::NewmarkSolver(); + (arg1)->Init(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8531,263 +8649,14 @@ SWIGINTERN PyObject *_wrap_new_NewmarkSolver__SWIG_2(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__NewmarkSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_NewmarkSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_NewmarkSolver", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_NewmarkSolver__SWIG_2(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_NewmarkSolver__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_NewmarkSolver__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_NewmarkSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NewmarkSolver::NewmarkSolver(double,double)\n" - " mfem::NewmarkSolver::NewmarkSolver(double)\n" - " mfem::NewmarkSolver::NewmarkSolver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); - } - arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - (arg1)->PrintProperties(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_PrintProperties" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); - } - arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - { - try { - (arg1)->PrintProperties(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_PrintProperties(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "NewmarkSolver_PrintProperties", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_NewmarkSolver_PrintProperties__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__NewmarkSolver, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_NewmarkSolver_PrintProperties__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'NewmarkSolver_PrintProperties'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::NewmarkSolver::PrintProperties(std::ostream &)\n" - " mfem::NewmarkSolver::PrintProperties()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; - mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Init" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); - } - arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); - } - arg2 = reinterpret_cast< mfem::SecondOrderTimeDependentOperator * >(argp2); - { - try { - (arg1)->Init(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewmarkSolver *arg1 = (mfem::NewmarkSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8802,15 +8671,22 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), Py int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewmarkSolver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:NewmarkSolver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewmarkSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewmarkSolver_Step" "', argument " "1"" of type '" "mfem::NewmarkSolver *""'"); } arg1 = reinterpret_cast< mfem::NewmarkSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8818,7 +8694,7 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewmarkSolver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewmarkSolver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8827,11 +8703,11 @@ SWIGINTERN PyObject *_wrap_NewmarkSolver_Step(PyObject *SWIGUNUSEDPARM(self), Py } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -9163,53 +9039,28 @@ SWIGINTERN PyObject *FoxGoodwinSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"rho_inf", NULL + }; mfem::GeneralizedAlpha2Solver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_GeneralizedAlpha2Solver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GeneralizedAlpha2Solver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::GeneralizedAlpha2Solver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(); + result = (mfem::GeneralizedAlpha2Solver *)new mfem::GeneralizedAlpha2Solver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9233,65 +9084,42 @@ SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver__SWIG_1(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_new_GeneralizedAlpha2Solver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_GeneralizedAlpha2Solver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_GeneralizedAlpha2Solver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_GeneralizedAlpha2Solver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GeneralizedAlpha2Solver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver(double)\n" - " mfem::GeneralizedAlpha2Solver::GeneralizedAlpha2Solver()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"out", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:GeneralizedAlpha2Solver_PrintProperties", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (obj1) { + { + if (SWIG_ConvertPtr(obj1, (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -9330,92 +9158,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_PrintProperties" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); - } - arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - { - try { - (arg1)->PrintProperties(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_PrintProperties(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_PrintProperties", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GeneralizedAlpha2Solver_PrintProperties__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GeneralizedAlpha2Solver_PrintProperties'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GeneralizedAlpha2Solver::PrintProperties(std::ostream &)\n" - " mfem::GeneralizedAlpha2Solver::PrintProperties()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; mfem::SecondOrderTimeDependentOperator *arg2 = 0 ; @@ -9423,15 +9166,19 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Init", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GeneralizedAlpha2Solver_Init", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Init" "', argument " "2"" of type '" "mfem::SecondOrderTimeDependentOperator &""'"); } @@ -9465,7 +9212,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Init(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GeneralizedAlpha2Solver *arg1 = (mfem::GeneralizedAlpha2Solver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9480,15 +9227,22 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM int res3 = 0 ; double temp4 ; double dtemp5 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"dxdt", (char *)"t", (char *)"dt", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GeneralizedAlpha2Solver_Step", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:GeneralizedAlpha2Solver_Step", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GeneralizedAlpha2Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "1"" of type '" "mfem::GeneralizedAlpha2Solver *""'"); } arg1 = reinterpret_cast< mfem::GeneralizedAlpha2Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -9496,7 +9250,7 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GeneralizedAlpha2Solver_Step" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9505,11 +9259,11 @@ SWIGINTERN PyObject *_wrap_GeneralizedAlpha2Solver_Step(PyObject *SWIGUNUSEDPARM } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - temp4 = PyFloat_AsDouble(swig_obj[3]); + temp4 = PyFloat_AsDouble(obj3); arg4 = &temp4; } { - dtemp5 = PyFloat_AsDouble(swig_obj[4]); + dtemp5 = PyFloat_AsDouble(obj4); arg5 = &dtemp5; } { @@ -9677,53 +9431,28 @@ SWIGINTERN PyObject *AverageAccelerationSolver_swiginit(PyObject *SWIGUNUSEDPARM return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"alpha", NULL + }; mfem::HHTAlphaSolver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HHTAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_HHTAlphaSolver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HHTAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__HHTAlphaSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::HHTAlphaSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(); + result = (mfem::HHTAlphaSolver *)new mfem::HHTAlphaSolver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9747,37 +9476,6 @@ SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_HHTAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_HHTAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_HHTAlphaSolver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_HHTAlphaSolver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HHTAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::HHTAlphaSolver::HHTAlphaSolver(double)\n" - " mfem::HHTAlphaSolver::HHTAlphaSolver()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_HHTAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::HHTAlphaSolver *arg1 = (mfem::HHTAlphaSolver *) 0 ; @@ -9829,53 +9527,28 @@ SWIGINTERN PyObject *HHTAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - double arg1 ; + double arg1 = (double) 1.0 ; double val1 ; int ecode1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"rho_inf", NULL + }; mfem::WBZAlphaSolver *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WBZAlphaSolver" "', argument " "1"" of type '" "double""'"); - } - arg1 = static_cast< double >(val1); - { - try { - result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_WBZAlphaSolver", kwnames, &obj0)) SWIG_fail; + if (obj0) { + ecode1 = SWIG_AsVal_double(obj0, &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_WBZAlphaSolver" "', argument " "1"" of type '" "double""'"); + } + arg1 = static_cast< double >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__WBZAlphaSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::WBZAlphaSolver *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(); + result = (mfem::WBZAlphaSolver *)new mfem::WBZAlphaSolver(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9899,37 +9572,6 @@ SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_WBZAlphaSolver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[2] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_WBZAlphaSolver", 0, 1, argv))) SWIG_fail; - --argc; - if (argc == 0) { - return _wrap_new_WBZAlphaSolver__SWIG_1(self, argc, argv); - } - if (argc == 1) { - int _v; - { - int res = SWIG_AsVal_double(argv[0], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_WBZAlphaSolver__SWIG_0(self, argc, argv); - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_WBZAlphaSolver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::WBZAlphaSolver::WBZAlphaSolver(double)\n" - " mfem::WBZAlphaSolver::WBZAlphaSolver()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_delete_WBZAlphaSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::WBZAlphaSolver *arg1 = (mfem::WBZAlphaSolver *) 0 ; @@ -9984,38 +9626,38 @@ SWIGINTERN PyObject *WBZAlphaSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "ODESolver_Init(ODESolver self, TimeDependentOperator f)"}, - { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "ODESolver_Step(ODESolver self, Vector x, double & t, double & dt)"}, - { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "ODESolver_Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, + { "ODESolver_Init", (PyCFunction)(void(*)(void))_wrap_ODESolver_Init, METH_VARARGS|METH_KEYWORDS, "ODESolver_Init(ODESolver self, TimeDependentOperator f)"}, + { "ODESolver_Step", (PyCFunction)(void(*)(void))_wrap_ODESolver_Step, METH_VARARGS|METH_KEYWORDS, "ODESolver_Step(ODESolver self, Vector x, double & t, double & dt)"}, + { "ODESolver_Run", (PyCFunction)(void(*)(void))_wrap_ODESolver_Run, METH_VARARGS|METH_KEYWORDS, "ODESolver_Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, { "delete_ODESolver", _wrap_delete_ODESolver, METH_O, "delete_ODESolver(ODESolver self)"}, { "ODESolver_swigregister", ODESolver_swigregister, METH_O, NULL}, - { "ForwardEulerSolver_Init", _wrap_ForwardEulerSolver_Init, METH_VARARGS, "ForwardEulerSolver_Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, - { "ForwardEulerSolver_Step", _wrap_ForwardEulerSolver_Step, METH_VARARGS, "ForwardEulerSolver_Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "ForwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "ForwardEulerSolver_Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, + { "ForwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "ForwardEulerSolver_Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_ForwardEulerSolver", _wrap_new_ForwardEulerSolver, METH_NOARGS, "new_ForwardEulerSolver() -> ForwardEulerSolver"}, { "delete_ForwardEulerSolver", _wrap_delete_ForwardEulerSolver, METH_O, "delete_ForwardEulerSolver(ForwardEulerSolver self)"}, { "ForwardEulerSolver_swigregister", ForwardEulerSolver_swigregister, METH_O, NULL}, { "ForwardEulerSolver_swiginit", ForwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "new_RK2Solver", _wrap_new_RK2Solver, METH_VARARGS, "RK2Solver(double const _a=2./3.)"}, - { "RK2Solver_Init", _wrap_RK2Solver_Init, METH_VARARGS, "RK2Solver_Init(RK2Solver self, TimeDependentOperator _f)"}, - { "RK2Solver_Step", _wrap_RK2Solver_Step, METH_VARARGS, "RK2Solver_Step(RK2Solver self, Vector x, double & t, double & dt)"}, + { "new_RK2Solver", (PyCFunction)(void(*)(void))_wrap_new_RK2Solver, METH_VARARGS|METH_KEYWORDS, "new_RK2Solver(double const _a=2./3.) -> RK2Solver"}, + { "RK2Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Init, METH_VARARGS|METH_KEYWORDS, "RK2Solver_Init(RK2Solver self, TimeDependentOperator _f)"}, + { "RK2Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Step, METH_VARARGS|METH_KEYWORDS, "RK2Solver_Step(RK2Solver self, Vector x, double & t, double & dt)"}, { "delete_RK2Solver", _wrap_delete_RK2Solver, METH_O, "delete_RK2Solver(RK2Solver self)"}, { "RK2Solver_swigregister", RK2Solver_swigregister, METH_O, NULL}, { "RK2Solver_swiginit", RK2Solver_swiginit, METH_VARARGS, NULL}, - { "RK3SSPSolver_Init", _wrap_RK3SSPSolver_Init, METH_VARARGS, "RK3SSPSolver_Init(RK3SSPSolver self, TimeDependentOperator _f)"}, - { "RK3SSPSolver_Step", _wrap_RK3SSPSolver_Step, METH_VARARGS, "RK3SSPSolver_Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, + { "RK3SSPSolver_Init", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Init, METH_VARARGS|METH_KEYWORDS, "RK3SSPSolver_Init(RK3SSPSolver self, TimeDependentOperator _f)"}, + { "RK3SSPSolver_Step", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Step, METH_VARARGS|METH_KEYWORDS, "RK3SSPSolver_Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, { "new_RK3SSPSolver", _wrap_new_RK3SSPSolver, METH_NOARGS, "new_RK3SSPSolver() -> RK3SSPSolver"}, { "delete_RK3SSPSolver", _wrap_delete_RK3SSPSolver, METH_O, "delete_RK3SSPSolver(RK3SSPSolver self)"}, { "RK3SSPSolver_swigregister", RK3SSPSolver_swigregister, METH_O, NULL}, { "RK3SSPSolver_swiginit", RK3SSPSolver_swiginit, METH_VARARGS, NULL}, - { "RK4Solver_Init", _wrap_RK4Solver_Init, METH_VARARGS, "RK4Solver_Init(RK4Solver self, TimeDependentOperator _f)"}, - { "RK4Solver_Step", _wrap_RK4Solver_Step, METH_VARARGS, "RK4Solver_Step(RK4Solver self, Vector x, double & t, double & dt)"}, + { "RK4Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Init, METH_VARARGS|METH_KEYWORDS, "RK4Solver_Init(RK4Solver self, TimeDependentOperator _f)"}, + { "RK4Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Step, METH_VARARGS|METH_KEYWORDS, "RK4Solver_Step(RK4Solver self, Vector x, double & t, double & dt)"}, { "new_RK4Solver", _wrap_new_RK4Solver, METH_NOARGS, "new_RK4Solver() -> RK4Solver"}, { "delete_RK4Solver", _wrap_delete_RK4Solver, METH_O, "delete_RK4Solver(RK4Solver self)"}, { "RK4Solver_swigregister", RK4Solver_swigregister, METH_O, NULL}, { "RK4Solver_swiginit", RK4Solver_swiginit, METH_VARARGS, NULL}, - { "new_ExplicitRKSolver", _wrap_new_ExplicitRKSolver, METH_VARARGS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, - { "ExplicitRKSolver_Init", _wrap_ExplicitRKSolver_Init, METH_VARARGS, "ExplicitRKSolver_Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, - { "ExplicitRKSolver_Step", _wrap_ExplicitRKSolver_Step, METH_VARARGS, "ExplicitRKSolver_Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, + { "new_ExplicitRKSolver", (PyCFunction)(void(*)(void))_wrap_new_ExplicitRKSolver, METH_VARARGS|METH_KEYWORDS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, + { "ExplicitRKSolver_Init", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Init, METH_VARARGS|METH_KEYWORDS, "ExplicitRKSolver_Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, + { "ExplicitRKSolver_Step", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Step, METH_VARARGS|METH_KEYWORDS, "ExplicitRKSolver_Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, { "delete_ExplicitRKSolver", _wrap_delete_ExplicitRKSolver, METH_O, "delete_ExplicitRKSolver(ExplicitRKSolver self)"}, { "ExplicitRKSolver_swigregister", ExplicitRKSolver_swigregister, METH_O, NULL}, { "ExplicitRKSolver_swiginit", ExplicitRKSolver_swiginit, METH_VARARGS, NULL}, @@ -10027,9 +9669,9 @@ static PyMethodDef SwigMethods[] = { { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, - { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "AdamsBashforthSolver_Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, - { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "AdamsBashforthSolver_Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsBashforthSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsBashforthSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Init, METH_VARARGS|METH_KEYWORDS, "AdamsBashforthSolver_Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Step, METH_VARARGS|METH_KEYWORDS, "AdamsBashforthSolver_Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, @@ -10053,9 +9695,9 @@ static PyMethodDef SwigMethods[] = { { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, - { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "AdamsMoultonSolver_Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, - { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "AdamsMoultonSolver_Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsMoultonSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsMoultonSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Init, METH_VARARGS|METH_KEYWORDS, "AdamsMoultonSolver_Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Step, METH_VARARGS|METH_KEYWORDS, "AdamsMoultonSolver_Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, @@ -10079,71 +9721,71 @@ static PyMethodDef SwigMethods[] = { { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, - { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "BackwardEulerSolver_Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, - { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "BackwardEulerSolver_Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "BackwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "BackwardEulerSolver_Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, + { "BackwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "BackwardEulerSolver_Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, { "delete_BackwardEulerSolver", _wrap_delete_BackwardEulerSolver, METH_O, "delete_BackwardEulerSolver(BackwardEulerSolver self)"}, { "BackwardEulerSolver_swigregister", BackwardEulerSolver_swigregister, METH_O, NULL}, { "BackwardEulerSolver_swiginit", BackwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "ImplicitMidpointSolver_Init", _wrap_ImplicitMidpointSolver_Init, METH_VARARGS, "ImplicitMidpointSolver_Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, - { "ImplicitMidpointSolver_Step", _wrap_ImplicitMidpointSolver_Step, METH_VARARGS, "ImplicitMidpointSolver_Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, + { "ImplicitMidpointSolver_Init", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Init, METH_VARARGS|METH_KEYWORDS, "ImplicitMidpointSolver_Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, + { "ImplicitMidpointSolver_Step", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Step, METH_VARARGS|METH_KEYWORDS, "ImplicitMidpointSolver_Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, { "new_ImplicitMidpointSolver", _wrap_new_ImplicitMidpointSolver, METH_NOARGS, "new_ImplicitMidpointSolver() -> ImplicitMidpointSolver"}, { "delete_ImplicitMidpointSolver", _wrap_delete_ImplicitMidpointSolver, METH_O, "delete_ImplicitMidpointSolver(ImplicitMidpointSolver self)"}, { "ImplicitMidpointSolver_swigregister", ImplicitMidpointSolver_swigregister, METH_O, NULL}, { "ImplicitMidpointSolver_swiginit", ImplicitMidpointSolver_swiginit, METH_VARARGS, NULL}, - { "new_SDIRK23Solver", _wrap_new_SDIRK23Solver, METH_VARARGS, "SDIRK23Solver(int gamma_opt=1)"}, - { "SDIRK23Solver_Init", _wrap_SDIRK23Solver_Init, METH_VARARGS, "SDIRK23Solver_Init(SDIRK23Solver self, TimeDependentOperator _f)"}, - { "SDIRK23Solver_Step", _wrap_SDIRK23Solver_Step, METH_VARARGS, "SDIRK23Solver_Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK23Solver", (PyCFunction)(void(*)(void))_wrap_new_SDIRK23Solver, METH_VARARGS|METH_KEYWORDS, "new_SDIRK23Solver(int gamma_opt=1) -> SDIRK23Solver"}, + { "SDIRK23Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Init, METH_VARARGS|METH_KEYWORDS, "SDIRK23Solver_Init(SDIRK23Solver self, TimeDependentOperator _f)"}, + { "SDIRK23Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Step, METH_VARARGS|METH_KEYWORDS, "SDIRK23Solver_Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, { "delete_SDIRK23Solver", _wrap_delete_SDIRK23Solver, METH_O, "delete_SDIRK23Solver(SDIRK23Solver self)"}, { "SDIRK23Solver_swigregister", SDIRK23Solver_swigregister, METH_O, NULL}, { "SDIRK23Solver_swiginit", SDIRK23Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK34Solver_Init", _wrap_SDIRK34Solver_Init, METH_VARARGS, "SDIRK34Solver_Init(SDIRK34Solver self, TimeDependentOperator _f)"}, - { "SDIRK34Solver_Step", _wrap_SDIRK34Solver_Step, METH_VARARGS, "SDIRK34Solver_Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK34Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Init, METH_VARARGS|METH_KEYWORDS, "SDIRK34Solver_Init(SDIRK34Solver self, TimeDependentOperator _f)"}, + { "SDIRK34Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Step, METH_VARARGS|METH_KEYWORDS, "SDIRK34Solver_Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK34Solver", _wrap_new_SDIRK34Solver, METH_NOARGS, "new_SDIRK34Solver() -> SDIRK34Solver"}, { "delete_SDIRK34Solver", _wrap_delete_SDIRK34Solver, METH_O, "delete_SDIRK34Solver(SDIRK34Solver self)"}, { "SDIRK34Solver_swigregister", SDIRK34Solver_swigregister, METH_O, NULL}, { "SDIRK34Solver_swiginit", SDIRK34Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK33Solver_Init", _wrap_SDIRK33Solver_Init, METH_VARARGS, "SDIRK33Solver_Init(SDIRK33Solver self, TimeDependentOperator _f)"}, - { "SDIRK33Solver_Step", _wrap_SDIRK33Solver_Step, METH_VARARGS, "SDIRK33Solver_Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK33Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Init, METH_VARARGS|METH_KEYWORDS, "SDIRK33Solver_Init(SDIRK33Solver self, TimeDependentOperator _f)"}, + { "SDIRK33Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Step, METH_VARARGS|METH_KEYWORDS, "SDIRK33Solver_Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK33Solver", _wrap_new_SDIRK33Solver, METH_NOARGS, "new_SDIRK33Solver() -> SDIRK33Solver"}, { "delete_SDIRK33Solver", _wrap_delete_SDIRK33Solver, METH_O, "delete_SDIRK33Solver(SDIRK33Solver self)"}, { "SDIRK33Solver_swigregister", SDIRK33Solver_swigregister, METH_O, NULL}, { "SDIRK33Solver_swiginit", SDIRK33Solver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlphaSolver", _wrap_new_GeneralizedAlphaSolver, METH_VARARGS, "GeneralizedAlphaSolver(double rho=1.0)"}, - { "GeneralizedAlphaSolver_Init", _wrap_GeneralizedAlphaSolver_Init, METH_VARARGS, "GeneralizedAlphaSolver_Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, - { "GeneralizedAlphaSolver_Step", _wrap_GeneralizedAlphaSolver_Step, METH_VARARGS, "GeneralizedAlphaSolver_Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, + { "new_GeneralizedAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlphaSolver(double rho=1.0) -> GeneralizedAlphaSolver"}, + { "GeneralizedAlphaSolver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Init, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlphaSolver_Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, + { "GeneralizedAlphaSolver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Step, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlphaSolver_Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, { "delete_GeneralizedAlphaSolver", _wrap_delete_GeneralizedAlphaSolver, METH_O, "delete_GeneralizedAlphaSolver(GeneralizedAlphaSolver self)"}, { "GeneralizedAlphaSolver_swigregister", GeneralizedAlphaSolver_swigregister, METH_O, NULL}, { "GeneralizedAlphaSolver_swiginit", GeneralizedAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "SIASolver_Init", _wrap_SIASolver_Init, METH_VARARGS, "SIASolver_Init(SIASolver self, Operator P, TimeDependentOperator F)"}, - { "SIASolver_Step", _wrap_SIASolver_Step, METH_VARARGS, "SIASolver_Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, - { "SIASolver_Run", _wrap_SIASolver_Run, METH_VARARGS, "SIASolver_Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, + { "SIASolver_Init", (PyCFunction)(void(*)(void))_wrap_SIASolver_Init, METH_VARARGS|METH_KEYWORDS, "SIASolver_Init(SIASolver self, Operator P, TimeDependentOperator F)"}, + { "SIASolver_Step", (PyCFunction)(void(*)(void))_wrap_SIASolver_Step, METH_VARARGS|METH_KEYWORDS, "SIASolver_Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIASolver_Run", (PyCFunction)(void(*)(void))_wrap_SIASolver_Run, METH_VARARGS|METH_KEYWORDS, "SIASolver_Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, { "delete_SIASolver", _wrap_delete_SIASolver, METH_O, "delete_SIASolver(SIASolver self)"}, { "SIASolver_swigregister", SIASolver_swigregister, METH_O, NULL}, { "new_SIA1Solver", _wrap_new_SIA1Solver, METH_NOARGS, "new_SIA1Solver() -> SIA1Solver"}, - { "SIA1Solver_Step", _wrap_SIA1Solver_Step, METH_VARARGS, "SIA1Solver_Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA1Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA1Solver_Step, METH_VARARGS|METH_KEYWORDS, "SIA1Solver_Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA1Solver", _wrap_delete_SIA1Solver, METH_O, "delete_SIA1Solver(SIA1Solver self)"}, { "SIA1Solver_swigregister", SIA1Solver_swigregister, METH_O, NULL}, { "SIA1Solver_swiginit", SIA1Solver_swiginit, METH_VARARGS, NULL}, { "new_SIA2Solver", _wrap_new_SIA2Solver, METH_NOARGS, "new_SIA2Solver() -> SIA2Solver"}, - { "SIA2Solver_Step", _wrap_SIA2Solver_Step, METH_VARARGS, "SIA2Solver_Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA2Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA2Solver_Step, METH_VARARGS|METH_KEYWORDS, "SIA2Solver_Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA2Solver", _wrap_delete_SIA2Solver, METH_O, "delete_SIA2Solver(SIA2Solver self)"}, { "SIA2Solver_swigregister", SIA2Solver_swigregister, METH_O, NULL}, { "SIA2Solver_swiginit", SIA2Solver_swiginit, METH_VARARGS, NULL}, - { "new_SIAVSolver", _wrap_new_SIAVSolver, METH_O, "new_SIAVSolver(int order) -> SIAVSolver"}, - { "SIAVSolver_Step", _wrap_SIAVSolver_Step, METH_VARARGS, "SIAVSolver_Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, + { "new_SIAVSolver", (PyCFunction)(void(*)(void))_wrap_new_SIAVSolver, METH_VARARGS|METH_KEYWORDS, "new_SIAVSolver(int order) -> SIAVSolver"}, + { "SIAVSolver_Step", (PyCFunction)(void(*)(void))_wrap_SIAVSolver_Step, METH_VARARGS|METH_KEYWORDS, "SIAVSolver_Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, - { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "SecondOrderODESolver_Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, - { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "SecondOrderODESolver_Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, - { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "SecondOrderODESolver_Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "SecondOrderODESolver_Init", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Init, METH_VARARGS|METH_KEYWORDS, "SecondOrderODESolver_Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Step, METH_VARARGS|METH_KEYWORDS, "SecondOrderODESolver_Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Run, METH_VARARGS|METH_KEYWORDS, "SecondOrderODESolver_Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, - { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, - { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "NewmarkSolver_PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, - { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "NewmarkSolver_Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, - { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "NewmarkSolver_Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_NewmarkSolver", (PyCFunction)(void(*)(void))_wrap_new_NewmarkSolver, METH_VARARGS|METH_KEYWORDS, "new_NewmarkSolver(double beta_=0.25, double gamma_=0.5) -> NewmarkSolver"}, + { "NewmarkSolver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "NewmarkSolver_PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Init, METH_VARARGS|METH_KEYWORDS, "NewmarkSolver_Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Step, METH_VARARGS|METH_KEYWORDS, "NewmarkSolver_Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, @@ -10159,10 +9801,10 @@ static PyMethodDef SwigMethods[] = { { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, - { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "GeneralizedAlpha2Solver_PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, - { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "GeneralizedAlpha2Solver_Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, - { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "GeneralizedAlpha2Solver_Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_GeneralizedAlpha2Solver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlpha2Solver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlpha2Solver(double rho_inf=1.0) -> GeneralizedAlpha2Solver"}, + { "GeneralizedAlpha2Solver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlpha2Solver_PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlpha2Solver_Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS|METH_KEYWORDS, "GeneralizedAlpha2Solver_Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, @@ -10170,11 +9812,11 @@ static PyMethodDef SwigMethods[] = { { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, - { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "new_HHTAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_HHTAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_HHTAlphaSolver(double alpha=1.0) -> HHTAlphaSolver"}, { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "new_WBZAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_WBZAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_WBZAlphaSolver(double rho_inf=1.0) -> WBZAlphaSolver"}, { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, @@ -10184,38 +9826,38 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "ODESolver_Init", _wrap_ODESolver_Init, METH_VARARGS, "Init(ODESolver self, TimeDependentOperator f)"}, - { "ODESolver_Step", _wrap_ODESolver_Step, METH_VARARGS, "Step(ODESolver self, Vector x, double & t, double & dt)"}, - { "ODESolver_Run", _wrap_ODESolver_Run, METH_VARARGS, "Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, + { "ODESolver_Init", (PyCFunction)(void(*)(void))_wrap_ODESolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ODESolver self, TimeDependentOperator f)"}, + { "ODESolver_Step", (PyCFunction)(void(*)(void))_wrap_ODESolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ODESolver self, Vector x, double & t, double & dt)"}, + { "ODESolver_Run", (PyCFunction)(void(*)(void))_wrap_ODESolver_Run, METH_VARARGS|METH_KEYWORDS, "Run(ODESolver self, Vector x, double & t, double & dt, double tf)"}, { "delete_ODESolver", _wrap_delete_ODESolver, METH_O, "delete_ODESolver(ODESolver self)"}, { "ODESolver_swigregister", ODESolver_swigregister, METH_O, NULL}, - { "ForwardEulerSolver_Init", _wrap_ForwardEulerSolver_Init, METH_VARARGS, "Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, - { "ForwardEulerSolver_Step", _wrap_ForwardEulerSolver_Step, METH_VARARGS, "Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "ForwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ForwardEulerSolver self, TimeDependentOperator _f)"}, + { "ForwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_ForwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ForwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_ForwardEulerSolver", _wrap_new_ForwardEulerSolver, METH_NOARGS, "new_ForwardEulerSolver() -> ForwardEulerSolver"}, { "delete_ForwardEulerSolver", _wrap_delete_ForwardEulerSolver, METH_O, "delete_ForwardEulerSolver(ForwardEulerSolver self)"}, { "ForwardEulerSolver_swigregister", ForwardEulerSolver_swigregister, METH_O, NULL}, { "ForwardEulerSolver_swiginit", ForwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "new_RK2Solver", _wrap_new_RK2Solver, METH_VARARGS, "RK2Solver(double const _a=2./3.)"}, - { "RK2Solver_Init", _wrap_RK2Solver_Init, METH_VARARGS, "Init(RK2Solver self, TimeDependentOperator _f)"}, - { "RK2Solver_Step", _wrap_RK2Solver_Step, METH_VARARGS, "Step(RK2Solver self, Vector x, double & t, double & dt)"}, + { "new_RK2Solver", (PyCFunction)(void(*)(void))_wrap_new_RK2Solver, METH_VARARGS|METH_KEYWORDS, "new_RK2Solver(double const _a=2./3.) -> RK2Solver"}, + { "RK2Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(RK2Solver self, TimeDependentOperator _f)"}, + { "RK2Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK2Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(RK2Solver self, Vector x, double & t, double & dt)"}, { "delete_RK2Solver", _wrap_delete_RK2Solver, METH_O, "delete_RK2Solver(RK2Solver self)"}, { "RK2Solver_swigregister", RK2Solver_swigregister, METH_O, NULL}, { "RK2Solver_swiginit", RK2Solver_swiginit, METH_VARARGS, NULL}, - { "RK3SSPSolver_Init", _wrap_RK3SSPSolver_Init, METH_VARARGS, "Init(RK3SSPSolver self, TimeDependentOperator _f)"}, - { "RK3SSPSolver_Step", _wrap_RK3SSPSolver_Step, METH_VARARGS, "Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, + { "RK3SSPSolver_Init", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(RK3SSPSolver self, TimeDependentOperator _f)"}, + { "RK3SSPSolver_Step", (PyCFunction)(void(*)(void))_wrap_RK3SSPSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(RK3SSPSolver self, Vector x, double & t, double & dt)"}, { "new_RK3SSPSolver", _wrap_new_RK3SSPSolver, METH_NOARGS, "new_RK3SSPSolver() -> RK3SSPSolver"}, { "delete_RK3SSPSolver", _wrap_delete_RK3SSPSolver, METH_O, "delete_RK3SSPSolver(RK3SSPSolver self)"}, { "RK3SSPSolver_swigregister", RK3SSPSolver_swigregister, METH_O, NULL}, { "RK3SSPSolver_swiginit", RK3SSPSolver_swiginit, METH_VARARGS, NULL}, - { "RK4Solver_Init", _wrap_RK4Solver_Init, METH_VARARGS, "Init(RK4Solver self, TimeDependentOperator _f)"}, - { "RK4Solver_Step", _wrap_RK4Solver_Step, METH_VARARGS, "Step(RK4Solver self, Vector x, double & t, double & dt)"}, + { "RK4Solver_Init", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(RK4Solver self, TimeDependentOperator _f)"}, + { "RK4Solver_Step", (PyCFunction)(void(*)(void))_wrap_RK4Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(RK4Solver self, Vector x, double & t, double & dt)"}, { "new_RK4Solver", _wrap_new_RK4Solver, METH_NOARGS, "new_RK4Solver() -> RK4Solver"}, { "delete_RK4Solver", _wrap_delete_RK4Solver, METH_O, "delete_RK4Solver(RK4Solver self)"}, { "RK4Solver_swigregister", RK4Solver_swigregister, METH_O, NULL}, { "RK4Solver_swiginit", RK4Solver_swiginit, METH_VARARGS, NULL}, - { "new_ExplicitRKSolver", _wrap_new_ExplicitRKSolver, METH_VARARGS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, - { "ExplicitRKSolver_Init", _wrap_ExplicitRKSolver_Init, METH_VARARGS, "Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, - { "ExplicitRKSolver_Step", _wrap_ExplicitRKSolver_Step, METH_VARARGS, "Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, + { "new_ExplicitRKSolver", (PyCFunction)(void(*)(void))_wrap_new_ExplicitRKSolver, METH_VARARGS|METH_KEYWORDS, "new_ExplicitRKSolver(int _s, double const * _a, double const * _b, double const * _c) -> ExplicitRKSolver"}, + { "ExplicitRKSolver_Init", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ExplicitRKSolver self, TimeDependentOperator _f)"}, + { "ExplicitRKSolver_Step", (PyCFunction)(void(*)(void))_wrap_ExplicitRKSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ExplicitRKSolver self, Vector x, double & t, double & dt)"}, { "delete_ExplicitRKSolver", _wrap_delete_ExplicitRKSolver, METH_O, "delete_ExplicitRKSolver(ExplicitRKSolver self)"}, { "ExplicitRKSolver_swigregister", ExplicitRKSolver_swigregister, METH_O, NULL}, { "ExplicitRKSolver_swiginit", ExplicitRKSolver_swiginit, METH_VARARGS, NULL}, @@ -10227,9 +9869,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_RK8Solver", _wrap_delete_RK8Solver, METH_O, "delete_RK8Solver(RK8Solver self)"}, { "RK8Solver_swigregister", RK8Solver_swigregister, METH_O, NULL}, { "RK8Solver_swiginit", RK8Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsBashforthSolver", _wrap_new_AdamsBashforthSolver, METH_VARARGS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, - { "AdamsBashforthSolver_Init", _wrap_AdamsBashforthSolver_Init, METH_VARARGS, "Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, - { "AdamsBashforthSolver_Step", _wrap_AdamsBashforthSolver_Step, METH_VARARGS, "Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsBashforthSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsBashforthSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsBashforthSolver(int _s, double const * _a) -> AdamsBashforthSolver"}, + { "AdamsBashforthSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(AdamsBashforthSolver self, TimeDependentOperator _f)"}, + { "AdamsBashforthSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsBashforthSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(AdamsBashforthSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsBashforthSolver", _wrap_delete_AdamsBashforthSolver, METH_O, "delete_AdamsBashforthSolver(AdamsBashforthSolver self)"}, { "AdamsBashforthSolver_swigregister", AdamsBashforthSolver_swigregister, METH_O, NULL}, { "AdamsBashforthSolver_swiginit", AdamsBashforthSolver_swiginit, METH_VARARGS, NULL}, @@ -10253,9 +9895,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_AB5Solver", _wrap_delete_AB5Solver, METH_O, "delete_AB5Solver(AB5Solver self)"}, { "AB5Solver_swigregister", AB5Solver_swigregister, METH_O, NULL}, { "AB5Solver_swiginit", AB5Solver_swiginit, METH_VARARGS, NULL}, - { "new_AdamsMoultonSolver", _wrap_new_AdamsMoultonSolver, METH_VARARGS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, - { "AdamsMoultonSolver_Init", _wrap_AdamsMoultonSolver_Init, METH_VARARGS, "Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, - { "AdamsMoultonSolver_Step", _wrap_AdamsMoultonSolver_Step, METH_VARARGS, "Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, + { "new_AdamsMoultonSolver", (PyCFunction)(void(*)(void))_wrap_new_AdamsMoultonSolver, METH_VARARGS|METH_KEYWORDS, "new_AdamsMoultonSolver(int _s, double const * _a) -> AdamsMoultonSolver"}, + { "AdamsMoultonSolver_Init", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(AdamsMoultonSolver self, TimeDependentOperator _f)"}, + { "AdamsMoultonSolver_Step", (PyCFunction)(void(*)(void))_wrap_AdamsMoultonSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(AdamsMoultonSolver self, Vector x, double & t, double & dt)"}, { "delete_AdamsMoultonSolver", _wrap_delete_AdamsMoultonSolver, METH_O, "delete_AdamsMoultonSolver(AdamsMoultonSolver self)"}, { "AdamsMoultonSolver_swigregister", AdamsMoultonSolver_swigregister, METH_O, NULL}, { "AdamsMoultonSolver_swiginit", AdamsMoultonSolver_swiginit, METH_VARARGS, NULL}, @@ -10279,71 +9921,71 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_AM4Solver", _wrap_delete_AM4Solver, METH_O, "delete_AM4Solver(AM4Solver self)"}, { "AM4Solver_swigregister", AM4Solver_swigregister, METH_O, NULL}, { "AM4Solver_swiginit", AM4Solver_swiginit, METH_VARARGS, NULL}, - { "BackwardEulerSolver_Init", _wrap_BackwardEulerSolver_Init, METH_VARARGS, "Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, - { "BackwardEulerSolver_Step", _wrap_BackwardEulerSolver_Step, METH_VARARGS, "Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, + { "BackwardEulerSolver_Init", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(BackwardEulerSolver self, TimeDependentOperator _f)"}, + { "BackwardEulerSolver_Step", (PyCFunction)(void(*)(void))_wrap_BackwardEulerSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(BackwardEulerSolver self, Vector x, double & t, double & dt)"}, { "new_BackwardEulerSolver", _wrap_new_BackwardEulerSolver, METH_NOARGS, "new_BackwardEulerSolver() -> BackwardEulerSolver"}, { "delete_BackwardEulerSolver", _wrap_delete_BackwardEulerSolver, METH_O, "delete_BackwardEulerSolver(BackwardEulerSolver self)"}, { "BackwardEulerSolver_swigregister", BackwardEulerSolver_swigregister, METH_O, NULL}, { "BackwardEulerSolver_swiginit", BackwardEulerSolver_swiginit, METH_VARARGS, NULL}, - { "ImplicitMidpointSolver_Init", _wrap_ImplicitMidpointSolver_Init, METH_VARARGS, "Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, - { "ImplicitMidpointSolver_Step", _wrap_ImplicitMidpointSolver_Step, METH_VARARGS, "Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, + { "ImplicitMidpointSolver_Init", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(ImplicitMidpointSolver self, TimeDependentOperator _f)"}, + { "ImplicitMidpointSolver_Step", (PyCFunction)(void(*)(void))_wrap_ImplicitMidpointSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(ImplicitMidpointSolver self, Vector x, double & t, double & dt)"}, { "new_ImplicitMidpointSolver", _wrap_new_ImplicitMidpointSolver, METH_NOARGS, "new_ImplicitMidpointSolver() -> ImplicitMidpointSolver"}, { "delete_ImplicitMidpointSolver", _wrap_delete_ImplicitMidpointSolver, METH_O, "delete_ImplicitMidpointSolver(ImplicitMidpointSolver self)"}, { "ImplicitMidpointSolver_swigregister", ImplicitMidpointSolver_swigregister, METH_O, NULL}, { "ImplicitMidpointSolver_swiginit", ImplicitMidpointSolver_swiginit, METH_VARARGS, NULL}, - { "new_SDIRK23Solver", _wrap_new_SDIRK23Solver, METH_VARARGS, "SDIRK23Solver(int gamma_opt=1)"}, - { "SDIRK23Solver_Init", _wrap_SDIRK23Solver_Init, METH_VARARGS, "Init(SDIRK23Solver self, TimeDependentOperator _f)"}, - { "SDIRK23Solver_Step", _wrap_SDIRK23Solver_Step, METH_VARARGS, "Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, + { "new_SDIRK23Solver", (PyCFunction)(void(*)(void))_wrap_new_SDIRK23Solver, METH_VARARGS|METH_KEYWORDS, "new_SDIRK23Solver(int gamma_opt=1) -> SDIRK23Solver"}, + { "SDIRK23Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SDIRK23Solver self, TimeDependentOperator _f)"}, + { "SDIRK23Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK23Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SDIRK23Solver self, Vector x, double & t, double & dt)"}, { "delete_SDIRK23Solver", _wrap_delete_SDIRK23Solver, METH_O, "delete_SDIRK23Solver(SDIRK23Solver self)"}, { "SDIRK23Solver_swigregister", SDIRK23Solver_swigregister, METH_O, NULL}, { "SDIRK23Solver_swiginit", SDIRK23Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK34Solver_Init", _wrap_SDIRK34Solver_Init, METH_VARARGS, "Init(SDIRK34Solver self, TimeDependentOperator _f)"}, - { "SDIRK34Solver_Step", _wrap_SDIRK34Solver_Step, METH_VARARGS, "Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK34Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SDIRK34Solver self, TimeDependentOperator _f)"}, + { "SDIRK34Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK34Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SDIRK34Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK34Solver", _wrap_new_SDIRK34Solver, METH_NOARGS, "new_SDIRK34Solver() -> SDIRK34Solver"}, { "delete_SDIRK34Solver", _wrap_delete_SDIRK34Solver, METH_O, "delete_SDIRK34Solver(SDIRK34Solver self)"}, { "SDIRK34Solver_swigregister", SDIRK34Solver_swigregister, METH_O, NULL}, { "SDIRK34Solver_swiginit", SDIRK34Solver_swiginit, METH_VARARGS, NULL}, - { "SDIRK33Solver_Init", _wrap_SDIRK33Solver_Init, METH_VARARGS, "Init(SDIRK33Solver self, TimeDependentOperator _f)"}, - { "SDIRK33Solver_Step", _wrap_SDIRK33Solver_Step, METH_VARARGS, "Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, + { "SDIRK33Solver_Init", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SDIRK33Solver self, TimeDependentOperator _f)"}, + { "SDIRK33Solver_Step", (PyCFunction)(void(*)(void))_wrap_SDIRK33Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SDIRK33Solver self, Vector x, double & t, double & dt)"}, { "new_SDIRK33Solver", _wrap_new_SDIRK33Solver, METH_NOARGS, "new_SDIRK33Solver() -> SDIRK33Solver"}, { "delete_SDIRK33Solver", _wrap_delete_SDIRK33Solver, METH_O, "delete_SDIRK33Solver(SDIRK33Solver self)"}, { "SDIRK33Solver_swigregister", SDIRK33Solver_swigregister, METH_O, NULL}, { "SDIRK33Solver_swiginit", SDIRK33Solver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlphaSolver", _wrap_new_GeneralizedAlphaSolver, METH_VARARGS, "GeneralizedAlphaSolver(double rho=1.0)"}, - { "GeneralizedAlphaSolver_Init", _wrap_GeneralizedAlphaSolver_Init, METH_VARARGS, "Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, - { "GeneralizedAlphaSolver_Step", _wrap_GeneralizedAlphaSolver_Step, METH_VARARGS, "Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, + { "new_GeneralizedAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlphaSolver(double rho=1.0) -> GeneralizedAlphaSolver"}, + { "GeneralizedAlphaSolver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(GeneralizedAlphaSolver self, TimeDependentOperator _f)"}, + { "GeneralizedAlphaSolver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlphaSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(GeneralizedAlphaSolver self, Vector x, double & t, double & dt)"}, { "delete_GeneralizedAlphaSolver", _wrap_delete_GeneralizedAlphaSolver, METH_O, "delete_GeneralizedAlphaSolver(GeneralizedAlphaSolver self)"}, { "GeneralizedAlphaSolver_swigregister", GeneralizedAlphaSolver_swigregister, METH_O, NULL}, { "GeneralizedAlphaSolver_swiginit", GeneralizedAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "SIASolver_Init", _wrap_SIASolver_Init, METH_VARARGS, "Init(SIASolver self, Operator P, TimeDependentOperator F)"}, - { "SIASolver_Step", _wrap_SIASolver_Step, METH_VARARGS, "Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, - { "SIASolver_Run", _wrap_SIASolver_Run, METH_VARARGS, "Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, + { "SIASolver_Init", (PyCFunction)(void(*)(void))_wrap_SIASolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SIASolver self, Operator P, TimeDependentOperator F)"}, + { "SIASolver_Step", (PyCFunction)(void(*)(void))_wrap_SIASolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIASolver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIASolver_Run", (PyCFunction)(void(*)(void))_wrap_SIASolver_Run, METH_VARARGS|METH_KEYWORDS, "Run(SIASolver self, Vector q, Vector p, double & t, double & dt, double tf)"}, { "delete_SIASolver", _wrap_delete_SIASolver, METH_O, "delete_SIASolver(SIASolver self)"}, { "SIASolver_swigregister", SIASolver_swigregister, METH_O, NULL}, { "new_SIA1Solver", _wrap_new_SIA1Solver, METH_NOARGS, "new_SIA1Solver() -> SIA1Solver"}, - { "SIA1Solver_Step", _wrap_SIA1Solver_Step, METH_VARARGS, "Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA1Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA1Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIA1Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA1Solver", _wrap_delete_SIA1Solver, METH_O, "delete_SIA1Solver(SIA1Solver self)"}, { "SIA1Solver_swigregister", SIA1Solver_swigregister, METH_O, NULL}, { "SIA1Solver_swiginit", SIA1Solver_swiginit, METH_VARARGS, NULL}, { "new_SIA2Solver", _wrap_new_SIA2Solver, METH_NOARGS, "new_SIA2Solver() -> SIA2Solver"}, - { "SIA2Solver_Step", _wrap_SIA2Solver_Step, METH_VARARGS, "Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, + { "SIA2Solver_Step", (PyCFunction)(void(*)(void))_wrap_SIA2Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIA2Solver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIA2Solver", _wrap_delete_SIA2Solver, METH_O, "delete_SIA2Solver(SIA2Solver self)"}, { "SIA2Solver_swigregister", SIA2Solver_swigregister, METH_O, NULL}, { "SIA2Solver_swiginit", SIA2Solver_swiginit, METH_VARARGS, NULL}, - { "new_SIAVSolver", _wrap_new_SIAVSolver, METH_O, "new_SIAVSolver(int order) -> SIAVSolver"}, - { "SIAVSolver_Step", _wrap_SIAVSolver_Step, METH_VARARGS, "Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, + { "new_SIAVSolver", (PyCFunction)(void(*)(void))_wrap_new_SIAVSolver, METH_VARARGS|METH_KEYWORDS, "new_SIAVSolver(int order) -> SIAVSolver"}, + { "SIAVSolver_Step", (PyCFunction)(void(*)(void))_wrap_SIAVSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SIAVSolver self, Vector q, Vector p, double & t, double & dt)"}, { "delete_SIAVSolver", _wrap_delete_SIAVSolver, METH_O, "delete_SIAVSolver(SIAVSolver self)"}, { "SIAVSolver_swigregister", SIAVSolver_swigregister, METH_O, NULL}, { "SIAVSolver_swiginit", SIAVSolver_swiginit, METH_VARARGS, NULL}, - { "SecondOrderODESolver_Init", _wrap_SecondOrderODESolver_Init, METH_VARARGS, "Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, - { "SecondOrderODESolver_Step", _wrap_SecondOrderODESolver_Step, METH_VARARGS, "Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, - { "SecondOrderODESolver_Run", _wrap_SecondOrderODESolver_Run, METH_VARARGS, "Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, + { "SecondOrderODESolver_Init", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(SecondOrderODESolver self, SecondOrderTimeDependentOperator f)"}, + { "SecondOrderODESolver_Step", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "SecondOrderODESolver_Run", (PyCFunction)(void(*)(void))_wrap_SecondOrderODESolver_Run, METH_VARARGS|METH_KEYWORDS, "Run(SecondOrderODESolver self, Vector x, Vector dxdt, double & t, double & dt, double tf)"}, { "delete_SecondOrderODESolver", _wrap_delete_SecondOrderODESolver, METH_O, "delete_SecondOrderODESolver(SecondOrderODESolver self)"}, { "SecondOrderODESolver_swigregister", SecondOrderODESolver_swigregister, METH_O, NULL}, - { "new_NewmarkSolver", _wrap_new_NewmarkSolver, METH_VARARGS, "NewmarkSolver(double beta_=0.25, double gamma_=0.5)"}, - { "NewmarkSolver_PrintProperties", _wrap_NewmarkSolver_PrintProperties, METH_VARARGS, "PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, - { "NewmarkSolver_Init", _wrap_NewmarkSolver_Init, METH_VARARGS, "Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, - { "NewmarkSolver_Step", _wrap_NewmarkSolver_Step, METH_VARARGS, "Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_NewmarkSolver", (PyCFunction)(void(*)(void))_wrap_new_NewmarkSolver, METH_VARARGS|METH_KEYWORDS, "new_NewmarkSolver(double beta_=0.25, double gamma_=0.5) -> NewmarkSolver"}, + { "NewmarkSolver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "PrintProperties(NewmarkSolver self, std::ostream & out=mfem::out)"}, + { "NewmarkSolver_Init", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Init, METH_VARARGS|METH_KEYWORDS, "Init(NewmarkSolver self, SecondOrderTimeDependentOperator _f)"}, + { "NewmarkSolver_Step", (PyCFunction)(void(*)(void))_wrap_NewmarkSolver_Step, METH_VARARGS|METH_KEYWORDS, "Step(NewmarkSolver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_NewmarkSolver", _wrap_delete_NewmarkSolver, METH_O, "delete_NewmarkSolver(NewmarkSolver self)"}, { "NewmarkSolver_swigregister", NewmarkSolver_swigregister, METH_O, NULL}, { "NewmarkSolver_swiginit", NewmarkSolver_swiginit, METH_VARARGS, NULL}, @@ -10359,10 +10001,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_FoxGoodwinSolver", _wrap_delete_FoxGoodwinSolver, METH_O, "delete_FoxGoodwinSolver(FoxGoodwinSolver self)"}, { "FoxGoodwinSolver_swigregister", FoxGoodwinSolver_swigregister, METH_O, NULL}, { "FoxGoodwinSolver_swiginit", FoxGoodwinSolver_swiginit, METH_VARARGS, NULL}, - { "new_GeneralizedAlpha2Solver", _wrap_new_GeneralizedAlpha2Solver, METH_VARARGS, "GeneralizedAlpha2Solver(double rho_inf=1.0)"}, - { "GeneralizedAlpha2Solver_PrintProperties", _wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS, "PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, - { "GeneralizedAlpha2Solver_Init", _wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS, "Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, - { "GeneralizedAlpha2Solver_Step", _wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS, "Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, + { "new_GeneralizedAlpha2Solver", (PyCFunction)(void(*)(void))_wrap_new_GeneralizedAlpha2Solver, METH_VARARGS|METH_KEYWORDS, "new_GeneralizedAlpha2Solver(double rho_inf=1.0) -> GeneralizedAlpha2Solver"}, + { "GeneralizedAlpha2Solver_PrintProperties", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_PrintProperties, METH_VARARGS|METH_KEYWORDS, "PrintProperties(GeneralizedAlpha2Solver self, std::ostream & out=mfem::out)"}, + { "GeneralizedAlpha2Solver_Init", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Init, METH_VARARGS|METH_KEYWORDS, "Init(GeneralizedAlpha2Solver self, SecondOrderTimeDependentOperator _f)"}, + { "GeneralizedAlpha2Solver_Step", (PyCFunction)(void(*)(void))_wrap_GeneralizedAlpha2Solver_Step, METH_VARARGS|METH_KEYWORDS, "Step(GeneralizedAlpha2Solver self, Vector x, Vector dxdt, double & t, double & dt)"}, { "delete_GeneralizedAlpha2Solver", _wrap_delete_GeneralizedAlpha2Solver, METH_O, "delete_GeneralizedAlpha2Solver(GeneralizedAlpha2Solver self)"}, { "GeneralizedAlpha2Solver_swigregister", GeneralizedAlpha2Solver_swigregister, METH_O, NULL}, { "GeneralizedAlpha2Solver_swiginit", GeneralizedAlpha2Solver_swiginit, METH_VARARGS, NULL}, @@ -10370,11 +10012,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_AverageAccelerationSolver", _wrap_delete_AverageAccelerationSolver, METH_O, "delete_AverageAccelerationSolver(AverageAccelerationSolver self)"}, { "AverageAccelerationSolver_swigregister", AverageAccelerationSolver_swigregister, METH_O, NULL}, { "AverageAccelerationSolver_swiginit", AverageAccelerationSolver_swiginit, METH_VARARGS, NULL}, - { "new_HHTAlphaSolver", _wrap_new_HHTAlphaSolver, METH_VARARGS, "HHTAlphaSolver(double alpha=1.0)"}, + { "new_HHTAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_HHTAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_HHTAlphaSolver(double alpha=1.0) -> HHTAlphaSolver"}, { "delete_HHTAlphaSolver", _wrap_delete_HHTAlphaSolver, METH_O, "delete_HHTAlphaSolver(HHTAlphaSolver self)"}, { "HHTAlphaSolver_swigregister", HHTAlphaSolver_swigregister, METH_O, NULL}, { "HHTAlphaSolver_swiginit", HHTAlphaSolver_swiginit, METH_VARARGS, NULL}, - { "new_WBZAlphaSolver", _wrap_new_WBZAlphaSolver, METH_VARARGS, "WBZAlphaSolver(double rho_inf=1.0)"}, + { "new_WBZAlphaSolver", (PyCFunction)(void(*)(void))_wrap_new_WBZAlphaSolver, METH_VARARGS|METH_KEYWORDS, "new_WBZAlphaSolver(double rho_inf=1.0) -> WBZAlphaSolver"}, { "delete_WBZAlphaSolver", _wrap_delete_WBZAlphaSolver, METH_O, "delete_WBZAlphaSolver(WBZAlphaSolver self)"}, { "WBZAlphaSolver_swigregister", WBZAlphaSolver_swigregister, METH_O, NULL}, { "WBZAlphaSolver_swiginit", WBZAlphaSolver_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/operators_wrap.cxx b/mfem/_ser/operators_wrap.cxx index 33b3b5f1..94dbb8ab 100644 --- a/mfem/_ser/operators_wrap.cxx +++ b/mfem/_ser/operators_wrap.cxx @@ -3502,7 +3502,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Operator_PrintMatlab__SWIG_3(mfem::Operator *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Operator_PrintMatlab__SWIG_1(mfem::Operator *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -6190,7 +6190,7 @@ mfem::Vector &SwigDirector_PyTimeDependentOperatorBase::_EvalMult(mfem::Vector c #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -6216,30 +6216,40 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"Po", (char *)"Ri", (char *)"Pi", (char *)"x", (char *)"b", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_InitTVectors", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:Operator_InitTVectors", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_InitTVectors" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_InitTVectors" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_InitTVectors" "', argument " "3"" of type '" "mfem::Operator const *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_InitTVectors" "', argument " "4"" of type '" "mfem::Operator const *""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -6247,7 +6257,7 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -6255,7 +6265,7 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -6263,7 +6273,7 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_InitTVectors" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_InitTVectors" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -6300,16 +6310,18 @@ SWIGINTERN PyObject *_wrap_Operator_InitTVectors(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; + int arg2 = (int) 0 ; mfem::Operator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -6345,46 +6357,6 @@ SWIGINTERN PyObject *_wrap_new_Operator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_Operator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::Operator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Operator *)new SwigDirector_Operator(arg1); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Operator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; @@ -6446,17 +6418,13 @@ SWIGINTERN PyObject *_wrap_new_Operator(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_Operator", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_Operator__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; _v = (argv[0] != 0); if (_v) { + if (argc <= 1) { + return _wrap_new_Operator__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6492,7 +6460,7 @@ SWIGINTERN PyObject *_wrap_new_Operator(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Operator__SWIG_2(self, argc, argv); + return _wrap_new_Operator__SWIG_1(self, argc, argv); } } } @@ -6502,7 +6470,6 @@ SWIGINTERN PyObject *_wrap_new_Operator(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Operator'.\n" " Possible C/C++ prototypes are:\n" " mfem::Operator::Operator(int)\n" - " mfem::Operator::Operator()\n" " mfem::Operator::Operator(PyObject *,int,int)\n"); return 0; } @@ -6725,7 +6692,7 @@ SWIGINTERN PyObject *_wrap_Operator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6736,17 +6703,22 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Operator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Operator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_Mult" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6754,7 +6726,7 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6763,7 +6735,7 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6798,7 +6770,7 @@ SWIGINTERN PyObject *_wrap_Operator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6809,17 +6781,22 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Operator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Operator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_MultTranspose" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6827,7 +6804,7 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -6836,7 +6813,7 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -6871,7 +6848,7 @@ SWIGINTERN PyObject *_wrap_Operator_MultTranspose(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6879,18 +6856,22 @@ SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Operator_GetGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Operator_GetGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_GetGradient" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_GetGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6899,7 +6880,7 @@ SWIGINTERN PyObject *_wrap_Operator_GetGradient(PyObject *SWIGUNUSEDPARM(self), } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -7191,7 +7172,7 @@ SWIGINTERN PyObject *_wrap_Operator_GetOutputRestriction(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7200,7 +7181,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE mfem::Operator **arg5 = 0 ; mfem::Vector *arg6 = 0 ; mfem::Vector *arg7 = 0 ; - int arg8 ; + int arg8 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -7215,14 +7196,25 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE int res6 = 0 ; void *argp7 = 0 ; int res7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", (char *)"copy_interior", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO|O:Operator_FormLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7230,7 +7222,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -7238,7 +7230,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7246,7 +7238,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } @@ -7254,7 +7246,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } @@ -7262,7 +7254,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); } arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -7270,119 +7262,17 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_0(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj7) { + { + if ((PyArray_PyIntAsInt(obj7) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg8 = PyArray_PyIntAsInt(obj7); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - mfem::Operator **arg5 = 0 ; - mfem::Vector *arg6 = 0 ; - mfem::Vector *arg7 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_p_mfem__Operator, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "5"" of type '" "mfem::Operator *&""'"); - } - arg5 = reinterpret_cast< mfem::Operator ** >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "6"" of type '" "mfem::Vector &""'"); - } - arg6 = reinterpret_cast< mfem::Vector * >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); - } - arg7 = reinterpret_cast< mfem::Vector * >(argp7); { try { - (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); + (arg1)->FormLinearSystem((mfem::Array< int > const &)*arg2,*arg3,*arg4,*arg5,*arg6,*arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7406,111 +7296,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_Operator_FormLinearSystem(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Operator_FormLinearSystem", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 7) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Operator_FormLinearSystem__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Operator_FormLinearSystem__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Operator_FormLinearSystem'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &,int)\n" - " mfem::Operator::FormLinearSystem(mfem::Array< int > const &,mfem::Vector &,mfem::Vector &,mfem::Operator *&,mfem::Vector &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7536,15 +7322,25 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN int res7 = 0 ; void *argp8 = 0 ; int res8 = 0 ; - PyObject *swig_obj[8] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"x", (char *)"b", (char *)"A", (char *)"X", (char *)"B", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularLinearSystem", 8, 8, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:Operator_FormRectangularLinearSystem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7552,7 +7348,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -7560,7 +7356,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7568,7 +7364,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_mfem__Vector, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } @@ -7576,7 +7372,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "5"" of type '" "mfem::Vector &""'"); } arg5 = reinterpret_cast< mfem::Vector * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); + res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res6)) { SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } @@ -7584,7 +7380,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "6"" of type '" "mfem::Operator *&""'"); } arg6 = reinterpret_cast< mfem::Operator ** >(argp6); - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_mfem__Vector, 0 ); + res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res7)) { SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } @@ -7592,7 +7388,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularLinearSystem" "', argument " "7"" of type '" "mfem::Vector &""'"); } arg7 = reinterpret_cast< mfem::Vector * >(argp7); - res8 = SWIG_ConvertPtr(swig_obj[7], &argp8, SWIGTYPE_p_mfem__Vector, 0 ); + res8 = SWIG_ConvertPtr(obj7, &argp8, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res8)) { SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "Operator_FormRectangularLinearSystem" "', argument " "8"" of type '" "mfem::Vector &""'"); } @@ -7626,7 +7422,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularLinearSystem(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -7640,17 +7436,23 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"X", (char *)"b", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Operator_RecoverFEMSolution", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Operator_RecoverFEMSolution", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_RecoverFEMSolution" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -7658,7 +7460,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_RecoverFEMSolution" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -7666,7 +7468,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_RecoverFEMSolution" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_RecoverFEMSolution" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -7675,7 +7477,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -7710,7 +7512,7 @@ SWIGINTERN PyObject *_wrap_Operator_RecoverFEMSolution(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7721,15 +7523,20 @@ SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ess_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormSystemOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Operator_FormSystemOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7737,7 +7544,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormSystemOperator" "', argument " "3"" of type '" "mfem::Operator *&""'"); } @@ -7771,7 +7578,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormSystemOperator(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7785,15 +7592,21 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"trial_tdof_list", (char *)"test_tdof_list", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormRectangularSystemOperator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Operator_FormRectangularSystemOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7801,7 +7614,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -7809,7 +7622,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Operator_FormRectangularSystemOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Operator_FormRectangularSystemOperator" "', argument " "4"" of type '" "mfem::Operator *&""'"); } @@ -7843,7 +7656,7 @@ SWIGINTERN PyObject *_wrap_Operator_FormRectangularSystemOperator(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator **arg2 = 0 ; @@ -7851,15 +7664,19 @@ SWIGINTERN PyObject *_wrap_Operator_FormDiscreteOperator(PyObject *SWIGUNUSEDPAR int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"A", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Operator_FormDiscreteOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Operator_FormDiscreteOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_FormDiscreteOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_FormDiscreteOperator" "', argument " "2"" of type '" "mfem::Operator *&""'"); } @@ -7897,14 +7714,14 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; std::ostream *arg2 = 0 ; - int arg3 ; - int arg4 ; + int arg3 = (int) 0 ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); @@ -7925,160 +7742,25 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM arg2 = &out2; } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator const *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } } { try { - ((mfem::Operator const *)arg1)->PrintMatlab(*arg2); + ((mfem::Operator const *)arg1)->PrintMatlab(*arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8193,18 +7875,18 @@ SWIGINTERN PyObject *_wrap_Operator_GetType(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator *""'"); @@ -8215,64 +7897,17 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Operator_PrintMatlab__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Operator_PrintMatlab__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Operator_PrintMatlab" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Operator_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Operator_PrintMatlab__SWIG_3(arg1,(char const *)arg2); + mfem_Operator_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8306,40 +7941,7 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "Operator_PrintMatlab", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Operator_PrintMatlab__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Operator_PrintMatlab__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -8348,36 +7950,9 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Operator_PrintMatlab__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_Operator_PrintMatlab__SWIG_1(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8392,7 +7967,7 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); @@ -8408,6 +7983,9 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) } } if (_v) { + if (argc <= 2) { + return _wrap_Operator_PrintMatlab__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8417,6 +7995,9 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) } } if (_v) { + if (argc <= 3) { + return _wrap_Operator_PrintMatlab__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8430,357 +8011,93 @@ SWIGINTERN PyObject *_wrap_Operator_PrintMatlab(PyObject *self, PyObject *args) } } } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Operator_PrintMatlab'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Operator::PrintMatlab(std::ostream &,int,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &,int) const\n" - " mfem::Operator::PrintMatlab(std::ostream &) const\n" - " mfem::Operator::PrintMatlab(char const *,int)\n" - " mfem::Operator::PrintMatlab(char const *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_disown_Operator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Operator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); - if (director) director->swig_disown(); - } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *Operator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__Operator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *Operator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - double arg3 ; - mfem::TimeDependentOperator::Type arg4 ; - double val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4); - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - double arg3 ; - double val3 ; - int ecode3 = 0 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3); - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2); - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::TimeDependentOperator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(); - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Operator_PrintMatlab'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::Operator::PrintMatlab(std::ostream &,int,int) const\n" + " mfem::Operator::PrintMatlab(char const *,int)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_disown_Operator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - mfem::TimeDependentOperator::Type arg5 ; - double val4 ; - int ecode4 = 0 ; - int val5 ; - int ecode5 = 0 ; - mfem::TimeDependentOperator *result = 0 ; + mfem::Operator *arg1 = (mfem::Operator *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_Operator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Operator" "', argument " "1"" of type '" "mfem::Operator *""'"); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDependentOperator" "', argument " "5"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg5 = static_cast< mfem::TimeDependentOperator::Type >(val5); + arg1 = reinterpret_cast< mfem::Operator * >(argp1); { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4,arg5); - } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4,arg5); - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); + if (director) director->swig_disown(); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_POINTER_NEW | 0 ); + + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *Operator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__Operator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *Operator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - double arg4 ; - double val4 ; + int arg2 = (int) 0 ; + double arg3 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg4 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; + double val3 ; + int ecode3 = 0 ; + int val4 ; int ecode4 = 0 ; mfem::TimeDependentOperator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_TimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { if ( arg1 != Py_None ) { @@ -8813,14 +8130,20 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_5(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; + double arg4 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg5 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; + double val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; mfem::TimeDependentOperator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 5)) SWIG_fail; arg1 = swig_obj[0]; { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { @@ -8834,13 +8157,27 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator__SWIG_6(PyObject *SWIGUNUSE }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TimeDependentOperator" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TimeDependentOperator" "', argument " "5"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg5 = static_cast< mfem::TimeDependentOperator::Type >(val5); + } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3); + result = (mfem::TimeDependentOperator *)new SwigDirector_TimeDependentOperator(arg1,arg2,arg3,arg4,arg5); } else { - result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3); + result = (mfem::TimeDependentOperator *)new mfem::TimeDependentOperator(arg2,arg3,arg4,arg5); } } @@ -8874,34 +8211,13 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a if (!(argc = SWIG_Python_UnpackTuple(args, "new_TimeDependentOperator", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_2(self, argc, argv); + if (argc <= 1) { + return _wrap_new_TimeDependentOperator__SWIG_0(self, argc, argv); } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -8911,94 +8227,17 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_6(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_TimeDependentOperator__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_5(self, argc, argv); + if (argc <= 3) { + return _wrap_new_TimeDependentOperator__SWIG_0(self, argc, argv); } - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { { int res = SWIG_AsVal_int(argv[3], NULL); _v = SWIG_CheckState(res); @@ -9010,7 +8249,7 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a } } } - if (argc == 5) { + if ((argc >= 3) && (argc <= 5)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -9032,17 +8271,23 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a } } if (_v) { + if (argc <= 3) { + return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 4) { + return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_TimeDependentOperator__SWIG_4(self, argc, argv); + return _wrap_new_TimeDependentOperator__SWIG_1(self, argc, argv); } } } @@ -9054,12 +8299,7 @@ SWIGINTERN PyObject *_wrap_new_TimeDependentOperator(PyObject *self, PyObject *a SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_TimeDependentOperator'.\n" " Possible C/C++ prototypes are:\n" " mfem::TimeDependentOperator::TimeDependentOperator(int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int,double)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int)\n" - " mfem::TimeDependentOperator::TimeDependentOperator()\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(int,int,double)\n" - " mfem::TimeDependentOperator::TimeDependentOperator(PyObject *,int,int)\n"); + " mfem::TimeDependentOperator::TimeDependentOperator(PyObject *,int,int,double,mfem::TimeDependentOperator::Type)\n"); return 0; } @@ -9117,7 +8357,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetTime(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; double arg2 ; @@ -9125,23 +8365,27 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetTime(PyObject *SWIGUNUSEDPAR int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_t", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SetTime", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TimeDependentOperator_SetTime", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SetTime" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_SetTime" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9340,7 +8584,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetEvalMode(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::TimeDependentOperator::EvalMode arg2 ; @@ -9348,23 +8592,27 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSE int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"new_eval_mode", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SetEvalMode", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TimeDependentOperator_SetEvalMode", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_SetEvalMode" "', argument " "2"" of type '" "mfem::TimeDependentOperator::EvalMode""'"); } arg2 = static_cast< mfem::TimeDependentOperator::EvalMode >(val2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9399,7 +8647,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SetEvalMode(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9410,17 +8658,22 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ExplicitMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TimeDependentOperator_ExplicitMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9428,7 +8681,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ExplicitMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9437,7 +8690,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9472,7 +8725,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ExplicitMult(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9486,17 +8739,23 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"k", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ImplicitMult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_ImplicitMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9504,7 +8763,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9512,7 +8771,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeDependentOperator_ImplicitMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9521,7 +8780,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9556,7 +8815,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitMult(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9567,17 +8826,22 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TimeDependentOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_Mult" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9585,7 +8849,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -9594,7 +8858,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9629,7 +8893,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_Mult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; double arg2 ; @@ -9643,22 +8907,28 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dt", (char *)"x", (char *)"k", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_ImplicitSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_ImplicitSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9666,7 +8936,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "TimeDependentOperator_ImplicitSolve" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9675,7 +8945,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU } arg4 = reinterpret_cast< mfem::Vector * >(argp4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9710,7 +8980,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_ImplicitSolve(PyObject *SWIGUNU } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9724,18 +8994,24 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S int res3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"k", (char *)"shift", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_GetImplicitGradient", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_GetImplicitGradient", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9743,7 +9019,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9751,13 +9027,13 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_GetImplicitGradient" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9801,7 +9077,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetImplicitGradient(PyObject *S } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9809,18 +9085,22 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Operator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_GetExplicitGradient", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TimeDependentOperator_GetExplicitGradient", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_GetExplicitGradient" "', argument " "1"" of type '" "mfem::TimeDependentOperator const *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_GetExplicitGradient" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9829,7 +9109,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9873,7 +9153,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_GetExplicitGradient(PyObject *S } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9891,18 +9171,26 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG int res5 = 0 ; double val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"fx", (char *)"jok", (char *)"jcur", (char *)"gamma", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSetup", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:TimeDependentOperator_SUNImplicitSetup", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -9910,7 +9198,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9919,23 +9207,23 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 | 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "5"" of type '" "int *""'"); } arg5 = reinterpret_cast< int * >(argp5); - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_double(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "TimeDependentOperator_SUNImplicitSetup" "', argument " "6"" of type '" "double""'"); } arg6 = static_cast< double >(val6); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -9970,7 +9258,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSetup(PyObject *SWIG } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9984,18 +9272,24 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIG int res3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", (char *)"tol", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNImplicitSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_SUNImplicitSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -10003,7 +9297,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10011,13 +9305,13 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNImplicitSolve(PyObject *SWIG SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNImplicitSolve" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -10105,7 +9399,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSetup(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10119,18 +9413,24 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS int res3 = 0 ; double val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", (char *)"tol", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassSolve", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:TimeDependentOperator_SUNMassSolve", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -10138,7 +9438,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10146,13 +9446,13 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_double(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "TimeDependentOperator_SUNMassSolve" "', argument " "4"" of type '" "double""'"); } arg4 = static_cast< double >(val4); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -10187,7 +9487,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassSolve(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -10198,18 +9498,23 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"v", NULL + }; Swig::Director *director = 0; bool upcall = false; int result; - if (!SWIG_Python_UnpackTuple(args, "TimeDependentOperator_SUNMassMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TimeDependentOperator_SUNMassMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } arg1 = reinterpret_cast< mfem::TimeDependentOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -10217,7 +9522,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TimeDependentOperator_SUNMassMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -10226,7 +9531,7 @@ SWIGINTERN PyObject *_wrap_TimeDependentOperator_SUNMassMult(PyObject *SWIGUNUSE } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -10301,16 +9606,18 @@ SWIGINTERN PyObject *_wrap_delete_TimeDependentOperator(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TimeDependentOperator *arg1 = (mfem::TimeDependentOperator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_TimeDependentOperator", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TimeDependentOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_TimeDependentOperator" "', argument " "1"" of type '" "mfem::TimeDependentOperator *""'"); } @@ -10319,282 +9626,59 @@ SWIGINTERN PyObject *_wrap_disown_TimeDependentOperator(PyObject *SWIGUNUSEDPARM Swig::Director *director = SWIG_DIRECTOR_CAST(arg1); if (director) director->swig_disown(); } - - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - mfem::TimeDependentOperator::Type arg3 ; - double val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg3 = static_cast< mfem::TimeDependentOperator::Type >(val3); - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - double val2 ; - int ecode2 = 0 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - double arg3 ; - mfem::TimeDependentOperator::Type arg4 ; - double val3 ; - int ecode3 = 0 ; - int val4 ; - int ecode4 = 0 ; - mfem::SecondOrderTimeDependentOperator *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); - } - arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); - { - try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SecondOrderTimeDependentOperator, SWIG_POINTER_NEW | 0 ); + + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *TimeDependentOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TimeDependentOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TimeDependentOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - double arg3 ; - double val3 ; + int arg1 = (int) 0 ; + double arg2 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg3 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; + double val2 ; + int ecode2 = 0 ; + int val3 ; int ecode3 = 0 ; mfem::SecondOrderTimeDependentOperator *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if ((nobjs < 0) || (nobjs > 3)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg3 = static_cast< mfem::TimeDependentOperator::Type >(val3); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3); @@ -10621,13 +9705,19 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_5(PyObject } -SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; + double arg3 = (double) 0.0 ; + mfem::TimeDependentOperator::Type arg4 = (mfem::TimeDependentOperator::Type) mfem::TimeDependentOperator::EXPLICIT ; + double val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; mfem::SecondOrderTimeDependentOperator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -10640,9 +9730,23 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator__SWIG_6(PyObject }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SecondOrderTimeDependentOperator" "', argument " "4"" of type '" "mfem::TimeDependentOperator::Type""'"); + } + arg4 = static_cast< mfem::TimeDependentOperator::Type >(val4); + } { try { - result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2); + result = (mfem::SecondOrderTimeDependentOperator *)new mfem::SecondOrderTimeDependentOperator(arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10674,25 +9778,11 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, if (!(argc = SWIG_Python_UnpackTuple(args, "new_SecondOrderTimeDependentOperator", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_3(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 3)) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (argc <= 0) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); } - if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -10702,85 +9792,17 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_6(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_5(self, argc, argv); + if (argc <= 2) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -10791,7 +9813,7 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, } } } - if (argc == 4) { + if ((argc >= 2) && (argc <= 4)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -10811,17 +9833,23 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, } } if (_v) { + if (argc <= 2) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 3) { + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_SecondOrderTimeDependentOperator__SWIG_4(self, argc, argv); + return _wrap_new_SecondOrderTimeDependentOperator__SWIG_1(self, argc, argv); } } } @@ -10832,12 +9860,7 @@ SWIGINTERN PyObject *_wrap_new_SecondOrderTimeDependentOperator(PyObject *self, SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SecondOrderTimeDependentOperator'.\n" " Possible C/C++ prototypes are:\n" " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,double)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator()\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double)\n" - " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int)\n"); + " mfem::SecondOrderTimeDependentOperator::SecondOrderTimeDependentOperator(int,int,double,mfem::TimeDependentOperator::Type)\n"); return 0; } @@ -11346,201 +10369,56 @@ SWIGINTERN PyObject *_wrap_Solver_iterative_mode_get(PyObject *SWIGUNUSEDPARM(se PyObject *resultobj = 0; mfem::Solver *arg1 = (mfem::Solver *) 0 ; void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_get" "', argument " "1"" of type '" "mfem::Solver *""'"); - } - arg1 = reinterpret_cast< mfem::Solver * >(argp1); - result = (bool) ((arg1)->iterative_mode); - resultobj = SWIG_From_bool(static_cast< bool >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - bool arg3 ; - bool val3 ; - int ecode3 = 0 ; - mfem::Solver *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Solver" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::Solver *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::Solver *result = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + bool result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_iterative_mode_get" "', argument " "1"" of type '" "mfem::Solver *""'"); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NEW | 0 ); + arg1 = reinterpret_cast< mfem::Solver * >(argp1); + result = (bool) ((arg1)->iterative_mode); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Solver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - bool arg4 ; - bool val4 ; - int ecode4 = 0 ; + int arg2 = (int) 0 ; + bool arg3 = (bool) false ; + bool val3 ; + int ecode3 = 0 ; mfem::Solver *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Solver" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Solver" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3,arg4); + result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -11569,14 +10447,17 @@ SWIGINTERN PyObject *_wrap_new_Solver__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_Solver__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Solver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; + bool arg4 = (bool) false ; + bool val4 ; + int ecode4 = 0 ; mfem::Solver *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { @@ -11590,11 +10471,18 @@ SWIGINTERN PyObject *_wrap_new_Solver__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Solver" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); + } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3); + result = (mfem::Solver *)new SwigDirector_Solver(arg1,arg2,arg3,arg4); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -11631,34 +10519,13 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_Solver", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_Solver__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; _v = (argv[0] != 0); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Solver__SWIG_1(self, argc, argv); + if (argc <= 1) { + return _wrap_new_Solver__SWIG_0(self, argc, argv); } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11668,6 +10535,9 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_Solver__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); @@ -11678,7 +10548,7 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 3) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -11700,39 +10570,15 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Solver__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 3) { + return _wrap_new_Solver__SWIG_1(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_bool(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_Solver__SWIG_3(self, argc, argv); + return _wrap_new_Solver__SWIG_1(self, argc, argv); } } } @@ -11743,15 +10589,12 @@ SWIGINTERN PyObject *_wrap_new_Solver(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Solver'.\n" " Possible C/C++ prototypes are:\n" " mfem::Solver::Solver(int,bool)\n" - " mfem::Solver::Solver(int)\n" - " mfem::Solver::Solver()\n" - " mfem::Solver::Solver(int,int,bool)\n" - " mfem::Solver::Solver(PyObject *,int,int)\n"); + " mfem::Solver::Solver(PyObject *,int,int,bool)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Solver *arg1 = (mfem::Solver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -11759,17 +10602,21 @@ SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "Solver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Solver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Solver_SetOperator" "', argument " "1"" of type '" "mfem::Solver *""'"); } arg1 = reinterpret_cast< mfem::Solver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Solver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -11778,7 +10625,7 @@ SWIGINTERN PyObject *_wrap_Solver_SetOperator(PyObject *SWIGUNUSEDPARM(self), Py } arg2 = reinterpret_cast< mfem::Operator * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -11853,16 +10700,18 @@ SWIGINTERN PyObject *_wrap_delete_Solver(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_disown_Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_Solver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Solver *arg1 = (mfem::Solver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_Solver", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Solver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_Solver" "', argument " "1"" of type '" "mfem::Solver *""'"); } @@ -11890,19 +10739,21 @@ SWIGINTERN PyObject *Solver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"n", NULL + }; mfem::IdentityOperator *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_IdentityOperator", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -11930,7 +10781,7 @@ SWIGINTERN PyObject *_wrap_new_IdentityOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11941,15 +10792,20 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IdentityOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityOperator_Mult" "', argument " "1"" of type '" "mfem::IdentityOperator const *""'"); } arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11957,7 +10813,7 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11991,7 +10847,7 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IdentityOperator *arg1 = (mfem::IdentityOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12002,15 +10858,20 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPA int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IdentityOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IdentityOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IdentityOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdentityOperator_MultTranspose" "', argument " "1"" of type '" "mfem::IdentityOperator const *""'"); } arg1 = reinterpret_cast< mfem::IdentityOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12018,7 +10879,7 @@ SWIGINTERN PyObject *_wrap_IdentityOperator_MultTranspose(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "IdentityOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IdentityOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12103,17 +10964,19 @@ SWIGINTERN PyObject *IdentityOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), P return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"P", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsIdentityProlongation", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IsIdentityProlongation" "', argument " "1"" of type '" "mfem::Operator const *""'"); } @@ -12144,7 +11007,7 @@ SWIGINTERN PyObject *_wrap_IsIdentityProlongation(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; double arg2 ; @@ -12152,16 +11015,20 @@ SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"a", NULL + }; mfem::ScaledOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ScaledOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ScaledOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ScaledOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScaledOperator" "', argument " "2"" of type '" "double""'"); } @@ -12192,7 +11059,7 @@ SWIGINTERN PyObject *_wrap_new_ScaledOperator(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ScaledOperator *arg1 = (mfem::ScaledOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12203,15 +11070,20 @@ SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ScaledOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ScaledOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ScaledOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ScaledOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScaledOperator_Mult" "', argument " "1"" of type '" "mfem::ScaledOperator const *""'"); } arg1 = reinterpret_cast< mfem::ScaledOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12219,7 +11091,7 @@ SWIGINTERN PyObject *_wrap_ScaledOperator_Mult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScaledOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ScaledOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12420,7 +11292,7 @@ SWIGINTERN PyObject *_wrap_new_TransposeOperator(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12431,15 +11303,20 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeOperator_Mult" "', argument " "1"" of type '" "mfem::TransposeOperator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12447,7 +11324,7 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12481,7 +11358,7 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TransposeOperator *arg1 = (mfem::TransposeOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12492,15 +11369,20 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TransposeOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TransposeOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TransposeOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TransposeOperator const *""'"); } arg1 = reinterpret_cast< mfem::TransposeOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12508,7 +11390,7 @@ SWIGINTERN PyObject *_wrap_TransposeOperator_MultTranspose(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TransposeOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12593,7 +11475,7 @@ SWIGINTERN PyObject *TransposeOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -12607,26 +11489,32 @@ SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), P int ecode3 = 0 ; bool val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"ownA", (char *)"ownB", NULL + }; mfem::ProductOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ProductOperator", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:new_ProductOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_bool(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ProductOperator" "', argument " "3"" of type '" "bool""'"); } arg3 = static_cast< bool >(val3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ProductOperator" "', argument " "4"" of type '" "bool""'"); } @@ -12657,7 +11545,7 @@ SWIGINTERN PyObject *_wrap_new_ProductOperator(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12668,15 +11556,20 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ProductOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_Mult" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12684,7 +11577,7 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12718,7 +11611,7 @@ SWIGINTERN PyObject *_wrap_ProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ProductOperator *arg1 = (mfem::ProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12729,15 +11622,20 @@ SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPAR int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ProductOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::ProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::ProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12745,7 +11643,7 @@ SWIGINTERN PyObject *_wrap_ProductOperator_MultTranspose(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12830,7 +11728,7 @@ SWIGINTERN PyObject *ProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), Py return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Operator *arg2 = 0 ; @@ -12841,11 +11739,16 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"Rt_", (char *)"A_", (char *)"P_", NULL + }; mfem::RAPOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_RAPOperator", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_RAPOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); } @@ -12853,7 +11756,7 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -12861,7 +11764,7 @@ SWIGINTERN PyObject *_wrap_new_RAPOperator(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RAPOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Operator, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RAPOperator" "', argument " "3"" of type '" "mfem::Operator const &""'"); } @@ -12936,7 +11839,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -12947,15 +11850,20 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAPOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_Mult" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); } arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -12963,7 +11871,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -12997,7 +11905,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RAPOperator *arg1 = (mfem::RAPOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13008,15 +11916,20 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RAPOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAPOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RAPOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAPOperator_MultTranspose" "', argument " "1"" of type '" "mfem::RAPOperator const *""'"); } arg1 = reinterpret_cast< mfem::RAPOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13024,7 +11937,7 @@ SWIGINTERN PyObject *_wrap_RAPOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAPOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAPOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13109,7 +12022,7 @@ SWIGINTERN PyObject *RAPOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObje return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Operator *arg2 = (mfem::Operator *) 0 ; @@ -13129,36 +12042,44 @@ SWIGINTERN PyObject *_wrap_new_TripleProductOperator(PyObject *SWIGUNUSEDPARM(se int ecode5 = 0 ; bool val6 ; int ecode6 = 0 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"C", (char *)"ownA", (char *)"ownB", (char *)"ownC", NULL + }; mfem::TripleProductOperator *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_TripleProductOperator", 6, 6, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:new_TripleProductOperator", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_TripleProductOperator" "', argument " "1"" of type '" "mfem::Operator const *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_TripleProductOperator" "', argument " "2"" of type '" "mfem::Operator const *""'"); } arg2 = reinterpret_cast< mfem::Operator * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_TripleProductOperator" "', argument " "3"" of type '" "mfem::Operator const *""'"); } arg3 = reinterpret_cast< mfem::Operator * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_TripleProductOperator" "', argument " "4"" of type '" "bool""'"); } arg4 = static_cast< bool >(val4); - ecode5 = SWIG_AsVal_bool(swig_obj[4], &val5); + ecode5 = SWIG_AsVal_bool(obj4, &val5); if (!SWIG_IsOK(ecode5)) { SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_TripleProductOperator" "', argument " "5"" of type '" "bool""'"); } arg5 = static_cast< bool >(val5); - ecode6 = SWIG_AsVal_bool(swig_obj[5], &val6); + ecode6 = SWIG_AsVal_bool(obj5, &val6); if (!SWIG_IsOK(ecode6)) { SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_TripleProductOperator" "', argument " "6"" of type '" "bool""'"); } @@ -13230,7 +12151,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_GetMemoryClass(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13241,15 +12162,20 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TripleProductOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_Mult" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13257,7 +12183,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13291,7 +12217,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_Mult(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::TripleProductOperator *arg1 = (mfem::TripleProductOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13302,15 +12228,20 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "TripleProductOperator_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:TripleProductOperator_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__TripleProductOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TripleProductOperator_MultTranspose" "', argument " "1"" of type '" "mfem::TripleProductOperator const *""'"); } arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13318,7 +12249,7 @@ SWIGINTERN PyObject *_wrap_TripleProductOperator_MultTranspose(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TripleProductOperator_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "TripleProductOperator_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13359,85 +12290,16 @@ SWIGINTERN PyObject *_wrap_delete_TripleProductOperator(PyObject *SWIGUNUSEDPARM int res1 = 0 ; PyObject *swig_obj[1] ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); - } - arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - bool arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - mfem::ConstrainedOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__TripleProductOperator, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_TripleProductOperator" "', argument " "1"" of type '" "mfem::TripleProductOperator *""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + arg1 = reinterpret_cast< mfem::TripleProductOperator * >(argp1); { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13454,30 +12316,50 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDP SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__ConstrainedOperator, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *TripleProductOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__TripleProductOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *TripleProductOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"list", (char *)"own_A", NULL + }; mfem::ConstrainedOperator *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:new_ConstrainedOperator", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13485,9 +12367,16 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ConstrainedOperator" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); + } { try { - result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2); + result = (mfem::ConstrainedOperator *)new mfem::ConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13511,56 +12400,6 @@ SWIGINTERN PyObject *_wrap_new_ConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_new_ConstrainedOperator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstrainedOperator", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_ConstrainedOperator__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstrainedOperator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,bool)\n" - " mfem::ConstrainedOperator::ConstrainedOperator(mfem::Operator *,mfem::Array< int > const &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; @@ -13602,7 +12441,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13613,15 +12452,20 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"b", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstrainedOperator_EliminateRHS", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13629,7 +12473,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13663,7 +12507,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ConstrainedOperator *arg1 = (mfem::ConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13674,15 +12518,20 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstrainedOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::ConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::ConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13690,7 +12539,7 @@ SWIGINTERN PyObject *_wrap_ConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13775,12 +12624,12 @@ SWIGINTERN PyObject *ConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self) return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = (mfem::Operator *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; - bool arg4 ; + bool arg4 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13789,15 +12638,22 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject * int res3 = 0 ; bool val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"trial_list", (char *)"test_list", (char *)"own_A", NULL + }; mfem::RectangularConstrainedOperator *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_RectangularConstrainedOperator", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -13805,7 +12661,7 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -13813,75 +12669,16 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_0(PyObject * SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RectangularConstrainedOperator" "', argument " "4"" of type '" "bool""'"); - } - arg4 = static_cast< bool >(val4); - { - try { - result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = (mfem::Operator *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - mfem::RectangularConstrainedOperator *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Operator, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RectangularConstrainedOperator" "', argument " "1"" of type '" "mfem::Operator *""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RectangularConstrainedOperator" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_bool(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_RectangularConstrainedOperator" "', argument " "4"" of type '" "bool""'"); + } + arg4 = static_cast< bool >(val4); } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3); + result = (mfem::RectangularConstrainedOperator *)new mfem::RectangularConstrainedOperator(arg1,(mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13905,64 +12702,6 @@ SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_new_RectangularConstrainedOperator(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_RectangularConstrainedOperator", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_RectangularConstrainedOperator__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_RectangularConstrainedOperator__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_RectangularConstrainedOperator'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &,bool)\n" - " mfem::RectangularConstrainedOperator::RectangularConstrainedOperator(mfem::Operator *,mfem::Array< int > const &,mfem::Array< int > const &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_GetMemoryClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; @@ -14004,7 +12743,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_GetMemoryClass(PyObjec } -SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14015,15 +12754,20 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"b", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_EliminateRHS", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RectangularConstrainedOperator_EliminateRHS", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14031,7 +12775,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_EliminateRHS" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14065,7 +12809,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_EliminateRHS(PyObject } -SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::RectangularConstrainedOperator *arg1 = (mfem::RectangularConstrainedOperator *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14076,15 +12820,20 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "RectangularConstrainedOperator_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RectangularConstrainedOperator_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__RectangularConstrainedOperator, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "1"" of type '" "mfem::RectangularConstrainedOperator const *""'"); } arg1 = reinterpret_cast< mfem::RectangularConstrainedOperator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14092,7 +12841,7 @@ SWIGINTERN PyObject *_wrap_RectangularConstrainedOperator_Mult(PyObject *SWIGUNU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RectangularConstrainedOperator_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RectangularConstrainedOperator_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14165,77 +12914,39 @@ SWIGINTERN PyObject *_wrap_delete_RectangularConstrainedOperator(PyObject *SWIGU return NULL; } - -SWIGINTERN PyObject *RectangularConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *RectangularConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::PyOperatorBase *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyOperatorBase *)new SwigDirector_PyOperatorBase(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyOperatorBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; + +SWIGINTERN PyObject *RectangularConstrainedOperator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__RectangularConstrainedOperator, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); } +SWIGINTERN PyObject *RectangularConstrainedOperator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} -SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; + int arg2 = (int) 0 ; mfem::PyOperatorBase *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; arg1 = swig_obj[0]; + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::PyOperatorBase *)new SwigDirector_PyOperatorBase(arg1); + result = (mfem::PyOperatorBase *)new SwigDirector_PyOperatorBase(arg1,arg2); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -14264,7 +12975,7 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PyOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; @@ -14326,17 +13037,13 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_PyOperatorBase", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_PyOperatorBase__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; _v = (argv[0] != 0); if (_v) { + if (argc <= 1) { + return _wrap_new_PyOperatorBase__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -14372,7 +13079,7 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_PyOperatorBase__SWIG_2(self, argc, argv); + return _wrap_new_PyOperatorBase__SWIG_1(self, argc, argv); } } } @@ -14382,13 +13089,12 @@ SWIGINTERN PyObject *_wrap_new_PyOperatorBase(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PyOperatorBase'.\n" " Possible C/C++ prototypes are:\n" " mfem::PyOperatorBase::PyOperatorBase(int)\n" - " mfem::PyOperatorBase::PyOperatorBase()\n" " mfem::PyOperatorBase::PyOperatorBase(PyObject *,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyOperatorBase *arg1 = (mfem::PyOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14399,17 +13105,22 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "PyOperatorBase_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyOperatorBase_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOperatorBase_Mult" "', argument " "1"" of type '" "mfem::PyOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14417,7 +13128,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyOperatorBase_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -14426,7 +13137,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -14461,7 +13172,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyOperatorBase *arg1 = (mfem::PyOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14469,18 +13180,22 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PyOperatorBase__EvalMult", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PyOperatorBase__EvalMult", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyOperatorBase__EvalMult" "', argument " "1"" of type '" "mfem::PyOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyOperatorBase__EvalMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14489,7 +13204,7 @@ SWIGINTERN PyObject *_wrap_PyOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(sel } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -14567,16 +13282,18 @@ SWIGINTERN PyObject *_wrap_delete_PyOperatorBase(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_disown_PyOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_PyOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyOperatorBase *arg1 = (mfem::PyOperatorBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_PyOperatorBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PyOperatorBase" "', argument " "1"" of type '" "mfem::PyOperatorBase *""'"); } @@ -14607,117 +13324,34 @@ SWIGINTERN PyObject *PyOperatorBase_swiginit(PyObject *SWIGUNUSEDPARM(self), PyO SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - double arg3 ; + int arg2 = (int) 0 ; + double arg3 = (double) 0.0 ; double val3 ; int ecode3 = 0 ; mfem::PyTimeDependentOperatorBase *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - mfem::PyTimeDependentOperatorBase *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - mfem::PyTimeDependentOperatorBase *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - arg1 = swig_obj[0]; { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1); + result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -14746,17 +13380,17 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_2(PyObject *SWI } -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; PyObject *arg1 = (PyObject *) 0 ; int arg2 ; int arg3 ; - double arg4 ; + double arg4 = (double) 0.0 ; double val4 ; int ecode4 = 0 ; mfem::PyTimeDependentOperatorBase *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; arg1 = swig_obj[0]; { if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { @@ -14770,70 +13404,18 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_3(PyObject *SWI }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - if ( arg1 != Py_None ) { - /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3,arg4); - } else { - SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); - SWIG_fail; - } - - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - PyObject *arg1 = (PyObject *) 0 ; - int arg2 ; - int arg3 ; - mfem::PyTimeDependentOperatorBase *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - arg1 = swig_obj[0]; - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_PyTimeDependentOperatorBase" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); } { try { if ( arg1 != Py_None ) { /* subclassed */ - result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3); + result = (mfem::PyTimeDependentOperatorBase *)new SwigDirector_PyTimeDependentOperatorBase(arg1,arg2,arg3,arg4); } else { SWIG_SetErrorMsg(PyExc_RuntimeError,"accessing abstract class or protected constructor"); SWIG_fail; @@ -14870,34 +13452,13 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj if (!(argc = SWIG_Python_UnpackTuple(args, "new_PyTimeDependentOperatorBase", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - _v = (argv[0] != 0); - if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; _v = (argv[0] != 0); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } + if (argc <= 1) { + return _wrap_new_PyTimeDependentOperatorBase__SWIG_0(self, argc, argv); } - if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -14907,33 +13468,9 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj } } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - _v = (argv[0] != 0); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_PyTimeDependentOperatorBase__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); @@ -14944,7 +13481,7 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj } } } - if (argc == 4) { + if ((argc >= 3) && (argc <= 4)) { int _v; _v = (argv[0] != 0); if (_v) { @@ -14966,12 +13503,15 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj } } if (_v) { + if (argc <= 3) { + return _wrap_new_PyTimeDependentOperatorBase__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[3], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_PyTimeDependentOperatorBase__SWIG_3(self, argc, argv); + return _wrap_new_PyTimeDependentOperatorBase__SWIG_1(self, argc, argv); } } } @@ -14982,15 +13522,12 @@ SWIGINTERN PyObject *_wrap_new_PyTimeDependentOperatorBase(PyObject *self, PyObj SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PyTimeDependentOperatorBase'.\n" " Possible C/C++ prototypes are:\n" " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(int,double)\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(int)\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase()\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(int,int,double)\n" - " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(PyObject *,int,int)\n"); + " mfem::PyTimeDependentOperatorBase::PyTimeDependentOperatorBase(PyObject *,int,int,double)\n"); return 0; } -SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyTimeDependentOperatorBase *arg1 = (mfem::PyTimeDependentOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -15001,17 +13538,22 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; Swig::Director *director = 0; bool upcall = false; - if (!SWIG_Python_UnpackTuple(args, "PyTimeDependentOperatorBase_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PyTimeDependentOperatorBase_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "1"" of type '" "mfem::PyTimeDependentOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyTimeDependentOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -15019,7 +13561,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyTimeDependentOperatorBase_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -15028,7 +13570,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED } arg3 = reinterpret_cast< mfem::Vector * >(argp3); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -15063,7 +13605,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase_Mult(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyTimeDependentOperatorBase *arg1 = (mfem::PyTimeDependentOperatorBase *) 0 ; mfem::Vector *arg2 = 0 ; @@ -15071,18 +13613,22 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGU int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg0", NULL + }; Swig::Director *director = 0; bool upcall = false; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "PyTimeDependentOperatorBase__EvalMult", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PyTimeDependentOperatorBase__EvalMult", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyTimeDependentOperatorBase__EvalMult" "', argument " "1"" of type '" "mfem::PyTimeDependentOperatorBase const *""'"); } arg1 = reinterpret_cast< mfem::PyTimeDependentOperatorBase * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyTimeDependentOperatorBase__EvalMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -15091,7 +13637,7 @@ SWIGINTERN PyObject *_wrap_PyTimeDependentOperatorBase__EvalMult(PyObject *SWIGU } arg2 = reinterpret_cast< mfem::Vector * >(argp2); director = SWIG_DIRECTOR_CAST(arg1); - upcall = (director && (director->swig_get_self()==swig_obj[0])); + upcall = (director && (director->swig_get_self()==obj0)); try { { try { @@ -15169,16 +13715,18 @@ SWIGINTERN PyObject *_wrap_delete_PyTimeDependentOperatorBase(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_disown_PyTimeDependentOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_disown_PyTimeDependentOperatorBase(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::PyTimeDependentOperatorBase *arg1 = (mfem::PyTimeDependentOperatorBase *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"_self", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:disown_PyTimeDependentOperatorBase", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__PyTimeDependentOperatorBase, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "disown_PyTimeDependentOperatorBase" "', argument " "1"" of type '" "mfem::PyTimeDependentOperatorBase *""'"); } @@ -15209,7 +13757,7 @@ SWIGINTERN PyObject *PyTimeDependentOperatorBase_swiginit(PyObject *SWIGUNUSEDPA static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "Operator_InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "Operator_InitTVectors", (PyCFunction)(void(*)(void))_wrap_Operator_InitTVectors, METH_VARARGS|METH_KEYWORDS, "Operator_InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" "Operator(int s=0)\n" "new_Operator(PyObject * _self, int h, int w) -> Operator\n" @@ -15219,57 +13767,57 @@ static PyMethodDef SwigMethods[] = { { "Operator_Width", _wrap_Operator_Width, METH_O, "Operator_Width(Operator self) -> int"}, { "Operator_NumCols", _wrap_Operator_NumCols, METH_O, "Operator_NumCols(Operator self) -> int"}, { "Operator_GetMemoryClass", _wrap_Operator_GetMemoryClass, METH_O, "Operator_GetMemoryClass(Operator self) -> mfem::MemoryClass"}, - { "Operator_Mult", _wrap_Operator_Mult, METH_VARARGS, "Operator_Mult(Operator self, Vector x, Vector y)"}, - { "Operator_MultTranspose", _wrap_Operator_MultTranspose, METH_VARARGS, "Operator_MultTranspose(Operator self, Vector x, Vector y)"}, - { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "Operator_GetGradient(Operator self, Vector x) -> Operator"}, + { "Operator_Mult", (PyCFunction)(void(*)(void))_wrap_Operator_Mult, METH_VARARGS|METH_KEYWORDS, "Operator_Mult(Operator self, Vector x, Vector y)"}, + { "Operator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_Operator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "Operator_MultTranspose(Operator self, Vector x, Vector y)"}, + { "Operator_GetGradient", (PyCFunction)(void(*)(void))_wrap_Operator_GetGradient, METH_VARARGS|METH_KEYWORDS, "Operator_GetGradient(Operator self, Vector x) -> Operator"}, { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "Operator_GetProlongation(Operator self) -> Operator"}, { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "Operator_GetRestriction(Operator self) -> Operator"}, { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "Operator_GetOutputProlongation(Operator self) -> Operator"}, { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "Operator_GetOutputRestriction(Operator self) -> Operator"}, - { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "Operator_FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "Operator_FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "Operator_RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, - { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "Operator_FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "Operator_FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "Operator_FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, + { "Operator_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "Operator_FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "Operator_FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "Operator_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_Operator_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "Operator_RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "Operator_FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "Operator_FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "Operator_FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, { "Operator_GetType", _wrap_Operator_GetType, METH_O, "Operator_GetType(Operator self) -> mfem::Operator::Type"}, { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" "Operator_PrintMatlab(Operator self, std::ostream & out, int n=0, int m=0)\n" "Operator_PrintMatlab(Operator self, char const * file, int precision=8)\n" ""}, - { "disown_Operator", _wrap_disown_Operator, METH_O, NULL}, + { "disown_Operator", (PyCFunction)(void(*)(void))_wrap_disown_Operator, METH_VARARGS|METH_KEYWORDS, NULL}, { "Operator_swigregister", Operator_swigregister, METH_O, NULL}, { "Operator_swiginit", Operator_swiginit, METH_VARARGS, NULL}, { "new_TimeDependentOperator", _wrap_new_TimeDependentOperator, METH_VARARGS, "\n" "TimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "TimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_TimeDependentOperator(PyObject * _self, int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> TimeDependentOperator\n" ""}, { "TimeDependentOperator_GetTime", _wrap_TimeDependentOperator_GetTime, METH_O, "TimeDependentOperator_GetTime(TimeDependentOperator self) -> double"}, - { "TimeDependentOperator_SetTime", _wrap_TimeDependentOperator_SetTime, METH_VARARGS, "TimeDependentOperator_SetTime(TimeDependentOperator self, double const _t)"}, + { "TimeDependentOperator_SetTime", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetTime, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SetTime(TimeDependentOperator self, double const _t)"}, { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "TimeDependentOperator_isExplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "TimeDependentOperator_isImplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "TimeDependentOperator_isHomogeneous(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "TimeDependentOperator_GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, - { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "TimeDependentOperator_SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, - { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "TimeDependentOperator_ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "TimeDependentOperator_ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, - { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "TimeDependentOperator_Mult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "TimeDependentOperator_ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, - { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "TimeDependentOperator_GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, - { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "TimeDependentOperator_GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, - { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "TimeDependentOperator_SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, - { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "TimeDependentOperator_SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SetEvalMode", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, + { "TimeDependentOperator_ExplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, + { "TimeDependentOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_Mult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_Mult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, + { "TimeDependentOperator_GetImplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, + { "TimeDependentOperator_GetExplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "TimeDependentOperator_SUNMassSetup(TimeDependentOperator self) -> int"}, - { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "TimeDependentOperator_SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, - { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "TimeDependentOperator_SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, + { "TimeDependentOperator_SUNMassSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS|METH_KEYWORDS, "TimeDependentOperator_SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, - { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, + { "disown_TimeDependentOperator", (PyCFunction)(void(*)(void))_wrap_disown_TimeDependentOperator, METH_VARARGS|METH_KEYWORDS, NULL}, { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator\n" ""}, { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" "SecondOrderTimeDependentOperator_Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" @@ -15286,22 +13834,22 @@ static PyMethodDef SwigMethods[] = { { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" "Solver(int s=0, bool iter_mode=False)\n" - "Solver(int h, int w, bool iter_mode=False)\n" + "new_Solver(PyObject * _self, int h, int w, bool iter_mode=False) -> Solver\n" ""}, - { "Solver_SetOperator", _wrap_Solver_SetOperator, METH_VARARGS, "Solver_SetOperator(Solver self, Operator op)"}, + { "Solver_SetOperator", (PyCFunction)(void(*)(void))_wrap_Solver_SetOperator, METH_VARARGS|METH_KEYWORDS, "Solver_SetOperator(Solver self, Operator op)"}, { "delete_Solver", _wrap_delete_Solver, METH_O, "delete_Solver(Solver self)"}, - { "disown_Solver", _wrap_disown_Solver, METH_O, NULL}, + { "disown_Solver", (PyCFunction)(void(*)(void))_wrap_disown_Solver, METH_VARARGS|METH_KEYWORDS, NULL}, { "Solver_swigregister", Solver_swigregister, METH_O, NULL}, { "Solver_swiginit", Solver_swiginit, METH_VARARGS, NULL}, - { "new_IdentityOperator", _wrap_new_IdentityOperator, METH_O, "new_IdentityOperator(int n) -> IdentityOperator"}, - { "IdentityOperator_Mult", _wrap_IdentityOperator_Mult, METH_VARARGS, "IdentityOperator_Mult(IdentityOperator self, Vector x, Vector y)"}, - { "IdentityOperator_MultTranspose", _wrap_IdentityOperator_MultTranspose, METH_VARARGS, "IdentityOperator_MultTranspose(IdentityOperator self, Vector x, Vector y)"}, + { "new_IdentityOperator", (PyCFunction)(void(*)(void))_wrap_new_IdentityOperator, METH_VARARGS|METH_KEYWORDS, "new_IdentityOperator(int n) -> IdentityOperator"}, + { "IdentityOperator_Mult", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_Mult, METH_VARARGS|METH_KEYWORDS, "IdentityOperator_Mult(IdentityOperator self, Vector x, Vector y)"}, + { "IdentityOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "IdentityOperator_MultTranspose(IdentityOperator self, Vector x, Vector y)"}, { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, - { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, - { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, - { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "ScaledOperator_Mult(ScaledOperator self, Vector x, Vector y)"}, + { "IsIdentityProlongation", (PyCFunction)(void(*)(void))_wrap_IsIdentityProlongation, METH_VARARGS|METH_KEYWORDS, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", (PyCFunction)(void(*)(void))_wrap_new_ScaledOperator, METH_VARARGS|METH_KEYWORDS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ScaledOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ScaledOperator_Mult(ScaledOperator self, Vector x, Vector y)"}, { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, @@ -15309,42 +13857,42 @@ static PyMethodDef SwigMethods[] = { "TransposeOperator(Operator a)\n" "new_TransposeOperator(Operator a) -> TransposeOperator\n" ""}, - { "TransposeOperator_Mult", _wrap_TransposeOperator_Mult, METH_VARARGS, "TransposeOperator_Mult(TransposeOperator self, Vector x, Vector y)"}, - { "TransposeOperator_MultTranspose", _wrap_TransposeOperator_MultTranspose, METH_VARARGS, "TransposeOperator_MultTranspose(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_Mult, METH_VARARGS|METH_KEYWORDS, "TransposeOperator_Mult(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "TransposeOperator_MultTranspose(TransposeOperator self, Vector x, Vector y)"}, { "delete_TransposeOperator", _wrap_delete_TransposeOperator, METH_O, "delete_TransposeOperator(TransposeOperator self)"}, { "TransposeOperator_swigregister", TransposeOperator_swigregister, METH_O, NULL}, { "TransposeOperator_swiginit", TransposeOperator_swiginit, METH_VARARGS, NULL}, - { "new_ProductOperator", _wrap_new_ProductOperator, METH_VARARGS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, - { "ProductOperator_Mult", _wrap_ProductOperator_Mult, METH_VARARGS, "ProductOperator_Mult(ProductOperator self, Vector x, Vector y)"}, - { "ProductOperator_MultTranspose", _wrap_ProductOperator_MultTranspose, METH_VARARGS, "ProductOperator_MultTranspose(ProductOperator self, Vector x, Vector y)"}, + { "new_ProductOperator", (PyCFunction)(void(*)(void))_wrap_new_ProductOperator, METH_VARARGS|METH_KEYWORDS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, + { "ProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ProductOperator_Mult(ProductOperator self, Vector x, Vector y)"}, + { "ProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ProductOperator_MultTranspose(ProductOperator self, Vector x, Vector y)"}, { "delete_ProductOperator", _wrap_delete_ProductOperator, METH_O, "delete_ProductOperator(ProductOperator self)"}, { "ProductOperator_swigregister", ProductOperator_swigregister, METH_O, NULL}, { "ProductOperator_swiginit", ProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_RAPOperator", _wrap_new_RAPOperator, METH_VARARGS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, + { "new_RAPOperator", (PyCFunction)(void(*)(void))_wrap_new_RAPOperator, METH_VARARGS|METH_KEYWORDS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, { "RAPOperator_GetMemoryClass", _wrap_RAPOperator_GetMemoryClass, METH_O, "RAPOperator_GetMemoryClass(RAPOperator self) -> mfem::MemoryClass"}, - { "RAPOperator_Mult", _wrap_RAPOperator_Mult, METH_VARARGS, "RAPOperator_Mult(RAPOperator self, Vector x, Vector y)"}, - { "RAPOperator_MultTranspose", _wrap_RAPOperator_MultTranspose, METH_VARARGS, "RAPOperator_MultTranspose(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RAPOperator_Mult, METH_VARARGS|METH_KEYWORDS, "RAPOperator_Mult(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_RAPOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "RAPOperator_MultTranspose(RAPOperator self, Vector x, Vector y)"}, { "delete_RAPOperator", _wrap_delete_RAPOperator, METH_O, "delete_RAPOperator(RAPOperator self)"}, { "RAPOperator_swigregister", RAPOperator_swigregister, METH_O, NULL}, { "RAPOperator_swiginit", RAPOperator_swiginit, METH_VARARGS, NULL}, - { "new_TripleProductOperator", _wrap_new_TripleProductOperator, METH_VARARGS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, + { "new_TripleProductOperator", (PyCFunction)(void(*)(void))_wrap_new_TripleProductOperator, METH_VARARGS|METH_KEYWORDS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, { "TripleProductOperator_GetMemoryClass", _wrap_TripleProductOperator_GetMemoryClass, METH_O, "TripleProductOperator_GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass"}, - { "TripleProductOperator_Mult", _wrap_TripleProductOperator_Mult, METH_VARARGS, "TripleProductOperator_Mult(TripleProductOperator self, Vector x, Vector y)"}, - { "TripleProductOperator_MultTranspose", _wrap_TripleProductOperator_MultTranspose, METH_VARARGS, "TripleProductOperator_MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "TripleProductOperator_Mult(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "TripleProductOperator_MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, { "delete_TripleProductOperator", _wrap_delete_TripleProductOperator, METH_O, "delete_TripleProductOperator(TripleProductOperator self)"}, { "TripleProductOperator_swigregister", TripleProductOperator_swigregister, METH_O, NULL}, { "TripleProductOperator_swiginit", TripleProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_ConstrainedOperator", _wrap_new_ConstrainedOperator, METH_VARARGS, "ConstrainedOperator(Operator A, intArray list, bool own_A=False)"}, + { "new_ConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_ConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_ConstrainedOperator(Operator A, intArray list, bool own_A=False) -> ConstrainedOperator"}, { "ConstrainedOperator_GetMemoryClass", _wrap_ConstrainedOperator_GetMemoryClass, METH_O, "ConstrainedOperator_GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass"}, - { "ConstrainedOperator_EliminateRHS", _wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS, "ConstrainedOperator_EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, - { "ConstrainedOperator_Mult", _wrap_ConstrainedOperator_Mult, METH_VARARGS, "ConstrainedOperator_Mult(ConstrainedOperator self, Vector x, Vector y)"}, + { "ConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "ConstrainedOperator_EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, + { "ConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "ConstrainedOperator_Mult(ConstrainedOperator self, Vector x, Vector y)"}, { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, - { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "new_RectangularConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_RectangularConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False) -> RectangularConstrainedOperator"}, { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "RectangularConstrainedOperator_GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, - { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "RectangularConstrainedOperator_EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, - { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "RectangularConstrainedOperator_Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "RectangularConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "RectangularConstrainedOperator_EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "RectangularConstrainedOperator_Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, @@ -15352,20 +13900,20 @@ static PyMethodDef SwigMethods[] = { "PyOperatorBase(int s=0)\n" "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" ""}, - { "PyOperatorBase_Mult", _wrap_PyOperatorBase_Mult, METH_VARARGS, "PyOperatorBase_Mult(PyOperatorBase self, Vector x, Vector y)"}, - { "PyOperatorBase__EvalMult", _wrap_PyOperatorBase__EvalMult, METH_VARARGS, "PyOperatorBase__EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, + { "PyOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "PyOperatorBase_Mult(PyOperatorBase self, Vector x, Vector y)"}, + { "PyOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "PyOperatorBase__EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyOperatorBase", _wrap_delete_PyOperatorBase, METH_O, "delete_PyOperatorBase(PyOperatorBase self)"}, - { "disown_PyOperatorBase", _wrap_disown_PyOperatorBase, METH_O, NULL}, + { "disown_PyOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyOperatorBase_swigregister", PyOperatorBase_swigregister, METH_O, NULL}, { "PyOperatorBase_swiginit", PyOperatorBase_swiginit, METH_VARARGS, NULL}, { "new_PyTimeDependentOperatorBase", _wrap_new_PyTimeDependentOperatorBase, METH_VARARGS, "\n" "PyTimeDependentOperatorBase(int n=0, double _t=0.0)\n" - "PyTimeDependentOperatorBase(int h, int w, double _t=0.0)\n" + "new_PyTimeDependentOperatorBase(PyObject * _self, int h, int w, double _t=0.0) -> PyTimeDependentOperatorBase\n" ""}, - { "PyTimeDependentOperatorBase_Mult", _wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS, "PyTimeDependentOperatorBase_Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, - { "PyTimeDependentOperatorBase__EvalMult", _wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS, "PyTimeDependentOperatorBase__EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, + { "PyTimeDependentOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "PyTimeDependentOperatorBase_Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, + { "PyTimeDependentOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "PyTimeDependentOperatorBase__EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyTimeDependentOperatorBase", _wrap_delete_PyTimeDependentOperatorBase, METH_O, "delete_PyTimeDependentOperatorBase(PyTimeDependentOperatorBase self)"}, - { "disown_PyTimeDependentOperatorBase", _wrap_disown_PyTimeDependentOperatorBase, METH_O, NULL}, + { "disown_PyTimeDependentOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyTimeDependentOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyTimeDependentOperatorBase_swigregister", PyTimeDependentOperatorBase_swigregister, METH_O, NULL}, { "PyTimeDependentOperatorBase_swiginit", PyTimeDependentOperatorBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } @@ -15374,7 +13922,7 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "Operator_InitTVectors", _wrap_Operator_InitTVectors, METH_VARARGS, "InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, + { "Operator_InitTVectors", (PyCFunction)(void(*)(void))_wrap_Operator_InitTVectors, METH_VARARGS|METH_KEYWORDS, "InitTVectors(Operator self, Operator Po, Operator Ri, Operator Pi, Vector x, Vector b, Vector X, Vector B)"}, { "new_Operator", _wrap_new_Operator, METH_VARARGS, "\n" "Operator(int s=0)\n" "new_Operator(PyObject * _self, int h, int w) -> Operator\n" @@ -15384,57 +13932,57 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Operator_Width", _wrap_Operator_Width, METH_O, "Width(Operator self) -> int"}, { "Operator_NumCols", _wrap_Operator_NumCols, METH_O, "NumCols(Operator self) -> int"}, { "Operator_GetMemoryClass", _wrap_Operator_GetMemoryClass, METH_O, "GetMemoryClass(Operator self) -> mfem::MemoryClass"}, - { "Operator_Mult", _wrap_Operator_Mult, METH_VARARGS, "Mult(Operator self, Vector x, Vector y)"}, - { "Operator_MultTranspose", _wrap_Operator_MultTranspose, METH_VARARGS, "MultTranspose(Operator self, Vector x, Vector y)"}, - { "Operator_GetGradient", _wrap_Operator_GetGradient, METH_VARARGS, "GetGradient(Operator self, Vector x) -> Operator"}, + { "Operator_Mult", (PyCFunction)(void(*)(void))_wrap_Operator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(Operator self, Vector x, Vector y)"}, + { "Operator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_Operator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(Operator self, Vector x, Vector y)"}, + { "Operator_GetGradient", (PyCFunction)(void(*)(void))_wrap_Operator_GetGradient, METH_VARARGS|METH_KEYWORDS, "GetGradient(Operator self, Vector x) -> Operator"}, { "Operator_GetProlongation", _wrap_Operator_GetProlongation, METH_O, "GetProlongation(Operator self) -> Operator"}, { "Operator_GetRestriction", _wrap_Operator_GetRestriction, METH_O, "GetRestriction(Operator self) -> Operator"}, { "Operator_GetOutputProlongation", _wrap_Operator_GetOutputProlongation, METH_O, "GetOutputProlongation(Operator self) -> Operator"}, { "Operator_GetOutputRestriction", _wrap_Operator_GetOutputRestriction, METH_O, "GetOutputRestriction(Operator self) -> Operator"}, - { "Operator_FormLinearSystem", _wrap_Operator_FormLinearSystem, METH_VARARGS, "FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, - { "Operator_FormRectangularLinearSystem", _wrap_Operator_FormRectangularLinearSystem, METH_VARARGS, "FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, - { "Operator_RecoverFEMSolution", _wrap_Operator_RecoverFEMSolution, METH_VARARGS, "RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, - { "Operator_FormSystemOperator", _wrap_Operator_FormSystemOperator, METH_VARARGS, "FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormRectangularSystemOperator", _wrap_Operator_FormRectangularSystemOperator, METH_VARARGS, "FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, - { "Operator_FormDiscreteOperator", _wrap_Operator_FormDiscreteOperator, METH_VARARGS, "FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, + { "Operator_FormLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormLinearSystem(Operator self, intArray ess_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B, int copy_interior=0)"}, + { "Operator_FormRectangularLinearSystem", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularLinearSystem, METH_VARARGS|METH_KEYWORDS, "FormRectangularLinearSystem(Operator self, intArray trial_tdof_list, intArray test_tdof_list, Vector x, Vector b, mfem::Operator *& A, Vector X, Vector B)"}, + { "Operator_RecoverFEMSolution", (PyCFunction)(void(*)(void))_wrap_Operator_RecoverFEMSolution, METH_VARARGS|METH_KEYWORDS, "RecoverFEMSolution(Operator self, Vector X, Vector b, Vector x)"}, + { "Operator_FormSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormSystemOperator(Operator self, intArray ess_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormRectangularSystemOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormRectangularSystemOperator, METH_VARARGS|METH_KEYWORDS, "FormRectangularSystemOperator(Operator self, intArray trial_tdof_list, intArray test_tdof_list, mfem::Operator *& A)"}, + { "Operator_FormDiscreteOperator", (PyCFunction)(void(*)(void))_wrap_Operator_FormDiscreteOperator, METH_VARARGS|METH_KEYWORDS, "FormDiscreteOperator(Operator self, mfem::Operator *& A)"}, { "delete_Operator", _wrap_delete_Operator, METH_O, "delete_Operator(Operator self)"}, { "Operator_GetType", _wrap_Operator_GetType, METH_O, "GetType(Operator self) -> mfem::Operator::Type"}, { "Operator_PrintMatlab", _wrap_Operator_PrintMatlab, METH_VARARGS, "\n" "PrintMatlab(Operator self, std::ostream & out, int n=0, int m=0)\n" "PrintMatlab(Operator self, char const * file, int precision=8)\n" ""}, - { "disown_Operator", _wrap_disown_Operator, METH_O, NULL}, + { "disown_Operator", (PyCFunction)(void(*)(void))_wrap_disown_Operator, METH_VARARGS|METH_KEYWORDS, NULL}, { "Operator_swigregister", Operator_swigregister, METH_O, NULL}, { "Operator_swiginit", Operator_swiginit, METH_VARARGS, NULL}, { "new_TimeDependentOperator", _wrap_new_TimeDependentOperator, METH_VARARGS, "\n" "TimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "TimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_TimeDependentOperator(PyObject * _self, int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> TimeDependentOperator\n" ""}, { "TimeDependentOperator_GetTime", _wrap_TimeDependentOperator_GetTime, METH_O, "GetTime(TimeDependentOperator self) -> double"}, - { "TimeDependentOperator_SetTime", _wrap_TimeDependentOperator_SetTime, METH_VARARGS, "SetTime(TimeDependentOperator self, double const _t)"}, + { "TimeDependentOperator_SetTime", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetTime, METH_VARARGS|METH_KEYWORDS, "SetTime(TimeDependentOperator self, double const _t)"}, { "TimeDependentOperator_isExplicit", _wrap_TimeDependentOperator_isExplicit, METH_O, "isExplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isImplicit", _wrap_TimeDependentOperator_isImplicit, METH_O, "isImplicit(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_isHomogeneous", _wrap_TimeDependentOperator_isHomogeneous, METH_O, "isHomogeneous(TimeDependentOperator self) -> bool"}, { "TimeDependentOperator_GetEvalMode", _wrap_TimeDependentOperator_GetEvalMode, METH_O, "GetEvalMode(TimeDependentOperator self) -> mfem::TimeDependentOperator::EvalMode"}, - { "TimeDependentOperator_SetEvalMode", _wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS, "SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, - { "TimeDependentOperator_ExplicitMult", _wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS, "ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitMult", _wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS, "ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, - { "TimeDependentOperator_Mult", _wrap_TimeDependentOperator_Mult, METH_VARARGS, "Mult(TimeDependentOperator self, Vector x, Vector y)"}, - { "TimeDependentOperator_ImplicitSolve", _wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS, "ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, - { "TimeDependentOperator_GetImplicitGradient", _wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS, "GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, - { "TimeDependentOperator_GetExplicitGradient", _wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS, "GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, - { "TimeDependentOperator_SUNImplicitSetup", _wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS, "SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, - { "TimeDependentOperator_SUNImplicitSolve", _wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS, "SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SetEvalMode", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SetEvalMode, METH_VARARGS|METH_KEYWORDS, "SetEvalMode(TimeDependentOperator self, mfem::TimeDependentOperator::EvalMode const new_eval_mode)"}, + { "TimeDependentOperator_ExplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ExplicitMult, METH_VARARGS|METH_KEYWORDS, "ExplicitMult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitMult, METH_VARARGS|METH_KEYWORDS, "ImplicitMult(TimeDependentOperator self, Vector x, Vector k, Vector y)"}, + { "TimeDependentOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(TimeDependentOperator self, Vector x, Vector y)"}, + { "TimeDependentOperator_ImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_ImplicitSolve, METH_VARARGS|METH_KEYWORDS, "ImplicitSolve(TimeDependentOperator self, double const dt, Vector x, Vector k)"}, + { "TimeDependentOperator_GetImplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetImplicitGradient, METH_VARARGS|METH_KEYWORDS, "GetImplicitGradient(TimeDependentOperator self, Vector x, Vector k, double shift) -> Operator"}, + { "TimeDependentOperator_GetExplicitGradient", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_GetExplicitGradient, METH_VARARGS|METH_KEYWORDS, "GetExplicitGradient(TimeDependentOperator self, Vector x) -> Operator"}, + { "TimeDependentOperator_SUNImplicitSetup", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSetup, METH_VARARGS|METH_KEYWORDS, "SUNImplicitSetup(TimeDependentOperator self, Vector x, Vector fx, int jok, int * jcur, double gamma) -> int"}, + { "TimeDependentOperator_SUNImplicitSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNImplicitSolve, METH_VARARGS|METH_KEYWORDS, "SUNImplicitSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, { "TimeDependentOperator_SUNMassSetup", _wrap_TimeDependentOperator_SUNMassSetup, METH_O, "SUNMassSetup(TimeDependentOperator self) -> int"}, - { "TimeDependentOperator_SUNMassSolve", _wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS, "SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, - { "TimeDependentOperator_SUNMassMult", _wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS, "SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, + { "TimeDependentOperator_SUNMassSolve", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassSolve, METH_VARARGS|METH_KEYWORDS, "SUNMassSolve(TimeDependentOperator self, Vector b, Vector x, double tol) -> int"}, + { "TimeDependentOperator_SUNMassMult", (PyCFunction)(void(*)(void))_wrap_TimeDependentOperator_SUNMassMult, METH_VARARGS|METH_KEYWORDS, "SUNMassMult(TimeDependentOperator self, Vector x, Vector v) -> int"}, { "delete_TimeDependentOperator", _wrap_delete_TimeDependentOperator, METH_O, "delete_TimeDependentOperator(TimeDependentOperator self)"}, - { "disown_TimeDependentOperator", _wrap_disown_TimeDependentOperator, METH_O, NULL}, + { "disown_TimeDependentOperator", (PyCFunction)(void(*)(void))_wrap_disown_TimeDependentOperator, METH_VARARGS|METH_KEYWORDS, NULL}, { "TimeDependentOperator_swigregister", TimeDependentOperator_swigregister, METH_O, NULL}, { "TimeDependentOperator_swiginit", TimeDependentOperator_swiginit, METH_VARARGS, NULL}, { "new_SecondOrderTimeDependentOperator", _wrap_new_SecondOrderTimeDependentOperator, METH_VARARGS, "\n" "SecondOrderTimeDependentOperator(int n=0, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" - "SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT)\n" + "new_SecondOrderTimeDependentOperator(int h, int w, double t_=0.0, mfem::TimeDependentOperator::Type type_=EXPLICIT) -> SecondOrderTimeDependentOperator\n" ""}, { "SecondOrderTimeDependentOperator_Mult", _wrap_SecondOrderTimeDependentOperator_Mult, METH_VARARGS, "\n" "Mult(SecondOrderTimeDependentOperator self, Vector x, Vector y)\n" @@ -15451,22 +13999,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "Solver_iterative_mode_get", _wrap_Solver_iterative_mode_get, METH_O, "Solver_iterative_mode_get(Solver self) -> bool"}, { "new_Solver", _wrap_new_Solver, METH_VARARGS, "\n" "Solver(int s=0, bool iter_mode=False)\n" - "Solver(int h, int w, bool iter_mode=False)\n" + "new_Solver(PyObject * _self, int h, int w, bool iter_mode=False) -> Solver\n" ""}, - { "Solver_SetOperator", _wrap_Solver_SetOperator, METH_VARARGS, "SetOperator(Solver self, Operator op)"}, + { "Solver_SetOperator", (PyCFunction)(void(*)(void))_wrap_Solver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(Solver self, Operator op)"}, { "delete_Solver", _wrap_delete_Solver, METH_O, "delete_Solver(Solver self)"}, - { "disown_Solver", _wrap_disown_Solver, METH_O, NULL}, + { "disown_Solver", (PyCFunction)(void(*)(void))_wrap_disown_Solver, METH_VARARGS|METH_KEYWORDS, NULL}, { "Solver_swigregister", Solver_swigregister, METH_O, NULL}, { "Solver_swiginit", Solver_swiginit, METH_VARARGS, NULL}, - { "new_IdentityOperator", _wrap_new_IdentityOperator, METH_O, "new_IdentityOperator(int n) -> IdentityOperator"}, - { "IdentityOperator_Mult", _wrap_IdentityOperator_Mult, METH_VARARGS, "Mult(IdentityOperator self, Vector x, Vector y)"}, - { "IdentityOperator_MultTranspose", _wrap_IdentityOperator_MultTranspose, METH_VARARGS, "MultTranspose(IdentityOperator self, Vector x, Vector y)"}, + { "new_IdentityOperator", (PyCFunction)(void(*)(void))_wrap_new_IdentityOperator, METH_VARARGS|METH_KEYWORDS, "new_IdentityOperator(int n) -> IdentityOperator"}, + { "IdentityOperator_Mult", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(IdentityOperator self, Vector x, Vector y)"}, + { "IdentityOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_IdentityOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(IdentityOperator self, Vector x, Vector y)"}, { "delete_IdentityOperator", _wrap_delete_IdentityOperator, METH_O, "delete_IdentityOperator(IdentityOperator self)"}, { "IdentityOperator_swigregister", IdentityOperator_swigregister, METH_O, NULL}, { "IdentityOperator_swiginit", IdentityOperator_swiginit, METH_VARARGS, NULL}, - { "IsIdentityProlongation", _wrap_IsIdentityProlongation, METH_O, "IsIdentityProlongation(Operator P) -> bool"}, - { "new_ScaledOperator", _wrap_new_ScaledOperator, METH_VARARGS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, - { "ScaledOperator_Mult", _wrap_ScaledOperator_Mult, METH_VARARGS, "Mult(ScaledOperator self, Vector x, Vector y)"}, + { "IsIdentityProlongation", (PyCFunction)(void(*)(void))_wrap_IsIdentityProlongation, METH_VARARGS|METH_KEYWORDS, "IsIdentityProlongation(Operator P) -> bool"}, + { "new_ScaledOperator", (PyCFunction)(void(*)(void))_wrap_new_ScaledOperator, METH_VARARGS|METH_KEYWORDS, "new_ScaledOperator(Operator A, double a) -> ScaledOperator"}, + { "ScaledOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ScaledOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ScaledOperator self, Vector x, Vector y)"}, { "delete_ScaledOperator", _wrap_delete_ScaledOperator, METH_O, "delete_ScaledOperator(ScaledOperator self)"}, { "ScaledOperator_swigregister", ScaledOperator_swigregister, METH_O, NULL}, { "ScaledOperator_swiginit", ScaledOperator_swiginit, METH_VARARGS, NULL}, @@ -15474,42 +14022,42 @@ static PyMethodDef SwigMethods_proxydocs[] = { "TransposeOperator(Operator a)\n" "new_TransposeOperator(Operator a) -> TransposeOperator\n" ""}, - { "TransposeOperator_Mult", _wrap_TransposeOperator_Mult, METH_VARARGS, "Mult(TransposeOperator self, Vector x, Vector y)"}, - { "TransposeOperator_MultTranspose", _wrap_TransposeOperator_MultTranspose, METH_VARARGS, "MultTranspose(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(TransposeOperator self, Vector x, Vector y)"}, + { "TransposeOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TransposeOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(TransposeOperator self, Vector x, Vector y)"}, { "delete_TransposeOperator", _wrap_delete_TransposeOperator, METH_O, "delete_TransposeOperator(TransposeOperator self)"}, { "TransposeOperator_swigregister", TransposeOperator_swigregister, METH_O, NULL}, { "TransposeOperator_swiginit", TransposeOperator_swiginit, METH_VARARGS, NULL}, - { "new_ProductOperator", _wrap_new_ProductOperator, METH_VARARGS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, - { "ProductOperator_Mult", _wrap_ProductOperator_Mult, METH_VARARGS, "Mult(ProductOperator self, Vector x, Vector y)"}, - { "ProductOperator_MultTranspose", _wrap_ProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(ProductOperator self, Vector x, Vector y)"}, + { "new_ProductOperator", (PyCFunction)(void(*)(void))_wrap_new_ProductOperator, METH_VARARGS|METH_KEYWORDS, "new_ProductOperator(Operator A, Operator B, bool ownA, bool ownB) -> ProductOperator"}, + { "ProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ProductOperator self, Vector x, Vector y)"}, + { "ProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ProductOperator self, Vector x, Vector y)"}, { "delete_ProductOperator", _wrap_delete_ProductOperator, METH_O, "delete_ProductOperator(ProductOperator self)"}, { "ProductOperator_swigregister", ProductOperator_swigregister, METH_O, NULL}, { "ProductOperator_swiginit", ProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_RAPOperator", _wrap_new_RAPOperator, METH_VARARGS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, + { "new_RAPOperator", (PyCFunction)(void(*)(void))_wrap_new_RAPOperator, METH_VARARGS|METH_KEYWORDS, "new_RAPOperator(Operator Rt_, Operator A_, Operator P_) -> RAPOperator"}, { "RAPOperator_GetMemoryClass", _wrap_RAPOperator_GetMemoryClass, METH_O, "GetMemoryClass(RAPOperator self) -> mfem::MemoryClass"}, - { "RAPOperator_Mult", _wrap_RAPOperator_Mult, METH_VARARGS, "Mult(RAPOperator self, Vector x, Vector y)"}, - { "RAPOperator_MultTranspose", _wrap_RAPOperator_MultTranspose, METH_VARARGS, "MultTranspose(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RAPOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(RAPOperator self, Vector x, Vector y)"}, + { "RAPOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_RAPOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(RAPOperator self, Vector x, Vector y)"}, { "delete_RAPOperator", _wrap_delete_RAPOperator, METH_O, "delete_RAPOperator(RAPOperator self)"}, { "RAPOperator_swigregister", RAPOperator_swigregister, METH_O, NULL}, { "RAPOperator_swiginit", RAPOperator_swiginit, METH_VARARGS, NULL}, - { "new_TripleProductOperator", _wrap_new_TripleProductOperator, METH_VARARGS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, + { "new_TripleProductOperator", (PyCFunction)(void(*)(void))_wrap_new_TripleProductOperator, METH_VARARGS|METH_KEYWORDS, "new_TripleProductOperator(Operator A, Operator B, Operator C, bool ownA, bool ownB, bool ownC) -> TripleProductOperator"}, { "TripleProductOperator_GetMemoryClass", _wrap_TripleProductOperator_GetMemoryClass, METH_O, "GetMemoryClass(TripleProductOperator self) -> mfem::MemoryClass"}, - { "TripleProductOperator_Mult", _wrap_TripleProductOperator_Mult, METH_VARARGS, "Mult(TripleProductOperator self, Vector x, Vector y)"}, - { "TripleProductOperator_MultTranspose", _wrap_TripleProductOperator_MultTranspose, METH_VARARGS, "MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_Mult", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(TripleProductOperator self, Vector x, Vector y)"}, + { "TripleProductOperator_MultTranspose", (PyCFunction)(void(*)(void))_wrap_TripleProductOperator_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(TripleProductOperator self, Vector x, Vector y)"}, { "delete_TripleProductOperator", _wrap_delete_TripleProductOperator, METH_O, "delete_TripleProductOperator(TripleProductOperator self)"}, { "TripleProductOperator_swigregister", TripleProductOperator_swigregister, METH_O, NULL}, { "TripleProductOperator_swiginit", TripleProductOperator_swiginit, METH_VARARGS, NULL}, - { "new_ConstrainedOperator", _wrap_new_ConstrainedOperator, METH_VARARGS, "ConstrainedOperator(Operator A, intArray list, bool own_A=False)"}, + { "new_ConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_ConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_ConstrainedOperator(Operator A, intArray list, bool own_A=False) -> ConstrainedOperator"}, { "ConstrainedOperator_GetMemoryClass", _wrap_ConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(ConstrainedOperator self) -> mfem::MemoryClass"}, - { "ConstrainedOperator_EliminateRHS", _wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, - { "ConstrainedOperator_Mult", _wrap_ConstrainedOperator_Mult, METH_VARARGS, "Mult(ConstrainedOperator self, Vector x, Vector y)"}, + { "ConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "EliminateRHS(ConstrainedOperator self, Vector x, Vector b)"}, + { "ConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_ConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ConstrainedOperator self, Vector x, Vector y)"}, { "delete_ConstrainedOperator", _wrap_delete_ConstrainedOperator, METH_O, "delete_ConstrainedOperator(ConstrainedOperator self)"}, { "ConstrainedOperator_swigregister", ConstrainedOperator_swigregister, METH_O, NULL}, { "ConstrainedOperator_swiginit", ConstrainedOperator_swiginit, METH_VARARGS, NULL}, - { "new_RectangularConstrainedOperator", _wrap_new_RectangularConstrainedOperator, METH_VARARGS, "RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False)"}, + { "new_RectangularConstrainedOperator", (PyCFunction)(void(*)(void))_wrap_new_RectangularConstrainedOperator, METH_VARARGS|METH_KEYWORDS, "new_RectangularConstrainedOperator(Operator A, intArray trial_list, intArray test_list, bool own_A=False) -> RectangularConstrainedOperator"}, { "RectangularConstrainedOperator_GetMemoryClass", _wrap_RectangularConstrainedOperator_GetMemoryClass, METH_O, "GetMemoryClass(RectangularConstrainedOperator self) -> mfem::MemoryClass"}, - { "RectangularConstrainedOperator_EliminateRHS", _wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS, "EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, - { "RectangularConstrainedOperator_Mult", _wrap_RectangularConstrainedOperator_Mult, METH_VARARGS, "Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, + { "RectangularConstrainedOperator_EliminateRHS", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_EliminateRHS, METH_VARARGS|METH_KEYWORDS, "EliminateRHS(RectangularConstrainedOperator self, Vector x, Vector b)"}, + { "RectangularConstrainedOperator_Mult", (PyCFunction)(void(*)(void))_wrap_RectangularConstrainedOperator_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(RectangularConstrainedOperator self, Vector x, Vector y)"}, { "delete_RectangularConstrainedOperator", _wrap_delete_RectangularConstrainedOperator, METH_O, "delete_RectangularConstrainedOperator(RectangularConstrainedOperator self)"}, { "RectangularConstrainedOperator_swigregister", RectangularConstrainedOperator_swigregister, METH_O, NULL}, { "RectangularConstrainedOperator_swiginit", RectangularConstrainedOperator_swiginit, METH_VARARGS, NULL}, @@ -15517,20 +14065,20 @@ static PyMethodDef SwigMethods_proxydocs[] = { "PyOperatorBase(int s=0)\n" "new_PyOperatorBase(PyObject * _self, int h, int w) -> PyOperatorBase\n" ""}, - { "PyOperatorBase_Mult", _wrap_PyOperatorBase_Mult, METH_VARARGS, "Mult(PyOperatorBase self, Vector x, Vector y)"}, - { "PyOperatorBase__EvalMult", _wrap_PyOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, + { "PyOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(PyOperatorBase self, Vector x, Vector y)"}, + { "PyOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "_EvalMult(PyOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyOperatorBase", _wrap_delete_PyOperatorBase, METH_O, "delete_PyOperatorBase(PyOperatorBase self)"}, - { "disown_PyOperatorBase", _wrap_disown_PyOperatorBase, METH_O, NULL}, + { "disown_PyOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyOperatorBase_swigregister", PyOperatorBase_swigregister, METH_O, NULL}, { "PyOperatorBase_swiginit", PyOperatorBase_swiginit, METH_VARARGS, NULL}, { "new_PyTimeDependentOperatorBase", _wrap_new_PyTimeDependentOperatorBase, METH_VARARGS, "\n" "PyTimeDependentOperatorBase(int n=0, double _t=0.0)\n" - "PyTimeDependentOperatorBase(int h, int w, double _t=0.0)\n" + "new_PyTimeDependentOperatorBase(PyObject * _self, int h, int w, double _t=0.0) -> PyTimeDependentOperatorBase\n" ""}, - { "PyTimeDependentOperatorBase_Mult", _wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS, "Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, - { "PyTimeDependentOperatorBase__EvalMult", _wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS, "_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, + { "PyTimeDependentOperatorBase_Mult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(PyTimeDependentOperatorBase self, Vector x, Vector y)"}, + { "PyTimeDependentOperatorBase__EvalMult", (PyCFunction)(void(*)(void))_wrap_PyTimeDependentOperatorBase__EvalMult, METH_VARARGS|METH_KEYWORDS, "_EvalMult(PyTimeDependentOperatorBase self, Vector arg0) -> Vector"}, { "delete_PyTimeDependentOperatorBase", _wrap_delete_PyTimeDependentOperatorBase, METH_O, "delete_PyTimeDependentOperatorBase(PyTimeDependentOperatorBase self)"}, - { "disown_PyTimeDependentOperatorBase", _wrap_disown_PyTimeDependentOperatorBase, METH_O, NULL}, + { "disown_PyTimeDependentOperatorBase", (PyCFunction)(void(*)(void))_wrap_disown_PyTimeDependentOperatorBase, METH_VARARGS|METH_KEYWORDS, NULL}, { "PyTimeDependentOperatorBase_swigregister", PyTimeDependentOperatorBase_swigregister, METH_O, NULL}, { "PyTimeDependentOperatorBase_swiginit", PyTimeDependentOperatorBase_swiginit, METH_VARARGS, NULL}, { NULL, NULL, 0, NULL } diff --git a/mfem/_ser/point_wrap.cxx b/mfem/_ser/point_wrap.cxx index 33aa3da0..c79aed7e 100644 --- a/mfem/_ser/point_wrap.cxx +++ b/mfem/_ser/point_wrap.cxx @@ -3235,11 +3235,11 @@ SWIGINTERN PyObject *_wrap_new_Point__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_Point__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; - int arg2 ; + int arg2 = (int) -1 ; int temp1 ; mfem::Point *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if (PyInt_Check(swig_obj[0])) { temp1 = PyInt_AsLong(swig_obj[0]); @@ -3251,14 +3251,16 @@ SWIGINTERN PyObject *_wrap_new_Point__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } arg1 = &temp1; } - { - if (PyInt_Check(swig_obj[1])) { - arg2 = PyInt_AsLong(swig_obj[1]); - } else if ((PyArray_PyIntAsInt(swig_obj[1]) != -1) || !PyErr_Occurred()) { - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; + if (swig_obj[1]) { + { + if (PyInt_Check(swig_obj[1])) { + arg2 = PyInt_AsLong(swig_obj[1]); + } else if ((PyArray_PyIntAsInt(swig_obj[1]) != -1) || !PyErr_Occurred()) { + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } else { + PyErr_SetString(PyExc_ValueError, "Expecting a integer"); + return NULL; + } } } { @@ -3287,50 +3289,6 @@ SWIGINTERN PyObject *_wrap_new_Point__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_new_Point__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int *arg1 = (int *) 0 ; - int temp1 ; - mfem::Point *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if (PyInt_Check(swig_obj[0])) { - temp1 = PyInt_AsLong(swig_obj[0]); - } else if ((PyArray_PyIntAsInt(swig_obj[0]) != -1) || !PyErr_Occurred()) { - temp1 = PyArray_PyIntAsInt(swig_obj[0]); - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a integer"); - return NULL; - } - arg1 = &temp1; - } - { - try { - result = (mfem::Point *)new mfem::Point((int const *)arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Point, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[3] = { @@ -3342,7 +3300,7 @@ SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Point__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if (PyInt_Check(argv[0])) { @@ -3354,21 +3312,9 @@ SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Point__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if (PyInt_Check(argv[0])) { - _v = 1; - } else if ((PyArray_PyIntAsInt(argv[0]) != -1) || !PyErr_Occurred()) { - _v = 1; - } else { - _v = 0; + if (argc <= 1) { + return _wrap_new_Point__SWIG_1(self, argc, argv); } - } - if (_v) { { if (PyInt_Check(argv[1])) { _v = 1; @@ -3388,8 +3334,7 @@ SWIGINTERN PyObject *_wrap_new_Point(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_Point'.\n" " Possible C/C++ prototypes are:\n" " mfem::Point::Point()\n" - " mfem::Point::Point(int const *,int)\n" - " mfem::Point::Point(int const *)\n"); + " mfem::Point::Point(int const *,int)\n"); return 0; } @@ -3648,26 +3593,30 @@ SWIGINTERN PyObject *_wrap_Point_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Point_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ei", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Point_GetEdgeVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_GetEdgeVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3825,26 +3774,30 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaces(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Point_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_GetNFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3872,26 +3825,30 @@ SWIGINTERN PyObject *_wrap_Point_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Point_GetFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_GetFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_GetFaceVertices" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3919,7 +3876,7 @@ SWIGINTERN PyObject *_wrap_Point_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Point_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Point_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Point *arg1 = (mfem::Point *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -3927,16 +3884,20 @@ SWIGINTERN PyObject *_wrap_Point_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::Element *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Point_Duplicate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Point_Duplicate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Point, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Duplicate" "', argument " "1"" of type '" "mfem::Point const *""'"); } arg1 = reinterpret_cast< mfem::Point * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Point_Duplicate" "', argument " "2"" of type '" "mfem::Mesh *""'"); } @@ -4053,7 +4014,7 @@ static PyMethodDef SwigMethods[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" "Point()\n" - "Point(int const * ind, int attr=-1)\n" + "new_Point(int const * ind, int attr=-1) -> Point\n" ""}, { "Point_GetType", _wrap_Point_GetType, METH_O, "Point_GetType(Point self) -> mfem::Element::Type"}, { "Point_GetVertices", _wrap_Point_GetVertices, METH_VARARGS, "\n" @@ -4062,14 +4023,14 @@ static PyMethodDef SwigMethods[] = { ""}, { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "Point_GetNVertices(Point self) -> int"}, { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "Point_GetNEdges(Point self) -> int"}, - { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "Point_GetEdgeVertices(Point self, int ei) -> int const *"}, + { "Point_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Point_GetEdgeVertices(Point self, int ei) -> int const *"}, { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" "Point_GetNFaces(Point self, int & nFaceVertices) -> int\n" "Point_GetNFaces(Point self) -> int\n" ""}, - { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "Point_GetNFaceVertices(Point self, int arg2) -> int"}, - { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "Point_GetFaceVertices(Point self, int fi) -> int const *"}, - { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Point_Duplicate(Point self, mfem::Mesh * m) -> Element"}, + { "Point_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "Point_GetNFaceVertices(Point self, int arg2) -> int"}, + { "Point_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Point_GetFaceVertices(Point self, int fi) -> int const *"}, + { "Point_Duplicate", (PyCFunction)(void(*)(void))_wrap_Point_Duplicate, METH_VARARGS|METH_KEYWORDS, "Point_Duplicate(Point self, mfem::Mesh * m) -> Element"}, { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, { "Point_swigregister", Point_swigregister, METH_O, NULL}, { "Point_swiginit", Point_swiginit, METH_VARARGS, NULL}, @@ -4081,7 +4042,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, { "new_Point", _wrap_new_Point, METH_VARARGS, "\n" "Point()\n" - "Point(int const * ind, int attr=-1)\n" + "new_Point(int const * ind, int attr=-1) -> Point\n" ""}, { "Point_GetType", _wrap_Point_GetType, METH_O, "GetType(Point self) -> mfem::Element::Type"}, { "Point_GetVertices", _wrap_Point_GetVertices, METH_VARARGS, "\n" @@ -4090,14 +4051,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Point_GetNVertices", _wrap_Point_GetNVertices, METH_O, "GetNVertices(Point self) -> int"}, { "Point_GetNEdges", _wrap_Point_GetNEdges, METH_O, "GetNEdges(Point self) -> int"}, - { "Point_GetEdgeVertices", _wrap_Point_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Point self, int ei) -> int const *"}, + { "Point_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Point self, int ei) -> int const *"}, { "Point_GetNFaces", _wrap_Point_GetNFaces, METH_VARARGS, "\n" "GetNFaces(Point self, int & nFaceVertices) -> int\n" "GetNFaces(Point self) -> int\n" ""}, - { "Point_GetNFaceVertices", _wrap_Point_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Point self, int arg2) -> int"}, - { "Point_GetFaceVertices", _wrap_Point_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Point self, int fi) -> int const *"}, - { "Point_Duplicate", _wrap_Point_Duplicate, METH_VARARGS, "Duplicate(Point self, mfem::Mesh * m) -> Element"}, + { "Point_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetNFaceVertices(Point self, int arg2) -> int"}, + { "Point_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Point_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Point self, int fi) -> int const *"}, + { "Point_Duplicate", (PyCFunction)(void(*)(void))_wrap_Point_Duplicate, METH_VARARGS|METH_KEYWORDS, "Duplicate(Point self, mfem::Mesh * m) -> Element"}, { "delete_Point", _wrap_delete_Point, METH_O, "delete_Point(Point self)"}, { "Point_swigregister", Point_swigregister, METH_O, NULL}, { "Point_swiginit", Point_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/restriction.py b/mfem/_ser/restriction.py index e9d6ef7f..01510bbb 100644 --- a/mfem/_ser/restriction.py +++ b/mfem/_ser/restriction.py @@ -179,9 +179,9 @@ class L2FaceRestriction(mfem._ser.operators.Operator): thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") __repr__ = _swig_repr - def __init__(self, *args): + def __init__(self, *args, **kwargs): r"""__init__(L2FaceRestriction self, FiniteElementSpace arg2, mfem::ElementDofOrdering const arg3, mfem::FaceType const arg4, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction""" - _restriction.L2FaceRestriction_swiginit(self, _restriction.new_L2FaceRestriction(*args)) + _restriction.L2FaceRestriction_swiginit(self, _restriction.new_L2FaceRestriction(*args, **kwargs)) def Mult(self, x, y): r"""Mult(L2FaceRestriction self, Vector x, Vector y)""" diff --git a/mfem/_ser/restriction_wrap.cxx b/mfem/_ser/restriction_wrap.cxx index 14586468..6a208c9f 100644 --- a/mfem/_ser/restriction_wrap.cxx +++ b/mfem/_ser/restriction_wrap.cxx @@ -3388,7 +3388,7 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::ElementDofOrdering arg2 ; @@ -3396,11 +3396,15 @@ SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"arg1", (char *)"arg2", NULL + }; mfem::ElementRestriction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_ElementRestriction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_ElementRestriction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -3408,7 +3412,7 @@ SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ElementRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } @@ -3439,7 +3443,7 @@ SWIGINTERN PyObject *_wrap_new_ElementRestriction(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3450,15 +3454,20 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3466,7 +3475,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3500,7 +3509,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3511,15 +3520,20 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSED int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3527,7 +3541,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3561,7 +3575,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTranspose(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ElementRestriction *arg1 = (mfem::ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3572,15 +3586,20 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SW int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ElementRestriction_MultTransposeUnsigned", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElementRestriction_MultTransposeUnsigned", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "1"" of type '" "mfem::ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3588,7 +3607,7 @@ SWIGINTERN PyObject *_wrap_ElementRestriction_MultTransposeUnsigned(PyObject *SW SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElementRestriction_MultTransposeUnsigned" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3673,17 +3692,19 @@ SWIGINTERN PyObject *ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"arg1", NULL + }; mfem::L2ElementRestriction *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_L2ElementRestriction", kwnames, &obj0)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2ElementRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -3717,7 +3738,7 @@ SWIGINTERN PyObject *_wrap_new_L2ElementRestriction(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3728,15 +3749,20 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(se int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2ElementRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_Mult" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3744,7 +3770,7 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3778,7 +3804,7 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_Mult(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2ElementRestriction *arg1 = (mfem::L2ElementRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3789,15 +3815,20 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUS int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2ElementRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2ElementRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2ElementRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2ElementRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2ElementRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3805,7 +3836,7 @@ SWIGINTERN PyObject *_wrap_L2ElementRestriction_MultTranspose(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2ElementRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2ElementRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3890,7 +3921,7 @@ SWIGINTERN PyObject *L2ElementRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::ElementDofOrdering arg2 ; @@ -3901,11 +3932,16 @@ SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), int ecode2 = 0 ; int val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"arg1", (char *)"arg2", (char *)"arg3", NULL + }; mfem::H1FaceRestriction *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "new_H1FaceRestriction", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:new_H1FaceRestriction", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -3913,12 +3949,12 @@ SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_H1FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_H1FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_H1FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } @@ -3949,7 +3985,7 @@ SWIGINTERN PyObject *_wrap_new_H1FaceRestriction(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3960,15 +3996,20 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1FaceRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3976,7 +4017,7 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4010,7 +4051,7 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::H1FaceRestriction *arg1 = (mfem::H1FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4021,15 +4062,20 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "H1FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:H1FaceRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__H1FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::H1FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::H1FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4037,7 +4083,7 @@ SWIGINTERN PyObject *_wrap_H1FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "H1FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "H1FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4122,12 +4168,12 @@ SWIGINTERN PyObject *H1FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_L2FaceRestriction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::FiniteElementSpace *arg1 = 0 ; mfem::ElementDofOrdering arg2 ; mfem::FaceType arg3 ; - mfem::L2FaceValues arg4 ; + mfem::L2FaceValues arg4 = (mfem::L2FaceValues) (mfem::L2FaceValues)mfem::L2FaceValues::DoubleValued ; void *argp1 = 0 ; int res1 = 0 ; int val2 ; @@ -4136,10 +4182,17 @@ SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPAR int ecode3 = 0 ; int val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"arg1", (char *)"arg2", (char *)"arg3", (char *)"m", NULL + }; mfem::L2FaceRestriction *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:new_L2FaceRestriction", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } @@ -4147,82 +4200,26 @@ SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_0(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); } arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); } arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_int(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); } arg3 = static_cast< mfem::FaceType >(val3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); - } - arg4 = static_cast< mfem::L2FaceValues >(val4); - { - try { - result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__L2FaceRestriction, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::FiniteElementSpace *arg1 = 0 ; - mfem::ElementDofOrdering arg2 ; - mfem::FaceType arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int val2 ; - int ecode2 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::L2FaceRestriction *result = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__FiniteElementSpace, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_L2FaceRestriction" "', argument " "1"" of type '" "mfem::FiniteElementSpace const &""'"); + if (obj3) { + ecode4 = SWIG_AsVal_int(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_L2FaceRestriction" "', argument " "4"" of type '" "mfem::L2FaceValues""'"); + } + arg4 = static_cast< mfem::L2FaceValues >(val4); } - arg1 = reinterpret_cast< mfem::FiniteElementSpace * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_L2FaceRestriction" "', argument " "2"" of type '" "mfem::ElementDofOrdering""'"); - } - arg2 = static_cast< mfem::ElementDofOrdering >(val2); - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_L2FaceRestriction" "', argument " "3"" of type '" "mfem::FaceType""'"); - } - arg3 = static_cast< mfem::FaceType >(val3); { try { - result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3); + result = (mfem::L2FaceRestriction *)new mfem::L2FaceRestriction((mfem::FiniteElementSpace const &)*arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4246,71 +4243,7 @@ SWIGINTERN PyObject *_wrap_new_L2FaceRestriction__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_new_L2FaceRestriction(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_L2FaceRestriction", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_L2FaceRestriction__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__FiniteElementSpace, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_L2FaceRestriction__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_L2FaceRestriction'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const,mfem::L2FaceValues const)\n" - " mfem::L2FaceRestriction::L2FaceRestriction(mfem::FiniteElementSpace const &,mfem::ElementDofOrdering const,mfem::FaceType const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4321,15 +4254,20 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2FaceRestriction_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_Mult" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4337,7 +4275,7 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4371,7 +4309,7 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_Mult(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::L2FaceRestriction *arg1 = (mfem::L2FaceRestriction *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4382,15 +4320,20 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "L2FaceRestriction_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:L2FaceRestriction_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__L2FaceRestriction, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "1"" of type '" "mfem::L2FaceRestriction const *""'"); } arg1 = reinterpret_cast< mfem::L2FaceRestriction * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4398,7 +4341,7 @@ SWIGINTERN PyObject *_wrap_L2FaceRestriction_MultTranspose(PyObject *SWIGUNUSEDP SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "L2FaceRestriction_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "L2FaceRestriction_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4483,7 +4426,7 @@ SWIGINTERN PyObject *L2FaceRestriction_swiginit(PyObject *SWIGUNUSEDPARM(self), return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -4491,28 +4434,34 @@ SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject mfem::Array< int > *arg4 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"face_id", (char *)"dof1d", (char *)"faceMap", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GetFaceDofs", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:GetFaceDofs", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GetFaceDofs" "', argument " "4"" of type '" "mfem::Array< int > &""'"); } @@ -4546,39 +4495,45 @@ SWIGINTERN PyObject *_wrap_GetFaceDofs(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"face_id", (char *)"size1d", (char *)"index", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ToLexOrdering", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:ToLexOrdering", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -4606,7 +4561,7 @@ SWIGINTERN PyObject *_wrap_ToLexOrdering(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -4614,45 +4569,53 @@ SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObjec int arg4 ; int arg5 ; int arg6 ; - PyObject *swig_obj[6] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"face_id1", (char *)"face_id2", (char *)"orientation", (char *)"size1d", (char *)"index", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "PermuteFaceL2", 6, 6, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:PermuteFaceL2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg6 = PyArray_PyIntAsInt(obj5); } { try { @@ -4683,68 +4646,68 @@ SWIGINTERN PyObject *_wrap_PermuteFaceL2(PyObject *SWIGUNUSEDPARM(self), PyObjec static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, - { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "ElementRestriction_MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "new_ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "ElementRestriction_Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "ElementRestriction_MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS|METH_KEYWORDS, "ElementRestriction_MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, - { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "L2ElementRestriction_Mult(L2ElementRestriction self, Vector x, Vector y)"}, - { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "L2ElementRestriction_MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "new_L2ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "L2ElementRestriction_Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "L2ElementRestriction_MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, - { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "H1FaceRestriction_Mult(H1FaceRestriction self, Vector x, Vector y)"}, - { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "H1FaceRestriction_MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "new_H1FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_H1FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "H1FaceRestriction_Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "H1FaceRestriction_MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, - { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "L2FaceRestriction_Mult(L2FaceRestriction self, Vector x, Vector y)"}, - { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "L2FaceRestriction_MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "new_L2FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction"}, + { "L2FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "L2FaceRestriction_Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "L2FaceRestriction_MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, - { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, - { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { "GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", (PyCFunction)(void(*)(void))_wrap_ToLexOrdering, METH_VARARGS|METH_KEYWORDS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", (PyCFunction)(void(*)(void))_wrap_PermuteFaceL2, METH_VARARGS|METH_KEYWORDS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, { NULL, NULL, 0, NULL } }; static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "new_ElementRestriction", _wrap_new_ElementRestriction, METH_VARARGS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, - { "ElementRestriction_Mult", _wrap_ElementRestriction_Mult, METH_VARARGS, "Mult(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTranspose", _wrap_ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(ElementRestriction self, Vector x, Vector y)"}, - { "ElementRestriction_MultTransposeUnsigned", _wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS, "MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, + { "new_ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_ElementRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering arg2) -> ElementRestriction"}, + { "ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(ElementRestriction self, Vector x, Vector y)"}, + { "ElementRestriction_MultTransposeUnsigned", (PyCFunction)(void(*)(void))_wrap_ElementRestriction_MultTransposeUnsigned, METH_VARARGS|METH_KEYWORDS, "MultTransposeUnsigned(ElementRestriction self, Vector x, Vector y)"}, { "delete_ElementRestriction", _wrap_delete_ElementRestriction, METH_O, "delete_ElementRestriction(ElementRestriction self)"}, { "ElementRestriction_swigregister", ElementRestriction_swigregister, METH_O, NULL}, { "ElementRestriction_swiginit", ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2ElementRestriction", _wrap_new_L2ElementRestriction, METH_O, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, - { "L2ElementRestriction_Mult", _wrap_L2ElementRestriction_Mult, METH_VARARGS, "Mult(L2ElementRestriction self, Vector x, Vector y)"}, - { "L2ElementRestriction_MultTranspose", _wrap_L2ElementRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, + { "new_L2ElementRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2ElementRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2ElementRestriction(FiniteElementSpace arg1) -> L2ElementRestriction"}, + { "L2ElementRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(L2ElementRestriction self, Vector x, Vector y)"}, + { "L2ElementRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2ElementRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(L2ElementRestriction self, Vector x, Vector y)"}, { "delete_L2ElementRestriction", _wrap_delete_L2ElementRestriction, METH_O, "delete_L2ElementRestriction(L2ElementRestriction self)"}, { "L2ElementRestriction_swigregister", L2ElementRestriction_swigregister, METH_O, NULL}, { "L2ElementRestriction_swiginit", L2ElementRestriction_swiginit, METH_VARARGS, NULL}, - { "new_H1FaceRestriction", _wrap_new_H1FaceRestriction, METH_VARARGS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, - { "H1FaceRestriction_Mult", _wrap_H1FaceRestriction_Mult, METH_VARARGS, "Mult(H1FaceRestriction self, Vector x, Vector y)"}, - { "H1FaceRestriction_MultTranspose", _wrap_H1FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, + { "new_H1FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_H1FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_H1FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3) -> H1FaceRestriction"}, + { "H1FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(H1FaceRestriction self, Vector x, Vector y)"}, + { "H1FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_H1FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(H1FaceRestriction self, Vector x, Vector y)"}, { "delete_H1FaceRestriction", _wrap_delete_H1FaceRestriction, METH_O, "delete_H1FaceRestriction(H1FaceRestriction self)"}, { "H1FaceRestriction_swigregister", H1FaceRestriction_swigregister, METH_O, NULL}, { "H1FaceRestriction_swiginit", H1FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "new_L2FaceRestriction", _wrap_new_L2FaceRestriction, METH_VARARGS, "L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued)"}, - { "L2FaceRestriction_Mult", _wrap_L2FaceRestriction_Mult, METH_VARARGS, "Mult(L2FaceRestriction self, Vector x, Vector y)"}, - { "L2FaceRestriction_MultTranspose", _wrap_L2FaceRestriction_MultTranspose, METH_VARARGS, "MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, + { "new_L2FaceRestriction", (PyCFunction)(void(*)(void))_wrap_new_L2FaceRestriction, METH_VARARGS|METH_KEYWORDS, "new_L2FaceRestriction(FiniteElementSpace arg1, mfem::ElementDofOrdering const arg2, mfem::FaceType const arg3, mfem::L2FaceValues const m=DoubleValued) -> L2FaceRestriction"}, + { "L2FaceRestriction_Mult", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(L2FaceRestriction self, Vector x, Vector y)"}, + { "L2FaceRestriction_MultTranspose", (PyCFunction)(void(*)(void))_wrap_L2FaceRestriction_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(L2FaceRestriction self, Vector x, Vector y)"}, { "delete_L2FaceRestriction", _wrap_delete_L2FaceRestriction, METH_O, "delete_L2FaceRestriction(L2FaceRestriction self)"}, { "L2FaceRestriction_swigregister", L2FaceRestriction_swigregister, METH_O, NULL}, { "L2FaceRestriction_swiginit", L2FaceRestriction_swiginit, METH_VARARGS, NULL}, - { "GetFaceDofs", _wrap_GetFaceDofs, METH_VARARGS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, - { "ToLexOrdering", _wrap_ToLexOrdering, METH_VARARGS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, - { "PermuteFaceL2", _wrap_PermuteFaceL2, METH_VARARGS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, + { "GetFaceDofs", (PyCFunction)(void(*)(void))_wrap_GetFaceDofs, METH_VARARGS|METH_KEYWORDS, "GetFaceDofs(int const dim, int const face_id, int const dof1d, intArray faceMap)"}, + { "ToLexOrdering", (PyCFunction)(void(*)(void))_wrap_ToLexOrdering, METH_VARARGS|METH_KEYWORDS, "ToLexOrdering(int const dim, int const face_id, int const size1d, int const index) -> int"}, + { "PermuteFaceL2", (PyCFunction)(void(*)(void))_wrap_PermuteFaceL2, METH_VARARGS|METH_KEYWORDS, "PermuteFaceL2(int const dim, int const face_id1, int const face_id2, int const orientation, int const size1d, int const index) -> int"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/segment_wrap.cxx b/mfem/_ser/segment_wrap.cxx index f791c049..8d2394a7 100644 --- a/mfem/_ser/segment_wrap.cxx +++ b/mfem/_ser/segment_wrap.cxx @@ -3235,11 +3235,11 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P SWIGINTERN PyObject *_wrap_new_Segment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; - int arg2 ; + int arg2 = (int) 1 ; int temp1[2] ; mfem::Segment *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if (PyList_Check(swig_obj[0])) { int ll = PyList_Size(swig_obj[0]); @@ -3260,11 +3260,13 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P arg1 = temp1; } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -3293,66 +3295,13 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P SWIGINTERN PyObject *_wrap_new_Segment__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int *arg1 = (int *) 0 ; - int temp1[2] ; - mfem::Segment *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if (PyList_Check(swig_obj[0])) { - int ll = PyList_Size(swig_obj[0]); - for (int i = 0; i < ll; i++) { - PyObject *s = PyList_GetItem(swig_obj[0],i); - temp1[i] = (int)PyInt_AsLong(s); - } - } else if (PyTuple_Check(swig_obj[0])) { - int ll = PyTuple_Size(swig_obj[0]); - for (int i = 0; i < ll; i++) { - PyObject *s = PyTuple_GetItem(swig_obj[0],i); - temp1[i] = (int)PyInt_AsLong(s); - } - } else { - PyErr_SetString(PyExc_ValueError, "Expecting a list/tuple"); - return NULL; - } - - arg1 = temp1; - } - { - try { - result = (mfem::Segment *)new mfem::Segment((int const *)arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Segment, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Segment__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; - int arg3 ; + int arg3 = (int) 1 ; mfem::Segment *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); @@ -3365,60 +3314,17 @@ SWIGINTERN PyObject *_wrap_new_Segment__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::Segment *)new mfem::Segment(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Segment, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Segment__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - int arg2 ; - mfem::Segment *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); } { try { - result = (mfem::Segment *)new mfem::Segment(arg1,arg2); + result = (mfem::Segment *)new mfem::Segment(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3453,7 +3359,7 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_Segment__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { _v = 0; @@ -3470,26 +3376,9 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } if (_v) { - return _wrap_new_Segment__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - _v = 0; - if (PyList_Check(argv[0])){ - if (PyList_Size(argv[0]) == 2){ - _v = 1; - } - } - if (PyTuple_Check(argv[0])){ - if (PyTuple_Size(argv[0]) == 2){ - _v = 1; - } + if (argc <= 1) { + return _wrap_new_Segment__SWIG_1(self, argc, argv); } - - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3503,7 +3392,7 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -3523,30 +3412,9 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Segment__SWIG_4(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_Segment__SWIG_2(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3556,7 +3424,7 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Segment__SWIG_3(self, argc, argv); + return _wrap_new_Segment__SWIG_2(self, argc, argv); } } } @@ -3567,39 +3435,41 @@ SWIGINTERN PyObject *_wrap_new_Segment(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::Segment::Segment()\n" " mfem::Segment::Segment(int const *,int)\n" - " mfem::Segment::Segment(int const *)\n" - " mfem::Segment::Segment(int,int,int)\n" - " mfem::Segment::Segment(int,int)\n"); + " mfem::Segment::Segment(int,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Segment_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_SetVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int *arg2 = (int *) 0 ; void *argp1 = 0 ; int res1 = 0 ; int temp2[2] ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ind", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Segment_SetVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_SetVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_SetVertices" "', argument " "1"" of type '" "mfem::Segment *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if (PyList_Check(swig_obj[1])) { - int ll = PyList_Size(swig_obj[1]); + if (PyList_Check(obj1)) { + int ll = PyList_Size(obj1); for (int i = 0; i < ll; i++) { - PyObject *s = PyList_GetItem(swig_obj[1],i); + PyObject *s = PyList_GetItem(obj1,i); temp2[i] = (int)PyInt_AsLong(s); } - } else if (PyTuple_Check(swig_obj[1])) { - int ll = PyTuple_Size(swig_obj[1]); + } else if (PyTuple_Check(obj1)) { + int ll = PyTuple_Size(obj1); for (int i = 0; i < ll; i++) { - PyObject *s = PyTuple_GetItem(swig_obj[1],i); + PyObject *s = PyTuple_GetItem(obj1,i); temp2[i] = (int)PyInt_AsLong(s); } } else { @@ -3892,26 +3762,30 @@ SWIGINTERN PyObject *_wrap_Segment_GetNEdges(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Segment_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetEdgeVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ei", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetEdgeVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_GetEdgeVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetEdgeVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4069,26 +3943,30 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaces(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"arg2", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetNFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_GetNFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetNFaceVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4116,26 +3994,30 @@ SWIGINTERN PyObject *_wrap_Segment_GetNFaceVertices(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"fi", NULL + }; int *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Segment_GetFaceVertices", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_GetFaceVertices", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_GetFaceVertices" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4163,7 +4045,7 @@ SWIGINTERN PyObject *_wrap_Segment_GetFaceVertices(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_Segment_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Segment_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Segment *arg1 = (mfem::Segment *) 0 ; mfem::Mesh *arg2 = (mfem::Mesh *) 0 ; @@ -4171,16 +4053,20 @@ SWIGINTERN PyObject *_wrap_Segment_Duplicate(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"m", NULL + }; mfem::Element *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Segment_Duplicate", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Segment_Duplicate", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Segment, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Segment_Duplicate" "', argument " "1"" of type '" "mfem::Segment const *""'"); } arg1 = reinterpret_cast< mfem::Segment * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mfem__Mesh, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Segment_Duplicate" "', argument " "2"" of type '" "mfem::Mesh *""'"); } @@ -4298,9 +4184,9 @@ static PyMethodDef SwigMethods[] = { { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" "Segment()\n" "Segment(int const * ind, int attr=1)\n" - "Segment(int ind1, int ind2, int attr=1)\n" + "new_Segment(int ind1, int ind2, int attr=1) -> Segment\n" ""}, - { "Segment_SetVertices", _wrap_Segment_SetVertices, METH_VARARGS, "Segment_SetVertices(Segment self, int const * ind)"}, + { "Segment_SetVertices", (PyCFunction)(void(*)(void))_wrap_Segment_SetVertices, METH_VARARGS|METH_KEYWORDS, "Segment_SetVertices(Segment self, int const * ind)"}, { "Segment_GetType", _wrap_Segment_GetType, METH_O, "Segment_GetType(Segment self) -> mfem::Element::Type"}, { "Segment_GetVertices", _wrap_Segment_GetVertices, METH_VARARGS, "\n" "Segment_GetVertices(Segment self, intArray v)\n" @@ -4308,14 +4194,14 @@ static PyMethodDef SwigMethods[] = { ""}, { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "Segment_GetNVertices(Segment self) -> int"}, { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "Segment_GetNEdges(Segment self) -> int"}, - { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "Segment_GetEdgeVertices(Segment self, int ei) -> int const *"}, + { "Segment_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "Segment_GetEdgeVertices(Segment self, int ei) -> int const *"}, { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" "Segment_GetNFaces(Segment self, int & nFaceVertices) -> int\n" "Segment_GetNFaces(Segment self) -> int\n" ""}, - { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "Segment_GetNFaceVertices(Segment self, int arg2) -> int"}, - { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "Segment_GetFaceVertices(Segment self, int fi) -> int const *"}, - { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Segment_Duplicate(Segment self, mfem::Mesh * m) -> Element"}, + { "Segment_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "Segment_GetNFaceVertices(Segment self, int arg2) -> int"}, + { "Segment_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "Segment_GetFaceVertices(Segment self, int fi) -> int const *"}, + { "Segment_Duplicate", (PyCFunction)(void(*)(void))_wrap_Segment_Duplicate, METH_VARARGS|METH_KEYWORDS, "Segment_Duplicate(Segment self, mfem::Mesh * m) -> Element"}, { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, { "Segment_swigregister", Segment_swigregister, METH_O, NULL}, { "Segment_swiginit", Segment_swiginit, METH_VARARGS, NULL}, @@ -4328,9 +4214,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "new_Segment", _wrap_new_Segment, METH_VARARGS, "\n" "Segment()\n" "Segment(int const * ind, int attr=1)\n" - "Segment(int ind1, int ind2, int attr=1)\n" + "new_Segment(int ind1, int ind2, int attr=1) -> Segment\n" ""}, - { "Segment_SetVertices", _wrap_Segment_SetVertices, METH_VARARGS, "SetVertices(Segment self, int const * ind)"}, + { "Segment_SetVertices", (PyCFunction)(void(*)(void))_wrap_Segment_SetVertices, METH_VARARGS|METH_KEYWORDS, "SetVertices(Segment self, int const * ind)"}, { "Segment_GetType", _wrap_Segment_GetType, METH_O, "GetType(Segment self) -> mfem::Element::Type"}, { "Segment_GetVertices", _wrap_Segment_GetVertices, METH_VARARGS, "\n" "GetVertices(Segment self, intArray v)\n" @@ -4338,14 +4224,14 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Segment_GetNVertices", _wrap_Segment_GetNVertices, METH_O, "GetNVertices(Segment self) -> int"}, { "Segment_GetNEdges", _wrap_Segment_GetNEdges, METH_O, "GetNEdges(Segment self) -> int"}, - { "Segment_GetEdgeVertices", _wrap_Segment_GetEdgeVertices, METH_VARARGS, "GetEdgeVertices(Segment self, int ei) -> int const *"}, + { "Segment_GetEdgeVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetEdgeVertices, METH_VARARGS|METH_KEYWORDS, "GetEdgeVertices(Segment self, int ei) -> int const *"}, { "Segment_GetNFaces", _wrap_Segment_GetNFaces, METH_VARARGS, "\n" "GetNFaces(Segment self, int & nFaceVertices) -> int\n" "GetNFaces(Segment self) -> int\n" ""}, - { "Segment_GetNFaceVertices", _wrap_Segment_GetNFaceVertices, METH_VARARGS, "GetNFaceVertices(Segment self, int arg2) -> int"}, - { "Segment_GetFaceVertices", _wrap_Segment_GetFaceVertices, METH_VARARGS, "GetFaceVertices(Segment self, int fi) -> int const *"}, - { "Segment_Duplicate", _wrap_Segment_Duplicate, METH_VARARGS, "Duplicate(Segment self, mfem::Mesh * m) -> Element"}, + { "Segment_GetNFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetNFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetNFaceVertices(Segment self, int arg2) -> int"}, + { "Segment_GetFaceVertices", (PyCFunction)(void(*)(void))_wrap_Segment_GetFaceVertices, METH_VARARGS|METH_KEYWORDS, "GetFaceVertices(Segment self, int fi) -> int const *"}, + { "Segment_Duplicate", (PyCFunction)(void(*)(void))_wrap_Segment_Duplicate, METH_VARARGS|METH_KEYWORDS, "Duplicate(Segment self, mfem::Mesh * m) -> Element"}, { "delete_Segment", _wrap_delete_Segment, METH_O, "delete_Segment(Segment self)"}, { "Segment_swigregister", Segment_swigregister, METH_O, NULL}, { "Segment_swiginit", Segment_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/sets_wrap.cxx b/mfem/_ser/sets_wrap.cxx index 1e7f5756..6a36f8fb 100644 --- a/mfem/_ser/sets_wrap.cxx +++ b/mfem/_ser/sets_wrap.cxx @@ -3059,7 +3059,7 @@ SWIGINTERN PyObject *_wrap_IntegerSet_PickRandomElement(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegerSet *arg1 = (mfem::IntegerSet *) 0 ; mfem::IntegerSet *arg2 = 0 ; @@ -3067,16 +3067,20 @@ SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "IntegerSet___eq__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntegerSet___eq__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerSet___eq__" "', argument " "1"" of type '" "mfem::IntegerSet *""'"); } arg1 = reinterpret_cast< mfem::IntegerSet * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntegerSet___eq__" "', argument " "2"" of type '" "mfem::IntegerSet &""'"); } @@ -3109,7 +3113,7 @@ SWIGINTERN PyObject *_wrap_IntegerSet___eq__(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_IntegerSet_Recreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IntegerSet_Recreate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IntegerSet *arg1 = (mfem::IntegerSet *) 0 ; int arg2 ; @@ -3118,21 +3122,26 @@ SWIGINTERN PyObject *_wrap_IntegerSet_Recreate(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"n", (char *)"p", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IntegerSet_Recreate", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntegerSet_Recreate", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IntegerSet, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntegerSet_Recreate" "', argument " "1"" of type '" "mfem::IntegerSet *""'"); } arg1 = reinterpret_cast< mfem::IntegerSet * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntegerSet_Recreate" "', argument " "3"" of type '" "int const *""'"); } @@ -3246,26 +3255,30 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Size(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_PickElementInSet", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_PickElementInSet", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_PickElementInSet" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3290,26 +3303,30 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickElementInSet(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickRandomElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickRandomElementInSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_PickRandomElementInSet", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_PickRandomElementInSet", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_PickRandomElementInSet" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3334,7 +3351,7 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_PickRandomElementInSet(PyObject *SW } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; mfem::IntegerSet *arg2 = 0 ; @@ -3342,16 +3359,20 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_Insert", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_Insert", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_Insert" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfIntegerSets_Insert" "', argument " "2"" of type '" "mfem::IntegerSet &""'"); } @@ -3382,7 +3403,7 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Insert(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; mfem::IntegerSet *arg2 = 0 ; @@ -3390,16 +3411,20 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"s", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_Lookup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_Lookup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_Lookup" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__IntegerSet, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfIntegerSets_Lookup" "', argument " "2"" of type '" "mfem::IntegerSet &""'"); } @@ -3430,7 +3455,7 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_Lookup(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_ListOfIntegerSets_AsTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_ListOfIntegerSets_AsTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::ListOfIntegerSets *arg1 = (mfem::ListOfIntegerSets *) 0 ; mfem::Table *arg2 = 0 ; @@ -3438,15 +3463,19 @@ SWIGINTERN PyObject *_wrap_ListOfIntegerSets_AsTable(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"t", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "ListOfIntegerSets_AsTable", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ListOfIntegerSets_AsTable", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__ListOfIntegerSets, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListOfIntegerSets_AsTable" "', argument " "1"" of type '" "mfem::ListOfIntegerSets *""'"); } arg1 = reinterpret_cast< mfem::ListOfIntegerSets * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListOfIntegerSets_AsTable" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -3564,17 +3593,17 @@ static PyMethodDef SwigMethods[] = { { "IntegerSet_Size", _wrap_IntegerSet_Size, METH_O, "IntegerSet_Size(IntegerSet self) -> int"}, { "IntegerSet_PickElement", _wrap_IntegerSet_PickElement, METH_O, "IntegerSet_PickElement(IntegerSet self) -> int"}, { "IntegerSet_PickRandomElement", _wrap_IntegerSet_PickRandomElement, METH_O, "IntegerSet_PickRandomElement(IntegerSet self) -> int"}, - { "IntegerSet___eq__", _wrap_IntegerSet___eq__, METH_VARARGS, "IntegerSet___eq__(IntegerSet self, IntegerSet s) -> int"}, - { "IntegerSet_Recreate", _wrap_IntegerSet_Recreate, METH_VARARGS, "IntegerSet_Recreate(IntegerSet self, int const n, int const * p)"}, + { "IntegerSet___eq__", (PyCFunction)(void(*)(void))_wrap_IntegerSet___eq__, METH_VARARGS|METH_KEYWORDS, "IntegerSet___eq__(IntegerSet self, IntegerSet s) -> int"}, + { "IntegerSet_Recreate", (PyCFunction)(void(*)(void))_wrap_IntegerSet_Recreate, METH_VARARGS|METH_KEYWORDS, "IntegerSet_Recreate(IntegerSet self, int const n, int const * p)"}, { "delete_IntegerSet", _wrap_delete_IntegerSet, METH_O, "delete_IntegerSet(IntegerSet self)"}, { "IntegerSet_swigregister", IntegerSet_swigregister, METH_O, NULL}, { "IntegerSet_swiginit", IntegerSet_swiginit, METH_VARARGS, NULL}, { "ListOfIntegerSets_Size", _wrap_ListOfIntegerSets_Size, METH_O, "ListOfIntegerSets_Size(ListOfIntegerSets self) -> int"}, - { "ListOfIntegerSets_PickElementInSet", _wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS, "ListOfIntegerSets_PickElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_PickRandomElementInSet", _wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS, "ListOfIntegerSets_PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_Insert", _wrap_ListOfIntegerSets_Insert, METH_VARARGS, "ListOfIntegerSets_Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_Lookup", _wrap_ListOfIntegerSets_Lookup, METH_VARARGS, "ListOfIntegerSets_Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_AsTable", _wrap_ListOfIntegerSets_AsTable, METH_VARARGS, "ListOfIntegerSets_AsTable(ListOfIntegerSets self, Table t)"}, + { "ListOfIntegerSets_PickElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_PickElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_PickRandomElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_Insert", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Insert, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_Lookup", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Lookup, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_AsTable", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_AsTable, METH_VARARGS|METH_KEYWORDS, "ListOfIntegerSets_AsTable(ListOfIntegerSets self, Table t)"}, { "delete_ListOfIntegerSets", _wrap_delete_ListOfIntegerSets, METH_O, "delete_ListOfIntegerSets(ListOfIntegerSets self)"}, { "new_ListOfIntegerSets", _wrap_new_ListOfIntegerSets, METH_NOARGS, "new_ListOfIntegerSets() -> ListOfIntegerSets"}, { "ListOfIntegerSets_swigregister", ListOfIntegerSets_swigregister, METH_O, NULL}, @@ -3593,17 +3622,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "IntegerSet_Size", _wrap_IntegerSet_Size, METH_O, "Size(IntegerSet self) -> int"}, { "IntegerSet_PickElement", _wrap_IntegerSet_PickElement, METH_O, "PickElement(IntegerSet self) -> int"}, { "IntegerSet_PickRandomElement", _wrap_IntegerSet_PickRandomElement, METH_O, "PickRandomElement(IntegerSet self) -> int"}, - { "IntegerSet___eq__", _wrap_IntegerSet___eq__, METH_VARARGS, "__eq__(IntegerSet self, IntegerSet s) -> int"}, - { "IntegerSet_Recreate", _wrap_IntegerSet_Recreate, METH_VARARGS, "Recreate(IntegerSet self, int const n, int const * p)"}, + { "IntegerSet___eq__", (PyCFunction)(void(*)(void))_wrap_IntegerSet___eq__, METH_VARARGS|METH_KEYWORDS, "__eq__(IntegerSet self, IntegerSet s) -> int"}, + { "IntegerSet_Recreate", (PyCFunction)(void(*)(void))_wrap_IntegerSet_Recreate, METH_VARARGS|METH_KEYWORDS, "Recreate(IntegerSet self, int const n, int const * p)"}, { "delete_IntegerSet", _wrap_delete_IntegerSet, METH_O, "delete_IntegerSet(IntegerSet self)"}, { "IntegerSet_swigregister", IntegerSet_swigregister, METH_O, NULL}, { "IntegerSet_swiginit", IntegerSet_swiginit, METH_VARARGS, NULL}, { "ListOfIntegerSets_Size", _wrap_ListOfIntegerSets_Size, METH_O, "Size(ListOfIntegerSets self) -> int"}, - { "ListOfIntegerSets_PickElementInSet", _wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS, "PickElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_PickRandomElementInSet", _wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS, "PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, - { "ListOfIntegerSets_Insert", _wrap_ListOfIntegerSets_Insert, METH_VARARGS, "Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_Lookup", _wrap_ListOfIntegerSets_Lookup, METH_VARARGS, "Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, - { "ListOfIntegerSets_AsTable", _wrap_ListOfIntegerSets_AsTable, METH_VARARGS, "AsTable(ListOfIntegerSets self, Table t)"}, + { "ListOfIntegerSets_PickElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickElementInSet, METH_VARARGS|METH_KEYWORDS, "PickElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_PickRandomElementInSet", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_PickRandomElementInSet, METH_VARARGS|METH_KEYWORDS, "PickRandomElementInSet(ListOfIntegerSets self, int i) -> int"}, + { "ListOfIntegerSets_Insert", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Insert, METH_VARARGS|METH_KEYWORDS, "Insert(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_Lookup", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_Lookup, METH_VARARGS|METH_KEYWORDS, "Lookup(ListOfIntegerSets self, IntegerSet s) -> int"}, + { "ListOfIntegerSets_AsTable", (PyCFunction)(void(*)(void))_wrap_ListOfIntegerSets_AsTable, METH_VARARGS|METH_KEYWORDS, "AsTable(ListOfIntegerSets self, Table t)"}, { "delete_ListOfIntegerSets", _wrap_delete_ListOfIntegerSets, METH_O, "delete_ListOfIntegerSets(ListOfIntegerSets self)"}, { "new_ListOfIntegerSets", _wrap_new_ListOfIntegerSets, METH_NOARGS, "new_ListOfIntegerSets() -> ListOfIntegerSets"}, { "ListOfIntegerSets_swigregister", ListOfIntegerSets_swigregister, METH_O, NULL}, diff --git a/mfem/_ser/socketstream_wrap.cxx b/mfem/_ser/socketstream_wrap.cxx index ba0faf81..fa8441bf 100644 --- a/mfem/_ser/socketstream_wrap.cxx +++ b/mfem/_ser/socketstream_wrap.cxx @@ -3689,26 +3689,30 @@ SWIGINTERN PyObject *_wrap_new_socketbuf(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_socketbuf_attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketbuf_attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketbuf *arg1 = (mfem::socketbuf *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sd", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "socketbuf_attach", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:socketbuf_attach", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketbuf_attach" "', argument " "1"" of type '" "mfem::socketbuf *""'"); } arg1 = reinterpret_cast< mfem::socketbuf * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3777,7 +3781,7 @@ SWIGINTERN PyObject *_wrap_socketbuf_detach(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_socketbuf_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketbuf_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketbuf *arg1 = (mfem::socketbuf *) 0 ; char *arg2 ; @@ -3787,25 +3791,30 @@ SWIGINTERN PyObject *_wrap_socketbuf_open(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"hostname", (char *)"port", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "socketbuf_open", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:socketbuf_open", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketbuf, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketbuf_open" "', argument " "1"" of type '" "mfem::socketbuf *""'"); } arg1 = reinterpret_cast< mfem::socketbuf * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketbuf_open" "', argument " "2"" of type '" "char const []""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4011,51 +4020,22 @@ SWIGINTERN PyObject *socketbuf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - bool arg1 ; + bool arg1 = (bool) mfem::socketstream::secure_default ; bool val1 ; int ecode1 = 0 ; mfem::socketstream *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); - if (!SWIG_IsOK(ecode1)) { - SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_socketstream" "', argument " "1"" of type '" "bool""'"); - } - arg1 = static_cast< bool >(val1); - { - try { - result = (mfem::socketstream *)new mfem::socketstream(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if ((nobjs < 0) || (nobjs > 1)) SWIG_fail; + if (swig_obj[0]) { + ecode1 = SWIG_AsVal_bool(swig_obj[0], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_socketstream" "', argument " "1"" of type '" "bool""'"); + } + arg1 = static_cast< bool >(val1); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketstream, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::socketstream *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::socketstream *)new mfem::socketstream(); + result = (mfem::socketstream *)new mfem::socketstream(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4079,7 +4059,7 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::socketbuf *arg1 = (mfem::socketbuf *) 0 ; void *argp1 = 0 ; @@ -4118,67 +4098,31 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_2(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - bool arg2 ; + bool arg2 = (bool) mfem::socketstream::secure_default ; bool val2 ; int ecode2 = 0 ; mfem::socketstream *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_socketstream" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::socketstream *)new mfem::socketstream(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketstream, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::socketstream *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_socketstream" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } { try { - result = (mfem::socketstream *)new mfem::socketstream(arg1); + result = (mfem::socketstream *)new mfem::socketstream(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4202,11 +4146,11 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_4(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; char *arg1 ; int arg2 ; - bool arg3 ; + bool arg3 = (bool) mfem::socketstream::secure_default ; int res1 ; char *buf1 = 0 ; int alloc1 = 0 ; @@ -4214,7 +4158,7 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_5(PyObject *SWIGUNUSEDPARM(sel int ecode3 = 0 ; mfem::socketstream *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_socketstream" "', argument " "1"" of type '" "char const []""'"); @@ -4226,63 +4170,16 @@ SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_5(PyObject *SWIGUNUSEDPARM(sel }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_socketstream" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - result = (mfem::socketstream *)new mfem::socketstream((char const (*))arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketstream, SWIG_POINTER_NEW | 0 ); - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return resultobj; -fail: - if (alloc1 == SWIG_NEWOBJ) delete[] buf1; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketstream__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - char *arg1 ; - int arg2 ; - int res1 ; - char *buf1 = 0 ; - int alloc1 = 0 ; - mfem::socketstream *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_socketstream" "', argument " "1"" of type '" "char const []""'"); - } - arg1 = reinterpret_cast< char * >(buf1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_socketstream" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } { try { - result = (mfem::socketstream *)new mfem::socketstream((char const (*))arg1,arg2); + result = (mfem::socketstream *)new mfem::socketstream((char const (*))arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4316,20 +4213,11 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_socketstream", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_socketstream__SWIG_1(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 1)) { int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__socketbuf, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_socketstream__SWIG_2(self, argc, argv); + if (argc <= 0) { + return _wrap_new_socketstream__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { int res = SWIG_AsVal_bool(argv[0], NULL); _v = SWIG_CheckState(res); @@ -4340,19 +4228,14 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { } if (argc == 1) { int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__socketbuf, 0); + _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_socketstream__SWIG_4(self, argc, argv); + return _wrap_new_socketstream__SWIG_1(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -4363,16 +4246,19 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 1) { + return _wrap_new_socketstream__SWIG_2(self, argc, argv); + } { int res = SWIG_AsVal_bool(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_socketstream__SWIG_3(self, argc, argv); + return _wrap_new_socketstream__SWIG_2(self, argc, argv); } } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); _v = SWIG_CheckState(res); @@ -4386,30 +4272,15 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_socketstream__SWIG_6(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_new_socketstream__SWIG_3(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_bool(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_socketstream__SWIG_5(self, argc, argv); + return _wrap_new_socketstream__SWIG_3(self, argc, argv); } } } @@ -4419,12 +4290,9 @@ SWIGINTERN PyObject *_wrap_new_socketstream(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_socketstream'.\n" " Possible C/C++ prototypes are:\n" " mfem::socketstream::socketstream(bool)\n" - " mfem::socketstream::socketstream()\n" " mfem::socketstream::socketstream(mfem::socketbuf *)\n" " mfem::socketstream::socketstream(int,bool)\n" - " mfem::socketstream::socketstream(int)\n" - " mfem::socketstream::socketstream(char const [],int,bool)\n" - " mfem::socketstream::socketstream(char const [],int)\n"); + " mfem::socketstream::socketstream(char const [],int,bool)\n"); return 0; } @@ -4470,7 +4338,7 @@ SWIGINTERN PyObject *_wrap_socketstream_rdbuf(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_socketstream_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketstream_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketstream *arg1 = (mfem::socketstream *) 0 ; char *arg2 ; @@ -4480,25 +4348,30 @@ SWIGINTERN PyObject *_wrap_socketstream_open(PyObject *SWIGUNUSEDPARM(self), PyO int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"hostname", (char *)"port", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "socketstream_open", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:socketstream_open", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketstream_open" "', argument " "1"" of type '" "mfem::socketstream *""'"); } arg1 = reinterpret_cast< mfem::socketstream * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketstream_open" "', argument " "2"" of type '" "char const []""'"); } arg2 = reinterpret_cast< char * >(buf2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4781,7 +4654,7 @@ SWIGINTERN PyObject *_wrap_socketstream_precision(PyObject *self, PyObject *args } -SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketstream *arg1 = (mfem::socketstream *) 0 ; mfem::Mesh *arg2 = 0 ; @@ -4792,15 +4665,20 @@ SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(s int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mesh", (char *)"gf", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "socketstream_send_solution", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:socketstream_send_solution", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketstream_send_solution" "', argument " "1"" of type '" "mfem::socketstream *""'"); } arg1 = reinterpret_cast< mfem::socketstream * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Mesh, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketstream_send_solution" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } @@ -4808,7 +4686,7 @@ SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "socketstream_send_solution" "', argument " "2"" of type '" "mfem::Mesh const &""'"); } arg2 = reinterpret_cast< mfem::Mesh * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__GridFunction, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__GridFunction, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "socketstream_send_solution" "', argument " "3"" of type '" "mfem::GridFunction const &""'"); } @@ -4842,7 +4720,7 @@ SWIGINTERN PyObject *_wrap_socketstream_send_solution(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_socketstream_send_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_socketstream_send_text(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::socketstream *arg1 = (mfem::socketstream *) 0 ; char *arg2 ; @@ -4851,15 +4729,19 @@ SWIGINTERN PyObject *_wrap_socketstream_send_text(PyObject *SWIGUNUSEDPARM(self) int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ostr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "socketstream_send_text", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:socketstream_send_text", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__socketstream, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "socketstream_send_text" "', argument " "1"" of type '" "mfem::socketstream *""'"); } arg1 = reinterpret_cast< mfem::socketstream * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); + res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "socketstream_send_text" "', argument " "2"" of type '" "char const []""'"); } @@ -5261,66 +5143,35 @@ SWIGINTERN PyObject *socketstream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_socketserver__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_socketserver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 4 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"port", (char *)"backlog", NULL + }; mfem::socketserver *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_socketserver", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::socketserver *)new mfem::socketserver(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__socketserver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_socketserver__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::socketserver *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::socketserver *)new mfem::socketserver(arg1); + result = (mfem::socketserver *)new mfem::socketserver(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5344,62 +5195,6 @@ SWIGINTERN PyObject *_wrap_new_socketserver__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_socketserver(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_socketserver", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_socketserver__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_socketserver__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_socketserver'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::socketserver::socketserver(int,int)\n" - " mfem::socketserver::socketserver(int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_socketserver_good(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::socketserver *arg1 = (mfem::socketserver *) 0 ; @@ -5671,9 +5466,9 @@ static PyMethodDef SwigMethods[] = { "socketbuf(int sd)\n" "new_socketbuf(char const [] hostname, int port) -> socketbuf\n" ""}, - { "socketbuf_attach", _wrap_socketbuf_attach, METH_VARARGS, "socketbuf_attach(socketbuf self, int sd) -> int"}, + { "socketbuf_attach", (PyCFunction)(void(*)(void))_wrap_socketbuf_attach, METH_VARARGS|METH_KEYWORDS, "socketbuf_attach(socketbuf self, int sd) -> int"}, { "socketbuf_detach", _wrap_socketbuf_detach, METH_O, "socketbuf_detach(socketbuf self) -> int"}, - { "socketbuf_open", _wrap_socketbuf_open, METH_VARARGS, "socketbuf_open(socketbuf self, char const [] hostname, int port) -> int"}, + { "socketbuf_open", (PyCFunction)(void(*)(void))_wrap_socketbuf_open, METH_VARARGS|METH_KEYWORDS, "socketbuf_open(socketbuf self, char const [] hostname, int port) -> int"}, { "socketbuf_close", _wrap_socketbuf_close, METH_O, "socketbuf_close(socketbuf self) -> int"}, { "socketbuf_getsocketdescriptor", _wrap_socketbuf_getsocketdescriptor, METH_O, "socketbuf_getsocketdescriptor(socketbuf self) -> int"}, { "socketbuf_is_open", _wrap_socketbuf_is_open, METH_O, "socketbuf_is_open(socketbuf self) -> bool"}, @@ -5684,10 +5479,10 @@ static PyMethodDef SwigMethods[] = { "socketstream(bool secure=secure_default)\n" "socketstream(socketbuf buf)\n" "socketstream(int s, bool secure=secure_default)\n" - "socketstream(char const [] hostname, int port, bool secure=secure_default)\n" + "new_socketstream(char const [] hostname, int port, bool secure=secure_default) -> socketstream\n" ""}, { "socketstream_rdbuf", _wrap_socketstream_rdbuf, METH_O, "socketstream_rdbuf(socketstream self) -> socketbuf"}, - { "socketstream_open", _wrap_socketstream_open, METH_VARARGS, "socketstream_open(socketstream self, char const [] hostname, int port) -> int"}, + { "socketstream_open", (PyCFunction)(void(*)(void))_wrap_socketstream_open, METH_VARARGS|METH_KEYWORDS, "socketstream_open(socketstream self, char const [] hostname, int port) -> int"}, { "socketstream_close", _wrap_socketstream_close, METH_O, "socketstream_close(socketstream self) -> int"}, { "socketstream_is_open", _wrap_socketstream_is_open, METH_O, "socketstream_is_open(socketstream self) -> bool"}, { "delete_socketstream", _wrap_delete_socketstream, METH_O, "delete_socketstream(socketstream self)"}, @@ -5695,8 +5490,8 @@ static PyMethodDef SwigMethods[] = { "socketstream_precision(socketstream self, int const p) -> int\n" "socketstream_precision(socketstream self) -> int\n" ""}, - { "socketstream_send_solution", _wrap_socketstream_send_solution, METH_VARARGS, "socketstream_send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, - { "socketstream_send_text", _wrap_socketstream_send_text, METH_VARARGS, "socketstream_send_text(socketstream self, char const [] ostr)"}, + { "socketstream_send_solution", (PyCFunction)(void(*)(void))_wrap_socketstream_send_solution, METH_VARARGS|METH_KEYWORDS, "socketstream_send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, + { "socketstream_send_text", (PyCFunction)(void(*)(void))_wrap_socketstream_send_text, METH_VARARGS|METH_KEYWORDS, "socketstream_send_text(socketstream self, char const [] ostr)"}, { "socketstream_flush", _wrap_socketstream_flush, METH_O, "socketstream_flush(socketstream self)"}, { "socketstream___lshift__", _wrap_socketstream___lshift__, METH_VARARGS, "\n" "socketstream___lshift__(socketstream self, char const [] ostr) -> socketstream\n" @@ -5707,7 +5502,7 @@ static PyMethodDef SwigMethods[] = { { "socketstream_endline", _wrap_socketstream_endline, METH_O, "socketstream_endline(socketstream self) -> socketstream"}, { "socketstream_swigregister", socketstream_swigregister, METH_O, NULL}, { "socketstream_swiginit", socketstream_swiginit, METH_VARARGS, NULL}, - { "new_socketserver", _wrap_new_socketserver, METH_VARARGS, "socketserver(int port, int backlog=4)"}, + { "new_socketserver", (PyCFunction)(void(*)(void))_wrap_new_socketserver, METH_VARARGS|METH_KEYWORDS, "new_socketserver(int port, int backlog=4) -> socketserver"}, { "socketserver_good", _wrap_socketserver_good, METH_O, "socketserver_good(socketserver self) -> bool"}, { "socketserver_close", _wrap_socketserver_close, METH_O, "socketserver_close(socketserver self) -> int"}, { "socketserver_accept", _wrap_socketserver_accept, METH_VARARGS, "\n" @@ -5728,9 +5523,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "socketbuf(int sd)\n" "new_socketbuf(char const [] hostname, int port) -> socketbuf\n" ""}, - { "socketbuf_attach", _wrap_socketbuf_attach, METH_VARARGS, "attach(socketbuf self, int sd) -> int"}, + { "socketbuf_attach", (PyCFunction)(void(*)(void))_wrap_socketbuf_attach, METH_VARARGS|METH_KEYWORDS, "attach(socketbuf self, int sd) -> int"}, { "socketbuf_detach", _wrap_socketbuf_detach, METH_O, "detach(socketbuf self) -> int"}, - { "socketbuf_open", _wrap_socketbuf_open, METH_VARARGS, "open(socketbuf self, char const [] hostname, int port) -> int"}, + { "socketbuf_open", (PyCFunction)(void(*)(void))_wrap_socketbuf_open, METH_VARARGS|METH_KEYWORDS, "open(socketbuf self, char const [] hostname, int port) -> int"}, { "socketbuf_close", _wrap_socketbuf_close, METH_O, "close(socketbuf self) -> int"}, { "socketbuf_getsocketdescriptor", _wrap_socketbuf_getsocketdescriptor, METH_O, "getsocketdescriptor(socketbuf self) -> int"}, { "socketbuf_is_open", _wrap_socketbuf_is_open, METH_O, "is_open(socketbuf self) -> bool"}, @@ -5741,10 +5536,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "socketstream(bool secure=secure_default)\n" "socketstream(socketbuf buf)\n" "socketstream(int s, bool secure=secure_default)\n" - "socketstream(char const [] hostname, int port, bool secure=secure_default)\n" + "new_socketstream(char const [] hostname, int port, bool secure=secure_default) -> socketstream\n" ""}, { "socketstream_rdbuf", _wrap_socketstream_rdbuf, METH_O, "rdbuf(socketstream self) -> socketbuf"}, - { "socketstream_open", _wrap_socketstream_open, METH_VARARGS, "open(socketstream self, char const [] hostname, int port) -> int"}, + { "socketstream_open", (PyCFunction)(void(*)(void))_wrap_socketstream_open, METH_VARARGS|METH_KEYWORDS, "open(socketstream self, char const [] hostname, int port) -> int"}, { "socketstream_close", _wrap_socketstream_close, METH_O, "close(socketstream self) -> int"}, { "socketstream_is_open", _wrap_socketstream_is_open, METH_O, "is_open(socketstream self) -> bool"}, { "delete_socketstream", _wrap_delete_socketstream, METH_O, "delete_socketstream(socketstream self)"}, @@ -5752,8 +5547,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "precision(socketstream self, int const p) -> int\n" "precision(socketstream self) -> int\n" ""}, - { "socketstream_send_solution", _wrap_socketstream_send_solution, METH_VARARGS, "send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, - { "socketstream_send_text", _wrap_socketstream_send_text, METH_VARARGS, "send_text(socketstream self, char const [] ostr)"}, + { "socketstream_send_solution", (PyCFunction)(void(*)(void))_wrap_socketstream_send_solution, METH_VARARGS|METH_KEYWORDS, "send_solution(socketstream self, Mesh mesh, GridFunction gf)"}, + { "socketstream_send_text", (PyCFunction)(void(*)(void))_wrap_socketstream_send_text, METH_VARARGS|METH_KEYWORDS, "send_text(socketstream self, char const [] ostr)"}, { "socketstream_flush", _wrap_socketstream_flush, METH_O, "flush(socketstream self)"}, { "socketstream___lshift__", _wrap_socketstream___lshift__, METH_VARARGS, "\n" "__lshift__(socketstream self, char const [] ostr) -> socketstream\n" @@ -5764,7 +5559,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "socketstream_endline", _wrap_socketstream_endline, METH_O, "endline(socketstream self) -> socketstream"}, { "socketstream_swigregister", socketstream_swigregister, METH_O, NULL}, { "socketstream_swiginit", socketstream_swiginit, METH_VARARGS, NULL}, - { "new_socketserver", _wrap_new_socketserver, METH_VARARGS, "socketserver(int port, int backlog=4)"}, + { "new_socketserver", (PyCFunction)(void(*)(void))_wrap_new_socketserver, METH_VARARGS|METH_KEYWORDS, "new_socketserver(int port, int backlog=4) -> socketserver"}, { "socketserver_good", _wrap_socketserver_good, METH_O, "good(socketserver self) -> bool"}, { "socketserver_close", _wrap_socketserver_close, METH_O, "close(socketserver self) -> int"}, { "socketserver_accept", _wrap_socketserver_accept, METH_VARARGS, "\n" diff --git a/mfem/_ser/solvers_wrap.cxx b/mfem/_ser/solvers_wrap.cxx index 2343ab02..aad4683a 100644 --- a/mfem/_ser/solvers_wrap.cxx +++ b/mfem/_ser/solvers_wrap.cxx @@ -3388,7 +3388,7 @@ SWIG_AsVal_int (PyObject * obj, int *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; double arg2 ; @@ -3396,15 +3396,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rtol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetRelTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetRelTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetRelTol" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IterativeSolver_SetRelTol" "', argument " "2"" of type '" "double""'"); } @@ -3435,7 +3439,7 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetRelTol(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; double arg2 ; @@ -3443,15 +3447,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"atol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetAbsTol", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetAbsTol", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetAbsTol" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IterativeSolver_SetAbsTol" "', argument " "2"" of type '" "double""'"); } @@ -3482,25 +3490,29 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetAbsTol(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetMaxIter(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"max_it", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetMaxIter", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetMaxIter", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetMaxIter" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3528,25 +3540,29 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetMaxIter(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetPrintLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"print_lvl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetPrintLevel", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetPrintLevel", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetPrintLevel" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3697,7 +3713,7 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_GetFinalNorm(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; mfem::Solver *arg2 = 0 ; @@ -3705,15 +3721,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IterativeSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } @@ -3747,7 +3767,7 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetPreconditioner(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_IterativeSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IterativeSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::IterativeSolver *arg1 = (mfem::IterativeSolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -3755,15 +3775,19 @@ SWIGINTERN PyObject *_wrap_IterativeSolver_SetOperator(PyObject *SWIGUNUSEDPARM( int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "IterativeSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IterativeSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__IterativeSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IterativeSolver_SetOperator" "', argument " "1"" of type '" "mfem::IterativeSolver *""'"); } arg1 = reinterpret_cast< mfem::IterativeSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IterativeSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -3848,7 +3872,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS PyObject *resultobj = 0; mfem::BilinearForm *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; - double arg3 ; + double arg3 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3857,7 +3881,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS int ecode3 = 0 ; mfem::OperatorJacobiSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); @@ -3874,11 +3898,13 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); + } { try { result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); @@ -3906,63 +3932,10 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_0(PyObject *SWIGUNUS SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::BilinearForm *arg1 = 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::OperatorJacobiSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__BilinearForm, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::BilinearForm const &""'"); - } - arg1 = reinterpret_cast< mfem::BilinearForm * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::BilinearForm const &)*arg1,(mfem::Array< int > const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; mfem::Array< int > *arg2 = 0 ; - double arg3 ; + double arg3 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -3971,7 +3944,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUS int ecode3 = 0 ; mfem::OperatorJacobiSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); @@ -3988,67 +3961,16 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_2(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__OperatorJacobiSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::OperatorJacobiSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "1"" of type '" "mfem::Vector const &""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_OperatorJacobiSmoother" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_OperatorJacobiSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); { try { - result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2); + result = (mfem::OperatorJacobiSmoother *)new mfem::OperatorJacobiSmoother((mfem::Vector const &)*arg1,(mfem::Array< int > const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4080,7 +4002,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject * if (!(argc = SWIG_Python_UnpackTuple(args, "new_OperatorJacobiSmoother", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -4088,54 +4010,36 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_2(self, argc, argv); + return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__BilinearForm, SWIG_POINTER_NO_NULL | 0); + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_OperatorJacobiSmoother__SWIG_0(self, argc, argv); + return _wrap_new_OperatorJacobiSmoother__SWIG_1(self, argc, argv); } } } @@ -4145,9 +4049,7 @@ SWIGINTERN PyObject *_wrap_new_OperatorJacobiSmoother(PyObject *self, PyObject * SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_OperatorJacobiSmoother'.\n" " Possible C/C++ prototypes are:\n" " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &,double const)\n" - " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::BilinearForm const &,mfem::Array< int > const &)\n" - " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &,double const)\n" - " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &)\n"); + " mfem::OperatorJacobiSmoother::OperatorJacobiSmoother(mfem::Vector const &,mfem::Array< int > const &,double const)\n"); return 0; } @@ -4192,7 +4094,7 @@ SWIGINTERN PyObject *_wrap_delete_OperatorJacobiSmoother(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4203,15 +4105,20 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM( int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OperatorJacobiSmoother_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother const *""'"); } arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4219,7 +4126,7 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM( SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OperatorJacobiSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OperatorJacobiSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4253,7 +4160,7 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Mult(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Operator *arg2 = 0 ; @@ -4261,15 +4168,19 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUS int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorJacobiSmoother_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -4303,7 +4214,7 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_SetOperator(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorJacobiSmoother *arg1 = (mfem::OperatorJacobiSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4311,15 +4222,19 @@ SWIGINTERN PyObject *_wrap_OperatorJacobiSmoother_Setup(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"diag", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OperatorJacobiSmoother_Setup", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OperatorJacobiSmoother_Setup", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OperatorJacobiSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "1"" of type '" "mfem::OperatorJacobiSmoother *""'"); } arg1 = reinterpret_cast< mfem::OperatorJacobiSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OperatorJacobiSmoother_Setup" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4395,7 +4310,7 @@ SWIGINTERN PyObject *_wrap_new_SLISolver(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -4403,15 +4318,19 @@ SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SLISolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_SetOperator" "', argument " "1"" of type '" "mfem::SLISolver *""'"); } arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -4445,7 +4364,7 @@ SWIGINTERN PyObject *_wrap_SLISolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SLISolver *arg1 = (mfem::SLISolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4456,15 +4375,20 @@ SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLISolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLISolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLISolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLISolver_Mult" "', argument " "1"" of type '" "mfem::SLISolver const *""'"); } arg1 = reinterpret_cast< mfem::SLISolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4472,7 +4396,7 @@ SWIGINTERN PyObject *_wrap_SLISolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLISolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLISolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4562,10 +4486,10 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ mfem::Operator *arg1 = 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1000 ; + double arg6 = (double) 1e-12 ; + double arg7 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -4577,7 +4501,7 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ double val7 ; int ecode7 = 0 ; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -4602,28 +4526,36 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); @@ -4653,21 +4585,27 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; + mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -4676,42 +4614,63 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "SLI" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4735,60 +4694,159 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; +SWIGINTERN PyObject *_wrap_SLI(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + if (!(argc = SWIG_Python_UnpackTuple(args, "SLI", 0, 8, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 7)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 3) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 4) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 5) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[5], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 6) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SLI__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if ((argc >= 4) && (argc <= 8)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 5) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 6) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 7) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SLI__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SLI'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" + " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::CGSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_CGSolver", 0, 0, 0)) SWIG_fail; { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + result = (mfem::CGSolver *)new mfem::CGSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4805,60 +4863,44 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CGSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CGSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_SetOperator" "', argument " "1"" of type '" "mfem::CGSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4882,9 +4924,9 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_CGSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -4893,35 +4935,38 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CGSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_Mult" "', argument " "1"" of type '" "mfem::CGSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - mfem::SLI((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + ((mfem::CGSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4945,87 +4990,145 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; + mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CGSolver" "', argument " "1"" of type '" "mfem::CGSolver *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *CGSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CGSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *CGSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_CG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1000 ; + double arg6 = (double) 1e-12 ; + double arg7 = (double) 1e-24 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"b", (char *)"x", (char *)"print_iter", (char *)"max_num_iter", (char *)"RTOLERANCE", (char *)"ATOLERANCE", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOO:CG", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (obj5) { + ecode6 = SWIG_AsVal_double(obj5, &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (obj6) { + ecode7 = SWIG_AsVal_double(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CG" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "SLI" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5049,15 +5152,16 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_PCG(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -5068,60 +5172,86 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ int res4 = 0 ; double val7 ; int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", (char *)"b", (char *)"x", (char *)"print_iter", (char *)"max_num_iter", (char *)"RTOLERANCE", (char *)"ATOLERANCE", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOO:PCG", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (obj5) { + { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(obj5); + } + } + if (obj6) { + ecode7 = SWIG_AsVal_double(obj6, &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (obj7) { + ecode8 = SWIG_AsVal_double(obj7, &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PCG" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "SLI" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5145,71 +5275,64 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; + mfem::GMRESSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_GMRESSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::GMRESSolver *)new mfem::GMRESSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_GMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; + int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:GMRESSolver_SetKDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); } + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + (arg1)->SetKDim(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5233,64 +5356,49 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_GMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GMRESSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_Mult" "', argument " "1"" of type '" "mfem::GMRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + ((mfem::GMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5314,57 +5422,23 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ } -SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLI" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GMRESSolver" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); { try { - mfem::SLI((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5384,4268 +5458,79 @@ SWIGINTERN PyObject *_wrap_SLI__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_ resultobj = SWIG_Py_Void(); return resultobj; fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SLI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SLI", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SLI__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SLI__SWIG_9(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_8(self, argc, argv); - } - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SLI__SWIG_7(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_6(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SLI__SWIG_5(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SLI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::SLI(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_CGSolver", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::CGSolver *)new mfem::CGSolver(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CGSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - mfem::Operator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "CGSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_SetOperator" "', argument " "1"" of type '" "mfem::CGSolver *""'"); - } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - { - try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CGSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "CGSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CGSolver_Mult" "', argument " "1"" of type '" "mfem::CGSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CGSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::CGSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_CGSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::CGSolver *arg1 = (mfem::CGSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__CGSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CGSolver" "', argument " "1"" of type '" "mfem::CGSolver *""'"); - } - arg1 = reinterpret_cast< mfem::CGSolver * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *CGSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__CGSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *CGSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_CG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "CG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "CG" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CG" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - mfem::CG((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_CG(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[8] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "CG", 0, 7, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_CG__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_CG__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_CG__SWIG_2(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CG__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_CG__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::CG(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "PCG" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "PCG" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCG" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::PCG((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_PCG(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "PCG", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_PCG__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PCG__SWIG_3(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_PCG__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PCG__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_PCG__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PCG'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::PCG(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_GMRESSolver", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::GMRESSolver *)new mfem::GMRESSolver(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetKDim(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "GMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRESSolver_Mult" "', argument " "1"" of type '" "mfem::GMRESSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::GMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_GMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::GMRESSolver *arg1 = (mfem::GMRESSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GMRESSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GMRESSolver" "', argument " "1"" of type '" "mfem::GMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::GMRESSolver * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *GMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GMRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *GMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_FGMRESSolver", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FGMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_SetKDim", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - (arg1)->SetKDim(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_FGMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "FGMRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_Mult" "', argument " "1"" of type '" "mfem::FGMRESSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::FGMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FGMRESSolver" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); - } - arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *FGMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FGMRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *FGMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Solver *arg4 = 0 ; - int *arg5 = 0 ; - int arg6 ; - double *arg7 = 0 ; - double arg8 ; - int arg9 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp7 = 0 ; - int res7 = 0 ; - double val8 ; - int ecode8 = 0 ; - int result; - - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - arg4 = reinterpret_cast< mfem::Solver * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); - } - arg5 = reinterpret_cast< int * >(argp5); - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res7)) { - SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); - } - if (!argp7) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); - } - arg7 = reinterpret_cast< double * >(argp7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - if ((PyArray_PyIntAsInt(swig_obj[8]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg9 = PyArray_PyIntAsInt(swig_obj[8]); - } - { - try { - result = (int)mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,arg6,*arg7,arg8,arg9); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - int arg7 ; - double arg8 ; - double arg9 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val8 ; - int ecode8 = 0 ; - double val9 ; - int ecode9 = 0 ; - - if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); - if (!SWIG_IsOK(ecode9)) { - SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GMRES" "', argument " "9"" of type '" "double""'"); - } - arg9 = static_cast< double >(val9); - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - int arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val8 ; - int ecode8 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - int arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); - } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[10] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES", 0, 9, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_GMRES__SWIG_6(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_5(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_4(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_3(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GMRES__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - } - } - if (argc == 9) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[8], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_GMRES__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } - } - } - } - if (argc == 9) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[8]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_GMRES__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::GMRES(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,int,double &,double,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double,double)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BiCGSTABSolver *result = 0 ; - - if (!SWIG_Python_UnpackTuple(args, "new_BiCGSTABSolver", 0, 0, 0)) SWIG_fail; - { - try { - result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; - mfem::Operator *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); - } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); - { - try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "BiCGSTABSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_Mult" "', argument " "1"" of type '" "mfem::BiCGSTABSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::BiCGSTABSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCGSTABSolver" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); - } - arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *BiCGSTABSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *BiCGSTABSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Solver *arg4 = 0 ; - int *arg5 = 0 ; - double *arg6 = 0 ; - double arg7 ; - int arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - void *argp5 = 0 ; - int res5 = 0 ; - void *argp6 = 0 ; - int res6 = 0 ; - double val7 ; - int ecode7 = 0 ; - int result; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); - } - arg4 = reinterpret_cast< mfem::Solver * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); - if (!SWIG_IsOK(res5)) { - SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); - } - if (!argp5) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); - } - arg5 = reinterpret_cast< int * >(argp5); - res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double, 0 ); - if (!SWIG_IsOK(res6)) { - SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); - } - if (!argp6) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); - } - arg6 = reinterpret_cast< double * >(argp6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); - } - { - try { - result = (int)mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,*arg6,arg7,arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; - - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BiCGSTAB" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); - { - try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - { - try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - { - try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "BiCGSTAB", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_BiCGSTAB__SWIG_5(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_4(self, argc, argv); - } - } - } - } - } - } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_3(self, argc, argv); - } - } - } - } - } - } - } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_2(self, argc, argv); - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_0(self, argc, argv); - } - } - } - } - } - } - } - } - } - if (argc == 8) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[7], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); - } - } - } - } - } - } - } + return NULL; +} + + +SWIGINTERN PyObject *GMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__GMRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *GMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::FGMRESSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_FGMRESSolver", 0, 0, 0)) SWIG_fail; + { + try { + result = (mfem::FGMRESSolver *)new mfem::FGMRESSolver(); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_NEW | 0 ); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BiCGSTAB'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,double &,double,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FGMRESSolver_SetKDim(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::MINRESSolver *result = 0 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + int arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "new_MINRESSolver", 0, 0, 0)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:FGMRESSolver_SetKDim", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_SetKDim" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); + } + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } { try { - result = (mfem::MINRESSolver *)new mfem::MINRESSolver(); + (arg1)->SetKDim(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9662,40 +5547,56 @@ SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_FGMRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; - mfem::Solver *arg2 = 0 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:FGMRESSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__FGMRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FGMRESSolver_Mult" "', argument " "1"" of type '" "mfem::FGMRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FGMRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->SetPreconditioner(*arg2); + ((mfem::FGMRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9719,33 +5620,153 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_FGMRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::FGMRESSolver *arg1 = (mfem::FGMRESSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__FGMRESSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FGMRESSolver" "', argument " "1"" of type '" "mfem::FGMRESSolver *""'"); + } + arg1 = reinterpret_cast< mfem::FGMRESSolver * >(argp1); + { + try { + delete arg1; + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *FGMRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__FGMRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *FGMRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_GMRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::Operator *arg1 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Solver *arg4 = 0 ; + int *arg5 = 0 ; + int arg6 ; + double *arg7 = 0 ; + double arg8 ; + int arg9 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp7 = 0 ; + int res7 = 0 ; + double val8 ; + int ecode8 = 0 ; + int result; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if ((nobjs < 9) || (nobjs > 9)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetOperator" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Solver &""'"); + } + arg4 = reinterpret_cast< mfem::Solver * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + res7 = SWIG_ConvertPtr(swig_obj[6], &argp7, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res7)) { + SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); + } + if (!argp7) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "7"" of type '" "double &""'"); + } + arg7 = reinterpret_cast< double * >(argp7); + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + { + if ((PyArray_PyIntAsInt(swig_obj[8]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg9 = PyArray_PyIntAsInt(swig_obj[8]); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + result = (int)mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,arg6,*arg7,arg8,arg9); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9762,51 +5783,111 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GMRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Operator *arg1 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + int arg7 = (int) 50 ; + double arg8 = (double) 1e-12 ; + double arg9 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + void *argp4 = 0 ; + int res4 = 0 ; + double val8 ; + int ecode8 = 0 ; + double val9 ; + int ecode9 = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MINRESSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); + if ((nobjs < 4) || (nobjs > 9)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_Mult" "', argument " "1"" of type '" "mfem::MINRESSolver const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!argp1) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + } + arg1 = reinterpret_cast< mfem::Operator * >(argp1); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GMRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } + if (swig_obj[6]) { + { + if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg7 = PyArray_PyIntAsInt(swig_obj[6]); + } + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "GMRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + } + if (swig_obj[8]) { + ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "GMRES" "', argument " "9"" of type '" "double""'"); + } + arg9 = static_cast< double >(val9); + } { try { - ((mfem::MINRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + mfem::GMRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9830,23 +5911,169 @@ SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; +SWIGINTERN PyObject *_wrap_GMRES(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[10] = { + 0 + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MINRESSolver" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "GMRES", 0, 9, argv))) SWIG_fail; + --argc; + if ((argc >= 4) && (argc <= 9)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 5) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 6) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[6]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 7) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 8) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[8], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_GMRES__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } + } + } } - arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + if (argc == 9) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[8]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_GMRES__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'GMRES'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::GMRES(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,int,double &,double,int)\n" + " mfem::GMRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,int,double,double)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_new_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BiCGSTABSolver *result = 0 ; + + if (!SWIG_Python_UnpackTuple(args, "new_BiCGSTABSolver", 0, 0, 0)) SWIG_fail; { try { - delete arg1; + result = (mfem::BiCGSTABSolver *)new mfem::BiCGSTABSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9863,94 +6090,44 @@ SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *MINRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MINRESSolver, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *MINRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BiCGSTABSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; - double arg7 ; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BiCGSTABSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + } + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9974,68 +6151,89 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BiCGSTABSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; - double arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - double val6 ; - int ecode6 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BiCGSTABSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTABSolver_Mult" "', argument " "1"" of type '" "mfem::BiCGSTABSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTABSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + try { + ((mfem::BiCGSTABSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_BiCGSTABSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::BiCGSTABSolver *arg1 = (mfem::BiCGSTABSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_BiCGSTABSolver" "', argument " "1"" of type '" "mfem::BiCGSTABSolver *""'"); } - ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); - if (!SWIG_IsOK(ecode6)) { - SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); - } - arg6 = static_cast< double >(val6); + arg1 = reinterpret_cast< mfem::BiCGSTABSolver * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10059,60 +6257,106 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *BiCGSTABSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__BiCGSTABSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *BiCGSTABSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; - int arg5 ; + mfem::Solver *arg4 = 0 ; + int *arg5 = 0 ; + double *arg6 = 0 ; + double arg7 ; + int arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + void *argp5 = 0 ; + int res5 = 0 ; + void *argp6 = 0 ; + int res6 = 0 ; + double val7 ; + int ecode7 = 0 ; + int result; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Solver, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Solver &""'"); + } + arg4 = reinterpret_cast< mfem::Solver * >(argp4); + res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); + } + if (!argp5) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "5"" of type '" "int &""'"); + } + arg5 = reinterpret_cast< int * >(argp5); + res6 = SWIG_ConvertPtr(swig_obj[5], &argp6, SWIGTYPE_p_double, 0 ); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); + } + if (!argp6) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "6"" of type '" "double &""'"); + } + arg6 = reinterpret_cast< double * >(argp6); + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg8 = PyArray_PyIntAsInt(swig_obj[7]); } { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5); + result = (int)mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,*arg5,*arg6,arg7,arg8); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10129,123 +6373,265 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_BiCGSTAB__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; + mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - int arg4 ; + mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BiCGSTAB" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } + } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); + } + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "BiCGSTAB" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); + } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "BiCGSTAB" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); } { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4); + mfem::BiCGSTAB((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_BiCGSTAB(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "BiCGSTAB", 0, 8, argv))) SWIG_fail; + --argc; + if ((argc >= 4) && (argc <= 8)) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + if (argc <= 4) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 5) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 6) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + if (argc <= 7) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_double(argv[7], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_1(self, argc, argv); + } + } + } + } + } + } + } } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + } + if (argc == 8) { + int _v; + int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_int, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_double, SWIG_POINTER_NO_NULL); + _v = SWIG_CheckState(res); + if (_v) { + { + int res = SWIG_AsVal_double(argv[6], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[7]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_BiCGSTAB__SWIG_0(self, argc, argv); + } + } + } + } + } + } + } } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - return resultobj; + fail: - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'BiCGSTAB'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Vector &,mfem::Vector const &,mfem::Solver &,int &,double &,double,int)\n" + " mfem::BiCGSTAB(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n"); + return 0; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + mfem::MINRESSolver *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (!SWIG_Python_UnpackTuple(args, "new_MINRESSolver", 0, 0, 0)) SWIG_fail; { try { - mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3); + result = (mfem::MINRESSolver *)new mfem::MINRESSolver(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10262,94 +6648,44 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRESSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; - double arg8 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; - double val8 ; - int ecode8 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr", NULL + }; - if ((nobjs < 8) || (nobjs > 8)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MINRESSolver_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); - } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); - ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); - if (!SWIG_IsOK(ecode8)) { - SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "MINRES" "', argument " "8"" of type '" "double""'"); - } - arg8 = static_cast< double >(val8); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + (arg1)->SetPreconditioner(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10373,79 +6709,37 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRESSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; - double arg7 ; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val7 ; - int ecode7 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if ((nobjs < 7) || (nobjs > 7)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MINRESSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_SetOperator" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); - if (!SWIG_IsOK(ecode7)) { - SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); - } - arg7 = static_cast< double >(val7); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10469,71 +6763,89 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRESSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; - int arg6 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MINRESSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__MINRESSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRESSolver_Mult" "', argument " "1"" of type '" "mfem::MINRESSolver const *""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRESSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + try { + ((mfem::MINRESSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_delete_MINRESSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::MINRESSolver *arg1 = (mfem::MINRESSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; + + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__MINRESSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MINRESSolver" "', argument " "1"" of type '" "mfem::MINRESSolver *""'"); } + arg1 = reinterpret_cast< mfem::MINRESSolver * >(argp1); { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10557,23 +6869,38 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *MINRESSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__MINRESSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *MINRESSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_MINRES__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; - mfem::Solver *arg2 = 0 ; + mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - int arg5 ; + int arg4 = (int) 0 ; + int arg5 = (int) 1000 ; + double arg6 = (double) 1e-12 ; + double arg7 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val6 ; + int ecode6 = 0 ; + double val7 ; + int ecode7 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 7)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -10582,39 +6909,55 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssi SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Solver &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); + } } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (swig_obj[5]) { + ecode6 = SWIG_AsVal_double(swig_obj[5], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "MINRES" "', argument " "6"" of type '" "double""'"); + } + arg6 = static_cast< double >(val6); + } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } { try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + mfem::MINRES((mfem::Operator const &)*arg1,(mfem::Vector const &)*arg2,*arg3,arg4,arg5,arg6,arg7); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10638,12 +6981,16 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssi } -SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_MINRES__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Solver *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 1000 ; + double arg7 = (double) 1e-12 ; + double arg8 = (double) 1e-24 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10652,8 +6999,12 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssi int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + double val7 ; + int ecode7 = 0 ; + double val8 ; + int ecode8 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 8)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MINRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); @@ -10682,313 +7033,75 @@ SWIGINTERN PyObject *_wrap_MINRES__SWIG_9(PyObject *SWIGUNUSEDPARM(self), Py_ssi if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[9] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "MINRES", 0, 8, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MINRES__SWIG_4(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_3(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_MINRES__SWIG_9(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_8(self, argc, argv); - } - } - } - } - } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MINRES" "', argument " "4"" of type '" "mfem::Vector &""'"); } - if (argc == 5) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_2(self, argc, argv); - } - } - } - } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (swig_obj[4]) { + { + if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(swig_obj[4]); } } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[5], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_1(self, argc, argv); - } - } - } - } - } + if (swig_obj[5]) { + { + if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg6 = PyArray_PyIntAsInt(swig_obj[5]); } } - if (argc == 6) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_MINRES__SWIG_7(self, argc, argv); - } - } - } - } - } - } + if (swig_obj[6]) { + ecode7 = SWIG_AsVal_double(swig_obj[6], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "MINRES" "', argument " "7"" of type '" "double""'"); + } + arg7 = static_cast< double >(val7); } - if (argc == 7) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__Solver, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[6], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_MINRES__SWIG_6(self, argc, argv); - } - } - } - } - } - } + if (swig_obj[7]) { + ecode8 = SWIG_AsVal_double(swig_obj[7], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "MINRES" "', argument " "8"" of type '" "double""'"); + } + arg8 = static_cast< double >(val8); + } + { + try { + mfem::MINRES((mfem::Operator const &)*arg1,*arg2,(mfem::Vector const &)*arg3,*arg4,arg5,arg6,arg7,arg8); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - if (argc == 7) { + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[9] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "MINRES", 0, 8, argv))) SWIG_fail; + --argc; + if ((argc >= 3) && (argc <= 7)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -11000,6 +7113,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 3) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11009,6 +7125,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 4) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11018,11 +7137,17 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[5], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 6) { + return _wrap_MINRES__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[6], NULL); _v = SWIG_CheckState(res); @@ -11037,7 +7162,7 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } } - if (argc == 8) { + if ((argc >= 4) && (argc <= 8)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); @@ -11053,6 +7178,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11062,6 +7190,9 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 5) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[5]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -11071,17 +7202,23 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 6) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[6], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 7) { + return _wrap_MINRES__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[7], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_MINRES__SWIG_5(self, argc, argv); + return _wrap_MINRES__SWIG_1(self, argc, argv); } } } @@ -11096,15 +7233,7 @@ SWIGINTERN PyObject *_wrap_MINRES(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MINRES'.\n" " Possible C/C++ prototypes are:\n" " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Vector const &,mfem::Vector &)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int)\n" - " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &)\n"); + " mfem::MINRES(mfem::Operator const &,mfem::Solver &,mfem::Vector const &,mfem::Vector &,int,int,double,double)\n"); return 0; } @@ -11140,7 +7269,7 @@ SWIGINTERN PyObject *_wrap_new_NewtonSolver(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Operator *arg2 = 0 ; @@ -11148,15 +7277,19 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewtonSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetOperator" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -11190,7 +7323,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetOperator(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Solver *arg2 = 0 ; @@ -11198,15 +7331,19 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"solver", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_SetSolver", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewtonSolver_SetSolver", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_SetSolver" "', argument " "1"" of type '" "mfem::NewtonSolver *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_SetSolver" "', argument " "2"" of type '" "mfem::Solver &""'"); } @@ -11240,7 +7377,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_SetSolver(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11251,15 +7388,20 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NewtonSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_Mult" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11267,7 +7409,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11301,7 +7443,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11312,16 +7454,21 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"b", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ComputeScalingFactor", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:NewtonSolver_ComputeScalingFactor", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11329,7 +7476,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "NewtonSolver_ComputeScalingFactor" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -11363,7 +7510,7 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ComputeScalingFactor(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::NewtonSolver *arg1 = (mfem::NewtonSolver *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11371,15 +7518,19 @@ SWIGINTERN PyObject *_wrap_NewtonSolver_ProcessNewState(PyObject *SWIGUNUSEDPARM int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "NewtonSolver_ProcessNewState", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:NewtonSolver_ProcessNewState", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__NewtonSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NewtonSolver_ProcessNewState" "', argument " "1"" of type '" "mfem::NewtonSolver const *""'"); } arg1 = reinterpret_cast< mfem::NewtonSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NewtonSolver_ProcessNewState" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11464,7 +7615,7 @@ SWIGINTERN PyObject *NewtonSolver_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; mfem::Vector *arg2 = 0 ; @@ -11494,11 +7645,25 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args int res10 = 0 ; void *argp11 = 0 ; int res11 = 0 ; - PyObject *swig_obj[12] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + PyObject * obj5 = 0 ; + PyObject * obj6 = 0 ; + PyObject * obj7 = 0 ; + PyObject * obj8 = 0 ; + PyObject * obj9 = 0 ; + PyObject * obj10 = 0 ; + PyObject * obj11 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"x", (char *)"b", (char *)"M", (char *)"max_iter", (char *)"m_max", (char *)"m_min", (char *)"m_step", (char *)"cf", (char *)"tol", (char *)"atol", (char *)"printit", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "aGMRES", 12, 12, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOO:aGMRES", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } @@ -11506,7 +7671,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "1"" of type '" "mfem::Operator const &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -11514,7 +7679,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "2"" of type '" "mfem::Vector &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -11522,7 +7687,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Operator, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); } @@ -11530,7 +7695,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "4"" of type '" "mfem::Operator const &""'"); } arg4 = reinterpret_cast< mfem::Operator * >(argp4); - res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_int, 0 ); + res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_int, 0 ); if (!SWIG_IsOK(res5)) { SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "aGMRES" "', argument " "5"" of type '" "int &""'"); } @@ -11539,29 +7704,29 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args } arg5 = reinterpret_cast< int * >(argp5); { - if ((PyArray_PyIntAsInt(swig_obj[5]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj5) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg6 = PyArray_PyIntAsInt(swig_obj[5]); + arg6 = PyArray_PyIntAsInt(obj5); } { - if ((PyArray_PyIntAsInt(swig_obj[6]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj6) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg7 = PyArray_PyIntAsInt(swig_obj[6]); + arg7 = PyArray_PyIntAsInt(obj6); } { - if ((PyArray_PyIntAsInt(swig_obj[7]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj7) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg8 = PyArray_PyIntAsInt(swig_obj[7]); + arg8 = PyArray_PyIntAsInt(obj7); } - ecode9 = SWIG_AsVal_double(swig_obj[8], &val9); + ecode9 = SWIG_AsVal_double(obj8, &val9); if (!SWIG_IsOK(ecode9)) { SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "aGMRES" "', argument " "9"" of type '" "double""'"); } arg9 = static_cast< double >(val9); - res10 = SWIG_ConvertPtr(swig_obj[9], &argp10, SWIGTYPE_p_double, 0 ); + res10 = SWIG_ConvertPtr(obj9, &argp10, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res10)) { SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); } @@ -11569,7 +7734,7 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "aGMRES" "', argument " "10"" of type '" "double &""'"); } arg10 = reinterpret_cast< double * >(argp10); - res11 = SWIG_ConvertPtr(swig_obj[10], &argp11, SWIGTYPE_p_double, 0 ); + res11 = SWIG_ConvertPtr(obj10, &argp11, SWIGTYPE_p_double, 0 ); if (!SWIG_IsOK(res11)) { SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "aGMRES" "', argument " "11"" of type '" "double &""'"); } @@ -11578,10 +7743,10 @@ SWIGINTERN PyObject *_wrap_aGMRES(PyObject *SWIGUNUSEDPARM(self), PyObject *args } arg11 = reinterpret_cast< double * >(argp11); { - if ((PyArray_PyIntAsInt(swig_obj[11]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj11) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg12 = PyArray_PyIntAsInt(swig_obj[11]); + arg12 = PyArray_PyIntAsInt(obj11); } { try { @@ -11632,7 +7797,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_input_size_get(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11640,16 +7805,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSE int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjective", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationProblem_CalcObjective", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjective" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjective" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11683,7 +7852,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjective(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11694,15 +7863,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"grad", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_CalcObjectiveGrad", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationProblem_CalcObjectiveGrad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11710,7 +7884,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_CalcObjectiveGrad" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -11744,7 +7918,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_CalcObjectiveGrad(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11752,15 +7926,19 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *S int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetEqualityConstraint", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationProblem_SetEqualityConstraint", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetEqualityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11794,7 +7972,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetEqualityConstraint(PyObject *S } -SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11805,15 +7983,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dl", (char *)"dh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetInequalityConstraint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationProblem_SetInequalityConstraint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11821,7 +8004,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetInequalityConstraint" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -11855,7 +8038,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetInequalityConstraint(PyObject } -SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11866,15 +8049,20 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGU int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"xl", (char *)"xh", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "OptimizationProblem_SetSolutionBounds", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationProblem_SetSolutionBounds", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -11882,7 +8070,7 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_SetSolutionBounds(PyObject *SWIGU SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationProblem_SetSolutionBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -12213,262 +8401,14 @@ SWIGINTERN PyObject *_wrap_OptimizationProblem_GetNumConstraints(PyObject *SWIGU if (!args) SWIG_fail; swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetNumConstraints" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); - } - arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - { - try { - result = (int)((mfem::OptimizationProblem const *)arg1)->GetNumConstraints(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_delete_OptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); - } - arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *OptimizationProblem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationProblem, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *_wrap_delete_OptimizationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationSolver" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); - } - arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - { - try { - delete arg1; - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; - mfem::OptimizationProblem *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); - } - arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); - } - arg2 = reinterpret_cast< mfem::OptimizationProblem * >(argp2); - { - try { - (arg1)->SetOptimizationProblem((mfem::OptimizationProblem const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_Mult" "', argument " "1"" of type '" "mfem::OptimizationSolver const *""'"); - } - arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::OptimizationSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; - mfem::Solver *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; - - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetPreconditioner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); - } - arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Solver, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationProblem_GetNumConstraints" "', argument " "1"" of type '" "mfem::OptimizationProblem const *""'"); } - arg2 = reinterpret_cast< mfem::Solver * >(argp2); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { try { - (arg1)->SetPreconditioner(*arg2); + result = (int)((mfem::OptimizationProblem const *)arg1)->GetNumConstraints(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12485,40 +8425,30 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_OptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; - mfem::Operator *arg2 = 0 ; + mfem::OptimizationProblem *arg1 = (mfem::OptimizationProblem *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "OptimizationSolver_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationProblem, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOperator" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); - } - arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationProblem *""'"); } - arg2 = reinterpret_cast< mfem::Operator * >(argp2); + arg1 = reinterpret_cast< mfem::OptimizationProblem * >(argp1); { try { - (arg1)->SetOperator((mfem::Operator const &)*arg2); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12542,21 +8472,30 @@ SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *OptimizationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *OptimizationProblem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *obj; if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationSolver, SWIG_NewClientData(obj)); + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationProblem, SWIG_NewClientData(obj)); return SWIG_Py_Void(); } -SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_delete_OptimizationSolver(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *result = 0 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "new_SLBQPOptimizer", 0, 0, 0)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__OptimizationSolver, SWIG_POINTER_DISOWN | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OptimizationSolver" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); + } + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); { try { - result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12573,35 +8512,39 @@ SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; mfem::OptimizationProblem *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"prob", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetOptimizationProblem", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationSolver_SetOptimizationProblem", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); } arg2 = reinterpret_cast< mfem::OptimizationProblem * >(argp2); { @@ -12630,9 +8573,9 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; @@ -12641,33 +8584,38 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"xt", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetBounds", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:OptimizationSolver_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_Mult" "', argument " "1"" of type '" "mfem::OptimizationSolver const *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->SetBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); + ((mfem::OptimizationSolver const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12691,41 +8639,37 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetPreconditioner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Vector *arg2 = 0 ; - double arg3 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Solver *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"pr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_SetLinearConstraint", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationSolver_SetPreconditioner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Solver, 0 ); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetPreconditioner" "', argument " "2"" of type '" "mfem::Solver &""'"); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + arg2 = reinterpret_cast< mfem::Solver * >(argp2); { try { - (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); + (arg1)->SetPreconditioner(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12749,44 +8693,37 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUS } -SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OptimizationSolver_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; + mfem::OptimizationSolver *arg1 = (mfem::OptimizationSolver *) 0 ; + mfem::Operator *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SLBQPOptimizer_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:OptimizationSolver_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__OptimizationSolver, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OptimizationSolver_SetOperator" "', argument " "1"" of type '" "mfem::OptimizationSolver *""'"); } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg1 = reinterpret_cast< mfem::OptimizationSolver * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "OptimizationSolver_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + arg2 = reinterpret_cast< mfem::Operator * >(argp2); { try { - ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); + (arg1)->SetOperator((mfem::Operator const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12810,23 +8747,21 @@ SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *OptimizationSolver_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__OptimizationSolver, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *_wrap_new_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; + mfem::SLBQPOptimizer *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); - } - arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + if (!SWIG_Python_UnpackTuple(args, "new_SLBQPOptimizer", 0, 0, 0)) SWIG_fail; { try { - delete arg1; + result = (mfem::SLBQPOptimizer *)new mfem::SLBQPOptimizer(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12843,54 +8778,44 @@ SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_NEW | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *obj; - if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; - SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); - return SWIG_Py_Void(); -} - -SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - return SWIG_Python_InitShadowInstance(args); -} - -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetOptimizationProblem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - mfem::BlockILU::Reordering arg2 ; - int arg3 ; - int val2 ; - int ecode2 = 0 ; - mfem::BlockILU *result = 0 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::OptimizationProblem *arg2 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"prob", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SLBQPOptimizer_SetOptimizationProblem", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg2 = static_cast< mfem::BlockILU::Reordering >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__OptimizationProblem, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetOptimizationProblem" "', argument " "2"" of type '" "mfem::OptimizationProblem const &""'"); } + arg2 = reinterpret_cast< mfem::OptimizationProblem * >(argp2); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2,arg3); + (arg1)->SetOptimizationProblem((mfem::OptimizationProblem const &)*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12907,36 +8832,56 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - mfem::BlockILU::Reordering arg2 ; - int val2 ; - int ecode2 = 0 ; - mfem::BlockILU *result = 0 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_lo", (char *)"_hi", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLBQPOptimizer_SetBounds", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg2 = static_cast< mfem::BlockILU::Reordering >(val2); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetBounds" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2); + (arg1)->SetBounds((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12953,28 +8898,53 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_SetLinearConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - int arg1 ; - mfem::BlockILU *result = 0 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + double arg3 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_w", (char *)"_a", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLBQPOptimizer_SetLinearConstraint", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SLBQPOptimizer_SetLinearConstraint" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(arg1); + (arg1)->SetLinearConstraint((mfem::Vector const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12991,54 +8961,56 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_2(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SLBQPOptimizer_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - int arg2 ; - mfem::BlockILU::Reordering arg3 ; - int arg4 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::BlockILU *result = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"xt", (char *)"x", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SLBQPOptimizer_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SLBQPOptimizer_Mult" "', argument " "1"" of type '" "mfem::SLBQPOptimizer const *""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg3 = static_cast< mfem::BlockILU::Reordering >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SLBQPOptimizer_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3,arg4); + ((mfem::SLBQPOptimizer const *)arg1)->Mult((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13055,47 +9027,30 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_delete_SLBQPOptimizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - int arg2 ; - mfem::BlockILU::Reordering arg3 ; + mfem::SLBQPOptimizer *arg1 = (mfem::SLBQPOptimizer *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; - mfem::BlockILU *result = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SLBQPOptimizer" "', argument " "1"" of type '" "mfem::SLBQPOptimizer *""'"); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); - } - arg3 = static_cast< mfem::BlockILU::Reordering >(val3); + arg1 = reinterpret_cast< mfem::SLBQPOptimizer * >(argp1); { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3); + delete arg1; } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13112,39 +9067,58 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_4(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__BlockILU, SWIG_POINTER_NEW | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *SLBQPOptimizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *obj; + if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL; + SWIG_TypeNewClientData(SWIGTYPE_p_mfem__SLBQPOptimizer, SWIG_NewClientData(obj)); + return SWIG_Py_Void(); +} + +SWIGINTERN PyObject *SLBQPOptimizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + return SWIG_Python_InitShadowInstance(args); +} + +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - mfem::Operator *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; + int arg1 ; + mfem::BlockILU::Reordering arg2 = (mfem::BlockILU::Reordering) mfem::BlockILU::Reordering::MINIMUM_DISCARDED_FILL ; + int arg3 = (int) 0 ; + int val2 ; + int ecode2 = 0 ; mfem::BlockILU *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); - } - arg1 = reinterpret_cast< mfem::Operator * >(argp1); + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg1 = PyArray_PyIntAsInt(swig_obj[0]); + } + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_BlockILU" "', argument " "2"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg2 = static_cast< mfem::BlockILU::Reordering >(val2); + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2); + result = (mfem::BlockILU *)new mfem::BlockILU(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13168,14 +9142,19 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_5(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Operator *arg1 = 0 ; + int arg2 = (int) 1 ; + mfem::BlockILU::Reordering arg3 = (mfem::BlockILU::Reordering) mfem::BlockILU::Reordering::MINIMUM_DISCARDED_FILL ; + int arg4 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; + int val3 ; + int ecode3 = 0 ; mfem::BlockILU *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__Operator, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); @@ -13184,9 +9163,32 @@ SWIGINTERN PyObject *_wrap_new_BlockILU__SWIG_6(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_BlockILU" "', argument " "1"" of type '" "mfem::Operator &""'"); } arg1 = reinterpret_cast< mfem::Operator * >(argp1); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_BlockILU" "', argument " "3"" of type '" "mfem::BlockILU::Reordering""'"); + } + arg3 = static_cast< mfem::BlockILU::Reordering >(val3); + } + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); + } + } { try { - result = (mfem::BlockILU *)new mfem::BlockILU(*arg1); + result = (mfem::BlockILU *)new mfem::BlockILU(*arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13218,74 +9220,15 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_BlockILU", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_BlockILU__SWIG_6(self, argc, argv); - } - } - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BlockILU__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BlockILU__SWIG_5(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { + if (argc <= 1) { return _wrap_new_BlockILU__SWIG_1(self, argc, argv); } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -13295,17 +9238,33 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_BlockILU__SWIG_4(self, argc, argv); + if (argc <= 3) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_BlockILU__SWIG_1(self, argc, argv); + } } } } } - if (argc == 3) { + if ((argc >= 1) && (argc <= 3)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -13316,11 +9275,17 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 1) { + return _wrap_new_BlockILU__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 2) { + return _wrap_new_BlockILU__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -13335,57 +9300,17 @@ SWIGINTERN PyObject *_wrap_new_BlockILU(PyObject *self, PyObject *args) { } } } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Operator, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_BlockILU__SWIG_3(self, argc, argv); - } - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_BlockILU'.\n" " Possible C/C++ prototypes are:\n" " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering,int)\n" - " mfem::BlockILU::BlockILU(int,mfem::BlockILU::Reordering)\n" - " mfem::BlockILU::BlockILU(int)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering,int)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &,int)\n" - " mfem::BlockILU::BlockILU(mfem::Operator &)\n"); + " mfem::BlockILU::BlockILU(mfem::Operator &,int,mfem::BlockILU::Reordering,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; mfem::Operator *arg2 = 0 ; @@ -13393,15 +9318,19 @@ SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"op", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockILU_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:BlockILU_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_SetOperator" "', argument " "1"" of type '" "mfem::BlockILU *""'"); } arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -13435,7 +9364,7 @@ SWIGINTERN PyObject *_wrap_BlockILU_SetOperator(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::BlockILU *arg1 = (mfem::BlockILU *) 0 ; mfem::Vector *arg2 = 0 ; @@ -13446,15 +9375,20 @@ SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "BlockILU_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:BlockILU_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__BlockILU, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BlockILU_Mult" "', argument " "1"" of type '" "mfem::BlockILU const *""'"); } arg1 = reinterpret_cast< mfem::BlockILU * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -13462,7 +9396,7 @@ SWIGINTERN PyObject *_wrap_BlockILU_Mult(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "BlockILU_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "BlockILU_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -13673,30 +9607,30 @@ SWIGINTERN PyObject *BlockILU_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "IterativeSolver_SetRelTol(IterativeSolver self, double rtol)"}, - { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "IterativeSolver_SetAbsTol(IterativeSolver self, double atol)"}, - { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "IterativeSolver_SetMaxIter(IterativeSolver self, int max_it)"}, - { "IterativeSolver_SetPrintLevel", _wrap_IterativeSolver_SetPrintLevel, METH_VARARGS, "IterativeSolver_SetPrintLevel(IterativeSolver self, int print_lvl)"}, + { "IterativeSolver_SetRelTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetRelTol, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetRelTol(IterativeSolver self, double rtol)"}, + { "IterativeSolver_SetAbsTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetAbsTol, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetAbsTol(IterativeSolver self, double atol)"}, + { "IterativeSolver_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetMaxIter(IterativeSolver self, int max_it)"}, + { "IterativeSolver_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetPrintLevel(IterativeSolver self, int print_lvl)"}, { "IterativeSolver_GetNumIterations", _wrap_IterativeSolver_GetNumIterations, METH_O, "IterativeSolver_GetNumIterations(IterativeSolver self) -> int"}, { "IterativeSolver_GetConverged", _wrap_IterativeSolver_GetConverged, METH_O, "IterativeSolver_GetConverged(IterativeSolver self) -> int"}, { "IterativeSolver_GetFinalNorm", _wrap_IterativeSolver_GetFinalNorm, METH_O, "IterativeSolver_GetFinalNorm(IterativeSolver self) -> double"}, - { "IterativeSolver_SetPreconditioner", _wrap_IterativeSolver_SetPreconditioner, METH_VARARGS, "IterativeSolver_SetPreconditioner(IterativeSolver self, Solver pr)"}, - { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "IterativeSolver_SetOperator(IterativeSolver self, Operator op)"}, + { "IterativeSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetPreconditioner(IterativeSolver self, Solver pr)"}, + { "IterativeSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "IterativeSolver_SetOperator(IterativeSolver self, Operator op)"}, { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" - "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + "new_OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother\n" ""}, { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, - { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "OperatorJacobiSmoother_Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, - { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "OperatorJacobiSmoother_SetOperator(OperatorJacobiSmoother self, Operator op)"}, - { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "OperatorJacobiSmoother_Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "OperatorJacobiSmoother_Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "OperatorJacobiSmoother_SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Setup, METH_VARARGS|METH_KEYWORDS, "OperatorJacobiSmoother_Setup(OperatorJacobiSmoother self, Vector diag)"}, { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, { "new_SLISolver", _wrap_new_SLISolver, METH_NOARGS, "new_SLISolver() -> SLISolver"}, - { "SLISolver_SetOperator", _wrap_SLISolver_SetOperator, METH_VARARGS, "SLISolver_SetOperator(SLISolver self, Operator op)"}, - { "SLISolver_Mult", _wrap_SLISolver_Mult, METH_VARARGS, "SLISolver_Mult(SLISolver self, Vector b, Vector x)"}, + { "SLISolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_SLISolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SLISolver_SetOperator(SLISolver self, Operator op)"}, + { "SLISolver_Mult", (PyCFunction)(void(*)(void))_wrap_SLISolver_Mult, METH_VARARGS|METH_KEYWORDS, "SLISolver_Mult(SLISolver self, Vector b, Vector x)"}, { "delete_SLISolver", _wrap_delete_SLISolver, METH_O, "delete_SLISolver(SLISolver self)"}, { "SLISolver_swigregister", SLISolver_swigregister, METH_O, NULL}, { "SLISolver_swiginit", SLISolver_swiginit, METH_VARARGS, NULL}, @@ -13705,22 +9639,22 @@ static PyMethodDef SwigMethods[] = { "SLI(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)\n" ""}, { "new_CGSolver", _wrap_new_CGSolver, METH_NOARGS, "new_CGSolver() -> CGSolver"}, - { "CGSolver_SetOperator", _wrap_CGSolver_SetOperator, METH_VARARGS, "CGSolver_SetOperator(CGSolver self, Operator op)"}, - { "CGSolver_Mult", _wrap_CGSolver_Mult, METH_VARARGS, "CGSolver_Mult(CGSolver self, Vector b, Vector x)"}, + { "CGSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_CGSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "CGSolver_SetOperator(CGSolver self, Operator op)"}, + { "CGSolver_Mult", (PyCFunction)(void(*)(void))_wrap_CGSolver_Mult, METH_VARARGS|METH_KEYWORDS, "CGSolver_Mult(CGSolver self, Vector b, Vector x)"}, { "delete_CGSolver", _wrap_delete_CGSolver, METH_O, "delete_CGSolver(CGSolver self)"}, { "CGSolver_swigregister", CGSolver_swigregister, METH_O, NULL}, { "CGSolver_swiginit", CGSolver_swiginit, METH_VARARGS, NULL}, - { "CG", _wrap_CG, METH_VARARGS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, - { "PCG", _wrap_PCG, METH_VARARGS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "CG", (PyCFunction)(void(*)(void))_wrap_CG, METH_VARARGS|METH_KEYWORDS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "PCG", (PyCFunction)(void(*)(void))_wrap_PCG, METH_VARARGS|METH_KEYWORDS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, { "new_GMRESSolver", _wrap_new_GMRESSolver, METH_NOARGS, "new_GMRESSolver() -> GMRESSolver"}, - { "GMRESSolver_SetKDim", _wrap_GMRESSolver_SetKDim, METH_VARARGS, "GMRESSolver_SetKDim(GMRESSolver self, int dim)"}, - { "GMRESSolver_Mult", _wrap_GMRESSolver_Mult, METH_VARARGS, "GMRESSolver_Mult(GMRESSolver self, Vector b, Vector x)"}, + { "GMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "GMRESSolver_SetKDim(GMRESSolver self, int dim)"}, + { "GMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "GMRESSolver_Mult(GMRESSolver self, Vector b, Vector x)"}, { "delete_GMRESSolver", _wrap_delete_GMRESSolver, METH_O, "delete_GMRESSolver(GMRESSolver self)"}, { "GMRESSolver_swigregister", GMRESSolver_swigregister, METH_O, NULL}, { "GMRESSolver_swiginit", GMRESSolver_swiginit, METH_VARARGS, NULL}, { "new_FGMRESSolver", _wrap_new_FGMRESSolver, METH_NOARGS, "new_FGMRESSolver() -> FGMRESSolver"}, - { "FGMRESSolver_SetKDim", _wrap_FGMRESSolver_SetKDim, METH_VARARGS, "FGMRESSolver_SetKDim(FGMRESSolver self, int dim)"}, - { "FGMRESSolver_Mult", _wrap_FGMRESSolver_Mult, METH_VARARGS, "FGMRESSolver_Mult(FGMRESSolver self, Vector b, Vector x)"}, + { "FGMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "FGMRESSolver_SetKDim(FGMRESSolver self, int dim)"}, + { "FGMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "FGMRESSolver_Mult(FGMRESSolver self, Vector b, Vector x)"}, { "delete_FGMRESSolver", _wrap_delete_FGMRESSolver, METH_O, "delete_FGMRESSolver(FGMRESSolver self)"}, { "FGMRESSolver_swigregister", FGMRESSolver_swigregister, METH_O, NULL}, { "FGMRESSolver_swiginit", FGMRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13729,8 +9663,8 @@ static PyMethodDef SwigMethods[] = { "GMRES(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, int m=50, double rtol=1e-12, double atol=1e-24)\n" ""}, { "new_BiCGSTABSolver", _wrap_new_BiCGSTABSolver, METH_NOARGS, "new_BiCGSTABSolver() -> BiCGSTABSolver"}, - { "BiCGSTABSolver_SetOperator", _wrap_BiCGSTABSolver_SetOperator, METH_VARARGS, "BiCGSTABSolver_SetOperator(BiCGSTABSolver self, Operator op)"}, - { "BiCGSTABSolver_Mult", _wrap_BiCGSTABSolver_Mult, METH_VARARGS, "BiCGSTABSolver_Mult(BiCGSTABSolver self, Vector b, Vector x)"}, + { "BiCGSTABSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "BiCGSTABSolver_SetOperator(BiCGSTABSolver self, Operator op)"}, + { "BiCGSTABSolver_Mult", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_Mult, METH_VARARGS|METH_KEYWORDS, "BiCGSTABSolver_Mult(BiCGSTABSolver self, Vector b, Vector x)"}, { "delete_BiCGSTABSolver", _wrap_delete_BiCGSTABSolver, METH_O, "delete_BiCGSTABSolver(BiCGSTABSolver self)"}, { "BiCGSTABSolver_swigregister", BiCGSTABSolver_swigregister, METH_O, NULL}, { "BiCGSTABSolver_swiginit", BiCGSTABSolver_swiginit, METH_VARARGS, NULL}, @@ -13739,9 +9673,9 @@ static PyMethodDef SwigMethods[] = { "BiCGSTAB(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double rtol=1e-12, double atol=1e-24)\n" ""}, { "new_MINRESSolver", _wrap_new_MINRESSolver, METH_NOARGS, "new_MINRESSolver() -> MINRESSolver"}, - { "MINRESSolver_SetPreconditioner", _wrap_MINRESSolver_SetPreconditioner, METH_VARARGS, "MINRESSolver_SetPreconditioner(MINRESSolver self, Solver pr)"}, - { "MINRESSolver_SetOperator", _wrap_MINRESSolver_SetOperator, METH_VARARGS, "MINRESSolver_SetOperator(MINRESSolver self, Operator op)"}, - { "MINRESSolver_Mult", _wrap_MINRESSolver_Mult, METH_VARARGS, "MINRESSolver_Mult(MINRESSolver self, Vector b, Vector x)"}, + { "MINRESSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "MINRESSolver_SetPreconditioner(MINRESSolver self, Solver pr)"}, + { "MINRESSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "MINRESSolver_SetOperator(MINRESSolver self, Operator op)"}, + { "MINRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "MINRESSolver_Mult(MINRESSolver self, Vector b, Vector x)"}, { "delete_MINRESSolver", _wrap_delete_MINRESSolver, METH_O, "delete_MINRESSolver(MINRESSolver self)"}, { "MINRESSolver_swigregister", MINRESSolver_swigregister, METH_O, NULL}, { "MINRESSolver_swiginit", MINRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13750,21 +9684,21 @@ static PyMethodDef SwigMethods[] = { "MINRES(Operator A, Solver B, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24)\n" ""}, { "new_NewtonSolver", _wrap_new_NewtonSolver, METH_NOARGS, "new_NewtonSolver() -> NewtonSolver"}, - { "NewtonSolver_SetOperator", _wrap_NewtonSolver_SetOperator, METH_VARARGS, "NewtonSolver_SetOperator(NewtonSolver self, Operator op)"}, - { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "NewtonSolver_SetSolver(NewtonSolver self, Solver solver)"}, - { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "NewtonSolver_Mult(NewtonSolver self, Vector b, Vector x)"}, - { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "NewtonSolver_ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, - { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "NewtonSolver_ProcessNewState(NewtonSolver self, Vector x)"}, + { "NewtonSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_SetOperator(NewtonSolver self, Operator op)"}, + { "NewtonSolver_SetSolver", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetSolver, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_SetSolver(NewtonSolver self, Solver solver)"}, + { "NewtonSolver_Mult", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_Mult, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_Mult(NewtonSolver self, Vector b, Vector x)"}, + { "NewtonSolver_ComputeScalingFactor", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ProcessNewState, METH_VARARGS|METH_KEYWORDS, "NewtonSolver_ProcessNewState(NewtonSolver self, Vector x)"}, { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, - { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "aGMRES", (PyCFunction)(void(*)(void))_wrap_aGMRES, METH_VARARGS|METH_KEYWORDS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, - { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "OptimizationProblem_CalcObjective(OptimizationProblem self, Vector x) -> double"}, - { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "OptimizationProblem_CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, - { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "OptimizationProblem_SetEqualityConstraint(OptimizationProblem self, Vector c)"}, - { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "OptimizationProblem_SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, - { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "OptimizationProblem_SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_CalcObjective", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjective, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS|METH_KEYWORDS, "OptimizationProblem_SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "OptimizationProblem_GetC(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "OptimizationProblem_GetD(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "OptimizationProblem_GetEqualityVec(OptimizationProblem self) -> Vector"}, @@ -13776,25 +9710,25 @@ static PyMethodDef SwigMethods[] = { { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, - { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "OptimizationSolver_SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, - { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "OptimizationSolver_Mult(OptimizationSolver self, Vector xt, Vector x)"}, - { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "OptimizationSolver_SetPreconditioner(OptimizationSolver self, Solver pr)"}, - { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "OptimizationSolver_SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_Mult, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "OptimizationSolver_SetOperator(OptimizationSolver self, Operator op)"}, { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_NOARGS, "new_SLBQPOptimizer() -> SLBQPOptimizer"}, - { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SLBQPOptimizer_SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, - { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SLBQPOptimizer_SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, - { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SLBQPOptimizer_SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, - { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "SLBQPOptimizer_Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, + { "SLBQPOptimizer_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, + { "SLBQPOptimizer_SetBounds", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetBounds, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, + { "SLBQPOptimizer_SetLinearConstraint", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, + { "SLBQPOptimizer_Mult", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_Mult, METH_VARARGS|METH_KEYWORDS, "SLBQPOptimizer_Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" - "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "new_BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU\n" ""}, - { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "BlockILU_SetOperator(BlockILU self, Operator op)"}, - { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "BlockILU_Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockILU_SetOperator, METH_VARARGS|METH_KEYWORDS, "BlockILU_SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", (PyCFunction)(void(*)(void))_wrap_BlockILU_Mult, METH_VARARGS|METH_KEYWORDS, "BlockILU_Mult(BlockILU self, Vector b, Vector x)"}, { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "BlockILU_GetBlockI(BlockILU self) -> int *"}, { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "BlockILU_GetBlockJ(BlockILU self) -> int *"}, { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "BlockILU_GetBlockData(BlockILU self) -> double *"}, @@ -13807,30 +9741,30 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "IterativeSolver_SetRelTol", _wrap_IterativeSolver_SetRelTol, METH_VARARGS, "SetRelTol(IterativeSolver self, double rtol)"}, - { "IterativeSolver_SetAbsTol", _wrap_IterativeSolver_SetAbsTol, METH_VARARGS, "SetAbsTol(IterativeSolver self, double atol)"}, - { "IterativeSolver_SetMaxIter", _wrap_IterativeSolver_SetMaxIter, METH_VARARGS, "SetMaxIter(IterativeSolver self, int max_it)"}, - { "IterativeSolver_SetPrintLevel", _wrap_IterativeSolver_SetPrintLevel, METH_VARARGS, "SetPrintLevel(IterativeSolver self, int print_lvl)"}, + { "IterativeSolver_SetRelTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetRelTol, METH_VARARGS|METH_KEYWORDS, "SetRelTol(IterativeSolver self, double rtol)"}, + { "IterativeSolver_SetAbsTol", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetAbsTol, METH_VARARGS|METH_KEYWORDS, "SetAbsTol(IterativeSolver self, double atol)"}, + { "IterativeSolver_SetMaxIter", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetMaxIter, METH_VARARGS|METH_KEYWORDS, "SetMaxIter(IterativeSolver self, int max_it)"}, + { "IterativeSolver_SetPrintLevel", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPrintLevel, METH_VARARGS|METH_KEYWORDS, "SetPrintLevel(IterativeSolver self, int print_lvl)"}, { "IterativeSolver_GetNumIterations", _wrap_IterativeSolver_GetNumIterations, METH_O, "GetNumIterations(IterativeSolver self) -> int"}, { "IterativeSolver_GetConverged", _wrap_IterativeSolver_GetConverged, METH_O, "GetConverged(IterativeSolver self) -> int"}, { "IterativeSolver_GetFinalNorm", _wrap_IterativeSolver_GetFinalNorm, METH_O, "GetFinalNorm(IterativeSolver self) -> double"}, - { "IterativeSolver_SetPreconditioner", _wrap_IterativeSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(IterativeSolver self, Solver pr)"}, - { "IterativeSolver_SetOperator", _wrap_IterativeSolver_SetOperator, METH_VARARGS, "SetOperator(IterativeSolver self, Operator op)"}, + { "IterativeSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(IterativeSolver self, Solver pr)"}, + { "IterativeSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_IterativeSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(IterativeSolver self, Operator op)"}, { "delete_IterativeSolver", _wrap_delete_IterativeSolver, METH_O, "delete_IterativeSolver(IterativeSolver self)"}, { "IterativeSolver_swigregister", IterativeSolver_swigregister, METH_O, NULL}, { "new_OperatorJacobiSmoother", _wrap_new_OperatorJacobiSmoother, METH_VARARGS, "\n" "OperatorJacobiSmoother(mfem::BilinearForm const & a, intArray ess_tdof_list, double const damping=1.0)\n" - "OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0)\n" + "new_OperatorJacobiSmoother(Vector d, intArray ess_tdof_list, double const damping=1.0) -> OperatorJacobiSmoother\n" ""}, { "delete_OperatorJacobiSmoother", _wrap_delete_OperatorJacobiSmoother, METH_O, "delete_OperatorJacobiSmoother(OperatorJacobiSmoother self)"}, - { "OperatorJacobiSmoother_Mult", _wrap_OperatorJacobiSmoother_Mult, METH_VARARGS, "Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, - { "OperatorJacobiSmoother_SetOperator", _wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS, "SetOperator(OperatorJacobiSmoother self, Operator op)"}, - { "OperatorJacobiSmoother_Setup", _wrap_OperatorJacobiSmoother_Setup, METH_VARARGS, "Setup(OperatorJacobiSmoother self, Vector diag)"}, + { "OperatorJacobiSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(OperatorJacobiSmoother self, Vector x, Vector y)"}, + { "OperatorJacobiSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(OperatorJacobiSmoother self, Operator op)"}, + { "OperatorJacobiSmoother_Setup", (PyCFunction)(void(*)(void))_wrap_OperatorJacobiSmoother_Setup, METH_VARARGS|METH_KEYWORDS, "Setup(OperatorJacobiSmoother self, Vector diag)"}, { "OperatorJacobiSmoother_swigregister", OperatorJacobiSmoother_swigregister, METH_O, NULL}, { "OperatorJacobiSmoother_swiginit", OperatorJacobiSmoother_swiginit, METH_VARARGS, NULL}, { "new_SLISolver", _wrap_new_SLISolver, METH_NOARGS, "new_SLISolver() -> SLISolver"}, - { "SLISolver_SetOperator", _wrap_SLISolver_SetOperator, METH_VARARGS, "SetOperator(SLISolver self, Operator op)"}, - { "SLISolver_Mult", _wrap_SLISolver_Mult, METH_VARARGS, "Mult(SLISolver self, Vector b, Vector x)"}, + { "SLISolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_SLISolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(SLISolver self, Operator op)"}, + { "SLISolver_Mult", (PyCFunction)(void(*)(void))_wrap_SLISolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(SLISolver self, Vector b, Vector x)"}, { "delete_SLISolver", _wrap_delete_SLISolver, METH_O, "delete_SLISolver(SLISolver self)"}, { "SLISolver_swigregister", SLISolver_swigregister, METH_O, NULL}, { "SLISolver_swiginit", SLISolver_swiginit, METH_VARARGS, NULL}, @@ -13839,22 +9773,22 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SLI(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)\n" ""}, { "new_CGSolver", _wrap_new_CGSolver, METH_NOARGS, "new_CGSolver() -> CGSolver"}, - { "CGSolver_SetOperator", _wrap_CGSolver_SetOperator, METH_VARARGS, "SetOperator(CGSolver self, Operator op)"}, - { "CGSolver_Mult", _wrap_CGSolver_Mult, METH_VARARGS, "Mult(CGSolver self, Vector b, Vector x)"}, + { "CGSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_CGSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(CGSolver self, Operator op)"}, + { "CGSolver_Mult", (PyCFunction)(void(*)(void))_wrap_CGSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(CGSolver self, Vector b, Vector x)"}, { "delete_CGSolver", _wrap_delete_CGSolver, METH_O, "delete_CGSolver(CGSolver self)"}, { "CGSolver_swigregister", CGSolver_swigregister, METH_O, NULL}, { "CGSolver_swiginit", CGSolver_swiginit, METH_VARARGS, NULL}, - { "CG", _wrap_CG, METH_VARARGS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, - { "PCG", _wrap_PCG, METH_VARARGS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "CG", (PyCFunction)(void(*)(void))_wrap_CG, METH_VARARGS|METH_KEYWORDS, "CG(Operator A, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, + { "PCG", (PyCFunction)(void(*)(void))_wrap_PCG, METH_VARARGS|METH_KEYWORDS, "PCG(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double RTOLERANCE=1e-12, double ATOLERANCE=1e-24)"}, { "new_GMRESSolver", _wrap_new_GMRESSolver, METH_NOARGS, "new_GMRESSolver() -> GMRESSolver"}, - { "GMRESSolver_SetKDim", _wrap_GMRESSolver_SetKDim, METH_VARARGS, "SetKDim(GMRESSolver self, int dim)"}, - { "GMRESSolver_Mult", _wrap_GMRESSolver_Mult, METH_VARARGS, "Mult(GMRESSolver self, Vector b, Vector x)"}, + { "GMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "SetKDim(GMRESSolver self, int dim)"}, + { "GMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_GMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(GMRESSolver self, Vector b, Vector x)"}, { "delete_GMRESSolver", _wrap_delete_GMRESSolver, METH_O, "delete_GMRESSolver(GMRESSolver self)"}, { "GMRESSolver_swigregister", GMRESSolver_swigregister, METH_O, NULL}, { "GMRESSolver_swiginit", GMRESSolver_swiginit, METH_VARARGS, NULL}, { "new_FGMRESSolver", _wrap_new_FGMRESSolver, METH_NOARGS, "new_FGMRESSolver() -> FGMRESSolver"}, - { "FGMRESSolver_SetKDim", _wrap_FGMRESSolver_SetKDim, METH_VARARGS, "SetKDim(FGMRESSolver self, int dim)"}, - { "FGMRESSolver_Mult", _wrap_FGMRESSolver_Mult, METH_VARARGS, "Mult(FGMRESSolver self, Vector b, Vector x)"}, + { "FGMRESSolver_SetKDim", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_SetKDim, METH_VARARGS|METH_KEYWORDS, "SetKDim(FGMRESSolver self, int dim)"}, + { "FGMRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_FGMRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(FGMRESSolver self, Vector b, Vector x)"}, { "delete_FGMRESSolver", _wrap_delete_FGMRESSolver, METH_O, "delete_FGMRESSolver(FGMRESSolver self)"}, { "FGMRESSolver_swigregister", FGMRESSolver_swigregister, METH_O, NULL}, { "FGMRESSolver_swiginit", FGMRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13863,8 +9797,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GMRES(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, int m=50, double rtol=1e-12, double atol=1e-24)\n" ""}, { "new_BiCGSTABSolver", _wrap_new_BiCGSTABSolver, METH_NOARGS, "new_BiCGSTABSolver() -> BiCGSTABSolver"}, - { "BiCGSTABSolver_SetOperator", _wrap_BiCGSTABSolver_SetOperator, METH_VARARGS, "SetOperator(BiCGSTABSolver self, Operator op)"}, - { "BiCGSTABSolver_Mult", _wrap_BiCGSTABSolver_Mult, METH_VARARGS, "Mult(BiCGSTABSolver self, Vector b, Vector x)"}, + { "BiCGSTABSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BiCGSTABSolver self, Operator op)"}, + { "BiCGSTABSolver_Mult", (PyCFunction)(void(*)(void))_wrap_BiCGSTABSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BiCGSTABSolver self, Vector b, Vector x)"}, { "delete_BiCGSTABSolver", _wrap_delete_BiCGSTABSolver, METH_O, "delete_BiCGSTABSolver(BiCGSTABSolver self)"}, { "BiCGSTABSolver_swigregister", BiCGSTABSolver_swigregister, METH_O, NULL}, { "BiCGSTABSolver_swiginit", BiCGSTABSolver_swiginit, METH_VARARGS, NULL}, @@ -13873,9 +9807,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "BiCGSTAB(Operator A, Solver B, Vector b, Vector x, int print_iter=0, int max_num_iter=1000, double rtol=1e-12, double atol=1e-24)\n" ""}, { "new_MINRESSolver", _wrap_new_MINRESSolver, METH_NOARGS, "new_MINRESSolver() -> MINRESSolver"}, - { "MINRESSolver_SetPreconditioner", _wrap_MINRESSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(MINRESSolver self, Solver pr)"}, - { "MINRESSolver_SetOperator", _wrap_MINRESSolver_SetOperator, METH_VARARGS, "SetOperator(MINRESSolver self, Operator op)"}, - { "MINRESSolver_Mult", _wrap_MINRESSolver_Mult, METH_VARARGS, "Mult(MINRESSolver self, Vector b, Vector x)"}, + { "MINRESSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(MINRESSolver self, Solver pr)"}, + { "MINRESSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(MINRESSolver self, Operator op)"}, + { "MINRESSolver_Mult", (PyCFunction)(void(*)(void))_wrap_MINRESSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(MINRESSolver self, Vector b, Vector x)"}, { "delete_MINRESSolver", _wrap_delete_MINRESSolver, METH_O, "delete_MINRESSolver(MINRESSolver self)"}, { "MINRESSolver_swigregister", MINRESSolver_swigregister, METH_O, NULL}, { "MINRESSolver_swiginit", MINRESSolver_swiginit, METH_VARARGS, NULL}, @@ -13884,21 +9818,21 @@ static PyMethodDef SwigMethods_proxydocs[] = { "MINRES(Operator A, Solver B, Vector b, Vector x, int print_it=0, int max_it=1000, double rtol=1e-12, double atol=1e-24)\n" ""}, { "new_NewtonSolver", _wrap_new_NewtonSolver, METH_NOARGS, "new_NewtonSolver() -> NewtonSolver"}, - { "NewtonSolver_SetOperator", _wrap_NewtonSolver_SetOperator, METH_VARARGS, "SetOperator(NewtonSolver self, Operator op)"}, - { "NewtonSolver_SetSolver", _wrap_NewtonSolver_SetSolver, METH_VARARGS, "SetSolver(NewtonSolver self, Solver solver)"}, - { "NewtonSolver_Mult", _wrap_NewtonSolver_Mult, METH_VARARGS, "Mult(NewtonSolver self, Vector b, Vector x)"}, - { "NewtonSolver_ComputeScalingFactor", _wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS, "ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, - { "NewtonSolver_ProcessNewState", _wrap_NewtonSolver_ProcessNewState, METH_VARARGS, "ProcessNewState(NewtonSolver self, Vector x)"}, + { "NewtonSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(NewtonSolver self, Operator op)"}, + { "NewtonSolver_SetSolver", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_SetSolver, METH_VARARGS|METH_KEYWORDS, "SetSolver(NewtonSolver self, Solver solver)"}, + { "NewtonSolver_Mult", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(NewtonSolver self, Vector b, Vector x)"}, + { "NewtonSolver_ComputeScalingFactor", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ComputeScalingFactor, METH_VARARGS|METH_KEYWORDS, "ComputeScalingFactor(NewtonSolver self, Vector x, Vector b) -> double"}, + { "NewtonSolver_ProcessNewState", (PyCFunction)(void(*)(void))_wrap_NewtonSolver_ProcessNewState, METH_VARARGS|METH_KEYWORDS, "ProcessNewState(NewtonSolver self, Vector x)"}, { "delete_NewtonSolver", _wrap_delete_NewtonSolver, METH_O, "delete_NewtonSolver(NewtonSolver self)"}, { "NewtonSolver_swigregister", NewtonSolver_swigregister, METH_O, NULL}, { "NewtonSolver_swiginit", NewtonSolver_swiginit, METH_VARARGS, NULL}, - { "aGMRES", _wrap_aGMRES, METH_VARARGS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, + { "aGMRES", (PyCFunction)(void(*)(void))_wrap_aGMRES, METH_VARARGS|METH_KEYWORDS, "aGMRES(Operator A, Vector x, Vector b, Operator M, int & max_iter, int m_max, int m_min, int m_step, double cf, double & tol, double & atol, int printit) -> int"}, { "OptimizationProblem_input_size_get", _wrap_OptimizationProblem_input_size_get, METH_O, "OptimizationProblem_input_size_get(OptimizationProblem self) -> int const"}, - { "OptimizationProblem_CalcObjective", _wrap_OptimizationProblem_CalcObjective, METH_VARARGS, "CalcObjective(OptimizationProblem self, Vector x) -> double"}, - { "OptimizationProblem_CalcObjectiveGrad", _wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS, "CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, - { "OptimizationProblem_SetEqualityConstraint", _wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS, "SetEqualityConstraint(OptimizationProblem self, Vector c)"}, - { "OptimizationProblem_SetInequalityConstraint", _wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS, "SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, - { "OptimizationProblem_SetSolutionBounds", _wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS, "SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, + { "OptimizationProblem_CalcObjective", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjective, METH_VARARGS|METH_KEYWORDS, "CalcObjective(OptimizationProblem self, Vector x) -> double"}, + { "OptimizationProblem_CalcObjectiveGrad", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_CalcObjectiveGrad, METH_VARARGS|METH_KEYWORDS, "CalcObjectiveGrad(OptimizationProblem self, Vector x, Vector grad)"}, + { "OptimizationProblem_SetEqualityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetEqualityConstraint, METH_VARARGS|METH_KEYWORDS, "SetEqualityConstraint(OptimizationProblem self, Vector c)"}, + { "OptimizationProblem_SetInequalityConstraint", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetInequalityConstraint, METH_VARARGS|METH_KEYWORDS, "SetInequalityConstraint(OptimizationProblem self, Vector dl, Vector dh)"}, + { "OptimizationProblem_SetSolutionBounds", (PyCFunction)(void(*)(void))_wrap_OptimizationProblem_SetSolutionBounds, METH_VARARGS|METH_KEYWORDS, "SetSolutionBounds(OptimizationProblem self, Vector xl, Vector xh)"}, { "OptimizationProblem_GetC", _wrap_OptimizationProblem_GetC, METH_O, "GetC(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetD", _wrap_OptimizationProblem_GetD, METH_O, "GetD(OptimizationProblem self) -> Operator"}, { "OptimizationProblem_GetEqualityVec", _wrap_OptimizationProblem_GetEqualityVec, METH_O, "GetEqualityVec(OptimizationProblem self) -> Vector"}, @@ -13910,25 +9844,25 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_OptimizationProblem", _wrap_delete_OptimizationProblem, METH_O, "delete_OptimizationProblem(OptimizationProblem self)"}, { "OptimizationProblem_swigregister", OptimizationProblem_swigregister, METH_O, NULL}, { "delete_OptimizationSolver", _wrap_delete_OptimizationSolver, METH_O, "delete_OptimizationSolver(OptimizationSolver self)"}, - { "OptimizationSolver_SetOptimizationProblem", _wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, - { "OptimizationSolver_Mult", _wrap_OptimizationSolver_Mult, METH_VARARGS, "Mult(OptimizationSolver self, Vector xt, Vector x)"}, - { "OptimizationSolver_SetPreconditioner", _wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS, "SetPreconditioner(OptimizationSolver self, Solver pr)"}, - { "OptimizationSolver_SetOperator", _wrap_OptimizationSolver_SetOperator, METH_VARARGS, "SetOperator(OptimizationSolver self, Operator op)"}, + { "OptimizationSolver_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "SetOptimizationProblem(OptimizationSolver self, OptimizationProblem prob)"}, + { "OptimizationSolver_Mult", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(OptimizationSolver self, Vector xt, Vector x)"}, + { "OptimizationSolver_SetPreconditioner", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetPreconditioner, METH_VARARGS|METH_KEYWORDS, "SetPreconditioner(OptimizationSolver self, Solver pr)"}, + { "OptimizationSolver_SetOperator", (PyCFunction)(void(*)(void))_wrap_OptimizationSolver_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(OptimizationSolver self, Operator op)"}, { "OptimizationSolver_swigregister", OptimizationSolver_swigregister, METH_O, NULL}, { "new_SLBQPOptimizer", _wrap_new_SLBQPOptimizer, METH_NOARGS, "new_SLBQPOptimizer() -> SLBQPOptimizer"}, - { "SLBQPOptimizer_SetOptimizationProblem", _wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS, "SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, - { "SLBQPOptimizer_SetBounds", _wrap_SLBQPOptimizer_SetBounds, METH_VARARGS, "SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, - { "SLBQPOptimizer_SetLinearConstraint", _wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS, "SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, - { "SLBQPOptimizer_Mult", _wrap_SLBQPOptimizer_Mult, METH_VARARGS, "Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, + { "SLBQPOptimizer_SetOptimizationProblem", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetOptimizationProblem, METH_VARARGS|METH_KEYWORDS, "SetOptimizationProblem(SLBQPOptimizer self, OptimizationProblem prob)"}, + { "SLBQPOptimizer_SetBounds", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetBounds, METH_VARARGS|METH_KEYWORDS, "SetBounds(SLBQPOptimizer self, Vector _lo, Vector _hi)"}, + { "SLBQPOptimizer_SetLinearConstraint", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_SetLinearConstraint, METH_VARARGS|METH_KEYWORDS, "SetLinearConstraint(SLBQPOptimizer self, Vector _w, double _a)"}, + { "SLBQPOptimizer_Mult", (PyCFunction)(void(*)(void))_wrap_SLBQPOptimizer_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(SLBQPOptimizer self, Vector xt, Vector x)"}, { "delete_SLBQPOptimizer", _wrap_delete_SLBQPOptimizer, METH_O, "delete_SLBQPOptimizer(SLBQPOptimizer self)"}, { "SLBQPOptimizer_swigregister", SLBQPOptimizer_swigregister, METH_O, NULL}, { "SLBQPOptimizer_swiginit", SLBQPOptimizer_swiginit, METH_VARARGS, NULL}, { "new_BlockILU", _wrap_new_BlockILU, METH_VARARGS, "\n" "BlockILU(int block_size_, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" - "BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0)\n" + "new_BlockILU(Operator op, int block_size_=1, mfem::BlockILU::Reordering reordering_=MINIMUM_DISCARDED_FILL, int k_fill_=0) -> BlockILU\n" ""}, - { "BlockILU_SetOperator", _wrap_BlockILU_SetOperator, METH_VARARGS, "SetOperator(BlockILU self, Operator op)"}, - { "BlockILU_Mult", _wrap_BlockILU_Mult, METH_VARARGS, "Mult(BlockILU self, Vector b, Vector x)"}, + { "BlockILU_SetOperator", (PyCFunction)(void(*)(void))_wrap_BlockILU_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(BlockILU self, Operator op)"}, + { "BlockILU_Mult", (PyCFunction)(void(*)(void))_wrap_BlockILU_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(BlockILU self, Vector b, Vector x)"}, { "BlockILU_GetBlockI", _wrap_BlockILU_GetBlockI, METH_O, "GetBlockI(BlockILU self) -> int *"}, { "BlockILU_GetBlockJ", _wrap_BlockILU_GetBlockJ, METH_O, "GetBlockJ(BlockILU self) -> int *"}, { "BlockILU_GetBlockData", _wrap_BlockILU_GetBlockData, METH_O, "GetBlockData(BlockILU self) -> double *"}, diff --git a/mfem/_ser/sparsemat.py b/mfem/_ser/sparsemat.py index b00c1a99..bfcfe468 100644 --- a/mfem/_ser/sparsemat.py +++ b/mfem/_ser/sparsemat.py @@ -205,17 +205,17 @@ def GetMemoryI(self, *args): GetMemoryI = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryI) def ReadI(self, on_dev=True): - r"""ReadI(SparseMatrix self, bool on_dev=True) -> int const""" + r"""ReadI(SparseMatrix self, bool on_dev=True) -> int const *""" return _sparsemat.SparseMatrix_ReadI(self, on_dev) ReadI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadI) def WriteI(self, on_dev=True): - r"""WriteI(SparseMatrix self, bool on_dev=True) -> int""" + r"""WriteI(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_WriteI(self, on_dev) WriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteI) def ReadWriteI(self, on_dev=True): - r"""ReadWriteI(SparseMatrix self, bool on_dev=True) -> int""" + r"""ReadWriteI(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_ReadWriteI(self, on_dev) ReadWriteI = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteI) @@ -243,17 +243,17 @@ def GetMemoryJ(self, *args): GetMemoryJ = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryJ) def ReadJ(self, on_dev=True): - r"""ReadJ(SparseMatrix self, bool on_dev=True) -> int const""" + r"""ReadJ(SparseMatrix self, bool on_dev=True) -> int const *""" return _sparsemat.SparseMatrix_ReadJ(self, on_dev) ReadJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadJ) def WriteJ(self, on_dev=True): - r"""WriteJ(SparseMatrix self, bool on_dev=True) -> int""" + r"""WriteJ(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_WriteJ(self, on_dev) WriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteJ) def ReadWriteJ(self, on_dev=True): - r"""ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int""" + r"""ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int *""" return _sparsemat.SparseMatrix_ReadWriteJ(self, on_dev) ReadWriteJ = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteJ) @@ -281,17 +281,17 @@ def GetMemoryData(self, *args): GetMemoryData = _swig_new_instance_method(_sparsemat.SparseMatrix_GetMemoryData) def ReadData(self, on_dev=True): - r"""ReadData(SparseMatrix self, bool on_dev=True) -> double const""" + r"""ReadData(SparseMatrix self, bool on_dev=True) -> double const *""" return _sparsemat.SparseMatrix_ReadData(self, on_dev) ReadData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadData) def WriteData(self, on_dev=True): - r"""WriteData(SparseMatrix self, bool on_dev=True) -> double""" + r"""WriteData(SparseMatrix self, bool on_dev=True) -> double *""" return _sparsemat.SparseMatrix_WriteData(self, on_dev) WriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_WriteData) def ReadWriteData(self, on_dev=True): - r"""ReadWriteData(SparseMatrix self, bool on_dev=True) -> double""" + r"""ReadWriteData(SparseMatrix self, bool on_dev=True) -> double *""" return _sparsemat.SparseMatrix_ReadWriteData(self, on_dev) ReadWriteData = _swig_new_instance_method(_sparsemat.SparseMatrix_ReadWriteData) @@ -468,9 +468,9 @@ def EliminateRow(self, *args): return _sparsemat.SparseMatrix_EliminateRow(self, *args) EliminateRow = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRow) - def EliminateCol(self, *args): + def EliminateCol(self, *args, **kwargs): r"""EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)""" - return _sparsemat.SparseMatrix_EliminateCol(self, *args) + return _sparsemat.SparseMatrix_EliminateCol(self, *args, **kwargs) EliminateCol = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCol) def EliminateCols(self, *args): @@ -481,9 +481,9 @@ def EliminateCols(self, *args): return _sparsemat.SparseMatrix_EliminateCols(self, *args) EliminateCols = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateCols) - def EliminateRowColMultipleRHS(self, *args): + def EliminateRowColMultipleRHS(self, *args, **kwargs): r"""EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)""" - return _sparsemat.SparseMatrix_EliminateRowColMultipleRHS(self, *args) + return _sparsemat.SparseMatrix_EliminateRowColMultipleRHS(self, *args, **kwargs) EliminateRowColMultipleRHS = _swig_new_instance_method(_sparsemat.SparseMatrix_EliminateRowColMultipleRHS) def EliminateRowColDiag(self, rc, value): diff --git a/mfem/_ser/sparsemat_wrap.cxx b/mfem/_ser/sparsemat_wrap.cxx index 74a828bf..7f2fd291 100644 --- a/mfem/_ser/sparsemat_wrap.cxx +++ b/mfem/_ser/sparsemat_wrap.cxx @@ -3562,7 +3562,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_SparseMatrix_Print__SWIG_3(mfem::SparseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_SparseMatrix_Print__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3573,7 +3573,7 @@ SWIGINTERN void mfem_SparseMatrix_Print__SWIG_3(mfem::SparseMatrix *self,char co self -> Print(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintMatlab__SWIG_2(mfem::SparseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_SparseMatrix_PrintMatlab__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3584,7 +3584,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintMatlab__SWIG_2(mfem::SparseMatrix *self,c self -> PrintMatlab(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintMM__SWIG_2(mfem::SparseMatrix *self,char const *file,int precision=8){ +SWIGINTERN void mfem_SparseMatrix_PrintMM__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3606,7 +3606,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintCSR__SWIG_1(mfem::SparseMatrix *self,char self -> PrintCSR(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintCSR__SWIG_3(mfem::SparseMatrix *self){ +SWIGINTERN void mfem_SparseMatrix_PrintCSR__SWIG_2(mfem::SparseMatrix *self){ self -> PrintCSR(std::cout); } SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ @@ -3620,7 +3620,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_1(mfem::SparseMatrix *self,cha self -> PrintCSR2(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_3(mfem::SparseMatrix *self){ +SWIGINTERN void mfem_SparseMatrix_PrintCSR2__SWIG_2(mfem::SparseMatrix *self){ self -> PrintCSR2(std::cout); } SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_1(mfem::SparseMatrix *self,char const *file,int precision=8){ @@ -3634,7 +3634,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_1(mfem::SparseMatrix *self,cha self -> PrintInfo(ofile); ofile.close(); } -SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_3(mfem::SparseMatrix *self){ +SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_2(mfem::SparseMatrix *self){ self -> PrintInfo(std::cout); } @@ -3648,7 +3648,7 @@ SWIGINTERN void mfem_SparseMatrix_PrintInfo__SWIG_3(mfem::SparseMatrix *self){ #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -3659,11 +3659,16 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"R", (char *)"ORAP", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RAP_P", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAP_P", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP_P" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3671,7 +3676,7 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_P" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAP_P" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3679,7 +3684,7 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_P" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP_P" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); } @@ -3710,7 +3715,7 @@ SWIGINTERN PyObject *_wrap_RAP_P(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -3721,11 +3726,16 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"Rt", (char *)"A", (char *)"P", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "RAP_R", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:RAP_R", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RAP_R" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3733,7 +3743,7 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_R" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RAP_R" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3741,7 +3751,7 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RAP_R" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } arg2 = reinterpret_cast< mfem::SparseMatrix * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RAP_R" "', argument " "3"" of type '" "mfem::SparseMatrix const &""'"); } @@ -3775,18 +3785,20 @@ SWIGINTERN PyObject *_wrap_RAP_R(PyObject *SWIGUNUSEDPARM(self), PyObject *args) } -SWIGINTERN PyObject *_wrap_OperatorPtr2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorPtr2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorPtr arg1 ; void *argp1 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:OperatorPtr2SparseMatrix", kwnames, &obj0)) SWIG_fail; { - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__OperatorPtr, 0 | 0); + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__OperatorPtr, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorPtr2SparseMatrix" "', argument " "1"" of type '" "mfem::OperatorPtr""'"); } @@ -3824,18 +3836,20 @@ SWIGINTERN PyObject *_wrap_OperatorPtr2SparseMatrix(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_OperatorHandle2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_OperatorHandle2SparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::OperatorHandle arg1 ; void *argp1 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"op", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:OperatorHandle2SparseMatrix", kwnames, &obj0)) SWIG_fail; { - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__OperatorHandle, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OperatorHandle2SparseMatrix" "', argument " "1"" of type '" "mfem::OperatorHandle""'"); } @@ -4144,21 +4158,23 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) -1 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -4187,44 +4203,6 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(sel SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::SparseMatrix *)new mfem::SparseMatrix(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; int *arg2 = (int *) 0 ; @@ -4292,7 +4270,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int *arg1 = (int *) 0 ; int *arg2 = (int *) 0 ; @@ -4384,7 +4362,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int arg2 ; @@ -4436,17 +4414,17 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -4455,56 +4433,16 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrix" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (mfem::SparseMatrix *)new mfem::SparseMatrix((mfem::SparseMatrix const &)*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_SparseMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SparseMatrix" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::SparseMatrix *)new mfem::SparseMatrix((mfem::SparseMatrix const &)*arg1); + result = (mfem::SparseMatrix *)new mfem::SparseMatrix((mfem::SparseMatrix const &)*arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4528,7 +4466,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_7(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_8(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_SparseMatrix__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = 0 ; void *argp1 = 0 ; @@ -4581,12 +4519,21 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { if (argc == 0) { return _wrap_new_SparseMatrix__SWIG_0(self, argc, argv); } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_SparseMatrix__SWIG_7(self, argc, argv); + if (argc <= 1) { + return _wrap_new_SparseMatrix__SWIG_5(self, argc, argv); + } + { + int res = SWIG_AsVal_bool(argv[1], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_new_SparseMatrix__SWIG_5(self, argc, argv); + } } } if (argc == 1) { @@ -4594,10 +4541,10 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_SparseMatrix__SWIG_8(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_6(self, argc, argv); } } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -4608,7 +4555,20 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); + if (argc <= 1) { + return _wrap_new_SparseMatrix__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SparseMatrix__SWIG_1(self, argc, argv); + } } } if (argc == 1) { @@ -4629,56 +4589,18 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { } if (_v) { if (argc <= 1) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } if (argc <= 2) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } if (argc <= 3) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } if (argc <= 4) { - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); - } - return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_SparseMatrix__SWIG_6(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_SparseMatrix__SWIG_1(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } + return _wrap_new_SparseMatrix__SWIG_2(self, argc, argv); } } if (argc == 3) { @@ -4710,7 +4632,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_SparseMatrix__SWIG_5(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_4(self, argc, argv); } } } @@ -4747,7 +4669,7 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_SparseMatrix__SWIG_4(self, argc, argv); + return _wrap_new_SparseMatrix__SWIG_3(self, argc, argv); } } } @@ -4759,18 +4681,16 @@ SWIGINTERN PyObject *_wrap_new_SparseMatrix(PyObject *self, PyObject *args) { " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::SparseMatrix()\n" " mfem::SparseMatrix::SparseMatrix(int,int)\n" - " mfem::SparseMatrix::SparseMatrix(int)\n" " mfem::SparseMatrix::SparseMatrix(int *,int *,double *,int,int)\n" " mfem::SparseMatrix::SparseMatrix(int *,int *,double *,int,int,bool,bool,bool)\n" " mfem::SparseMatrix::SparseMatrix(int,int,int)\n" " mfem::SparseMatrix::SparseMatrix(mfem::SparseMatrix const &,bool)\n" - " mfem::SparseMatrix::SparseMatrix(mfem::SparseMatrix const &)\n" " mfem::SparseMatrix::SparseMatrix(mfem::Vector const &)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -4778,15 +4698,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_MakeRef(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"master", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_MakeRef", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_MakeRef", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MakeRef" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_MakeRef" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -5398,27 +5322,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryI(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadI" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(arg2); @@ -5445,22 +5376,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_WriteI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->ReadI(); + result = (int *)(arg1)->WriteI(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5484,72 +5430,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadI", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadI__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadI__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadI(bool) const\n" - " mfem::SparseMatrix::ReadI() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadWriteI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteI" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteI" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)(arg1)->WriteI(arg2); + result = (int *)(arg1)->ReadWriteI(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5573,228 +5484,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_0(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (int *)(arg1)->WriteI(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteI", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_WriteI__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_WriteI__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::WriteI(bool)\n" - " mfem::SparseMatrix::WriteI()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - int *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteI" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)(arg1)->ReadWriteI(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteI" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (int *)(arg1)->ReadWriteI(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteI(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteI", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadWriteI__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadWriteI__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteI'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadWriteI(bool)\n" - " mfem::SparseMatrix::ReadWriteI()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int *result = 0 ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_HostReadI" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -6019,27 +5721,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryJ(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadJ", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadJ" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(arg2); @@ -6066,22 +5775,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_WriteJ", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadJ" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (int *)((mfem::SparseMatrix const *)arg1)->ReadJ(); + result = (int *)(arg1)->WriteJ(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6105,197 +5829,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ__SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadJ", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadJ__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadJ__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadJ(bool) const\n" - " mfem::SparseMatrix::ReadJ() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; int *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadWriteJ", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteJ" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (int *)(arg1)->WriteJ(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (int *)(arg1)->WriteJ(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteJ", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_WriteJ__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_WriteJ__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::WriteJ(bool)\n" - " mfem::SparseMatrix::WriteJ()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - int *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (int *)(arg1)->ReadWriteJ(arg2); @@ -6322,87 +5883,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_0(PyObject *SWIGUNUSEDP } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteJ" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (int *)(arg1)->ReadWriteJ(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteJ", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadWriteJ__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadWriteJ__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadWriteJ(bool)\n" - " mfem::SparseMatrix::ReadWriteJ()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; @@ -6640,27 +6120,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryData(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadData" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(arg2); @@ -6687,22 +6174,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_WriteData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadData" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)((mfem::SparseMatrix const *)arg1)->ReadData(); + result = (double *)(arg1)->WriteData(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6726,72 +6228,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadData(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadData", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadData__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadData__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadData'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadData(bool) const\n" - " mfem::SparseMatrix::ReadData() const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_ReadWriteData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_WriteData" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteData" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->WriteData(arg2); + result = (double *)(arg1)->ReadWriteData(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6815,216 +6282,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_WriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (double *)(arg1)->WriteData(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_WriteData(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_WriteData", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_WriteData__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_WriteData__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_WriteData'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::WriteData(bool)\n" - " mfem::SparseMatrix::WriteData()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_ReadWriteData" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->ReadWriteData(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ReadWriteData" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (double *)(arg1)->ReadWriteData(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ReadWriteData(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_ReadWriteData", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_ReadWriteData__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_ReadWriteData__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_ReadWriteData'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::ReadWriteData(bool)\n" - " mfem::SparseMatrix::ReadWriteData()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -7147,26 +6405,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_HostReadWriteData(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_RowSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_RowSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_RowSize" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -7531,24 +6793,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowEntries(PyObject *self, PyObject * } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; + int arg2 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"width_", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_SetWidth", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetWidth" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } } { try { @@ -7576,21 +6845,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ActualWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + int result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetWidth" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ActualWidth" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - (arg1)->SetWidth(); + result = (int)((mfem::SparseMatrix const *)arg1)->ActualWidth(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7607,112 +6879,25 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_int(static_cast< int >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetWidth(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; +SWIGINTERN PyObject *_wrap_SparseMatrix_SortColumnIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + PyObject *swig_obj[1] ; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SetWidth", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_SetWidth__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SetWidth__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SetWidth'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SetWidth(int)\n" - " mfem::SparseMatrix::SetWidth()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ActualWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - int result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ActualWidth" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (int)((mfem::SparseMatrix const *)arg1)->ActualWidth(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_int(static_cast< int >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_SortColumnIndices(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SortColumnIndices" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + if (!args) SWIG_fail; + swig_obj[0] = args; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SortColumnIndices" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -8145,7 +7330,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix___call__(PyObject *self, PyObject *args) } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8153,15 +7338,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetDiag(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetDiag", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetDiag", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetDiag" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetDiag" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -8365,7 +7554,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetMemoryClass(PyObject *SWIGUNUSEDPARM( } -SWIGINTERN PyObject *_wrap_SparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8376,15 +7565,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyO int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Mult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -8392,7 +7586,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyO SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8426,12 +7620,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Mult(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; - double arg4 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -8440,14 +7634,21 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM int res3 = 0 ; double val4 ; int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:SparseMatrix_AddMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -8455,7 +7656,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -8463,11 +7664,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMult" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { ((mfem::SparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3,arg4); @@ -8494,7 +7697,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -8505,32 +7708,38 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_MultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMult" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::SparseMatrix const *)arg1)->AddMult((mfem::Vector const &)*arg2,*arg3); + ((mfem::SparseMatrix const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8554,104 +7763,60 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult__SWIG_1(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_AddMult", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_AddMult__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_AddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_AddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::SparseMatrix::AddMult(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; mfem::Vector *arg3 = 0 ; + double arg4 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_MultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:SparseMatrix_AddMultTranspose", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_MultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_MultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { - ((mfem::SparseMatrix const *)arg1)->MultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::SparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8675,51 +7840,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_MultTranspose(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_BuildTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BuildTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - ((mfem::SparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3,arg4); + ((mfem::SparseMatrix const *)arg1)->BuildTranspose(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8743,43 +7880,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose__SWIG_0(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ResetTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ResetTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddMultTranspose" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - ((mfem::SparseMatrix const *)arg1)->AddMultTranspose((mfem::Vector const &)*arg2,*arg3); + ((mfem::SparseMatrix const *)arg1)->ResetTranspose(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8803,169 +7920,35 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose__SWIG_1(PyObject *SWIGU } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddMultTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 +SWIGINTERN PyObject *_wrap_SparseMatrix_PartMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"x", (char *)"y", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_AddMultTranspose", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_AddMultTranspose__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_AddMultTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_AddMultTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::SparseMatrix::AddMultTranspose(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_BuildTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BuildTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->BuildTranspose(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_ResetTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ResetTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->ResetTranspose(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PartMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_PartMult", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_PartMult", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -8973,7 +7956,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartMult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -8981,7 +7964,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartMult(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9015,13 +7998,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartMult(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Vector *arg3 = 0 ; mfem::Vector *arg4 = 0 ; - double arg5 ; + double arg5 = (double) (double)1.0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9032,14 +8015,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_0(PyObject *SWIGUNUSED int res4 = 0 ; double val5 ; int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"x", (char *)"y", (char *)"a", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_PartAddMult", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartAddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -9047,7 +8038,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9055,7 +8046,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); } arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -9063,11 +8054,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_0(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_PartAddMult" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_PartAddMult" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); + } { try { ((mfem::SparseMatrix const *)arg1)->PartAddMult((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); @@ -9094,54 +8087,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_0(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; + mfem::Array< int > *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_BooleanMult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PartAddMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_PartAddMult" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::SparseMatrix const *)arg1)->PartAddMult((mfem::Array< int > const &)*arg2,(mfem::Vector const &)*arg3,*arg4); + ((mfem::SparseMatrix const *)arg1)->BooleanMult((mfem::Array< int > const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9165,75 +8153,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult__SWIG_1(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SparseMatrix_PartAddMult(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_PartAddMult", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PartAddMult__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_PartAddMult__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PartAddMult'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::PartAddMult(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &,double const) const\n" - " mfem::SparseMatrix::PartAddMult(mfem::Array< int > const &,mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -9244,33 +8164,38 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(sel int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_BooleanMult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_BooleanMultTranspose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMult" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMult" "', argument " "3"" of type '" "mfem::Array< int > &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); { try { - ((mfem::SparseMatrix const *)arg1)->BooleanMult((mfem::Array< int > const &)*arg2,*arg3); + ((mfem::SparseMatrix const *)arg1)->BooleanMultTranspose((mfem::Array< int > const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9294,96 +8219,40 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMult(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SparseMatrix_BooleanMultTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; + double result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_BooleanMultTranspose", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_InnerProduct", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_InnerProduct" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_BooleanMultTranspose" "', argument " "3"" of type '" "mfem::Array< int > &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->BooleanMultTranspose((mfem::Array< int > const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_InnerProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_InnerProduct", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_InnerProduct" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_InnerProduct" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_InnerProduct" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -9417,7 +8286,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_InnerProduct(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -9425,15 +8294,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowSums", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetRowSums", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowSums" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetRowSums" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -9467,26 +8340,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowSums(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowNorml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRowNorml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"irow", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRowNorml1", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetRowNorml1", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRowNorml1" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -9623,13 +8500,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_1(PyObject *SWIGUNUSE PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ZERO ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -9641,59 +8518,16 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_1(PyObject *SWIGUNUSE }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRow" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateRow(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRow" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } { try { - (arg1)->EliminateRow(arg2); + (arg1)->EliminateRow(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9725,7 +8559,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow(PyObject *self, PyObject *a if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRow", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -9740,25 +8574,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow(PyObject *self, PyObject *a } } if (_v) { - return _wrap_SparseMatrix_EliminateRow__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 2) { + return _wrap_SparseMatrix_EliminateRow__SWIG_1(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_int(argv[2], NULL); _v = SWIG_CheckState(res); @@ -9804,87 +8622,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRow(PyObject *self, PyObject *a SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRow'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::EliminateRow(int,double const,mfem::Vector &)\n" - " mfem::SparseMatrix::EliminateRow(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRow(int)\n"); + " mfem::SparseMatrix::EliminateRow(int,mfem::Matrix::DiagonalPolicy)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ZERO ; void *argp1 = 0 ; int res1 = 0 ; int val3 ; int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"col", (char *)"dpolicy", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:SparseMatrix_EliminateCol", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); - { - try { - (arg1)->EliminateCol(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj2) { + ecode3 = SWIG_AsVal_int(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } { try { - (arg1)->EliminateCol(arg2); + (arg1)->EliminateCol(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9908,74 +8688,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCol(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateCol", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_EliminateCol__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateCol__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateCol'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateCol(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateCol(int)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; - mfem::Vector *arg4 = (mfem::Vector *) 0 ; + mfem::Vector *arg3 = (mfem::Vector *) NULL ; + mfem::Vector *arg4 = (mfem::Vector *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -9985,7 +8703,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_0(PyObject *SWIGUNUS void *argp4 = 0 ; int res4 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -9999,16 +8717,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_0(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::Vector const *""'"); + if (swig_obj[2]) { + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::Vector const *""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateCols" "', argument " "4"" of type '" "mfem::Vector *""'"); + if (swig_obj[3]) { + res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateCols" "', argument " "4"" of type '" "mfem::Vector *""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,(mfem::Vector const *)arg3,arg4); @@ -10039,7 +8761,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_1(PyObject *SWIGUNUS PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; - mfem::Vector *arg3 = (mfem::Vector *) 0 ; + mfem::SparseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -10061,123 +8783,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_1(PyObject *SWIGUNUS SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { - (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,(mfem::Vector const *)arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - { - try { - (arg1)->EliminateCols((mfem::Array< int > const &)*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::SparseMatrix *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateCols" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateCols" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); - { - try { - (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,*arg3); + (arg1)->EliminateCols((mfem::Array< int > const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10209,20 +8825,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateCols", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_2(self, argc, argv); - } - } - } - if (argc == 3) { + if ((argc >= 2) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -10231,11 +8834,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); + } void *vptr = 0; int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_1(self, argc, argv); + if (argc <= 3) { + return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); + } + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, 0); + _v = SWIG_CheckState(res); + if (_v) { + return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); + } } } } @@ -10253,30 +8867,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_3(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateCols__SWIG_0(self, argc, argv); - } + return _wrap_SparseMatrix_EliminateCols__SWIG_1(self, argc, argv); } } } @@ -10286,8 +8877,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateCols(PyObject *self, PyObject * SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateCols'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *,mfem::Vector *)\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::Vector const *)\n" - " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &)\n" " mfem::SparseMatrix::EliminateCols(mfem::Array< int > const &,mfem::SparseMatrix &)\n"); return 0; } @@ -10299,7 +8888,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUN int arg2 ; double arg3 ; mfem::Vector *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; @@ -10309,7 +8898,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUN int val5 ; int ecode5 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 5)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -10334,11 +8923,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUN SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); } arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + if (swig_obj[4]) { + ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + } { try { (arg1)->EliminateRowCol(arg2,arg3,*arg4,arg5); @@ -10365,47 +8956,68 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_0(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - double arg3 ; - mfem::Vector *arg4 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; + mfem::Matrix::DiagonalPolicy arg5 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + int val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rc", (char *)"sol", (char *)"rhs", (char *)"dpolicy", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_EliminateRowColMultipleRHS", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Vector &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_int(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); { try { - (arg1)->EliminateRowCol(arg2,arg3,*arg4); + (arg1)->EliminateRowColMultipleRHS(arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10429,58 +9041,42 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - mfem::Matrix::DiagonalPolicy arg5 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - int val5 ; - int ecode5 = 0 ; + double val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rc", (char *)"value", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_EliminateRowColDiag", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + arg2 = PyArray_PyIntAsInt(obj1); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - ecode5 = SWIG_AsVal_int(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "5"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + ecode3 = SWIG_AsVal_double(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "3"" of type '" "double""'"); } - arg5 = static_cast< mfem::Matrix::DiagonalPolicy >(val5); + arg3 = static_cast< double >(val3); { try { - (arg1)->EliminateRowColMultipleRHS(arg2,(mfem::Vector const &)*arg3,*arg4,arg5); + (arg1)->EliminateRowColDiag(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10504,23 +9100,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_0(PyObj } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - mfem::Vector *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + mfem::Matrix::DiagonalPolicy arg3 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + int val3 ; + int ecode3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -10529,25 +9122,82 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_1(PyObj }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowColMultipleRHS" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + { + try { + (arg1)->EliminateRowCol(arg2,arg3); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; +fail: + return NULL; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; + mfem::SparseMatrix *arg3 = 0 ; + mfem::Matrix::DiagonalPolicy arg4 = (mfem::Matrix::DiagonalPolicy) mfem::Matrix::DIAG_ONE ; + void *argp1 = 0 ; + int res1 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + int val4 ; + int ecode4 = 0 ; + + if ((nobjs < 3) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + } + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); + if (swig_obj[3]) { + ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Matrix::DiagonalPolicy""'"); + } + arg4 = static_cast< mfem::Matrix::DiagonalPolicy >(val4); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->EliminateRowColMultipleRHS(arg2,(mfem::Vector const &)*arg3,*arg4); + (arg1)->EliminateRowCol(arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10571,15 +9221,43 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_1(PyObj } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[6] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowColMultipleRHS", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowCol", 0, 5, argv))) SWIG_fail; --argc; - if (argc == 4) { + if ((argc >= 2) && (argc <= 3)) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_1(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_1(self, argc, argv); + } + } + } + } + if ((argc >= 3) && (argc <= 4)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -10594,20 +9272,25 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS(PyObject *sel } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); + if (argc <= 3) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_2(self, argc, argv); + } + { + int res = SWIG_AsVal_int(argv[3], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - return _wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_1(self, argc, argv); + return _wrap_SparseMatrix_EliminateRowCol__SWIG_2(self, argc, argv); } } } } } - if (argc == 5) { + if ((argc >= 4) && (argc <= 5)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -10622,19 +9305,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS(PyObject *sel } } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } if (_v) { void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL); + int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 4) { + return _wrap_SparseMatrix_EliminateRowCol__SWIG_0(self, argc, argv); + } { int res = SWIG_AsVal_int(argv[4], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SparseMatrix_EliminateRowColMultipleRHS__SWIG_0(self, argc, argv); + return _wrap_SparseMatrix_EliminateRowCol__SWIG_0(self, argc, argv); } } } @@ -10643,45 +9331,32 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColMultipleRHS(PyObject *sel } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRowColMultipleRHS'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRowCol'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateRowColMultipleRHS(int,mfem::Vector const &,mfem::DenseMatrix &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowColMultipleRHS(int,mfem::Vector const &,mfem::DenseMatrix &)\n"); + " mfem::SparseMatrix::EliminateRowCol(int,double const,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" + " mfem::SparseMatrix::EliminateRowCol(int,mfem::Matrix::DiagonalPolicy)\n" + " mfem::SparseMatrix::EliminateRowCol(int,mfem::SparseMatrix &,mfem::Matrix::DiagonalPolicy)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColDiag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetDiagIdentity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowColDiag", 3, 3, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetDiagIdentity" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowColDiag" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { - (arg1)->EliminateRowColDiag(arg2,arg3); + (arg1)->SetDiagIdentity(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10705,36 +9380,36 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowColDiag(PyObject *SWIGUNUSED } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - mfem::Matrix::DiagonalPolicy arg3 ; + double arg2 = (double) (double)1e-12 ; void *argp1 = 0 ; int res1 = 0 ; - int val3 ; - int ecode3 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"threshold", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SparseMatrix_EliminateZeroRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (obj1) { + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - ecode3 = SWIG_AsVal_int(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg3 = static_cast< mfem::Matrix::DiagonalPolicy >(val3); { try { - (arg1)->EliminateRowCol(arg2,arg3); + (arg1)->EliminateZeroRows(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10758,28 +9433,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_2(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_forw(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_Gauss_Seidel_forw", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->EliminateRowCol(arg2); + ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_forw((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10803,47 +9499,49 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_3(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - mfem::SparseMatrix *arg3 = 0 ; - mfem::Matrix::DiagonalPolicy arg4 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - int val4 ; - int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_Gauss_Seidel_back", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); - ecode4 = SWIG_AsVal_int(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "4"" of type '" "mfem::Matrix::DiagonalPolicy""'"); - } - arg4 = static_cast< mfem::Matrix::DiagonalPolicy >(val4); + arg3 = reinterpret_cast< mfem::Vector * >(argp3); { try { - (arg1)->EliminateRowCol(arg2,*arg3,arg4); + ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_back((mfem::Vector const &)*arg2,*arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10867,39 +9565,24 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_4(PyObject *SWIGUN } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetJacobiScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - mfem::SparseMatrix *arg3 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; + PyObject *swig_obj[1] ; + double result; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetJacobiScaling" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__SparseMatrix, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_EliminateRowCol" "', argument " "3"" of type '" "mfem::SparseMatrix &""'"); - } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); { try { - (arg1)->EliminateRowCol(arg2,*arg3); + result = (double)((mfem::SparseMatrix const *)arg1)->GetJacobiScaling(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -10916,1015 +9599,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol__SWIG_5(PyObject *SWIGUN SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateRowCol(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateRowCol", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_3(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_5(self, argc, argv); - } - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_int(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_2(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_4(self, argc, argv); - } - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_int(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateRowCol__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateRowCol'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateRowCol(int,double const,mfem::Vector &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowCol(int,double const,mfem::Vector &)\n" - " mfem::SparseMatrix::EliminateRowCol(int,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowCol(int)\n" - " mfem::SparseMatrix::EliminateRowCol(int,mfem::SparseMatrix &,mfem::Matrix::DiagonalPolicy)\n" - " mfem::SparseMatrix::EliminateRowCol(int,mfem::SparseMatrix &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_SetDiagIdentity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetDiagIdentity" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - (arg1)->SetDiagIdentity(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - (arg1)->EliminateZeroRows(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_EliminateZeroRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - (arg1)->EliminateZeroRows(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_EliminateZeroRows(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_EliminateZeroRows", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_EliminateZeroRows__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_EliminateZeroRows__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_EliminateZeroRows'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::EliminateZeroRows(double const)\n" - " mfem::SparseMatrix::EliminateZeroRows()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_forw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Gauss_Seidel_forw", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_forw" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_forw((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Gauss_Seidel_back(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - PyObject *swig_obj[3] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Gauss_Seidel_back", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Gauss_Seidel_back" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->Gauss_Seidel_back((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_GetJacobiScaling(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetJacobiScaling" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - result = (double)((mfem::SparseMatrix const *)arg1)->GetJacobiScaling(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - double arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - PyObject *swig_obj[5] ; - - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Jacobi", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - ((mfem::SparseMatrix const *)arg1)->Jacobi((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - double arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - double val4 ; - int ecode4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_DiagScale" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_DiagScale" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); - { - try { - ((mfem::SparseMatrix const *)arg1)->DiagScale((mfem::Vector const &)*arg2,*arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_DiagScale" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - { - try { - ((mfem::SparseMatrix const *)arg1)->DiagScale((mfem::Vector const &)*arg2,*arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_DiagScale", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_DiagScale__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_DiagScale__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_DiagScale'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::DiagScale(mfem::Vector const &,mfem::Vector &,double) const\n" - " mfem::SparseMatrix::DiagScale(mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - double arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - double val5 ; - int ecode5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi2" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi2" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - ((mfem::SparseMatrix const *)arg1)->Jacobi2((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi2" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::SparseMatrix const *)arg1)->Jacobi2((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Jacobi2", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Jacobi2__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_Jacobi2__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Jacobi2'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Jacobi2(mfem::Vector const &,mfem::Vector const &,mfem::Vector &,double) const\n" - " mfem::SparseMatrix::Jacobi2(mfem::Vector const &,mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -11941,229 +9623,53 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_0(PyObject *SWIGUNUSEDPARM int res4 = 0 ; double val5 ; int ecode5 = 0 ; - - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi3" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - ecode5 = SWIG_AsVal_double(swig_obj[4], &val5); - if (!SWIG_IsOK(ecode5)) { - SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi3" "', argument " "5"" of type '" "double""'"); - } - arg5 = static_cast< double >(val5); - { - try { - ((mfem::SparseMatrix const *)arg1)->Jacobi3((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Vector *arg2 = 0 ; - mfem::Vector *arg3 = 0 ; - mfem::Vector *arg4 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi3" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); - } - arg3 = reinterpret_cast< mfem::Vector * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); - } - arg4 = reinterpret_cast< mfem::Vector * >(argp4); - { - try { - ((mfem::SparseMatrix const *)arg1)->Jacobi3((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x0", (char *)"x1", (char *)"sc", NULL }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Jacobi3", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Jacobi3__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_double(argv[4], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_Jacobi3__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Jacobi3'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Jacobi3(mfem::Vector const &,mfem::Vector const &,mfem::Vector &,double) const\n" - " mfem::SparseMatrix::Jacobi3(mfem::Vector const &,mfem::Vector const &,mfem::Vector &) const\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:SparseMatrix_Jacobi", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalize" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi" "', argument " "4"" of type '" "mfem::Vector &""'"); } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); { try { - (arg1)->Finalize(arg2); + ((mfem::SparseMatrix const *)arg1)->Jacobi((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12187,21 +9693,60 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_DiagScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + double arg4 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x", (char *)"sc", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:SparseMatrix_DiagScale", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalize" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_DiagScale" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_DiagScale" "', argument " "3"" of type '" "mfem::Vector &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + if (obj3) { + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_DiagScale" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + } { try { - (arg1)->Finalize(); + ((mfem::SparseMatrix const *)arg1)->DiagScale((mfem::Vector const &)*arg2,*arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12225,149 +9770,72 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi2(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - bool arg3 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + double arg5 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; - bool val3 ; - int ecode3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x0", (char *)"x1", (char *)"sc", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_Jacobi2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalize" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi2" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_Finalize" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); - { - try { - (arg1)->Finalize(arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "2"" of type '" "mfem::Vector const &""'"); } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Finalize", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Finalize__SWIG_1(self, argc, argv); - } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_Finalize__SWIG_0(self, argc, argv); - } - } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "3"" of type '" "mfem::Vector const &""'"); } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_bool(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix_Finalize__SWIG_2(self, argc, argv); - } - } - } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Finalize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Finalize(int)\n" - " mfem::SparseMatrix::Finalize()\n" - " mfem::SparseMatrix::Finalize(int,bool)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Finalized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalized" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi2" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi2" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (bool)((mfem::SparseMatrix const *)arg1)->Finalized(); + ((mfem::SparseMatrix const *)arg1)->Jacobi2((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12384,31 +9852,79 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Finalized(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_ColumnsAreSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Jacobi3(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Vector *arg2 = 0 ; + mfem::Vector *arg3 = 0 ; + mfem::Vector *arg4 = 0 ; + double arg5 = (double) 1.0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; - bool result; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + double val5 ; + int ecode5 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"b", (char *)"x0", (char *)"x1", (char *)"sc", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_Jacobi3", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ColumnsAreSorted" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Jacobi3" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "2"" of type '" "mfem::Vector const &""'"); + } + arg2 = reinterpret_cast< mfem::Vector * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "3"" of type '" "mfem::Vector const &""'"); + } + arg3 = reinterpret_cast< mfem::Vector * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_Jacobi3" "', argument " "4"" of type '" "mfem::Vector &""'"); + } + arg4 = reinterpret_cast< mfem::Vector * >(argp4); + if (obj4) { + ecode5 = SWIG_AsVal_double(obj4, &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "SparseMatrix_Jacobi3" "', argument " "5"" of type '" "double""'"); + } + arg5 = static_cast< double >(val5); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (bool)((mfem::SparseMatrix const *)arg1)->ColumnsAreSorted(); + ((mfem::SparseMatrix const *)arg1)->Jacobi3((mfem::Vector const &)*arg2,(mfem::Vector const &)*arg3,*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12425,44 +9941,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ColumnsAreSorted(PyObject *SWIGUNUSEDPAR SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_bool(static_cast< bool >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - double arg2 ; - bool arg3 ; + int arg2 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - bool val3 ; - int ecode3 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Threshold" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalize" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_Threshold" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_Threshold" "', argument " "3"" of type '" "bool""'"); - } - arg3 = static_cast< bool >(val3); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + } { try { - (arg1)->Threshold(arg2,arg3); + (arg1)->Finalize(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12486,29 +9995,36 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold__SWIG_0(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - double arg2 ; + int arg2 ; + bool arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Threshold" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalize" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_Threshold" "', argument " "2"" of type '" "double""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } + ecode3 = SWIG_AsVal_bool(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_Finalize" "', argument " "3"" of type '" "bool""'"); } - arg2 = static_cast< double >(val2); + arg3 = static_cast< bool >(val3); { try { - (arg1)->Threshold(arg2); + (arg1)->Finalize(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12532,26 +10048,33 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Finalize(PyObject *self, PyObject *args) { Py_ssize_t argc; PyObject *argv[4] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Threshold", 0, 3, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Finalize", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_SparseMatrix_Finalize__SWIG_0(self, argc, argv); + } { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { - return _wrap_SparseMatrix_Threshold__SWIG_1(self, argc, argv); + return _wrap_SparseMatrix_Finalize__SWIG_0(self, argc, argv); } } } @@ -12562,8 +10085,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold(PyObject *self, PyObject *args _v = SWIG_CheckState(res); if (_v) { { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } } if (_v) { { @@ -12571,48 +10098,39 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold(PyObject *self, PyObject *args _v = SWIG_CheckState(res); } if (_v) { - return _wrap_SparseMatrix_Threshold__SWIG_0(self, argc, argv); + return _wrap_SparseMatrix_Finalize__SWIG_1(self, argc, argv); } } } } fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Threshold'.\n" + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Finalize'.\n" " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::Threshold(double,bool)\n" - " mfem::SparseMatrix::Threshold(double)\n"); + " mfem::SparseMatrix::Finalize(int)\n" + " mfem::SparseMatrix::Finalize(int,bool)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Finalized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject *swig_obj[1] ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetBlocks", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetBlocks" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Finalized" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); - } - arg2 = reinterpret_cast< mfem::Array2D< mfem::SparseMatrix * > * >(argp2); { try { - ((mfem::SparseMatrix const *)arg1)->GetBlocks(*arg2); + result = (bool)((mfem::SparseMatrix const *)arg1)->Finalized(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12629,62 +10147,31 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self) SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ColumnsAreSorted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject *swig_obj[1] ; + bool result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetSubMatrix", 4, 4, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ColumnsAreSorted" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); - } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - ((mfem::SparseMatrix const *)arg1)->GetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); + result = (bool)((mfem::SparseMatrix const *)arg1)->ColumnsAreSorted(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12701,36 +10188,52 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(se SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_bool(static_cast< bool >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetColPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Threshold(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; + double arg2 ; + bool arg3 = (bool) false ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + double val2 ; + int ecode2 = 0 ; + bool val3 ; + int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", (char *)"fix_empty_rows", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetColPtr", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:SparseMatrix_Threshold", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetColPtr" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Threshold" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_Threshold" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + if (obj2) { + ecode3 = SWIG_AsVal_bool(obj2, &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_Threshold" "', argument " "3"" of type '" "bool""'"); + } + arg3 = static_cast< bool >(val3); } { try { - ((mfem::SparseMatrix const *)arg1)->SetColPtr(arg2); + (arg1)->Threshold(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12754,69 +10257,37 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetColPtr(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SparseMatrix_ClearColPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetBlocks(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + mfem::Array2D< mfem::SparseMatrix * > *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[1] ; + void *argp2 = 0 ; + int res2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"blocks", NULL + }; - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_GetBlocks", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ClearColPtr" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetBlocks" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->ClearColPtr(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SearchRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Array2DT_mfem__SparseMatrix_p_t, 0 ); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetBlocks" "', argument " "2"" of type '" "mfem::Array2D< mfem::SparseMatrix * > &""'"); } + arg2 = reinterpret_cast< mfem::Array2D< mfem::SparseMatrix * > * >(argp2); { try { - result = (double *) &(arg1)->SearchRow(arg2); + ((mfem::SparseMatrix const *)arg1)->GetBlocks(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12833,43 +10304,68 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_0(PyObject *SWIGUNUSEDPA SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; - double arg3 ; + mfem::Array< int > *arg2 = 0 ; + mfem::Array< int > *arg3 = 0 ; + mfem::DenseMatrix *arg4 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; + void *argp2 = 0 ; + int res2 = 0 ; + void *argp3 = 0 ; + int res3 = 0 ; + void *argp4 = 0 ; + int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_GetSubMatrix", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Add_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix__Add_" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); + if (!argp2) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + } + arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + if (!argp3) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + } + arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 ); + if (!SWIG_IsOK(res4)) { + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_GetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + if (!argp4) { + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix &""'"); + } + arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { try { - (arg1)->_Add_(arg2,arg3); + ((mfem::SparseMatrix const *)arg1)->GetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,*arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12893,36 +10389,33 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetColPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", NULL + }; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_SetColPtr", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Set_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetColPtr" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix__Set_" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); { try { - (arg1)->_Set_(arg2,arg3); + ((mfem::SparseMatrix const *)arg1)->SetColPtr(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12946,30 +10439,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_0(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix__Get_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ClearColPtr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; - double result; + PyObject *swig_obj[1] ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix__Get_", 2, 2, swig_obj)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Get_" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ClearColPtr" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - result = (double)((mfem::SparseMatrix const *)arg1)->_Get_(arg2); + ((mfem::SparseMatrix const *)arg1)->ClearColPtr(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -12986,23 +10472,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Get_(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_From_double(static_cast< double >(result)); + resultobj = SWIG_Py_Void(); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - int arg3 ; void *argp1 = 0 ; int res1 = 0 ; double *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SearchRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -13014,15 +10499,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_1(PyObject *SWIGUNUSEDPA }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } { try { - result = (double *) &(arg1)->SearchRow(arg2,arg3); + result = (double *) &(arg1)->SearchRow(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13046,84 +10525,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_1(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SearchRow", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SearchRow__SWIG_0(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SearchRow__SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SearchRow'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SearchRow(int const)\n" - " mfem::SparseMatrix::SearchRow(int const,int const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - int arg3 ; - double arg4 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; + double val3 ; + int ecode3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Add_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -13135,20 +10547,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(s }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Add_" "', argument " "4"" of type '" "double""'"); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix__Add_" "', argument " "3"" of type '" "double""'"); } - arg4 = static_cast< double >(val4); + arg3 = static_cast< double >(val3); { try { - (arg1)->_Add_(arg2,arg3,arg4); + (arg1)->_Add_(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13166,102 +10572,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(s } } resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix__Add_(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Add_", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix__Add___SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix__Add___SWIG_1(self, argc, argv); - } - } - } - } - } - + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Add_'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::_Add_(int const,double const)\n" - " mfem::SparseMatrix::_Add_(int const,int const,double const)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - int arg3 ; - double arg4 ; + double arg3 ; void *argp1 = 0 ; int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; + double val3 ; + int ecode3 = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Set_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -13273,20 +10600,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(s }; arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Set_" "', argument " "4"" of type '" "double""'"); + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix__Set_" "', argument " "3"" of type '" "double""'"); } - arg4 = static_cast< double >(val4); + arg3 = static_cast< double >(val3); { try { - (arg1)->_Set_(arg2,arg3,arg4); + (arg1)->_Set_(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13310,122 +10631,34 @@ SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix__Set_(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Set_", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix__Set___SWIG_0(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[3], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_SparseMatrix__Set___SWIG_1(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Set_'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::_Set_(int const,double const)\n" - " mfem::SparseMatrix::_Set_(int const,int const,double const)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Get_(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; - int arg3 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"col", NULL + }; + double result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Set", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix__Get_", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Set" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Get_" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Set" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - (arg1)->Set(arg2,arg3,arg4); + result = (double)((mfem::SparseMatrix const *)arg1)->_Get_(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13442,28 +10675,26 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Set(PyObject *SWIGUNUSEDPARM(self), PyOb SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; int arg3 ; - double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - double val4 ; - int ecode4 = 0 ; + double *result = 0 ; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Add" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SearchRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { @@ -13478,14 +10709,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(sel }; arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); - if (!SWIG_IsOK(ecode4)) { - SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Add" "', argument " "4"" of type '" "double""'"); - } - arg4 = static_cast< double >(val4); { try { - (arg1)->Add(arg2,arg3,arg4); + result = (double *) &(arg1)->SearchRow(arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13502,68 +10728,116 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; +SWIGINTERN PyObject *_wrap_SparseMatrix_SearchRow(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SearchRow", 0, 3, argv))) SWIG_fail; + --argc; + if (argc == 2) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_SearchRow__SWIG_0(self, argc, argv); + } + } } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_SearchRow__SWIG_1(self, argc, argv); + } + } + } } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SearchRow'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::SearchRow(int const)\n" + " mfem::SparseMatrix::SearchRow(int const,int const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix__Add___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; + int arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val4 ; + int ecode4 = 0 ; + + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; + res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Add_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Add_" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); { try { - (arg1)->SetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); + (arg1)->_Add_(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13587,54 +10861,121 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Add_(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[5] = { + 0 + }; + + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Add_", 0, 4, argv))) SWIG_fail; + --argc; + if (argc == 3) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[2], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix__Add___SWIG_0(self, argc, argv); + } + } + } + } + if (argc == 4) { + int _v; + void *vptr = 0; + int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); + _v = SWIG_CheckState(res); + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } + if (_v) { + return _wrap_SparseMatrix__Add___SWIG_1(self, argc, argv); + } + } + } + } + } + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Add_'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::_Add_(int const,double const)\n" + " mfem::SparseMatrix::_Add_(int const,int const,double const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix__Set___SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; + int arg2 ; + int arg3 ; + double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val4 ; + int ecode4 = 0 ; if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix__Set_" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix__Set_" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); { try { - (arg1)->SetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4); + (arg1)->_Set_(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13658,131 +10999,188 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix(PyObject *self, PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix__Set_(PyObject *self, PyObject *args) { Py_ssize_t argc; - PyObject *argv[6] = { + PyObject *argv[5] = { 0 }; - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SetSubMatrix", 0, 5, argv))) SWIG_fail; + if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix__Set_", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 4) { + if (argc == 3) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); + { + int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_SetSubMatrix__SWIG_1(self, argc, argv); - } + } + if (_v) { + return _wrap_SparseMatrix__Set___SWIG_0(self, argc, argv); } } } } - if (argc == 5) { + if (argc == 4) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); + { + int res = SWIG_AsVal_double(argv[3], NULL); + _v = SWIG_CheckState(res); + } if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SetSubMatrix__SWIG_0(self, argc, argv); - } + return _wrap_SparseMatrix__Set___SWIG_1(self, argc, argv); } } } } } - + +fail: + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix__Set_'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::_Set_(int const,double const)\n" + " mfem::SparseMatrix::_Set_(int const,int const,double const)\n"); + return 0; +} + + +SWIGINTERN PyObject *_wrap_SparseMatrix_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + int arg2 ; + int arg3 ; + double arg4 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val4 ; + int ecode4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", (char *)"a", NULL + }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Set" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + } + arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(obj2); + } + ecode4 = SWIG_AsVal_double(obj3, &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Set" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); + { + try { + (arg1)->Set(arg2,arg3,arg4); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); + } +#endif + + catch (Swig::DirectorException &e){ + SWIG_fail; + } + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } + } + resultobj = SWIG_Py_Void(); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SetSubMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SetSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &,int)\n" - " mfem::SparseMatrix::SetSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &)\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Add__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - mfem::Array< int > *arg2 = 0 ; - mfem::Array< int > *arg3 = 0 ; - mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; + int arg2 ; + int arg3 ; + double arg4 ; void *argp1 = 0 ; int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - void *argp4 = 0 ; - int res4 = 0 ; + double val4 ; + int ecode4 = 0 ; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; + if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Add" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); - } - arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); - } - arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); - if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); - } - if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } - arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } + ecode4 = SWIG_AsVal_double(swig_obj[3], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "SparseMatrix_Add" "', argument " "4"" of type '" "double""'"); + } + arg4 = static_cast< double >(val4); { try { - (arg1)->SetSubMatrixTranspose((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); + (arg1)->Add(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13806,12 +11204,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_0(PyObject * } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13820,40 +11219,56 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(PyObject * int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", (char *)"skip_zeros", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_SetSubMatrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } + } { try { - (arg1)->SetSubMatrixTranspose((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4); + (arg1)->SetSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -13877,83 +11292,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(PyObject * } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_SetSubMatrixTranspose", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_SetSubMatrixTranspose__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_SetSubMatrixTranspose'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::SetSubMatrixTranspose(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &,int)\n" - " mfem::SparseMatrix::SetSubMatrixTranspose(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetSubMatrixTranspose(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; - int arg5 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -13962,46 +11307,56 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_0(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", (char *)"skip_zeros", NULL + }; - if ((nobjs < 5) || (nobjs > 5)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_SetSubMatrixTranspose", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } if (!argp3) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res4)) { - SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } if (!argp4) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); + SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetSubMatrixTranspose" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); - { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } } { try { - (arg1)->AddSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); + (arg1)->SetSubMatrixTranspose((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14025,12 +11380,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_0(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Array< int > *arg2 = 0 ; mfem::Array< int > *arg3 = 0 ; mfem::DenseMatrix *arg4 = 0 ; + int arg5 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; @@ -14039,14 +11395,22 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"cols", (char *)"subm", (char *)"skip_zeros", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:SparseMatrix_AddSubMatrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -14054,7 +11418,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -14062,7 +11426,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__DenseMatrix, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } @@ -14070,9 +11434,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddSubMatrix" "', argument " "4"" of type '" "mfem::DenseMatrix const &""'"); } arg4 = reinterpret_cast< mfem::DenseMatrix * >(argp4); + if (obj4) { + { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg5 = PyArray_PyIntAsInt(obj4); + } + } { try { - (arg1)->AddSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4); + (arg1)->AddSubMatrix((mfem::Array< int > const &)*arg2,(mfem::Array< int > const &)*arg3,(mfem::DenseMatrix const &)*arg4,arg5); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -14096,96 +11468,30 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix__SWIG_1(PyObject *SWIGUNUSE } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddSubMatrix(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[6] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_AddSubMatrix", 0, 5, argv))) SWIG_fail; - --argc; - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_AddSubMatrix__SWIG_1(self, argc, argv); - } - } - } - } - } - if (argc == 5) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_mfem__ArrayT_int_t, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_mfem__DenseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[4]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_AddSubMatrix__SWIG_0(self, argc, argv); - } - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_AddSubMatrix'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::AddSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &,int)\n" - " mfem::SparseMatrix::AddSubMatrix(mfem::Array< int > const &,mfem::Array< int > const &,mfem::DenseMatrix const &)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_RowIsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_RowIsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_RowIsEmpty", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_RowIsEmpty", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_RowIsEmpty" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -14213,7 +11519,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_RowIsEmpty(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -14225,22 +11531,28 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_GetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_GetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_GetRow" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } @@ -14248,7 +11560,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_GetRow" "', argument " "3"" of type '" "mfem::Array< int > &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 ); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_GetRow" "', argument " "4"" of type '" "mfem::Vector &""'"); } @@ -14282,7 +11594,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetRow(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -14294,21 +11606,27 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_SetRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_SetRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -14316,7 +11634,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_SetRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_SetRow" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -14350,7 +11668,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetRow(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -14362,21 +11680,27 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), P int res3 = 0 ; void *argp4 = 0 ; int res4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"cols", (char *)"srow", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_AddRow", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:SparseMatrix_AddRow", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_AddRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SparseMatrix_AddRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } @@ -14384,7 +11708,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SparseMatrix_AddRow" "', argument " "3"" of type '" "mfem::Array< int > const &""'"); } arg3 = reinterpret_cast< mfem::Array< int > * >(argp3); - res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); + res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res4)) { SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SparseMatrix_AddRow" "', argument " "4"" of type '" "mfem::Vector const &""'"); } @@ -14418,7 +11742,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_AddRow(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; int arg2 ; @@ -14427,21 +11751,26 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"row", (char *)"scale", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_ScaleRow", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SparseMatrix_ScaleRow", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ScaleRow" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SparseMatrix_ScaleRow" "', argument " "3"" of type '" "double""'"); } @@ -14472,7 +11801,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRow(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14480,15 +11809,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sl", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_ScaleRows", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_ScaleRows", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ScaleRows" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_ScaleRows" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14522,7 +11855,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleRows(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::Vector *arg2 = 0 ; @@ -14530,15 +11863,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"sr", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_ScaleColumns", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_ScaleColumns", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_ScaleColumns" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_ScaleColumns" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -14572,7 +11909,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_ScaleColumns(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SparseMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -14580,16 +11917,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix___iadd__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"B", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix___iadd__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix___iadd__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___iadd__" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix___iadd__" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -14752,7 +12093,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Add(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; double arg2 ; @@ -14760,16 +12101,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix___imul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix___imul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix___imul__" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix___imul__" "', argument " "2"" of type '" "double""'"); } @@ -14793,271 +12138,58 @@ SWIGINTERN PyObject *_wrap_SparseMatrix___imul__(PyObject *SWIGUNUSEDPARM(self), SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_OWN | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - ((mfem::SparseMatrix const *)arg1)->Print(*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::SparseMatrix const *)arg1)->Print(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - try { - ((mfem::SparseMatrix const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::SparseMatrix const *)arg1)->PrintMatlab(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } + resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_OWN | 0 ); return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - ((mfem::SparseMatrix const *)arg1)->PrintMatlab(); + ((mfem::SparseMatrix const *)arg1)->Print(*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15075,45 +12207,58 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSED } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { try { - ((mfem::SparseMatrix const *)arg1)->PrintMM(*arg2); + ((mfem::SparseMatrix const *)arg1)->PrintMatlab(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15147,21 +12292,42 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_0(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; + PyMFEM::wFILE *temp2 = 0 ; + std::ofstream out2 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } { try { - ((mfem::SparseMatrix const *)arg1)->PrintMM(); + ((mfem::SparseMatrix const *)arg1)->PrintMM(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -15179,8 +12345,18 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_1(PyObject *SWIGUNUSEDPARM } } resultobj = SWIG_Py_Void(); + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return resultobj; fail: + { + if (temp2->isSTDOUT() != 1) { + out2.close(); + } + } return NULL; } @@ -15546,7 +12722,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_MaxNorm(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SparseMatrix_CountSmallElems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_CountSmallElems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; double arg2 ; @@ -15554,16 +12730,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_CountSmallElems(PyObject *SWIGUNUSEDPARM int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"tol", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_CountSmallElems", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_CountSmallElems", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_CountSmallElems" "', argument " "1"" of type '" "mfem::SparseMatrix const *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_CountSmallElems" "', argument " "2"" of type '" "double""'"); } @@ -15635,7 +12815,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_CheckFinite(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; bool arg2 ; @@ -15643,15 +12823,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"ownij", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetGraphOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_SetGraphOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetGraphOwner" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_SetGraphOwner" "', argument " "2"" of type '" "bool""'"); } @@ -15682,7 +12866,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetGraphOwner(PyObject *SWIGUNUSEDPARM(s } -SWIGINTERN PyObject *_wrap_SparseMatrix_SetDataOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_SetDataOwner(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; bool arg2 ; @@ -15690,15 +12874,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_SetDataOwner(PyObject *SWIGUNUSEDPARM(se int res1 = 0 ; bool val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"owna", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_SetDataOwner", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_SetDataOwner", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_SetDataOwner" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_bool(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SparseMatrix_SetDataOwner" "', argument " "2"" of type '" "bool""'"); } @@ -15851,7 +13039,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_LoseData(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_SparseMatrix_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -15859,15 +13047,19 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Swap(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"other", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrix_Swap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrix_Swap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Swap" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Swap" "', argument " "2"" of type '" "mfem::SparseMatrix &""'"); } @@ -16105,18 +13297,18 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_GetDataArray(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -16127,64 +13319,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_Print" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_SparseMatrix_Print__SWIG_3(arg1,(char const *)arg2); + mfem_SparseMatrix_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16218,34 +13363,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -16256,19 +13382,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_SparseMatrix_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -16278,27 +13394,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_SparseMatrix_Print__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -16308,7 +13420,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_SparseMatrix_Print__SWIG_0(self, argc, argv); + return _wrap_SparseMatrix_Print__SWIG_1(self, argc, argv); } } } @@ -16318,26 +13430,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::Print(std::ostream &,int) const\n" - " mfem::SparseMatrix::Print(std::ostream &) const\n" - " mfem::SparseMatrix::Print() const\n" - " mfem::SparseMatrix::Print(char const *,int)\n" - " mfem::SparseMatrix::Print(char const *)\n"); + " mfem::SparseMatrix::Print(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -16348,64 +13457,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_2(PyObject *SWIGUNUSED SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMatlab" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_SparseMatrix_PrintMatlab__SWIG_2(arg1,(char const *)arg2); + mfem_SparseMatrix_PrintMatlab__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16439,34 +13501,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMatlab__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMatlab__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_SparseMatrix_PrintMatlab__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -16481,7 +13524,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -16490,6 +13533,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_PrintMatlab__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -16499,7 +13545,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar } } if (_v) { - return _wrap_SparseMatrix_PrintMatlab__SWIG_2(self, argc, argv); + return _wrap_SparseMatrix_PrintMatlab__SWIG_1(self, argc, argv); } } } @@ -16509,25 +13555,23 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMatlab(PyObject *self, PyObject *ar SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintMatlab(std::ostream &) const\n" - " mfem::SparseMatrix::PrintMatlab() const\n" - " mfem::SparseMatrix::PrintMatlab(char const *,int)\n" - " mfem::SparseMatrix::PrintMatlab(char const *)\n"); + " mfem::SparseMatrix::PrintMatlab(char const *,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -16538,64 +13582,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_2(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMM" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_PrintMM__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintMM" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintMM" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_SparseMatrix_PrintMM__SWIG_2(arg1,(char const *)arg2); + mfem_SparseMatrix_PrintMM__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16629,34 +13626,15 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) if (!(argc = SWIG_Python_UnpackTuple(args, "SparseMatrix_PrintMM", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMM__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_SparseMatrix_PrintMM__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_SparseMatrix_PrintMM__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -16671,7 +13649,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -16680,6 +13658,9 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_SparseMatrix_PrintMM__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -16689,7 +13670,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) } } if (_v) { - return _wrap_SparseMatrix_PrintMM__SWIG_2(self, argc, argv); + return _wrap_SparseMatrix_PrintMM__SWIG_1(self, argc, argv); } } } @@ -16699,9 +13680,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintMM(PyObject *self, PyObject *args) SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintMM'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintMM(std::ostream &) const\n" - " mfem::SparseMatrix::PrintMM() const\n" - " mfem::SparseMatrix::PrintMM(char const *,int)\n" - " mfem::SparseMatrix::PrintMM(char const *)\n"); + " mfem::SparseMatrix::PrintMM(char const *,int)\n"); return 0; } @@ -16710,14 +13689,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_1(PyObject *SWIGUNUSEDPAR PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -16728,11 +13707,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_1(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -16763,55 +13744,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_1(PyObject *SWIGUNUSEDPAR SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_SparseMatrix_PrintCSR__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -16825,7 +13757,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR__SWIG_3(PyObject *SWIGUNUSEDPAR arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - mfem_SparseMatrix_PrintCSR__SWIG_3(arg1); + mfem_SparseMatrix_PrintCSR__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -16863,10 +13795,10 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR(PyObject *self, PyObject *args) int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_PrintCSR__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -16875,7 +13807,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR(PyObject *self, PyObject *args) int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_SparseMatrix_PrintCSR__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_PrintCSR__SWIG_1(self, argc, argv); + } } } } @@ -16899,108 +13844,29 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR(PyObject *self, PyObject *args) } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_PrintCSR__SWIG_1(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintCSR'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::SparseMatrix::PrintCSR(std::ostream &) const\n" - " mfem::SparseMatrix::PrintCSR(char const *,int)\n" - " mfem::SparseMatrix::PrintCSR(char const *)\n" - " mfem::SparseMatrix::PrintCSR()\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - int arg3 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR2" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR2" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_SparseMatrix_PrintCSR2__SWIG_1(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; + fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; + SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintCSR'.\n" + " Possible C/C++ prototypes are:\n" + " mfem::SparseMatrix::PrintCSR(std::ostream &) const\n" + " mfem::SparseMatrix::PrintCSR(char const *,int)\n" + " mfem::SparseMatrix::PrintCSR()\n"); + return 0; } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintCSR2" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -17011,9 +13877,17 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintCSR2" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { - mfem_SparseMatrix_PrintCSR2__SWIG_1(arg1,(char const *)arg2); + mfem_SparseMatrix_PrintCSR2__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17039,7 +13913,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPA } -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -17053,7 +13927,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2__SWIG_3(PyObject *SWIGUNUSEDPA arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - mfem_SparseMatrix_PrintCSR2__SWIG_3(arg1); + mfem_SparseMatrix_PrintCSR2__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17091,10 +13965,10 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR2__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_PrintCSR2__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -17103,7 +13977,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2(PyObject *self, PyObject *args int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintCSR2__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_SparseMatrix_PrintCSR2__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_PrintCSR2__SWIG_1(self, argc, argv); + } } } } @@ -17127,36 +14014,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintCSR2(PyObject *self, PyObject *args } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_PrintCSR2__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintCSR2'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintCSR2(std::ostream &) const\n" " mfem::SparseMatrix::PrintCSR2(char const *,int)\n" - " mfem::SparseMatrix::PrintCSR2(char const *)\n" " mfem::SparseMatrix::PrintCSR2()\n"); return 0; } @@ -17166,14 +14029,14 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPA PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintInfo" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); @@ -17184,11 +14047,13 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPA SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintInfo" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -17219,55 +14084,6 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_1(PyObject *SWIGUNUSEDPA SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrix_PrintInfo" "', argument " "1"" of type '" "mfem::SparseMatrix *""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseMatrix_PrintInfo" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_SparseMatrix_PrintInfo__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = (mfem::SparseMatrix *) 0 ; void *argp1 = 0 ; @@ -17281,7 +14097,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo__SWIG_3(PyObject *SWIGUNUSEDPA arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - mfem_SparseMatrix_PrintInfo__SWIG_3(arg1); + mfem_SparseMatrix_PrintInfo__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17319,10 +14135,10 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo(PyObject *self, PyObject *args int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintInfo__SWIG_3(self, argc, argv); + return _wrap_SparseMatrix_PrintInfo__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); @@ -17331,7 +14147,20 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo(PyObject *self, PyObject *args int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_SparseMatrix_PrintInfo__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_SparseMatrix_PrintInfo__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SparseMatrix_PrintInfo__SWIG_1(self, argc, argv); + } } } } @@ -17355,36 +14184,12 @@ SWIGINTERN PyObject *_wrap_SparseMatrix_PrintInfo(PyObject *self, PyObject *args } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_SparseMatrix_PrintInfo__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SparseMatrix_PrintInfo'.\n" " Possible C/C++ prototypes are:\n" " mfem::SparseMatrix::PrintInfo(std::ostream &) const\n" " mfem::SparseMatrix::PrintInfo(char const *,int)\n" - " mfem::SparseMatrix::PrintInfo(char const *)\n" " mfem::SparseMatrix::PrintInfo()\n"); return 0; } @@ -17401,16 +14206,20 @@ SWIGINTERN PyObject *SparseMatrix_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; double (*arg2)(double) = (double (*)(double)) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"S", (char *)"f", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseMatrixFunction", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseMatrixFunction", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseMatrixFunction" "', argument " "1"" of type '" "mfem::SparseMatrix &""'"); } @@ -17419,7 +14228,7 @@ SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { - int res = SWIG_ConvertFunctionPtr(swig_obj[1], (void**)(&arg2), SWIGTYPE_p_f_double__double); + int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_double__double); if (!SWIG_IsOK(res)) { SWIG_exception_fail(SWIG_ArgError(res), "in method '" "SparseMatrixFunction" "', argument " "2"" of type '" "double (*)(double)""'"); } @@ -17450,17 +14259,21 @@ SWIGINTERN PyObject *_wrap_SparseMatrixFunction(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"useActualWidth", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TransposeAbstractSparseMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeAbstractSparseMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeAbstractSparseMatrix" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const &""'"); } @@ -17469,10 +14282,10 @@ SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPAR } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -17500,7 +14313,7 @@ SWIGINTERN PyObject *_wrap_TransposeAbstractSparseMatrix(PyObject *SWIGUNUSEDPAR } -SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::SparseMatrix *arg2 = 0 ; @@ -17508,11 +14321,15 @@ SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObjec int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "TransposeMult", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:TransposeMult", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransposeMult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -17520,7 +14337,7 @@ SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "TransposeMult" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "TransposeMult" "', argument " "2"" of type '" "mfem::SparseMatrix const &""'"); } @@ -17554,7 +14371,7 @@ SWIGINTERN PyObject *_wrap_TransposeMult(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::AbstractSparseMatrix *arg1 = 0 ; mfem::AbstractSparseMatrix *arg2 = 0 ; @@ -17562,11 +14379,15 @@ SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(sel int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"B", NULL + }; mfem::SparseMatrix *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "MultAbstractSparseMatrix", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MultAbstractSparseMatrix", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MultAbstractSparseMatrix" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const &""'"); } @@ -17574,7 +14395,7 @@ SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(sel SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MultAbstractSparseMatrix" "', argument " "1"" of type '" "mfem::AbstractSparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::AbstractSparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__AbstractSparseMatrix, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MultAbstractSparseMatrix" "', argument " "2"" of type '" "mfem::AbstractSparseMatrix const &""'"); } @@ -17608,21 +14429,27 @@ SWIGINTERN PyObject *_wrap_MultAbstractSparseMatrix(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Mult_AtDA(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; mfem::Vector *arg2 = 0 ; - mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) 0 ; + mfem::SparseMatrix *arg3 = (mfem::SparseMatrix *) NULL ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"A", (char *)"D", (char *)"OAtDA", NULL + }; mfem::SparseMatrix *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Mult_AtDA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } @@ -17630,7 +14457,7 @@ SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -17638,67 +14465,16 @@ SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult_AtDA" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); - } - arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); - { - try { - result = (mfem::SparseMatrix *)mfem::Mult_AtDA((mfem::SparseMatrix const &)*arg1,(mfem::Vector const &)*arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj2) { + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Mult_AtDA" "', argument " "3"" of type '" "mfem::SparseMatrix *""'"); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__SparseMatrix, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - mfem::Vector *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - mfem::SparseMatrix *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); - } - if (!argp2) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Mult_AtDA" "', argument " "2"" of type '" "mfem::Vector const &""'"); + arg3 = reinterpret_cast< mfem::SparseMatrix * >(argp3); } - arg2 = reinterpret_cast< mfem::Vector * >(argp2); { try { - result = (mfem::SparseMatrix *)mfem::Mult_AtDA((mfem::SparseMatrix const &)*arg1,(mfem::Vector const &)*arg2); + result = (mfem::SparseMatrix *)mfem::Mult_AtDA((mfem::SparseMatrix const &)*arg1,(mfem::Vector const &)*arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -17722,53 +14498,6 @@ SWIGINTERN PyObject *_wrap_Mult_AtDA__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_Mult_AtDA(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Mult_AtDA", 0, 3, argv))) SWIG_fail; - --argc; - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mult_AtDA__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_mfem__Vector, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_mfem__SparseMatrix, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Mult_AtDA__SWIG_0(self, argc, argv); - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Mult_AtDA'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Mult_AtDA(mfem::SparseMatrix const &,mfem::Vector const &,mfem::SparseMatrix *)\n" - " mfem::Mult_AtDA(mfem::SparseMatrix const &,mfem::Vector const &)\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_OuterProduct__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::DenseMatrix *arg1 = 0 ; @@ -18052,10 +14781,10 @@ SWIGINTERN PyObject *_wrap_OuterProduct(PyObject *self, PyObject *args) { static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, - { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, - { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, - { "OperatorHandle2SparseMatrix", _wrap_OperatorHandle2SparseMatrix, METH_O, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, + { "RAP_P", (PyCFunction)(void(*)(void))_wrap_RAP_P, METH_VARARGS|METH_KEYWORDS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, + { "RAP_R", (PyCFunction)(void(*)(void))_wrap_RAP_R, METH_VARARGS|METH_KEYWORDS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, + { "OperatorPtr2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorPtr2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, + { "OperatorHandle2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorHandle2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, { "RowNode_Value_set", _wrap_RowNode_Value_set, METH_VARARGS, "RowNode_Value_set(RowNode self, double Value)"}, { "RowNode_Value_get", _wrap_RowNode_Value_get, METH_O, "RowNode_Value_get(RowNode self) -> double"}, { "RowNode_Prev_set", _wrap_RowNode_Prev_set, METH_VARARGS, "RowNode_Prev_set(RowNode self, RowNode Prev)"}, @@ -18075,7 +14804,7 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix(SparseMatrix mat, bool copy_graph=True)\n" "new_SparseMatrix(Vector v) -> SparseMatrix\n" ""}, - { "SparseMatrix_MakeRef", _wrap_SparseMatrix_MakeRef, METH_VARARGS, "SparseMatrix_MakeRef(SparseMatrix self, SparseMatrix master)"}, + { "SparseMatrix_MakeRef", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MakeRef, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_MakeRef(SparseMatrix self, SparseMatrix master)"}, { "SparseMatrix_Size", _wrap_SparseMatrix_Size, METH_O, "SparseMatrix_Size(SparseMatrix self) -> int"}, { "SparseMatrix_Clear", _wrap_SparseMatrix_Clear, METH_O, "SparseMatrix_Clear(SparseMatrix self)"}, { "SparseMatrix_Empty", _wrap_SparseMatrix_Empty, METH_O, "SparseMatrix_Empty(SparseMatrix self) -> bool"}, @@ -18095,9 +14824,9 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" "SparseMatrix_GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "SparseMatrix_ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "SparseMatrix_WriteI(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "SparseMatrix_ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadI, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadI(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteI, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_WriteI(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteI, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadWriteI(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "SparseMatrix_HostReadI(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "SparseMatrix_HostWriteI(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "SparseMatrix_HostReadWriteI(SparseMatrix self) -> int *"}, @@ -18105,9 +14834,9 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" "SparseMatrix_GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "SparseMatrix_ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "SparseMatrix_WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "SparseMatrix_ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadJ, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadJ(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteJ, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_WriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteJ, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "SparseMatrix_HostReadJ(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "SparseMatrix_HostWriteJ(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "SparseMatrix_HostReadWriteJ(SparseMatrix self) -> int *"}, @@ -18115,13 +14844,13 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" "SparseMatrix_GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" ""}, - { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "SparseMatrix_ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, - { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "SparseMatrix_WriteData(SparseMatrix self, bool on_dev=True) -> double"}, - { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "SparseMatrix_ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadData, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadData(SparseMatrix self, bool on_dev=True) -> double const *"}, + { "SparseMatrix_WriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteData, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_WriteData(SparseMatrix self, bool on_dev=True) -> double *"}, + { "SparseMatrix_ReadWriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteData, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ReadWriteData(SparseMatrix self, bool on_dev=True) -> double *"}, { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "SparseMatrix_HostReadData(SparseMatrix self) -> double const *"}, { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "SparseMatrix_HostWriteData(SparseMatrix self) -> double *"}, { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "SparseMatrix_HostReadWriteData(SparseMatrix self) -> double *"}, - { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "SparseMatrix_RowSize(SparseMatrix self, int const i) -> int"}, + { "SparseMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_RowSize(SparseMatrix self, int const i) -> int"}, { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "SparseMatrix_MaxRowSize(SparseMatrix self) -> int"}, { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" "SparseMatrix_GetRowColumns(SparseMatrix self, int const row) -> int\n" @@ -18131,7 +14860,7 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix_GetRowEntries(SparseMatrix self, int const row) -> double\n" "SparseMatrix_GetRowEntries(SparseMatrix self, int const row) -> double const *\n" ""}, - { "SparseMatrix_SetWidth", _wrap_SparseMatrix_SetWidth, METH_VARARGS, "SparseMatrix_SetWidth(SparseMatrix self, int width_=-1)"}, + { "SparseMatrix_SetWidth", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetWidth, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetWidth(SparseMatrix self, int width_=-1)"}, { "SparseMatrix_ActualWidth", _wrap_SparseMatrix_ActualWidth, METH_O, "SparseMatrix_ActualWidth(SparseMatrix self) -> int"}, { "SparseMatrix_SortColumnIndices", _wrap_SparseMatrix_SortColumnIndices, METH_O, "SparseMatrix_SortColumnIndices(SparseMatrix self)"}, { "SparseMatrix_MoveDiagonalFirst", _wrap_SparseMatrix_MoveDiagonalFirst, METH_O, "SparseMatrix_MoveDiagonalFirst(SparseMatrix self)"}, @@ -18143,63 +14872,63 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix___call__(SparseMatrix self, int i, int j) -> double\n" "SparseMatrix___call__(SparseMatrix self, int i, int j) -> double const &\n" ""}, - { "SparseMatrix_GetDiag", _wrap_SparseMatrix_GetDiag, METH_VARARGS, "SparseMatrix_GetDiag(SparseMatrix self, Vector d)"}, + { "SparseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetDiag(SparseMatrix self, Vector d)"}, { "SparseMatrix_ToDenseMatrix", _wrap_SparseMatrix_ToDenseMatrix, METH_VARARGS, "\n" "SparseMatrix_ToDenseMatrix(SparseMatrix self) -> DenseMatrix\n" "SparseMatrix_ToDenseMatrix(SparseMatrix self, DenseMatrix B)\n" ""}, { "SparseMatrix_GetMemoryClass", _wrap_SparseMatrix_GetMemoryClass, METH_O, "SparseMatrix_GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass"}, - { "SparseMatrix_Mult", _wrap_SparseMatrix_Mult, METH_VARARGS, "SparseMatrix_Mult(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMult", _wrap_SparseMatrix_AddMult, METH_VARARGS, "SparseMatrix_AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_MultTranspose", _wrap_SparseMatrix_MultTranspose, METH_VARARGS, "SparseMatrix_MultTranspose(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMultTranspose", _wrap_SparseMatrix_AddMultTranspose, METH_VARARGS, "SparseMatrix_AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Mult(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_MultTranspose(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, { "SparseMatrix_BuildTranspose", _wrap_SparseMatrix_BuildTranspose, METH_O, "SparseMatrix_BuildTranspose(SparseMatrix self)"}, { "SparseMatrix_ResetTranspose", _wrap_SparseMatrix_ResetTranspose, METH_O, "SparseMatrix_ResetTranspose(SparseMatrix self)"}, - { "SparseMatrix_PartMult", _wrap_SparseMatrix_PartMult, METH_VARARGS, "SparseMatrix_PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, - { "SparseMatrix_PartAddMult", _wrap_SparseMatrix_PartAddMult, METH_VARARGS, "SparseMatrix_PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_BooleanMult", _wrap_SparseMatrix_BooleanMult, METH_VARARGS, "SparseMatrix_BooleanMult(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_BooleanMultTranspose", _wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS, "SparseMatrix_BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_InnerProduct", _wrap_SparseMatrix_InnerProduct, METH_VARARGS, "SparseMatrix_InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, - { "SparseMatrix_GetRowSums", _wrap_SparseMatrix_GetRowSums, METH_VARARGS, "SparseMatrix_GetRowSums(SparseMatrix self, Vector x)"}, - { "SparseMatrix_GetRowNorml1", _wrap_SparseMatrix_GetRowNorml1, METH_VARARGS, "SparseMatrix_GetRowNorml1(SparseMatrix self, int irow) -> double"}, + { "SparseMatrix_PartMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, + { "SparseMatrix_PartAddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartAddMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BooleanMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMult, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_BooleanMult(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_BooleanMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_InnerProduct", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_InnerProduct, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, + { "SparseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetRowSums(SparseMatrix self, Vector x)"}, + { "SparseMatrix_GetRowNorml1", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowNorml1, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetRowNorml1(SparseMatrix self, int irow) -> double"}, { "SparseMatrix_Inverse", _wrap_SparseMatrix_Inverse, METH_O, "SparseMatrix_Inverse(SparseMatrix self) -> MatrixInverse"}, { "SparseMatrix_EliminateRow", _wrap_SparseMatrix_EliminateRow, METH_VARARGS, "\n" "SparseMatrix_EliminateRow(SparseMatrix self, int row, double const sol, Vector rhs)\n" "SparseMatrix_EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" ""}, - { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "SparseMatrix_EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, + { "SparseMatrix_EliminateCol", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateCol, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" "SparseMatrix_EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" "SparseMatrix_EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" ""}, - { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "SparseMatrix_EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, - { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "SparseMatrix_EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, + { "SparseMatrix_EliminateRowColMultipleRHS", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, + { "SparseMatrix_EliminateRowColDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" "SparseMatrix_EliminateRowCol(SparseMatrix self, int rc, double const sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "SparseMatrix_EliminateRowCol(SparseMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "SparseMatrix_EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, { "SparseMatrix_SetDiagIdentity", _wrap_SparseMatrix_SetDiagIdentity, METH_O, "SparseMatrix_SetDiagIdentity(SparseMatrix self)"}, - { "SparseMatrix_EliminateZeroRows", _wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS, "SparseMatrix_EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, - { "SparseMatrix_Gauss_Seidel_forw", _wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS, "SparseMatrix_Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_Gauss_Seidel_back", _wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS, "SparseMatrix_Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, + { "SparseMatrix_Gauss_Seidel_forw", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_Gauss_Seidel_back", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, { "SparseMatrix_GetJacobiScaling", _wrap_SparseMatrix_GetJacobiScaling, METH_O, "SparseMatrix_GetJacobiScaling(SparseMatrix self) -> double"}, - { "SparseMatrix_Jacobi", _wrap_SparseMatrix_Jacobi, METH_VARARGS, "SparseMatrix_Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, - { "SparseMatrix_DiagScale", _wrap_SparseMatrix_DiagScale, METH_VARARGS, "SparseMatrix_DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, - { "SparseMatrix_Jacobi2", _wrap_SparseMatrix_Jacobi2, METH_VARARGS, "SparseMatrix_Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, - { "SparseMatrix_Jacobi3", _wrap_SparseMatrix_Jacobi3, METH_VARARGS, "SparseMatrix_Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, + { "SparseMatrix_DiagScale", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_DiagScale, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, + { "SparseMatrix_Jacobi2", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi2, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi3", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi3, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, { "SparseMatrix_Finalize", _wrap_SparseMatrix_Finalize, METH_VARARGS, "\n" "SparseMatrix_Finalize(SparseMatrix self, int skip_zeros=1)\n" "SparseMatrix_Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" ""}, { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "SparseMatrix_Finalized(SparseMatrix self) -> bool"}, { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "SparseMatrix_ColumnsAreSorted(SparseMatrix self) -> bool"}, - { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "SparseMatrix_Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, - { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "SparseMatrix_GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, - { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "SparseMatrix_GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, - { "SparseMatrix_SetColPtr", _wrap_SparseMatrix_SetColPtr, METH_VARARGS, "SparseMatrix_SetColPtr(SparseMatrix self, int const row)"}, + { "SparseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, + { "SparseMatrix_GetBlocks", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetBlocks, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "SparseMatrix_GetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetSubMatrix, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, + { "SparseMatrix_SetColPtr", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetColPtr, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetColPtr(SparseMatrix self, int const row)"}, { "SparseMatrix_ClearColPtr", _wrap_SparseMatrix_ClearColPtr, METH_O, "SparseMatrix_ClearColPtr(SparseMatrix self)"}, - { "SparseMatrix__Get_", _wrap_SparseMatrix__Get_, METH_VARARGS, "SparseMatrix__Get_(SparseMatrix self, int const col) -> double"}, + { "SparseMatrix__Get_", (PyCFunction)(void(*)(void))_wrap_SparseMatrix__Get_, METH_VARARGS|METH_KEYWORDS, "SparseMatrix__Get_(SparseMatrix self, int const col) -> double"}, { "SparseMatrix_SearchRow", _wrap_SparseMatrix_SearchRow, METH_VARARGS, "\n" "SparseMatrix_SearchRow(SparseMatrix self, int const col) -> double\n" "SparseMatrix_SearchRow(SparseMatrix self, int const row, int const col) -> double &\n" @@ -18212,35 +14941,35 @@ static PyMethodDef SwigMethods[] = { "SparseMatrix__Set_(SparseMatrix self, int const col, double const a)\n" "SparseMatrix__Set_(SparseMatrix self, int const row, int const col, double const a)\n" ""}, - { "SparseMatrix_Set", _wrap_SparseMatrix_Set, METH_VARARGS, "SparseMatrix_Set(SparseMatrix self, int const i, int const j, double const a)"}, - { "SparseMatrix_SetSubMatrix", _wrap_SparseMatrix_SetSubMatrix, METH_VARARGS, "SparseMatrix_SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_SetSubMatrixTranspose", _wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS, "SparseMatrix_SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_AddSubMatrix", _wrap_SparseMatrix_AddSubMatrix, METH_VARARGS, "SparseMatrix_AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_RowIsEmpty", _wrap_SparseMatrix_RowIsEmpty, METH_VARARGS, "SparseMatrix_RowIsEmpty(SparseMatrix self, int const row) -> bool"}, - { "SparseMatrix_GetRow", _wrap_SparseMatrix_GetRow, METH_VARARGS, "SparseMatrix_GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "SparseMatrix_SetRow", _wrap_SparseMatrix_SetRow, METH_VARARGS, "SparseMatrix_SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_AddRow", _wrap_SparseMatrix_AddRow, METH_VARARGS, "SparseMatrix_AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_ScaleRow", _wrap_SparseMatrix_ScaleRow, METH_VARARGS, "SparseMatrix_ScaleRow(SparseMatrix self, int const row, double const scale)"}, - { "SparseMatrix_ScaleRows", _wrap_SparseMatrix_ScaleRows, METH_VARARGS, "SparseMatrix_ScaleRows(SparseMatrix self, Vector sl)"}, - { "SparseMatrix_ScaleColumns", _wrap_SparseMatrix_ScaleColumns, METH_VARARGS, "SparseMatrix_ScaleColumns(SparseMatrix self, Vector sr)"}, - { "SparseMatrix___iadd__", _wrap_SparseMatrix___iadd__, METH_VARARGS, "SparseMatrix___iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, + { "SparseMatrix_Set", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Set, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Set(SparseMatrix self, int const i, int const j, double const a)"}, + { "SparseMatrix_SetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrix, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_SetSubMatrixTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_AddSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddSubMatrix, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_RowIsEmpty", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowIsEmpty, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_RowIsEmpty(SparseMatrix self, int const row) -> bool"}, + { "SparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "SparseMatrix_SetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_AddRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_ScaleRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRow, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ScaleRow(SparseMatrix self, int const row, double const scale)"}, + { "SparseMatrix_ScaleRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRows, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ScaleRows(SparseMatrix self, Vector sl)"}, + { "SparseMatrix_ScaleColumns", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleColumns, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_ScaleColumns(SparseMatrix self, Vector sr)"}, + { "SparseMatrix___iadd__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___iadd__, METH_VARARGS|METH_KEYWORDS, "SparseMatrix___iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, { "SparseMatrix_Add", _wrap_SparseMatrix_Add, METH_VARARGS, "\n" "SparseMatrix_Add(SparseMatrix self, int const i, int const j, double const a)\n" "SparseMatrix_Add(SparseMatrix self, double const a, SparseMatrix B)\n" ""}, - { "SparseMatrix___imul__", _wrap_SparseMatrix___imul__, METH_VARARGS, "SparseMatrix___imul__(SparseMatrix self, double a) -> SparseMatrix"}, + { "SparseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "SparseMatrix___imul__(SparseMatrix self, double a) -> SparseMatrix"}, { "SparseMatrix_IsSymmetric", _wrap_SparseMatrix_IsSymmetric, METH_O, "SparseMatrix_IsSymmetric(SparseMatrix self) -> double"}, { "SparseMatrix_Symmetrize", _wrap_SparseMatrix_Symmetrize, METH_O, "SparseMatrix_Symmetrize(SparseMatrix self)"}, { "SparseMatrix_NumNonZeroElems", _wrap_SparseMatrix_NumNonZeroElems, METH_O, "SparseMatrix_NumNonZeroElems(SparseMatrix self) -> int"}, { "SparseMatrix_MaxNorm", _wrap_SparseMatrix_MaxNorm, METH_O, "SparseMatrix_MaxNorm(SparseMatrix self) -> double"}, - { "SparseMatrix_CountSmallElems", _wrap_SparseMatrix_CountSmallElems, METH_VARARGS, "SparseMatrix_CountSmallElems(SparseMatrix self, double tol) -> int"}, + { "SparseMatrix_CountSmallElems", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_CountSmallElems, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_CountSmallElems(SparseMatrix self, double tol) -> int"}, { "SparseMatrix_CheckFinite", _wrap_SparseMatrix_CheckFinite, METH_O, "SparseMatrix_CheckFinite(SparseMatrix self) -> int"}, - { "SparseMatrix_SetGraphOwner", _wrap_SparseMatrix_SetGraphOwner, METH_VARARGS, "SparseMatrix_SetGraphOwner(SparseMatrix self, bool ownij)"}, - { "SparseMatrix_SetDataOwner", _wrap_SparseMatrix_SetDataOwner, METH_VARARGS, "SparseMatrix_SetDataOwner(SparseMatrix self, bool owna)"}, + { "SparseMatrix_SetGraphOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetGraphOwner, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetGraphOwner(SparseMatrix self, bool ownij)"}, + { "SparseMatrix_SetDataOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetDataOwner, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_SetDataOwner(SparseMatrix self, bool owna)"}, { "SparseMatrix_OwnsGraph", _wrap_SparseMatrix_OwnsGraph, METH_O, "SparseMatrix_OwnsGraph(SparseMatrix self) -> bool"}, { "SparseMatrix_OwnsData", _wrap_SparseMatrix_OwnsData, METH_O, "SparseMatrix_OwnsData(SparseMatrix self) -> bool"}, { "SparseMatrix_LoseData", _wrap_SparseMatrix_LoseData, METH_O, "SparseMatrix_LoseData(SparseMatrix self)"}, - { "SparseMatrix_Swap", _wrap_SparseMatrix_Swap, METH_VARARGS, "SparseMatrix_Swap(SparseMatrix self, SparseMatrix other)"}, + { "SparseMatrix_Swap", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Swap, METH_VARARGS|METH_KEYWORDS, "SparseMatrix_Swap(SparseMatrix self, SparseMatrix other)"}, { "delete_SparseMatrix", _wrap_delete_SparseMatrix, METH_O, "delete_SparseMatrix(SparseMatrix self)"}, { "SparseMatrix_GetType", _wrap_SparseMatrix_GetType, METH_O, "SparseMatrix_GetType(SparseMatrix self) -> mfem::Operator::Type"}, { "SparseMatrix_GetIArray", _wrap_SparseMatrix_GetIArray, METH_O, "SparseMatrix_GetIArray(SparseMatrix self) -> PyObject *"}, @@ -18275,11 +15004,11 @@ static PyMethodDef SwigMethods[] = { ""}, { "SparseMatrix_swigregister", SparseMatrix_swigregister, METH_O, NULL}, { "SparseMatrix_swiginit", SparseMatrix_swiginit, METH_VARARGS, NULL}, - { "SparseMatrixFunction", _wrap_SparseMatrixFunction, METH_VARARGS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, - { "TransposeAbstractSparseMatrix", _wrap_TransposeAbstractSparseMatrix, METH_VARARGS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, - { "TransposeMult", _wrap_TransposeMult, METH_VARARGS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, - { "MultAbstractSparseMatrix", _wrap_MultAbstractSparseMatrix, METH_VARARGS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, - { "Mult_AtDA", _wrap_Mult_AtDA, METH_VARARGS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, + { "SparseMatrixFunction", (PyCFunction)(void(*)(void))_wrap_SparseMatrixFunction, METH_VARARGS|METH_KEYWORDS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, + { "TransposeAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, + { "TransposeMult", (PyCFunction)(void(*)(void))_wrap_TransposeMult, METH_VARARGS|METH_KEYWORDS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, + { "MultAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_MultAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, + { "Mult_AtDA", (PyCFunction)(void(*)(void))_wrap_Mult_AtDA, METH_VARARGS|METH_KEYWORDS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, { "OuterProduct", _wrap_OuterProduct, METH_VARARGS, "\n" "OuterProduct(DenseMatrix A, DenseMatrix B) -> DenseMatrix\n" "OuterProduct(DenseMatrix A, SparseMatrix B) -> SparseMatrix\n" @@ -18292,10 +15021,10 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "RAP_P", _wrap_RAP_P, METH_VARARGS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, - { "RAP_R", _wrap_RAP_R, METH_VARARGS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, - { "OperatorPtr2SparseMatrix", _wrap_OperatorPtr2SparseMatrix, METH_O, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, - { "OperatorHandle2SparseMatrix", _wrap_OperatorHandle2SparseMatrix, METH_O, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, + { "RAP_P", (PyCFunction)(void(*)(void))_wrap_RAP_P, METH_VARARGS|METH_KEYWORDS, "RAP_P(SparseMatrix A, SparseMatrix R, SparseMatrix ORAP) -> SparseMatrix"}, + { "RAP_R", (PyCFunction)(void(*)(void))_wrap_RAP_R, METH_VARARGS|METH_KEYWORDS, "RAP_R(SparseMatrix Rt, SparseMatrix A, SparseMatrix P) -> SparseMatrix"}, + { "OperatorPtr2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorPtr2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorPtr2SparseMatrix(mfem::OperatorPtr op) -> SparseMatrix"}, + { "OperatorHandle2SparseMatrix", (PyCFunction)(void(*)(void))_wrap_OperatorHandle2SparseMatrix, METH_VARARGS|METH_KEYWORDS, "OperatorHandle2SparseMatrix(mfem::OperatorHandle op) -> SparseMatrix"}, { "RowNode_Value_set", _wrap_RowNode_Value_set, METH_VARARGS, "RowNode_Value_set(RowNode self, double Value)"}, { "RowNode_Value_get", _wrap_RowNode_Value_get, METH_O, "RowNode_Value_get(RowNode self) -> double"}, { "RowNode_Prev_set", _wrap_RowNode_Prev_set, METH_VARARGS, "RowNode_Prev_set(RowNode self, RowNode Prev)"}, @@ -18315,7 +15044,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SparseMatrix(SparseMatrix mat, bool copy_graph=True)\n" "new_SparseMatrix(Vector v) -> SparseMatrix\n" ""}, - { "SparseMatrix_MakeRef", _wrap_SparseMatrix_MakeRef, METH_VARARGS, "MakeRef(SparseMatrix self, SparseMatrix master)"}, + { "SparseMatrix_MakeRef", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MakeRef, METH_VARARGS|METH_KEYWORDS, "MakeRef(SparseMatrix self, SparseMatrix master)"}, { "SparseMatrix_Size", _wrap_SparseMatrix_Size, METH_O, "Size(SparseMatrix self) -> int"}, { "SparseMatrix_Clear", _wrap_SparseMatrix_Clear, METH_O, "Clear(SparseMatrix self)"}, { "SparseMatrix_Empty", _wrap_SparseMatrix_Empty, METH_O, "Empty(SparseMatrix self) -> bool"}, @@ -18335,9 +15064,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemoryI(SparseMatrix self) -> mfem::Memory< int >\n" "GetMemoryI(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadI", _wrap_SparseMatrix_ReadI, METH_VARARGS, "ReadI(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteI", _wrap_SparseMatrix_WriteI, METH_VARARGS, "WriteI(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteI", _wrap_SparseMatrix_ReadWriteI, METH_VARARGS, "ReadWriteI(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadI, METH_VARARGS|METH_KEYWORDS, "ReadI(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteI, METH_VARARGS|METH_KEYWORDS, "WriteI(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteI", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteI, METH_VARARGS|METH_KEYWORDS, "ReadWriteI(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadI", _wrap_SparseMatrix_HostReadI, METH_O, "HostReadI(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteI", _wrap_SparseMatrix_HostWriteI, METH_O, "HostWriteI(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteI", _wrap_SparseMatrix_HostReadWriteI, METH_O, "HostReadWriteI(SparseMatrix self) -> int *"}, @@ -18345,9 +15074,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int >\n" "GetMemoryJ(SparseMatrix self) -> mfem::Memory< int > const &\n" ""}, - { "SparseMatrix_ReadJ", _wrap_SparseMatrix_ReadJ, METH_VARARGS, "ReadJ(SparseMatrix self, bool on_dev=True) -> int const"}, - { "SparseMatrix_WriteJ", _wrap_SparseMatrix_WriteJ, METH_VARARGS, "WriteJ(SparseMatrix self, bool on_dev=True) -> int"}, - { "SparseMatrix_ReadWriteJ", _wrap_SparseMatrix_ReadWriteJ, METH_VARARGS, "ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int"}, + { "SparseMatrix_ReadJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadJ, METH_VARARGS|METH_KEYWORDS, "ReadJ(SparseMatrix self, bool on_dev=True) -> int const *"}, + { "SparseMatrix_WriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteJ, METH_VARARGS|METH_KEYWORDS, "WriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, + { "SparseMatrix_ReadWriteJ", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteJ, METH_VARARGS|METH_KEYWORDS, "ReadWriteJ(SparseMatrix self, bool on_dev=True) -> int *"}, { "SparseMatrix_HostReadJ", _wrap_SparseMatrix_HostReadJ, METH_O, "HostReadJ(SparseMatrix self) -> int const *"}, { "SparseMatrix_HostWriteJ", _wrap_SparseMatrix_HostWriteJ, METH_O, "HostWriteJ(SparseMatrix self) -> int *"}, { "SparseMatrix_HostReadWriteJ", _wrap_SparseMatrix_HostReadWriteJ, METH_O, "HostReadWriteJ(SparseMatrix self) -> int *"}, @@ -18355,13 +15084,13 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemoryData(SparseMatrix self) -> mfem::Memory< double >\n" "GetMemoryData(SparseMatrix self) -> mfem::Memory< double > const &\n" ""}, - { "SparseMatrix_ReadData", _wrap_SparseMatrix_ReadData, METH_VARARGS, "ReadData(SparseMatrix self, bool on_dev=True) -> double const"}, - { "SparseMatrix_WriteData", _wrap_SparseMatrix_WriteData, METH_VARARGS, "WriteData(SparseMatrix self, bool on_dev=True) -> double"}, - { "SparseMatrix_ReadWriteData", _wrap_SparseMatrix_ReadWriteData, METH_VARARGS, "ReadWriteData(SparseMatrix self, bool on_dev=True) -> double"}, + { "SparseMatrix_ReadData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadData, METH_VARARGS|METH_KEYWORDS, "ReadData(SparseMatrix self, bool on_dev=True) -> double const *"}, + { "SparseMatrix_WriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_WriteData, METH_VARARGS|METH_KEYWORDS, "WriteData(SparseMatrix self, bool on_dev=True) -> double *"}, + { "SparseMatrix_ReadWriteData", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ReadWriteData, METH_VARARGS|METH_KEYWORDS, "ReadWriteData(SparseMatrix self, bool on_dev=True) -> double *"}, { "SparseMatrix_HostReadData", _wrap_SparseMatrix_HostReadData, METH_O, "HostReadData(SparseMatrix self) -> double const *"}, { "SparseMatrix_HostWriteData", _wrap_SparseMatrix_HostWriteData, METH_O, "HostWriteData(SparseMatrix self) -> double *"}, { "SparseMatrix_HostReadWriteData", _wrap_SparseMatrix_HostReadWriteData, METH_O, "HostReadWriteData(SparseMatrix self) -> double *"}, - { "SparseMatrix_RowSize", _wrap_SparseMatrix_RowSize, METH_VARARGS, "RowSize(SparseMatrix self, int const i) -> int"}, + { "SparseMatrix_RowSize", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowSize, METH_VARARGS|METH_KEYWORDS, "RowSize(SparseMatrix self, int const i) -> int"}, { "SparseMatrix_MaxRowSize", _wrap_SparseMatrix_MaxRowSize, METH_O, "MaxRowSize(SparseMatrix self) -> int"}, { "SparseMatrix_GetRowColumns", _wrap_SparseMatrix_GetRowColumns, METH_VARARGS, "\n" "GetRowColumns(SparseMatrix self, int const row) -> int\n" @@ -18371,7 +15100,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetRowEntries(SparseMatrix self, int const row) -> double\n" "GetRowEntries(SparseMatrix self, int const row) -> double const *\n" ""}, - { "SparseMatrix_SetWidth", _wrap_SparseMatrix_SetWidth, METH_VARARGS, "SetWidth(SparseMatrix self, int width_=-1)"}, + { "SparseMatrix_SetWidth", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetWidth, METH_VARARGS|METH_KEYWORDS, "SetWidth(SparseMatrix self, int width_=-1)"}, { "SparseMatrix_ActualWidth", _wrap_SparseMatrix_ActualWidth, METH_O, "ActualWidth(SparseMatrix self) -> int"}, { "SparseMatrix_SortColumnIndices", _wrap_SparseMatrix_SortColumnIndices, METH_O, "SortColumnIndices(SparseMatrix self)"}, { "SparseMatrix_MoveDiagonalFirst", _wrap_SparseMatrix_MoveDiagonalFirst, METH_O, "MoveDiagonalFirst(SparseMatrix self)"}, @@ -18383,63 +15112,63 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__call__(SparseMatrix self, int i, int j) -> double\n" "__call__(SparseMatrix self, int i, int j) -> double const &\n" ""}, - { "SparseMatrix_GetDiag", _wrap_SparseMatrix_GetDiag, METH_VARARGS, "GetDiag(SparseMatrix self, Vector d)"}, + { "SparseMatrix_GetDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetDiag, METH_VARARGS|METH_KEYWORDS, "GetDiag(SparseMatrix self, Vector d)"}, { "SparseMatrix_ToDenseMatrix", _wrap_SparseMatrix_ToDenseMatrix, METH_VARARGS, "\n" "ToDenseMatrix(SparseMatrix self) -> DenseMatrix\n" "ToDenseMatrix(SparseMatrix self, DenseMatrix B)\n" ""}, { "SparseMatrix_GetMemoryClass", _wrap_SparseMatrix_GetMemoryClass, METH_O, "GetMemoryClass(SparseMatrix self) -> mfem::MemoryClass"}, - { "SparseMatrix_Mult", _wrap_SparseMatrix_Mult, METH_VARARGS, "Mult(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMult", _wrap_SparseMatrix_AddMult, METH_VARARGS, "AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_MultTranspose", _wrap_SparseMatrix_MultTranspose, METH_VARARGS, "MultTranspose(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_AddMultTranspose", _wrap_SparseMatrix_AddMultTranspose, METH_VARARGS, "AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_Mult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMult, METH_VARARGS|METH_KEYWORDS, "AddMult(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_MultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_MultTranspose, METH_VARARGS|METH_KEYWORDS, "MultTranspose(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_AddMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddMultTranspose, METH_VARARGS|METH_KEYWORDS, "AddMultTranspose(SparseMatrix self, Vector x, Vector y, double const a=1.0)"}, { "SparseMatrix_BuildTranspose", _wrap_SparseMatrix_BuildTranspose, METH_O, "BuildTranspose(SparseMatrix self)"}, { "SparseMatrix_ResetTranspose", _wrap_SparseMatrix_ResetTranspose, METH_O, "ResetTranspose(SparseMatrix self)"}, - { "SparseMatrix_PartMult", _wrap_SparseMatrix_PartMult, METH_VARARGS, "PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, - { "SparseMatrix_PartAddMult", _wrap_SparseMatrix_PartAddMult, METH_VARARGS, "PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, - { "SparseMatrix_BooleanMult", _wrap_SparseMatrix_BooleanMult, METH_VARARGS, "BooleanMult(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_BooleanMultTranspose", _wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS, "BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, - { "SparseMatrix_InnerProduct", _wrap_SparseMatrix_InnerProduct, METH_VARARGS, "InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, - { "SparseMatrix_GetRowSums", _wrap_SparseMatrix_GetRowSums, METH_VARARGS, "GetRowSums(SparseMatrix self, Vector x)"}, - { "SparseMatrix_GetRowNorml1", _wrap_SparseMatrix_GetRowNorml1, METH_VARARGS, "GetRowNorml1(SparseMatrix self, int irow) -> double"}, + { "SparseMatrix_PartMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartMult, METH_VARARGS|METH_KEYWORDS, "PartMult(SparseMatrix self, intArray rows, Vector x, Vector y)"}, + { "SparseMatrix_PartAddMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_PartAddMult, METH_VARARGS|METH_KEYWORDS, "PartAddMult(SparseMatrix self, intArray rows, Vector x, Vector y, double const a=1.0)"}, + { "SparseMatrix_BooleanMult", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMult, METH_VARARGS|METH_KEYWORDS, "BooleanMult(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_BooleanMultTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_BooleanMultTranspose, METH_VARARGS|METH_KEYWORDS, "BooleanMultTranspose(SparseMatrix self, intArray x, intArray y)"}, + { "SparseMatrix_InnerProduct", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_InnerProduct, METH_VARARGS|METH_KEYWORDS, "InnerProduct(SparseMatrix self, Vector x, Vector y) -> double"}, + { "SparseMatrix_GetRowSums", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowSums, METH_VARARGS|METH_KEYWORDS, "GetRowSums(SparseMatrix self, Vector x)"}, + { "SparseMatrix_GetRowNorml1", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRowNorml1, METH_VARARGS|METH_KEYWORDS, "GetRowNorml1(SparseMatrix self, int irow) -> double"}, { "SparseMatrix_Inverse", _wrap_SparseMatrix_Inverse, METH_O, "Inverse(SparseMatrix self) -> MatrixInverse"}, { "SparseMatrix_EliminateRow", _wrap_SparseMatrix_EliminateRow, METH_VARARGS, "\n" "EliminateRow(SparseMatrix self, int row, double const sol, Vector rhs)\n" "EliminateRow(SparseMatrix self, int row, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)\n" ""}, - { "SparseMatrix_EliminateCol", _wrap_SparseMatrix_EliminateCol, METH_VARARGS, "EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, + { "SparseMatrix_EliminateCol", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateCol, METH_VARARGS|METH_KEYWORDS, "EliminateCol(SparseMatrix self, int col, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ZERO)"}, { "SparseMatrix_EliminateCols", _wrap_SparseMatrix_EliminateCols, METH_VARARGS, "\n" "EliminateCols(SparseMatrix self, intArray cols, Vector x=None, Vector b=None)\n" "EliminateCols(SparseMatrix self, intArray col_marker, SparseMatrix Ae)\n" ""}, - { "SparseMatrix_EliminateRowColMultipleRHS", _wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS, "EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, - { "SparseMatrix_EliminateRowColDiag", _wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS, "EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, + { "SparseMatrix_EliminateRowColMultipleRHS", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColMultipleRHS, METH_VARARGS|METH_KEYWORDS, "EliminateRowColMultipleRHS(SparseMatrix self, int rc, Vector sol, DenseMatrix rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)"}, + { "SparseMatrix_EliminateRowColDiag", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateRowColDiag, METH_VARARGS|METH_KEYWORDS, "EliminateRowColDiag(SparseMatrix self, int rc, double value)"}, { "SparseMatrix_EliminateRowCol", _wrap_SparseMatrix_EliminateRowCol, METH_VARARGS, "\n" "EliminateRowCol(SparseMatrix self, int rc, double const sol, Vector rhs, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateRowCol(SparseMatrix self, int rc, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" "EliminateRowCol(SparseMatrix self, int rc, SparseMatrix Ae, mfem::Matrix::DiagonalPolicy dpolicy=DIAG_ONE)\n" ""}, { "SparseMatrix_SetDiagIdentity", _wrap_SparseMatrix_SetDiagIdentity, METH_O, "SetDiagIdentity(SparseMatrix self)"}, - { "SparseMatrix_EliminateZeroRows", _wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS, "EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, - { "SparseMatrix_Gauss_Seidel_forw", _wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS, "Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, - { "SparseMatrix_Gauss_Seidel_back", _wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS, "Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_EliminateZeroRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_EliminateZeroRows, METH_VARARGS|METH_KEYWORDS, "EliminateZeroRows(SparseMatrix self, double const threshold=1e-12)"}, + { "SparseMatrix_Gauss_Seidel_forw", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_forw, METH_VARARGS|METH_KEYWORDS, "Gauss_Seidel_forw(SparseMatrix self, Vector x, Vector y)"}, + { "SparseMatrix_Gauss_Seidel_back", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Gauss_Seidel_back, METH_VARARGS|METH_KEYWORDS, "Gauss_Seidel_back(SparseMatrix self, Vector x, Vector y)"}, { "SparseMatrix_GetJacobiScaling", _wrap_SparseMatrix_GetJacobiScaling, METH_O, "GetJacobiScaling(SparseMatrix self) -> double"}, - { "SparseMatrix_Jacobi", _wrap_SparseMatrix_Jacobi, METH_VARARGS, "Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, - { "SparseMatrix_DiagScale", _wrap_SparseMatrix_DiagScale, METH_VARARGS, "DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, - { "SparseMatrix_Jacobi2", _wrap_SparseMatrix_Jacobi2, METH_VARARGS, "Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, - { "SparseMatrix_Jacobi3", _wrap_SparseMatrix_Jacobi3, METH_VARARGS, "Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi, METH_VARARGS|METH_KEYWORDS, "Jacobi(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc)"}, + { "SparseMatrix_DiagScale", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_DiagScale, METH_VARARGS|METH_KEYWORDS, "DiagScale(SparseMatrix self, Vector b, Vector x, double sc=1.0)"}, + { "SparseMatrix_Jacobi2", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi2, METH_VARARGS|METH_KEYWORDS, "Jacobi2(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, + { "SparseMatrix_Jacobi3", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Jacobi3, METH_VARARGS|METH_KEYWORDS, "Jacobi3(SparseMatrix self, Vector b, Vector x0, Vector x1, double sc=1.0)"}, { "SparseMatrix_Finalize", _wrap_SparseMatrix_Finalize, METH_VARARGS, "\n" "Finalize(SparseMatrix self, int skip_zeros=1)\n" "Finalize(SparseMatrix self, int skip_zeros, bool fix_empty_rows)\n" ""}, { "SparseMatrix_Finalized", _wrap_SparseMatrix_Finalized, METH_O, "Finalized(SparseMatrix self) -> bool"}, { "SparseMatrix_ColumnsAreSorted", _wrap_SparseMatrix_ColumnsAreSorted, METH_O, "ColumnsAreSorted(SparseMatrix self) -> bool"}, - { "SparseMatrix_Threshold", _wrap_SparseMatrix_Threshold, METH_VARARGS, "Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, - { "SparseMatrix_GetBlocks", _wrap_SparseMatrix_GetBlocks, METH_VARARGS, "GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, - { "SparseMatrix_GetSubMatrix", _wrap_SparseMatrix_GetSubMatrix, METH_VARARGS, "GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, - { "SparseMatrix_SetColPtr", _wrap_SparseMatrix_SetColPtr, METH_VARARGS, "SetColPtr(SparseMatrix self, int const row)"}, + { "SparseMatrix_Threshold", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Threshold, METH_VARARGS|METH_KEYWORDS, "Threshold(SparseMatrix self, double tol, bool fix_empty_rows=False)"}, + { "SparseMatrix_GetBlocks", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetBlocks, METH_VARARGS|METH_KEYWORDS, "GetBlocks(SparseMatrix self, mfem::Array2D< mfem::SparseMatrix * > & blocks)"}, + { "SparseMatrix_GetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetSubMatrix, METH_VARARGS|METH_KEYWORDS, "GetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm)"}, + { "SparseMatrix_SetColPtr", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetColPtr, METH_VARARGS|METH_KEYWORDS, "SetColPtr(SparseMatrix self, int const row)"}, { "SparseMatrix_ClearColPtr", _wrap_SparseMatrix_ClearColPtr, METH_O, "ClearColPtr(SparseMatrix self)"}, - { "SparseMatrix__Get_", _wrap_SparseMatrix__Get_, METH_VARARGS, "_Get_(SparseMatrix self, int const col) -> double"}, + { "SparseMatrix__Get_", (PyCFunction)(void(*)(void))_wrap_SparseMatrix__Get_, METH_VARARGS|METH_KEYWORDS, "_Get_(SparseMatrix self, int const col) -> double"}, { "SparseMatrix_SearchRow", _wrap_SparseMatrix_SearchRow, METH_VARARGS, "\n" "SearchRow(SparseMatrix self, int const col) -> double\n" "SearchRow(SparseMatrix self, int const row, int const col) -> double &\n" @@ -18452,35 +15181,35 @@ static PyMethodDef SwigMethods_proxydocs[] = { "_Set_(SparseMatrix self, int const col, double const a)\n" "_Set_(SparseMatrix self, int const row, int const col, double const a)\n" ""}, - { "SparseMatrix_Set", _wrap_SparseMatrix_Set, METH_VARARGS, "Set(SparseMatrix self, int const i, int const j, double const a)"}, - { "SparseMatrix_SetSubMatrix", _wrap_SparseMatrix_SetSubMatrix, METH_VARARGS, "SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_SetSubMatrixTranspose", _wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS, "SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_AddSubMatrix", _wrap_SparseMatrix_AddSubMatrix, METH_VARARGS, "AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, - { "SparseMatrix_RowIsEmpty", _wrap_SparseMatrix_RowIsEmpty, METH_VARARGS, "RowIsEmpty(SparseMatrix self, int const row) -> bool"}, - { "SparseMatrix_GetRow", _wrap_SparseMatrix_GetRow, METH_VARARGS, "GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, - { "SparseMatrix_SetRow", _wrap_SparseMatrix_SetRow, METH_VARARGS, "SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_AddRow", _wrap_SparseMatrix_AddRow, METH_VARARGS, "AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, - { "SparseMatrix_ScaleRow", _wrap_SparseMatrix_ScaleRow, METH_VARARGS, "ScaleRow(SparseMatrix self, int const row, double const scale)"}, - { "SparseMatrix_ScaleRows", _wrap_SparseMatrix_ScaleRows, METH_VARARGS, "ScaleRows(SparseMatrix self, Vector sl)"}, - { "SparseMatrix_ScaleColumns", _wrap_SparseMatrix_ScaleColumns, METH_VARARGS, "ScaleColumns(SparseMatrix self, Vector sr)"}, - { "SparseMatrix___iadd__", _wrap_SparseMatrix___iadd__, METH_VARARGS, "__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, + { "SparseMatrix_Set", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Set, METH_VARARGS|METH_KEYWORDS, "Set(SparseMatrix self, int const i, int const j, double const a)"}, + { "SparseMatrix_SetSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrix, METH_VARARGS|METH_KEYWORDS, "SetSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_SetSubMatrixTranspose", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetSubMatrixTranspose, METH_VARARGS|METH_KEYWORDS, "SetSubMatrixTranspose(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_AddSubMatrix", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddSubMatrix, METH_VARARGS|METH_KEYWORDS, "AddSubMatrix(SparseMatrix self, intArray rows, intArray cols, DenseMatrix subm, int skip_zeros=1)"}, + { "SparseMatrix_RowIsEmpty", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_RowIsEmpty, METH_VARARGS|METH_KEYWORDS, "RowIsEmpty(SparseMatrix self, int const row) -> bool"}, + { "SparseMatrix_GetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_GetRow, METH_VARARGS|METH_KEYWORDS, "GetRow(SparseMatrix self, int const row, intArray cols, Vector srow) -> int"}, + { "SparseMatrix_SetRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetRow, METH_VARARGS|METH_KEYWORDS, "SetRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_AddRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_AddRow, METH_VARARGS|METH_KEYWORDS, "AddRow(SparseMatrix self, int const row, intArray cols, Vector srow)"}, + { "SparseMatrix_ScaleRow", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRow, METH_VARARGS|METH_KEYWORDS, "ScaleRow(SparseMatrix self, int const row, double const scale)"}, + { "SparseMatrix_ScaleRows", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleRows, METH_VARARGS|METH_KEYWORDS, "ScaleRows(SparseMatrix self, Vector sl)"}, + { "SparseMatrix_ScaleColumns", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_ScaleColumns, METH_VARARGS|METH_KEYWORDS, "ScaleColumns(SparseMatrix self, Vector sr)"}, + { "SparseMatrix___iadd__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___iadd__, METH_VARARGS|METH_KEYWORDS, "__iadd__(SparseMatrix self, SparseMatrix B) -> SparseMatrix"}, { "SparseMatrix_Add", _wrap_SparseMatrix_Add, METH_VARARGS, "\n" "Add(SparseMatrix self, int const i, int const j, double const a)\n" "Add(SparseMatrix self, double const a, SparseMatrix B)\n" ""}, - { "SparseMatrix___imul__", _wrap_SparseMatrix___imul__, METH_VARARGS, "__imul__(SparseMatrix self, double a) -> SparseMatrix"}, + { "SparseMatrix___imul__", (PyCFunction)(void(*)(void))_wrap_SparseMatrix___imul__, METH_VARARGS|METH_KEYWORDS, "__imul__(SparseMatrix self, double a) -> SparseMatrix"}, { "SparseMatrix_IsSymmetric", _wrap_SparseMatrix_IsSymmetric, METH_O, "IsSymmetric(SparseMatrix self) -> double"}, { "SparseMatrix_Symmetrize", _wrap_SparseMatrix_Symmetrize, METH_O, "Symmetrize(SparseMatrix self)"}, { "SparseMatrix_NumNonZeroElems", _wrap_SparseMatrix_NumNonZeroElems, METH_O, "NumNonZeroElems(SparseMatrix self) -> int"}, { "SparseMatrix_MaxNorm", _wrap_SparseMatrix_MaxNorm, METH_O, "MaxNorm(SparseMatrix self) -> double"}, - { "SparseMatrix_CountSmallElems", _wrap_SparseMatrix_CountSmallElems, METH_VARARGS, "CountSmallElems(SparseMatrix self, double tol) -> int"}, + { "SparseMatrix_CountSmallElems", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_CountSmallElems, METH_VARARGS|METH_KEYWORDS, "CountSmallElems(SparseMatrix self, double tol) -> int"}, { "SparseMatrix_CheckFinite", _wrap_SparseMatrix_CheckFinite, METH_O, "CheckFinite(SparseMatrix self) -> int"}, - { "SparseMatrix_SetGraphOwner", _wrap_SparseMatrix_SetGraphOwner, METH_VARARGS, "SetGraphOwner(SparseMatrix self, bool ownij)"}, - { "SparseMatrix_SetDataOwner", _wrap_SparseMatrix_SetDataOwner, METH_VARARGS, "SetDataOwner(SparseMatrix self, bool owna)"}, + { "SparseMatrix_SetGraphOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetGraphOwner, METH_VARARGS|METH_KEYWORDS, "SetGraphOwner(SparseMatrix self, bool ownij)"}, + { "SparseMatrix_SetDataOwner", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_SetDataOwner, METH_VARARGS|METH_KEYWORDS, "SetDataOwner(SparseMatrix self, bool owna)"}, { "SparseMatrix_OwnsGraph", _wrap_SparseMatrix_OwnsGraph, METH_O, "OwnsGraph(SparseMatrix self) -> bool"}, { "SparseMatrix_OwnsData", _wrap_SparseMatrix_OwnsData, METH_O, "OwnsData(SparseMatrix self) -> bool"}, { "SparseMatrix_LoseData", _wrap_SparseMatrix_LoseData, METH_O, "LoseData(SparseMatrix self)"}, - { "SparseMatrix_Swap", _wrap_SparseMatrix_Swap, METH_VARARGS, "Swap(SparseMatrix self, SparseMatrix other)"}, + { "SparseMatrix_Swap", (PyCFunction)(void(*)(void))_wrap_SparseMatrix_Swap, METH_VARARGS|METH_KEYWORDS, "Swap(SparseMatrix self, SparseMatrix other)"}, { "delete_SparseMatrix", _wrap_delete_SparseMatrix, METH_O, "delete_SparseMatrix(SparseMatrix self)"}, { "SparseMatrix_GetType", _wrap_SparseMatrix_GetType, METH_O, "GetType(SparseMatrix self) -> mfem::Operator::Type"}, { "SparseMatrix_GetIArray", _wrap_SparseMatrix_GetIArray, METH_O, "GetIArray(SparseMatrix self) -> PyObject *"}, @@ -18515,11 +15244,11 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "SparseMatrix_swigregister", SparseMatrix_swigregister, METH_O, NULL}, { "SparseMatrix_swiginit", SparseMatrix_swiginit, METH_VARARGS, NULL}, - { "SparseMatrixFunction", _wrap_SparseMatrixFunction, METH_VARARGS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, - { "TransposeAbstractSparseMatrix", _wrap_TransposeAbstractSparseMatrix, METH_VARARGS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, - { "TransposeMult", _wrap_TransposeMult, METH_VARARGS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, - { "MultAbstractSparseMatrix", _wrap_MultAbstractSparseMatrix, METH_VARARGS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, - { "Mult_AtDA", _wrap_Mult_AtDA, METH_VARARGS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, + { "SparseMatrixFunction", (PyCFunction)(void(*)(void))_wrap_SparseMatrixFunction, METH_VARARGS|METH_KEYWORDS, "SparseMatrixFunction(SparseMatrix S, double (*)(double) f)"}, + { "TransposeAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_TransposeAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "TransposeAbstractSparseMatrix(AbstractSparseMatrix A, int useActualWidth) -> SparseMatrix"}, + { "TransposeMult", (PyCFunction)(void(*)(void))_wrap_TransposeMult, METH_VARARGS|METH_KEYWORDS, "TransposeMult(SparseMatrix A, SparseMatrix B) -> SparseMatrix"}, + { "MultAbstractSparseMatrix", (PyCFunction)(void(*)(void))_wrap_MultAbstractSparseMatrix, METH_VARARGS|METH_KEYWORDS, "MultAbstractSparseMatrix(AbstractSparseMatrix A, AbstractSparseMatrix B) -> SparseMatrix"}, + { "Mult_AtDA", (PyCFunction)(void(*)(void))_wrap_Mult_AtDA, METH_VARARGS|METH_KEYWORDS, "Mult_AtDA(SparseMatrix A, Vector D, SparseMatrix OAtDA=None) -> SparseMatrix"}, { "OuterProduct", _wrap_OuterProduct, METH_VARARGS, "\n" "OuterProduct(DenseMatrix A, DenseMatrix B) -> DenseMatrix\n" "OuterProduct(DenseMatrix A, SparseMatrix B) -> SparseMatrix\n" diff --git a/mfem/_ser/sparsesmoothers_wrap.cxx b/mfem/_ser/sparsesmoothers_wrap.cxx index 0e3de2b3..841f9df9 100644 --- a/mfem/_ser/sparsesmoothers_wrap.cxx +++ b/mfem/_ser/sparsesmoothers_wrap.cxx @@ -3257,7 +3257,7 @@ SWIG_AsVal_double (PyObject *obj, double *val) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_SparseSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_SparseSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::SparseSmoother *arg1 = (mfem::SparseSmoother *) 0 ; mfem::Operator *arg2 = 0 ; @@ -3265,15 +3265,19 @@ SWIGINTERN PyObject *_wrap_SparseSmoother_SetOperator(PyObject *SWIGUNUSEDPARM(s int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "SparseSmoother_SetOperator", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__SparseSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SparseSmoother_SetOperator", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__SparseSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SparseSmoother_SetOperator" "', argument " "1"" of type '" "mfem::SparseSmoother *""'"); } arg1 = reinterpret_cast< mfem::SparseSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Operator, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SparseSmoother_SetOperator" "', argument " "2"" of type '" "mfem::Operator const &""'"); } @@ -3356,95 +3360,30 @@ SWIGINTERN PyObject *SparseSmoother_swigregister(PyObject *SWIGUNUSEDPARM(self), SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - int arg2 ; + int arg1 = (int) 0 ; + int arg2 = (int) 1 ; mfem::GSSmoother *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if ((nobjs < 0) || (nobjs > 2)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; { try { - result = (mfem::GSSmoother *)new mfem::GSSmoother(); + result = (mfem::GSSmoother *)new mfem::GSSmoother(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3468,16 +3407,16 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - int arg3 ; + int arg2 = (int) 0 ; + int arg3 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; mfem::GSSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -3486,112 +3425,25 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__GSSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_GSSmoother__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::GSSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_GSSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1); + result = (mfem::GSSmoother *)new mfem::GSSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -3623,19 +3475,11 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_GSSmoother", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_GSSmoother__SWIG_2(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 2)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_GSSmoother__SWIG_5(self, argc, argv); + if (argc <= 0) { + return _wrap_new_GSSmoother__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3645,38 +3489,9 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_GSSmoother__SWIG_4(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_GSSmoother__SWIG_0(self, argc, argv); } - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3690,11 +3505,14 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 1) && (argc <= 3)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3704,6 +3522,9 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -3713,7 +3534,7 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_GSSmoother__SWIG_3(self, argc, argv); + return _wrap_new_GSSmoother__SWIG_1(self, argc, argv); } } } @@ -3723,16 +3544,12 @@ SWIGINTERN PyObject *_wrap_new_GSSmoother(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_GSSmoother'.\n" " Possible C/C++ prototypes are:\n" " mfem::GSSmoother::GSSmoother(int,int)\n" - " mfem::GSSmoother::GSSmoother(int)\n" - " mfem::GSSmoother::GSSmoother()\n" - " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &,int,int)\n" - " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &,int)\n" - " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &)\n"); + " mfem::GSSmoother::GSSmoother(mfem::SparseMatrix const &,int,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::GSSmoother *arg1 = (mfem::GSSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -3743,15 +3560,20 @@ SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObj int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "GSSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__GSSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:GSSmoother_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__GSSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GSSmoother_Mult" "', argument " "1"" of type '" "mfem::GSSmoother const *""'"); } arg1 = reinterpret_cast< mfem::GSSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GSSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -3759,7 +3581,7 @@ SWIGINTERN PyObject *_wrap_GSSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObj SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GSSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GSSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -3846,213 +3668,40 @@ SWIGINTERN PyObject *GSSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - int arg3 ; + int arg1 = (int) 0 ; + double arg2 = (double) 1. ; + int arg3 = (int) 1 ; double val2 ; int ecode2 = 0 ; mfem::DSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DSmoother" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - double arg2 ; - double val2 ; - int ecode2 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DSmoother" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if ((nobjs < 0) || (nobjs > 3)) SWIG_fail; + if (swig_obj[0]) { + { + if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg1 = PyArray_PyIntAsInt(swig_obj[0]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } + if (swig_obj[1]) { + ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DSmoother" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) { - PyObject *resultobj = 0; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 0) || (nobjs > 0)) SWIG_fail; - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - double arg3 ; - int arg4 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val3 ; - int ecode3 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); } { try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3,arg4); + result = (mfem::DSmoother *)new mfem::DSmoother(arg1,arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4076,18 +3725,19 @@ SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_4(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - double arg3 ; + int arg2 = (int) 0 ; + double arg3 = (double) 1. ; + int arg4 = (int) 1 ; void *argp1 = 0 ; int res1 = 0 ; double val3 ; int ecode3 = 0 ; mfem::DSmoother *result = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 4)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); @@ -4096,111 +3746,32 @@ SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_5(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); - if (!SWIG_IsOK(ecode3)) { - SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DSmoother" "', argument " "3"" of type '" "double""'"); - } - arg3 = static_cast< double >(val3); - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_6(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - int arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[2]) { + ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DSmoother" "', argument " "3"" of type '" "double""'"); + } + arg3 = static_cast< double >(val3); } - { - try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[3]) { + { + if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(swig_obj[3]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__DSmoother, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_DSmoother__SWIG_7(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::SparseMatrix *arg1 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - mfem::DSmoother *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__SparseMatrix, 0 | 0); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); } - if (!argp1) { - SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DSmoother" "', argument " "1"" of type '" "mfem::SparseMatrix const &""'"); - } - arg1 = reinterpret_cast< mfem::SparseMatrix * >(argp1); { try { - result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1); + result = (mfem::DSmoother *)new mfem::DSmoother((mfem::SparseMatrix const &)*arg1,arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4232,19 +3803,11 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "new_DSmoother", 0, 4, argv))) SWIG_fail; --argc; - if (argc == 0) { - return _wrap_new_DSmoother__SWIG_3(self, argc, argv); - } - if (argc == 1) { + if ((argc >= 0) && (argc <= 3)) { int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_new_DSmoother__SWIG_7(self, argc, argv); + if (argc <= 0) { + return _wrap_new_DSmoother__SWIG_0(self, argc, argv); } - } - if (argc == 1) { - int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4254,87 +3817,17 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_DSmoother__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_DSmoother__SWIG_6(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; + if (argc <= 1) { + return _wrap_new_DSmoother__SWIG_0(self, argc, argv); } - } - if (_v) { { int res = SWIG_AsVal_double(argv[1], NULL); _v = SWIG_CheckState(res); } if (_v) { - return _wrap_new_DSmoother__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[2], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_new_DSmoother__SWIG_5(self, argc, argv); + if (argc <= 2) { + return _wrap_new_DSmoother__SWIG_0(self, argc, argv); } - } - } - } - if (argc == 3) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - int res = SWIG_AsVal_double(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4349,11 +3842,14 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } } - if (argc == 4) { + if ((argc >= 1) && (argc <= 4)) { int _v; int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_mfem__SparseMatrix, SWIG_POINTER_NO_NULL | 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 1) { + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4363,11 +3859,17 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } if (_v) { + if (argc <= 2) { + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); + } { int res = SWIG_AsVal_double(argv[2], NULL); _v = SWIG_CheckState(res); } if (_v) { + if (argc <= 3) { + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4377,7 +3879,7 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_DSmoother__SWIG_4(self, argc, argv); + return _wrap_new_DSmoother__SWIG_1(self, argc, argv); } } } @@ -4388,18 +3890,12 @@ SWIGINTERN PyObject *_wrap_new_DSmoother(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DSmoother'.\n" " Possible C/C++ prototypes are:\n" " mfem::DSmoother::DSmoother(int,double,int)\n" - " mfem::DSmoother::DSmoother(int,double)\n" - " mfem::DSmoother::DSmoother(int)\n" - " mfem::DSmoother::DSmoother()\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int,double,int)\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int,double)\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int)\n" - " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &)\n"); + " mfem::DSmoother::DSmoother(mfem::SparseMatrix const &,int,double,int)\n"); return 0; } -SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DSmoother *arg1 = (mfem::DSmoother *) 0 ; mfem::Vector *arg2 = 0 ; @@ -4410,15 +3906,20 @@ SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"x", (char *)"y", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "DSmoother_Mult", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DSmoother, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DSmoother_Mult", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DSmoother, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DSmoother_Mult" "', argument " "1"" of type '" "mfem::DSmoother const *""'"); } arg1 = reinterpret_cast< mfem::DSmoother * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -4426,7 +3927,7 @@ SWIGINTERN PyObject *_wrap_DSmoother_Mult(PyObject *SWIGUNUSEDPARM(self), PyObje SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DSmoother_Mult" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DSmoother_Mult" "', argument " "3"" of type '" "mfem::Vector &""'"); } @@ -4514,22 +4015,22 @@ SWIGINTERN PyObject *DSmoother_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SparseSmoother_SetOperator(SparseSmoother self, Operator a)"}, + { "SparseSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_SparseSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "SparseSmoother_SetOperator(SparseSmoother self, Operator a)"}, { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, { "new_GSSmoother", _wrap_new_GSSmoother, METH_VARARGS, "\n" "GSSmoother(int t=0, int it=1)\n" - "GSSmoother(SparseMatrix a, int t=0, int it=1)\n" + "new_GSSmoother(SparseMatrix a, int t=0, int it=1) -> GSSmoother\n" ""}, - { "GSSmoother_Mult", _wrap_GSSmoother_Mult, METH_VARARGS, "GSSmoother_Mult(GSSmoother self, Vector x, Vector y)"}, + { "GSSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_GSSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "GSSmoother_Mult(GSSmoother self, Vector x, Vector y)"}, { "delete_GSSmoother", _wrap_delete_GSSmoother, METH_O, "delete_GSSmoother(GSSmoother self)"}, { "GSSmoother_swigregister", GSSmoother_swigregister, METH_O, NULL}, { "GSSmoother_swiginit", GSSmoother_swiginit, METH_VARARGS, NULL}, { "new_DSmoother", _wrap_new_DSmoother, METH_VARARGS, "\n" "DSmoother(int t=0, double s=1., int it=1)\n" - "DSmoother(SparseMatrix a, int t=0, double s=1., int it=1)\n" + "new_DSmoother(SparseMatrix a, int t=0, double s=1., int it=1) -> DSmoother\n" ""}, - { "DSmoother_Mult", _wrap_DSmoother_Mult, METH_VARARGS, "DSmoother_Mult(DSmoother self, Vector x, Vector y)"}, + { "DSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_DSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "DSmoother_Mult(DSmoother self, Vector x, Vector y)"}, { "delete_DSmoother", _wrap_delete_DSmoother, METH_O, "delete_DSmoother(DSmoother self)"}, { "DSmoother_swigregister", DSmoother_swigregister, METH_O, NULL}, { "DSmoother_swiginit", DSmoother_swiginit, METH_VARARGS, NULL}, @@ -4539,22 +4040,22 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "SparseSmoother_SetOperator", _wrap_SparseSmoother_SetOperator, METH_VARARGS, "SetOperator(SparseSmoother self, Operator a)"}, + { "SparseSmoother_SetOperator", (PyCFunction)(void(*)(void))_wrap_SparseSmoother_SetOperator, METH_VARARGS|METH_KEYWORDS, "SetOperator(SparseSmoother self, Operator a)"}, { "delete_SparseSmoother", _wrap_delete_SparseSmoother, METH_O, "delete_SparseSmoother(SparseSmoother self)"}, { "SparseSmoother_swigregister", SparseSmoother_swigregister, METH_O, NULL}, { "new_GSSmoother", _wrap_new_GSSmoother, METH_VARARGS, "\n" "GSSmoother(int t=0, int it=1)\n" - "GSSmoother(SparseMatrix a, int t=0, int it=1)\n" + "new_GSSmoother(SparseMatrix a, int t=0, int it=1) -> GSSmoother\n" ""}, - { "GSSmoother_Mult", _wrap_GSSmoother_Mult, METH_VARARGS, "Mult(GSSmoother self, Vector x, Vector y)"}, + { "GSSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_GSSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(GSSmoother self, Vector x, Vector y)"}, { "delete_GSSmoother", _wrap_delete_GSSmoother, METH_O, "delete_GSSmoother(GSSmoother self)"}, { "GSSmoother_swigregister", GSSmoother_swigregister, METH_O, NULL}, { "GSSmoother_swiginit", GSSmoother_swiginit, METH_VARARGS, NULL}, { "new_DSmoother", _wrap_new_DSmoother, METH_VARARGS, "\n" "DSmoother(int t=0, double s=1., int it=1)\n" - "DSmoother(SparseMatrix a, int t=0, double s=1., int it=1)\n" + "new_DSmoother(SparseMatrix a, int t=0, double s=1., int it=1) -> DSmoother\n" ""}, - { "DSmoother_Mult", _wrap_DSmoother_Mult, METH_VARARGS, "Mult(DSmoother self, Vector x, Vector y)"}, + { "DSmoother_Mult", (PyCFunction)(void(*)(void))_wrap_DSmoother_Mult, METH_VARARGS|METH_KEYWORDS, "Mult(DSmoother self, Vector x, Vector y)"}, { "delete_DSmoother", _wrap_delete_DSmoother, METH_O, "delete_DSmoother(DSmoother self)"}, { "DSmoother_swigregister", DSmoother_swigregister, METH_O, NULL}, { "DSmoother_swiginit", DSmoother_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/stable3d_wrap.cxx b/mfem/_ser/stable3d_wrap.cxx index 39c84fa4..37647876 100644 --- a/mfem/_ser/stable3d_wrap.cxx +++ b/mfem/_ser/stable3d_wrap.cxx @@ -3310,7 +3310,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_STable3D_Print__SWIG_2(mfem::STable3D *self,char const *file,int precision=8){ +SWIGINTERN void mfem_STable3D_Print__SWIG_1(mfem::STable3D *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3619,19 +3619,21 @@ SWIGINTERN PyObject *STable3DNode_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObj return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"nr", NULL + }; mfem::STable3D *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_STable3D", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -3659,7 +3661,7 @@ SWIGINTERN PyObject *_wrap_new_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_STable3D_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable3D_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; int arg2 ; @@ -3667,32 +3669,38 @@ SWIGINTERN PyObject *_wrap_STable3D_Push(PyObject *SWIGUNUSEDPARM(self), PyObjec int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"f", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable3D_Push", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:STable3D_Push", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Push" "', argument " "1"" of type '" "mfem::STable3D *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3780,7 +3788,7 @@ SWIGINTERN PyObject *_wrap_STable3D___call____SWIG_0(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; int arg2 ; @@ -3788,32 +3796,38 @@ SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObje int arg4 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"f", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable3D_Index", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:STable3D_Index", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Index" "', argument " "1"" of type '" "mfem::STable3D const *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3841,7 +3855,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Index(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_STable3D_Push4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable3D_Push4(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; int arg2 ; @@ -3850,38 +3864,45 @@ SWIGINTERN PyObject *_wrap_STable3D_Push4(PyObject *SWIGUNUSEDPARM(self), PyObje int arg5 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[5] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + PyObject * obj4 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"f", (char *)"t", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable3D_Push4", 5, 5, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:STable3D_Push4", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Push4" "', argument " "1"" of type '" "mfem::STable3D *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { - if ((PyArray_PyIntAsInt(swig_obj[4]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj4) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg5 = PyArray_PyIntAsInt(swig_obj[4]); + arg5 = PyArray_PyIntAsInt(obj4); } { try { @@ -4126,31 +4147,34 @@ SWIGINTERN PyObject *_wrap_STable3D_NumberOfElements(PyObject *SWIGUNUSEDPARM(se SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; - std::ostream *arg2 = 0 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D const *""'"); } arg1 = reinterpret_cast< mfem::STable3D * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } { @@ -4189,44 +4213,6 @@ SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self) } -SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D const *""'"); - } - arg1 = reinterpret_cast< mfem::STable3D * >(argp1); - { - try { - ((mfem::STable3D const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_delete_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; @@ -4267,18 +4253,18 @@ SWIGINTERN PyObject *_wrap_delete_STable3D(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D *""'"); @@ -4289,64 +4275,17 @@ SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self) SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STable3D_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_STable3D_Print__SWIG_2(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (Swig::DirectorException &e){ - SWIG_fail; - } - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_STable3D_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::STable3D *arg1 = (mfem::STable3D *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable3D, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable3D_Print" "', argument " "1"" of type '" "mfem::STable3D *""'"); - } - arg1 = reinterpret_cast< mfem::STable3D * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "STable3D_Print" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_STable3D_Print__SWIG_2(arg1,(char const *)arg2); + mfem_STable3D_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -4380,34 +4319,15 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "STable3D_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_STable3D_Print__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 2)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_STable3D_Print__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_STable3D_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -4422,7 +4342,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__STable3D, 0); @@ -4431,6 +4351,9 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_STable3D_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -4440,7 +4363,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_STable3D_Print__SWIG_2(self, argc, argv); + return _wrap_STable3D_Print__SWIG_1(self, argc, argv); } } } @@ -4450,9 +4373,7 @@ SWIGINTERN PyObject *_wrap_STable3D_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'STable3D_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::STable3D::Print(std::ostream &) const\n" - " mfem::STable3D::Print() const\n" - " mfem::STable3D::Print(char const *,int)\n" - " mfem::STable3D::Print(char const *)\n"); + " mfem::STable3D::Print(char const *,int)\n"); return 0; } @@ -4483,10 +4404,10 @@ static PyMethodDef SwigMethods[] = { { "delete_STable3DNode", _wrap_delete_STable3DNode, METH_O, "delete_STable3DNode(STable3DNode self)"}, { "STable3DNode_swigregister", STable3DNode_swigregister, METH_O, NULL}, { "STable3DNode_swiginit", STable3DNode_swiginit, METH_VARARGS, NULL}, - { "new_STable3D", _wrap_new_STable3D, METH_O, "new_STable3D(int nr) -> STable3D"}, - { "STable3D_Push", _wrap_STable3D_Push, METH_VARARGS, "STable3D_Push(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Index", _wrap_STable3D_Index, METH_VARARGS, "STable3D_Index(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Push4", _wrap_STable3D_Push4, METH_VARARGS, "STable3D_Push4(STable3D self, int r, int c, int f, int t) -> int"}, + { "new_STable3D", (PyCFunction)(void(*)(void))_wrap_new_STable3D, METH_VARARGS|METH_KEYWORDS, "new_STable3D(int nr) -> STable3D"}, + { "STable3D_Push", (PyCFunction)(void(*)(void))_wrap_STable3D_Push, METH_VARARGS|METH_KEYWORDS, "STable3D_Push(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Index", (PyCFunction)(void(*)(void))_wrap_STable3D_Index, METH_VARARGS|METH_KEYWORDS, "STable3D_Index(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Push4", (PyCFunction)(void(*)(void))_wrap_STable3D_Push4, METH_VARARGS|METH_KEYWORDS, "STable3D_Push4(STable3D self, int r, int c, int f, int t) -> int"}, { "STable3D___call__", _wrap_STable3D___call__, METH_VARARGS, "\n" "STable3D___call__(STable3D self, int r, int c, int f) -> int\n" "STable3D___call__(STable3D self, int r, int c, int f, int t) -> int\n" @@ -4517,10 +4438,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { { "delete_STable3DNode", _wrap_delete_STable3DNode, METH_O, "delete_STable3DNode(STable3DNode self)"}, { "STable3DNode_swigregister", STable3DNode_swigregister, METH_O, NULL}, { "STable3DNode_swiginit", STable3DNode_swiginit, METH_VARARGS, NULL}, - { "new_STable3D", _wrap_new_STable3D, METH_O, "new_STable3D(int nr) -> STable3D"}, - { "STable3D_Push", _wrap_STable3D_Push, METH_VARARGS, "Push(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Index", _wrap_STable3D_Index, METH_VARARGS, "Index(STable3D self, int r, int c, int f) -> int"}, - { "STable3D_Push4", _wrap_STable3D_Push4, METH_VARARGS, "Push4(STable3D self, int r, int c, int f, int t) -> int"}, + { "new_STable3D", (PyCFunction)(void(*)(void))_wrap_new_STable3D, METH_VARARGS|METH_KEYWORDS, "new_STable3D(int nr) -> STable3D"}, + { "STable3D_Push", (PyCFunction)(void(*)(void))_wrap_STable3D_Push, METH_VARARGS|METH_KEYWORDS, "Push(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Index", (PyCFunction)(void(*)(void))_wrap_STable3D_Index, METH_VARARGS|METH_KEYWORDS, "Index(STable3D self, int r, int c, int f) -> int"}, + { "STable3D_Push4", (PyCFunction)(void(*)(void))_wrap_STable3D_Push4, METH_VARARGS|METH_KEYWORDS, "Push4(STable3D self, int r, int c, int f, int t) -> int"}, { "STable3D___call__", _wrap_STable3D___call__, METH_VARARGS, "\n" "__call__(STable3D self, int r, int c, int f) -> int\n" "__call__(STable3D self, int r, int c, int f, int t) -> int\n" diff --git a/mfem/_ser/table_wrap.cxx b/mfem/_ser/table_wrap.cxx index 55ac4697..bdaf7ed2 100644 --- a/mfem/_ser/table_wrap.cxx +++ b/mfem/_ser/table_wrap.cxx @@ -2934,7 +2934,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Table_Print__SWIG_3(mfem::Table *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Table_Print__SWIG_1(mfem::Table *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -2967,7 +2967,7 @@ SWIGINTERN void mfem_Table_Save__SWIG_1(mfem::Table *self,char const *file,int p self -> Save(ofile); ofile.close(); } -SWIGINTERN void mfem_Table_Save__SWIG_3(mfem::Table *self){ +SWIGINTERN void mfem_Table_Save__SWIG_2(mfem::Table *self){ self -> Save(std::cout); } #ifdef __cplusplus @@ -3190,7 +3190,7 @@ SWIGINTERN PyObject *_wrap_new_Connection(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Connection *arg1 = (mfem::Connection *) 0 ; mfem::Connection *arg2 = 0 ; @@ -3198,16 +3198,20 @@ SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rhs", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "Connection___eq__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Connection___eq__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Connection___eq__" "', argument " "1"" of type '" "mfem::Connection const *""'"); } arg1 = reinterpret_cast< mfem::Connection * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Connection___eq__" "', argument " "2"" of type '" "mfem::Connection const &""'"); } @@ -3240,7 +3244,7 @@ SWIGINTERN PyObject *_wrap_Connection___eq__(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Connection___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Connection___lt__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Connection *arg1 = (mfem::Connection *) 0 ; mfem::Connection *arg2 = 0 ; @@ -3248,16 +3252,20 @@ SWIGINTERN PyObject *_wrap_Connection___lt__(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rhs", NULL + }; bool result; - if (!SWIG_Python_UnpackTuple(args, "Connection___lt__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Connection___lt__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Connection, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Connection___lt__" "', argument " "1"" of type '" "mfem::Connection const *""'"); } arg1 = reinterpret_cast< mfem::Connection * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Connection, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Connection___lt__" "', argument " "2"" of type '" "mfem::Connection const &""'"); } @@ -3408,21 +3416,23 @@ SWIGINTERN PyObject *_wrap_new_Table__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_Table__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 3 ; mfem::Table *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 2)) SWIG_fail; { if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; arg1 = PyArray_PyIntAsInt(swig_obj[0]); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + if (swig_obj[1]) { + { + if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(swig_obj[1]); + } } { try { @@ -3448,41 +3458,6 @@ SWIGINTERN PyObject *_wrap_new_Table__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ SWIGINTERN PyObject *_wrap_new_Table__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::Table *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); - } - { - try { - result = (mfem::Table *)new mfem::Table(arg1); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__Table, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_Table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; mfem::Array< mfem::Connection > *arg2 = 0 ; @@ -3528,7 +3503,7 @@ SWIGINTERN PyObject *_wrap_new_Table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ } -SWIGINTERN PyObject *_wrap_new_Table__SWIG_5(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_Table__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; int arg1 ; int *arg2 = (int *) 0 ; @@ -3590,7 +3565,7 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { return _wrap_new_Table__SWIG_1(self, argc, argv); } } - if (argc == 1) { + if ((argc >= 1) && (argc <= 2)) { int _v; { if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { @@ -3601,7 +3576,20 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_new_Table__SWIG_3(self, argc, argv); + if (argc <= 1) { + return _wrap_new_Table__SWIG_2(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_Table__SWIG_2(self, argc, argv); + } } } if (argc == 2) { @@ -3619,7 +3607,7 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_mfem__ArrayT_mfem__Connection_t, SWIG_POINTER_NO_NULL); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Table__SWIG_4(self, argc, argv); + return _wrap_new_Table__SWIG_3(self, argc, argv); } } } @@ -3638,31 +3626,7 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_new_Table__SWIG_5(self, argc, argv); - } - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_Table__SWIG_2(self, argc, argv); + return _wrap_new_Table__SWIG_4(self, argc, argv); } } } @@ -3673,32 +3637,35 @@ SWIGINTERN PyObject *_wrap_new_Table(PyObject *self, PyObject *args) { " mfem::Table::Table()\n" " mfem::Table::Table(mfem::Table const &)\n" " mfem::Table::Table(int,int)\n" - " mfem::Table::Table(int)\n" " mfem::Table::Table(int,mfem::Array< mfem::Connection > &)\n" " mfem::Table::Table(int,int *)\n"); return 0; } -SWIGINTERN PyObject *_wrap_Table_MakeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_MakeI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nrows", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_MakeI", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_MakeI", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_MakeI" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3723,25 +3690,29 @@ SWIGINTERN PyObject *_wrap_Table_MakeI(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Table_AddAColumnInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddAColumnInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddAColumnInRow", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_AddAColumnInRow", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddAColumnInRow" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -3766,32 +3737,37 @@ SWIGINTERN PyObject *_wrap_Table_AddAColumnInRow(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Table_AddColumnsInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddColumnsInRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"ncol", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddColumnsInRow", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_AddColumnsInRow", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddColumnsInRow" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3853,32 +3829,37 @@ SWIGINTERN PyObject *_wrap_Table_MakeJ(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Table_AddConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddConnection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddConnection", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_AddConnection", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddConnection" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3903,7 +3884,7 @@ SWIGINTERN PyObject *_wrap_Table_AddConnection(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Table_AddConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_AddConnections(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; @@ -3913,30 +3894,36 @@ SWIGINTERN PyObject *_wrap_Table_AddConnections(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"r", (char *)"c", (char *)"nc", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_AddConnections", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Table_AddConnections", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_AddConnections" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_AddConnections" "', argument " "3"" of type '" "int const *""'"); } arg3 = reinterpret_cast< int * >(argp3); { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3998,32 +3985,37 @@ SWIGINTERN PyObject *_wrap_Table_ShiftUpI(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Table_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dim", (char *)"connections_per_row", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_SetSize", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_SetSize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetSize" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4048,32 +4040,37 @@ SWIGINTERN PyObject *_wrap_Table_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Table_SetDims(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_SetDims(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"rows", (char *)"nnz", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_SetDims", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_SetDims", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetDims" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4174,33 +4171,38 @@ SWIGINTERN PyObject *_wrap_Table_Size_of_connections(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Table___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Table___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table___call__" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4278,26 +4280,30 @@ SWIGINTERN PyObject *_wrap_Table_GetRow__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Table_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_RowSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Table_RowSize", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_RowSize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_RowSize" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4958,95 +4964,53 @@ SWIGINTERN PyObject *_wrap_Table_SortRows(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Table_SetIJ__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Table_SetIJ(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int *arg2 = (int *) 0 ; int *arg3 = (int *) 0 ; - int arg4 ; + int arg4 = (int) -1 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"newI", (char *)"newJ", (char *)"newsize", NULL + }; - if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Table_SetIJ", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetIJ" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_SetIJ" "', argument " "2"" of type '" "int *""'"); } arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); + res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 | 0 ); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_SetIJ" "', argument " "3"" of type '" "int *""'"); } arg3 = reinterpret_cast< int * >(argp3); - { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); - } - { - try { - (arg1)->SetIJ(arg2,arg3,arg4); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj3) { + { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg4 = PyArray_PyIntAsInt(obj3); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_SetIJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - int *arg2 = (int *) 0 ; - int *arg3 = (int *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - void *argp2 = 0 ; - int res2 = 0 ; - void *argp3 = 0 ; - int res3 = 0 ; - - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_SetIJ" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_SetIJ" "', argument " "2"" of type '" "int *""'"); - } - arg2 = reinterpret_cast< int * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_int, 0 | 0 ); - if (!SWIG_IsOK(res3)) { - SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_SetIJ" "', argument " "3"" of type '" "int *""'"); } - arg3 = reinterpret_cast< int * >(argp3); { try { - (arg1)->SetIJ(arg2,arg3); + (arg1)->SetIJ(arg2,arg3,arg4); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -5067,99 +5031,38 @@ SWIGINTERN PyObject *_wrap_Table_SetIJ__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Table_SetIJ(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[5] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Table_SetIJ", 0, 4, argv))) SWIG_fail; - --argc; - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Table_SetIJ__SWIG_1(self, argc, argv); - } - } - } - } - if (argc == 4) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[3]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Table_SetIJ__SWIG_0(self, argc, argv); - } - } - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_SetIJ'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Table::SetIJ(int *,int *,int)\n" - " mfem::Table::SetIJ(int *,int *)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_Table_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "Table_Push", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_Push", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Push" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -5221,7 +5124,7 @@ SWIGINTERN PyObject *_wrap_Table_Finalize(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Table_MakeFromList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_MakeFromList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; @@ -5230,21 +5133,26 @@ SWIGINTERN PyObject *_wrap_Table_MakeFromList(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"nrows", (char *)"list", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_MakeFromList", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Table_MakeFromList", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_MakeFromList" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Connection_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__ArrayT_mfem__Connection_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Table_MakeFromList" "', argument " "3"" of type '" "mfem::Array< mfem::Connection > const &""'"); } @@ -5353,40 +5261,45 @@ SWIGINTERN PyObject *_wrap_Table_LoseData(PyObject *SWIGUNUSEDPARM(self), PyObje SWIGINTERN PyObject *_wrap_Table_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 4 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } + } + } + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } + } { try { ((mfem::Table const *)arg1)->Print(*arg2,arg3); @@ -5420,104 +5333,6 @@ SWIGINTERN PyObject *_wrap_Table_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - std::ostream *arg2 = 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table const *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } - { - try { - ((mfem::Table const *)arg1)->Print(*arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return resultobj; -fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table const *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - { - try { - ((mfem::Table const *)arg1)->Print(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - return resultobj; -fail: - return NULL; -} - - SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; @@ -5644,7 +5459,7 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; std::istream *arg2 = 0 ; @@ -5652,15 +5467,19 @@ SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"_in", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_Load", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_Load", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Load" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__istream, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__istream, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Load" "', argument " "2"" of type '" "std::istream &""'"); } @@ -5691,7 +5510,7 @@ SWIGINTERN PyObject *_wrap_Table_Load(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; mfem::Table *arg2 = 0 ; @@ -5699,15 +5518,19 @@ SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"copy", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_Copy", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_Copy", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Copy" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Copy" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -5738,7 +5561,7 @@ SWIGINTERN PyObject *_wrap_Table_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Table_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; mfem::Table *arg2 = 0 ; @@ -5746,15 +5569,19 @@ SWIGINTERN PyObject *_wrap_Table_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject * int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"other", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Table_Swap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_Swap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Swap" "', argument " "1"" of type '" "mfem::Table *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Table, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Table, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Swap" "', argument " "2"" of type '" "mfem::Table &""'"); } @@ -5897,26 +5724,30 @@ SWIGINTERN PyObject *_wrap_delete_Table(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Table_GetRowList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Table_GetRowList(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Table_GetRowList", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Table_GetRowList", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_GetRowList" "', argument " "1"" of type '" "mfem::Table const *""'"); } arg1 = reinterpret_cast< mfem::Table * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -5941,18 +5772,18 @@ SWIGINTERN PyObject *_wrap_Table_GetRowList(PyObject *SWIGUNUSEDPARM(self), PyOb } -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Table_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table *""'"); @@ -5963,61 +5794,17 @@ SWIGINTERN PyObject *_wrap_Table_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), P SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Table_Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Print" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Table_Print__SWIG_3(arg1,(char const *)arg2); + mfem_Table_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6048,34 +5835,15 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Table_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Table_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Table_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_Table_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -6086,19 +5854,9 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Table_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Table_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6108,27 +5866,23 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Table_Print__SWIG_3(self, argc, argv); + return _wrap_Table_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Table_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -6138,7 +5892,7 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Table_Print__SWIG_0(self, argc, argv); + return _wrap_Table_Print__SWIG_1(self, argc, argv); } } } @@ -6148,10 +5902,7 @@ SWIGINTERN PyObject *_wrap_Table_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Table::Print(std::ostream &,int) const\n" - " mfem::Table::Print(std::ostream &) const\n" - " mfem::Table::Print() const\n" - " mfem::Table::Print(char const *,int)\n" - " mfem::Table::Print(char const *)\n"); + " mfem::Table::Print(char const *,int)\n"); return 0; } @@ -6160,14 +5911,14 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(se PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_PrintMatlab" "', argument " "1"" of type '" "mfem::Table *""'"); @@ -6178,11 +5929,13 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(se SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -6209,61 +5962,15 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_1(PyObject *SWIGUNUSEDPARM(se } -SWIGINTERN PyObject *_wrap_Table_PrintMatlab__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_PrintMatlab" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_PrintMatlab" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Table_PrintMatlab__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[4] = { - 0 - }; +SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { + Py_ssize_t argc; + PyObject *argv[4] = { + 0 + }; if (!(argc = SWIG_Python_UnpackTuple(args, "Table_PrintMatlab", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); @@ -6272,7 +5979,20 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Table_PrintMatlab__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_Table_PrintMatlab__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Table_PrintMatlab__SWIG_1(self, argc, argv); + } } } } @@ -6296,36 +6016,12 @@ SWIGINTERN PyObject *_wrap_Table_PrintMatlab(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Table_PrintMatlab__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_PrintMatlab'.\n" " Possible C/C++ prototypes are:\n" " mfem::Table::PrintMatlab(std::ostream &) const\n" - " mfem::Table::PrintMatlab(char const *,int)\n" - " mfem::Table::PrintMatlab(char const *)\n"); + " mfem::Table::PrintMatlab(char const *,int)\n"); return 0; } @@ -6334,14 +6030,14 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Save" "', argument " "1"" of type '" "mfem::Table *""'"); @@ -6352,11 +6048,13 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Save" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -6384,52 +6082,6 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py SWIGINTERN PyObject *_wrap_Table_Save__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Table *arg1 = (mfem::Table *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Table, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Table_Save" "', argument " "1"" of type '" "mfem::Table *""'"); - } - arg1 = reinterpret_cast< mfem::Table * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Table_Save" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Table_Save__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Table_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Table *arg1 = (mfem::Table *) 0 ; void *argp1 = 0 ; @@ -6443,7 +6095,7 @@ SWIGINTERN PyObject *_wrap_Table_Save__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py arg1 = reinterpret_cast< mfem::Table * >(argp1); { try { - mfem_Table_Save__SWIG_3(arg1); + mfem_Table_Save__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6478,10 +6130,10 @@ SWIGINTERN PyObject *_wrap_Table_Save(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Table_Save__SWIG_3(self, argc, argv); + return _wrap_Table_Save__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); @@ -6490,7 +6142,20 @@ SWIGINTERN PyObject *_wrap_Table_Save(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Table_Save__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_Table_Save__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Table_Save__SWIG_1(self, argc, argv); + } } } } @@ -6514,36 +6179,12 @@ SWIGINTERN PyObject *_wrap_Table_Save(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Table, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Table_Save__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Table_Save'.\n" " Possible C/C++ prototypes are:\n" " mfem::Table::Save(std::ostream &) const\n" " mfem::Table::Save(char const *,int)\n" - " mfem::Table::Save(char const *)\n" " mfem::Table::Save()\n"); return 0; } @@ -6560,63 +6201,35 @@ SWIGINTERN PyObject *Table_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *ar return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_STable__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_new_STable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - int arg2 ; + int arg2 = (int) 3 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"dim", (char *)"connections_per_row", NULL + }; mfem::STable *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_STable", kwnames, &obj0, &obj1)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } - { - try { - result = (mfem::STable *)new mfem::STable(arg1,arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mfem__STable, SWIG_POINTER_NEW | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_new_STable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - int arg1 ; - mfem::STable *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); } { try { - result = (mfem::STable *)new mfem::STable(arg1); + result = (mfem::STable *)new mfem::STable(arg1,arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -6637,89 +6250,38 @@ SWIGINTERN PyObject *_wrap_new_STable__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_new_STable(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "new_STable", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_STable__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - { - if ((PyArray_PyIntAsInt(argv[0]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_new_STable__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_STable'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::STable::STable(int,int)\n" - " mfem::STable::STable(int)\n"); - return 0; -} - - -SWIGINTERN PyObject *_wrap_STable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable *arg1 = (mfem::STable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:STable___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable___call__" "', argument " "1"" of type '" "mfem::STable const *""'"); } arg1 = reinterpret_cast< mfem::STable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -6744,33 +6306,38 @@ SWIGINTERN PyObject *_wrap_STable___call__(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_STable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_STable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::STable *arg1 = (mfem::STable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"j", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "STable_Push", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:STable_Push", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__STable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "STable_Push" "', argument " "1"" of type '" "mfem::STable *""'"); } arg1 = reinterpret_cast< mfem::STable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -6843,19 +6410,21 @@ SWIGINTERN PyObject *STable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_new_DSTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_new_DSTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; int arg1 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"nrows", NULL + }; mfem::DSTable *result = 0 ; - if (!args) SWIG_fail; - swig_obj[0] = args; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_DSTable", kwnames, &obj0)) SWIG_fail; { - if ((PyArray_PyIntAsInt(swig_obj[0]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj0) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg1 = PyArray_PyIntAsInt(swig_obj[0]); + arg1 = PyArray_PyIntAsInt(obj0); } { try { @@ -6956,33 +6525,38 @@ SWIGINTERN PyObject *_wrap_DSTable_NumberOfEntries(PyObject *SWIGUNUSEDPARM(self } -SWIGINTERN PyObject *_wrap_DSTable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DSTable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DSTable *arg1 = (mfem::DSTable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"b", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "DSTable_Push", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DSTable_Push", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DSTable_Push" "', argument " "1"" of type '" "mfem::DSTable *""'"); } arg1 = reinterpret_cast< mfem::DSTable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -7007,33 +6581,38 @@ SWIGINTERN PyObject *_wrap_DSTable_Push(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_DSTable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DSTable___call__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::DSTable *arg1 = (mfem::DSTable *) 0 ; int arg2 ; int arg3 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"b", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "DSTable___call__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DSTable___call__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__DSTable, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DSTable___call__" "', argument " "1"" of type '" "mfem::DSTable const *""'"); } arg1 = reinterpret_cast< mfem::DSTable * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -7117,8 +6696,8 @@ static PyMethodDef SwigMethods[] = { "Connection()\n" "new_Connection(int _from, int to) -> Connection\n" ""}, - { "Connection___eq__", _wrap_Connection___eq__, METH_VARARGS, "Connection___eq__(Connection self, Connection rhs) -> bool"}, - { "Connection___lt__", _wrap_Connection___lt__, METH_VARARGS, "Connection___lt__(Connection self, Connection rhs) -> bool"}, + { "Connection___eq__", (PyCFunction)(void(*)(void))_wrap_Connection___eq__, METH_VARARGS|METH_KEYWORDS, "Connection___eq__(Connection self, Connection rhs) -> bool"}, + { "Connection___lt__", (PyCFunction)(void(*)(void))_wrap_Connection___lt__, METH_VARARGS|METH_KEYWORDS, "Connection___lt__(Connection self, Connection rhs) -> bool"}, { "delete_Connection", _wrap_delete_Connection, METH_O, "delete_Connection(Connection self)"}, { "Connection_swigregister", Connection_swigregister, METH_O, NULL}, { "Connection_swiginit", Connection_swiginit, METH_VARARGS, NULL}, @@ -7129,19 +6708,19 @@ static PyMethodDef SwigMethods[] = { "Table(int nrows, mfem::Array< mfem::Connection > & list)\n" "new_Table(int nrows, int * partitioning) -> Table\n" ""}, - { "Table_MakeI", _wrap_Table_MakeI, METH_VARARGS, "Table_MakeI(Table self, int nrows)"}, - { "Table_AddAColumnInRow", _wrap_Table_AddAColumnInRow, METH_VARARGS, "Table_AddAColumnInRow(Table self, int r)"}, - { "Table_AddColumnsInRow", _wrap_Table_AddColumnsInRow, METH_VARARGS, "Table_AddColumnsInRow(Table self, int r, int ncol)"}, + { "Table_MakeI", (PyCFunction)(void(*)(void))_wrap_Table_MakeI, METH_VARARGS|METH_KEYWORDS, "Table_MakeI(Table self, int nrows)"}, + { "Table_AddAColumnInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddAColumnInRow, METH_VARARGS|METH_KEYWORDS, "Table_AddAColumnInRow(Table self, int r)"}, + { "Table_AddColumnsInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddColumnsInRow, METH_VARARGS|METH_KEYWORDS, "Table_AddColumnsInRow(Table self, int r, int ncol)"}, { "Table_MakeJ", _wrap_Table_MakeJ, METH_O, "Table_MakeJ(Table self)"}, - { "Table_AddConnection", _wrap_Table_AddConnection, METH_VARARGS, "Table_AddConnection(Table self, int r, int c)"}, - { "Table_AddConnections", _wrap_Table_AddConnections, METH_VARARGS, "Table_AddConnections(Table self, int r, int const * c, int nc)"}, + { "Table_AddConnection", (PyCFunction)(void(*)(void))_wrap_Table_AddConnection, METH_VARARGS|METH_KEYWORDS, "Table_AddConnection(Table self, int r, int c)"}, + { "Table_AddConnections", (PyCFunction)(void(*)(void))_wrap_Table_AddConnections, METH_VARARGS|METH_KEYWORDS, "Table_AddConnections(Table self, int r, int const * c, int nc)"}, { "Table_ShiftUpI", _wrap_Table_ShiftUpI, METH_O, "Table_ShiftUpI(Table self)"}, - { "Table_SetSize", _wrap_Table_SetSize, METH_VARARGS, "Table_SetSize(Table self, int dim, int connections_per_row)"}, - { "Table_SetDims", _wrap_Table_SetDims, METH_VARARGS, "Table_SetDims(Table self, int rows, int nnz)"}, + { "Table_SetSize", (PyCFunction)(void(*)(void))_wrap_Table_SetSize, METH_VARARGS|METH_KEYWORDS, "Table_SetSize(Table self, int dim, int connections_per_row)"}, + { "Table_SetDims", (PyCFunction)(void(*)(void))_wrap_Table_SetDims, METH_VARARGS|METH_KEYWORDS, "Table_SetDims(Table self, int rows, int nnz)"}, { "Table_Size", _wrap_Table_Size, METH_O, "Table_Size(Table self) -> int"}, { "Table_Size_of_connections", _wrap_Table_Size_of_connections, METH_O, "Table_Size_of_connections(Table self) -> int"}, - { "Table___call__", _wrap_Table___call__, METH_VARARGS, "Table___call__(Table self, int i, int j) -> int"}, - { "Table_RowSize", _wrap_Table_RowSize, METH_VARARGS, "Table_RowSize(Table self, int i) -> int"}, + { "Table___call__", (PyCFunction)(void(*)(void))_wrap_Table___call__, METH_VARARGS|METH_KEYWORDS, "Table___call__(Table self, int i, int j) -> int"}, + { "Table_RowSize", (PyCFunction)(void(*)(void))_wrap_Table_RowSize, METH_VARARGS|METH_KEYWORDS, "Table_RowSize(Table self, int i) -> int"}, { "Table_GetRow", _wrap_Table_GetRow, METH_VARARGS, "\n" "Table_GetRow(Table self, int i, intArray row)\n" "Table_GetRow(Table self, int i) -> int const\n" @@ -7164,19 +6743,19 @@ static PyMethodDef SwigMethods[] = { "Table_GetJMemory(Table self) -> mfem::Memory< int > const &\n" ""}, { "Table_SortRows", _wrap_Table_SortRows, METH_O, "Table_SortRows(Table self)"}, - { "Table_SetIJ", _wrap_Table_SetIJ, METH_VARARGS, "Table_SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, - { "Table_Push", _wrap_Table_Push, METH_VARARGS, "Table_Push(Table self, int i, int j) -> int"}, + { "Table_SetIJ", (PyCFunction)(void(*)(void))_wrap_Table_SetIJ, METH_VARARGS|METH_KEYWORDS, "Table_SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, + { "Table_Push", (PyCFunction)(void(*)(void))_wrap_Table_Push, METH_VARARGS|METH_KEYWORDS, "Table_Push(Table self, int i, int j) -> int"}, { "Table_Finalize", _wrap_Table_Finalize, METH_O, "Table_Finalize(Table self)"}, - { "Table_MakeFromList", _wrap_Table_MakeFromList, METH_VARARGS, "Table_MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, + { "Table_MakeFromList", (PyCFunction)(void(*)(void))_wrap_Table_MakeFromList, METH_VARARGS|METH_KEYWORDS, "Table_MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, { "Table_Width", _wrap_Table_Width, METH_O, "Table_Width(Table self) -> int"}, { "Table_LoseData", _wrap_Table_LoseData, METH_O, "Table_LoseData(Table self)"}, - { "Table_Load", _wrap_Table_Load, METH_VARARGS, "Table_Load(Table self, std::istream & _in)"}, - { "Table_Copy", _wrap_Table_Copy, METH_VARARGS, "Table_Copy(Table self, Table copy)"}, - { "Table_Swap", _wrap_Table_Swap, METH_VARARGS, "Table_Swap(Table self, Table other)"}, + { "Table_Load", (PyCFunction)(void(*)(void))_wrap_Table_Load, METH_VARARGS|METH_KEYWORDS, "Table_Load(Table self, std::istream & _in)"}, + { "Table_Copy", (PyCFunction)(void(*)(void))_wrap_Table_Copy, METH_VARARGS|METH_KEYWORDS, "Table_Copy(Table self, Table copy)"}, + { "Table_Swap", (PyCFunction)(void(*)(void))_wrap_Table_Swap, METH_VARARGS|METH_KEYWORDS, "Table_Swap(Table self, Table other)"}, { "Table_Clear", _wrap_Table_Clear, METH_O, "Table_Clear(Table self)"}, { "Table_MemoryUsage", _wrap_Table_MemoryUsage, METH_O, "Table_MemoryUsage(Table self) -> long"}, { "delete_Table", _wrap_delete_Table, METH_O, "delete_Table(Table self)"}, - { "Table_GetRowList", _wrap_Table_GetRowList, METH_VARARGS, "Table_GetRowList(Table self, int i) -> PyObject *"}, + { "Table_GetRowList", (PyCFunction)(void(*)(void))_wrap_Table_GetRowList, METH_VARARGS|METH_KEYWORDS, "Table_GetRowList(Table self, int i) -> PyObject *"}, { "Table_Print", _wrap_Table_Print, METH_VARARGS, "\n" "Table_Print(Table self, std::ostream & out=mfem::out, int width=4)\n" "Table_Print(Table self, char const * file, int precision=8)\n" @@ -7192,17 +6771,17 @@ static PyMethodDef SwigMethods[] = { ""}, { "Table_swigregister", Table_swigregister, METH_O, NULL}, { "Table_swiginit", Table_swiginit, METH_VARARGS, NULL}, - { "new_STable", _wrap_new_STable, METH_VARARGS, "STable(int dim, int connections_per_row=3)"}, - { "STable___call__", _wrap_STable___call__, METH_VARARGS, "STable___call__(STable self, int i, int j) -> int"}, - { "STable_Push", _wrap_STable_Push, METH_VARARGS, "STable_Push(STable self, int i, int j) -> int"}, + { "new_STable", (PyCFunction)(void(*)(void))_wrap_new_STable, METH_VARARGS|METH_KEYWORDS, "new_STable(int dim, int connections_per_row=3) -> STable"}, + { "STable___call__", (PyCFunction)(void(*)(void))_wrap_STable___call__, METH_VARARGS|METH_KEYWORDS, "STable___call__(STable self, int i, int j) -> int"}, + { "STable_Push", (PyCFunction)(void(*)(void))_wrap_STable_Push, METH_VARARGS|METH_KEYWORDS, "STable_Push(STable self, int i, int j) -> int"}, { "delete_STable", _wrap_delete_STable, METH_O, "delete_STable(STable self)"}, { "STable_swigregister", STable_swigregister, METH_O, NULL}, { "STable_swiginit", STable_swiginit, METH_VARARGS, NULL}, - { "new_DSTable", _wrap_new_DSTable, METH_O, "new_DSTable(int nrows) -> DSTable"}, + { "new_DSTable", (PyCFunction)(void(*)(void))_wrap_new_DSTable, METH_VARARGS|METH_KEYWORDS, "new_DSTable(int nrows) -> DSTable"}, { "DSTable_NumberOfRows", _wrap_DSTable_NumberOfRows, METH_O, "DSTable_NumberOfRows(DSTable self) -> int"}, { "DSTable_NumberOfEntries", _wrap_DSTable_NumberOfEntries, METH_O, "DSTable_NumberOfEntries(DSTable self) -> int"}, - { "DSTable_Push", _wrap_DSTable_Push, METH_VARARGS, "DSTable_Push(DSTable self, int a, int b) -> int"}, - { "DSTable___call__", _wrap_DSTable___call__, METH_VARARGS, "DSTable___call__(DSTable self, int a, int b) -> int"}, + { "DSTable_Push", (PyCFunction)(void(*)(void))_wrap_DSTable_Push, METH_VARARGS|METH_KEYWORDS, "DSTable_Push(DSTable self, int a, int b) -> int"}, + { "DSTable___call__", (PyCFunction)(void(*)(void))_wrap_DSTable___call__, METH_VARARGS|METH_KEYWORDS, "DSTable___call__(DSTable self, int a, int b) -> int"}, { "delete_DSTable", _wrap_delete_DSTable, METH_O, "delete_DSTable(DSTable self)"}, { "DSTable_swigregister", DSTable_swigregister, METH_O, NULL}, { "DSTable_swiginit", DSTable_swiginit, METH_VARARGS, NULL}, @@ -7220,8 +6799,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Connection()\n" "new_Connection(int _from, int to) -> Connection\n" ""}, - { "Connection___eq__", _wrap_Connection___eq__, METH_VARARGS, "__eq__(Connection self, Connection rhs) -> bool"}, - { "Connection___lt__", _wrap_Connection___lt__, METH_VARARGS, "__lt__(Connection self, Connection rhs) -> bool"}, + { "Connection___eq__", (PyCFunction)(void(*)(void))_wrap_Connection___eq__, METH_VARARGS|METH_KEYWORDS, "__eq__(Connection self, Connection rhs) -> bool"}, + { "Connection___lt__", (PyCFunction)(void(*)(void))_wrap_Connection___lt__, METH_VARARGS|METH_KEYWORDS, "__lt__(Connection self, Connection rhs) -> bool"}, { "delete_Connection", _wrap_delete_Connection, METH_O, "delete_Connection(Connection self)"}, { "Connection_swigregister", Connection_swigregister, METH_O, NULL}, { "Connection_swiginit", Connection_swiginit, METH_VARARGS, NULL}, @@ -7232,19 +6811,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Table(int nrows, mfem::Array< mfem::Connection > & list)\n" "new_Table(int nrows, int * partitioning) -> Table\n" ""}, - { "Table_MakeI", _wrap_Table_MakeI, METH_VARARGS, "MakeI(Table self, int nrows)"}, - { "Table_AddAColumnInRow", _wrap_Table_AddAColumnInRow, METH_VARARGS, "AddAColumnInRow(Table self, int r)"}, - { "Table_AddColumnsInRow", _wrap_Table_AddColumnsInRow, METH_VARARGS, "AddColumnsInRow(Table self, int r, int ncol)"}, + { "Table_MakeI", (PyCFunction)(void(*)(void))_wrap_Table_MakeI, METH_VARARGS|METH_KEYWORDS, "MakeI(Table self, int nrows)"}, + { "Table_AddAColumnInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddAColumnInRow, METH_VARARGS|METH_KEYWORDS, "AddAColumnInRow(Table self, int r)"}, + { "Table_AddColumnsInRow", (PyCFunction)(void(*)(void))_wrap_Table_AddColumnsInRow, METH_VARARGS|METH_KEYWORDS, "AddColumnsInRow(Table self, int r, int ncol)"}, { "Table_MakeJ", _wrap_Table_MakeJ, METH_O, "MakeJ(Table self)"}, - { "Table_AddConnection", _wrap_Table_AddConnection, METH_VARARGS, "AddConnection(Table self, int r, int c)"}, - { "Table_AddConnections", _wrap_Table_AddConnections, METH_VARARGS, "AddConnections(Table self, int r, int const * c, int nc)"}, + { "Table_AddConnection", (PyCFunction)(void(*)(void))_wrap_Table_AddConnection, METH_VARARGS|METH_KEYWORDS, "AddConnection(Table self, int r, int c)"}, + { "Table_AddConnections", (PyCFunction)(void(*)(void))_wrap_Table_AddConnections, METH_VARARGS|METH_KEYWORDS, "AddConnections(Table self, int r, int const * c, int nc)"}, { "Table_ShiftUpI", _wrap_Table_ShiftUpI, METH_O, "ShiftUpI(Table self)"}, - { "Table_SetSize", _wrap_Table_SetSize, METH_VARARGS, "SetSize(Table self, int dim, int connections_per_row)"}, - { "Table_SetDims", _wrap_Table_SetDims, METH_VARARGS, "SetDims(Table self, int rows, int nnz)"}, + { "Table_SetSize", (PyCFunction)(void(*)(void))_wrap_Table_SetSize, METH_VARARGS|METH_KEYWORDS, "SetSize(Table self, int dim, int connections_per_row)"}, + { "Table_SetDims", (PyCFunction)(void(*)(void))_wrap_Table_SetDims, METH_VARARGS|METH_KEYWORDS, "SetDims(Table self, int rows, int nnz)"}, { "Table_Size", _wrap_Table_Size, METH_O, "Size(Table self) -> int"}, { "Table_Size_of_connections", _wrap_Table_Size_of_connections, METH_O, "Size_of_connections(Table self) -> int"}, - { "Table___call__", _wrap_Table___call__, METH_VARARGS, "__call__(Table self, int i, int j) -> int"}, - { "Table_RowSize", _wrap_Table_RowSize, METH_VARARGS, "RowSize(Table self, int i) -> int"}, + { "Table___call__", (PyCFunction)(void(*)(void))_wrap_Table___call__, METH_VARARGS|METH_KEYWORDS, "__call__(Table self, int i, int j) -> int"}, + { "Table_RowSize", (PyCFunction)(void(*)(void))_wrap_Table_RowSize, METH_VARARGS|METH_KEYWORDS, "RowSize(Table self, int i) -> int"}, { "Table_GetRow", _wrap_Table_GetRow, METH_VARARGS, "\n" "GetRow(Table self, int i, intArray row)\n" "GetRow(Table self, int i) -> int const\n" @@ -7267,19 +6846,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetJMemory(Table self) -> mfem::Memory< int > const &\n" ""}, { "Table_SortRows", _wrap_Table_SortRows, METH_O, "SortRows(Table self)"}, - { "Table_SetIJ", _wrap_Table_SetIJ, METH_VARARGS, "SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, - { "Table_Push", _wrap_Table_Push, METH_VARARGS, "Push(Table self, int i, int j) -> int"}, + { "Table_SetIJ", (PyCFunction)(void(*)(void))_wrap_Table_SetIJ, METH_VARARGS|METH_KEYWORDS, "SetIJ(Table self, int * newI, int * newJ, int newsize=-1)"}, + { "Table_Push", (PyCFunction)(void(*)(void))_wrap_Table_Push, METH_VARARGS|METH_KEYWORDS, "Push(Table self, int i, int j) -> int"}, { "Table_Finalize", _wrap_Table_Finalize, METH_O, "Finalize(Table self)"}, - { "Table_MakeFromList", _wrap_Table_MakeFromList, METH_VARARGS, "MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, + { "Table_MakeFromList", (PyCFunction)(void(*)(void))_wrap_Table_MakeFromList, METH_VARARGS|METH_KEYWORDS, "MakeFromList(Table self, int nrows, mfem::Array< mfem::Connection > const & list)"}, { "Table_Width", _wrap_Table_Width, METH_O, "Width(Table self) -> int"}, { "Table_LoseData", _wrap_Table_LoseData, METH_O, "LoseData(Table self)"}, - { "Table_Load", _wrap_Table_Load, METH_VARARGS, "Load(Table self, std::istream & _in)"}, - { "Table_Copy", _wrap_Table_Copy, METH_VARARGS, "Copy(Table self, Table copy)"}, - { "Table_Swap", _wrap_Table_Swap, METH_VARARGS, "Swap(Table self, Table other)"}, + { "Table_Load", (PyCFunction)(void(*)(void))_wrap_Table_Load, METH_VARARGS|METH_KEYWORDS, "Load(Table self, std::istream & _in)"}, + { "Table_Copy", (PyCFunction)(void(*)(void))_wrap_Table_Copy, METH_VARARGS|METH_KEYWORDS, "Copy(Table self, Table copy)"}, + { "Table_Swap", (PyCFunction)(void(*)(void))_wrap_Table_Swap, METH_VARARGS|METH_KEYWORDS, "Swap(Table self, Table other)"}, { "Table_Clear", _wrap_Table_Clear, METH_O, "Clear(Table self)"}, { "Table_MemoryUsage", _wrap_Table_MemoryUsage, METH_O, "MemoryUsage(Table self) -> long"}, { "delete_Table", _wrap_delete_Table, METH_O, "delete_Table(Table self)"}, - { "Table_GetRowList", _wrap_Table_GetRowList, METH_VARARGS, "GetRowList(Table self, int i) -> PyObject *"}, + { "Table_GetRowList", (PyCFunction)(void(*)(void))_wrap_Table_GetRowList, METH_VARARGS|METH_KEYWORDS, "GetRowList(Table self, int i) -> PyObject *"}, { "Table_Print", _wrap_Table_Print, METH_VARARGS, "\n" "Print(Table self, std::ostream & out=mfem::out, int width=4)\n" "Print(Table self, char const * file, int precision=8)\n" @@ -7295,17 +6874,17 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Table_swigregister", Table_swigregister, METH_O, NULL}, { "Table_swiginit", Table_swiginit, METH_VARARGS, NULL}, - { "new_STable", _wrap_new_STable, METH_VARARGS, "STable(int dim, int connections_per_row=3)"}, - { "STable___call__", _wrap_STable___call__, METH_VARARGS, "__call__(STable self, int i, int j) -> int"}, - { "STable_Push", _wrap_STable_Push, METH_VARARGS, "Push(STable self, int i, int j) -> int"}, + { "new_STable", (PyCFunction)(void(*)(void))_wrap_new_STable, METH_VARARGS|METH_KEYWORDS, "new_STable(int dim, int connections_per_row=3) -> STable"}, + { "STable___call__", (PyCFunction)(void(*)(void))_wrap_STable___call__, METH_VARARGS|METH_KEYWORDS, "__call__(STable self, int i, int j) -> int"}, + { "STable_Push", (PyCFunction)(void(*)(void))_wrap_STable_Push, METH_VARARGS|METH_KEYWORDS, "Push(STable self, int i, int j) -> int"}, { "delete_STable", _wrap_delete_STable, METH_O, "delete_STable(STable self)"}, { "STable_swigregister", STable_swigregister, METH_O, NULL}, { "STable_swiginit", STable_swiginit, METH_VARARGS, NULL}, - { "new_DSTable", _wrap_new_DSTable, METH_O, "new_DSTable(int nrows) -> DSTable"}, + { "new_DSTable", (PyCFunction)(void(*)(void))_wrap_new_DSTable, METH_VARARGS|METH_KEYWORDS, "new_DSTable(int nrows) -> DSTable"}, { "DSTable_NumberOfRows", _wrap_DSTable_NumberOfRows, METH_O, "NumberOfRows(DSTable self) -> int"}, { "DSTable_NumberOfEntries", _wrap_DSTable_NumberOfEntries, METH_O, "NumberOfEntries(DSTable self) -> int"}, - { "DSTable_Push", _wrap_DSTable_Push, METH_VARARGS, "Push(DSTable self, int a, int b) -> int"}, - { "DSTable___call__", _wrap_DSTable___call__, METH_VARARGS, "__call__(DSTable self, int a, int b) -> int"}, + { "DSTable_Push", (PyCFunction)(void(*)(void))_wrap_DSTable_Push, METH_VARARGS|METH_KEYWORDS, "Push(DSTable self, int a, int b) -> int"}, + { "DSTable___call__", (PyCFunction)(void(*)(void))_wrap_DSTable___call__, METH_VARARGS|METH_KEYWORDS, "__call__(DSTable self, int a, int b) -> int"}, { "delete_DSTable", _wrap_delete_DSTable, METH_O, "delete_DSTable(DSTable self)"}, { "DSTable_swigregister", DSTable_swigregister, METH_O, NULL}, { "DSTable_swiginit", DSTable_swiginit, METH_VARARGS, NULL}, diff --git a/mfem/_ser/vector.py b/mfem/_ser/vector.py index dccfbfa4..945b0664 100644 --- a/mfem/_ser/vector.py +++ b/mfem/_ser/vector.py @@ -384,7 +384,7 @@ def CheckFinite(self): __swig_destroy__ = _vector.delete_Vector def Read(self, on_dev=True): - r"""Read(Vector self, bool on_dev=True) -> double const""" + r"""Read(Vector self, bool on_dev=True) -> double const *""" return _vector.Vector_Read(self, on_dev) Read = _swig_new_instance_method(_vector.Vector_Read) @@ -394,7 +394,7 @@ def HostRead(self): HostRead = _swig_new_instance_method(_vector.Vector_HostRead) def Write(self, on_dev=True): - r"""Write(Vector self, bool on_dev=True) -> double""" + r"""Write(Vector self, bool on_dev=True) -> double *""" return _vector.Vector_Write(self, on_dev) Write = _swig_new_instance_method(_vector.Vector_Write) @@ -404,7 +404,7 @@ def HostWrite(self): HostWrite = _swig_new_instance_method(_vector.Vector_HostWrite) def ReadWrite(self, on_dev=True): - r"""ReadWrite(Vector self, bool on_dev=True) -> double""" + r"""ReadWrite(Vector self, bool on_dev=True) -> double *""" return _vector.Vector_ReadWrite(self, on_dev) ReadWrite = _swig_new_instance_method(_vector.Vector_ReadWrite) diff --git a/mfem/_ser/vector_wrap.cxx b/mfem/_ser/vector_wrap.cxx index 5c971562..5086707e 100644 --- a/mfem/_ser/vector_wrap.cxx +++ b/mfem/_ser/vector_wrap.cxx @@ -3217,7 +3217,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc) -SWIGINTERN void mfem_Vector_Print__SWIG_3(mfem::Vector *self,char const *file,int precision=8){ +SWIGINTERN void mfem_Vector_Print__SWIG_1(mfem::Vector *self,char const *file,int precision=8){ std::ofstream ofile(file); if (!ofile) { @@ -3239,7 +3239,7 @@ SWIGINTERN void mfem_Vector_Print_HYPRE__SWIG_1(mfem::Vector *self,char const *f self -> Print_HYPRE(ofile); ofile.close(); } -SWIGINTERN void mfem_Vector_Print_HYPRE__SWIG_3(mfem::Vector *self){ +SWIGINTERN void mfem_Vector_Print_HYPRE__SWIG_2(mfem::Vector *self){ self -> Print_HYPRE(std::cout); } #ifdef __cplusplus @@ -3815,26 +3815,30 @@ SWIGINTERN PyObject *_wrap_subtract_vector(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_CheckFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CheckFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; int arg2 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"v", (char *)"n", NULL + }; int result; - if (!SWIG_Python_UnpackTuple(args, "CheckFinite", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CheckFinite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CheckFinite" "', argument " "1"" of type '" "double const *""'"); } arg1 = reinterpret_cast< double * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } { try { @@ -4694,7 +4698,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetSize(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -4702,15 +4706,19 @@ SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObje int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetData", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_SetData", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetData" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetData" "', argument " "2"" of type '" "double *""'"); } @@ -4738,7 +4746,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetData(PyObject *SWIGUNUSEDPARM(self), PyObje } -SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -4747,24 +4755,29 @@ SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetDataAndSize", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_SetDataAndSize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetDataAndSize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetDataAndSize" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4789,7 +4802,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetDataAndSize(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -4798,24 +4811,29 @@ SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"d", (char *)"s", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_NewDataAndSize", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_NewDataAndSize", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_NewDataAndSize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_NewDataAndSize" "', argument " "2"" of type '" "double *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -4840,7 +4858,7 @@ SWIGINTERN PyObject *_wrap_Vector_NewDataAndSize(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Memory< double > *arg2 = 0 ; @@ -4852,15 +4870,21 @@ SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self int res2 = 0 ; bool val4 ; int ecode4 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"mem", (char *)"s", (char *)"own_mem", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_NewMemoryAndSize", 4, 4, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Vector_NewMemoryAndSize", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_NewMemoryAndSize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__MemoryT_double_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_NewMemoryAndSize" "', argument " "2"" of type '" "mfem::Memory< double > const &""'"); } @@ -4869,12 +4893,12 @@ SWIGINTERN PyObject *_wrap_Vector_NewMemoryAndSize(PyObject *SWIGUNUSEDPARM(self } arg2 = reinterpret_cast< mfem::Memory< double > * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } - ecode4 = SWIG_AsVal_bool(swig_obj[3], &val4); + ecode4 = SWIG_AsVal_bool(obj3, &val4); if (!SWIG_IsOK(ecode4)) { SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Vector_NewMemoryAndSize" "', argument " "4"" of type '" "bool""'"); } @@ -5387,7 +5411,7 @@ SWIGINTERN PyObject *_wrap_Vector_GetMemory(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5395,15 +5419,19 @@ SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SyncMemory", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_SyncMemory", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SyncMemory" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SyncMemory" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -5434,7 +5462,7 @@ SWIGINTERN PyObject *_wrap_Vector_SyncMemory(PyObject *SWIGUNUSEDPARM(self), PyO } -SWIGINTERN PyObject *_wrap_Vector_SyncAliasMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SyncAliasMemory(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -5442,15 +5470,19 @@ SWIGINTERN PyObject *_wrap_Vector_SyncAliasMemory(PyObject *SWIGUNUSEDPARM(self) int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SyncAliasMemory", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_SyncAliasMemory", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SyncAliasMemory" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SyncAliasMemory" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6060,7 +6092,7 @@ SWIGINTERN PyObject *_wrap_Vector___mul__(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6068,16 +6100,20 @@ SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___imul__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___imul__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___imul__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___imul__" "', argument " "2"" of type '" "double""'"); } @@ -6105,7 +6141,7 @@ SWIGINTERN PyObject *_wrap_Vector___imul__(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector___itruediv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___itruediv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6113,16 +6149,20 @@ SWIGINTERN PyObject *_wrap_Vector___itruediv__(PyObject *SWIGUNUSEDPARM(self), P int res1 = 0 ; double val2 ; int ecode2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"c", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___itruediv__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___itruediv__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___itruediv__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector___itruediv__" "', argument " "2"" of type '" "double""'"); } @@ -6287,7 +6327,7 @@ SWIGINTERN PyObject *_wrap_Vector___isub__(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6295,16 +6335,20 @@ SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___iadd__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___iadd__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, SWIG_POINTER_DISOWN | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___iadd__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector___iadd__" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6335,7 +6379,7 @@ SWIGINTERN PyObject *_wrap_Vector___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6346,21 +6390,26 @@ SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject * int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"Va", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector_Add", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_Add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Add" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Add" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_Add" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -6391,7 +6440,7 @@ SWIGINTERN PyObject *_wrap_Vector_Add(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double arg2 ; @@ -6402,21 +6451,26 @@ SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject * int ecode2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"a", (char *)"x", NULL + }; mfem::Vector *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector_Set", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Set" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_double(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Set" "', argument " "2"" of type '" "double""'"); } arg2 = static_cast< double >(val2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_Set" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -6447,7 +6501,7 @@ SWIGINTERN PyObject *_wrap_Vector_Set(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6456,15 +6510,20 @@ SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyOb int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"v", (char *)"offset", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetVector", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_SetVector", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetVector" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetVector" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6473,10 +6532,10 @@ SWIGINTERN PyObject *_wrap_Vector_SetVector(PyObject *SWIGUNUSEDPARM(self), PyOb } arg2 = reinterpret_cast< mfem::Vector * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -6538,7 +6597,7 @@ SWIGINTERN PyObject *_wrap_Vector_Neg(PyObject *SWIGUNUSEDPARM(self), PyObject * } -SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6546,15 +6605,19 @@ SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"other", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_Swap", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_Swap", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Swap" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Swap" "', argument " "2"" of type '" "mfem::Vector &""'"); } @@ -6585,7 +6648,7 @@ SWIGINTERN PyObject *_wrap_Vector_Swap(PyObject *SWIGUNUSEDPARM(self), PyObject } -SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Vector *arg2 = 0 ; @@ -6596,15 +6659,20 @@ SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObjec int res2 = 0 ; void *argp3 = 0 ; int res3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"lo", (char *)"hi", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_median", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_median", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_median" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_median" "', argument " "2"" of type '" "mfem::Vector const &""'"); } @@ -6612,7 +6680,7 @@ SWIGINTERN PyObject *_wrap_Vector_median(PyObject *SWIGUNUSEDPARM(self), PyObjec SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_median" "', argument " "2"" of type '" "mfem::Vector const &""'"); } arg2 = reinterpret_cast< mfem::Vector * >(argp2); - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_mfem__Vector, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Vector_median" "', argument " "3"" of type '" "mfem::Vector const &""'"); } @@ -7299,7 +7367,7 @@ SWIGINTERN PyObject *_wrap_Vector_AddElementVector(PyObject *self, PyObject *arg } -SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; mfem::Array< int > *arg2 = 0 ; @@ -7310,15 +7378,20 @@ SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPAR int res2 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"dofs", (char *)"val", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector_SetSubVectorComplement", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector_SetSubVectorComplement", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_SetSubVectorComplement" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); + res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_mfem__ArrayT_int_t, 0 | 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_SetSubVectorComplement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } @@ -7326,7 +7399,7 @@ SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPAR SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Vector_SetSubVectorComplement" "', argument " "2"" of type '" "mfem::Array< int > const &""'"); } arg2 = reinterpret_cast< mfem::Array< int > * >(argp2); - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector_SetSubVectorComplement" "', argument " "3"" of type '" "double""'"); } @@ -7357,39 +7430,44 @@ SWIGINTERN PyObject *_wrap_Vector_SetSubVectorComplement(PyObject *SWIGUNUSEDPAR SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - std::ostream *arg2 = 0 ; - int arg3 ; + std::ostream &arg2_defvalue = mfem::out ; + std::ostream *arg2 = (std::ostream *) &arg2_defvalue ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; PyMFEM::wFILE *temp2 = 0 ; std::ofstream out2 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 1) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; + if (swig_obj[1]) { + { + if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + SWIG_exception(SWIG_ValueError,"io_stream object is expected."); + return NULL; + } + + if (temp2->isSTDOUT() == 1) { + arg2 = &std::cout; + } + else { + out2.open(temp2->getFilename()); + out2.precision(temp2->getPrecision()); + arg2 = &out2; + } } } - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -7424,7 +7502,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_0(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; std::ostream *arg2 = 0 ; @@ -7436,7 +7514,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { @@ -7456,7 +7534,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } { try { - ((mfem::Vector const *)arg1)->Print(*arg2); + ((mfem::Vector const *)arg1)->Print_HYPRE(*arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7487,21 +7565,35 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Randomize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; + int arg2 = (int) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"seed", NULL + }; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_Randomize", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Randomize" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); + if (obj1) { + { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg2 = PyArray_PyIntAsInt(obj1); + } + } { try { - ((mfem::Vector const *)arg1)->Print(); + (arg1)->Randomize(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7522,39 +7614,24 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_2(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - std::ostream *arg2 = 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyMFEM::wFILE *temp2 = 0 ; - std::ofstream out2 ; + PyObject *swig_obj[1] ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml2" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - if (SWIG_ConvertPtr(swig_obj[1], (void **) &temp2, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { - SWIG_exception(SWIG_ValueError,"io_stream object is expected."); - return NULL; - } - - if (temp2->isSTDOUT() == 1) { - arg2 = &std::cout; - } - else { - out2.open(temp2->getFilename()); - out2.precision(temp2->getPrecision()); - arg2 = &out2; - } - } { try { - ((mfem::Vector const *)arg1)->Print_HYPRE(*arg2); + result = (double)((mfem::Vector const *)arg1)->Norml2(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7568,45 +7645,31 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_0(PyObject *SWIGUNUSEDPARM(s SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: - { - if (temp2->isSTDOUT() != 1) { - out2.close(); - } - } return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - int arg2 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Randomize" "', argument " "1"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlinf" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); - } { try { - (arg1)->Randomize(arg2); + result = (double)((mfem::Vector const *)arg1)->Normlinf(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7620,28 +7683,31 @@ SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_0(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; int res1 = 0 ; + PyObject *swig_obj[1] ; + double result; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; + if (!args) SWIG_fail; + swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Randomize" "', argument " "1"" of type '" "mfem::Vector *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml1" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - (arg1)->Randomize(); + result = (double)((mfem::Vector const *)arg1)->Norml1(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7655,60 +7721,63 @@ SWIGINTERN PyObject *_wrap_Vector_Randomize__SWIG_1(PyObject *SWIGUNUSEDPARM(sel SWIG_exception(SWIG_RuntimeError, "unknown exception"); } } - resultobj = SWIG_Py_Void(); + resultobj = SWIG_From_double(static_cast< double >(result)); return resultobj; fail: return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Randomize(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 +SWIGINTERN PyObject *_wrap_Vector_Normlp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { + PyObject *resultobj = 0; + mfem::Vector *arg1 = (mfem::Vector *) 0 ; + double arg2 ; + void *argp1 = 0 ; + int res1 = 0 ; + double val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL }; + double result; - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Randomize", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Randomize__SWIG_1(self, argc, argv); - } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_Normlp", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlp" "', argument " "1"" of type '" "mfem::Vector const *""'"); } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[1]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Vector_Randomize__SWIG_0(self, argc, argv); - } + arg1 = reinterpret_cast< mfem::Vector * >(argp1); + ecode2 = SWIG_AsVal_double(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Normlp" "', argument " "2"" of type '" "double""'"); + } + arg2 = static_cast< double >(val2); + { + try { + result = (double)((mfem::Vector const *)arg1)->Normlp(arg2); + } +#ifdef MFEM_USE_EXCEPTIONS + catch (mfem::ErrorException &_e) { + std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); + s = s + s2; + SWIG_exception(SWIG_RuntimeError, s.c_str()); } +#endif + + catch (...) { + SWIG_exception(SWIG_RuntimeError, "unknown exception"); + } } - + resultobj = SWIG_From_double(static_cast< double >(result)); + return resultobj; fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Randomize'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::Randomize(int)\n" - " mfem::Vector::Randomize()\n"); - return 0; + return NULL; } -SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -7720,12 +7789,12 @@ SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObjec swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml2" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Max" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double)((mfem::Vector const *)arg1)->Norml2(); + result = (double)((mfem::Vector const *)arg1)->Max(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7746,7 +7815,7 @@ SWIGINTERN PyObject *_wrap_Vector_Norml2(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -7758,12 +7827,12 @@ SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObj swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlinf" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Min" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double)((mfem::Vector const *)arg1)->Normlinf(); + result = (double)((mfem::Vector const *)arg1)->Min(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7784,7 +7853,7 @@ SWIGINTERN PyObject *_wrap_Vector_Normlinf(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_Sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -7796,12 +7865,12 @@ SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObjec swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Norml1" "', argument " "1"" of type '" "mfem::Vector const *""'"); + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Sum" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double)((mfem::Vector const *)arg1)->Norml1(); + result = (double)((mfem::Vector const *)arg1)->Sum(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -7822,183 +7891,28 @@ SWIGINTERN PyObject *_wrap_Vector_Norml1(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Vector_Normlp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_DistanceSquaredTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - double arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - double val2 ; - int ecode2 = 0 ; - PyObject *swig_obj[2] ; - double result; - - if (!SWIG_Python_UnpackTuple(args, "Vector_Normlp", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Normlp" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_double(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Normlp" "', argument " "2"" of type '" "double""'"); - } - arg2 = static_cast< double >(val2); - { - try { - result = (double)((mfem::Vector const *)arg1)->Normlp(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Max(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Max" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - try { - result = (double)((mfem::Vector const *)arg1)->Max(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Min(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Min" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - try { - result = (double)((mfem::Vector const *)arg1)->Min(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Sum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - PyObject *swig_obj[1] ; - double result; - - if (!args) SWIG_fail; - swig_obj[0] = args; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Sum" "', argument " "1"" of type '" "mfem::Vector const *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - { - try { - result = (double)((mfem::Vector const *)arg1)->Sum(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_From_double(static_cast< double >(result)); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_DistanceSquaredTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - double *arg2 = (double *) 0 ; + double *arg2 = (double *) 0 ; void *argp1 = 0 ; int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Vector_DistanceSquaredTo", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_DistanceSquaredTo", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_DistanceSquaredTo" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_DistanceSquaredTo" "', argument " "2"" of type '" "double const *""'"); } @@ -8026,7 +7940,7 @@ SWIGINTERN PyObject *_wrap_Vector_DistanceSquaredTo(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Vector_DistanceTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector_DistanceTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; double *arg2 = (double *) 0 ; @@ -8034,16 +7948,20 @@ SWIGINTERN PyObject *_wrap_Vector_DistanceTo(PyObject *SWIGUNUSEDPARM(self), PyO int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"p", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Vector_DistanceTo", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector_DistanceTo", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_DistanceTo" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_DistanceTo" "', argument " "2"" of type '" "double const *""'"); } @@ -8146,66 +8064,37 @@ SWIGINTERN PyObject *_wrap_delete_Vector(PyObject *SWIGUNUSEDPARM(self), PyObjec } -SWIGINTERN PyObject *_wrap_Vector_Read__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_Read", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Read" "', argument " "1"" of type '" "mfem::Vector const *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Read" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)((mfem::Vector const *)arg1)->Read(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Read" "', argument " "1"" of type '" "mfem::Vector const *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Read" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double *)((mfem::Vector const *)arg1)->Read(); + result = (double *)((mfem::Vector const *)arg1)->Read(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8226,48 +8115,6 @@ SWIGINTERN PyObject *_wrap_Vector_Read__SWIG_1(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Vector_Read(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Read", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Read__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Vector_Read__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Read'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::Read(bool) const\n" - " mfem::Vector::Read() const\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Vector_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -8306,66 +8153,37 @@ SWIGINTERN PyObject *_wrap_Vector_HostRead(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Vector_Write__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; - bool arg2 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; bool val2 ; int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_Write", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Write" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Write" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->Write(arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - double *result = 0 ; - - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Write" "', argument " "1"" of type '" "mfem::Vector *""'"); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_Write" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double *)(arg1)->Write(); + result = (double *)(arg1)->Write(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8386,48 +8204,6 @@ SWIGINTERN PyObject *_wrap_Vector_Write__SWIG_1(PyObject *SWIGUNUSEDPARM(self), } -SWIGINTERN PyObject *_wrap_Vector_Write(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Write", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Write__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Vector_Write__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Write'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::Write(bool)\n" - " mfem::Vector::Write()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Vector_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -8445,51 +8221,7 @@ SWIGINTERN PyObject *_wrap_Vector_HostWrite(PyObject *SWIGUNUSEDPARM(self), PyOb arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - result = (double *)(arg1)->HostWrite(); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 ); - return resultobj; -fail: - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - bool arg2 ; - void *argp1 = 0 ; - int res1 = 0 ; - bool val2 ; - int ecode2 = 0 ; - double *result = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_ReadWrite" "', argument " "1"" of type '" "mfem::Vector *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2); - if (!SWIG_IsOK(ecode2)) { - SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_ReadWrite" "', argument " "2"" of type '" "bool""'"); - } - arg2 = static_cast< bool >(val2); - { - try { - result = (double *)(arg1)->ReadWrite(arg2); + result = (double *)(arg1)->HostWrite(); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8510,22 +8242,37 @@ SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_0(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_ReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; + bool arg2 = (bool) true ; void *argp1 = 0 ; int res1 = 0 ; + bool val2 ; + int ecode2 = 0 ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"on_dev", NULL + }; double *result = 0 ; - if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:Vector_ReadWrite", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_ReadWrite" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); + if (obj1) { + ecode2 = SWIG_AsVal_bool(obj1, &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Vector_ReadWrite" "', argument " "2"" of type '" "bool""'"); + } + arg2 = static_cast< bool >(val2); + } { try { - result = (double *)(arg1)->ReadWrite(); + result = (double *)(arg1)->ReadWrite(arg2); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -8546,48 +8293,6 @@ SWIGINTERN PyObject *_wrap_Vector_ReadWrite__SWIG_1(PyObject *SWIGUNUSEDPARM(sel } -SWIGINTERN PyObject *_wrap_Vector_ReadWrite(PyObject *self, PyObject *args) { - Py_ssize_t argc; - PyObject *argv[3] = { - 0 - }; - - if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_ReadWrite", 0, 2, argv))) SWIG_fail; - --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_ReadWrite__SWIG_1(self, argc, argv); - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - int res = SWIG_AsVal_bool(argv[1], NULL); - _v = SWIG_CheckState(res); - } - if (_v) { - return _wrap_Vector_ReadWrite__SWIG_0(self, argc, argv); - } - } - } - -fail: - SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_ReadWrite'.\n" - " Possible C/C++ prototypes are:\n" - " mfem::Vector::ReadWrite(bool)\n" - " mfem::Vector::ReadWrite()\n"); - return 0; -} - - SWIGINTERN PyObject *_wrap_Vector_HostReadWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; @@ -8989,7 +8694,7 @@ SWIGINTERN PyObject *_wrap_Vector_Assign(PyObject *self, PyObject *args) { } -SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; int arg2 ; @@ -8998,21 +8703,26 @@ SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), Py int res1 = 0 ; double val3 ; int ecode3 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"i", (char *)"v", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "Vector___setitem__", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Vector___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___setitem__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); { - if ((PyArray_PyIntAsInt(swig_obj[1]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj1) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg2 = PyArray_PyIntAsInt(swig_obj[1]); + arg2 = PyArray_PyIntAsInt(obj1); } - ecode3 = SWIG_AsVal_double(swig_obj[2], &val3); + ecode3 = SWIG_AsVal_double(obj2, &val3); if (!SWIG_IsOK(ecode3)) { SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Vector___setitem__" "', argument " "3"" of type '" "double""'"); } @@ -9040,22 +8750,26 @@ SWIGINTERN PyObject *_wrap_Vector___setitem__(PyObject *SWIGUNUSEDPARM(self), Py } -SWIGINTERN PyObject *_wrap_Vector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Vector___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; PyObject *arg2 = (PyObject *) 0 ; void *argp1 = 0 ; int res1 = 0 ; - PyObject *swig_obj[2] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + char * kwnames[] = { + (char *)"self", (char *)"param", NULL + }; PyObject *result = 0 ; - if (!SWIG_Python_UnpackTuple(args, "Vector___getitem__", 2, 2, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Vector___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector___getitem__" "', argument " "1"" of type '" "mfem::Vector *""'"); } arg1 = reinterpret_cast< mfem::Vector * >(argp1); - arg2 = swig_obj[1]; + arg2 = obj1; { try { result = (PyObject *)mfem_Vector___getitem__(arg1,arg2); @@ -9117,18 +8831,18 @@ SWIGINTERN PyObject *_wrap_Vector_GetDataArray(PyObject *SWIGUNUSEDPARM(self), P } -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { +SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector *""'"); @@ -9139,61 +8853,17 @@ SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_3(PyObject *SWIGUNUSEDPARM(self), SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); - } - { - try { - mfem_Vector_Print__SWIG_3(arg1,(char const *)arg2,arg3); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Print__SWIG_4(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print" "', argument " "1"" of type '" "mfem::Vector *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print" "', argument " "2"" of type '" "char const *""'"); } - arg2 = reinterpret_cast< char * >(buf2); { try { - mfem_Vector_Print__SWIG_3(arg1,(char const *)arg2); + mfem_Vector_Print__SWIG_1(arg1,(char const *)arg2,arg3); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9224,34 +8894,15 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { if (!(argc = SWIG_Python_UnpackTuple(args, "Vector_Print", 0, 3, argv))) SWIG_fail; --argc; - if (argc == 1) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Print__SWIG_2(self, argc, argv); - } - } - if (argc == 2) { + if ((argc >= 1) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - return _wrap_Vector_Print__SWIG_4(self, argc, argv); + if (argc <= 1) { + return _wrap_Vector_Print__SWIG_0(self, argc, argv); } - } - } - if (argc == 2) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { { void *ptr; if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { @@ -9262,19 +8913,9 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Vector_Print__SWIG_1(self, argc, argv); - } - } - } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { + if (argc <= 2) { + return _wrap_Vector_Print__SWIG_0(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -9284,27 +8925,23 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Vector_Print__SWIG_3(self, argc, argv); + return _wrap_Vector_Print__SWIG_0(self, argc, argv); } } } } - if (argc == 3) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - { - void *ptr; - if (SWIG_ConvertPtr(argv[1], (void **) &ptr, SWIGTYPE_p_PyMFEM__wFILE, 0 |0) == -1) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } + int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); + _v = SWIG_CheckState(res); if (_v) { + if (argc <= 2) { + return _wrap_Vector_Print__SWIG_1(self, argc, argv); + } { if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { PyErr_Clear(); @@ -9314,7 +8951,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { } } if (_v) { - return _wrap_Vector_Print__SWIG_0(self, argc, argv); + return _wrap_Vector_Print__SWIG_1(self, argc, argv); } } } @@ -9324,10 +8961,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print(PyObject *self, PyObject *args) { SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Print'.\n" " Possible C/C++ prototypes are:\n" " mfem::Vector::Print(std::ostream &,int) const\n" - " mfem::Vector::Print(std::ostream &) const\n" - " mfem::Vector::Print() const\n" - " mfem::Vector::Print(char const *,int)\n" - " mfem::Vector::Print(char const *)\n"); + " mfem::Vector::Print(char const *,int)\n"); return 0; } @@ -9336,14 +8970,14 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_1(PyObject *SWIGUNUSEDPARM(s PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; char *arg2 = (char *) 0 ; - int arg3 ; + int arg3 = (int) 8 ; void *argp1 = 0 ; int res1 = 0 ; int res2 ; char *buf2 = 0 ; int alloc2 = 0 ; - if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; + if ((nobjs < 2) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector *""'"); @@ -9354,11 +8988,13 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print_HYPRE" "', argument " "2"" of type '" "char const *""'"); } arg2 = reinterpret_cast< char * >(buf2); - { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { - SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); - }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + if (swig_obj[2]) { + { + if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); + }; + arg3 = PyArray_PyIntAsInt(swig_obj[2]); + } } { try { @@ -9386,52 +9022,6 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_1(PyObject *SWIGUNUSEDPARM(s SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_2(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { - PyObject *resultobj = 0; - mfem::Vector *arg1 = (mfem::Vector *) 0 ; - char *arg2 = (char *) 0 ; - void *argp1 = 0 ; - int res1 = 0 ; - int res2 ; - char *buf2 = 0 ; - int alloc2 = 0 ; - - if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_mfem__Vector, 0 | 0 ); - if (!SWIG_IsOK(res1)) { - SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Vector_Print_HYPRE" "', argument " "1"" of type '" "mfem::Vector *""'"); - } - arg1 = reinterpret_cast< mfem::Vector * >(argp1); - res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2); - if (!SWIG_IsOK(res2)) { - SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Vector_Print_HYPRE" "', argument " "2"" of type '" "char const *""'"); - } - arg2 = reinterpret_cast< char * >(buf2); - { - try { - mfem_Vector_Print_HYPRE__SWIG_1(arg1,(char const *)arg2); - } -#ifdef MFEM_USE_EXCEPTIONS - catch (mfem::ErrorException &_e) { - std::string s("PyMFEM error (mfem::ErrorException): "), s2(_e.what()); - s = s + s2; - SWIG_exception(SWIG_RuntimeError, s.c_str()); - } -#endif - - catch (...) { - SWIG_exception(SWIG_RuntimeError, "unknown exception"); - } - } - resultobj = SWIG_Py_Void(); - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return resultobj; -fail: - if (alloc2 == SWIG_NEWOBJ) delete[] buf2; - return NULL; -} - - -SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_3(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) { PyObject *resultobj = 0; mfem::Vector *arg1 = (mfem::Vector *) 0 ; void *argp1 = 0 ; @@ -9445,7 +9035,7 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE__SWIG_3(PyObject *SWIGUNUSEDPARM(s arg1 = reinterpret_cast< mfem::Vector * >(argp1); { try { - mfem_Vector_Print_HYPRE__SWIG_3(arg1); + mfem_Vector_Print_HYPRE__SWIG_2(arg1); } #ifdef MFEM_USE_EXCEPTIONS catch (mfem::ErrorException &_e) { @@ -9480,10 +9070,10 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE(PyObject *self, PyObject *args) { int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Vector_Print_HYPRE__SWIG_3(self, argc, argv); + return _wrap_Vector_Print_HYPRE__SWIG_2(self, argc, argv); } } - if (argc == 2) { + if ((argc >= 2) && (argc <= 3)) { int _v; void *vptr = 0; int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); @@ -9492,7 +9082,20 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE(PyObject *self, PyObject *args) { int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); _v = SWIG_CheckState(res); if (_v) { - return _wrap_Vector_Print_HYPRE__SWIG_2(self, argc, argv); + if (argc <= 2) { + return _wrap_Vector_Print_HYPRE__SWIG_1(self, argc, argv); + } + { + if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { + PyErr_Clear(); + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_Vector_Print_HYPRE__SWIG_1(self, argc, argv); + } } } } @@ -9516,36 +9119,12 @@ SWIGINTERN PyObject *_wrap_Vector_Print_HYPRE(PyObject *self, PyObject *args) { } } } - if (argc == 3) { - int _v; - void *vptr = 0; - int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_mfem__Vector, 0); - _v = SWIG_CheckState(res); - if (_v) { - int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0); - _v = SWIG_CheckState(res); - if (_v) { - { - if ((PyArray_PyIntAsInt(argv[2]) == -1) && PyErr_Occurred()) { - PyErr_Clear(); - _v = 0; - } else { - _v = 1; - } - } - if (_v) { - return _wrap_Vector_Print_HYPRE__SWIG_1(self, argc, argv); - } - } - } - } fail: SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'Vector_Print_HYPRE'.\n" " Possible C/C++ prototypes are:\n" " mfem::Vector::Print_HYPRE(std::ostream &) const\n" " mfem::Vector::Print_HYPRE(char const *,int)\n" - " mfem::Vector::Print_HYPRE(char const *)\n" " mfem::Vector::Print_HYPRE()\n"); return 0; } @@ -9562,18 +9141,20 @@ SWIGINTERN PyObject *Vector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a return SWIG_Python_InitShadowInstance(args); } -SWIGINTERN PyObject *_wrap_IsFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_IsFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = 0 ; double temp1 ; double val1 ; int ecode1 = 0 ; - PyObject *swig_obj[1] ; + PyObject * obj0 = 0 ; + char * kwnames[] = { + (char *)"val", NULL + }; bool result; - if (!args) SWIG_fail; - swig_obj[0] = args; - ecode1 = SWIG_AsVal_double(swig_obj[0], &val1); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:IsFinite", kwnames, &obj0)) SWIG_fail; + ecode1 = SWIG_AsVal_double(obj0, &val1); if (!SWIG_IsOK(ecode1)) { SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IsFinite" "', argument " "1"" of type '" "double""'"); } @@ -9602,7 +9183,7 @@ SWIGINTERN PyObject *_wrap_IsFinite(PyObject *SWIGUNUSEDPARM(self), PyObject *ar } -SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; @@ -9611,25 +9192,30 @@ SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObj int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"y", (char *)"n", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "DistanceSquared", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DistanceSquared", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DistanceSquared" "', argument " "1"" of type '" "double const *""'"); } arg1 = reinterpret_cast< double * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DistanceSquared" "', argument " "2"" of type '" "double const *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9654,7 +9240,7 @@ SWIGINTERN PyObject *_wrap_DistanceSquared(PyObject *SWIGUNUSEDPARM(self), PyObj } -SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; double *arg1 = (double *) 0 ; double *arg2 = (double *) 0 ; @@ -9663,25 +9249,30 @@ SWIGINTERN PyObject *_wrap_Distance(PyObject *SWIGUNUSEDPARM(self), PyObject *ar int res1 = 0 ; void *argp2 = 0 ; int res2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"x", (char *)"y", (char *)"n", NULL + }; double result; - if (!SWIG_Python_UnpackTuple(args, "Distance", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_double, 0 | 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:Distance", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Distance" "', argument " "1"" of type '" "double const *""'"); } arg1 = reinterpret_cast< double * >(argp1); - res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_double, 0 | 0 ); + res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 | 0 ); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Distance" "', argument " "2"" of type '" "double const *""'"); } arg2 = reinterpret_cast< double * >(argp2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -9719,7 +9310,7 @@ static PyMethodDef SwigMethods[] = { "subtract_vector(Vector v1, Vector v2, Vector v)\n" "subtract_vector(double const a, Vector x, Vector y, Vector z)\n" ""}, - { "CheckFinite", _wrap_CheckFinite, METH_VARARGS, "CheckFinite(double const * v, int const n) -> int"}, + { "CheckFinite", (PyCFunction)(void(*)(void))_wrap_CheckFinite, METH_VARARGS|METH_KEYWORDS, "CheckFinite(double const * v, int const n) -> int"}, { "infinity", _wrap_infinity, METH_NOARGS, "infinity() -> double"}, { "Vector_UseDevice", _wrap_Vector_UseDevice, METH_VARARGS, "\n" "Vector_UseDevice(Vector self, bool use_dev)\n" @@ -9735,10 +9326,10 @@ static PyMethodDef SwigMethods[] = { "Vector_SetSize(Vector self, int s, mfem::MemoryType mt)\n" "Vector_SetSize(Vector self, int s, Vector v)\n" ""}, - { "Vector_SetData", _wrap_Vector_SetData, METH_VARARGS, "Vector_SetData(Vector self, double * d)"}, - { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "Vector_SetDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "Vector_NewDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "Vector_NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_SetData", (PyCFunction)(void(*)(void))_wrap_Vector_SetData, METH_VARARGS|METH_KEYWORDS, "Vector_SetData(Vector self, double * d)"}, + { "Vector_SetDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_SetDataAndSize, METH_VARARGS|METH_KEYWORDS, "Vector_SetDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewDataAndSize, METH_VARARGS|METH_KEYWORDS, "Vector_NewDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewMemoryAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewMemoryAndSize, METH_VARARGS|METH_KEYWORDS, "Vector_NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" "Vector_MakeRef(Vector self, Vector base, int offset, int size)\n" "Vector_MakeRef(Vector self, Vector base, int offset)\n" @@ -9752,8 +9343,8 @@ static PyMethodDef SwigMethods[] = { "Vector_GetMemory(Vector self) -> mfem::Memory< double >\n" "Vector_GetMemory(Vector self) -> mfem::Memory< double > const &\n" ""}, - { "Vector_SyncMemory", _wrap_Vector_SyncMemory, METH_VARARGS, "Vector_SyncMemory(Vector self, Vector v)"}, - { "Vector_SyncAliasMemory", _wrap_Vector_SyncAliasMemory, METH_VARARGS, "Vector_SyncAliasMemory(Vector self, Vector v)"}, + { "Vector_SyncMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncMemory, METH_VARARGS|METH_KEYWORDS, "Vector_SyncMemory(Vector self, Vector v)"}, + { "Vector_SyncAliasMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncAliasMemory, METH_VARARGS|METH_KEYWORDS, "Vector_SyncAliasMemory(Vector self, Vector v)"}, { "Vector_OwnsData", _wrap_Vector_OwnsData, METH_O, "Vector_OwnsData(Vector self) -> bool"}, { "Vector_StealData", _wrap_Vector_StealData, METH_VARARGS, "\n" "Vector_StealData(Vector self, double ** p)\n" @@ -9771,19 +9362,19 @@ static PyMethodDef SwigMethods[] = { "Vector___mul__(Vector self, double const * arg2) -> double\n" "Vector___mul__(Vector self, Vector v) -> double\n" ""}, - { "Vector___imul__", _wrap_Vector___imul__, METH_VARARGS, "Vector___imul__(Vector self, double c) -> Vector"}, - { "Vector___itruediv__", _wrap_Vector___itruediv__, METH_VARARGS, "Vector___itruediv__(Vector self, double c) -> Vector"}, + { "Vector___imul__", (PyCFunction)(void(*)(void))_wrap_Vector___imul__, METH_VARARGS|METH_KEYWORDS, "Vector___imul__(Vector self, double c) -> Vector"}, + { "Vector___itruediv__", (PyCFunction)(void(*)(void))_wrap_Vector___itruediv__, METH_VARARGS|METH_KEYWORDS, "Vector___itruediv__(Vector self, double c) -> Vector"}, { "Vector___isub__", _wrap_Vector___isub__, METH_VARARGS, "\n" "Vector___isub__(Vector self, double c) -> Vector\n" "Vector___isub__(Vector self, Vector v) -> Vector\n" ""}, - { "Vector___iadd__", _wrap_Vector___iadd__, METH_VARARGS, "Vector___iadd__(Vector self, Vector v) -> Vector"}, - { "Vector_Add", _wrap_Vector_Add, METH_VARARGS, "Vector_Add(Vector self, double const a, Vector Va) -> Vector"}, - { "Vector_Set", _wrap_Vector_Set, METH_VARARGS, "Vector_Set(Vector self, double const a, Vector x) -> Vector"}, - { "Vector_SetVector", _wrap_Vector_SetVector, METH_VARARGS, "Vector_SetVector(Vector self, Vector v, int offset)"}, + { "Vector___iadd__", (PyCFunction)(void(*)(void))_wrap_Vector___iadd__, METH_VARARGS|METH_KEYWORDS, "Vector___iadd__(Vector self, Vector v) -> Vector"}, + { "Vector_Add", (PyCFunction)(void(*)(void))_wrap_Vector_Add, METH_VARARGS|METH_KEYWORDS, "Vector_Add(Vector self, double const a, Vector Va) -> Vector"}, + { "Vector_Set", (PyCFunction)(void(*)(void))_wrap_Vector_Set, METH_VARARGS|METH_KEYWORDS, "Vector_Set(Vector self, double const a, Vector x) -> Vector"}, + { "Vector_SetVector", (PyCFunction)(void(*)(void))_wrap_Vector_SetVector, METH_VARARGS|METH_KEYWORDS, "Vector_SetVector(Vector self, Vector v, int offset)"}, { "Vector_Neg", _wrap_Vector_Neg, METH_O, "Vector_Neg(Vector self)"}, - { "Vector_Swap", _wrap_Vector_Swap, METH_VARARGS, "Vector_Swap(Vector self, Vector other)"}, - { "Vector_median", _wrap_Vector_median, METH_VARARGS, "Vector_median(Vector self, Vector lo, Vector hi)"}, + { "Vector_Swap", (PyCFunction)(void(*)(void))_wrap_Vector_Swap, METH_VARARGS|METH_KEYWORDS, "Vector_Swap(Vector self, Vector other)"}, + { "Vector_median", (PyCFunction)(void(*)(void))_wrap_Vector_median, METH_VARARGS|METH_KEYWORDS, "Vector_median(Vector self, Vector lo, Vector hi)"}, { "Vector_GetSubVector", _wrap_Vector_GetSubVector, METH_VARARGS, "\n" "Vector_GetSubVector(Vector self, intArray dofs, Vector elemvect)\n" "Vector_GetSubVector(Vector self, intArray dofs, double * elem_data)\n" @@ -9798,24 +9389,24 @@ static PyMethodDef SwigMethods[] = { "Vector_AddElementVector(Vector self, intArray dofs, double * elem_data)\n" "Vector_AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect)\n" ""}, - { "Vector_SetSubVectorComplement", _wrap_Vector_SetSubVectorComplement, METH_VARARGS, "Vector_SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, - { "Vector_Randomize", _wrap_Vector_Randomize, METH_VARARGS, "Vector_Randomize(Vector self, int seed=0)"}, + { "Vector_SetSubVectorComplement", (PyCFunction)(void(*)(void))_wrap_Vector_SetSubVectorComplement, METH_VARARGS|METH_KEYWORDS, "Vector_SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, + { "Vector_Randomize", (PyCFunction)(void(*)(void))_wrap_Vector_Randomize, METH_VARARGS|METH_KEYWORDS, "Vector_Randomize(Vector self, int seed=0)"}, { "Vector_Norml2", _wrap_Vector_Norml2, METH_O, "Vector_Norml2(Vector self) -> double"}, { "Vector_Normlinf", _wrap_Vector_Normlinf, METH_O, "Vector_Normlinf(Vector self) -> double"}, { "Vector_Norml1", _wrap_Vector_Norml1, METH_O, "Vector_Norml1(Vector self) -> double"}, - { "Vector_Normlp", _wrap_Vector_Normlp, METH_VARARGS, "Vector_Normlp(Vector self, double p) -> double"}, + { "Vector_Normlp", (PyCFunction)(void(*)(void))_wrap_Vector_Normlp, METH_VARARGS|METH_KEYWORDS, "Vector_Normlp(Vector self, double p) -> double"}, { "Vector_Max", _wrap_Vector_Max, METH_O, "Vector_Max(Vector self) -> double"}, { "Vector_Min", _wrap_Vector_Min, METH_O, "Vector_Min(Vector self) -> double"}, { "Vector_Sum", _wrap_Vector_Sum, METH_O, "Vector_Sum(Vector self) -> double"}, - { "Vector_DistanceSquaredTo", _wrap_Vector_DistanceSquaredTo, METH_VARARGS, "Vector_DistanceSquaredTo(Vector self, double const * p) -> double"}, - { "Vector_DistanceTo", _wrap_Vector_DistanceTo, METH_VARARGS, "Vector_DistanceTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceSquaredTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceSquaredTo, METH_VARARGS|METH_KEYWORDS, "Vector_DistanceSquaredTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceTo, METH_VARARGS|METH_KEYWORDS, "Vector_DistanceTo(Vector self, double const * p) -> double"}, { "Vector_CheckFinite", _wrap_Vector_CheckFinite, METH_O, "Vector_CheckFinite(Vector self) -> int"}, { "delete_Vector", _wrap_delete_Vector, METH_O, "delete_Vector(Vector self)"}, - { "Vector_Read", _wrap_Vector_Read, METH_VARARGS, "Vector_Read(Vector self, bool on_dev=True) -> double const"}, + { "Vector_Read", (PyCFunction)(void(*)(void))_wrap_Vector_Read, METH_VARARGS|METH_KEYWORDS, "Vector_Read(Vector self, bool on_dev=True) -> double const *"}, { "Vector_HostRead", _wrap_Vector_HostRead, METH_O, "Vector_HostRead(Vector self) -> double const *"}, - { "Vector_Write", _wrap_Vector_Write, METH_VARARGS, "Vector_Write(Vector self, bool on_dev=True) -> double"}, + { "Vector_Write", (PyCFunction)(void(*)(void))_wrap_Vector_Write, METH_VARARGS|METH_KEYWORDS, "Vector_Write(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostWrite", _wrap_Vector_HostWrite, METH_O, "Vector_HostWrite(Vector self) -> double *"}, - { "Vector_ReadWrite", _wrap_Vector_ReadWrite, METH_VARARGS, "Vector_ReadWrite(Vector self, bool on_dev=True) -> double"}, + { "Vector_ReadWrite", (PyCFunction)(void(*)(void))_wrap_Vector_ReadWrite, METH_VARARGS|METH_KEYWORDS, "Vector_ReadWrite(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostReadWrite", _wrap_Vector_HostReadWrite, METH_O, "Vector_HostReadWrite(Vector self) -> double *"}, { "new_Vector", _wrap_new_Vector, METH_VARARGS, "\n" "Vector()\n" @@ -9830,8 +9421,8 @@ static PyMethodDef SwigMethods[] = { "Vector_Assign(Vector self, Vector v)\n" "Vector_Assign(Vector self, PyObject * param)\n" ""}, - { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, "Vector___setitem__(Vector self, int i, double const v)"}, - { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, "Vector___getitem__(Vector self, PyObject * param) -> PyObject *"}, + { "Vector___setitem__", (PyCFunction)(void(*)(void))_wrap_Vector___setitem__, METH_VARARGS|METH_KEYWORDS, "Vector___setitem__(Vector self, int i, double const v)"}, + { "Vector___getitem__", (PyCFunction)(void(*)(void))_wrap_Vector___getitem__, METH_VARARGS|METH_KEYWORDS, "Vector___getitem__(Vector self, PyObject * param) -> PyObject *"}, { "Vector_GetDataArray", _wrap_Vector_GetDataArray, METH_O, "Vector_GetDataArray(Vector self) -> PyObject *"}, { "Vector_Print", _wrap_Vector_Print, METH_VARARGS, "\n" "Vector_Print(Vector self, std::ostream & out=mfem::out, int width=8)\n" @@ -9844,9 +9435,9 @@ static PyMethodDef SwigMethods[] = { ""}, { "Vector_swigregister", Vector_swigregister, METH_O, NULL}, { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL}, - { "IsFinite", _wrap_IsFinite, METH_O, "IsFinite(double const & val) -> bool"}, - { "DistanceSquared", _wrap_DistanceSquared, METH_VARARGS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, - { "Distance", _wrap_Distance, METH_VARARGS, "Distance(double const * x, double const * y, int const n) -> double"}, + { "IsFinite", (PyCFunction)(void(*)(void))_wrap_IsFinite, METH_VARARGS|METH_KEYWORDS, "IsFinite(double const & val) -> bool"}, + { "DistanceSquared", (PyCFunction)(void(*)(void))_wrap_DistanceSquared, METH_VARARGS|METH_KEYWORDS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, + { "Distance", (PyCFunction)(void(*)(void))_wrap_Distance, METH_VARARGS|METH_KEYWORDS, "Distance(double const * x, double const * y, int const n) -> double"}, { NULL, NULL, 0, NULL } }; @@ -9863,7 +9454,7 @@ static PyMethodDef SwigMethods_proxydocs[] = { "subtract_vector(Vector v1, Vector v2, Vector v)\n" "subtract_vector(double const a, Vector x, Vector y, Vector z)\n" ""}, - { "CheckFinite", _wrap_CheckFinite, METH_VARARGS, "CheckFinite(double const * v, int const n) -> int"}, + { "CheckFinite", (PyCFunction)(void(*)(void))_wrap_CheckFinite, METH_VARARGS|METH_KEYWORDS, "CheckFinite(double const * v, int const n) -> int"}, { "infinity", _wrap_infinity, METH_NOARGS, "infinity() -> double"}, { "Vector_UseDevice", _wrap_Vector_UseDevice, METH_VARARGS, "\n" "UseDevice(Vector self, bool use_dev)\n" @@ -9879,10 +9470,10 @@ static PyMethodDef SwigMethods_proxydocs[] = { "SetSize(Vector self, int s, mfem::MemoryType mt)\n" "SetSize(Vector self, int s, Vector v)\n" ""}, - { "Vector_SetData", _wrap_Vector_SetData, METH_VARARGS, "SetData(Vector self, double * d)"}, - { "Vector_SetDataAndSize", _wrap_Vector_SetDataAndSize, METH_VARARGS, "SetDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewDataAndSize", _wrap_Vector_NewDataAndSize, METH_VARARGS, "NewDataAndSize(Vector self, double * d, int s)"}, - { "Vector_NewMemoryAndSize", _wrap_Vector_NewMemoryAndSize, METH_VARARGS, "NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, + { "Vector_SetData", (PyCFunction)(void(*)(void))_wrap_Vector_SetData, METH_VARARGS|METH_KEYWORDS, "SetData(Vector self, double * d)"}, + { "Vector_SetDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_SetDataAndSize, METH_VARARGS|METH_KEYWORDS, "SetDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewDataAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewDataAndSize, METH_VARARGS|METH_KEYWORDS, "NewDataAndSize(Vector self, double * d, int s)"}, + { "Vector_NewMemoryAndSize", (PyCFunction)(void(*)(void))_wrap_Vector_NewMemoryAndSize, METH_VARARGS|METH_KEYWORDS, "NewMemoryAndSize(Vector self, mfem::Memory< double > const & mem, int s, bool own_mem)"}, { "Vector_MakeRef", _wrap_Vector_MakeRef, METH_VARARGS, "\n" "MakeRef(Vector self, Vector base, int offset, int size)\n" "MakeRef(Vector self, Vector base, int offset)\n" @@ -9896,8 +9487,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "GetMemory(Vector self) -> mfem::Memory< double >\n" "GetMemory(Vector self) -> mfem::Memory< double > const &\n" ""}, - { "Vector_SyncMemory", _wrap_Vector_SyncMemory, METH_VARARGS, "SyncMemory(Vector self, Vector v)"}, - { "Vector_SyncAliasMemory", _wrap_Vector_SyncAliasMemory, METH_VARARGS, "SyncAliasMemory(Vector self, Vector v)"}, + { "Vector_SyncMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncMemory, METH_VARARGS|METH_KEYWORDS, "SyncMemory(Vector self, Vector v)"}, + { "Vector_SyncAliasMemory", (PyCFunction)(void(*)(void))_wrap_Vector_SyncAliasMemory, METH_VARARGS|METH_KEYWORDS, "SyncAliasMemory(Vector self, Vector v)"}, { "Vector_OwnsData", _wrap_Vector_OwnsData, METH_O, "OwnsData(Vector self) -> bool"}, { "Vector_StealData", _wrap_Vector_StealData, METH_VARARGS, "\n" "StealData(Vector self, double ** p)\n" @@ -9915,19 +9506,19 @@ static PyMethodDef SwigMethods_proxydocs[] = { "__mul__(Vector self, double const * arg2) -> double\n" "__mul__(Vector self, Vector v) -> double\n" ""}, - { "Vector___imul__", _wrap_Vector___imul__, METH_VARARGS, "__imul__(Vector self, double c) -> Vector"}, - { "Vector___itruediv__", _wrap_Vector___itruediv__, METH_VARARGS, "__itruediv__(Vector self, double c) -> Vector"}, + { "Vector___imul__", (PyCFunction)(void(*)(void))_wrap_Vector___imul__, METH_VARARGS|METH_KEYWORDS, "__imul__(Vector self, double c) -> Vector"}, + { "Vector___itruediv__", (PyCFunction)(void(*)(void))_wrap_Vector___itruediv__, METH_VARARGS|METH_KEYWORDS, "__itruediv__(Vector self, double c) -> Vector"}, { "Vector___isub__", _wrap_Vector___isub__, METH_VARARGS, "\n" "__isub__(Vector self, double c) -> Vector\n" "__isub__(Vector self, Vector v) -> Vector\n" ""}, - { "Vector___iadd__", _wrap_Vector___iadd__, METH_VARARGS, "__iadd__(Vector self, Vector v) -> Vector"}, - { "Vector_Add", _wrap_Vector_Add, METH_VARARGS, "Add(Vector self, double const a, Vector Va) -> Vector"}, - { "Vector_Set", _wrap_Vector_Set, METH_VARARGS, "Set(Vector self, double const a, Vector x) -> Vector"}, - { "Vector_SetVector", _wrap_Vector_SetVector, METH_VARARGS, "SetVector(Vector self, Vector v, int offset)"}, + { "Vector___iadd__", (PyCFunction)(void(*)(void))_wrap_Vector___iadd__, METH_VARARGS|METH_KEYWORDS, "__iadd__(Vector self, Vector v) -> Vector"}, + { "Vector_Add", (PyCFunction)(void(*)(void))_wrap_Vector_Add, METH_VARARGS|METH_KEYWORDS, "Add(Vector self, double const a, Vector Va) -> Vector"}, + { "Vector_Set", (PyCFunction)(void(*)(void))_wrap_Vector_Set, METH_VARARGS|METH_KEYWORDS, "Set(Vector self, double const a, Vector x) -> Vector"}, + { "Vector_SetVector", (PyCFunction)(void(*)(void))_wrap_Vector_SetVector, METH_VARARGS|METH_KEYWORDS, "SetVector(Vector self, Vector v, int offset)"}, { "Vector_Neg", _wrap_Vector_Neg, METH_O, "Neg(Vector self)"}, - { "Vector_Swap", _wrap_Vector_Swap, METH_VARARGS, "Swap(Vector self, Vector other)"}, - { "Vector_median", _wrap_Vector_median, METH_VARARGS, "median(Vector self, Vector lo, Vector hi)"}, + { "Vector_Swap", (PyCFunction)(void(*)(void))_wrap_Vector_Swap, METH_VARARGS|METH_KEYWORDS, "Swap(Vector self, Vector other)"}, + { "Vector_median", (PyCFunction)(void(*)(void))_wrap_Vector_median, METH_VARARGS|METH_KEYWORDS, "median(Vector self, Vector lo, Vector hi)"}, { "Vector_GetSubVector", _wrap_Vector_GetSubVector, METH_VARARGS, "\n" "GetSubVector(Vector self, intArray dofs, Vector elemvect)\n" "GetSubVector(Vector self, intArray dofs, double * elem_data)\n" @@ -9942,24 +9533,24 @@ static PyMethodDef SwigMethods_proxydocs[] = { "AddElementVector(Vector self, intArray dofs, double * elem_data)\n" "AddElementVector(Vector self, intArray dofs, double const a, Vector elemvect)\n" ""}, - { "Vector_SetSubVectorComplement", _wrap_Vector_SetSubVectorComplement, METH_VARARGS, "SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, - { "Vector_Randomize", _wrap_Vector_Randomize, METH_VARARGS, "Randomize(Vector self, int seed=0)"}, + { "Vector_SetSubVectorComplement", (PyCFunction)(void(*)(void))_wrap_Vector_SetSubVectorComplement, METH_VARARGS|METH_KEYWORDS, "SetSubVectorComplement(Vector self, intArray dofs, double const val)"}, + { "Vector_Randomize", (PyCFunction)(void(*)(void))_wrap_Vector_Randomize, METH_VARARGS|METH_KEYWORDS, "Randomize(Vector self, int seed=0)"}, { "Vector_Norml2", _wrap_Vector_Norml2, METH_O, "Norml2(Vector self) -> double"}, { "Vector_Normlinf", _wrap_Vector_Normlinf, METH_O, "Normlinf(Vector self) -> double"}, { "Vector_Norml1", _wrap_Vector_Norml1, METH_O, "Norml1(Vector self) -> double"}, - { "Vector_Normlp", _wrap_Vector_Normlp, METH_VARARGS, "Normlp(Vector self, double p) -> double"}, + { "Vector_Normlp", (PyCFunction)(void(*)(void))_wrap_Vector_Normlp, METH_VARARGS|METH_KEYWORDS, "Normlp(Vector self, double p) -> double"}, { "Vector_Max", _wrap_Vector_Max, METH_O, "Max(Vector self) -> double"}, { "Vector_Min", _wrap_Vector_Min, METH_O, "Min(Vector self) -> double"}, { "Vector_Sum", _wrap_Vector_Sum, METH_O, "Sum(Vector self) -> double"}, - { "Vector_DistanceSquaredTo", _wrap_Vector_DistanceSquaredTo, METH_VARARGS, "DistanceSquaredTo(Vector self, double const * p) -> double"}, - { "Vector_DistanceTo", _wrap_Vector_DistanceTo, METH_VARARGS, "DistanceTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceSquaredTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceSquaredTo, METH_VARARGS|METH_KEYWORDS, "DistanceSquaredTo(Vector self, double const * p) -> double"}, + { "Vector_DistanceTo", (PyCFunction)(void(*)(void))_wrap_Vector_DistanceTo, METH_VARARGS|METH_KEYWORDS, "DistanceTo(Vector self, double const * p) -> double"}, { "Vector_CheckFinite", _wrap_Vector_CheckFinite, METH_O, "CheckFinite(Vector self) -> int"}, { "delete_Vector", _wrap_delete_Vector, METH_O, "delete_Vector(Vector self)"}, - { "Vector_Read", _wrap_Vector_Read, METH_VARARGS, "Read(Vector self, bool on_dev=True) -> double const"}, + { "Vector_Read", (PyCFunction)(void(*)(void))_wrap_Vector_Read, METH_VARARGS|METH_KEYWORDS, "Read(Vector self, bool on_dev=True) -> double const *"}, { "Vector_HostRead", _wrap_Vector_HostRead, METH_O, "HostRead(Vector self) -> double const *"}, - { "Vector_Write", _wrap_Vector_Write, METH_VARARGS, "Write(Vector self, bool on_dev=True) -> double"}, + { "Vector_Write", (PyCFunction)(void(*)(void))_wrap_Vector_Write, METH_VARARGS|METH_KEYWORDS, "Write(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostWrite", _wrap_Vector_HostWrite, METH_O, "HostWrite(Vector self) -> double *"}, - { "Vector_ReadWrite", _wrap_Vector_ReadWrite, METH_VARARGS, "ReadWrite(Vector self, bool on_dev=True) -> double"}, + { "Vector_ReadWrite", (PyCFunction)(void(*)(void))_wrap_Vector_ReadWrite, METH_VARARGS|METH_KEYWORDS, "ReadWrite(Vector self, bool on_dev=True) -> double *"}, { "Vector_HostReadWrite", _wrap_Vector_HostReadWrite, METH_O, "HostReadWrite(Vector self) -> double *"}, { "new_Vector", _wrap_new_Vector, METH_VARARGS, "\n" "Vector()\n" @@ -9974,8 +9565,8 @@ static PyMethodDef SwigMethods_proxydocs[] = { "Assign(Vector self, Vector v)\n" "Assign(Vector self, PyObject * param)\n" ""}, - { "Vector___setitem__", _wrap_Vector___setitem__, METH_VARARGS, "__setitem__(Vector self, int i, double const v)"}, - { "Vector___getitem__", _wrap_Vector___getitem__, METH_VARARGS, "__getitem__(Vector self, PyObject * param) -> PyObject *"}, + { "Vector___setitem__", (PyCFunction)(void(*)(void))_wrap_Vector___setitem__, METH_VARARGS|METH_KEYWORDS, "__setitem__(Vector self, int i, double const v)"}, + { "Vector___getitem__", (PyCFunction)(void(*)(void))_wrap_Vector___getitem__, METH_VARARGS|METH_KEYWORDS, "__getitem__(Vector self, PyObject * param) -> PyObject *"}, { "Vector_GetDataArray", _wrap_Vector_GetDataArray, METH_O, "GetDataArray(Vector self) -> PyObject *"}, { "Vector_Print", _wrap_Vector_Print, METH_VARARGS, "\n" "Print(Vector self, std::ostream & out=mfem::out, int width=8)\n" @@ -9988,9 +9579,9 @@ static PyMethodDef SwigMethods_proxydocs[] = { ""}, { "Vector_swigregister", Vector_swigregister, METH_O, NULL}, { "Vector_swiginit", Vector_swiginit, METH_VARARGS, NULL}, - { "IsFinite", _wrap_IsFinite, METH_O, "IsFinite(double const & val) -> bool"}, - { "DistanceSquared", _wrap_DistanceSquared, METH_VARARGS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, - { "Distance", _wrap_Distance, METH_VARARGS, "Distance(double const * x, double const * y, int const n) -> double"}, + { "IsFinite", (PyCFunction)(void(*)(void))_wrap_IsFinite, METH_VARARGS|METH_KEYWORDS, "IsFinite(double const & val) -> bool"}, + { "DistanceSquared", (PyCFunction)(void(*)(void))_wrap_DistanceSquared, METH_VARARGS|METH_KEYWORDS, "DistanceSquared(double const * x, double const * y, int const n) -> double"}, + { "Distance", (PyCFunction)(void(*)(void))_wrap_Distance, METH_VARARGS|METH_KEYWORDS, "Distance(double const * x, double const * y, int const n) -> double"}, { NULL, NULL, 0, NULL } }; diff --git a/mfem/_ser/vtk_wrap.cxx b/mfem/_ser/vtk_wrap.cxx index 73528c3a..9226b183 100644 --- a/mfem/_ser/vtk_wrap.cxx +++ b/mfem/_ser/vtk_wrap.cxx @@ -3393,7 +3393,7 @@ SWIG_FromCharPtr(const char *cptr) #ifdef __cplusplus extern "C" { #endif -SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; mfem::Array< int > *arg1 = 0 ; mfem::Geometry::Type arg2 ; @@ -3402,10 +3402,15 @@ SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM int res1 = 0 ; int val2 ; int ecode2 = 0 ; - PyObject *swig_obj[3] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + char * kwnames[] = { + (char *)"con", (char *)"geom", (char *)"ref", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "CreateVTKElementConnectivity", 3, 3, swig_obj)) SWIG_fail; - res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CreateVTKElementConnectivity", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; + res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_mfem__ArrayT_int_t, 0 ); if (!SWIG_IsOK(res1)) { SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); } @@ -3413,16 +3418,16 @@ SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "CreateVTKElementConnectivity" "', argument " "1"" of type '" "mfem::Array< int > &""'"); } arg1 = reinterpret_cast< mfem::Array< int > * >(argp1); - ecode2 = SWIG_AsVal_int(swig_obj[1], &val2); + ecode2 = SWIG_AsVal_int(obj1, &val2); if (!SWIG_IsOK(ecode2)) { SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CreateVTKElementConnectivity" "', argument " "2"" of type '" "mfem::Geometry::Type""'"); } arg2 = static_cast< mfem::Geometry::Type >(val2); { - if ((PyArray_PyIntAsInt(swig_obj[2]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj2) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg3 = PyArray_PyIntAsInt(swig_obj[2]); + arg3 = PyArray_PyIntAsInt(obj2); } { try { @@ -3450,7 +3455,7 @@ SWIGINTERN PyObject *_wrap_CreateVTKElementConnectivity(PyObject *SWIGUNUSEDPARM } -SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) { +SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) { PyObject *resultobj = 0; std::ostream *arg1 = 0 ; void *arg2 = (void *) 0 ; @@ -3461,11 +3466,17 @@ SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(se int res2 ; void *argp3 ; int res3 = 0 ; - PyObject *swig_obj[4] ; + PyObject * obj0 = 0 ; + PyObject * obj1 = 0 ; + PyObject * obj2 = 0 ; + PyObject * obj3 = 0 ; + char * kwnames[] = { + (char *)"out", (char *)"bytes", (char *)"nbytes", (char *)"compression_level", NULL + }; - if (!SWIG_Python_UnpackTuple(args, "WriteVTKEncodedCompressed", 4, 4, swig_obj)) SWIG_fail; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:WriteVTKEncodedCompressed", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { - if (SWIG_ConvertPtr(swig_obj[0], (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { + if (SWIG_ConvertPtr(obj0, (void **) &temp1, SWIGTYPE_p_PyMFEM__wFILE, 0 | 0) == -1) { SWIG_exception(SWIG_ValueError,"io_stream object is expected."); return NULL; } @@ -3479,12 +3490,12 @@ SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(se arg1 = &out1; } } - res2 = SWIG_ConvertPtr(swig_obj[1],SWIG_as_voidptrptr(&arg2), 0, 0); + res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0); if (!SWIG_IsOK(res2)) { SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "WriteVTKEncodedCompressed" "', argument " "2"" of type '" "void const *""'"); } { - res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_uint32_t, 0 | 0); + res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_uint32_t, 0 | 0); if (!SWIG_IsOK(res3)) { SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "WriteVTKEncodedCompressed" "', argument " "3"" of type '" "uint32_t""'"); } @@ -3497,10 +3508,10 @@ SWIGINTERN PyObject *_wrap_WriteVTKEncodedCompressed(PyObject *SWIGUNUSEDPARM(se } } { - if ((PyArray_PyIntAsInt(swig_obj[3]) == -1) && PyErr_Occurred()) { + if ((PyArray_PyIntAsInt(obj3) == -1) && PyErr_Occurred()) { SWIG_exception_fail(SWIG_TypeError, "Input must be integer"); }; - arg4 = PyArray_PyIntAsInt(swig_obj[3]); + arg4 = PyArray_PyIntAsInt(obj3); } { try { @@ -3572,8 +3583,8 @@ SWIGINTERN PyObject *_wrap_VTKByteOrder(PyObject *SWIGUNUSEDPARM(self), PyObject static PyMethodDef SwigMethods[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, - { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "CreateVTKElementConnectivity", (PyCFunction)(void(*)(void))_wrap_CreateVTKElementConnectivity, METH_VARARGS|METH_KEYWORDS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", (PyCFunction)(void(*)(void))_wrap_WriteVTKEncodedCompressed, METH_VARARGS|METH_KEYWORDS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, { NULL, NULL, 0, NULL } }; @@ -3581,8 +3592,8 @@ static PyMethodDef SwigMethods[] = { static PyMethodDef SwigMethods_proxydocs[] = { { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL}, { "SWIG_PyStaticMethod_New", SWIG_PyStaticMethod_New, METH_O, NULL}, - { "CreateVTKElementConnectivity", _wrap_CreateVTKElementConnectivity, METH_VARARGS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, - { "WriteVTKEncodedCompressed", _wrap_WriteVTKEncodedCompressed, METH_VARARGS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, + { "CreateVTKElementConnectivity", (PyCFunction)(void(*)(void))_wrap_CreateVTKElementConnectivity, METH_VARARGS|METH_KEYWORDS, "CreateVTKElementConnectivity(intArray con, mfem::Geometry::Type geom, int ref)"}, + { "WriteVTKEncodedCompressed", (PyCFunction)(void(*)(void))_wrap_WriteVTKEncodedCompressed, METH_VARARGS|METH_KEYWORDS, "WriteVTKEncodedCompressed(std::ostream & out, void const * bytes, uint32_t nbytes, int compression_level)"}, { "VTKByteOrder", _wrap_VTKByteOrder, METH_NOARGS, "VTKByteOrder() -> char const *"}, { NULL, NULL, 0, NULL } }; From 2e4101c862f86967377c1eb3080d685e6882c165 Mon Sep 17 00:00:00 2001 From: Syun'ichi Shiraiwa Date: Tue, 14 Apr 2020 13:40:05 -0400 Subject: [PATCH 8/9] added warn/inv_trans keywords to FindPoints --- README | 4 ++-- mfem/_par/mesh.i | 6 +++--- mfem/_par/mesh.py | 6 +++--- mfem/_ser/mesh.i | 6 +++--- mfem/_ser/mesh.py | 6 +++--- 5 files changed, 14 insertions(+), 14 deletions(-) diff --git a/README b/README index 273d6c7a..b0cbcab4 100644 --- a/README +++ b/README @@ -197,8 +197,8 @@ to find more detail of the MFEM libirary. FindPoints receive only one argument (points to look for) and returns count, element_id, integration_points. Note points are row order. For example, - >>> count, elem_ids, int_pts = mesh.FindPoint([1,2,3], [3,4,5], [4,5,6], [7,8,9]]) - + >>> count, elem_ids, int_pts = mesh.FindPoint([1,2,3], [3,4,5], [4,5,6], [7,8,9]], + warn=True, int_trans=None) will look for 4 points. diff --git a/mfem/_par/mesh.i b/mfem/_par/mesh.i index bf70e966..5a2a5b5d 100644 --- a/mfem/_par/mesh.i +++ b/mfem/_par/mesh.i @@ -269,8 +269,8 @@ def GetEdgeTransformation(self, i): return Tr %} %feature("shadow") mfem::Mesh::FindPoints %{ -def FindPoints(self, pp): - r"""count, element_id, integration_points = FindPoints(points)""" +def FindPoints(self, pp, warn=True, inv_trans=None): + r"""count, element_id, integration_points = FindPoints(points, warn=True, int_trans=None)""" import numpy as np import mfem.par as mfem @@ -279,7 +279,7 @@ def FindPoints(self, pp): M.Assign(pp) elem_ids = mfem.intArray() int_points = mfem.IntegrationPointArray() - count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points, warn, inv_trans) elem_ids = elem_ids.ToList() return count, elem_ids, int_points %} diff --git a/mfem/_par/mesh.py b/mfem/_par/mesh.py index 8b9be363..7eeedc5c 100644 --- a/mfem/_par/mesh.py +++ b/mfem/_par/mesh.py @@ -977,8 +977,8 @@ def PrintCharacteristics(self, *args, **kwargs): return _mesh.Mesh_PrintCharacteristics(self, *args, **kwargs) PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) - def FindPoints(self, pp): - r"""count, element_id, integration_points = FindPoints(points)""" + def FindPoints(self, pp, warn=True, inv_trans=None): + r"""count, element_id, integration_points = FindPoints(points, warn=True, int_trans=None)""" import numpy as np import mfem.par as mfem @@ -987,7 +987,7 @@ def FindPoints(self, pp): M.Assign(pp) elem_ids = mfem.intArray() int_points = mfem.IntegrationPointArray() - count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points, warn, inv_trans) elem_ids = elem_ids.ToList() return count, elem_ids, int_points diff --git a/mfem/_ser/mesh.i b/mfem/_ser/mesh.i index 2c77c1be..b7d2d35b 100644 --- a/mfem/_ser/mesh.i +++ b/mfem/_ser/mesh.i @@ -276,8 +276,8 @@ def GetEdgeTransformation(self, i): return Tr %} %feature("shadow") mfem::Mesh::FindPoints %{ -def FindPoints(self, pp): - r"""count, element_id, integration_points = FindPoints(points)""" +def FindPoints(self, pp, warn=True, inv_trans=None): + r"""count, element_id, integration_points = FindPoints(points, warn=True, inv_trans=None)""" import numpy as np import mfem.ser as mfem @@ -286,7 +286,7 @@ def FindPoints(self, pp): M.Assign(pp) elem_ids = mfem.intArray() int_points = mfem.IntegrationPointArray() - count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points, warn, inv_trans) elem_ids = elem_ids.ToList() return count, elem_ids, int_points %} diff --git a/mfem/_ser/mesh.py b/mfem/_ser/mesh.py index d132d739..1a354436 100644 --- a/mfem/_ser/mesh.py +++ b/mfem/_ser/mesh.py @@ -1040,8 +1040,8 @@ def PrintCharacteristics(self, *args, **kwargs): return _mesh.Mesh_PrintCharacteristics(self, *args, **kwargs) PrintCharacteristics = _swig_new_instance_method(_mesh.Mesh_PrintCharacteristics) - def FindPoints(self, pp): - r"""count, element_id, integration_points = FindPoints(points)""" + def FindPoints(self, pp, warn=True, inv_trans=None): + r"""count, element_id, integration_points = FindPoints(points, warn=True, inv_trans=None)""" import numpy as np import mfem.ser as mfem @@ -1050,7 +1050,7 @@ def FindPoints(self, pp): M.Assign(pp) elem_ids = mfem.intArray() int_points = mfem.IntegrationPointArray() - count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points) + count = _mesh.Mesh_FindPoints(self, M, elem_ids, int_points, warn, inv_trans) elem_ids = elem_ids.ToList() return count, elem_ids, int_points From a913a1a4e3995f2dfa1b8714a1ca3b7e32e504a4 Mon Sep 17 00:00:00 2001 From: Morteza HS Date: Fri, 15 May 2020 00:49:07 -0400 Subject: [PATCH 9/9] Adds a new constructor to ParMesh This constructor takes an apf::Mesh2 (PUMI mesh) as an input. This helps create a ParMesh object properly. --- mfem/_par/pmesh.i | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/mfem/_par/pmesh.i b/mfem/_par/pmesh.i index 196aff01..7243312a 100644 --- a/mfem/_par/pmesh.i +++ b/mfem/_par/pmesh.i @@ -13,6 +13,7 @@ #include "io_stream.hpp" #include "config/config.hpp" #include "mesh/pmesh.hpp" +#include "mesh/pumi.hpp" #include "fem/linearform.hpp" #include "general/communication.hpp" #include "numpy/arrayobject.h" @@ -87,6 +88,17 @@ ParMesh(MPI_Comm comm, const char *mesh_file){ mesh = new mfem::ParMesh(comm, imesh); return mesh; } +ParMesh(MPI_Comm comm, apf::Mesh2* pumi_mesh){ + mfem::ParMesh *mesh; + if (!pumi_mesh) + { + std::cerr << "\nPointer to pumi_mesh is not set\n" << std::endl; + return NULL; + } + mesh = new mfem::ParPumiMesh(comm, pumi_mesh); + return mesh; + } + void ParPrintToFile(const char *mesh_file, const int precision) const { std::ofstream mesh_ofs(mesh_file);